Migrate to Expronicon.jl, add Const(::Any)

Project.toml

@@ -13,9 +13,11 @@ ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9"
 DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
 DocStringExtensions = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
 DynamicPolynomials = "7c1d4256-1411-5781-91ec-d7bc3513ac07"
+Expronicon = "6b7a57c9-7cc1-4fdf-b7f5-e857abae3636"
 IfElse = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173"
 LabelledArrays = "2ee39098-c373-598a-b85f-a56591580800"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+MLStyle = "d8e11817-5142-5d16-987a-aa16d5891078"
 MultivariatePolynomials = "102ac46a-7ee4-5c85-9060-abc95bfdeaa3"
 NaNMath = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"
 Setfield = "efcf1570-3423-57d1-acb7-fd33fddbac46"
@@ -25,7 +27,6 @@ StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 SymbolicIndexingInterface = "2efcf032-c050-4f8e-a9bb-153293bab1f5"
 TermInterface = "8ea1fca8-c5ef-4a55-8b96-4e9afe9c9a3c"
 TimerOutputs = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f"
-Unityper = "a7c27f48-0311-42f6-a7f8-2c11e75eb415"
 
 [weakdeps]
 LabelledArrays = "2ee39098-c373-598a-b85f-a56591580800"
@@ -45,8 +46,10 @@ ConstructionBase = "1.5.7"
 DataStructures = "0.18"
 DocStringExtensions = "0.8, 0.9"
 DynamicPolynomials = "0.5, 0.6"
+Expronicon = "~0.8"
 IfElse = "0.1"
 LabelledArrays = "1.5"
+MLStyle = "0.4"
 MultivariatePolynomials = "0.5"
 NaNMath = "0.3, 1"
 ReverseDiff = "1"
@@ -56,7 +59,6 @@ StaticArrays = "0.12, 1.0"
 SymbolicIndexingInterface = "0.3"
 TermInterface = "2.0"
 TimerOutputs = "0.5"
-Unityper = "0.1.2"
 julia = "1.3"
 
 [extras]

docs/src/manual/rewrite.md

@@ -71,7 +71,7 @@ If you want to match a variable number of subexpressions at once, you will need
 @rule(+(~~xs) => ~~xs)(x + y + z)
 
 # output
-3-element view(::Vector{Any}, 1:3) with eltype Any:
+3-element view(::Vector{SymbolicUtils.BasicSymbolic}, 1:3) with eltype SymbolicUtils.BasicSymbolic:
  z
  y
  x

src/SymbolicUtils.jl

@@ -7,7 +7,6 @@ using DocStringExtensions
 
 export @syms, term, showraw, hasmetadata, getmetadata, setmetadata
 
-using Unityper
 using TermInterface
 using DataStructures
 using Setfield
@@ -23,6 +22,10 @@ import ArrayInterface
 
 Base.@deprecate istree iscall
 export istree, operation, arguments, sorted_arguments, similarterm, iscall
+
+using Base: RefValue
+using Expronicon.ADT: @adt
+using MLStyle: @match
 # Sym, Term,
 # Add, Mul and Pow
 include("types.jl")

src/code.jl

@@ -8,8 +8,8 @@ export toexpr, Assignment, (←), Let, Func, DestructuredArgs, LiteralExpr,
 
 import ..SymbolicUtils
 import ..SymbolicUtils.Rewriters
-import SymbolicUtils: @matchable, BasicSymbolic, Sym, Term, iscall, operation, arguments, issym,
-                      symtype, sorted_arguments, metadata, isterm, term, maketerm
+import SymbolicUtils: @matchable, BasicSymbolic, _Sym, Term, iscall, operation, arguments, issym,
+                      isconst, symtype, sorted_arguments, metadata, isterm, term, maketerm, get_val
 import SymbolicIndexingInterface: symbolic_type, NotSymbolic
 
 ##== state management ==##
@@ -182,6 +182,8 @@ function toexpr(O, st)
     if issym(O)
         O = substitute_name(O, st)
         return issym(O) ? nameof(O) : toexpr(O, st)
+    elseif isconst(O)
+        return toexpr(get_val(O), st)
     end
     O = substitute_name(O, st)
 
@@ -681,7 +683,7 @@ end
 
 ### Common subexprssion evaluation
 
-@inline newsym(::Type{T}) where T = Sym{T}(gensym("cse"))
+@inline newsym(::Type{T}) where T = _Sym(T, gensym("cse"))
 
 function _cse!(mem, expr)
     iscall(expr) || return expr
@@ -745,7 +747,7 @@ function cse_block!(assignments, counter, names, name, state, x)
         if haskey(names, x)
             return names[x]
         else
-            sym = Sym{symtype(x)}(Symbol(name, counter[]))
+            sym = _Sym(symtype(x), Symbol(name, counter[]))
             names[x] = sym
             push!(assignments, sym ← x)
             counter[] += 1

src/inspect.jl

@@ -6,22 +6,23 @@ function AbstractTrees.nodevalue(x::Symbolic)
 end
 
 function AbstractTrees.nodevalue(x::BasicSymbolic)
-    str = if !iscall(x)
+    str = if issym(x)
         string(exprtype(x), "(", x, ")")
+    elseif isconst(x)
+        string(get_val(x))
     elseif isadd(x)
-        string(exprtype(x), 
-            (scalar=x.coeff, coeffs=Tuple(k=>v for (k,v) in x.dict)))
+        string(exprtype(x),
+            (scalar = get_coeff(x), coeffs = Tuple(k => v for (k, v) in get_dict(x))))
     elseif ismul(x)
         string(exprtype(x),
-            (scalar=x.coeff, powers=Tuple(k=>v for (k,v) in x.dict)))
+            (scalar = get_coeff(x), powers = Tuple(k => v for (k, v) in get_dict(x))))
     elseif isdiv(x) || ispow(x)
         string(exprtype(x))
     else
-        string(exprtype(x),"{", operation(x), "}")
+        string(exprtype(x), "{", operation(x), "}")
     end
-
     if inspect_metadata[] && !isnothing(metadata(x))
-        str *= string(" metadata=", Tuple(k=>v for (k, v) in metadata(x)))
+        str *= string(" metadata=", Tuple(k => v for (k, v) in metadata(x)))
     end
     Text(str)
 end

src/matchers.jl

@@ -6,9 +6,23 @@
 # 3. Callback: takes arguments Dictionary × Number of elements matched
 #
 function matcher(val::Any)
-    iscall(val) && return term_matcher(val)
+    if isconst(val)
+        slot = get_val(val)
+        return matcher(slot)
+    elseif iscall(val)
+        return term_matcher(val)
+    end
     function literal_matcher(next, data, bindings)
-        islist(data) && isequal(car(data), val) ? next(bindings, 1) : nothing
+        if islist(data)
+            cd = car(data)
+            if isconst(cd)
+                cd = get_val(cd)
+            end
+            if isequal(cd, val)
+                return next(bindings, 1)
+            end
+        end
+        nothing
     end
 end
 

src/methods.jl

@@ -179,24 +179,30 @@ for (f, Domain) in [(==) => Number, (!=) => Number,
                     xor => Bool]
     @eval begin
         promote_symtype(::$(typeof(f)), ::Type{<:$Domain}, ::Type{<:$Domain}) = Bool
-        (::$(typeof(f)))(a::Symbolic{<:$Domain}, b::$Domain) = term($f, a, b, type=Bool)
-        (::$(typeof(f)))(a::Symbolic{<:$Domain}, b::Symbolic{<:$Domain}) = term($f, a, b, type=Bool)
-        (::$(typeof(f)))(a::$Domain, b::Symbolic{<:$Domain}) = term($f, a, b, type=Bool)
+        (::$(typeof(f)))(a::Symbolic{<:$Domain}, b::$Domain) = term($f, a, b; type = Bool)
+        (::$(typeof(f)))(a::Symbolic{<:$Domain}, b::Symbolic{<:$Domain}) = term($f, a, b; type = Bool)
+        (::$(typeof(f)))(a::$Domain, b::Symbolic{<:$Domain}) = term($f, a, b; type = Bool)
     end
 end
 
 for f in [!, ~]
     @eval begin
         promote_symtype(::$(typeof(f)), ::Type{<:Bool}) = Bool
-        (::$(typeof(f)))(s::Symbolic{Bool}) = Term{Bool}(!, [s])
+        function (::$(typeof(f)))(s::Symbolic{Bool})
+            if isconst(s)
+                s = get_val(s)
+                return !s
+            end
+            _Term(Bool, !, [s])
+        end
     end
 end
 
 
 # An ifelse node, ifelse is a built-in unfortunately
 # So this uses IfElse.jl's ifelse that we imported
 function ifelse(_if::Symbolic{Bool}, _then, _else)
-    Term{Union{symtype(_then), symtype(_else)}}(ifelse, Any[_if, _then, _else])
+    _Term(Union{symtype(_then), symtype(_else)}, ifelse, Any[_if, _then, _else])
 end
 promote_symtype(::typeof(ifelse), _, ::Type{T}, ::Type{S}) where {T,S} = Union{T, 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
+        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
@@ -79,12 +79,23 @@ function <ₑ(a::Tuple, b::Tuple)
 end
 
 function <ₑ(a::BasicSymbolic, b::BasicSymbolic)
+    aisconst = isconst(a)
+    if aisconst
+        a = get_val(a)
+    end
+    bisconst = isconst(b)
+    if bisconst
+        b = get_val(b)
+    end
+    if aisconst || bisconst
+        return a <ₑ b
+    end
     da, db = get_degrees(a), get_degrees(b)
     fw = monomial_lt(da, db)
     bw = monomial_lt(db, da)
     if fw === bw && !isequal(a, b)
         if _arglen(a) == _arglen(b)
-            return (operation(a), arguments(a)...,) <ₑ (operation(b), arguments(b)...,)
+            return (operation(a), arguments(a)...) <ₑ (operation(b), arguments(b)...)
         else
             return _arglen(a) < _arglen(b)
         end