changed names of operations for compatibility with symbolicutils and symbolics

Author: Alessandro

README.md

@@ -9,25 +9,25 @@ You should define the following methods for an expression tree type `T` with sym
 with TermInterface.jl, and therefore with [SymbolicUtils.jl](https://github.com/JuliaSymbolics/SymbolicUtils.jl) 
 and [Metatheory.jl](https://github.com/0x0f0f0f/Metatheory.jl).
 
-#### `isterm(x::T)` or `isterm(x::Type{T})`
+#### `istree(x::T)` or `istree(x::Type{T})`
 
 Check if `x` represents an expression tree. If returns true,
-it will be assumed that `gethead(::T)` and `getargs(::T)`
+it will be assumed that `operation(::T)` and `arguments(::T)`
 methods are defined. Definining these three should allow use
 of `SymbolicUtils.simplify` on custom types. Optionally `symtype(x)` can be
 defined to return the expected type of the symbolic expression.
 
-#### `gethead(x::T)`
+#### `operation(x::T)`
 
 Returns the head (a function object) performed by an expression
-tree. Called only if `isterm(::T)` is true. Part of the API required
-for `simplify` to work. Other required methods are `getargs` and `isterm`
+tree. Called only if `istree(::T)` is true. Part of the API required
+for `simplify` to work. Other required methods are `arguments` and `istree`
 
-#### `getargs(x::T)`
+#### `arguments(x::T)`
 
 Returns the arguments (a `Vector`) for an expression tree.
-Called only if `isterm(x)` is `true`. Part of the API required
-for `simplify` to work. Other required methods are `gethead` and `isterm`
+Called only if `istree(x)` is `true`. Part of the API required
+for `simplify` to work. Other required methods are `operation` and `istree`
 
 In addition, the methods for `Base.hash` and `Base.isequal` should also be implemented by the types for the purposes of substitution and equality matching respectively.
 
@@ -71,16 +71,16 @@ ex = 1 + (:x - 2)
 ```
 
 
-How can we use SymbolicUtils.jl to convert `ex` to `(-)(:x, 1)`? We simply implement `isterm`,
+How can we use SymbolicUtils.jl to convert `ex` to `(-)(:x, 1)`? We simply implement `istree`,
 `head`, `arguments` and we'll be able to do rule-based rewriting on `Expr`s:
 ```julia
 using TermInterface
 using SymbolicUtils
 
 
-TermInterface.isterm(ex::Expr) = ex.head == :call
-TermInterface.gethead(ex::Expr) = ex.args[1]
-TermInterface.getargs(ex::Expr) = ex.args[2:end]
+TermInterface.istree(ex::Expr) = ex.head == :call
+TermInterface.operation(ex::Expr) = ex.args[1]
+TermInterface.arguments(ex::Expr) = ex.args[2:end]
 TermInterface.similarterm(x::Type{Expr}, head, args; type=nothing, metadata=nothing) = Expr(:call, head, args...)
 
 @rule(~x => ~x - 1)(ex)

src/TermInterface.jl

@@ -1,15 +1,15 @@
 module TermInterface
 
 """
-    isterm(x)
+    istree(x)
 
-Returns `true` if `x` is a term. If true, `gethead`, `getargs`
+Returns `true` if `x` is a term. If true, `operation`, `arguments`
 must also be defined for `x` appropriately.
 """
-isterm(x) = isterm(typeof(x))
-isterm(x::Type{Expr}) = true
-isterm(x::Type{T}) where {T} = false
-export isterm
+istree(x) = istree(typeof(x))
+istree(x::Type{Expr}) = true
+istree(x::Type{T}) where {T} = false
+export istree
 
 """
     symtype(x)
@@ -34,31 +34,31 @@ function issym end
 export issym
 
 """
-    gethead(x)
+    operation(x)
 
-If `x` is a term as defined by `isterm(x)`, `gethead(x)` returns the
+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 gethead end
-gethead(e::Expr) = e.head
-export gethead
+function operation end
+operation(e::Expr) = e.head
+export operation
 
 """
-    getargs(x)
+    arguments(x)
 
-Get the arguments of `x`, must be defined if `isterm(x)` is `true`.
+Get the arguments of `x`, must be defined if `istree(x)` is `true`.
 """
-getargs(e::Expr) = e.args
-export getargs
+arguments(e::Expr) = e.args
+export arguments
 
 """
     arity(x)
 
 Returns the number of arguments of `x`. Implicitly defined 
-if `getargs(x)` is defined.
+if `arguments(x)` is defined.
 """
-arity(x) = length(getargs(x))
+arity(x) = length(arguments(x))
 export arity
 
 
@@ -99,7 +99,7 @@ similarterm(x, head, args; metadata=nothing) =
 
 similarterm(x::Type{Expr}, head, args, symtype=nothing; metadata=nothing) = Expr(head, args...)
 function similarterm(x::Type{T}, head::T, args, symtype=nothing; metadata=nothing) where T
-    if !isterm(T) head else head(args...) end
+    if !istree(T) head else head(args...) end
 end 
 export similarterm
 

src/utils.jl

@@ -2,15 +2,15 @@
     is_operation(f)
 
 Returns a single argument anonymous function predicate, that returns `true` if and only if
-the argument to the predicate satisfies `isterm` and `gethead(x) == f` 
+the argument to the predicate satisfies `istree` and `operation(x) == f` 
 """
-is_operation(f) = @nospecialize(x) -> isterm(x) && (gethead(x) == f)
+is_operation(f) = @nospecialize(x) -> istree(x) && (operation(x) == f)
 export is_operation
 
 
 """
     node_count(t)
-Count the nodes in a symbolic expression tree satisfying `isterm` and `getargs`.
+Count the nodes in a symbolic expression tree satisfying `istree` and `arguments`.
 """
-node_count(t) = isterm(t) ? reduce(+, node_count(x) for x in  getargs(t), init=0) + 1 : 1
+node_count(t) = istree(t) ? reduce(+, node_count(x) for x in  arguments(t), init=0) + 1 : 1
 export node_count