trait-like dispatch

Author: shashi

benchmark/benchmarks.jl

@@ -1,5 +1,5 @@
 using BenchmarkTools, SymbolicUtils
-using SymbolicUtils: isnumber
+using SymbolicUtils: is_literal_number
 
 using Random
 
@@ -8,7 +8,7 @@ SUITE = BenchmarkGroup()
 @syms a b c d; Random.seed!(123);
 
 let r = @rule(~x => ~x), rs = RuleSet([r]),
-    acr = @rule(~x::isnumber + ~y => ~y)
+    acr = @rule(~x::is_literal_number + ~y => ~y)
 
     overhead = SUITE["overhead"]  = BenchmarkGroup()
     overhead["rule"]  = BenchmarkGroup()

src/methods.jl

@@ -5,18 +5,22 @@ const diadic = [+, -, max, min, *, /, \, hypot, atan, mod, rem, ^, copysign]
 const previously_declared_for = Set([])
 
 # TODO: it's not possible to dispatch on the symtype! (only problem is Parameter{})
-function assert_number(a, b)
-    assert_number(a)
-    assert_number(b)
+
+assert_like(f, T) = nothing
+function assert_like(f, T, a, b...)
+    islike(a, T) || throw(ArgumentError("The function $f cannot be applied to $a which is not a $T-like object." *
+                                           "Define `isnumberlike(::$(typeof(a))) = true` to enable this."))
+    assert_like(f, T, b...)
 end
 
-assert_number(a) = symtype(a) <: Number || error("Can't apply this to not a number")
+islike(a, T) = symtype(a) <: T
+
 # TODO: keep domains tighter than this
 function number_methods(T, rhs1, rhs2)
     exprs = []
 
-    rhs2 = :($assert_number(a, b); $rhs2)
-    rhs1 = :($assert_number(a); $rhs1)
+    rhs2 = :($assert_like(f, Number, a, b); $rhs2)
+    rhs1 = :($assert_like(f, Number, a); $rhs1)
 
     for f in diadic
         for S in previously_declared_for
@@ -101,8 +105,7 @@ for f in [identity, one, zero, *, +]
 end
 
 promote_symtype(::typeof(Base.real), T::Type{<:Number}) = Real
-Base.real(s::Symbolic{<:Real}) = s
-Base.real(s::Symbolic{<:Number}) = term(real, s)
+Base.real(s::Symbolic) = islike(s, Real) ? s : term(real, s)
 
 ## Booleans
 

src/ordering.jl

@@ -17,7 +17,7 @@ function <ₑ(a, b)
     elseif istree(b) && !istree(a)
         args = arguments(b)
         if length(args) === 2
-            n1, n2 = !isnumber(args[1]) , !isnumber(args[2])
+            n1, n2 = !is_literal_number(args[1]) , !is_literal_number(args[2])
             if n1 && n2
                 # both subterms are terms, so it's definitely firster
                 return true
@@ -102,7 +102,7 @@ function cmp_term_term(a, b)
         if length(aa) !== length(ab)
             return length(aa) < length(ab)
         else
-            terms = zip(Iterators.filter(!isnumber, aa), Iterators.filter(!isnumber, ab))
+            terms = zip(Iterators.filter(!is_literal_number, aa), Iterators.filter(!is_literal_number, ab))
 
             for (x,y) in terms
                 if x <ₑ y
@@ -113,8 +113,8 @@ function cmp_term_term(a, b)
             end
 
             # compare the numbers
-            nums = zip(Iterators.filter(isnumber, aa),
-                       Iterators.filter(isnumber, ab))
+            nums = zip(Iterators.filter(is_literal_number, aa),
+                       Iterators.filter(is_literal_number, ab))
 
             for (x,y) in nums
                 if x <ₑ y

src/simplify_rules.jl

@@ -4,14 +4,14 @@ let
     PLUS_RULES = [
         @rule(~x::isnotflat(+) => flatten_term(+, ~x))
         @rule(~x::needs_sorting(+) => sort_args(+, ~x))
-        @ordered_acrule(~a::isnumber + ~b::isnumber => ~a + ~b)
+        @ordered_acrule(~a::is_literal_number + ~b::is_literal_number => ~a + ~b)
 
         @acrule(*(~~x) + *(~β, ~~x) => *(1 + ~β, (~~x)...))
         @acrule(*(~α, ~~x) + *(~β, ~~x) => *(~α + ~β, (~~x)...))
         @acrule(*(~~x, ~α) + *(~~x, ~β) => *(~α + ~β, (~~x)...))
 
         @acrule(~x + *(~β, ~x) => *(1 + ~β, ~x))
-        @acrule(*(~α::isnumber, ~x) + ~x => *(~α + 1, ~x))
+        @acrule(*(~α::is_literal_number, ~x) + ~x => *(~α + 1, ~x))
         @rule(+(~~x::hasrepeats) => +(merge_repeats(*, ~~x)...))
 
         @ordered_acrule((~z::_iszero + ~x) => ~x)
@@ -22,7 +22,7 @@ let
         @rule(~x::isnotflat(*) => flatten_term(*, ~x))
         @rule(~x::needs_sorting(*) => sort_args(*, ~x))
 
-        @ordered_acrule(~a::isnumber * ~b::isnumber => ~a * ~b)
+        @ordered_acrule(~a::is_literal_number * ~b::is_literal_number => ~a * ~b)
         @rule(*(~~x::hasrepeats) => *(merge_repeats(^, ~~x)...))
 
         @acrule((~y)^(~n) * ~y => (~y)^(~n+1))
@@ -50,7 +50,7 @@ let
         @rule(~x / ~y => ~x * pow(~y, -1))
         @rule(one(~x) => one(symtype(~x)))
         @rule(zero(~x) => zero(symtype(~x)))
-        @rule(cond(~x::isnumber, ~y, ~z) => ~x ? ~y : ~z)
+        @rule(cond(~x::is_literal_number, ~y, ~z) => ~x ? ~y : ~z)
     ]
 
     TRIG_RULES = [
@@ -92,9 +92,9 @@ let
         # simplify terms with no symbolic arguments
         # e.g. this simplifies term(isodd, 3, type=Bool)
         # or term(!, false)
-        @rule((~f)(~x::isnumber) => (~f)(~x))
+        @rule((~f)(~x::is_literal_number) => (~f)(~x))
         # and this simplifies any binary comparison operator
-        @rule((~f)(~x::isnumber, ~y::isnumber) => (~f)(~x, ~y))
+        @rule((~f)(~x::is_literal_number, ~y::is_literal_number) => (~f)(~x, ~y))
     ]
 
     function number_simplifier()

src/utils.jl

@@ -109,7 +109,7 @@ sym_isa(::Type{T}) where {T} = @nospecialize(x) -> x isa T || symtype(x) <: T
 is_operation(f) = @nospecialize(x) -> istree(x) && (operation(x) == f)
 
 isliteral(::Type{T}) where {T} = x -> x isa T
-isnumber(x) = isliteral(Number)(x)
+is_literal_number(x) = isliteral(Number)(x)
 
 _iszero(t) = false
 _iszero(x::Number) = iszero(x)