modular patterns

* keep Node#to_pattern primitive
* define patterns via 'pattern(pat): body', where pat is a pattern
matching a Node, and body returns a Pattern
* Module#make_pattern(node) for node -> pattern conversion
* similar semantics to macro expansion

kernel/atomy.ay

@@ -1,9 +1,9 @@
 require("operators")
-require("patterns")
 require("errors")
 
 export(
   require("core")
+  require("patterns")
   require("define")
   require("comparison")
   require("loop")

kernel/block.ay

@@ -5,6 +5,7 @@ use("control-flow")
 use("meta")
 use("interpolation")
 use("node")
+use("patterns")
 
 Atomy Patterns open:
   NamedRedirectedInstance = NamedInstance class:
@@ -97,11 +98,11 @@ Atomy AST open:
     g send(.class-variable-get, 1)
 
 
-  RedirectedInstanceVariable to-pattern :=
-    Atomy Patterns NamedRedirectedInstance new(@target, @name)
+pattern(ri: Atomy AST RedirectedInstanceVariable):
+  Atomy Patterns NamedRedirectedInstance new(node target, node name)
 
-  RedirectedClassVariable to-pattern :=
-    Atomy Patterns NamedRedirectedClass new(@target, @name)
+pattern(rc: Atomy AST RedirectedClassVariable):
+  Atomy Patterns NamedRedirectedClass new(node target, node name)
 
 
 macro(~x onto ~(b: Block)):

kernel/concurrency.ay

@@ -12,15 +12,15 @@ Actor <- v := send(v)
 macro(receive ~(body: Block)):
   names [e]:
     bs =
-      `(~e when('~pat to-pattern) [~pat]: ~exp)
+      `(~e when(make-pattern('~pat)) [~pat]: ~exp)
         for [pat, exp] in pairs-from(body contents)
 
     `(Actor receive [~e]: ~*bs)
 
 macro(receive ~(body: Block) after(~timeout) ~(action: Block)):
   names [e]:
     bs =
-      `(~e when('~pat to-pattern) [~pat]: ~exp)
+      `(~e when(make-pattern('~pat)) [~pat]: ~exp)
         for [pat, exp] in pairs-from(body contents)
 
     `(Actor receive [~e]:

kernel/control-flow.ay

@@ -117,7 +117,7 @@ macro(condition ~(b: Block)):
 
 macro(~val match ~(b: Block)):
   branches = pairs-from(b contents) collect [x, y]:
-    MatchBranch new(x line, x to-pattern to-node, y)
+    MatchBranch new(x line, x, y)
 
   Match new(node line, val, branches)
 

kernel/core.ay

@@ -18,7 +18,7 @@ macro(false): Primitive new(node line, "false" to-sym)
 macro(_): Primitive new(node line, "undefined" to-sym)
 
 -- assignment/pattern-matching
-macro(~x = ~y): Assign new(node line, x to-pattern to-node, y)
+macro(~x = ~y): Assign new(node line, x, y)
 
 macro(_ ~(c: Constant)):
   ToplevelConstant new(node line, c name)
@@ -237,4 +237,5 @@ macro(~x (~Word)(~*args)!):
 
   node
 
+
 use("operators")

kernel/data.ay

@@ -3,6 +3,10 @@ use("define")
 use("control-flow")
 use("comparison")
 
+-- patterns defined by dsl use 'with', so make sure it's exported
+export(use("patterns"))
+
+
 define-class(nil, e: Atomy AST Constant) = `(~e = class:)
 define-class(root, e: Atomy AST Constant) = `(~e = ~root class:)
 define-class(root, `(~n { ~*cs })) =
@@ -28,8 +32,8 @@ define-class(root, `((~name)(~*as): ~*cs)) = do:
   cons = `((~name)(~*tmps))
 
   pat-def =
-    `(~(Atomy AST QuasiQuote new(0, cons)) to-pattern :=
-        ~(Atomy AST QuasiQuote new(0, pat)) to-pattern)
+    `(pattern(~(Atomy AST QuasiQuote new(0, cons))):
+        pattern(~(Atomy AST QuasiQuote new(0, pat))))
 
   parent = root or 'Object
 

kernel/define.ay

@@ -6,7 +6,7 @@ infix("&= ||= |= += -= /= ^= %=", 10, .right)
 macro(do ~(b: Block)): b body
 
 macro(~x =! ~y):
-  Set new(node line, x to-pattern to-node, y)
+  Set new(node line, x, y)
 
 macro((~name)(~*args) = ~body):
   Function new(node line, body, args, name text)

kernel/doc.ay

@@ -4,6 +4,7 @@ use("define")
 use("control-flow")
 use("comparison")
 use("array")
+use("patterns")
 
 infix("</> <//> <$> <$$>", 60, .right)
 infix("<> <+>", 70, .right)

kernel/format/formatter.ay

@@ -5,6 +5,7 @@ use("loop")
 use("regexp")
 use("comparison")
 use("particles")
+use("patterns")
 
 pretty = require("pretty")
 

kernel/interpolation.ay

@@ -5,6 +5,7 @@ use("quotes")
 use("range")
 use("grammar")
 use("node")
+use("patterns")
 
 parser(Parser):
   %atomy := Atomy Parser

kernel/particles.ay

@@ -4,6 +4,7 @@ use("data")
 use("control-flow")
 use("cosmetics")
 use("comparison")
+use("patterns")
 
 data(Particle(@receiver, @message, @arguments))
 
@@ -120,61 +121,62 @@ Atomy Patterns open:
       g send(.arguments, 0)
       @arguments deconstruct(g, mod, locals)
 
-`.(~r [~*as]) to-pattern :=
+
+pattern(`.(~r [~*as])):
   Atomy Patterns Particle new(
-    r to-pattern
+    pattern(r)
     .[]
-    `[~*as] to-pattern)
+    pattern(`[~*as]))
 
-`.[] to-pattern :=
+pattern(`.[]):
   Atomy Patterns Literal new(.[])
 
-`.[~*as] to-pattern :=
+pattern(`.[~*as]):
   Atomy Patterns Particle new(
-    '_ to-pattern
+    pattern('_)
     .[]
-    `[~*as] to-pattern)
+    pattern(`[~*as]))
 
-`.~(x: Atomy AST Binary) to-pattern :=
+pattern(`.~(x: Atomy AST Binary)):
   Atomy Patterns Particle new(
     if(x private)
-      then: '_ to-pattern
-      else: x lhs to-pattern
-    `[~(x rhs)] to-pattern
+      then: pattern('_)
+      else: pattern(x lhs)
+    pattern(`[~(x rhs)])
     x operator)
 
-`.((~(x: Atomy AST Word))(~*as)) to-pattern :=
+pattern(`.((~(x: Atomy AST Word))(~*as))):
   Atomy Patterns Particle new(
-    '_ to-pattern
-    `[~*as] to-pattern
+    pattern('_)
+    pattern(`[~*as])
     x text)
 
-`.((~(x: Atomy AST Word))(~*as)?) to-pattern :=
+pattern(`.((~(x: Atomy AST Word))(~*as)?)):
   Atomy Patterns Particle new(
-    '_ to-pattern
-    `[~*as] to-pattern
+    pattern('_)
+    pattern(`[~*as])
     `((~x)?) to-word text)
 
-`.((~(x: Atomy AST Word))(~*as)!) to-pattern :=
+pattern(`.((~(x: Atomy AST Word))(~*as)!)):
   Atomy Patterns Particle new(
-    '_ to-pattern
-    `[~*as] to-pattern
+    pattern('_)
+    pattern(`[~*as])
     `((~x)!) to-word text)
 
-`.(~r (~(x: Atomy AST Word))(~*as)) to-pattern :=
+pattern(`.(~r (~(x: Atomy AST Word))(~*as))):
   Atomy Patterns Particle new(
-    r to-pattern
-    `[~*as] to-pattern
+    pattern(r)
+    pattern(`[~*as])
     x text)
 
-`.(~r (~(x: Atomy AST Word))(~*as)?) to-pattern :=
+pattern(`.(~r (~(x: Atomy AST Word))(~*as)?)):
   Atomy Patterns Particle new(
-    r to-pattern
-    `[~*as] to-pattern
+    pattern(r)
+    pattern(`[~*as])
     `((~x)?) to-word text)
 
-`.(~r (~(x: Atomy AST Word))(~*as)!) to-pattern :=
+pattern(`.(~r (~(x: Atomy AST Word))(~*as)!)):
   Atomy Patterns Particle new(
-    r to-pattern
-    `[~*as] to-pattern
+    pattern(r)
+    pattern(`[~*as])
     `((~x)!) to-word text)