Adjust interface, add sorted_* functions for arguments & children

Author: bowenszhu

src/code.jl

@@ -124,7 +124,7 @@ end
 function function_to_expr(op::Union{typeof(*),typeof(+)}, O, st)
     out = get(st.rewrites, O, nothing)
     out === nothing || return out
-    args = map(Base.Fix2(toexpr, st), arguments(O; sort = true))
+    args = map(Base.Fix2(toexpr, st), sorted_arguments(O))
     if length(args) >= 3 && symtype(O) <: Number
         x, xs = Iterators.peel(args)
         foldl(xs, init=x) do a, b

src/inspect.jl

@@ -35,7 +35,7 @@ the expression.
 This function is used internally for printing via AbstractTrees.
 """
 function AbstractTrees.children(x::Symbolic)
-    iscall(x) ? arguments(x; sort = true) : isexpr(x) ? children(x; sort = true) : ()
+    iscall(x) ? sorted_arguments(x) : isexpr(x) ? sorted_children(x) : ()
 end
 
 """

src/ordering.jl

@@ -26,7 +26,7 @@ function get_degrees(expr)
         ((Symbol(expr),) => 1,)
     elseif iscall(expr)
         op = operation(expr)
-        args = arguments(expr; sort = true)
+        args = sorted_arguments(expr)
         if op == (^) && args[2] isa Number
             return map(get_degrees(args[1])) do (base, pow)
                 (base => pow * args[2])

src/polyform.jl

@@ -187,7 +187,7 @@ end
 head(::PolyForm) = PolyForm
 operation(x::PolyForm) = MP.nterms(x.p) == 1 ? (*) : (+)
 
-function arguments(x::PolyForm{T}; kwargs...) where {T}
+function arguments(x::PolyForm{T}) where {T}
 
     function is_var(v)
         MP.nterms(v) == 1 &&
@@ -231,6 +231,9 @@ function arguments(x::PolyForm{T}; kwargs...) where {T}
                  PolyForm{T}(t, x.pvar2sym, x.sym2term, nothing)) for t in ts]
     end
 end
+
+sorted_arguments(x::PolyForm) = arguments(x)
+
 children(x::PolyForm) = [operation(x); arguments(x)]
 
 Base.show(io::IO, x::PolyForm) = show_term(io, x)

src/types.jl

@@ -116,11 +116,8 @@ end
 
 @inline head(x::BasicSymbolic) = operation(x)
 
-function arguments(x::BasicSymbolic; sort::Bool = false)
-    args = unsorted_arguments(x)
-    if !sort
-        return args
-    end
+function sorted_arguments(x::BasicSymbolic)
+    args = arguments(x)
     @compactified x::BasicSymbolic begin
         Add => @goto ADD
         Mul => @goto MUL
@@ -141,9 +138,11 @@ function arguments(x::BasicSymbolic; sort::Bool = false)
     return args
 end
 
-unsorted_arguments(x) = arguments(x)
-children(x::BasicSymbolic; kwargs...) = arguments(x; kwargs...)
-function unsorted_arguments(x::BasicSymbolic)
+children(x::BasicSymbolic) = arguments(x)
+
+sorted_children(x::BasicSymbolic) = sorted_arguments(x)
+
+function arguments(x::BasicSymbolic)
     @compactified x::BasicSymbolic begin
         Term => return x.arguments
         Add  => @goto ADDMUL
@@ -812,7 +811,7 @@ function show_term(io::IO, t)
     end
 
     f = operation(t)
-    args = arguments(t; sort = true)
+    args = sorted_arguments(t)
     if symtype(t) <: LiteralReal
         show_call(io, f, args)
     elseif f === (+)