feat: use Moshi.jl instead of Unityper.jl

Author: AayushSabharwal

Project.toml

@@ -13,11 +13,15 @@ ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9"
 DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
 DocStringExtensions = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
 DynamicPolynomials = "7c1d4256-1411-5781-91ec-d7bc3513ac07"
+EnumX = "4e289a0a-7415-4d19-859d-a7e5c4648b56"
 ExproniconLite = "55351af7-c7e9-48d6-89ff-24e801d99491"
 LabelledArrays = "2ee39098-c373-598a-b85f-a56591580800"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+Moshi = "2e0e35c7-a2e4-4343-998d-7ef72827ed2d"
 MultivariatePolynomials = "102ac46a-7ee4-5c85-9060-abc95bfdeaa3"
 NaNMath = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"
+ReadOnlyArrays = "988b38a3-91fc-5605-94a2-ee2116b3bd83"
+ReadOnlyDicts = "795d4caa-f5a7-4580-b5d8-c01d53451803"
 Setfield = "efcf1570-3423-57d1-acb7-fd33fddbac46"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"
@@ -26,7 +30,6 @@ SymbolicIndexingInterface = "2efcf032-c050-4f8e-a9bb-153293bab1f5"
 TaskLocalValues = "ed4db957-447d-4319-bfb6-7fa9ae7ecf34"
 TermInterface = "8ea1fca8-c5ef-4a55-8b96-4e9afe9c9a3c"
 TimerOutputs = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f"
-Unityper = "a7c27f48-0311-42f6-a7f8-2c11e75eb415"
 WeakValueDicts = "897b6980-f191-5a31-bcb0-bf3c4585e0c1"
 
 [weakdeps]
@@ -47,11 +50,15 @@ ConstructionBase = "1.5.7"
 DataStructures = "0.18"
 DocStringExtensions = "0.8, 0.9"
 DynamicPolynomials = "0.5, 0.6"
+EnumX = "1.0.5"
 ExproniconLite = "0.10.14"
 LabelledArrays = "1.5"
+Moshi = "0.3.6"
 MultivariatePolynomials = "0.5"
 NaNMath = "0.3, 1.1.2"
 OhMyThreads = "0.7"
+ReadOnlyArrays = "0.2.0"
+ReadOnlyDicts = "1.0.0"
 ReverseDiff = "1"
 RuntimeGeneratedFunctions = "0.5.13"
 Setfield = "0.7, 0.8, 1"
@@ -61,7 +68,6 @@ SymbolicIndexingInterface = "0.3"
 TaskLocalValues = "0.1.2"
 TermInterface = "2.0"
 TimerOutputs = "0.5"
-Unityper = "0.1.2"
 WeakValueDicts = "0.1.0"
 julia = "1.10"
 

src/SymbolicUtils.jl

@@ -7,7 +7,12 @@ using DocStringExtensions
 
 export @syms, term, showraw, hasmetadata, getmetadata, setmetadata
 
-using Unityper
+using Moshi.Data: @data
+import Moshi.Data as MData
+using Moshi.Match: @match
+using ReadOnlyArrays
+using ReadOnlyDicts
+using EnumX: @enumx
 using TermInterface
 using DataStructures
 using Setfield
@@ -23,6 +28,7 @@ import ArrayInterface
 import ExproniconLite as EL
 import TaskLocalValues: TaskLocalValue
 using WeakValueDicts: WeakValueDict
+using Base: RefValue
 
 # include("WeakCacheSets.jl")
 

src/inspect.jl

@@ -5,19 +5,21 @@ function AbstractTrees.nodevalue(x::Symbolic)
     iscall(x) ? operation(x) : isexpr(x) ? head(x) : x
 end
 
-function AbstractTrees.nodevalue(x::BasicSymbolic)
+AbstractTrees.nodevalue(x::BasicSymbolic) = AbstractTrees.nodevalue(_unwrap_internal(x))
+function AbstractTrees.nodevalue(x::BSImpl.Type)
+    T = nameof(MData.variant_type(x))
     str = if !iscall(x)
-        string(exprtype(x), "(", x, ")")
+        string(T, "(", x, ")")
     elseif isadd(x)
-        string(exprtype(x), 
-            (scalar=x.coeff, coeffs=Tuple(k=>v for (k,v) in x.dict)))
+        string(T, 
+            (variant=string(x.variant), scalar=x.coeff, coeffs=Tuple(k=>v for (k,v) in x.dict)))
     elseif ismul(x)
-        string(exprtype(x),
-            (scalar=x.coeff, powers=Tuple(k=>v for (k,v) in x.dict)))
+        string(T,
+            (variant=string(x.variant), scalar=x.coeff, powers=Tuple(k=>v for (k,v) in x.dict)))
     elseif isdiv(x) || ispow(x)
-        string(exprtype(x))
+        string(T)
     else
-        string(exprtype(x),"{", operation(x), "}")
+        string(T,"{", operation(x), "}")
     end
 
     if inspect_metadata[] && !isnothing(metadata(x))

src/methods.jl

@@ -29,11 +29,19 @@ const basic_diadic = [+, -, *, /, //, \, ^]
 export SafeReal, LiteralReal
 
 # ideally the relationship should be the other way around
-abstract type SafeReal <: Real end
+abstract type SafeRealImpl <: Number end
+const SafeReal = Union{SafeRealImpl, Real}
+Base.one(::Type{SafeReal}) = true
+Base.zero(::Type{SafeReal}) = false
+Base.convert(::Type{<:SafeRealImpl}, x::Number) = convert(Real, x)
 
 ################### LiteralReal #######################
 
-abstract type LiteralReal <: Real end
+abstract type LiteralRealImpl <: Number end
+const LiteralReal = Union{LiteralRealImpl, Real}
+Base.one(::Type{LiteralReal}) = true
+Base.zero(::Type{LiteralReal}) = false
+Base.convert(::Type{<:LiteralRealImpl}, x::Number) = convert(Real, x)
 
 #######################################################
 
@@ -101,13 +109,13 @@ macro number_methods(T, rhs1, rhs2, options=nothing)
 end
 
 @number_methods(BasicSymbolic{<:Number}, term(f, a), term(f, a, b), skipbasics)
-@number_methods(BasicSymbolic{<:LiteralReal}, term(f, a), term(f, a, b), onlybasics)
+@number_methods(BasicSymbolic{LiteralReal}, term(f, a), term(f, a, b), onlybasics)
 
 for f in vcat(diadic, [+, -, *, \, /, ^])
     @eval promote_symtype(::$(typeof(f)),
                    T::Type{<:Number},
                    S::Type{<:Number}) = promote_type(T, S)
-    for R in [SafeReal, LiteralReal]
+    for R in [SafeRealImpl, LiteralRealImpl]
         @eval function promote_symtype(::$(typeof(f)),
                 T::Type{<:$R},
                 S::Type{<:Real})
@@ -153,8 +161,8 @@ end
 promote_symtype(::Any, T) = promote_type(T, Real)
 for f in monadic
     @eval promote_symtype(::$(typeof(f)), T::Type{<:Number}) = promote_type(T, Real)
-    @eval promote_symtype(::$(typeof(f)), T::Type{<:SafeReal}) = SafeReal
-    @eval promote_symtype(::$(typeof(f)), T::Type{<:LiteralReal}) = LiteralReal
+    @eval promote_symtype(::$(typeof(f)), T::Type{<:SafeRealImpl}) = SafeReal
+    @eval promote_symtype(::$(typeof(f)), T::Type{<:LiteralRealImpl}) = LiteralReal
 end
 
 Base.:*(a::AbstractArray, b::Symbolic{<:Number}) = map(x->x*b, a)

src/polyform.jl

@@ -213,10 +213,10 @@ function TermInterface.arguments(x::PolyForm{T}) where {T}
         m = MP.monomial(t)
 
         if !isone(c)
-            [c, (unstable_pow(resolve(v), pow)
+            [c, (^(resolve(v), pow)
                         for (v, pow) in MP.powers(m) if !iszero(pow))...]
         else
-            [unstable_pow(resolve(v), pow)
+            [^(resolve(v), pow)
                     for (v, pow) in MP.powers(m) if !iszero(pow)]
         end
     elseif MP.nterms(x.p) == 0
@@ -283,7 +283,7 @@ function simplify_div(d)
     if all(_isone, ds)
         return isempty(ns) ? 1 : simplify_fractions(_mul(ns))
     else
-        Div(simplify_fractions(_mul(ns)), simplify_fractions(_mul(ds)))
+        Div(simplify_fractions(_mul(ns)), simplify_fractions(_mul(ds)), false)
     end
 end
 
@@ -343,15 +343,20 @@ function simplify_fractions(x; polyform=false)
 end
 
 function add_with_div(x, flatten=true)
-    (!iscall(x) || operation(x) != (+)) && return x
+    (!iscall(x) || operation(x) != (+)) && return nothing
     aa = arguments(x)
-    !any(a->isdiv(a), aa) && return x # no rewrite necessary
+    !any(a->isdiv(a), aa) && return nothing # no rewrite necessary
 
-    divs = filter(a->isdiv(a), aa)
-    nondivs = filter(a->!(isdiv(a)), aa)
-    nds = isempty(nondivs) ? 0 : +(nondivs...)
-    d = reduce(quick_cancel∘add_divs, divs)
-    flatten ? quick_cancel(add_divs(d, nds)) : d + nds
+    nondiv_result = 0
+    div_result = 0
+    for a in aa
+        if isdiv(a)
+            div_result = quick_cancel(add_divs(div_result, a))
+        else
+            nondiv_result += a
+        end
+    end
+    flatten ? quick_cancel(add_divs(div_result, nondiv_result)) : div_result + nondiv_result
 end
 """
     flatten_fractions(x)
@@ -364,7 +369,7 @@ julia> flatten_fractions((1+(1+1/a)/a)/a)
 ```
 """
 function flatten_fractions(x)
-    Fixpoint(Postwalk(add_with_div))(x)
+    Fixpoint(Postwalk(PassThrough(add_with_div)))(x)
 end
 
 function fraction_iszero(x)
@@ -419,7 +424,7 @@ function quick_cancel(d)
         return prod(arguments(d))
     elseif isdiv(d)
         num, den = quick_cancel(d.num, d.den)
-        return Div(num, den)
+        return Div(num, den, false)
     else
         return d
     end
@@ -471,7 +476,7 @@ end
 # ismul(x)
 function quick_mul(x, y)
     if haskey(x.dict, y) && x.dict[y] >= 1
-        d = copy(x.dict)
+        d = copy(parent(x.dict))
         if d[y] > 1
             d[y] -= 1
         elseif d[y] == 1
@@ -490,7 +495,7 @@ end
 function quick_mulpow(x, y)
     y.exp isa Number || return (x, y)
     if haskey(x.dict, y.base)
-        d = copy(x.dict)
+        d = copy(parent(x.dict))
         if x.dict[y.base] > y.exp
             d[y.base] -= y.exp
             den = 1
@@ -514,6 +519,12 @@ function quick_mulmul(x, y)
 end
 
 function _merge_div(ndict, ddict)
+    if ndict isa ReadOnlyDict
+        ndict = parent(ndict)
+    end
+    if ddict isa ReadOnlyDict
+        ddict = parent(ddict)
+    end
     num = copy(ndict)
     den = copy(ddict)
     for (k, v) in den