added matching capapbility for optional operation with a tree of expressions

Author: Bumblebee00

src/matchers.jl

@@ -11,10 +11,10 @@ function matcher(val::Any)
     if iscall(val)
         # if has two arguments and one of them is a DefSlot, create a term matcher with defslot
         if length(arguments(val)) == 2 && any(x -> isa(x, DefSlot), arguments(val))
-            return term_matcher_defslot(val)
+            return defslot_term_matcher_constructor(val)
         # else return a normal term matcher
         else
-            return term_matcher(val)
+            return term_matcher_constructor(val)
         end
     end
 
@@ -40,18 +40,11 @@ function matcher(slot::Slot)
     end
 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)
-    function defslot_matcher(next, data, bindings)
-        !islist(data) && return
-        val = get(bindings, defslot.name, nothing)
-        if val !== nothing
-            if isequal(val, car(data))
-                return next(bindings, 1)
-            end
-        elseif defslot.predicate(car(data))
-            next(assoc(bindings, defslot.name, car(data)), 1)
-        end
-    end
+    matcher(Slot(defslot.name, defslot.predicate))
 end
 
 # returns n == offset, 0 if failed
@@ -110,7 +103,7 @@ function matcher(segment::Segment)
     end
 end
 
-function term_matcher(term)
+function term_matcher_constructor(term)
     matchers = (matcher(operation(term)), map(matcher, arguments(term))...,)
 
     function term_matcher(success, data, bindings)
@@ -129,7 +122,7 @@ function term_matcher(term)
             end
             # explenation of above 3 lines:
             # car(matchers′)(b,n -> loop(drop_n(term, n), b, cdr(matchers′)), term, bindings′)
-            #                ------- next(b,n) -----------------------------
+            #                <------ next(b,n) ---------------------------->
             # car = first element of list, cdr = rest of the list, drop_n = drop first n elements of list
             # Calls the first matcher, with the "next" function being loop again but with n terms dropepd from term
             # Term is a linked list (a list and a index). drop n advances the index. when the index sorpasses
@@ -140,25 +133,43 @@ function term_matcher(term)
     end
 end
 
-
-# ~x + ~!y
-function term_matcher_defslot(term)
-    matchers = (matcher(operation(term)), map(matcher, arguments(term))...) # create matchers for the operation and arguments of the term
-
-    function term_matcher(success, data, bindings)
-        
-        !islist(data) && return nothing # if data is not a list, return nothing
-        if !iscall(car(data))
-            a = arguments(term)
-            slot = a[findfirst(x -> isa(x, Slot), a)] # find the first slot in the term
-            defslot = a[findfirst(x -> isa(x, DefSlot), a)] # find the first defslot in the term
-
-            bindings = assoc(bindings, slot.name, car(data))
-            bindings = assoc(bindings, defslot.name, defslot.default)
-
-            return success(bindings, 1) # if first element is not a call, return success with bindings and 1
+# creates a matcher for a term containing a defslot, such as:
+# (~x + ...complicated pattern...)     *          ~!y
+#    normal part (can bee a tree)   operation     defslot part
+
+# defslot_term_matcher works like this:
+# checks wether data starts with the default operation.
+#     if yes (1): continues like term_matcher
+#     if no checks wether data matches the normal part
+#          if no returns nothing, rule is not applied
+#          if yes (2): adds the pair (default value name, default value) to the found bindings and 
+#          calls the success function like term_matcher would do
+
+function defslot_term_matcher_constructor(term)
+    a = arguments(term) # lenght two bc defslot term matcher is allowed only with +,* and ^, that accept two arguments
+    matchers = (matcher(operation(term)), map(matcher, a)...) # create matchers for the operation and the two arguments of the term
+    
+    defslot_index = findfirst(x -> isa(x, DefSlot), a) # find the defslot in the term
+    defslot = a[defslot_index]
+    
+    function defslot_term_matcher(success, data, bindings)
+        # if data is not a list, return nothing
+        !islist(data) && return nothing
+        # if data (is not a tree and is just a symbol) or (is a tree not starting with the default operation)
+        if !iscall(car(data)) || (istree(car(data)) && string(defslot.operation) != string(operation(car(data))))
+            other_part_matcher = matchers[defslot_index==2 ? 2 : 3] # find the matcher of the normal part
+            
+            # checks wether it matches the normal part
+            #                             <-----------------(2)------------------------------->
+            bindings = other_part_matcher((b,n) -> assoc(b, defslot.name, defslot.defaultValue), data, bindings)
+            
+            if bindings === nothing
+                return nothing
+            end
+            return success(bindings, 1)
         end
 
+        # (1)
         function loop(term, bindings′, matchers′) # Get it to compile faster
             if !islist(matchers′)
                 if  !islist(term)

src/rule.jl

@@ -1,7 +1,7 @@
 
 @inline alwaystrue(x) = true
 
-# Matcher patterns with Slot and Segment
+# Matcher patterns with Slot, DefSlot and Segment
 
 # matches one term
 # syntax:  ~x
@@ -31,53 +31,61 @@ function makeslot(s::Expr, keys)
     :(Slot($(QuoteNode(name)), $(esc(s.args[2]))))
 end
 
+
+
+
+
+
 # matches one term with built in default value.
 # syntax: ~!x
 # Example usage:
 # (~!x + ~y) can match (a + b) but also just "a" and x takes default value of zero.
 # (~!x)*(~y) can match a*b but also just "a", and x takes default value of one.
 # (~x + ~y)^(~!z) can match (a + b)^c but also just "a + b", and z takes default value of one.
 # only these three operations are supported for default values.
-# Note that the default value is not used in the consequent, it is only used to match the pattern.
 
-struct DefSlot{P, D}
+struct DefSlot{P, O}
     name::Symbol
     predicate::P
-    default::D
+    operation::O
+    defaultValue::Real
+end
+
+# operation | default
+# + | 0
+# * | 1
+# ^ | 1
+function defaultValOfCall(call)
+    if call == :+
+        return 0
+    elseif call == :*
+        return 1
+    elseif call == :^
+        return 1
+    end
+    # else no default value for this call
+    return nothing
 end
 
-DefSlot(s) = DefSlot(s, alwaystrue, nothing)
+DefSlot(s) = DefSlot(s, alwaystrue, nothing, 0)
 Base.isequal(s1::DefSlot, s2::DefSlot) = s1.name == s2.name
 Base.show(io::IO, s::DefSlot) = (print(io, "~!"); print(io, s.name))
 
-makeDefSlot(s::Symbol, keys, default) = (push!(keys, s); DefSlot(s, alwaystrue, default))
+makeDefSlot(s::Symbol, keys, op) = (push!(keys, s); DefSlot(s, alwaystrue, op, defaultValOfCall(op)))
 
-function makeDefSlot(s::Expr, keys, default)
+function makeDefSlot(s::Expr, keys, op)
     if !(s.head == :(::))
         error("Syntax for specifying a default slot is ~!x::\$predicate, where predicate is a boolean function")
     end
 
     name = s.args[1]
 
     push!(keys, name)
-    :(DefSlot($(QuoteNode(name)), $(esc(s.args[2])), $(esc(default))))
+    tmp = defaultValOfCall(op)
+    :(DefSlot($(QuoteNode(name)), $(esc(s.args[2])), $(esc(op))), $(esc(tmp)))
 end
 
-# parent | default
-# + | 0
-# * | 1
-# ^ | 1
-function defaultValOfCall(call)
-    if call == :+
-        return 0
-    elseif call == :*
-        return 1
-    elseif call == :^
-        return 1
-    end
 
-    return nothing # no default value for this call
-end
 
 
 
@@ -117,7 +125,7 @@ function makepattern(expr, keys, parentCall=nothing)
                     makesegment(expr.args[2].args[2], keys)
                 elseif expr.args[2] isa Expr && expr.args[2].args[1] == :(!)
                     # matches ~!x::predicate
-                    makeDefSlot(expr.args[2].args[2], keys, defaultValOfCall(parentCall))
+                    makeDefSlot(expr.args[2].args[2], keys, parentCall)
                 else
                     # matches ~x::predicate
                     makeslot(expr.args[2], keys)

test/rewrite.jl

@@ -52,13 +52,34 @@ end
     @test r_sum((a + b)^2) === b
     @test r_sum(b^2) === 0
 
-    r_mult = @rule (~x * ~!y + ~z) => ~y
-    @test r_mult(c + a*b) === b
-    @test r_mult(c + b) === 1
-
-    r_pow = @rule (~x + ~y)^(~!m) => ~m
-    @test r_pow((a + b)^2) === 2
-    @test r_pow(a + b) === 1
+    r_mult = @rule ~x * ~!y  => ~y
+    @test r_mult(a * b) === b
+    @test r_mult(a) === 1
+
+    r_mult2 = @rule (~x * ~!y + ~z) => ~y
+    @test r_mult2(c + a*b) === b
+    @test r_mult2(c + b) === 1
+
+    # here the "normal part" in the defslot_term_matcher is not a symbol but a tree
+    r_mult3 = @rule (~!x)*(~y + ~z) => ~x
+    @test r_mult3(a*(c+2)) === a
+    @test r_mult3(2*(c+2)) === 2
+    @test r_mult3(c+2) === 1
+    
+    r_pow = @rule (~x)^(~!m) => ~m
+    @test r_pow(a^(b+1)) === b+1
+    @test r_pow(a) === 1
+    @test r_pow(a+1) === 1
+
+    # here the "normal part" in the defslot_term_matcher is not a symbol but a tree
+    r_pow2 = @rule (~x + ~y)^(~!m) => ~m
+    @test r_pow2((a+b)^c) === c
+    @test r_pow2(a+b) === 1
+
+    r_mix = @rule (~x + (~y)*(~!c))^(~!m) => ~m + ~c
+    @test r_mix((a + b*c)^d) === c + d
+    @test r_mix((a + b*c)) === 1 + c
+    @test r_mix((a + b)) === 2 #1+1
 end
 
 using SymbolicUtils: @capture