Merge pull request #482 from JuliaSymbolics/s/unityper-updates

[wip] Unityper updates

Author: shashi

Project.toml

@@ -15,14 +15,12 @@ DynamicPolynomials = "7c1d4256-1411-5781-91ec-d7bc3513ac07"
 IfElse = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173"
 LabelledArrays = "2ee39098-c373-598a-b85f-a56591580800"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
-Metatheory = "e9d8d322-4543-424a-9be4-0cc815abe26c"
 MultivariatePolynomials = "102ac46a-7ee4-5c85-9060-abc95bfdeaa3"
 NaNMath = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"
 Setfield = "efcf1570-3423-57d1-acb7-fd33fddbac46"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
-TermInterface = "8ea1fca8-c5ef-4a55-8b96-4e9afe9c9a3c"
 TimerOutputs = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f"
 Unityper = "a7c27f48-0311-42f6-a7f8-2c11e75eb415"
 
@@ -37,13 +35,11 @@ DocStringExtensions = "0.8, 0.9"
 DynamicPolynomials = "0.3, 0.4"
 IfElse = "0.1"
 LabelledArrays = "1.5"
-Metatheory = "1.2"
 MultivariatePolynomials = "0.3, 0.4"
 NaNMath = "0.3, 1"
 Setfield = "0.7, 0.8, 1"
 SpecialFunctions = "0.10, 1.0, 2"
 StaticArrays = "0.12, 1.0"
-TermInterface = "0.2.1, 0.3"
 TimerOutputs = "0.5"
 Unityper = "0.1.2"
 julia = "1.3"

src/SymbolicUtils.jl

@@ -6,11 +6,6 @@ module SymbolicUtils
 using DocStringExtensions
 export @syms, term, showraw, hasmetadata, getmetadata, setmetadata
 
-using TermInterface
-using TermInterface: node_count
-using Metatheory
-using Metatheory.Rules
-using Metatheory.Rewriters
 using Unityper
 
 # Sym, Term,
@@ -20,6 +15,7 @@ using Setfield
 import Setfield: PropertyLens
 import Base: +, -, *, /, //, \, ^, ImmutableDict
 using ConstructionBase
+include("interface.jl")
 include("types.jl")
 export istree, operation, arguments, similarterm
 
@@ -40,6 +36,8 @@ export @rule, @acrule, RuleSet
 
 # Rule type and @rule macro
 include("rule.jl")
+include("matchers.jl")
+include("rewriters.jl")
 
 # Convert to an efficient multi-variate polynomial representation
 import MultivariatePolynomials
@@ -61,10 +59,6 @@ include("simplify.jl")
 export substitute
 include("substitute.jl")
 
-# EGraph rewriting
-include("egraph.jl")
-export optimize
-
 include("code.jl")
 
 

src/code.jl

@@ -1,16 +1,15 @@
 module Code
 
 using StaticArrays, LabelledArrays, SparseArrays, LinearAlgebra
-using TermInterface
 
 export toexpr, Assignment, (←), Let, Func, DestructuredArgs, LiteralExpr,
        SetArray, MakeArray, MakeSparseArray, MakeTuple, AtIndex,
        SpawnFetch, Multithreaded, cse
 
 import ..SymbolicUtils
 import ..SymbolicUtils.Rewriters
-import SymbolicUtils: @matchable, BasicSymbolic, Sym, Term, istree, operation, arguments,
-                      symtype, similarterm, unsorted_arguments, metadata
+import SymbolicUtils: @matchable, BasicSymbolic, Sym, Term, istree, operation, arguments, issym,
+                      symtype, similarterm, unsorted_arguments, metadata, isterm, term
 
 ##== state management ==##
 
@@ -134,7 +133,7 @@ function function_to_expr(::typeof(SymbolicUtils.ifelse), O, st)
 end
 
 function function_to_expr(x::BasicSymbolic, O, st)
-    TermInterface.issym(x) ? get(st.symbolify, O, nothing) : nothing
+    issym(x) ? get(st.symbolify, O, nothing) : nothing
 end
 
 toexpr(O::Expr, st) = O
@@ -693,8 +692,8 @@ end
 
 
 function _cse(exprs::AbstractArray)
-    letblock = cse(Term{Any}(tuple, exprs))
-    letblock.pairs, arguments(letblock.body)
+    letblock = cse(Term{Any}(tuple, vec(exprs)))
+    letblock.pairs, reshape(arguments(letblock.body), size(exprs))
 end
 
 function cse(x::MakeArray)
@@ -738,8 +737,13 @@ function cse_block!(assignments, counter, names, name, state, x)
         end
     elseif istree(x)
         args = map(a->cse_block!(assignments, counter, names, name, state,a), unsorted_arguments(x))
-        return similarterm(x, operation(x), args, symtype(x),
-                    metadata=metadata(x))
+        if isterm(x)
+            return term(operation(x), args...)
+        else
+            return similarterm(x, operation(x),
+                               args, symtype(x),
+                               metadata=metadata(x))
+        end
     else
         return x
     end

src/egraph.jl

@@ -0,0 +1,82 @@
+"""
+  istree(x)
+
+Returns `true` if `x` is a term. If true, `operation`, `arguments`
+must also be defined for `x` appropriately.
+"""
+istree(x) = false
+
+"""
+  symtype(x)
+
+Returns the symbolic type of `x`. By default this is just `typeof(x)`.
+Define this for your symbolic types if you want `SymbolicUtils.simplify` to apply rules
+specific to numbers (such as commutativity of multiplication). Or such
+rules that may be implemented in the future.
+"""
+function symtype(x)
+  typeof(x)
+end
+
+"""
+  issym(x)
+
+Returns `true` if `x` is a symbol. If true, `nameof` must be defined
+on `x` and must return a Symbol.
+"""
+issym(x) = false
+
+"""
+  operation(x)
+
+If `x` is a term as defined by `istree(x)`, `operation(x)` returns the
+head of the term if `x` represents a function call, for example, the head
+is the function being called.
+"""
+function operation end
+
+"""
+  arguments(x)
+
+Get the arguments of `x`, must be defined if `istree(x)` is `true`.
+"""
+function arguments end
+
+"""
+  unsorted_arguments(x::T)
+
+If x is a term satisfying `istree(x)` and your term type `T` orovides
+and 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.
+"""
+unsorted_arguments(x) = arguments(x)
+arity(x) = length(unsorted_arguments(x))
+
+"""
+  metadata(x)
+
+Return the metadata attached to `x`.
+"""
+metadata(x) = nothing
+
+"""
+  metadata(x, md)
+
+Returns a new term which has the structure of `x` but also has
+the metadata `md` attached to it.
+"""
+function metadata(x, data)
+  error("Setting metadata on $x is not possible")
+end
+
+"""
+  similarterm(x, head, args, symtype=nothing; metadata=nothing, exprhead=:call)
+
+Returns a term that is in the same closure of types as `typeof(x)`,
+with `head` as the head and `args` as the arguments, `type` as the symtype
+and `metadata` as the metadata. By default this will execute `head(args...)`.
+`x` parameter can also be a `Type`. The `exprhead` keyword argument is useful 
+when manipulating `Expr`s.
+"""
+function similarterm end