Define get_val

Author: bowenszhu

src/code.jl

@@ -9,7 +9,7 @@ export toexpr, Assignment, (←), Let, Func, DestructuredArgs, LiteralExpr,
 import ..SymbolicUtils
 import ..SymbolicUtils.Rewriters
 import SymbolicUtils: @matchable, BasicSymbolic, _Sym, Term, iscall, operation, arguments, issym,
-                      isconst, symtype, sorted_arguments, metadata, isterm, term, maketerm
+                      isconst, symtype, sorted_arguments, metadata, isterm, term, maketerm, get_val
 import SymbolicIndexingInterface: symbolic_type, NotSymbolic
 
 ##== state management ==##
@@ -183,7 +183,7 @@ function toexpr(O, st)
         O = substitute_name(O, st)
         return issym(O) ? nameof(O) : toexpr(O, st)
     elseif isconst(O)
-        return toexpr(O.impl.val, st)
+        return toexpr(get_val(O), st)
     end
     O = substitute_name(O, st)
 

src/inspect.jl

@@ -9,7 +9,7 @@ function AbstractTrees.nodevalue(x::BasicSymbolic)
     str = if issym(x)
         string(exprtype(x), "(", x, ")")
     elseif isconst(x)
-        string(x.impl.val)
+        string(get_val(x))
     elseif isadd(x)
         string(exprtype(x),
             (scalar = get_coeff(x), coeffs = Tuple(k => v for (k, v) in get_dict(x))))

src/matchers.jl

@@ -7,7 +7,7 @@
 #
 function matcher(val::Any)
     if isconst(val)
-        slot = val.impl.val
+        slot = get_val(val)
         return matcher(slot)
     elseif iscall(val)
         return term_matcher(val)
@@ -16,7 +16,7 @@ function matcher(val::Any)
         if islist(data)
             cd = car(data)
             if isconst(cd)
-                cd = cd.impl.val
+                cd = get_val(cd)
             end
             if isequal(cd, val)
                 return next(bindings, 1)

src/methods.jl

@@ -190,7 +190,7 @@ for f in [!, ~]
         promote_symtype(::$(typeof(f)), ::Type{<:Bool}) = Bool
         function (::$(typeof(f)))(s::Symbolic{Bool})
             if isconst(s)
-                s = s.impl.val
+                s = get_val(s)
                 return !s
             end
             _Term(Bool, !, [s])

src/ordering.jl

@@ -27,7 +27,7 @@ function get_degrees(expr)
     elseif iscall(expr)
         op = operation(expr)
         args = sorted_arguments(expr)
-        if op == (^) && (args[2] isa Number || (isconst(args[2]) && args[2].impl.val isa Number))
+        if op == (^) && (args[2] isa Number || (isconst(args[2]) && get_val(args[2]) isa Number))
             return map(get_degrees(args[1])) do (base, pow)
                 (base => pow * args[2])
             end
@@ -81,11 +81,11 @@ end
 function <ₑ(a::BasicSymbolic, b::BasicSymbolic)
     aisconst = isconst(a)
     if aisconst
-        a = a.impl.val
+        a = get_val(a)
     end
     bisconst = isconst(b)
     if bisconst
-        b = b.impl.val
+        b = get_val(b)
     end
     if aisconst || bisconst
         return a <ₑ b

src/polyform.jl

@@ -96,7 +96,7 @@ _isone(p::PolyForm) = isone(p.p)
 
 function polyize(x, pvar2sym, sym2term, vtype, pow, Fs, recurse)
     if isconst(x)
-        x = x.impl.val
+        x = get_val(x)
     end
     if x isa Number
         return x

src/substitute.jl

@@ -23,7 +23,7 @@ function substitute(expr, dict; fold=true)
             args = map(arguments(expr)) do x
                 x′ = substitute(x, dict; fold=fold)
                 if isconst(x)
-                    x′ = x′.impl.val
+                    x′ = get_val(x′)
                 end
                 canfold = canfold && !(x′ isa Symbolic)
                 x′
@@ -58,7 +58,7 @@ function _occursin(needle, haystack)
         args = arguments(haystack)
         for arg in args
             if isconst(arg)
-                arg = arg.impl.val
+                arg = get_val(arg)
             end
             if needle isa Integer || needle isa AbstractFloat
                 isequal(needle, arg) && return true

src/types.jl

@@ -92,6 +92,10 @@ function get_exp(x::BasicSymbolic)
     x.impl.exp
 end
 
+function get_val(x::BasicSymbolic)
+    x.impl.val
+end
+
 # Same but different error messages
 @noinline error_on_type() = error("Internal error: unreachable reached!")
 @noinline error_sym() = error("Sym doesn't have a operation or arguments!")
@@ -327,7 +331,7 @@ function _isequal(a, b, E)
         a2 = arguments(b)
         isequal(operation(a), operation(b)) && _allarequal(a1, a2)
     elseif E === CONST
-        isequal(a.impl.val, b.impl.val)
+        isequal(get_val(a), get_val(b))
     else
         error_on_type()
     end
@@ -378,7 +382,7 @@ function Base.hash(s::BasicSymbolic, salt::UInt)::UInt
         s.hash[] = h′
         return h′
     elseif E === CONST
-        return hash(s.impl.val, salt ⊻ COS_SALT)
+        return hash(get_val(s), salt ⊻ COS_SALT)
     else
         error_on_type()
     end
@@ -452,14 +456,14 @@ end
 
 function _iszero(x::BasicSymbolic)
     @match x.impl begin
-        Const(_...) => iszero(x.impl.val)
+        Const(_...) => iszero(get_val(x))
         _ => false
     end
 end
 
 function _isone(x::BasicSymbolic)
     @match x.impl begin
-        Const(_...) => isone(x.impl.val)
+        Const(_...) => isone(get_val(x))
         _ => false
     end
 end
@@ -833,7 +837,7 @@ const show_simplified = Ref(false)
 isnegative(t::Real) = t < 0
 function isnegative(t)
     if isconst(t)
-        val = t.impl.val
+        val = get_val(t)
         return isnegative(val)
     end
     if iscall(t) && operation(t) === (*)
@@ -872,7 +876,7 @@ function remove_minus(t)
     args = arguments(t)
     arg1 = args[1]
     if isconst(arg1)
-        arg1 = arg1.impl.val
+        arg1 = get_val(arg1)
     end
     @assert arg1 < 0
     Any[-arg1, args[2:end]...]
@@ -911,14 +915,14 @@ end
 
 function show_mul(io, args)
     if isconst(args)
-        print(io, args.impl.val)
+        print(io, get_val(args))
         return
     end
     length(args) == 1 && return print_arg(io, *, args[1])
 
     arg1 = args[1]
     if isconst(arg1)
-        arg1 = arg1.impl.val
+        arg1 = get_val(arg1)
     end
 
     minus = arg1 isa Number && arg1 == -1
@@ -930,7 +934,7 @@ function show_mul(io, args)
 
     nostar = minus || unit ||
              (!paren_scalar && arg1 isa Number &&
-              !(isconst(args[2]) && args[2].impl.val isa Number))
+              !(isconst(args[2]) && get_val(args[2]) isa Number))
 
     for (i, t) in enumerate(args)
         if i != 1
@@ -1021,7 +1025,7 @@ showraw(t) = showraw(stdout, t)
 function Base.show(io::IO, v::BasicSymbolic)
     @match v.impl begin
         Sym(_...) => Base.show_unquoted(io, get_name(v))
-        Const(_...) => print(io, v.impl.val)
+        Const(_...) => print(io, get_val(v))
         _ => show_term(io, v)
     end
 end
@@ -1235,10 +1239,10 @@ sub_t(a) = promote_symtype(-, symtype(a))
 import Base: (+), (-), (*), (//), (/), (\), (^)
 function +(a::SN, b::SN)
     if isconst(a)
-        return a.impl.val + b
+        return get_val(a) + b
     end
     if isconst(b)
-        return b.impl.val + a
+        return get_val(b) + a
     end
     !issafecanon(+, a, b) && return term(+, a, b) # Don't flatten if args have metadata
     if isadd(a) && isadd(b)
@@ -1255,7 +1259,7 @@ function +(a::SN, b::SN)
 end
 function +(a::Number, b::SN)
     if isconst(b)
-        return a + b.impl.val
+        return a + get_val(b)
     end
     !issafecanon(+, b) && return term(+, a, b) # Don't flatten if args have metadata
     iszero(a) && return b
@@ -1270,7 +1274,7 @@ end
 
 function -(a::SN)
     if isconst(a)
-        v = a.impl.val
+        v = get_val(a)
         mv = -v
         return _Const(mv)
     end
@@ -1299,10 +1303,10 @@ mul_t(a) = promote_symtype(*, symtype(a))
 
 function *(a::SN, b::SN)
     if isconst(a)
-        return a.impl.val * b
+        return get_val(a) * b
     end
     if isconst(b)
-        return b.impl.val * a
+        return get_val(b) * a
     end
     # Always make sure Div wraps Mul
     !issafecanon(*, a, b) && return term(*, a, b)
@@ -1333,7 +1337,7 @@ function *(a::SN, b::SN)
 end
 function *(a::Number, b::SN)
     if isconst(b)
-        return a * b.impl.val
+        return a * get_val(b)
     end
     !issafecanon(*, b) && return term(*, a, b)
     if iszero(a)

src/utils.jl

@@ -66,7 +66,7 @@ sym_isa(::Type{T}) where {T} = @nospecialize(x) -> x isa T || symtype(x) <: T
 
 function is_literal_number(x)
     if isconst(x)
-        x = x.impl.val
+        x = get_val(x)
     end
     x isa Number
 end

test/types.jl

@@ -1,4 +1,4 @@
-using SymbolicUtils: Symbolic, BasicSymbolic, _Sym, _Term, _Const, _Add, get_name
+using SymbolicUtils: Symbolic, BasicSymbolic, _Sym, _Term, _Const, _Add, get_name, get_val
 
 @testset "Expronicon generated constructors" begin
     s1 = Sym(:abc)
@@ -133,17 +133,17 @@ end
         @test typeof(c1) == BasicSymbolic{Float64}
         @test c1.metadata == SymbolicUtils.NO_METADATA
         @test c1.hash[] == SymbolicUtils.EMPTY_HASH
-        @test c1.impl.val == 1.0
+        @test get_val(c1) == 1.0
         c2 = _Const(big"123456789012345678901234567890")
         @test typeof(c2) == BasicSymbolic{BigInt}
         @test c2.metadata == SymbolicUtils.NO_METADATA
         @test c2.hash[] == SymbolicUtils.EMPTY_HASH
-        @test c2.impl.val == big"123456789012345678901234567890"
+        @test get_val(c2) == big"123456789012345678901234567890"
         c3 = _Const(big"1.23456789012345678901")
         @test typeof(c3) == BasicSymbolic{BigFloat}
         @test c3.metadata == SymbolicUtils.NO_METADATA
         @test c3.hash[] == SymbolicUtils.EMPTY_HASH
-        @test c3.impl.val == big"1.23456789012345678901"
+        @test get_val(c3) == big"1.23456789012345678901"
     end
 end