refactor

Author: Alessandro

src/TermInterface.jl

@@ -1,7 +1,7 @@
 module TermInterface
 
 """
-    istree(x)
+  istree(x)
 
 Returns `true` if `x` is a term. If true, `operation`, `arguments`
 must also be defined for `x` appropriately.
@@ -11,20 +11,20 @@ istree(x::Type{T}) where {T} = false
 export istree
 
 """
-    symtype(x)
+  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)
+  typeof(x)
 end
 export symtype
 
 """
-    issym(x)
+  issym(x)
 
 Returns `true` if `x` is a symbol. If true, `nameof` must be defined
 on `x` and must return a Symbol.
@@ -34,7 +34,7 @@ issym(x::Type{T}) where {T} = false
 export issym
 
 """
-    exprhead(x)
+  exprhead(x)
 
 If `x` is a term as defined by `istree(x)`, `exprhead(x)` must return a symbol,
 corresponding to the head of the `Expr` most similar to the term `x`.
@@ -49,7 +49,7 @@ export exprhead
 
 
 """
-    operation(x)
+  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
@@ -59,7 +59,7 @@ function operation end
 export operation
 
 """
-    arguments(x)
+  arguments(x)
 
 Get the arguments of `x`, must be defined if `istree(x)` is `true`.
 """
@@ -68,7 +68,7 @@ export arguments
 
 
 """
-    unsorted_arguments(x::T)
+  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 
@@ -80,7 +80,7 @@ export unsorted_arguments
 
 
 """
-    arity(x)
+  arity(x)
 
 Returns the number of arguments of `x`. Implicitly defined 
 if `arguments(x)` is defined.
@@ -90,7 +90,7 @@ export arity
 
 
 """
-    metadata(x)
+  metadata(x)
 
 Return the metadata attached to `x`.
 """
@@ -99,36 +99,36 @@ export metadata
 
 
 """
-    metadata(x, md)
+  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")
+  error("Setting metadata on $x is not possible")
 end
 
 
 """
-    similarterm(x, head, args, symtype=nothing; metadata=nothing, exprhead=:call)
+  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(x, head, args, symtype=nothing; metadata=nothing, exprhead=nothing)
-    if exprhead === nothing
-        similarterm(typeof(x), head, args, symtype; metadata=metadata)
-    else
-        similarterm(typeof(x), head, args, symtype; metadata=metadata, exprhead=exprhead)
-    end
+function similarterm(x, head, args, symtype = nothing; metadata = nothing, exprhead = nothing)
+  if exprhead === nothing
+    similarterm(typeof(x), head, args, symtype; metadata = metadata)
+  else
+    similarterm(typeof(x), head, args, symtype; metadata = metadata, exprhead = exprhead)
+  end
 end
 
-function similarterm(x::Type{T}, head, args, symtype=nothing; metadata=nothing, exprhead=:call) where T
-    !istree(T) ? head : head(args...)
-end 
+function similarterm(x::Type{T}, head, args, symtype = nothing; metadata = nothing, exprhead = :call) where {T}
+  !istree(T) ? head : head(args...)
+end
 export similarterm
 
 include("utils.jl")

src/expr.jl

@@ -5,23 +5,23 @@ istree(x::Type{Expr}) = true
 exprhead(e::Expr) = e.head
 
 operation(e::Expr) = expr_operation(e, Val{exprhead(e)}())
-arguments(e::Expr) =  expr_arguments(e, Val{exprhead(e)}())
+arguments(e::Expr) = expr_arguments(e, Val{exprhead(e)}())
 
 # See https://docs.julialang.org/en/v1/devdocs/ast/
-expr_operation(e::Expr, ::Union{Val{:call}, Val{:macrocall}}) = e.args[1]
+expr_operation(e::Expr, ::Union{Val{:call},Val{:macrocall}}) = e.args[1]
 expr_operation(e::Expr, ::Union{Val{:ref}}) = getindex
 expr_operation(e::Expr, ::Val{T}) where {T} = T
 
-expr_arguments(e::Expr, ::Union{Val{:call}, Val{:macrocall}}) = e.args[2:end]
+expr_arguments(e::Expr, ::Union{Val{:call},Val{:macrocall}}) = e.args[2:end]
 expr_arguments(e::Expr, _) = e.args
 
 
-function similarterm(x::Type{Expr}, head, args, symtype=nothing; metadata=nothing, exprhead=:call)
-    expr_similarterm(head, args, Val{exprhead}())
+function similarterm(x::Type{Expr}, head, args, symtype = nothing; metadata = nothing, exprhead = :call)
+  expr_similarterm(head, args, Val{exprhead}())
 end
 
-function similarterm(x::Expr, head, args, symtype=nothing; metadata=nothing, exprhead=exprhead(x))
-    expr_similarterm(head, args, Val{exprhead}())
+function similarterm(x::Expr, head, args, symtype = nothing; metadata = nothing, exprhead = exprhead(x))
+  expr_similarterm(head, args, Val{exprhead}())
 end
 
 

src/utils.jl

@@ -1,5 +1,5 @@
 """
-    is_operation(f)
+  is_operation(f)
 
 Returns a single argument anonymous function predicate, that returns `true` if and only if
 the argument to the predicate satisfies `istree` and `operation(x) == f` 
@@ -9,8 +9,8 @@ export is_operation
 
 
 """
-    node_count(t)
+  node_count(t)
 Count the nodes in a symbolic expression tree satisfying `istree` and `arguments`.
 """
-node_count(t) = istree(t) ? reduce(+, node_count(x) for x in  arguments(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