added documentation of defslot code

Author: Bumblebee00

src/matchers.jl

@@ -281,8 +281,8 @@ function defslot_term_matcher_constructor(term, acSets)
         # if no match, try to match with a defslot.
         # checks whether it matches the normal part if yes executes foo2
         # foo2: adds the pair (default value name, default value) to the found bindings
-        #       after checking predicate and presence in the bindings. If added succesfully
-        #       returns the bindings (foo3), otherwise return nothing
+        #       after checking predicate and presence in the bindings. If added 
+        #       successfully returns the bindings (foo3), otherwise return nothing
         #                           <-------------------foo2----------------------------------->
         #                                                  <-foo3->
         result = other_part_matcher((b,n)->defslot_matcher((b,n)->b, (defslot.defaultValue,), b), data, bindings)

src/rule.jl

@@ -240,10 +240,11 @@ it if it matches the LHS pattern to the RHS pattern, returns `nothing` otherwise
 The rule language is described below.
 
 LHS can be any possibly nested function call expression where any of the arguments can
-optionally be a Slot (`~x`) or a Segment (`~~x`) (described below).
+optionally be a Slot (`~x`), Default Value Slot (`~!x` also called DefSlot) or a Segment
+ (`~~x`) (described below).
 
-If an expression matches LHS entirely, then it is rewritten to the pattern in the RHS
-Segment (`~x`) and slot variables (`~~x`) on the RHS will substitute the result of the
+If an expression matches LHS entirely, then it is rewritten to the pattern in the RHS.
+Slot, DefSlot and Segment variables on the RHS will substitute the result of the
 matches found for these variables in the LHS.
 
 If the RHS is a single tilde `~`, then the rule returns a a dictionary of
@@ -306,6 +307,41 @@ julia> r(sin(2a)^2 + cos(a)^2)
 # nothing
 ```
 
+**DefSlot**:
+
+A DefSlot variable is written as `~!x`. Works like a normal slot, but can also take additional values if not present in the expression.
+
+_Example in power:_
+```julia
+julia> r_pow = @rule (~x)^(~!m) => ~m
+(~x) ^ ~(!m) => ~m
+
+julia> r_pow(x^2)
+2
+
+julia> r_pow(x)
+1
+```
+
+_Example in sum:_
+```julia
+julia> r_sum = @rule ~x + ~!y => ~y
+~x + ~(!y) => ~y
+
+julia> r_sum(x+2)
+x
+
+julia> r_sum(x)
+0
+```
+
+Currently DefSlot is implemented in:
+Operation | Default value
+----------|--------------
+* | 1
++ | 0
+2nd argument of ^ | 1
+
 **Segment**:
 
 A Segment variable is written as `~~x` and matches zero or more expressions in the

test/rewrite.jl

@@ -114,7 +114,7 @@ end
     @test r_predicate1(x+2) === 2
     @test r_predicate1(x+2.0) === nothing
 
-    # predicate checked in defslot mathcing process
+    # predicate checked in defslot matching process
     r_predicate2 = @rule x + ~!m::(var->!(var===0)) => ~m
     @test r_predicate2(x+1)===1 # matches normally
     @test r_predicate2(x)===nothing # doesnt matches bc the default value is 0 and doesnt respect the predicate