atomy 0.1.1 → 0.6.3

data/kernel/let-macro.ay

@@ -0,0 +1,24 @@
+use(require("core"))
+use(require("define"))
+use(require("patterns"))
+
+require("atomy/bootstrap")
+
+let-macro = class:
+  def(initialize(@body, @macros)) {}
+
+  def(bytecode(gen, mod)):
+    new = Atomy Module new: use(mod)
+
+    @macros each [`(~pat = ~exp)]:
+      definer = Atomy Bootstrap macro-definer(
+        Atomy Grammar AST QuasiQuote new(pat)
+        exp
+      )
+
+      new evaluate(definer, new compile-context)
+
+    new compile(gen, @body)
+
+macro(let-macro(~*ms): ~*body):
+  let-macro new(`(do: ~*body), ms)

data/kernel/let-pattern.ay

@@ -0,0 +1,24 @@
+use(require("core"))
+use(require("define"))
+use(require("patterns"))
+
+require("atomy/bootstrap")
+
+let-pattern = class:
+  def(initialize(@body, @patterns)) {}
+
+  def(bytecode(gen, mod)):
+    new = Atomy Module new: use(mod)
+
+    @patterns each [`(~pat = ~exp)]:
+      definer = Atomy Bootstrap pattern-definer(
+        Atomy Grammar AST QuasiQuote new(pat)
+        exp
+      )
+
+      new evaluate(definer, new compile-context)
+
+    new compile(gen, @body)
+
+macro(let-pattern(~*ms): ~*body):
+  let-pattern new(`(do: ~*body), ms)

data/kernel/loop.ay

@@ -0,0 +1,80 @@
+use(require("core"))
+use(require("define"))
+use(require("dynamic"))
+use(require("control-flow"))
+use(require("patterns"))
+use(require("let-macro"))
+use(require("data"))
+use(require("mutation"))
+
+tags = dynamic(Hash new)
+
+Atomy Grammar AST open:
+  data(GoTo(@name))
+
+  def(GoTo bytecode(gen, mod)):
+    gen goto(^tags fetch(@name))
+
+labels = class:
+  def(initialize(@branches)) {}
+
+  def(bytecode(gen, mod)):
+    new-tags = Hash new
+
+    lbls = @branches collect [name, body]:
+      new-tags[name] = gen new-label
+
+    with(tags = new-tags):
+      lbls zip(@branches) each [l, [_, body]]:
+        l set!
+        mod compile(gen, body)
+        gen pop
+
+    gen push-nil
+
+
+macro(labels: ~*branches):
+  branch-pairs = branches collect [`(~n: ~*body)]:
+    [n text, `(do: ~*body)]
+
+  `(let-macro(go(~'~name) = GoTo new(name text)):
+      ~(labels new(branch-pairs)))
+
+macro(while(~test): ~*body):
+  `(labels:
+      loop:
+        unless(~test):
+          go(done)
+
+        let-macro(break = 'go(done),
+                  next = 'go(loop)):
+          ~*body
+
+        go(loop)
+
+      done {})
+
+macro(until(~test): ~*body):
+  `(labels:
+      loop:
+        when(~test):
+          go(done)
+
+        let-macro(break = 'go(done),
+                  next = 'go(loop)):
+          ~*body
+
+        go(loop)
+
+      done {})
+
+macro(loop: ~*body):
+  `(labels:
+      loop:
+        let-macro(break = 'go(done),
+                  next = 'go(loop)):
+          ~*body
+
+        go(loop)
+
+      done {})

data/kernel/mutation.ay

@@ -0,0 +1,53 @@
+use(require("define"))
+use(require("patterns"))
+use(require("let-pattern"))
+sl = require("stack-local")
+
+-- variable mutation
+let-pattern(Identifier = pattern(`(Word | (`(~Word)! | `(~Word)?)))):
+  macro(~(x & Identifier) += ~y): `(&~x = (~x + ~y))
+  macro(~(x & Identifier) -= ~y): `(&~x = (~x - ~y))
+  macro(~(x & Identifier) *= ~y): `(&~x = (~x * ~y))
+  macro(~(x & Identifier) **= ~y): `(&~x = (~x ** ~y))
+  macro(~(x & Identifier) /= ~y): `(&~x = (~x / ~y))
+  macro(~(x & Identifier) &= ~y): `(&~x = (~x & ~y))
+  macro(~(x & Identifier) |= ~y): `(&~x = (~x | ~y))
+
+  fn(attr-mutator(recv, attr, op, val)):
+    r = sl Local new
+    `(do:
+        ~(r set(recv))
+        ~r ~attr = ~(Atomy Grammar AST Infix new(`(~r ~attr), val, op)))
+
+  fn(index-mutator(recv, args, op, val)):
+    r = sl Local new
+    als = args collect [a]: sl Local new
+    `(do:
+        ~(r set(recv))
+        ~*(als zip(args) collect [[l, v]]: l set(v))
+        ~r[~*als] = ~(Atomy Grammar AST Infix new(`(~r[~*als]), val, op)))
+
+  macro(~r ~(x & Identifier) += ~y): attr-mutator(r, x, ."+", y)
+  macro(~r ~(x & Identifier) -= ~y): attr-mutator(r, x, ."-", y)
+  macro(~r ~(x & Identifier) *= ~y): attr-mutator(r, x, ."*", y)
+  macro(~r ~(x & Identifier) **= ~y): attr-mutator(r, x, ."**", y)
+  macro(~r ~(x & Identifier) /= ~y): attr-mutator(r, x, ."/", y)
+  macro(~r ~(x & Identifier) &= ~y): attr-mutator(r, x, ."&", y)
+  macro(~r ~(x & Identifier) |= ~y): attr-mutator(r, x, ."|", y)
+
+  macro(~r[~*x] += ~y): index-mutator(r, x, ."+", y)
+  macro(~r[~*x] -= ~y): index-mutator(r, x, ."-", y)
+  macro(~r[~*x] *= ~y): index-mutator(r, x, ."*", y)
+  macro(~r[~*x] **= ~y): index-mutator(r, x, ."**", y)
+  macro(~r[~*x] /= ~y): index-mutator(r, x, ."/", y)
+  macro(~r[~*x] &= ~y): index-mutator(r, x, ."&", y)
+  macro(~r[~*x] |= ~y): index-mutator(r, x, ."|", y)
+
+-- other (ivar) mutation
+macro(~x += ~y): `(~x = (~x + ~y))
+macro(~x -= ~y): `(~x = (~x - ~y))
+macro(~x *= ~y): `(~x = (~x * ~y))
+macro(~x **= ~y): `(~x = (~x ** ~y))
+macro(~x /= ~y): `(~x = (~x / ~y))
+macro(~x &= ~y): `(~x = (~x & ~y))
+macro(~x |= ~y): `(~x = (~x | ~y))

data/kernel/particles.ay

@@ -1,53 +1,190 @@
-namespace(atomy)
+use(require("core"))
+use(require("define"))
+use(require("data"))
+use(require("control-flow"))
+use(require("patterns"))
+use(require("mutation"))
 
-for-macro:
-  wildcard('_) := '_undefined
-  wildcard(x) := x
+data(Particle(@receiver, @message, @arguments))
 
-macro(#(x: Send)):
-  `(Particle [
-      ~(if(x private)
-          then: '_undefined
-          else: wildcard(x receiver))
-      ~(Atomy::AST::Particle new(0, x method-name))
-      ~*(x arguments collect [c]: wildcard(c))
-    ])
+def(Particle call(*args) &blk):
+  to-proc call(*args) &blk
 
-macro(#(x: BinarySend)):
-  `(Particle [
-      ~(if(x private)
-          then: '_undefined
-          else: wildcard(x lhs))
-      ~(Atomy::AST::Particle new(0, x operator))
-      ~(wildcard(x rhs))
-    ])
+Particle open:
+  alias-method(.[], .call)
 
-export:
-  class(Particle < Array):
-    call(*args) := to-proc [*args]
+def(Particle to-proc):
+  [*args] &blk:
+    unless(args size >= arity):
+      raise(ArgumentError new((("given " + args size to-s) + ", expected ") + arity to-s))
 
-    to-proc := [*args]:
-      x = dup
+    [recv, cur] =
+      if(@receiver equal?(_))
+        then: [args[0], 1]
+        else: [@receiver, 0]
 
-      args each [a]:
-        idx = x find-index [a]:
-          a equal?(_undefined)
+    filled =
+      @arguments collect [v]:
+        if(v equal?(_) && (args size >= cur))
+          then:
+            cur += 1
+            args[cur - 1]
+          else:
+            v
 
-        when(idx):
-          x [idx] = a
+    recv __send__(@message, *filled) &blk
 
-      x first send(*(x drop(1)))
+def(Particle arity):
+  required-args = 0
+  when(@receiver equal?(_)):
+    required-args += 1
 
-    arity :=
-      select(&#equal?(_undefined)) size
+  @arguments each [v]:
+    when(v equal?(_)):
+      required-args += 1
 
-    receiver := at(0)
+  required-args
 
-    message := at(1)
+def(Particle == other):
+  other is-a?(self class) && (
+    (other receiver == @receiver) && (
+      (other message == @message) && (
+        other arguments == @arguments)))
 
-    arguments := drop(2)
+def(Symbol call(recv)): to-proc call(recv)
 
-class(Symbol):
-  call(*args) := to-proc [*args]
+def(Symbol arity): 1
 
-  arity := 1
+macro(.[~a, ~*as]):
+  `(Particle new(_, .[], [~a, ~*as]))
+
+macro(.((~x)(~*as))):
+  `(Particle new(_, .~x, [~*as]))
+
+macro(.(~r (~x)(~*as))):
+  `(Particle new(~r, .~x, [~*as]))
+
+macro(.(~r [~*as])):
+  `(Particle new(~r, .[], [~*as]))
+
+macro(.~(x & Infix)):
+  `(Particle new(
+      ~(x left || '_)
+      .~(StringLiteral new(x operator to-s))
+      [~(x right)]))
+
+particle-klass = Particle
+
+Atomy Pattern open:
+  self data(Particle(@receiver, @message, @arguments))
+
+  def(Particle target): particle-klass
+
+  def(Particle matches?(value)):
+    when(value is-a?(Symbol)):
+      &value = particle-klass new(_, value, [])
+
+    unless(value is-a?(particle-klass)):
+      return(false)
+
+    when(value message != @message):
+      return(false)
+
+    unless(@receiver matches?(value receiver)):
+      return(false)
+
+    @arguments matches?(value arguments)
+
+  def(Particle assign(scope, value)):
+    when(value is-a?(Symbol)):
+      &value = particle-klass new(_, value, [])
+
+    @receiver assign(scope, value receiver)
+    @arguments assign(scope, value arguments)
+
+particle-pattern-code = Atomy Code Pattern class:
+  def(initialize(@receiver, @message, @arguments)) {}
+
+  def(bytecode(gen, mod)):
+    mod compile(gen, `(//Atomy Pattern Particle new(
+      ~@receiver
+      ~@message
+      ~@arguments
+    )))
+
+  def(assign(gen)):
+    assign-symbol = gen new-label
+    done = gen new-label
+
+    gen dup
+    gen push-cpath-top
+    gen find-const(.Symbol)
+    gen swap
+    gen kind-of
+    gen git(assign-symbol)
+
+    gen dup-many(2)
+    gen send(.receiver, 0)
+    gen swap
+    gen send(.receiver, 0)
+    gen swap
+    @receiver assign(gen)
+    gen pop-many(2)
+
+    gen dup-many(2)
+    gen send(.arguments, 0)
+    gen swap
+    gen send(.arguments, 0)
+    gen swap
+    @arguments assign(gen)
+    gen pop-many(2)
+
+    gen goto(done)
+
+    assign-symbol set!
+
+    gen dup-many(2)
+    gen pop
+    gen send(.receiver, 0)
+    gen push-undef
+    @receiver assign(gen)
+    gen pop-many(2)
+
+    gen dup-many(2)
+    gen pop
+    gen send(.arguments, 0)
+    gen make-array(0)
+    @arguments assign(gen)
+    gen pop-many(2)
+
+    done set!
+
+pattern(.(~r [~*as])):
+  particle-pattern-code new(
+    pattern(r)
+    .[]
+    pattern(`[~*as]))
+
+pattern(.[]):
+  Atomy Code Pattern new(`(Atomy Pattern Equality new(.[])))
+
+pattern(.~(x & Word)):
+  Atomy Code Pattern new(`(Atomy Pattern Equality new(.~x)))
+
+pattern(.(~(x & Word))!):
+  Atomy Code Pattern new(`(Atomy Pattern Equality new(.(~x)!)))
+
+pattern(.(~(x & Word))?):
+  Atomy Code Pattern new(`(Atomy Pattern Equality new(.(~x)?)))
+
+pattern(.[~a, ~*as]):
+  particle-pattern-code new(pattern('_), '.[], pattern(`[~a, ~*as]))
+
+pattern(.~(x & Infix)):
+  particle-pattern-code new(pattern(x left || '_), `.~(StringLiteral new(x operator to-s)), pattern(`[~(x right)]))
+
+pattern(.((~x)(~*as))):
+  particle-pattern-code new(pattern('_), `.~x, pattern(`[~*as]))
+
+pattern(.(~r (~x)(~*as))):
+  particle-pattern-code new(pattern(r), `.~x, pattern(`[~*as]))

data/kernel/patterns.ay

@@ -1,256 +1,592 @@
-namespace(atomy)
+use(require("core"))
+use(require("define"))
+use(require("control-flow"))
 
-module(Atomy::Patterns):
-  export:
-    class(RuntimeClass < Pattern):
-      initialize(@body, @name) := #ok
+require("atomy/pattern/class_variable")
+require("atomy/pattern/instance_variable")
+require("atomy/pattern/attribute")
+require("atomy/pattern/or")
 
-      construct(g) := do:
-        get(g)
-        @body construct(g)
-        @body compile(g)
-        g send(#name, 0)
-        g send(#new, 2)
+instance-variable-pattern-code = Atomy Code Pattern class:
+  def(initialize(name)):
+    instance-variable-set("@name", name)
 
-      (== b) :=
-        b kind-of?(RuntimeClass) &&
-          @body == b body &&
-          @name == b name
+  def(bytecode(gen, mod)):
+    mod compile(gen, `(//Atomy Pattern Wildcard new))
 
-      target(g) :=
-        @body compile(g)
+  def(assign(gen)):
+    gen set-ivar(("@" + @name to-s) to-sym)
 
-      matches?(g) := do:
-        Atomy const-from-string(g, @name)
-        g swap
-        g kind-of
+pattern(@~(name & Word)):
+  instance-variable-pattern-code new(name text)
 
-    class(Predicate < Pattern):
-      initialize(@pattern, @test) := #ok
+pattern(@(~(name & Word))?):
+  instance-variable-pattern-code new((name text to-s + "?") to-sym)
 
-      construct(g) := do:
-        get(g)
-        @pattern construct(g)
-        @test construct(g)
-        g send(#new, 2)
-
-      (== b) :=
-        b kind-of?(Predicate) &&
-          @pattern == b pattern &&
-          @test == b test
+pattern(@(~(name & Word))!):
+  instance-variable-pattern-code new((name text to-s + "!") to-sym)
 
-      target(g) := @pattern target(g)
+kind-of-pattern-code = Atomy Code Pattern class:
+  def(initialize(@parent, @constant)) {}
 
-      matches?(g) := do:
-        mismatch = g new-label
-        done = g new-label
+  def(bytecode(gen, mod)):
+    mod compile(gen, `(//Atomy Pattern KindOf new(~@parent ~@constant)))
 
-        g dup
-        @pattern matches?(g)
-        g gif(mismatch)
+pattern(~parent ~(constant & Constant)):
+  kind-of-pattern-code new(parent, constant)
 
-        `{ ~@test } bytecode(g)
-        g send(#block, 0)
-        g swap
-        g send(#call-on-instance, 1)
-        g goto(done)
+attribute-pattern-code = Atomy Code Pattern class:
+  def(initialize(@attribute, @receiver, @arguments)) {}
 
-        mismatch set!
-        g pop
-        g push-false
+  def(bytecode(gen, mod)):
+    mod compile(gen, `(//Atomy Pattern Attribute new(~@receiver, [~*@arguments])))
 
-        done set!
+  def(assign(gen)):
+    -- [value, pattern, value, pattern]
+    gen dup-many(2)
+    -- [pattern, value, value, pattern]
+    gen swap
+    -- [pattern, pattern, value, value, pattern]
+    gen dup
+    -- [receiver, pattern, value, value, pattern]
+    gen send(.receiver, 0)
+    -- [pattern, value, receiver, value, pattern]
+    gen move-down(2)
+    -- [[arguments], value, receiver, value, pattern]
+    gen send(.arguments, 0)
+    -- [<nil block>, [arguments], value, receiver, value, pattern]
+    gen push-nil
+    -- [assign result, value, pattern]
+    gen set-call-flags(2) -- CALL_FLAG_CONCAT
+    gen send-with-splat(((@attribute to-s) + "=") to-sym, 1)
+    -- [value, pattern]
+    gen pop
 
-      deconstruct(g, locals = Hash new) :=
-        @pattern deconstruct(g, locals)
+pattern(~receiver ~(attribute & Word)):
+  attribute-pattern-code new(attribute text, receiver, [])
 
-      local-names := @pattern local-names
+pattern(~receiver (~(attribute & Word))?):
+  attribute-pattern-code new((attribute text to-s + "?") to-sym, receiver, [])
 
-      bindings := @pattern bindings
+pattern(~receiver (~(attribute & Word))!):
+  attribute-pattern-code new((attribute text to-s + "!") to-sym, receiver, [])
 
-    class(With < Pattern):
-      initialize(@expression, @pattern) := #ok
+pattern(~receiver [~*arguments]):
+  attribute-pattern-code new("[]" to-sym, receiver, arguments)
 
-      construct(g) := do:
-        get(g)
-        @expression construct(g)
-        @pattern construct(g)
-        g send(#new, 2)
+class-variable-pattern-code = Atomy Code Pattern class:
+  def(initialize(@name)) {}
 
-      (== b) :=
-        b kind-of?(With) &&
-          @expression == b expression &&
-          @pattern == b pattern
+  def(bytecode(gen, mod)):
+    mod compile(gen, `(//Atomy Pattern Wildcard new))
 
-      target(g) := Any new target(g)
+  def(assign(gen)):
+    gen dup
+    gen push-scope
+    gen swap
+    gen push-literal(("@@" + @name to-s) to-sym)
+    gen swap
+    gen send(.class-variable-set, 2)
+    gen pop
 
-      matches?(g) := do:
-        `{ ~@expression } bytecode(g)
-        g send(#block, 0)
-        g swap
-        g send(#call-on-instance, 1)
-        @pattern matches?(g)
 
-      deconstruct(g, locals = Hash new) := do:
-        `{ ~@expression } bytecode(g)
-        g send(#block, 0)
-        g swap
-        g send(#call-on-instance, 1)
-        @pattern deconstruct(g, locals)
+pattern(@@~(name & Word)):
+  class-variable-pattern-code new(name text)
 
-      local-names := @pattern local-names
+pattern(@@(~(name & Word))?):
+  class-variable-pattern-code new((name text to-s + "?") to-sym)
 
-      bindings := @pattern bindings
+pattern(@@(~(name & Word))!):
+  class-variable-pattern-code new((name text to-s + "!") to-sym)
 
-    class(And < Pattern):
-      initialize(@a, @b) := #ok
+pattern($~(name & Word)):
+  pattern(`(//Rubinius Globals[~(Atomy Code Symbol new(("$" + name text to-s) to-sym))]))
 
-      construct(g) := do:
-        get(g)
-        @a construct(g)
-        @b construct(g)
-        g send(#new, 2)
+pattern($(~(name & Word))?):
+  pattern(`(//Rubinius Globals[~(Atomy Code Symbol new(("$" + (name text to-s + "?")) to-sym))]))
 
-      (== b) :=
-        b kind-of?(And) &&
-          @a == b a &&
-          @b == b b
+pattern($(~(name & Word))!):
+  pattern(`(//Rubinius Globals[~(Atomy Code Symbol new(("$" + (name text to-s + "!")) to-sym))]))
 
-      target(g) :=
-        @a target(g)
+pattern(nil):
+  Atomy Code Pattern new(`(//Atomy Pattern Equality new(nil)))
 
-      matches?(g) := do:
-        mismatch = g new-label
-        done = g new-label
+pattern(true):
+  Atomy Code Pattern new(`(//Atomy Pattern Equality new(true)))
 
-        g dup
-        @a matches?(g)
-        g gif(mismatch)
+pattern(false):
+  Atomy Code Pattern new(`(//Atomy Pattern Equality new(false)))
 
-        @b matches?(g)
-        g dup
-        g git(done)
+pattern(~(x & StringLiteral)):
+  Atomy Code Pattern new(`(//Atomy Pattern Equality new(~x)))
 
-        mismatch set!
-        g pop
-        g push-false
+or-pattern-code = Atomy Code Pattern class:
+  def(initialize(@a, @b)) {}
 
-        done set!
+  def(bytecode(gen, mod)):
+    mod compile(gen, `(//Atomy Pattern Or new(~@a, ~@b)))
 
-      deconstruct(g, locals = Hash new) := do:
-        g dup
-        @a deconstruct(g, locals)
-        @b deconstruct(g, locals)
+  def(assign(gen)):
+    done = gen new-label
+    assign-b = gen new-label
 
-      local-names := [@a local-names + @b local-names] uniq
+    gen dup-many(2)
+    gen swap
+    gen send(.a, 0)
+    gen swap
+    gen send(.matches?, 1)
+    gen gif(assign-b)
 
-    class(Or < Pattern):
-      initialize(@a, @b) := #ok
+    gen dup-many(2)
+    gen swap
+    gen send(.a, 0)
+    gen swap
+    @a assign(gen)
+    gen pop-many(2)
 
-      construct(g) := do:
-        get(g)
-        @a construct(g)
-        @b construct(g)
-        g send(#new, 2)
+    gen goto(done)
 
-      (== b) :=
-        b kind-of?(Or) &&
-          @a == b a &&
-          @b == b b
+    assign-b set!
 
-      target(g) :=
-        @a target(g)
+    gen dup-many(2)
+    gen swap
+    gen send(.b, 0)
+    gen swap
+    @b assign(gen)
+    gen pop-many(2)
 
-      matches?(g) := do:
-        matched = g new-label
-        done = g new-label
+    done set!
 
-        g dup
-        @a matches?(g)
-        g git(matched)
+pattern(~a | ~b):
+  or-pattern-code new(pattern(a), pattern(b))
 
-        @b matches?(g)
-        g dup
-        g gif(done)
+Atomy Pattern open:
+  self class(With):
+    attr-reader(.block, .pattern)
 
-        matched set!
-        g pop
-        g push-true
+    def(initialize(@block, @pattern)) {}
 
-        done set!
+    def(matches?(val)):
+      @pattern matches?(@block call-on-object(val))
 
-      deconstruct(g, locals = #[]) := do:
-        b = g new-label
-        done = g new-label
+    def(target):
+      Object
 
-        g dup
-        g dup
-        @a matches?(g)
-        g gif(b)
+with-pattern-code = Atomy Code Pattern class:
+  def(initialize(@expr, @sub-pattern)) {}
 
-        @a deconstruct(g, locals)
-        g pop
-        g goto(done)
+  def(bytecode(gen, mod)):
+    mod compile(gen, `(//Atomy Pattern With new({ ~@expr }, ~@sub-pattern)))
 
-        b set!
-        g pop
-        @b deconstruct(g, locals)
+  def(assign(gen)):
+    -- [value, pattern, value, pattern]
+    gen dup-many(2)
 
-        done set!
+    -- [pattern, value, value, pattern]
+    gen swap
 
-      local-names := [@a local-names + @b local-names] uniq
+    -- [pattern, pattern, value, value, pattern]
+    gen dup
 
+    -- [with-block, pattern, value, value, pattern]
+    gen send(.block, 0)
 
--- base patterns
-module(Atomy::AST):
-  export:
-    Variable pattern :=
-      Atomy::Patterns::Named new $:
-        @name
-        Atomy::Patterns::Any new
+    -- [pattern, with-block, value, value, pattern]
+    gen swap
 
-    Primitive pattern :=
-      Atomy::Patterns::Match new(@value)
+    -- [with-pattern, with-block, value, value, pattern]
+    gen send(.pattern, 0)
 
-    List pattern :=
-      Atomy::Patterns::List new $:
-        @elements collect [e]: e to-pattern
+    -- [with-block, value, with-pattern, value, pattern]
+    gen move-down(2)
 
-    Constant pattern :=
-      Atomy::Patterns::Constant new(self)
+    -- [value, with-block, with-pattern, value, pattern]
+    gen swap
 
-    ScopedConstant pattern :=
-      Atomy::Patterns::Constant new(self)
+    -- [block-result, with-pattern, value, pattern]
+    gen send(.call-on-object, 1)
 
-    ToplevelConstant pattern :=
-      Atomy::Patterns::Constant new(self)
+    -- [block-result, with-pattern, value, pattern]
+    @sub-pattern assign(gen)
 
-    Quote pattern :=
-      Atomy::Patterns::Quote new(@expression)
+    -- [value, pattern]
+    gen pop-many(2)
 
-    Block pattern :=
-      Atomy::Patterns::SingletonClass new(self)
+pattern(with(~expr, ~pat)):
+  with-pattern-code new(expr, pattern(pat))
 
-    Particle pattern :=
-      Atomy::Patterns::Particle new(@name to-sym)
+Atomy Pattern open:
+  self class(Predicate):
+    def(initialize(@block)) {}
 
-    QuasiQuote pattern :=
-      Atomy::Patterns::QuasiQuote new(self)
+    def(matches?(val)):
+      @block call-on-object(val)
 
-    Send pattern :=
-      if(@block)
-        then:
-          Atomy::Patterns::Named new $:
-            @method-name
-            @block contents [0] to-pattern
+    def(target):
+      Object
+
+pattern({ ~*pred-body }):
+  Atomy Code Pattern new(`(//Atomy Pattern Predicate new({ ~*pred-body })))
+
+Atomy Pattern open:
+  self class(List):
+    attr-reader(.patterns, .splat)
+
+    def(initialize(@patterns, @splat)) {}
+
+    def(matches?(val)):
+      unless(val is-a?(Array)):
+        return(false)
+
+      when(@splat && (val size < @patterns size)):
+        return(false)
+
+      when(!@splat && (val size != @patterns size)):
+        return(false)
+
+      idx = 0
+      mismatch = false
+      @patterns each [p]:
+        unless(p matches?(val[idx])):
+          &mismatch = true
+          -- TODO: break, or return false
+
+        &idx = (idx + 1)
+
+      if(mismatch)
+        then: false
         else:
-          Atomy::Patterns::Attribute new $:
-            @receiver
-            @method-name
-            @arguments
 
-    String pattern :=
-      Atomy::Patterns::Match new(@value)
+      if(@splat)
+        then: @splat matches?(val drop(idx))
+        else: true
+
+    def(assign(scope, val)):
+      idx = 0
+      @patterns each [p]:
+        p assign(scope, val[idx])
+        &idx = (idx + 1)
+
+      when(@splat):
+        @splat assign(scope, val drop(idx))
+
+list-pattern-code = Atomy Code Pattern class:
+  def(initialize(patterns)):
+    @patterns = []
+    @splat = nil
+
+    patterns each [p]:
+      if(p splat?)
+        then: @splat = p
+        else: @patterns << p
+
+  def(bytecode(gen, mod)):
+    splat-node = (@splat || 'nil)
+    mod compile(gen, `(//Atomy Pattern List new([~*@patterns], ~splat-node)))
+
+  def(assign(gen)):
+    -- [[value], pattern, [value], pattern]
+    gen dup-many(2)
+
+    -- [pattern, [value], [value], pattern]
+    gen swap
+
+    -- [[pattern], [value], [value], pattern]
+    gen send(.patterns, 0)
+
+    @patterns each with-index [p, i]:
+      -- [pattern, [pattern], [value], [value], pattern]
+      gen shift-array
+
+      -- [[pattern], pattern, [value], [value], pattern]
+      gen swap
+
+      -- [[value], pattern, [pattern], [value], pattern]
+      gen rotate(3)
+
+      -- [value, [value], pattern, [pattern], [value], pattern]
+      gen shift-array
+
+      -- [[value], value, pattern, [pattern], [value], pattern]
+      gen swap
+
+      -- [value, pattern, [value], [pattern], [value], pattern]
+      gen move-down(2)
+
+      -- [value, pattern, [value], [pattern], [value], pattern]
+      p assign(gen)
+
+      -- [[value], [pattern], [value], pattern]
+      gen pop-many(2)
+
+      -- [[pattern], [value], [value], pattern]
+      gen swap
+
+    when(@splat):
+      -- [[remaining values], [value], pattern]
+      gen pop
+
+      -- [[value], [remaining values], pattern]
+      gen swap
+
+      -- [pattern, [remaining values], [value]]
+      gen rotate(3)
+
+      -- [pattern, pattern, [remaining values], [value]]
+      gen dup
+
+      -- [splat pattern, pattern, [remaining values], [value]]
+      gen send(.splat, 0)
+
+      -- [splatted pattern, pattern, [remaining values], [value]]
+      gen send(.pattern, 0)
+
+      -- [pattern, [remaining values], splatted pattern, [value]]
+      gen move-down(2)
+
+      -- [[remaining values], splatted pattern, [value], pattern]
+      gen move-down(3)
+
+      -- [[remaining values], splatted pattern, [value], pattern]
+      @splat assign(gen)
+
+    -- either pop the splatted values/pattern, or the two empty arrays if no splat
+    -- [[value], pattern]
+    gen pop-many(2)
+
+-- list-pattern
+pattern([~*pats]):
+  list-pattern-code new(pats collect [p]: pattern(p))
+
+match = class:
+  def(initialize(@node, @branches)) {}
+
+  def(bytecode(gen, mod)):
+    gen create-block(build-block(gen state scope, mod))
+    mod compile(gen, @node)
+    gen send(.call, 1)
+
+
+  def(build-block(scope, mod)):
+    Atomy Compiler generate(mod file) [blk]:
+      -- close over the outer scope
+      blk state scope parent = scope
+
+      blk total-args = 1
+      blk required-args = 1
+      blk arity = 1
+
+      pairs = @branches collect [`(~pat: ~*body)]:
+        [mod pattern(pat), `(do: ~*body)]
+
+      -- create a local for the value being matched against
+      blk state scope new-local(."arg:match-value")
+
+      -- [node]
+      blk push-local(0)
+
+      done = blk new-label
+
+      pairs each [pat, body]:
+        skip = blk new-label
+
+        -- [pattern, node]
+        mod compile(blk, pat)
+
+        -- [pattern, node, pattern, node]
+        blk dup-many(2)
+
+        -- [node, pattern, pattern, node]
+        blk swap
+
+        -- [bool, pattern, node]
+        blk send(.matches?, 1)
+
+        -- [pattern, node]
+        blk gif(skip)
+
+        -- [node, pattern]
+        blk swap
+
+        -- [node, pattern]
+        pat assign(blk)
+
+        -- []
+        blk pop-many(2)
+
+        -- [value]
+        mod compile(blk, body)
+
+        -- [value]
+        blk goto(done)
+
+        -- [pattern, node]
+        skip set!
+
+        -- [node]
+        blk pop
+
+      -- []
+      blk pop
+
+      -- [value]
+      blk push-nil
+
+      -- [value]
+      done set!
+
+  def(assignment-local(gen, name)):
+    var = gen state scope search-local(name)
+
+    if(var && (var depth == 0))
+      then: [var, false]
+      else: [gen state scope new-local(name) nested-reference, true]
+
+
+macro(~x match: ~*branches):
+  match new(x, branches)
+
+rescue = class:
+  def(initialize(@node, @branches)) {}
+
+  -- TODO: this is pretty barebones compared to:
+  -- https://github.com/rubinius/rubinius-ast/blob/aa5ff6260a7647a9ef1035feb66b6d4b632d4211/lib/rubinius/ast/exceptions.rb
+  -- i'd rather prove out the complexity than blindly mirror it
+  def(bytecode(gen, mod)):
+    ok = gen new-label
+    ex = gen new-label
+    rescued = gen new-label
+
+    -- []
+    gen setup-unwind(ex, 0) -- RescueType
+
+    -- [value]
+    mod compile(gen, @node)
+
+    -- [value]
+    gen pop-unwind
+
+    -- [value]
+    gen goto(ok)
+
+    ex set!
+
+    -- []
+    -- gen pop
+
+    -- [exc_state]
+    gen push-exception-state
+
+    -- [block, exc_state]
+    gen create-block(build-block(gen state scope, mod))
+
+    -- [exc, block, exc_state]
+    gen push-current-exception
+
+    -- [value, exc_state]
+    gen send(.call, 1)
+
+    -- [value, value, exc_state]
+    gen dup
+
+    -- [value, exc_state]
+    gen goto-if-not-undefined(rescued)
+
+    -- [exc_state]
+    gen pop
+
+    -- []
+    gen restore-exception-state
+
+    -- []
+    gen reraise
+
+    -- [value, exc_state]
+    rescued set!
+
+    -- [exc_state, value]
+    gen swap
+
+    -- [value]
+    gen pop
+
+    -- [value]
+    ok set!
+
+  def(build-block(scope, mod)):
+    Atomy Compiler generate(mod file) [blk]:
+      -- close over the outer scope
+      blk state scope parent = scope
+
+      blk total-args = 1
+      blk required-args = 1
+      blk arity = 1
+
+      pairs = @branches collect [`(~pat: ~*body)]:
+        [mod pattern(pat), `(do: ~*body)]
+
+      -- create a local for the value being matched against
+      blk state scope new-local(."arg:match-value")
+
+      -- [node]
+      blk push-local(0)
+
+      done = blk new-label
+
+      pairs each [pat, body]:
+        skip = blk new-label
+
+        -- [pattern, node]
+        mod compile(blk, pat)
+
+        -- [pattern, node, pattern, node]
+        blk dup-many(2)
+
+        -- [node, pattern, pattern, node]
+        blk swap
+
+        -- [bool, pattern, node]
+        blk send(.matches?, 1)
+
+        -- [pattern, node]
+        blk gif(skip)
+
+        -- [node, pattern]
+        blk swap
+
+        -- [node, pattern]
+        pat assign(blk)
+
+        -- []
+        blk pop-many(2)
+
+        -- [value]
+        mod compile(blk, body)
+
+        -- [value]
+        blk goto(done)
+
+        -- [pattern, node]
+        skip set!
+
+        -- [node]
+        blk pop
+
+      -- []
+      blk pop
+
+      -- [value]
+      blk push-undef
+
+      -- [value]
+      done set!
+
+  def(assignment-local(gen, name)):
+    var = gen state scope search-local(name)
+
+    if(var && (var depth == 0))
+      then: [var, false]
+      else: [gen state scope new-local(name) nested-reference, true]
 
-    Node pattern :=
-      raise("unknown pattern: " + self inspect)
+macro(~x rescue: ~*branches):
+  rescue new(x, branches)