Merge remote-tracking branch 'willow/compromise-interface' into compromise-interface

Author: shashi

src/TermInterface.jl

@@ -50,12 +50,14 @@ export issym
 Returns the head of the S-expression.
 """
 function head end
+export head
 
 """
     children(x)
 Returns the children (aka tail) of the S-expression.
 """
 function children end
+export children
 
 """
   operation(x)
@@ -119,20 +121,20 @@ end
     similarterm(x, op, args, symtype=nothing; metadata=nothing)
 
 """
-function similarterm(x, op, args, symtype = nothing; metadata = nothing)
-    Base.depwarn("""`similarterm` is deprecated, use `maketerm` instead.
-                    See https://github.com/JuliaSymbolics/TermInterface.jl for details.
-                    The present call can be replaced by
-                    `maketerm(typeof(x), $(callhead(x)), [op, args...], symtype, metadata)`""", :similarterm)
+function similarterm(x, op, args, symtype=nothing; metadata=nothing)
+  Base.depwarn("""`similarterm` is deprecated, use `maketerm` instead.
+                  See https://github.com/JuliaSymbolics/TermInterface.jl for details.
+                  The present call can be replaced by
+                  `maketerm(typeof(x), $(head(x)), [op, args...], symtype, metadata)`""", :similarterm)
 
-    maketerm(typeof(x), callhead(x), [op, args...], symtype, metadata)
+  maketerm(typeof(x), callhead(x), [op, args...], symtype, metadata)
 end
 
 # Old fallback
-function similarterm(T::Type, op, args, symtype = nothing; metadata = nothing)
-    Base.depwarn("`similarterm` is deprecated, use `maketerm` instead." *
-                 "See https://github.com/JuliaSymbolics/TermInterface.jl for details.", :similarterm)
-    op(args...)
+function similarterm(T::Type, op, args, symtype=nothing; metadata=nothing)
+  Base.depwarn("`similarterm` is deprecated, use `maketerm` instead." *
+               "See https://github.com/JuliaSymbolics/TermInterface.jl for details.", :similarterm)
+  op(args...)
 end
 
 export similarterm
@@ -141,7 +143,7 @@ export similarterm
 """
     callhead(x)
 Used in this deprecation cycle of `similarterm` to find the `head` argument to
-`makterm`. Do not implement this, or use `similarterm` if you're using this package.
+`maketerm`. Do not implement this, or use `similarterm` if you're using this package.
 """
 callhead(x) = typeof(x)
 
@@ -166,9 +168,10 @@ If your types do not support type information or metadata, you still need to acc
 these arguments and may choose to not use them.
 """
 
-function maketerm(T::Type, head, children, type, metadata)
-    error("maketerm for $T is not implemented")
+function maketerm(T::Type, head, children, type=nothing, metadata=nothing)
+  error("maketerm for $T is not implemented")
 end
+export maketerm
 
 include("utils.jl")
 

src/expr.jl

@@ -3,12 +3,13 @@
 
 iscall(x::Expr) = x.head == :call
 
+callhead(e::Expr) = e.head
 head(e::Expr) = e.head
 children(e::Expr) = e.args
 
-operation(e::Expr) = e.args[1]
-arguments(e::Expr) = e.args[2:end]
+operation(e::Expr) = iscall(e) ? first(children(e)) : error("operation called on a non-function call expression")
+arguments(e::Expr) = iscall(e) ? @view(e.args[2:end]) : error("arguments called on a non-function call expression")
 
-function maketerm(::Type{Expr}, head, args, symtype, metadata)
+function maketerm(::Type{Expr}, head, args, symtype=nothing, metadata=nothing)
     Expr(head, args...)
 end

test/runtests.jl

@@ -3,12 +3,19 @@ using Test
 
 @testset "Expr" begin
     ex = :(f(a, b))
-    @test operation(ex) == :call
-    @test arguments(ex) == [:f, :a, :b]
-    @test ex == similarterm(ex, :call, [:f, :a, :b])
+    @test head(ex) == :call
+    @test children(ex) == [:f, :a, :b]
+    @test operation(ex) == :f
+    @test arguments(ex) == [:a, :b]
+    @test iscall(ex)
+    @test ex == similarterm(ex, :f, [:a, :b])
+    @test ex == maketerm(Expr, :call, [:f, :a, :b])
+
 
     ex = :(arr[i, j])
-    @test operation(ex) == :ref
-    @test arguments(ex) == [:arr, :i, :j]
-    @test ex == similarterm(ex, :ref, [:arr, :i, :j])
+    @test head(ex) == :ref
+    @test_throws ErrorException operation(ex)
+    @test_throws ErrorException arguments(ex)
+    @test !iscall(ex)
+    @test ex == maketerm(Expr, :ref, [:arr, :i, :j])
 end