Allow use of do syntax with matchers

Author: shashi

src/matchers.jl

@@ -125,13 +125,13 @@ end
 # 3. Callback: takes arguments Dictionary × Number of elements matched
 #
 function matcher(val::Any)
-    function literal_matcher(data, bindings, ctx, next)
+    function literal_matcher(next, data, bindings, ctx)
         !isempty(data) && isequal(car(data), val) ? next(bindings, 1) : nothing
     end
 end
 
 function matcher(slot::Slot)
-    function slot_matcher(data, bindings, ctx, next)
+    function slot_matcher(next, data, bindings, ctx)
         isempty(data) && return
         val = get(bindings, slot.name, nothing)
         if val !== nothing
@@ -175,7 +175,7 @@ function trymatchexpr(data, value, n)
 end
 
 function matcher(segment::Segment)
-    function segment_matcher(data, bindings, ctx, success)
+    function segment_matcher(success, data, bindings, ctx)
         val = get(bindings, segment.name, nothing)
 
         if val !== nothing
@@ -204,7 +204,7 @@ end
 
 function matcher(term::Term)
     matchers = (matcher(operation(term)), map(matcher, arguments(term))...,)
-    function term_matcher(data, bindings, ctx, success)
+    function term_matcher(success, data, bindings, ctx)
 
         isempty(data) && return nothing
         !(car(data) isa Term) && return nothing
@@ -216,8 +216,9 @@ function matcher(term::Term)
                 end
                 return nothing
             end
-            res = car(matchers′)(term, bindings′, ctx,
-                                 (b, n) -> loop(drop_n(term, n), b, cdr(matchers′)))
+            car(matchers′)(term, bindings′, ctx) do b, n
+                loop(drop_n(term, n), b, cdr(matchers′))
+            end
         end
 
         loop(car(data), bindings, matchers) # Try to eat exactly one term

src/rule_dsl.jl

@@ -31,13 +31,12 @@ const EMPTY_DICT = ImmutableDict{Symbol, Any}(:____, nothing)
 struct EmptyCtx end
 
 function (r::Rule)(term, ctx=EmptyCtx())
-    match_function = r.matcher
     rhs = r.rhs
 
-    match_function((term,),
-                   EMPTY_DICT,
-                   ctx,
-                   (d, n) -> n === 1 ? (@timer "RHS" rhs(d, ctx)) : nothing)
+    r.matcher((term,), EMPTY_DICT, ctx) do bindings, n
+        # n == 1 means that exactly one term of the input (term,) was matched
+        n === 1 ? (@timer "RHS" rhs(bindings, ctx)) : nothing
+    end
 end
 
 """