Updates for Scheme compiler.

18 files changed, 911 insertions, 531 deletions

diff --git a/stdlib/source/lux/target/scheme.lux b/stdlib/source/lux/target/scheme.lux
index b5cf7c76d..ecdaa7324 100644
--- a/stdlib/source/lux/target/scheme.lux
+++ b/stdlib/source/lux/target/scheme.lux
@@ -1,16 +1,17 @@
 (.module:
-  [lux (#- Code Global int or and if function cond let)
+  [lux (#- Code int or and if function cond let)
    [control
     [pipe (#+ new> cond> case>)]]
    [data
-    [number
-     ["f" frac]]
     ["." text
      ["%" format (#+ format)]]
     [collection
      ["." list ("#\." functor fold)]]]
    [macro
     ["." template]]
+   [math
+    [number
+     ["f" frac]]]
    [type
     abstract]])
 
@@ -28,7 +29,6 @@
     [(abstract: #export <brand> Any)
      (`` (type: #export <type> (|> <brand> (~~ (template.splice <super>+)))))]
 
-    [Global Global' [Expression' Code]]
     [Var Var' [Expression' Code]]
     [Computation Computation' [Expression' Code]]
     )
@@ -37,9 +37,17 @@
     {#mandatory (List Var)
      #rest (Maybe Var)})
 
-  (def: #export code (-> (Code Any) Text) (|>> :representation))
+  (def: #export manual
+    (-> Text Code)
+    (|>> :abstraction))
 
-  (def: #export var (-> Text Var) (|>> :abstraction))
+  (def: #export code
+    (-> (Code Any) Text)
+    (|>> :representation))
+
+  (def: #export var
+    (-> Text Var)
+    (|>> :abstraction))
 
   (def: (arguments [mandatory rest])
     (-> Arguments (Code Any))
@@ -53,14 +61,14 @@
         (|> (format " . " (:representation rest))
             (format (|> mandatory
                         (list\map ..code)
-                        (text.join-with " ")))
+                        (text.join_with " ")))
             (text.enclose ["(" ")"])
             :abstraction))
       
       #.None
       (|> mandatory
           (list\map ..code)
-          (text.join-with " ")
+          (text.join_with " ")
           (text.enclose ["(" ")"])
           :abstraction)))
 
@@ -80,34 +88,34 @@
 
   (def: #export float
     (-> Frac Computation)
-    (|>> (cond> [(f.= f.positive-infinity)]
+    (|>> (cond> [(f.= f.positive_infinity)]
                 [(new> "+inf.0" [])]
                 
-                [(f.= f.negative-infinity)]
+                [(f.= f.negative_infinity)]
                 [(new> "-inf.0" [])]
                 
-                [f.not-a-number?]
+                [f.not_a_number?]
                 [(new> "+nan.0" [])]
                 
                 ## else
                 [%.frac])
          :abstraction))
 
-  (def: #export positive-infinity Computation (..float f.positive-infinity))
-  (def: #export negative-infinity Computation (..float f.negative-infinity))
-  (def: #export not-a-number Computation (..float f.not-a-number))
+  (def: #export positive_infinity Computation (..float f.positive_infinity))
+  (def: #export negative_infinity Computation (..float f.negative_infinity))
+  (def: #export not_a_number Computation (..float f.not_a_number))
 
   (def: sanitize
     (-> Text Text)
     (`` (|>> (~~ (template [<find> <replace>]
-                   [(text.replace-all <find> <replace>)]
+                   [(text.replace_all <find> <replace>)]
 
                    [text.alarm "\a"]
-                   [text.back-space "\b"]
+                   [text.back_space "\b"]
                    [text.tab "\t"]
-                   [text.new-line "\n"]
-                   [text.carriage-return "\r"]
-                   [text.double-quote (format "\" text.double-quote)]
+                   [text.new_line "\n"]
+                   [text.carriage_return "\r"]
+                   [text.double_quote (format "\" text.double_quote)]
                    ["\" "\\"]
                    ["|" "\|"]
                    ))
@@ -121,36 +129,32 @@
     (-> Text Computation)
     (|>> (format "'") :abstraction))
 
-  (def: #export global
-    (-> Text Global)
-    (|>> :abstraction))
-
   (def: form
     (-> (List (Code Any)) Code)
     (|>> (list\map ..code)
-         (text.join-with " ")
+         (text.join_with " ")
          (text.enclose ["(" ")"])
          :abstraction))
   
-  (def: #export (apply/* func args)
-    (-> Expression (List Expression) Computation)
+  (def: #export (apply/* args func)
+    (-> (List Expression) Expression Computation)
     (..form (#.Cons func args)))
   
   (template [<name> <function>]
-    [(def: #export <name>
+    [(def: #export (<name> members)
        (-> (List Expression) Computation)
-       (apply/* (..global <function>)))]
+       (..apply/* members (..var <function>)))]
 
     [vector/* "vector"]
     [list/*   "list"]
     )
 
-  (def: #export (apply/0 func)
+  (def: #export apply/0
     (-> Expression Computation)
-    (..apply/* func (list)))
+    (..apply/* (list)))
 
-  (template [<lux-name> <scheme-name>]
-    [(def: #export <lux-name> (apply/0 (..global <scheme-name>)))]
+  (template [<lux_name> <scheme_name>]
+    [(def: #export <lux_name> (apply/0 (..var <scheme_name>)))]
 
     [newline/0 "newline"]
     )
@@ -159,10 +163,10 @@
     [(`` (def: #export (<apply> function)
            (-> Expression (~~ (template.splice <type>+)) Computation)
            (.function (_ (~~ (template.splice <arg>+)))
-             (..apply/* function (list (~~ (template.splice <arg>+)))))))
+             (..apply/* (list (~~ (template.splice <arg>+))) function))))
 
      (`` (template [<definition> <function>]
-           [(def: #export <definition> (<apply> (..global <function>)))]
+           [(def: #export <definition> (<apply> (..var <function>)))]
 
            (~~ (template.splice <function>+))))]
 
@@ -177,12 +181,12 @@
       [car/1 "car"]
       [cdr/1 "cdr"]
       [raise/1 "raise"]
-      [error-object-message/1 "error-object-message"]
-      [make-vector/1 "make-vector"]
-      [vector-length/1 "vector-length"]
+      [error_object_message/1 "error-object-message"]
+      [make_vector/1 "make-vector"]
+      [vector_length/1 "vector-length"]
       [not/1 "not"]
-      [string-length/1 "string-length"]
-      [string-hash/1 "string-hash"]
+      [string_length/1 "string-length"]
+      [string_hash/1 "string-hash"]
       [reverse/1 "reverse"]
       [display/1 "display"]
       [exit/1 "exit"]]]
@@ -190,19 +194,19 @@
     [apply/2 [_0 _1] [Expression Expression]
      [[append/2 "append"]
       [cons/2 "cons"]
-      [make-vector/2 "make-vector"]
-      ## [vector-ref/2 "vector-ref"]
-      [list-tail/2 "list-tail"]
+      [make_vector/2 "make-vector"]
+      ## [vector_ref/2 "vector-ref"]
+      [list_tail/2 "list-tail"]
       [map/2 "map"]
-      [string-ref/2 "string-ref"]
-      [string-append/2 "string-append"]]]
+      [string_ref/2 "string-ref"]
+      [string_append/2 "string-append"]]]
 
     [apply/3 [_0 _1 _2] [Expression Expression Expression]
      [[substring/3 "substring"]
-      [vector-set!/3 "vector-set!"]]]
+      [vector_set!/3 "vector-set!"]]]
 
     [apply/5 [_0 _1 _2 _3 _4] [Expression Expression Expression Expression Expression]
-     [[vector-copy!/5 "vector-copy!"]]]
+     [[vector_copy!/5 "vector-copy!"]]]
     )
 
   ## TODO: define "vector-ref/2" like a normal apply/2 function.
@@ -218,14 +222,14 @@
   ## 1. To carry on, and then, when it's time to compile the compiler
   ## itself into Scheme, switch from 'invoke' to normal 'vector-ref'.
   ## Either way, the 'invoke' needs to go away.
-  (def: #export (vector-ref/2 vector index)
+  (def: #export (vector_ref/2 vector index)
     (-> Expression Expression Computation)
     (..form (list (..var "invoke") vector (..symbol "getRaw") index)))
 
-  (template [<lux-name> <scheme-name>]
-    [(def: #export (<lux-name> param subject)
+  (template [<lux_name> <scheme_name>]
+    [(def: #export (<lux_name> param subject)
        (-> Expression Expression Computation)
-       (..apply/2 (..global <scheme-name>) subject param))]
+       (..apply/2 (..var <scheme_name>) subject param))]
 
     [=/2   "="]
     [eq?/2 "eq?"]
@@ -244,25 +248,25 @@
     [remainder/2 "remainder"]
     [quotient/2 "quotient"]
     [mod/2 "mod"]
-    [arithmetic-shift/2 "arithmetic-shift"]
-    [bit-and/2 "bitwise-and"]
-    [bit-or/2 "bitwise-ior"]
-    [bit-xor/2 "bitwise-xor"]
+    [arithmetic_shift/2 "arithmetic-shift"]
+    [bit_and/2 "bitwise-and"]
+    [bit_or/2 "bitwise-ior"]
+    [bit_xor/2 "bitwise-xor"]
     )
 
-  (template [<lux-name> <scheme-name>]
-    [(def: #export <lux-name>
+  (template [<lux_name> <scheme_name>]
+    [(def: #export <lux_name>
        (-> (List Expression) Computation)
-       (|>> (list& (..global <scheme-name>)) ..form))]
+       (|>> (list& (..var <scheme_name>)) ..form))]
 
     [or "or"]
     [and "and"]
     )
 
-  (template [<lux-name> <scheme-name> <var> <pre>]
-    [(def: #export (<lux-name> bindings body)
+  (template [<lux_name> <scheme_name> <var> <pre>]
+    [(def: #export (<lux_name> bindings body)
        (-> (List [<var> Expression]) Expression Computation)
-       (..form (list (..global <scheme-name>)
+       (..form (list (..var <scheme_name>)
                      (|> bindings
                          (list\map (.function (_ [binding/name binding/value])
                                      (..form (list (|> binding/name <pre>)
@@ -273,18 +277,18 @@
     [let           "let"           Var       (<|)]
     [let*          "let*"          Var       (<|)]
     [letrec        "letrec"        Var       (<|)]
-    [let-values    "let-values"    Arguments ..arguments]
-    [let*-values   "let*-values"   Arguments ..arguments]
-    [letrec-values "letrec-values" Arguments ..arguments]
+    [let_values    "let-values"    Arguments ..arguments]
+    [let*_values   "let*-values"   Arguments ..arguments]
+    [letrec_values "letrec-values" Arguments ..arguments]
     )
 
   (def: #export (if test then else)
     (-> Expression Expression Expression Computation)
-    (..form (list (..global "if") test then else)))
+    (..form (list (..var "if") test then else)))
 
   (def: #export (when test then)
     (-> Expression Expression Computation)
-    (..form (list (..global "when") test then)))
+    (..form (list (..var "when") test then)))
 
   (def: #export (cond clauses else)
     (-> (List [Expression Expression]) Expression Computation)
@@ -297,31 +301,31 @@
 
   (def: #export (lambda arguments body)
     (-> Arguments Expression Computation)
-    (..form (list (..global "lambda")
+    (..form (list (..var "lambda")
                   (..arguments arguments)
                   body)))
 
-  (def: #export (define-function name arguments body)
+  (def: #export (define_function name arguments body)
     (-> Var Arguments Expression Computation)
-    (..form (list (..global "define")
+    (..form (list (..var "define")
                   (|> arguments
                       (update@ #mandatory (|>> (#.Cons name)))
                       ..arguments)
                   body)))
 
-  (def: #export (define-constant name value)
+  (def: #export (define_constant name value)
     (-> Var Expression Computation)
-    (..form (list (..global "define") name value)))
+    (..form (list (..var "define") name value)))
 
   (def: #export begin
     (-> (List Expression) Computation)
-    (|>> (#.Cons (..global "begin")) ..form))
+    (|>> (#.Cons (..var "begin")) ..form))
 
   (def: #export (set! name value)
     (-> Var Expression Computation)
-    (..form (list (..global "set!") name value)))
+    (..form (list (..var "set!") name value)))
 
-  (def: #export (with-exception-handler handler body)
+  (def: #export (with_exception_handler handler body)
     (-> Expression Expression Computation)
-    (..form (list (..global "with-exception-handler") handler body)))
+    (..form (list (..var "with-exception-handler") handler body)))
   )
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/analysis/scheme.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/analysis/scheme.lux
new file mode 100644
index 000000000..1c0a89df5
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/analysis/scheme.lux
@@ -0,0 +1,34 @@
+(.module:
+  [lux #*
+   ["." host]
+   [abstract
+    ["." monad (#+ do)]]
+   [control
+    ["<>" parser
+     ["<c>" code (#+ Parser)]]]
+   [data
+    [collection
+     ["." array (#+ Array)]
+     ["." dictionary]
+     ["." list]]]
+   ["." type
+    ["." check]]
+   ["@" target
+    ["_" scheme]]]
+  [//
+   ["/" lux (#+ custom)]
+   [//
+    ["." bundle]
+    [//
+     ["." analysis #_
+      ["#/." type]]
+     [//
+      ["." analysis (#+ Analysis Operation Phase Handler Bundle)]
+      [///
+       ["." phase]]]]]])
+
+(def: #export bundle
+  Bundle
+  (<| (bundle.prefix "scheme")
+      (|> bundle.empty
+          )))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme.lux
new file mode 100644
index 000000000..945e90e57
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme.lux
@@ -0,0 +1,17 @@
+(.module:
+  [lux #*
+   [data
+    [collection
+     ["." dictionary]]]]
+  ["." / #_
+   ["#." common]
+   ["#." host]
+   [////
+    [generation
+     [scheme
+      [runtime (#+ Bundle)]]]]])
+
+(def: #export bundle
+  Bundle
+  (dictionary.merge /common.bundle
+                    /host.bundle))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme/common.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme/common.lux
new file mode 100644
index 000000000..6a13e29bb
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme/common.lux
@@ -0,0 +1,198 @@
+(.module:
+  [lux #*
+   [abstract
+    ["." monad (#+ do)]]
+   [control
+    ["." function]
+    ["." try]
+    ["<>" parser
+     ["<s>" synthesis (#+ Parser)]]]
+   [data
+    ["." product]
+    ["." text
+     ["%" format (#+ format)]]
+    [collection
+     ["." dictionary]
+     ["." set]
+     ["." list ("#\." functor fold)]]]
+   [math
+    [number
+     ["f" frac]]]
+   ["@" target
+    ["_" scheme (#+ Expression)]]]
+  ["." //// #_
+   ["/" bundle]
+   ["/#" // #_
+    ["." extension]
+    [generation
+     [extension (#+ Nullary Unary Binary Trinary
+                    nullary unary binary trinary)]
+     ["." reference]
+     ["//" scheme #_
+      ["#." runtime (#+ Operation Phase Handler Bundle Generator)]
+      ["#." case]]]
+    [//
+     ["." synthesis (#+ %synthesis)]
+     ["." generation]
+     [///
+      ["#" phase]]]]])
+
+(def: #export (custom [parser handler])
+  (All [s]
+    (-> [(Parser s)
+         (-> Text (Generator s))]
+        Handler))
+  (function (_ extension_name phase archive input)
+    (case (<s>.run parser input)
+      (#try.Success input')
+      (handler extension_name phase archive input')
+
+      (#try.Failure error)
+      (/////.throw extension.invalid_syntax [extension_name %synthesis input]))))
+
+(template: (!unary function)
+  (|>> list _.apply/* (|> (_.constant function))))
+
+## TODO: Get rid of this ASAP
+## (def: lux::syntax_char_case!
+##   (..custom [($_ <>.and
+##                  <s>.any
+##                  <s>.any
+##                  (<>.some (<s>.tuple ($_ <>.and
+##                                          (<s>.tuple (<>.many <s>.i64))
+##                                          <s>.any))))
+##              (function (_ extension_name phase archive [input else conditionals])
+##                (do {! /////.monad}
+##                  [inputG (phase archive input)
+##                   [[context_module context_artifact] elseG] (generation.with_new_context archive
+##                                                               (phase archive else))
+##                   @input (\ ! map _.var (generation.gensym "input"))
+##                   conditionalsG (: (Operation (List [Expression Expression]))
+##                                    (monad.map ! (function (_ [chars branch])
+##                                                   (do !
+##                                                     [branchG (phase archive branch)]
+##                                                     (wrap [(|> chars
+##                                                                (list\map (|>> .int _.int (_.=== @input)))
+##                                                                (list\fold (function (_ clause total)
+##                                                                             (if (is? _.null total)
+##                                                                               clause
+##                                                                               (_.or clause total)))
+##                                                                           _.null))
+##                                                            branchG])))
+##                                               conditionals))
+##                   #let [foreigns (|> conditionals
+##                                      (list\map (|>> product.right synthesis.path/then //case.dependencies))
+##                                      (list& (//case.dependencies (synthesis.path/then else)))
+##                                      list.concat
+##                                      (set.from_list _.hash)
+##                                      set.to_list)
+##                         @expression (_.constant (reference.artifact [context_module context_artifact]))
+##                         directive (_.define_function @expression (list& (_.parameter @input) (list\map _.reference foreigns))
+##                                                      (list\fold (function (_ [test then] else)
+##                                                                   (_.if test (_.return then) else))
+##                                                                 (_.return elseG)
+##                                                                 conditionalsG))]
+##                   _ (generation.execute! directive)
+##                   _ (generation.save! (%.nat context_artifact) directive)]
+##                  (wrap (_.apply/* (list& inputG foreigns) @expression))))]))
+
+## (def: lux_procs
+##   Bundle
+##   (|> /.empty
+##       (/.install "syntax char case!" lux::syntax_char_case!)
+##       (/.install "is" (binary (product.uncurry _.===)))
+##       (/.install "try" (unary //runtime.lux//try))
+##       ))
+
+## (def: (left_shift [parameter subject])
+##   (Binary Expression)
+##   (_.bit_shl (_.% (_.int +64) parameter) subject))
+
+## (def: i64_procs
+##   Bundle
+##   (<| (/.prefix "i64")
+##       (|> /.empty
+##           (/.install "and" (binary (product.uncurry _.bit_and)))
+##           (/.install "or" (binary (product.uncurry _.bit_or)))
+##           (/.install "xor" (binary (product.uncurry _.bit_xor)))
+##           (/.install "left-shift" (binary ..left_shift))
+##           (/.install "right-shift" (binary (product.uncurry //runtime.i64//right_shift)))
+##           (/.install "=" (binary (product.uncurry _.==)))
+##           (/.install "<" (binary (product.uncurry _.<)))
+##           (/.install "+" (binary (product.uncurry //runtime.i64//+)))
+##           (/.install "-" (binary (product.uncurry //runtime.i64//-)))
+##           (/.install "*" (binary (product.uncurry //runtime.i64//*)))
+##           (/.install "/" (binary (function (_ [parameter subject])
+##                                    (_.intdiv/2 [subject parameter]))))
+##           (/.install "%" (binary (product.uncurry _.%)))
+##           (/.install "f64" (unary (_./ (_.float +1.0))))
+##           (/.install "char" (unary //runtime.i64//char))
+##           )))
+
+## (def: (f64//% [parameter subject])
+##   (Binary Expression)
+##   (_.fmod/2 [subject parameter]))
+
+## (def: (f64//encode subject)
+##   (Unary Expression)
+##   (_.number_format/2 [subject (_.int +17)]))
+
+## (def: f64_procs
+##   Bundle
+##   (<| (/.prefix "f64")
+##       (|> /.empty
+##           (/.install "=" (binary (product.uncurry _.==)))
+##           (/.install "<" (binary (product.uncurry _.<)))
+##           (/.install "+" (binary (product.uncurry _.+)))
+##           (/.install "-" (binary (product.uncurry _.-)))
+##           (/.install "*" (binary (product.uncurry _.*)))
+##           (/.install "/" (binary (product.uncurry _./)))
+##           (/.install "%" (binary ..f64//%))
+##           (/.install "i64" (unary _.intval/1))
+##           (/.install "encode" (unary ..f64//encode))
+##           (/.install "decode" (unary //runtime.f64//decode)))))
+
+## (def: (text//clip [paramO extraO subjectO])
+##   (Trinary Expression)
+##   (//runtime.text//clip paramO extraO subjectO))
+
+## (def: (text//index [startO partO textO])
+##   (Trinary Expression)
+##   (//runtime.text//index textO partO startO))
+
+## (def: text_procs
+##   Bundle
+##   (<| (/.prefix "text")
+##       (|> /.empty
+##           (/.install "=" (binary (product.uncurry _.==)))
+##           (/.install "<" (binary (product.uncurry _.<)))
+##           (/.install "concat" (binary (product.uncurry (function.flip _.concat))))
+##           (/.install "index" (trinary ..text//index))
+##           (/.install "size" (unary //runtime.text//size))
+##           (/.install "char" (binary (product.uncurry //runtime.text//char)))
+##           (/.install "clip" (trinary ..text//clip))
+##           )))
+
+## (def: io//current-time
+##   (Nullary Expression)
+##   (|>> _.time/0
+##        (_.* (_.int +1,000))))
+
+## (def: io_procs
+##   Bundle
+##   (<| (/.prefix "io")
+##       (|> /.empty
+##           (/.install "log" (unary //runtime.io//log!))
+##           (/.install "error" (unary //runtime.io//throw!))
+##           (/.install "current-time" (nullary ..io//current-time)))))
+
+(def: #export bundle
+  Bundle
+  (<| (/.prefix "lux")
+      (|> /.empty
+          ## (dictionary.merge lux_procs)
+          ## (dictionary.merge i64_procs)
+          ## (dictionary.merge f64_procs)
+          ## (dictionary.merge text_procs)
+          ## (dictionary.merge io_procs)
+          )))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme/host.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme/host.lux
new file mode 100644
index 000000000..0a05436c2
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme/host.lux
@@ -0,0 +1,39 @@
+(.module:
+  [lux #*
+   [abstract
+    ["." monad (#+ do)]]
+   [control
+    ["." function]
+    ["<>" parser
+     ["<s>" synthesis (#+ Parser)]]]
+   [data
+    [collection
+     ["." dictionary]
+     ["." list]]
+    [text
+     ["%" format (#+ format)]]]
+   [target
+    ["_" scheme (#+ Var Expression)]]]
+  ["." // #_
+   ["#." common (#+ custom)]
+   ["//#" /// #_
+    ["/" bundle]
+    ["/#" // #_
+     ["." extension]
+     [generation
+      [extension (#+ Nullary Unary Binary Trinary
+                     nullary unary binary trinary)]
+      ["." reference]
+      ["//" scheme #_
+       ["#." runtime (#+ Operation Phase Handler Bundle
+                         with_vars)]]]
+     ["/#" // #_
+      ["." generation]
+      ["//#" /// #_
+       ["#." phase]]]]]])
+
+(def: #export bundle
+  Bundle
+  (<| (/.prefix "scheme")
+      (|> /.empty
+          )))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/case.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/case.lux
index 419c0ed2f..137c72c71 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/case.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/case.lux
@@ -57,7 +57,7 @@
     [valueO (expression archive valueS)
      body! (statement expression archive bodyS)]
     (wrap ($_ _.then
-              (_.; (_.set (..register register) valueO))
+              (_.set! (..register register) valueO)
               body!))))
 
 (def: #export (if expression archive [testS thenS elseS])
@@ -121,7 +121,7 @@
 
 (def: restore!
   Statement
-  (_.; (_.set @cursor (_.array_pop/1 @savepoint))))
+  (_.set! @cursor (_.array_pop/1 @savepoint)))
 
 (def: fail! _.break)
 
@@ -135,7 +135,7 @@
   [(def: (<name> simple? idx)
      (-> Bit Nat Statement)
      ($_ _.then
-         (_.; (_.set @temp (|> idx <prep> .int _.int (//runtime.sum//get ..peek <flag>))))
+         (_.set! @temp (|> idx <prep> .int _.int (//runtime.sum//get ..peek <flag>)))
          (.if simple?
            (_.when (_.is_null/1 @temp)
                    fail!)
@@ -169,7 +169,7 @@
       (///////phase\wrap ..pop!)
 
       (#/////synthesis.Bind register)
-      (///////phase\wrap (_.; (_.set (..register register) ..peek)))
+      (///////phase\wrap (_.set! (..register register) ..peek))
 
       (#/////synthesis.Bit_Fork when thenP elseP)
       (do {! ///////phase.monad}
@@ -227,7 +227,7 @@
       (do ///////phase.monad
         [then! (recur thenP)]
         (///////phase\wrap ($_ _.then
-                               (_.; (_.set (..register register) ..peek_and_pop))
+                               (_.set! (..register register) ..peek_and_pop)
                                then!)))
 
       ## (^ (/////synthesis.!multi_pop nextP))
@@ -279,8 +279,8 @@
     [stack_init (expression archive valueS)
      pattern_matching! (pattern_matching statement expression archive pathP)]
     (wrap ($_ _.then
-              (_.; (_.set @cursor (_.array/* (list stack_init))))
-              (_.; (_.set @savepoint (_.array/* (list))))
+              (_.set! @cursor (_.array/* (list stack_init)))
+              (_.set! @savepoint (_.array/* (list)))
               pattern_matching!))))
 
 (def: #export (case statement expression archive [valueS pathP])
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/function.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/function.lux
index c6fa5687c..8dad09d37 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/function.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/function.lux
@@ -51,19 +51,19 @@
   (case inits
     #.Nil
     [($_ _.then
-         (_.; (_.set @selfL (_.closure (list (_.reference @selfL)) (list) body!)))
-         (_.; (_.set @selfG @selfL)))
+         (_.set! @selfL (_.closure (list (_.reference @selfL)) (list) body!))
+         (_.set! @selfG @selfL))
      @selfG]
 
     _
     (let [@inits (|> (list.enumeration inits)
                      (list\map (|>> product.left ..capture)))]
-      [(_.; (_.set @selfG (_.closure (list) (list\map _.parameter @inits)
-                                     ($_ _.then
-                                         (_.; (_.set @selfL (_.closure (list& (_.reference @selfL) (list\map _.reference @inits))
-                                                                       (list)
-                                                                       body!)))
-                                         (_.return @selfL)))))
+      [(_.set! @selfG (_.closure (list) (list\map _.parameter @inits)
+                                 ($_ _.then
+                                     (_.set! @selfL (_.closure (list& (_.reference @selfL) (list\map _.reference @inits))
+                                                               (list)
+                                                               body!))
+                                     (_.return @selfL))))
        (_.apply/* inits @selfG)])))
 
 (def: #export (function statement expression archive [environment arity bodyS])
@@ -82,17 +82,17 @@
            @scope (..@scope function_name)
            @selfG (_.global (///reference.artifact function_name))
            @selfL (_.var (///reference.artifact function_name))
-           initialize_self! (_.; (_.set (//case.register 0) @selfL))
+           initialize_self! (_.set! (//case.register 0) @selfL)
            initialize! (list\fold (.function (_ post pre!)
                                     ($_ _.then
                                         pre!
-                                        (_.; (_.set (..input post) (_.nth (|> post .int _.int) @curried)))))
+                                        (_.set! (..input post) (_.nth (|> post .int _.int) @curried))))
                                   initialize_self!
                                   (list.indices arity))]
      #let [[definition instantiation] (..with_closure closureG+ @selfG @selfL
                                         ($_ _.then
-                                            (_.; (_.set @num_args (_.func_num_args/0 [])))
-                                            (_.; (_.set @curried (_.func_get_args/0 [])))
+                                            (_.set! @num_args (_.func_num_args/0 []))
+                                            (_.set! @curried (_.func_get_args/0 []))
                                             (_.cond (list [(|> @num_args (_.=== arityG))
                                                            ($_ _.then
                                                                initialize!
@@ -107,7 +107,7 @@
                                                     (let [@missing (_.var "missing")]
                                                       (_.return (<| (_.closure (list (_.reference @selfL) (_.reference @curried)) (list))
                                                                     ($_ _.then
-                                                                        (_.; (_.set @missing (_.func_get_args/0 [])))
+                                                                        (_.set! @missing (_.func_get_args/0 []))
                                                                         (_.return (_.call_user_func_array/2 [@selfL (_.array_merge/+ @curried (list @missing))])))))))
                                             ))]
      _ (/////generation.execute! definition)
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/loop.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/loop.lux
index d3e91b925..41289ed58 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/loop.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/loop.lux
@@ -42,7 +42,7 @@
       list.enumeration
       (list\map (function (_ [register value])
                   (let [variable (//case.register (n.+ offset register))]
-                    (_.; (_.set variable value)))))
+                    (_.set! variable value))))
       list.reverse
       (list\fold _.then body)))
 
@@ -112,7 +112,7 @@
     [[offset @scope] /////generation.anchor
      argsO+ (monad.map ! (expression archive) argsS+)]
     (wrap ($_ _.then
-              (_.; (_.set @temp (_.array/* argsO+)))
+              (_.set! @temp (_.array/* argsO+))
               (..setup offset
                        (|> argsO+
                            list.enumeration
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/runtime.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/runtime.lux
index 651e3854f..d5e831e09 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/runtime.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/runtime.lux
@@ -55,9 +55,6 @@
 (type: #export (Generator! i)
   (-> Phase! Phase Archive i (Operation Statement)))
 
-(def: prefix
-  "LuxRuntime")
-
 (def: #export unit
   (_.string /////synthesis.unit))
 
@@ -597,8 +594,6 @@
       runtime//io
       ))
 
-(def: #export artifact ..prefix)
-
 (def: #export generate
   (Operation [Registry Output])
   (do ///////phase.monad
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/structure.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/structure.lux
index ed4fe4ae1..5f7a4e358 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/structure.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/structure.lux
@@ -16,28 +16,26 @@
     ["//#" /// #_
      ["#." phase ("#\." monad)]]]])
 
-(def: #export (tuple generate archive elemsS+)
+(def: #export (tuple expression archive elemsS+)
   (Generator (Tuple Synthesis))
   (case elemsS+
     #.Nil
     (///////phase\wrap (//primitive.text /////synthesis.unit))
 
     (#.Cons singletonS #.Nil)
-    (generate archive singletonS)
+    (expression archive singletonS)
 
     _
     (let [size (_.int (.int (list.size elemsS+)))]
       (|> elemsS+
-          (monad.map ///////phase.monad (generate archive))
-          ## (///////phase\map (|>> (list& (_.key_value (_.string //runtime.tuple_size_field) size))
-          ##                        _.array/*))
+          (monad.map ///////phase.monad (expression archive))
           (///////phase\map (|>> _.array/*
                                  (//runtime.tuple//make size)))))))
 
-(def: #export (variant generate archive [lefts right? valueS])
+(def: #export (variant expression archive [lefts right? valueS])
   (Generator (Variant Synthesis))
   (let [tag (if right?
               (inc lefts)
               lefts)]
     (///////phase\map (//runtime.variant tag right?)
-                      (generate archive valueS))))
+                      (expression archive valueS))))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme.lux
index a6e03cfd4..be476cf74 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme.lux
@@ -1,60 +1,60 @@
 (.module:
   [lux #*
    [abstract
-    [monad (#+ do)]]]
-  [/
+    [monad (#+ do)]]
+   [control
+    ["." exception (#+ exception:)]]
+   [target
+    ["_" scheme]]]
+  ["." / #_
    [runtime (#+ Phase)]
-   ["." primitive]
-   ["." structure]
-   ["." reference ("#\." system)]
-   ["." function]
-   ["." case]
-   ["." loop]
-   ["." ///
-    ["." extension]
-    [//
-     ["." synthesis]]]])
-
-(def: #export (generate synthesis)
+   ["#." primitive]
+   ["#." structure]
+   ["#." reference]
+   ["#." case]
+   ["#." loop]
+   ["#." function]
+   ["/#" // #_
+    ["#." reference]
+    ["/#" // #_
+     ["#." extension]
+     ["/#" // #_
+      [analysis (#+)]
+      ["#." synthesis]
+      ["//#" /// #_
+       ["#." phase ("#\." monad)]
+       [reference (#+)
+        [variable (#+)]]]]]]])
+
+(def: #export (generate archive synthesis)
   Phase
   (case synthesis
     (^template [<tag> <generator>]
       [(^ (<tag> value))
-       (\ ///.monad wrap (<generator> value))])
-    ([synthesis.bit  primitive.bit]
-     [synthesis.i64  primitive.i64]
-     [synthesis.f64  primitive.f64]
-     [synthesis.text primitive.text])
-
-    (^ (synthesis.variant variantS))
-    (structure.variant generate variantS)
-
-    (^ (synthesis.tuple members))
-    (structure.tuple generate members)
-
-    (#synthesis.Reference value)
-    (reference\reference value)
-
-    (^ (synthesis.branch/case case))
-    (case.case generate case)
-
-    (^ (synthesis.branch/let let))
-    (case.let generate let)
+       (//////phase\wrap (<generator> value))])
+    ([////synthesis.bit  /primitive.bit]
+     [////synthesis.i64  /primitive.i64]
+     [////synthesis.f64  /primitive.f64]
+     [////synthesis.text /primitive.text])
 
-    (^ (synthesis.branch/if if))
-    (case.if generate if)
+    (#////synthesis.Reference value)
+    (//reference.reference /reference.system archive value)
 
-    (^ (synthesis.loop/scope scope))
-    (loop.scope generate scope)
-
-    (^ (synthesis.loop/recur updates))
-    (loop.recur generate updates)
-
-    (^ (synthesis.function/abstraction abstraction))
-    (function.function generate abstraction)
-
-    (^ (synthesis.function/apply application))
-    (function.apply generate application)
-
-    (#synthesis.Extension extension)
-    (extension.apply generate extension)))
+    (^template [<tag> <generator>]
+      [(^ (<tag> value))
+       (<generator> generate archive value)])
+    ([////synthesis.variant /structure.variant]
+     [////synthesis.tuple /structure.tuple]
+     [////synthesis.branch/let /case.let]
+     [////synthesis.branch/if /case.if]
+     [////synthesis.branch/get /case.get]
+     [////synthesis.function/apply /function.apply]
+
+     [////synthesis.branch/case /case.case]
+     [////synthesis.loop/scope /loop.scope]
+     [////synthesis.loop/recur /loop.recur]
+     [////synthesis.function/abstraction /function.function])
+
+    (#////synthesis.Extension extension)
+    (///extension.apply archive generate extension)
+    ))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/case.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/case.lux
index 5f460b749..8f7d8a8b1 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/case.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/case.lux
@@ -1,43 +1,66 @@
 (.module:
   [lux (#- case let if)
    [abstract
-    [monad (#+ do)]]
-   [control
-    ["ex" exception (#+ exception:)]]
+    ["." monad (#+ do)]]
    [data
-    ["." number]
-    ["." text]
+    ["." product]
+    ["." text
+     ["%" format (#+ format)]]
     [collection
-     ["." list ("#\." functor fold)]]]
+     ["." list ("#\." functor fold)]
+     ["." set]]]
+   [math
+    [number
+     ["i" int]]]
    [target
     ["_" scheme (#+ Expression Computation Var)]]]
   ["." // #_
-   ["#." runtime (#+ Operation Phase)]
+   ["#." runtime (#+ Operation Phase Generator)]
+   ["#." reference]
    ["#." primitive]
-   ["#/" // #_
+   ["/#" // #_
     ["#." reference]
-    ["#/" // ("#\." monad)
-     ["#/" // #_
-      [reference (#+ Register)]
-      ["#." synthesis (#+ Synthesis Path)]]]]])
+    ["/#" // #_
+     ["#." synthesis #_
+      ["#/." case]]
+     ["/#" // #_
+      ["#." synthesis (#+ Member Synthesis Path)]
+      ["#." generation]
+      ["//#" /// #_
+       [reference
+        ["#." variable (#+ Register)]]
+       ["#." phase ("#\." monad)]
+       [meta
+        [archive (#+ Archive)]]]]]]])
 
 (def: #export register
-  (///reference.local _.var))
-
-(def: #export (let generate [valueS register bodyS])
-  (-> Phase [Synthesis Register Synthesis]
-      (Operation Computation))
-  (do ////.monad
-    [valueO (generate valueS)
-     bodyO (generate bodyS)]
+  (-> Register Var)
+  (|>> (///reference.local //reference.system) :assume))
+
+(def: #export capture
+  (-> Register Var)
+  (|>> (///reference.foreign //reference.system) :assume))
+
+(def: #export (let expression archive [valueS register bodyS])
+  (Generator [Synthesis Register Synthesis])
+  (do ///////phase.monad
+    [valueO (expression archive valueS)
+     bodyO (expression archive bodyS)]
     (wrap (_.let (list [(..register register) valueO])
             bodyO))))
 
-(def: #export (record-get generate valueS pathP)
-  (-> Phase Synthesis (List (Either Nat Nat))
-      (Operation Expression))
-  (do ////.monad
-    [valueO (generate valueS)]
+(def: #export (if expression archive [testS thenS elseS])
+  (Generator [Synthesis Synthesis Synthesis])
+  (do ///////phase.monad
+    [testO (expression archive testS)
+     thenO (expression archive thenS)
+     elseO (expression archive elseS)]
+    (wrap (_.if testO thenO elseO))))
+
+(def: #export (get expression archive [pathP valueS])
+  (Generator [(List Member) Synthesis])
+  (do ///////phase.monad
+    [valueO (expression archive valueS)]
     (wrap (list\fold (function (_ side source)
                        (.let [method (.case side
                                        (^template [<side> <accessor>]
@@ -47,27 +70,18 @@
                                         [#.Right //runtime.tuple//right]))]
                          (method source)))
                      valueO
-                     pathP))))
-
-(def: #export (if generate [testS thenS elseS])
-  (-> Phase [Synthesis Synthesis Synthesis]
-      (Operation Computation))
-  (do ////.monad
-    [testO (generate testS)
-     thenO (generate thenS)
-     elseO (generate elseS)]
-    (wrap (_.if testO thenO elseO))))
+                     (list.reverse pathP)))))
 
 (def: @savepoint (_.var "lux_pm_cursor_savepoint"))
 (def: @cursor (_.var "lux_pm_cursor"))
 (def: @temp (_.var "lux_pm_temp"))
-(def: @alt-error (_.var "alt_error"))
+(def: @alt_error (_.var "alt_error"))
 
 (def: (push! value var)
   (-> Expression Var Computation)
   (_.set! var (_.cons/2 value var)))
 
-(def: (push-cursor! value)
+(def: (push_cursor! value)
   (-> Expression Computation)
   (push! value @cursor))
 
@@ -75,97 +89,123 @@
   (-> Var Computation)
   (_.set! var var))
 
-(def: save-cursor!
+(def: save_cursor!
   Computation
   (push! @cursor @savepoint))
 
-(def: restore-cursor!
+(def: restore_cursor!
   Computation
   (_.set! @cursor (_.car/1 @savepoint)))
 
-(def: cursor-top
+(def: peek
   Computation
   (_.car/1 @cursor))
 
-(def: pop-cursor!
+(def: pop_cursor!
   Computation
   (pop! @cursor))
 
-(def: pm-error (_.string "PM-ERROR"))
+(def: pm_error
+  (_.string "PM-ERROR"))
 
-(def: fail-pm! (_.raise/1 pm-error))
+(def: fail!
+  (_.raise/1 pm_error))
 
-(def: (pm-catch handler)
+(def: (pm_catch handler)
   (-> Expression Computation)
-  (_.lambda [(list @alt-error) #.None]
-            (_.if (|> @alt-error (_.eqv?/2 pm-error))
+  (_.lambda [(list @alt_error) #.None]
+            (_.if (|> @alt_error (_.eqv?/2 pm_error))
               handler
-              (_.raise/1 @alt-error))))
-
-(def: (pattern-matching' generate pathP)
-  (-> Phase Path (Operation Expression))
-  (.case pathP
-    (^ (/////synthesis.path/then bodyS))
-    (generate bodyS)
-
-    #/////synthesis.Pop
-    (////\wrap pop-cursor!)
-
-    (#/////synthesis.Bind register)
-    (////\wrap (_.define-constant (..register register) ..cursor-top))
-
-    (^template [<tag> <format> <=>]
-      [(^ (<tag> value))
-       (////\wrap (_.when (|> value <format> (<=> cursor-top) _.not/1)
-                          fail-pm!))])
-    ([/////synthesis.path/bit  //primitive.bit           _.eqv?/2]
-     [/////synthesis.path/i64  (<| //primitive.i64 .int) _.=/2]
-     [/////synthesis.path/f64  //primitive.f64           _.=/2]
-     [/////synthesis.path/text //primitive.text          _.eqv?/2])
-
-    (^template [<pm> <flag> <prep>]
-      [(^ (<pm> idx))
-       (////\wrap (_.let (list [@temp (|> idx <prep> .int _.int (//runtime.sum//get cursor-top <flag>))])
-                    (_.if (_.null?/1 @temp)
-                      fail-pm!
-                      (push-cursor! @temp))))])
-    ([/////synthesis.side/left  _.nil         (<|)]
-     [/////synthesis.side/right (_.string "") inc])
-
-    (^template [<pm> <getter>]
-      [(^ (<pm> idx))
-       (////\wrap (push-cursor! (<getter> (_.int (.int idx)) cursor-top)))])
-    ([/////synthesis.member/left  //runtime.tuple//left]
-     [/////synthesis.member/right //runtime.tuple//right])
-
-    (^template [<tag> <computation>]
-      [(^ (<tag> leftP rightP))
-       (do ////.monad
-         [leftO (pattern-matching' generate leftP)
-          rightO (pattern-matching' generate rightP)]
-         (wrap <computation>))])
-    ([/////synthesis.path/seq (_.begin (list leftO
-                                             rightO))]
-     [/////synthesis.path/alt (_.with-exception-handler
-                                (pm-catch (_.begin (list restore-cursor!
-                                                         rightO)))
-                                (_.lambda [(list) #.None]
-                                          (_.begin (list save-cursor!
-                                                         leftO))))])))
-
-(def: (pattern-matching generate pathP)
-  (-> Phase Path (Operation Computation))
-  (do ////.monad
-    [pattern-matching! (pattern-matching' generate pathP)]
-    (wrap (_.with-exception-handler
-            (pm-catch (_.raise/1 (_.string "Invalid expression for pattern-matching.")))
+              (_.raise/1 @alt_error))))
+
+(def: (pattern_matching' expression archive)
+  (Generator Path)
+  (function (recur pathP)
+    (.case pathP
+      (#/////synthesis.Then bodyS)
+      (expression archive bodyS)
+
+      #/////synthesis.Pop
+      (///////phase\wrap pop_cursor!)
+
+      (#/////synthesis.Bind register)
+      (///////phase\wrap (_.define_constant (..register register) ..peek))
+
+      (#/////synthesis.Bit_Fork when thenP elseP)
+      (do {! ///////phase.monad}
+        [then! (recur thenP)
+         else! (.case elseP
+                 (#.Some elseP)
+                 (recur elseP)
+
+                 #.None
+                 (wrap ..fail!))]
+        (wrap (.if when
+                (_.if ..peek
+                  then!
+                  else!)
+                (_.if ..peek
+                  else!
+                  then!))))
+
+      (^template [<tag> <format> <=>]
+        [(<tag> cons)
+         (do {! ///////phase.monad}
+           [clauses (monad.map ! (function (_ [match then])
+                                   (do !
+                                     [then! (recur then)]
+                                     (wrap [(<=> (|> match <format>)
+                                                 ..peek)
+                                            then!])))
+                               (#.Cons cons))]
+           (wrap (_.cond clauses ..fail!)))])
+      ([#/////synthesis.I64_Fork //primitive.i64 _.=/2]
+       [#/////synthesis.F64_Fork //primitive.f64 _.=/2]
+       [#/////synthesis.Text_Fork //primitive.text _.eqv?/2])
+
+      (^template [<pm> <flag> <prep>]
+        [(^ (<pm> idx))
+         (///////phase\wrap (_.let (list [@temp (|> idx <prep> .int _.int (//runtime.sum//get ..peek <flag>))])
+                              (_.if (_.null?/1 @temp)
+                                ..fail!
+                                (push_cursor! @temp))))])
+      ([/////synthesis.side/left  _.nil         (<|)]
+       [/////synthesis.side/right (_.string "") inc])
+
+      (^template [<pm> <getter>]
+        [(^ (<pm> idx))
+         (///////phase\wrap (push_cursor! (<getter> (_.int (.int idx)) ..peek)))])
+      ([/////synthesis.member/left  //runtime.tuple//left]
+       [/////synthesis.member/right //runtime.tuple//right])
+
+      (^template [<tag> <computation>]
+        [(^ (<tag> leftP rightP))
+         (do ///////phase.monad
+           [leftO (recur leftP)
+            rightO (recur rightP)]
+           (wrap <computation>))])
+      ([/////synthesis.path/seq (_.begin (list leftO
+                                               rightO))]
+       [/////synthesis.path/alt (_.with_exception_handler
+                                  (pm_catch (_.begin (list restore_cursor!
+                                                           rightO)))
+                                  (_.lambda [(list) #.None]
+                                            (_.begin (list save_cursor!
+                                                           leftO))))]))))
+
+(def: (pattern_matching expression archive pathP)
+  (Generator Path)
+  (do ///////phase.monad
+    [pattern_matching! (pattern_matching' expression archive pathP)]
+    (wrap (_.with_exception_handler
+            (pm_catch (_.raise/1 (_.string "Invalid expression for pattern-matching.")))
             (_.lambda [(list) #.None]
-                      pattern-matching!)))))
+                      pattern_matching!)))))
 
-(def: #export (case generate [valueS pathP])
-  (-> Phase [Synthesis Path] (Operation Computation))
-  (do {! ////.monad}
-    [valueO (generate valueS)]
+(def: #export (case expression archive [valueS pathP])
+  (Generator [Synthesis Path])
+  (do {! ///////phase.monad}
+    [valueO (expression archive valueS)]
     (<| (\ ! map (_.let (list [@cursor (_.list/* (list valueO))]
                               [@savepoint (_.list/* (list))])))
-        (pattern-matching generate pathP))))
+        (pattern_matching expression archive pathP))))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/function.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/function.lux
index 97725a8f2..edcdb89b4 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/function.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/function.lux
@@ -6,50 +6,52 @@
     pipe]
    [data
     ["." product]
-    [text
+    ["." text
      ["%" format (#+ format)]]
     [collection
-     ["." list ("#\." functor)]]]
+     ["." list ("#\." functor fold)]]]
    [target
     ["_" scheme (#+ Expression Computation Var)]]]
   ["." // #_
-   ["#." runtime (#+ Operation Phase)]
+   ["#." runtime (#+ Operation Phase Generator)]
    ["#." reference]
    ["#." case]
-   ["#/" //
+   ["/#" // #_
     ["#." reference]
-    ["#/" // ("#\." monad)
-     ["#/" // #_
-      [reference (#+ Register Variable)]
+    ["//#" /// #_
+     [analysis (#+ Variant Tuple Abstraction Application Analysis)]
+     [synthesis (#+ Synthesis)]
+     ["#." generation (#+ Context)]
+     ["//#" /// #_
       [arity (#+ Arity)]
-      [analysis (#+ Variant Tuple Environment Abstraction Application Analysis)]
-      [synthesis (#+ Synthesis)]]]]])
+      ["#." phase ("#\." monad)]
+      [reference
+       [variable (#+ Register Variable)]]]]]])
 
-(def: #export (apply generate [functionS argsS+])
-  (-> Phase (Application Synthesis) (Operation Computation))
-  (do {! ////.monad}
-    [functionO (generate functionS)
-     argsO+ (monad.map ! generate argsS+)]
-    (wrap (_.apply/* functionO argsO+))))
+(def: #export (apply expression archive [functionS argsS+])
+  (Generator (Application Synthesis))
+  (do {! ///////phase.monad}
+    [functionO (expression archive functionS)
+     argsO+ (monad.map ! (expression archive) argsS+)]
+    (wrap (_.apply/* argsO+ functionO))))
 
-(def: #export capture
-  (///reference.foreign _.var))
+(def: capture
+  (-> Register Var)
+  (|>> (///reference.foreign //reference.system) :assume))
 
-(def: (with-closure function-name inits function-definition)
-  (-> Text (List Expression) Computation (Operation Computation))
-  (////\wrap
+(def: (with_closure inits function_definition)
+  (-> (List Expression) Computation (Operation Computation))
+  (///////phase\wrap
    (case inits
      #.Nil
-     function-definition
+     function_definition
 
      _
-     (let [@closure (_.var (format function-name "___CLOSURE"))]
-       (_.letrec (list [@closure
-                        (_.lambda [(|> (list.enumeration inits)
-                                  (list\map (|>> product.left ..capture)))
-                              #.None]
-                             function-definition)])
-                 (_.apply/* @closure inits))))))
+     (|> function_definition
+         (_.lambda [(|> (list.enumeration inits)
+                        (list\map (|>> product.left ..capture)))
+                    #.None])
+         (_.apply/* inits)))))
 
 (def: @curried (_.var "curried"))
 (def: @missing (_.var "missing"))
@@ -57,42 +59,42 @@
 (def: input
   (|>> inc //case.register))
 
-(def: #export (function generate [environment arity bodyS])
-  (-> Phase (Abstraction Synthesis) (Operation Computation))
-  (do {! ////.monad}
-    [[function-name bodyO] (///.with-context
+(def: #export (function expression archive [environment arity bodyS])
+  (Generator (Abstraction Synthesis))
+  (do {! ///////phase.monad}
+    [[function_name bodyO] (/////generation.with_new_context archive
                              (do !
-                               [function-name ///.context]
-                               (///.with-anchor (_.var function-name)
-                                 (generate bodyS))))
-     closureO+ (: (Operation (List Expression))
-                  (monad.map ! (\ //reference.system variable) environment))
+                               [@self (\ ! map (|>> ///reference.artifact _.var)
+                                         (/////generation.context archive))]
+                               (/////generation.with_anchor @self
+                                 (expression archive bodyS))))
+     closureO+ (monad.map ! (expression archive) environment)
      #let [arityO (|> arity .int _.int)
-           apply-poly (.function (_ args func)
-                        (_.apply/2 (_.global "apply") func args))
-           @num-args (_.var "num_args")
-           @function (_.var function-name)]]
-    (with-closure function-name closureO+
-      (_.letrec (list [@function (_.lambda [(list) (#.Some @curried)]
-                                      (_.let (list [@num-args (_.length/1 @curried)])
-                                        (<| (_.if (|> @num-args (_.=/2 arityO))
-                                              (<| (_.let (list [(//case.register 0) @function]))
-                                                  (_.let-values (list [[(|> (list.indices arity)
-                                                                            (list\map ..input))
-                                                                        #.None]
-                                                                       (_.apply/2 (_.global "apply") (_.global "values") @curried)]))
-                                                  bodyO))
-                                            (_.if (|> @num-args (_.>/2 arityO))
-                                              (let [arity-args (//runtime.slice (_.int +0) arityO @curried)
-                                                    output-func-args (//runtime.slice arityO
-                                                                                      (|> @num-args (_.-/2 arityO))
-                                                                                      @curried)]
-                                                (|> @function
-                                                    (apply-poly arity-args)
-                                                    (apply-poly output-func-args))))
-                                            ## (|> @num-args (_.</2 arityO))
-                                            (_.lambda [(list) (#.Some @missing)]
-                                                 (|> @function
-                                                     (apply-poly (_.append/2 @curried @missing)))))
-                                        ))])
-                @function))))
+           apply_poly (.function (_ args func)
+                        (_.apply/2 (_.var "apply") func args))
+           @num_args (_.var "num_args")
+           @self (_.var (///reference.artifact function_name))]]
+    (with_closure closureO+
+      (_.letrec (list [@self (_.lambda [(list) (#.Some @curried)]
+                                       (_.let (list [@num_args (_.length/1 @curried)])
+                                         (<| (_.if (|> @num_args (_.=/2 arityO))
+                                               (<| (_.let (list [(//case.register 0) @self]))
+                                                   (_.let_values (list [[(|> (list.indices arity)
+                                                                             (list\map ..input))
+                                                                         #.None]
+                                                                        (_.apply/2 (_.var "apply") (_.var "values") @curried)]))
+                                                   bodyO))
+                                             (_.if (|> @num_args (_.>/2 arityO))
+                                               (let [arity_args (//runtime.slice (_.int +0) arityO @curried)
+                                                     output_func_args (//runtime.slice arityO
+                                                                                       (|> @num_args (_.-/2 arityO))
+                                                                                       @curried)]
+                                                 (|> @self
+                                                     (apply_poly arity_args)
+                                                     (apply_poly output_func_args))))
+                                             ## (|> @num_args (_.</2 arityO))
+                                             (_.lambda [(list) (#.Some @missing)]
+                                                       (|> @self
+                                                           (apply_poly (_.append/2 @curried @missing)))))
+                                         ))])
+                @self))))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/loop.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/loop.lux
index 053a32c15..633b0da5a 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/loop.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/loop.lux
@@ -4,39 +4,60 @@
     ["." monad (#+ do)]]
    [data
     ["." product]
-    ["." text]
-    [number
-     ["n" nat]]
+    ["." text
+     ["%" format (#+ format)]]
     [collection
-     ["." list ("#\." functor)]]]
+     ["." list ("#\." functor fold)]
+     ["." set (#+ Set)]]]
+   [math
+    [number
+     ["n" nat]]]
    [target
     ["_" scheme (#+ Computation Var)]]]
   ["." // #_
-   [runtime (#+ Operation Phase)]
+   [runtime (#+ Operation Phase Generator)]
    ["#." case]
-   ["#/" //
-    ["#/" //
-     [//
-      [synthesis (#+ Scope Synthesis)]]]]])
+   ["/#" // #_
+    ["#." reference]
+    ["/#" // #_
+     [synthesis
+      ["." case]]
+     ["/#" // #_
+      ["."synthesis (#+ Scope Synthesis)]
+      ["#." generation]
+      ["//#" /// #_
+       ["#." phase]
+       [meta
+        [archive (#+ Archive)]]
+       [reference
+        [variable (#+ Register)]]]]]]])
+
+(def: @scope
+  (_.var "scope"))
 
-(def: @scope (_.var "scope"))
+(def: #export (scope expression archive [start initsS+ bodyS])
+  (Generator (Scope Synthesis))
+  (case initsS+
+    ## function/false/non-independent loop
+    #.Nil
+    (expression archive bodyS)
 
-(def: #export (scope generate [start initsS+ bodyS])
-  (-> Phase (Scope Synthesis) (Operation Computation))
-  (do {! ////.monad}
-    [initsO+ (monad.map ! generate initsS+)
-     bodyO (///.with-anchor @scope
-             (generate bodyS))]
-    (wrap (_.letrec (list [@scope (_.lambda [(|> initsS+
-                                            list.enumeration
-                                            (list\map (|>> product.left (n.+ start) //case.register)))
-                                        #.None]
-                                       bodyO)])
-                    (_.apply/* @scope initsO+)))))
+    ## true loop
+    _
+    (do {! ///////phase.monad}
+      [initsO+ (monad.map ! (expression archive) initsS+)
+       bodyO (/////generation.with_anchor @scope
+               (expression archive bodyS))]
+      (wrap (_.letrec (list [@scope (_.lambda [(|> initsS+
+                                                   list.enumeration
+                                                   (list\map (|>> product.left (n.+ start) //case.register)))
+                                               #.None]
+                                              bodyO)])
+                      (_.apply/* initsO+ @scope))))))
 
-(def: #export (recur generate argsS+)
-  (-> Phase (List Synthesis) (Operation Computation))
-  (do {! ////.monad}
-    [@scope ///.anchor
-     argsO+ (monad.map ! generate argsS+)]
-    (wrap (_.apply/* @scope argsO+))))
+(def: #export (recur expression archive argsS+)
+  (Generator (List Synthesis))
+  (do {! ///////phase.monad}
+    [@scope /////generation.anchor
+     argsO+ (monad.map ! (expression archive) argsS+)]
+    (wrap (_.apply/* argsO+ @scope))))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/reference.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/reference.lux
index b9add2e48..4e8ae26cf 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/reference.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/reference.lux
@@ -3,8 +3,10 @@
    [target
     ["_" scheme (#+ Expression)]]]
   [///
-   ["." reference]])
+   [reference (#+ System)]])
 
-(def: #export system
-  (reference.system (: (-> Text Expression) _.global)
-                    (: (-> Text Expression) _.var)))
+(structure: #export system
+  (System Expression)
+
+  (def: constant _.var)
+  (def: variable _.var))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/runtime.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/runtime.lux
index 45dcd3eb2..d6ae1cffd 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/runtime.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/runtime.lux
@@ -1,47 +1,65 @@
 (.module:
-  [lux #*
+  [lux (#- Location inc)
+   ["." meta]
    [abstract
-    [monad (#+ do)]]
+    ["." monad (#+ do)]]
    [control
     ["." function]
-    ["p" parser ("#\." monad)
-     ["s" code (#+ Parser)]]]
+    ["<>" parser
+     ["<.>" code]]]
    [data
-    [number (#+ hex)]
-    [text
-     ["%" format (#+ format)]]
+    ["." product]
+    ["." text ("#\." hash)
+     ["%" format (#+ format)]
+     ["." encoding]]
     [collection
-     ["." list ("#\." monad)]]]
-   [macro
-    ["." code]
-    [syntax (#+ syntax:)]]
-   [target
+     ["." list ("#\." functor)]
+     ["." row]]]
+   ["." macro
+    [syntax (#+ syntax:)]
+    ["." code]]
+   [math
+    [number (#+ hex)
+     ["." i64]]]
+   ["@" target
     ["_" scheme (#+ Expression Computation Var)]]]
-  ["." ///
-   ["#/" //
-    ["#/" // #_
-     [analysis (#+ Variant)]
-     ["#." name]
-     ["#." synthesis]]]])
+  ["." /// #_
+   ["#." reference]
+   ["//#" /// #_
+    [analysis (#+ Variant)]
+    ["#." synthesis (#+ Synthesis)]
+    ["#." generation]
+    ["//#" ///
+     ["#." phase]
+     [reference
+      [variable (#+ Register)]]
+     [meta
+      [archive (#+ Output Archive)
+       ["." artifact (#+ Registry)]]]]]])
+
+(def: module_id
+  0)
 
 (template [<name> <base>]
   [(type: #export <name>
      (<base> Var Expression Expression))]
 
-  [Operation ///.Operation]
-  [Phase ///.Phase]
-  [Handler ///.Handler]
-  [Bundle ///.Bundle]
+  [Operation /////generation.Operation]
+  [Phase /////generation.Phase]
+  [Handler /////generation.Handler]
+  [Bundle /////generation.Bundle]
   )
 
-(def: prefix Text "LuxRuntime")
+(type: #export (Generator i)
+  (-> Phase Archive i (Operation Expression)))
 
-(def: unit (_.string /////synthesis.unit))
+(def: unit
+  (_.string /////synthesis.unit))
 
 (def: (flag value)
   (-> Bit Computation)
   (if value
-    (_.string "")
+    ..unit
     _.nil))
 
 (def: (variant' tag last? value)
@@ -70,44 +88,54 @@
   (-> Expression Computation)
   (|>> [0 #1] ..variant))
 
-(def: declaration
-  (Parser [Text (List Text)])
-  (p.either (p.and s.local-identifier (p\wrap (list)))
-            (s.form (p.and s.local-identifier (p.some s.local-identifier)))))
-
-(syntax: (runtime: {[name args] declaration}
-           definition)
-  (let [implementation (code.local-identifier (format "@@" name))
-        runtime (format prefix "__" (/////name.normalize name))
-        @runtime (` (_.var (~ (code.text runtime))))
-        argsC+ (list\map code.local-identifier args)
-        argsLC+ (list\map (|>> /////name.normalize (format "LRV__") code.text (~) (_.var) (`))
-                          args)
-        declaration (` ((~ (code.local-identifier name))
-                        (~+ argsC+)))
-        type (` (-> (~+ (list.repeat (list.size argsC+) (` _.Expression)))
-                    _.Computation))]
-    (wrap (list (` (def: (~' #export) (~ declaration)
-                     (~ type)
-                     (~ (case argsC+
-                          #.Nil
-                          @runtime
-
-                          _
-                          (` (_.apply/* (~ @runtime) (list (~+ argsC+))))))))
-                (` (def: (~ implementation)
-                     _.Computation
-                     (~ (case argsC+
-                          #.Nil
-                          (` (_.define-constant (~ @runtime) [(list) #.None] (~ definition)))
-
-                          _
-                          (` (let [(~+ (|> (list.zip/2 argsC+ argsLC+)
-                                           (list\map (function (_ [left right])
-                                                       (list left right)))
-                                           list\join))]
-                               (_.define-function (~ @runtime) [(list (~+ argsLC+)) #.None]
-                                                  (~ definition))))))))))))
+(syntax: #export (with_vars {vars (<code>.tuple (<>.some <code>.local_identifier))}
+                   body)
+  (do {! meta.monad}
+    [ids (monad.seq ! (list.repeat (list.size vars) meta.count))]
+    (wrap (list (` (let [(~+ (|> vars
+                                 (list.zip/2 ids)
+                                 (list\map (function (_ [id var])
+                                             (list (code.local_identifier var)
+                                                   (` (_.var (~ (code.text (format "v" (%.nat id)))))))))
+                                 list.concat))]
+                     (~ body)))))))
+
+(syntax: (runtime: {declaration (<>.or <code>.local_identifier
+                                       (<code>.form (<>.and <code>.local_identifier
+                                                            (<>.some <code>.local_identifier))))}
+           code)
+  (do meta.monad
+    [runtime_id meta.count]
+    (macro.with_gensyms [g!_]
+      (let [runtime (code.local_identifier (///reference.artifact [..module_id runtime_id]))
+            runtime_name (` (_.var (~ (code.text (%.code runtime)))))]
+        (case declaration
+          (#.Left name)
+          (macro.with_gensyms [g!_]
+            (let [g!name (code.local_identifier name)]
+              (wrap (list (` (def: #export (~ g!name)
+                               Var
+                               (~ runtime_name)))
+                          
+                          (` (def: (~ (code.local_identifier (format "@" name)))
+                               _.Computation
+                               (_.define_constant (~ runtime_name) (~ code))))))))
+          
+          (#.Right [name inputs])
+          (macro.with_gensyms [g!_]
+            (let [g!name (code.local_identifier name)
+                  inputsC (list\map code.local_identifier inputs)
+                  inputs_typesC (list\map (function.constant (` _.Expression))
+                                          inputs)]
+              (wrap (list (` (def: #export ((~ g!name) (~+ inputsC))
+                               (-> (~+ inputs_typesC) _.Computation)
+                               (_.apply/* (list (~+ inputsC)) (~ runtime_name))))
+
+                          (` (def: (~ (code.local_identifier (format "@" name)))
+                               _.Computation
+                               (..with_vars [(~+ inputsC)]
+                                 (_.define_function (~ runtime_name) [(list (~+ inputsC)) #.None]
+                                                    (~ code))))))))))))))
 
 (runtime: (slice offset length list)
   (<| (_.if (_.null?/1 list)
@@ -123,113 +151,104 @@
                          (_.cdr/1 list))))
       _.nil))
 
-(syntax: #export (with-vars {vars (s.tuple (p.many s.local-identifier))}
-                   body)
-  (wrap (list (` (let [(~+ (|> vars
-                               (list\map (function (_ var)
-                                           (list (code.local-identifier var)
-                                                 (` (_.var (~ (code.text (format "LRV__" (/////name.normalize var)))))))))
-                               list\join))]
-                   (~ body))))))
-
 (runtime: (lux//try op)
-  (with-vars [error]
-    (_.with-exception-handler
+  (with_vars [error]
+    (_.with_exception_handler
       (_.lambda [(list error) #.None]
                 (..left error))
       (_.lambda [(list) #.None]
-                (..right (_.apply/* op (list ..unit)))))))
+                (..right (_.apply/* (list ..unit) op))))))
 
-(runtime: (lux//program-args program-args)
-  (with-vars [@loop @input @output]
+(runtime: (lux//program_args program_args)
+  (with_vars [@loop @input @output]
     (_.letrec (list [@loop (_.lambda [(list @input @output) #.None]
                                      (_.if (_.eqv?/2 _.nil @input)
                                        @output
                                        (_.apply/2 @loop (_.cdr/1 @input) (..some (_.vector/* (list (_.car/1 @input) @output))))))])
-              (_.apply/2 @loop (_.reverse/1 program-args) ..none))))
+              (_.apply/2 @loop (_.reverse/1 program_args) ..none))))
 
 (def: runtime//lux
   Computation
-  (_.begin (list @@lux//try
-                 @@lux//program-args)))
+  (_.begin (list @lux//try
+                 @lux//program_args)))
 
-(def: last-index
+(def: last_index
   (-> Expression Computation)
   (|>> _.length/1 (_.-/2 (_.int +1))))
 
 (runtime: (tuple//left lefts tuple)
-  (with-vars [last-index-right]
+  (with_vars [last_index_right]
     (_.begin
-     (list (_.define-constant last-index-right (..last-index tuple))
-           (_.if (_.>/2 lefts last-index-right)
+     (list (_.define_constant last_index_right (..last_index tuple))
+           (_.if (_.>/2 lefts last_index_right)
              ## No need for recursion
-             (_.vector-ref/2 tuple lefts)
+             (_.vector_ref/2 tuple lefts)
              ## Needs recursion
-             (tuple//left (_.-/2 last-index-right lefts)
-                          (_.vector-ref/2 tuple last-index-right)))))))
+             (tuple//left (_.-/2 last_index_right lefts)
+                          (_.vector_ref/2 tuple last_index_right)))))))
 
 (runtime: (tuple//right lefts tuple)
-  (with-vars [last-index-right right-index @slice]
+  (with_vars [last_index_right right_index @slice]
     (_.begin
-     (list (_.define-constant last-index-right (..last-index tuple))
-           (_.define-constant right-index (_.+/2 (_.int +1) lefts))
-           (_.cond (list [(_.=/2 last-index-right right-index)
-                          (_.vector-ref/2 tuple right-index)]
-                         [(_.>/2 last-index-right right-index)
+     (list (_.define_constant last_index_right (..last_index tuple))
+           (_.define_constant right_index (_.+/2 (_.int +1) lefts))
+           (_.cond (list [(_.=/2 last_index_right right_index)
+                          (_.vector_ref/2 tuple right_index)]
+                         [(_.>/2 last_index_right right_index)
                           ## Needs recursion.
-                          (tuple//right (_.-/2 last-index-right lefts)
-                                        (_.vector-ref/2 tuple last-index-right))])
+                          (tuple//right (_.-/2 last_index_right lefts)
+                                        (_.vector_ref/2 tuple last_index_right))])
                    (_.begin
-                    (list (_.define-constant @slice (_.make-vector/1 (_.-/2 right-index (_.length/1 tuple))))
-                          (_.vector-copy!/5 @slice (_.int +0) tuple right-index (_.length/1 tuple))
+                    (list (_.define_constant @slice (_.make_vector/1 (_.-/2 right_index (_.length/1 tuple))))
+                          (_.vector_copy!/5 @slice (_.int +0) tuple right_index (_.length/1 tuple))
                           @slice))))
      )))
 
-(runtime: (sum//get sum last? wanted-tag)
-  (with-vars [sum-tag sum-flag sum-value]
-    (let [no-match _.nil
-          is-last? (|> sum-flag (_.eqv?/2 (_.string "")))
-          test-recursion (_.if is-last?
+(runtime: (sum//get sum last? wanted_tag)
+  (with_vars [sum_tag sum_flag sum_value]
+    (let [no_match _.nil
+          is_last? (|> sum_flag (_.eqv?/2 ..unit))
+          test_recursion (_.if is_last?
                            ## Must recurse.
-                           (sum//get sum-value
+                           (sum//get sum_value
                                      last?
-                                     (|> wanted-tag (_.-/2 sum-tag)))
-                           no-match)]
-      (<| (_.let (list [sum-tag (_.car/1 sum)]
-                       [sum-value (_.cdr/1 sum)]))
-          (_.let (list [sum-flag (_.car/1 sum-value)]
-                       [sum-value (_.cdr/1 sum-value)]))
-          (_.if (|> wanted-tag (_.=/2 sum-tag))
-            (_.if (|> sum-flag (_.eqv?/2 last?))
-              sum-value
-              test-recursion))
-          (_.if (|> wanted-tag (_.>/2 sum-tag))
-            test-recursion)
-          (_.if (_.and (list (|> last? (_.eqv?/2 (_.string "")))
-                             (|> wanted-tag (_.</2 sum-tag))))
-            (variant' (|> sum-tag (_.-/2 wanted-tag)) sum-flag sum-value))
-          no-match))))
+                                     (|> wanted_tag (_.-/2 sum_tag)))
+                           no_match)]
+      (<| (_.let (list [sum_tag (_.car/1 sum)]
+                       [sum_value (_.cdr/1 sum)]))
+          (_.let (list [sum_flag (_.car/1 sum_value)]
+                       [sum_value (_.cdr/1 sum_value)]))
+          (_.if (|> wanted_tag (_.=/2 sum_tag))
+            (_.if (|> sum_flag (_.eqv?/2 last?))
+              sum_value
+              test_recursion))
+          (_.if (|> wanted_tag (_.>/2 sum_tag))
+            test_recursion)
+          (_.if (_.and (list (|> last? (_.eqv?/2 ..unit))
+                             (|> wanted_tag (_.</2 sum_tag))))
+            (variant' (|> sum_tag (_.-/2 wanted_tag)) sum_flag sum_value))
+          no_match))))
 
 (def: runtime//adt
   Computation
-  (_.begin (list @@tuple//left
-                 @@tuple//right
-                 @@sum//get)))
+  (_.begin (list @tuple//left
+                 @tuple//right
+                 @sum//get)))
 
-(runtime: (i64//logical-right-shift shift input)
+(runtime: (i64//logical_right_shift shift input)
   (_.if (_.=/2 (_.int +0) shift)
     input
     (|> input
-        (_.arithmetic-shift/2 (_.*/2 (_.int -1) shift))
-        (_.bit-and/2 (_.int (hex "+7FFFFFFFFFFFFFFF"))))))
+        (_.arithmetic_shift/2 (_.*/2 (_.int -1) shift))
+        (_.bit_and/2 (_.int (hex "+7FFFFFFFFFFFFFFF"))))))
 
 (def: runtime//bit
   Computation
-  (_.begin (list @@i64//logical-right-shift)))
+  (_.begin (list @i64//logical_right_shift)))
 
 (runtime: (frac//decode input)
-  (with-vars [@output]
-    (_.let (list [@output ((_.apply/1 (_.global "string->number")) input)])
+  (with_vars [@output]
+    (_.let (list [@output ((_.apply/1 (_.var "string->number")) input)])
       (_.if (_.and (list (_.not/1 (_.=/2 @output @output))
                          (_.not/1 (_.eqv?/2 (_.string "+nan.0") input))))
         ..none
@@ -238,19 +257,19 @@
 (def: runtime//frac
   Computation
   (_.begin
-   (list @@frac//decode)))
+   (list @frac//decode)))
 
-(runtime: (io//current-time _)
-  (|> (_.apply/* (_.global "current-second") (list))
+(runtime: (io//current_time _)
+  (|> (_.apply/0 (_.var "current-second"))
       (_.*/2 (_.int +1,000))
       _.exact/1))
 
 (def: runtime//io
-  (_.begin (list @@io//current-time)))
+  (_.begin (list @io//current_time)))
 
 (def: runtime
   Computation
-  (_.begin (list @@slice
+  (_.begin (list @slice
                  runtime//lux
                  runtime//bit
                  runtime//adt
@@ -259,9 +278,14 @@
                  )))
 
 (def: #export generate
-  (Operation Any)
-  (///.with-buffer
-    (do ////.monad
-      [_ (///.execute! ..runtime)
-       _ (///.save! ..prefix ..runtime)]
-      (///.save-buffer! ""))))
+  (Operation [Registry Output])
+  (do ///////phase.monad
+    [_ (/////generation.execute! ..runtime)
+     _ (/////generation.save! (%.nat ..module_id) ..runtime)]
+    (wrap [(|> artifact.empty
+               artifact.resource
+               product.right)
+           (row.row [(%.nat ..module_id)
+                     (|> ..runtime
+                         _.code
+                         (\ encoding.utf8 encode))])])))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/structure.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/structure.lux
index bb11d2e1f..951fa494d 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/structure.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/structure.lux
@@ -2,36 +2,38 @@
   [lux #*
    [abstract
     ["." monad (#+ do)]]
+   [data
+    [collection
+     ["." list]]]
    [target
     ["_" scheme (#+ Expression)]]]
-  [//
-   ["." runtime (#+ Operation Phase)]
-   ["." primitive]
-   ["." ///
-    [//
-     [analysis (#+ Variant Tuple)]
-     ["." synthesis (#+ Synthesis)]]]])
+  ["." // #_
+   ["#." runtime (#+ Operation Phase Generator)]
+   ["#." primitive]
+   ["///#" //// #_
+    [analysis (#+ Variant Tuple)]
+    ["#." synthesis (#+ Synthesis)]
+    ["//#" /// #_
+     ["#." phase ("#\." monad)]]]])
 
-(def: #export (tuple generate elemsS+)
-  (-> Phase (Tuple Synthesis) (Operation Expression))
+(def: #export (tuple expression archive elemsS+)
+  (Generator (Tuple Synthesis))
   (case elemsS+
     #.Nil
-    (\ ///.monad wrap (primitive.text synthesis.unit))
+    (///////phase\wrap (//primitive.text /////synthesis.unit))
 
     (#.Cons singletonS #.Nil)
-    (generate singletonS)
+    (expression archive singletonS)
 
     _
-    (do {! ///.monad}
-      [elemsT+ (monad.map ! generate elemsS+)]
-      (wrap (_.vector/* elemsT+)))))
+    (|> elemsS+
+        (monad.map ///////phase.monad (expression archive))
+        (///////phase\map _.vector/*))))
 
-(def: #export (variant generate [lefts right? valueS])
-  (-> Phase (Variant Synthesis) (Operation Expression))
-  (do ///.monad
-    [valueT (generate valueS)]
-    (wrap (runtime.variant [(if right?
-                              (inc lefts)
-                              lefts)
-                            right?
-                            valueT]))))
+(def: #export (variant expression archive [lefts right? valueS])
+  (Generator (Variant Synthesis))
+  (let [tag (if right?
+              (inc lefts)
+              lefts)]
+    (///////phase\map (|>> [tag right?] //runtime.variant)
+                      (expression archive valueS))))
diff --git a/stdlib/source/test/lux.lux b/stdlib/source/test/lux.lux
index 8d9f68922..8532b3e12 100644
--- a/stdlib/source/test/lux.lux
+++ b/stdlib/source/test/lux.lux
@@ -11,7 +11,9 @@
       [monad (#+ do)]
       [predicate (#+ Predicate)]]
      [control
-      ["." io (#+ io)]]
+      ["." io (#+ io)]
+      [concurrency
+       ["." atom (#+ Atom)]]]
      [data
       ["." name]
       [text
@@ -52,12 +54,14 @@
 (def: identity
   Test
   (do {! random.monad}
-    [self (random.unicode 1)]
+    [#let [object (: (Random (Atom Text))
+                     (\ ! map atom.atom (random.unicode 1)))]
+     self object]
     ($_ _.and
         (_.test "Every value is identical to itself."
                 (is? self self))
         (do !
-          [other (random.unicode 1)]
+          [other object]
           (_.test "Values created separately can't be identical."
                   (not (is? self other))))
         )))