refactor: remove abstract type Symbolic

Author: AayushSabharwal

src/code.jl

@@ -10,7 +10,7 @@ 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, Symbolic, unwrap_const,
+                      symtype, sorted_arguments, metadata, isterm, term, maketerm, unwrap_const,
                       ArgsT, maybe_const
 import SymbolicIndexingInterface: symbolic_type, NotSymbolic
 

src/inspect.jl

@@ -1,9 +1,6 @@
 import AbstractTrees
 
 const inspect_metadata = Ref{Bool}(false)
-function AbstractTrees.nodevalue(x::Symbolic)
-    iscall(x) ? operation(x) : isexpr(x) ? head(x) : x
-end
 
 function AbstractTrees.nodevalue(x::BSImpl.Type)
     T = nameof(MData.variant_type(x))
@@ -35,7 +32,7 @@ the expression.
 
 This function is used internally for printing via AbstractTrees.
 """
-function AbstractTrees.children(x::Symbolic)
+function AbstractTrees.children(x::BasicSymbolic)
     iscall(x) ? sorted_arguments(x) : isexpr(x) ? sorted_children(x) : ()
 end
 
@@ -50,7 +47,7 @@ Line numbers will be shown, use `pluck(expr, line_number)` to get the sub expres
 """
 function inspect end
 
-function inspect(io::IO, x::Symbolic;
+function inspect(io::IO, x::BasicSymbolic;
         hint=true,
         metadata=inspect_metadata[])
 

src/methods.jl

@@ -134,17 +134,17 @@ promote_symtype(::typeof(rem2pi), T::Type{<:Number}, mode) = T
 
 error_f_symbolic(f, T) = error("$f is not defined for T.")
 
-function Base.rem2pi(x::Symbolic, mode::Base.RoundingMode)
+function Base.rem2pi(x::BasicSymbolic, mode::Base.RoundingMode)
     T = symtype(x)
     T <: Number ? term(rem2pi, x, mode) : error_f_symbolic(rem2pi, T)
 end
 
 # Specially handle inv and literal pow
-function Base.inv(x::Symbolic)
+function Base.inv(x::BasicSymbolic)
     T = symtype(x)
     T <: Number ? Base.:^(x, -1) : error_f_symbolic(rem2pi, T)
 end
-function Base.literal_pow(::typeof(^), x::Symbolic, ::Val{p}) where {p}
+function Base.literal_pow(::typeof(^), x::BasicSymbolic, ::Val{p}) where {p}
     T = symtype(x)
     T <: Number ? Base.:^(x, p) : error_f_symbolic(^, T)
 end
@@ -159,20 +159,20 @@ for f in monadic
     @eval promote_symtype(::$(typeof(f)), T::Type{<:LiteralRealImpl}) = LiteralReal
 end
 
-Base.:*(a::AbstractArray, b::Symbolic{<:Number}) = map(x->x*b, a)
-Base.:*(a::Symbolic{<:Number}, b::AbstractArray) = map(x->a*x, b)
+Base.:*(a::AbstractArray, b::BasicSymbolic{<:Number}) = map(x->x*b, a)
+Base.:*(a::BasicSymbolic{<:Number}, b::AbstractArray) = map(x->a*x, b)
 
 for f in [identity, one, zero, *, +, -]
     @eval promote_symtype(::$(typeof(f)), T::Type{<:Number}) = T
 end
 
 promote_symtype(::typeof(Base.real), T::Type{<:Number}) = Real
-Base.real(s::Symbolic{<:Number}) = islike(s, Real) ? s : term(real, s)
+Base.real(s::BasicSymbolic{<:Number}) = islike(s, Real) ? s : term(real, s)
 promote_symtype(::typeof(Base.conj), T::Type{<:Number}) = T
-Base.conj(s::Symbolic{<:Number}) = islike(s, Real) ? s : term(conj, s)
+Base.conj(s::BasicSymbolic{<:Number}) = islike(s, Real) ? s : term(conj, s)
 promote_symtype(::typeof(Base.imag), T::Type{<:Number}) = Real
-Base.imag(s::Symbolic{<:Number}) = islike(s, Real) ? zero(symtype(s)) : term(imag, s)
-Base.adjoint(s::Symbolic{<:Number}) = conj(s)
+Base.imag(s::BasicSymbolic{<:Number}) = islike(s, Real) ? zero(symtype(s)) : term(imag, s)
+Base.adjoint(s::BasicSymbolic{<:Number}) = conj(s)
 
 
 ## Booleans
@@ -186,29 +186,29 @@ 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::BasicSymbolic{<:$Domain}, b::$Domain) = term($f, a, b, type=Bool)
+        (::$(typeof(f)))(a::BasicSymbolic{<:$Domain}, b::BasicSymbolic{<:$Domain}) = term($f, a, b, type=Bool)
+        (::$(typeof(f)))(a::$Domain, b::BasicSymbolic{<:$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])
+        (::$(typeof(f)))(s::BasicSymbolic{Bool}) = Term{Bool}(!, [s])
     end
 end
 
 
 # An ifelse node
-function Base.ifelse(_if::Symbolic{Bool}, _then, _else)
+function Base.ifelse(_if::BasicSymbolic{Bool}, _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}
 
 # Array-like operations
-Base.size(x::Symbolic{<:Number}) = ()
-Base.length(x::Symbolic{<:Number}) = 1
-Base.ndims(x::Symbolic{T}) where {T} = Base.ndims(T)
-Base.ndims(::Type{<:Symbolic{T}}) where {T} = Base.ndims(T)
-Base.broadcastable(x::Symbolic{T}) where {T<:Number} = Ref(x)
+Base.size(x::BasicSymbolic{<:Number}) = ()
+Base.length(x::BasicSymbolic{<:Number}) = 1
+Base.ndims(x::BasicSymbolic{T}) where {T} = Base.ndims(T)
+Base.ndims(::Type{<:BasicSymbolic{T}}) where {T} = Base.ndims(T)
+Base.broadcastable(x::BasicSymbolic{T}) where {T<:Number} = Ref(x)

src/ordering.jl

@@ -5,8 +5,8 @@
 <ₑ(a::Real,    b::Complex) = true
 <ₑ(a::Complex, b::Real) = false
 
-<ₑ(a::Symbolic, b::Number) = false
-<ₑ(a::Number, b::Symbolic) = true
+<ₑ(a::BasicSymbolic, b::Number) = false
+<ₑ(a::Number, b::BasicSymbolic) = true
 
 <ₑ(a::Function, b::Function) = nameof(a) <ₑ nameof(b)
 

src/substitute.jl

@@ -7,12 +7,12 @@ function (s::Substituter)(expr)
 end
 
 function _const_or_not_symbolic(x)
-    isconst(x) || !(x isa Symbolic)
+    isconst(x) || !(x isa BasicSymbolic)
 end
 
 function combine_fold(::Type{T}, op, args::ArgsT, meta) where {T}
     @nospecialize op args meta
-    can_fold = !(op isa Symbolic) && all(_const_or_not_symbolic, args)
+    can_fold = !(op isa BasicSymbolic) && all(_const_or_not_symbolic, args)
     if can_fold
         if op === (+)
             add_worker(args)
@@ -60,14 +60,14 @@ julia> substitute(1+sqrt(y), Dict(y => 2), fold=false)
 end
 
 """
-    occursin(needle::Symbolic, haystack::Symbolic)
+    occursin(needle::BasicSymbolic, haystack::BasicSymbolic)
 
 Determine whether the second argument contains the first argument. Note that
 this function doesn't handle associativity, commutativity, or distributivity.
 """
-Base.occursin(needle::Symbolic, haystack::Symbolic) = _occursin(needle, haystack)
-Base.occursin(needle, haystack::Symbolic) = _occursin(needle, haystack)
-Base.occursin(needle::Symbolic, haystack) = _occursin(needle, haystack)
+Base.occursin(needle::BasicSymbolic, haystack::BasicSymbolic) = _occursin(needle, haystack)
+Base.occursin(needle, haystack::BasicSymbolic) = _occursin(needle, haystack)
+Base.occursin(needle::BasicSymbolic, haystack) = _occursin(needle, haystack)
 function _occursin(needle, haystack)
     isequal(unwrap_const(needle), unwrap_const(haystack)) && return true
     if iscall(haystack)

src/types.jl

@@ -2,7 +2,6 @@
 #--------------------
 #### Symbolic
 #--------------------
-abstract type Symbolic{T} end
 
 #################### SafeReal #########################
 export SafeReal, LiteralReal
@@ -55,7 +54,7 @@ end
 
 Core ADT for `BasicSymbolic`. `hash` and `isequal` compare metadata.
 """
-@data mutable BasicSymbolicImpl{T} <: Symbolic{T} begin 
+@data mutable BasicSymbolicImpl{T} begin 
     struct Const
         const val::T
         id::IdentT
@@ -491,11 +490,10 @@ end
 ### Base interface
 ###
 
-Base.isequal(::Symbolic, x) = false
-Base.isequal(x, ::Symbolic) = false
-Base.isequal(::Symbolic, ::Missing) = false
-Base.isequal(::Missing, ::Symbolic) = false
-Base.isequal(::Symbolic, ::Symbolic) = false
+Base.isequal(::BasicSymbolic, x) = false
+Base.isequal(x, ::BasicSymbolic) = false
+Base.isequal(::BasicSymbolic, ::Missing) = false
+Base.isequal(::Missing, ::BasicSymbolic) = false
 
 const SCALAR_SYMTYPE_VARIANTS = [Number, Real, SafeReal, LiteralReal, Int, Float64, Bool]
 const ARR_VARIANTS = [Vector, Matrix]
@@ -718,8 +716,8 @@ function Base.hash(s::BSImpl.Type, h::UInt)
     hash_bsimpl(s, h, COMPARE_FULL[])
 end
 
-Base.one( s::Union{Symbolic, BSImpl.Type}) = one( symtype(s))
-Base.zero(s::Union{Symbolic, BSImpl.Type}) = zero(symtype(s))
+Base.one( s::BSImpl.Type) = one( symtype(s))
+Base.zero(s::BSImpl.Type) = zero(symtype(s))
 
 
 Base.nameof(s::Union{BasicSymbolic, BSImpl.Type}) = issym(s) ? s.name : error("Non-Sym BasicSymbolic doesn't have a name")
@@ -975,7 +973,7 @@ struct Div{T} end
 
 function Const{T}(val) where {T}
     val = unwrap(val)
-    val isa Symbolic && return val
+    val isa BasicSymbolic && return val
     BSImpl.Const{T}(convert(T, val))
 end
 
@@ -1227,12 +1225,12 @@ end
 metadata(s::BSImpl.Type) = isconst(s) ? nothing : s.metadata
 metadata(s::BasicSymbolic, meta) = Setfield.@set! s.metadata = meta
 
-function hasmetadata(s::Symbolic, ctx)
+function hasmetadata(s::BasicSymbolic, ctx)
     metadata(s) isa AbstractDict && haskey(metadata(s), ctx)
 end
 
 issafecanon(f, s) = true
-function issafecanon(f, s::Symbolic)
+function issafecanon(f, s::BasicSymbolic)
     if metadata(s) === nothing || isempty(metadata(s)) || issym(s)
         return true
     else
@@ -1245,7 +1243,7 @@ _issafecanon(::typeof(^), s) = !iscall(s) || !(operation(s) in (*, ^))
 
 issafecanon(f, ss...) = all(x->issafecanon(f, x), ss)
 
-function getmetadata(s::Symbolic, ctx)
+function getmetadata(s::BasicSymbolic, ctx)
     md = metadata(s)
     if md isa AbstractDict
         md[ctx]
@@ -1254,7 +1252,7 @@ function getmetadata(s::Symbolic, ctx)
     end
 end
 
-function getmetadata(s::Symbolic, ctx, default)
+function getmetadata(s::BasicSymbolic, ctx, default)
     md = metadata(s)
     md isa AbstractDict ? get(md, ctx, default) : default
 end
@@ -1282,7 +1280,7 @@ function assocmeta(d::Base.ImmutableDict, ctx, val)::ImmutableDict{DataType,Any}
     Base.ImmutableDict{DataType, Any}(d, ctx, val)
 end
 
-function setmetadata(s::Symbolic, ctx::DataType, val)
+function setmetadata(s::BasicSymbolic, ctx::DataType, val)
     if s.metadata isa AbstractDict
         @set s.metadata = assocmeta(s.metadata, ctx, val)
     else
@@ -1521,9 +1519,9 @@ promote_symtype(f, Ts...) = Any
 
 struct FnType{X<:Tuple,Y,Z} end
 
-(f::Symbolic{<:FnType})(args...) = Term{promote_symtype(f, symtype.(args)...)}(f, SmallV{Any}(args))
+(f::BasicSymbolic{<:FnType})(args...) = Term{promote_symtype(f, symtype.(args)...)}(f, SmallV{Any}(args))
 
-function (f::Symbolic)(args...)
+function (f::BasicSymbolic)(args...)
     error("Sym $f is not callable. " *
           "Use @syms $f(var1, var2,...) to create it as a callable.")
 end
@@ -1548,7 +1546,7 @@ function promote_symtype(f::BasicSymbolic{<:FnType{X,Y}}, args...) where {X, Y}
     return Y
 end
 
-function Base.show(io::IO, f::Symbolic{<:FnType{X,Y}}) where {X,Y}
+function Base.show(io::IO, f::BasicSymbolic{<:FnType{X,Y}}) where {X,Y}
     print(io, nameof(f))
     # Use `Base.unwrap_unionall` to handle `Tuple{T} where T`. This is not the
     # best printing, but it's better than erroring.
@@ -1657,7 +1655,7 @@ end
 ###
 ### Arithmetic
 ###
-const SN = Symbolic{<:Number}
+const SN = BasicSymbolic{<:Number}
 # integration. Constructors of `Add, Mul, Pow...` from Base (+, *, ^, ...)
 
 add_t(a::Number,b::Number) = promote_symtype(+, symtype(a), symtype(b))

src/utils.jl

@@ -2,9 +2,9 @@ using Base: ImmutableDict
 
 
 pow(x,y) = y==0 ? 1 : y<0 ? inv(x)^(-y) : x^y
-pow(x::Symbolic,y) = y==0 ? 1 : Base.:^(x,y)
-pow(x, y::Symbolic) = Base.:^(x,y)
-pow(x::Symbolic,y::Symbolic) = Base.:^(x,y)
+pow(x::BasicSymbolic,y) = y==0 ? 1 : Base.:^(x,y)
+pow(x, y::BasicSymbolic) = Base.:^(x,y)
+pow(x::BasicSymbolic,y::BasicSymbolic) = Base.:^(x,y)
 
 # Simplification utilities
 function has_trig_exp(term)
@@ -19,20 +19,6 @@ function has_trig_exp(term)
     end
 end
 
-function fold(t)
-    if iscall(t)
-        tt = map(fold, parent(arguments(t)))
-        if !any(x->x isa Symbolic, tt)
-            # evaluate it
-            return operation(t)(tt...)
-        else
-            return maketerm(typeof(t), operation(t), tt, metadata(t))
-        end
-    else
-        return t
-    end
-end
-
 ### Predicates
 
 sym_isa(::Type{T}) where {T} = @nospecialize(x) -> x isa T || symtype(x) <: T
@@ -53,8 +39,8 @@ function _isone(x)
     x isa Array && return isone(x)
     return false
 end
-_isinteger(x) = (x isa Number && isinteger(x)) || (x isa Symbolic && symtype(x) <: Integer)
-_isreal(x) = (x isa Number && isreal(x)) || (x isa Symbolic && symtype(x) <: Real)
+_isinteger(x) = (x isa Number && isinteger(x)) || (x isa BasicSymbolic && symtype(x) <: Integer)
+_isreal(x) = (x isa Number && isreal(x)) || (x isa BasicSymbolic && symtype(x) <: Real)
 
 issortedₑ(args) = issorted(args, lt=<ₑ)
 needs_sorting(f) = x -> is_operation(f)(x) && !issortedₑ(arguments(x))

test/basics.jl

@@ -1,4 +1,4 @@
-using SymbolicUtils: Symbolic, Sym, FnType, Term, Polyform, symtype, operation, arguments, issym, isterm, BasicSymbolic, term, basicsymbolic_to_polyvar, get_mul_coefficient, PolynomialT, Const
+using SymbolicUtils: Sym, FnType, Term, Polyform, symtype, operation, arguments, issym, isterm, BasicSymbolic, term, basicsymbolic_to_polyvar, get_mul_coefficient, PolynomialT, Const
 using SymbolicUtils
 using ConstructionBase: setproperties
 import MultivariatePolynomials as MP
@@ -165,7 +165,7 @@ end
 
 @testset "array-like operations" begin
     abstract type SquareDummy end
-    Base.:*(a::Symbolic{SquareDummy}, b) = b^2
+    Base.:*(a::BasicSymbolic{SquareDummy}, b) = b^2
     @syms s t a::SquareDummy A[1:2, 1:2]
 
     @test isequal(ndims(A), 2)

test/fuzzlib.jl

@@ -1,5 +1,5 @@
 using SymbolicUtils
-using SymbolicUtils: Term, showraw, Symbolic, issym
+using SymbolicUtils: BasicSymbolic, Term, showraw, issym
 using SpecialFunctions
 using Test
 using NaNMath
@@ -30,7 +30,7 @@ function rand_input(T)
     end
 end
 
-rand_input(i::Symbolic{T}) where {T} = rand_input(T)
+rand_input(i::BasicSymbolic{T}) where {T} = rand_input(T)
 
 const num_spec = let
     @syms a b::Real c::Integer d::Float64 e::Rational f