rename istree to iscall

Author: Shashi Gowda

Project.toml

@@ -22,6 +22,7 @@ SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"
 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"
 

src/SymbolicUtils.jl

@@ -4,21 +4,23 @@ $(DocStringExtensions.README)
 module SymbolicUtils
 
 using DocStringExtensions
+
 export @syms, term, showraw, hasmetadata, getmetadata, setmetadata
 
 using Unityper
-
-# Sym, Term,
-# Add, Mul and Pow
+using TermInterface
 using DataStructures
 using Setfield
 import Setfield: PropertyLens
 using SymbolicIndexingInterface
 import Base: +, -, *, /, //, \, ^, ImmutableDict
 using ConstructionBase
 include("interface.jl")
+
+# Sym, Term,
+# Add, Mul and Pow
 include("types.jl")
-export istree, operation, arguments, similarterm
+export iscall, operation, arguments, similarterm
 
 # Methods on symbolic objects
 using SpecialFunctions, NaNMath

src/code.jl

@@ -8,7 +8,7 @@ export toexpr, Assignment, (←), Let, Func, DestructuredArgs, LiteralExpr,
 
 import ..SymbolicUtils
 import ..SymbolicUtils.Rewriters
-import SymbolicUtils: @matchable, BasicSymbolic, Sym, Term, istree, operation, arguments, issym,
+import SymbolicUtils: @matchable, BasicSymbolic, Sym, Term, iscall, operation, arguments, issym,
                       symtype, similarterm, unsorted_arguments, metadata, isterm, term
 
 ##== state management ==##
@@ -162,7 +162,7 @@ end
 toexpr(O::Expr, st) = O
 
 function substitute_name(O, st)
-    if (issym(O) || istree(O)) && haskey(st.rewrites, O)
+    if (issym(O) || iscall(O)) && haskey(st.rewrites, O)
         st.rewrites[O]
     else
         O
@@ -176,13 +176,13 @@ function toexpr(O, st)
     end
     O = substitute_name(O, st)
 
-    !istree(O) && return O
+    !iscall(O) && return O
     op = operation(O)
     expr′ = function_to_expr(op, O, st)
     if expr′ !== nothing
         return expr′
     else
-        !istree(O) && return O
+        !iscall(O) && return O
         args = arguments(O)
         return Expr(:call, toexpr(op, st), map(x->toexpr(x, st), args)...)
     end
@@ -221,7 +221,7 @@ get_rewrites(args::DestructuredArgs) = ()
 function get_rewrites(args::Union{AbstractArray, Tuple})
     cflatten(map(get_rewrites, args))
 end
-get_rewrites(x) = istree(x) ? (x,) : ()
+get_rewrites(x) = iscall(x) ? (x,) : ()
 cflatten(x) = Iterators.flatten(x) |> collect
 
 # Used in Symbolics
@@ -691,7 +691,7 @@ end
 @inline newsym(::Type{T}) where T = Sym{T}(gensym("cse"))
 
 function _cse!(mem, expr)
-    istree(expr) || return expr
+    iscall(expr) || return expr
     op = _cse!(mem, operation(expr))
     args = map(Base.Fix1(_cse!, mem), arguments(expr))
     t = similarterm(expr, op, args)
@@ -742,7 +742,7 @@ end
 
 
 function cse_state!(state, t)
-    !istree(t) && return t
+    !iscall(t) && return t
     state[t] = Base.get!(state, t, 0) + 1
     foreach(x->cse_state!(state, x), unsorted_arguments(t))
 end
@@ -758,7 +758,7 @@ function cse_block!(assignments, counter, names, name, state, x)
             counter[] += 1
             return sym
         end
-    elseif istree(x)
+    elseif iscall(x)
         args = map(a->cse_block!(assignments, counter, names, name, state,a), unsorted_arguments(x))
         if isterm(x)
             return term(operation(x), args...)

src/inspect.jl

@@ -2,11 +2,11 @@ import AbstractTrees
 
 const inspect_metadata = Ref{Bool}(false)
 function AbstractTrees.nodevalue(x::Symbolic)
-    istree(x) ? operation(x) : x
+    iscall(x) ? operation(x) : x
 end
 
 function AbstractTrees.nodevalue(x::BasicSymbolic)
-    str = if !istree(x)
+    str = if !iscall(x)
         string(exprtype(x), "(", x, ")")
     elseif isadd(x)
         string(exprtype(x), 
@@ -27,7 +27,7 @@ function AbstractTrees.nodevalue(x::BasicSymbolic)
 end
 
 function AbstractTrees.children(x::Symbolic)
-    istree(x) ? arguments(x) : ()
+    iscall(x) ? arguments(x) : ()
 end
 
 """

src/interface.jl

@@ -1,10 +1,10 @@
 """
-  istree(x)
+  iscall(x)
 
 Returns `true` if `x` is a term. If true, `operation`, `arguments`
 must also be defined for `x` appropriately.
 """
-istree(x) = false
+iscall(x) = false
 
 """
   symtype(x)
@@ -29,7 +29,7 @@ issym(x) = false
 """
   operation(x)
 
-If `x` is a term as defined by `istree(x)`, `operation(x)` returns the
+If `x` is a term as defined by `iscall(x)`, `operation(x)` returns the
 head of the term if `x` represents a function call, for example, the head
 is the function being called.
 """
@@ -38,14 +38,14 @@ function operation end
 """
   arguments(x)
 
-Get the arguments of `x`, must be defined if `istree(x)` is `true`.
+Get the arguments of `x`, must be defined if `iscall(x)` is `true`.
 """
 function arguments end
 
 """
   unsorted_arguments(x::T)
 
-If x is a term satisfying `istree(x)` and your term type `T` provides
+If x is a term satisfying `iscall(x)` and your term type `T` provides
 an optimized implementation for storing the arguments, this function can
 be used to retrieve the arguments when the order of arguments does not matter 
 but the speed of the operation does.

src/matchers.jl

@@ -6,7 +6,7 @@
 # 3. Callback: takes arguments Dictionary × Number of elements matched
 #
 function matcher(val::Any)
-    istree(val) && return term_matcher(val)
+    iscall(val) && return term_matcher(val)
     function literal_matcher(next, data, bindings)
         islist(data) && isequal(car(data), val) ? next(bindings, 1) : nothing
     end
@@ -89,7 +89,7 @@ function term_matcher(term)
     function term_matcher(success, data, bindings)
 
         !islist(data) && return nothing
-        !istree(car(data)) && return nothing
+        !iscall(car(data)) && return nothing
 
         function loop(term, bindings′, matchers′) # Get it to compile faster
             if !islist(matchers′)

src/ordering.jl

@@ -20,7 +20,7 @@
 function get_degrees(expr)
     if issym(expr)
         ((Symbol(expr),) => 1,)
-    elseif istree(expr)
+    elseif iscall(expr)
         op = operation(expr)
         args = arguments(expr)
         if operation(expr) == (^) && args[2] isa Number
@@ -62,7 +62,7 @@ function lexlt(degs1, degs2)
     return false # they are equal
 end
 
-_arglen(a) = istree(a) ? length(unsorted_arguments(a)) : 0
+_arglen(a) = iscall(a) ? length(unsorted_arguments(a)) : 0
 
 function <ₑ(a::Tuple, b::Tuple)
     for (x, y) in zip(a, b)

src/polyform.jl

@@ -6,7 +6,7 @@ using Bijections
 
 Abstracts a [MultivariatePolynomials.jl](https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/) as a SymbolicUtils expression and vice-versa.
 
-The SymbolicUtils term interface (`istree`, `operation, and `arguments`) works on PolyForm lazily:
+The SymbolicUtils term interface (`iscall`, `operation, and `arguments`) works on PolyForm lazily:
 the `operation` and `arguments` are created by converting one level of arguments into SymbolicUtils expressions. They may further contain PolyForm within them.
 We use this to hold polynomials in memory while doing `simplify_fractions`.
 
@@ -97,7 +97,7 @@ _isone(p::PolyForm) = isone(p.p)
 function polyize(x, pvar2sym, sym2term, vtype, pow, Fs, recurse)
     if x isa Number
         return x
-    elseif istree(x)
+    elseif iscall(x)
         if !(symtype(x) <: Number)
             error("Cannot convert $x of symtype $(symtype(x)) into a PolyForm")
         end
@@ -170,8 +170,8 @@ function PolyForm(x,
     PolyForm{symtype(x)}(p, pvar2sym, sym2term, metadata)
 end
 
-istree(x::Type{<:PolyForm}) = true
-istree(x::PolyForm) = true
+iscall(x::Type{<:PolyForm}) = true
+iscall(x::PolyForm) = true
 
 function similarterm(t::PolyForm, f, args, symtype; metadata=nothing)
     basic_similarterm(t, f, args, symtype; metadata=metadata)
@@ -336,7 +336,7 @@ function simplify_fractions(x; polyform=false)
 end
 
 function add_with_div(x, flatten=true)
-    (!istree(x) || operation(x) != (+)) && return x
+    (!iscall(x) || operation(x) != (+)) && return x
     aa = unsorted_arguments(x)
     !any(a->isdiv(a), aa) && return x # no rewrite necessary
 
@@ -361,26 +361,26 @@ function flatten_fractions(x)
 end
 
 function fraction_iszero(x)
-    !istree(x) && return _iszero(x)
+    !iscall(x) && return _iszero(x)
     ff = flatten_fractions(x)
     # fast path and then slow path
     any(_iszero, numerators(ff)) ||
     any(_iszero∘expand, numerators(ff))
 end
 
 function fraction_isone(x)
-    !istree(x) && return _isone(x)
+    !iscall(x) && return _isone(x)
     _isone(simplify_fractions(flatten_fractions(x)))
 end
 
 function needs_div_rules(x)
     (isdiv(x) && !(x.num isa Number) && !(x.den isa Number)) ||
-    (istree(x) && operation(x) === (+) && count(has_div, unsorted_arguments(x)) > 1) ||
-    (istree(x) && any(needs_div_rules, unsorted_arguments(x)))
+    (iscall(x) && operation(x) === (+) && count(has_div, unsorted_arguments(x)) > 1) ||
+    (iscall(x) && any(needs_div_rules, unsorted_arguments(x)))
 end
 
 function has_div(x)
-    return isdiv(x) || (istree(x) && any(has_div, unsorted_arguments(x)))
+    return isdiv(x) || (iscall(x) && any(has_div, unsorted_arguments(x)))
 end
 
 flatten_pows(xs) = map(xs) do x

src/rewriters.jl

@@ -32,7 +32,7 @@ rewriters.
 module Rewriters
 using SymbolicUtils: @timer
 
-import SymbolicUtils: similarterm, istree, operation, arguments, unsorted_arguments, node_count
+import SymbolicUtils: similarterm, iscall, operation, arguments, unsorted_arguments, node_count
 export Empty, IfElse, If, Chain, RestartedChain, Fixpoint, Postwalk, Prewalk, PassThrough
 
 # Cache of printed rules to speed up @timer
@@ -190,11 +190,11 @@ instrument(x::PassThrough, f) = PassThrough(instrument(x.rw, f))
 passthrough(x, default) = x === nothing ? default : x
 function (p::Walk{ord, C, F, false})(x) where {ord, C, F}
     @assert ord === :pre || ord === :post
-    if istree(x)
+    if iscall(x)
         if ord === :pre
             x = p.rw(x)
         end
-        if istree(x)
+        if iscall(x)
             x = p.similarterm(x, operation(x), map(PassThrough(p), unsorted_arguments(x)))
         end
         return ord === :post ? p.rw(x) : x
@@ -205,11 +205,11 @@ end
 
 function (p::Walk{ord, C, F, true})(x) where {ord, C, F}
     @assert ord === :pre || ord === :post
-    if istree(x)
+    if iscall(x)
         if ord === :pre
             x = p.rw(x)
         end
-        if istree(x)
+        if iscall(x)
             _args = map(arguments(x)) do arg
                 if node_count(arg) > p.thread_cutoff
                     Threads.@spawn p(arg)

src/rule.jl

@@ -120,7 +120,7 @@ end
 getdepth(r::Rule) = r.depth
 
 function rule_depth(rule, d=0, maxdepth=0)
-    if istree(rule)
+    if iscall(rule)
         maxdepth = reduce(max, (rule_depth(r, d+1, maxdepth) for r in arguments(rule)), init=1)
     elseif rule isa Slot || rule isa Segment
         maxdepth = max(d, maxdepth)
@@ -389,7 +389,7 @@ Base.show(io::IO, acr::ACRule) = print(io, "ACRule(", acr.rule, ")")
 
 function (acr::ACRule)(term)
     r = Rule(acr)
-    if !istree(term)
+    if !iscall(term)
         r(term)
     else
         f =  operation(term)