removed smrule macro and added commutativity checks to the rule macro

Author: Bumblebee00

src/SymbolicUtils.jl

@@ -54,7 +54,7 @@ export Rewriters
 # A library for composing together expr -> expr functions
 
 using Combinatorics: permutations, combinations
-export @rule, @acrule, @smrule, RuleSet
+export @rule, @acrule, RuleSet
 
 # Rule type and @rule macro
 include("rule.jl")

src/matchers.jl

@@ -6,7 +6,7 @@
 # 3. Callback: takes arguments Dictionary × Number of elements matched
 #
 
-function matcher(val::Any; acSets = nothing)
+function matcher(val::Any, acSets)
     # if val is a call (like an operation) creates a term matcher or term matcher with defslot
     if iscall(val)
         # if has two arguments and one of them is a DefSlot, create a term matcher with defslot
@@ -25,7 +25,7 @@ function matcher(val::Any; acSets = nothing)
 end
 
 # acSets is not used but needs to be there in case matcher(::Slot) is directly called from the macro
-function matcher(slot::Slot; acSets = nothing)
+function matcher(slot::Slot, acSets)
     function slot_matcher(next, data, bindings)
         !islist(data) && return nothing
         val = get(bindings, slot.name, nothing)
@@ -44,8 +44,8 @@ end
 # this is called only when defslot_term_matcher finds the operation and tries
 # to match it, so no default value used. So the same function as slot_matcher
 # can be used
-function matcher(defslot::DefSlot; acSets = nothing)
-    matcher(Slot(defslot.name, defslot.predicate))
+function matcher(defslot::DefSlot, acSets)
+    matcher(Slot(defslot.name, defslot.predicate), nothing) # slot matcher doesnt use acsets
 end
 
 # returns n == offset, 0 if failed
@@ -76,7 +76,7 @@ function trymatchexpr(data, value, n)
     end
 end
 
-function matcher(segment::Segment; acSets=nothing)
+function matcher(segment::Segment, acSets)
     function segment_matcher(success, data, bindings)
         val = get(bindings, segment.name, nothing)
 
@@ -105,7 +105,7 @@ function matcher(segment::Segment; acSets=nothing)
 end
 
 function term_matcher_constructor(term, acSets)
-    matchers = (matcher(operation(term); acSets=acSets), map(x->matcher(x;acSets=acSets), arguments(term))...,)
+    matchers = (matcher(operation(term), acSets), map(x->matcher(x,acSets), arguments(term))...,)
 
     function loop(term, bindings′, matchers′) # Get it to compile faster
         if !islist(matchers′)
@@ -181,14 +181,21 @@ function term_matcher_constructor(term, acSets)
             operation(term) !== operation(car(data)) && return nothing # if the operation of data is not the correct one, don't even try
 
             T = symtype(car(data))
-            f = operation(car(data))
-            data_args = arguments(car(data))
-
-            for inds in acSets(eachindex(data_args), length(arguments(term)))
-                candidate = Term{T}(f, @views data_args[inds])
-
-                result = loop(candidate, bindings, matchers)                
-                result !== nothing && length(data_args) == length(inds) && return success(result,1)
+            if T <: Number
+                f = operation(car(data))
+                data_args = arguments(car(data))
+                
+                for inds in acSets(eachindex(data_args), length(arguments(term)))
+                    candidate = Term{T}(f, @views data_args[inds])
+                    
+                    result = loop(candidate, bindings, matchers)                
+                    result !== nothing && length(data_args) == length(inds) && return success(result,1)
+                end
+            # if car(data) does not subtype to number, it might not be commutative
+            else
+                # call the normal matcher
+                result = loop(car(data), bindings, matchers)
+                result !== nothing && return success(result, 1)
             end
             return nothing
         end
@@ -214,7 +221,7 @@ function defslot_term_matcher_constructor(term, acSets)
     defslot_index = findfirst(x -> isa(x, DefSlot), a) # find the defslot in the term
     defslot = a[defslot_index]
     if length(a) == 2
-        other_part_matcher = matcher(a[defslot_index == 1 ? 2 : 1]; acSets = acSets)
+        other_part_matcher = matcher(a[defslot_index == 1 ? 2 : 1], acSets)
     else
         others = [a[i] for i in eachindex(a) if i != defslot_index]
         T = symtype(term)

src/rule.jl

@@ -387,24 +387,6 @@ _In the consequent pattern_: Use `(@ctx)` to access the context object on the ri
 of an expression.
 """
 macro rule(expr)
-    @assert expr.head == :call && expr.args[1] == :(=>)
-    lhs = expr.args[2]
-    rhs = rewrite_rhs(expr.args[3])
-    keys = Symbol[]
-    lhs_term = makepattern(lhs, keys)
-    unique!(keys)
-    quote
-        $(__source__)
-        lhs_pattern = $(lhs_term)
-        Rule($(QuoteNode(expr)),
-             lhs_pattern,
-             matcher(lhs_pattern),
-             __MATCHES__ -> $(makeconsequent(rhs)),
-             rule_depth($lhs_term))
-    end
-end
-
-macro smrule(expr)
     @assert expr.head == :call && expr.args[1] == :(=>)
     lhs = expr.args[2]
     rhs = rewrite_rhs(expr.args[3])
@@ -417,7 +399,7 @@ macro smrule(expr)
         Rule(
             $(QuoteNode(expr)),
             lhs_pattern,
-            matcher(lhs_pattern; acSets = permutations),
+            matcher(lhs_pattern, permutations),
             __MATCHES__ -> $(makeconsequent(rhs)),
             rule_depth($lhs_term)
         )
@@ -455,7 +437,7 @@ macro capture(ex, lhs)
         lhs_pattern = $(lhs_term)
         __MATCHES__ = Rule($(QuoteNode(lhs)),
              lhs_pattern,
-             matcher(lhs_pattern),
+             matcher(lhs_pattern, nothing),
              identity,
              rule_depth($lhs_term))($(esc(ex)))
         if __MATCHES__ !== nothing
@@ -523,7 +505,7 @@ macro acrule(expr)
         lhs_pattern = $(lhs_term)
         rule = Rule($(QuoteNode(expr)),
              lhs_pattern,
-             matcher(lhs_pattern; acSets = permutations),
+             matcher(lhs_pattern, permutations),
              __MATCHES__ -> $(makeconsequent(rhs)),
              rule_depth($lhs_term))
         ACRule(permutations, rule, $arity)
@@ -545,7 +527,7 @@ macro ordered_acrule(expr)
         lhs_pattern = $(lhs_term)
         rule = Rule($(QuoteNode(expr)),
              lhs_pattern,
-             matcher(lhs_pattern; acSets = combinations),
+             matcher(lhs_pattern, combinations),
              __MATCHES__ -> $(makeconsequent(rhs)),
              rule_depth($lhs_term))
         ACRule(combinations, rule, $arity)

test/rewrite.jl

@@ -48,19 +48,20 @@ end
 end
 
 @testset "Commutative + and *" begin
-    r1 = @acrule exp(sin(~x) + cos(~x)) => ~x
+    r1 = @rule exp(sin(~x) + cos(~x)) => ~x
+    # using a or x changes the order of the arguments in the call
     @test r1(exp(sin(a)+cos(a))) === a
     @test r1(exp(sin(x)+cos(x))) === x
-    r2 = @acrule (~x+~y)*(~z+~w)^(~m) => (~x, ~y, ~z, ~w, ~m)
-    r3 = @acrule (~z+~w)^(~m)*(~x+~y) => (~x, ~y, ~z, ~w, ~m)
+    r2 = @rule (~x+~y)*(~z+~w)^(~m) => (~x, ~y, ~z, ~w, ~m)
+    r3 = @rule (~z+~w)^(~m)*(~x+~y) => (~x, ~y, ~z, ~w, ~m)
     @test r2((a+b)*(x+c)^b) === (a, b, x, c, b)
     @test r3((a+b)*(x+c)^b) === (a, b, x, c, b)
-    rPredicate1 = @acrule ~x::(x->isa(x,Number)) + ~y => (~x, ~y)
-    rPredicate2 = @acrule ~y + ~x::(x->isa(x,Number)) => (~x, ~y)
+    rPredicate1 = @rule ~x::(x->isa(x,Number)) + ~y => (~x, ~y)
+    rPredicate2 = @rule ~y + ~x::(x->isa(x,Number)) => (~x, ~y)
     @test rPredicate1(2+x) === (2, x)
     @test rPredicate2(2+x) === (2, x)
-    r5 = @acrule (~y*(~z+~w))+~x => (~x, ~y, ~z, ~w)
-    r6 = @acrule ~x+((~z+~w)*~y) => (~x, ~y, ~z, ~w)
+    r5 = @rule (~y*(~z+~w))+~x => (~x, ~y, ~z, ~w)
+    r6 = @rule ~x+((~z+~w)*~y) => (~x, ~y, ~z, ~w)
     @test r5(c*(a+b)+d) === (d, c, a, b)
     @test r6(c*(a+b)+d) === (d, c, a, b)
 end