- WIP: Moved some of the JS compiler machinery over to stdlib.

- DRYed the reference translation machinery.

13 files changed, 1029 insertions, 105 deletions

diff --git a/stdlib/source/lux/data/text.lux b/stdlib/source/lux/data/text.lux
index 9be782e65..29bbd98ab 100644
--- a/stdlib/source/lux/data/text.lux
+++ b/stdlib/source/lux/data/text.lux
@@ -233,11 +233,18 @@
     "" #1
     _  #0))
 
+(def: #export (prefix param subject)
+  (-> Text Text Text)
+  ("lux text concat" param subject))
+
+(def: #export (suffix param subject)
+  (-> Text Text Text)
+  ("lux text concat" subject param))
+
 (def: #export (enclose [left right] content)
   {#.doc "Surrounds the given content text with left and right side additions."}
   (-> [Text Text] Text Text)
-  (let [(^open ".") ..monoid]
-    ($_ "lux text concat" left content right)))
+  ($_ "lux text concat" left content right))
 
 (def: #export (enclose' boundary content)
   {#.doc "Surrounds the given content text with the same boundary text."}
diff --git a/stdlib/source/lux/host/js.lux b/stdlib/source/lux/host/js.lux
index e10c0395f..fbaf12fc3 100644
--- a/stdlib/source/lux/host/js.lux
+++ b/stdlib/source/lux/host/js.lux
@@ -1,5 +1,5 @@
 (.module:
-  [lux (#- Code or and function if cond undefined false true)
+  [lux (#- Code or and function if cond undefined for false true not)
    [control
     [pipe (#+ case>)]]
    [data
@@ -49,6 +49,9 @@
     [undefined "undefined"]
     [false "false"]
     [true "true"]
+    [positive-infinity "Infinity"]
+    [negative-infinity "-Infinity"]
+    [not-a-number "NaN"]
     )
 
   (def: #export boolean
@@ -102,11 +105,11 @@
         :abstraction))
 
   (def: #export (the field object)
-    (-> Var Expression Access)
-    (:abstraction (format (:representation object) "." (:representation field))))
+    (-> Text Expression Access)
+    (:abstraction (format (:representation object) "." field)))
 
   (def: #export (do method inputs object)
-    (-> Var (List Expression) Expression Access)
+    (-> Text (List Expression) Expression Access)
     (|> (format (:representation (..the method object))
                 (|> inputs
                     (list/map ..code)
@@ -116,7 +119,7 @@
         :abstraction))
 
   (def: #export object
-    (-> (List [Text Computation]) Computation)
+    (-> (List [Text Expression]) Computation)
     (|>> (list/map (.function (_ [key val])
                      (format (:representation (..string key)) ..field-separator (:representation val))))
          (text.join-with ..argument-separator)
@@ -130,9 +133,16 @@
 
   (def: #export (then pre post)
     (-> Statement Statement Statement)
-    (:abstraction (format (:representation pre) " " (:representation post))))
+    (:abstraction (format (text.suffix ..statement-suffix
+                                       (:representation pre))
+                          " "
+                          (:representation post))))
 
-  (def: block (-> Statement Text) (|>> :representation (text.enclose ["{" "}"])))
+  (def: block
+    (-> Statement Text)
+    (|>> :representation
+         (text.suffix ..statement-suffix)
+         (text.enclose ["{" "}"])))
 
   (def: #export (function name inputs body)
     (-> Var (List Var) Statement Computation)
@@ -160,7 +170,7 @@
         ..argument
         :abstraction))
 
-  (def: #export (apply function inputs)
+  (def: #export (apply/* function inputs)
     (-> Expression (List Expression) Computation)
     (|> inputs
         (list/map ..code)
@@ -169,6 +179,27 @@
         (format (:representation function))
         :abstraction))
 
+  (do-template [<apply> <arg>+ <type>+ <function>+]
+    [(`` (def: #export (<apply> function)
+           (-> Expression (~~ (template.splice <type>+)) Computation)
+           (.function (_ (~~ (template.splice <arg>+)))
+             (..apply/* function (list (~~ (template.splice <arg>+)))))))
+
+     (`` (do-template [<definition> <function>]
+           [(def: #export <definition> (<apply> (..var <function>)))]
+
+           (~~ (template.splice <function>+))))]
+
+    [apply/1 [_0] [Expression]
+     [[not-a-number? "isNaN"]]]
+
+    [apply/2 [_0 _1] [Expression Expression]
+     []]
+
+    [apply/3 [_0 _1 _2] [Expression Expression Expression]
+     []]
+    )
+
   (do-template [<name> <op>]
     [(def: #export (<name> param subject)
        (-> Expression Expression Computation)
@@ -188,12 +219,27 @@
     [/  "/"]
     [%  "%"]
 
+    [left-shift "<<"]
+    [arithmetic-right-shift ">>"]
+    [logic-right-shift ">>>"]
+
     [or      "||"]
     [and     "&&"]
+    [bit-xor "^"]
     [bit-or  "|"]
     [bit-and "&"]
     )
 
+  (do-template [<name> <prefix>]
+    [(def: #export <name>
+       (-> Expression Computation)
+       (|>> :representation (text.prefix <prefix>) ..argument :abstraction))]
+
+    [not "!"]
+    [bit-not "~"]
+    [negate "-"]
+    )
+
   (def: #export (i32 value)
     {#.doc "A 32-bit integer expression."}
     (-> Int Computation)
@@ -214,21 +260,37 @@
          ..argument
          :abstraction))
 
+  (def: #export statement
+    (-> Expression Statement)
+    (|>> :transmutation))
+
   (def: #export use-strict
     Statement
-    (:abstraction (format text.double-quote "use strict" text.double-quote ..statement-suffix)))
+    (:abstraction (format text.double-quote "use strict" text.double-quote)))
 
   (def: #export (declare name)
     (-> Var Statement)
-    (:abstraction (format "var " (:representation name) ..statement-suffix)))
+    (:abstraction (format "var " (:representation name))))
 
   (def: #export (define name value)
     (-> Var Expression Statement)
-    (:abstraction (format "var " (:representation name) " = " (:representation value) ..statement-suffix)))
+    (:abstraction (format "var " (:representation name) " = " (:representation value))))
 
   (def: #export (set name value)
     (-> Location Expression Statement)
-    (:abstraction (format (:representation name) " = " (:representation value) ..statement-suffix)))
+    (:abstraction (format (:representation name) " = " (:representation value))))
+
+  (def: #export (throw message)
+    (-> Expression Statement)
+    (:abstraction (format "throw new Error(" (:representation message) ")")))
+
+  (def: #export (return value)
+    (-> Expression Statement)
+    (:abstraction (format "return " (:representation value))))
+
+  (def: #export (delete value)
+    (-> Location Statement)
+    (:abstraction (format "delete " (:representation value))))
 
   (def: #export (if test then! else!)
     (-> Expression Statement Statement Statement)
@@ -242,17 +304,31 @@
     (:abstraction (format "while(" (:representation test) ") "
                           (..block body))))
 
-  (def: #export (throw message)
-    (-> Expression Statement)
-    (:abstraction (format "throw Error(" (:representation message) ")" ..statement-suffix)))
-
-  (def: #export (return value)
-    (-> Expression Statement)
-    (:abstraction (format "return " (:representation value) ..statement-suffix)))
+  (def: #export (try body [exception catch])
+    (-> Statement [Var Statement] Statement)
+    (:abstraction (format "try "
+                          (..block body)
+                          " catch(" (:representation exception) ") "
+                          (..block body))))
 
-  (def: #export (delete value)
-    (-> Location Statement)
-    (:abstraction (format "delete " (:representation value) ..statement-suffix)))
+  (def: #export (for var init condition update iteration)
+    (-> Var Expression Expression Statement Statement Statement)
+    (:abstraction (format "for(" (:representation (..define var init))
+                          ..statement-suffix " " (:representation condition)
+                          ..statement-suffix " " (:representation update)
+                          ")"
+                          (..block iteration))))
+
+  (do-template [<name> <js>]
+    [(def: #export <name>
+       (-> Location Statement)
+       (|>> :representation
+            (text.suffix <js>)
+            :abstraction))]
+
+    [++ "++"]
+    [-- "--"]
+    )
   )
 
 (def: #export (cond clauses else!)
diff --git a/stdlib/source/lux/tool/compiler/phase.lux b/stdlib/source/lux/tool/compiler/phase.lux
index 66abcc6cd..909b7e9e9 100644
--- a/stdlib/source/lux/tool/compiler/phase.lux
+++ b/stdlib/source/lux/tool/compiler/phase.lux
@@ -20,7 +20,7 @@
   (state.State' Error s o))
 
 (def: #export monad
-  (state.monad error.monad))
+  (state.with-state error.monad))
 
 (type: #export (Phase s i o)
   (-> i (Operation s o)))
diff --git a/stdlib/source/lux/tool/compiler/phase/translation.lux b/stdlib/source/lux/tool/compiler/phase/translation.lux
index d8522adcd..6ee7f3841 100644
--- a/stdlib/source/lux/tool/compiler/phase/translation.lux
+++ b/stdlib/source/lux/tool/compiler/phase/translation.lux
@@ -13,10 +13,10 @@
      ["." row (#+ Row)]
      ["." dictionary (#+ Dictionary)]]]
    [world
-    [file (#+ File)]]]
+    [file (#+ Path)]]]
   ["." //
-   ["." extension]]
-  [//synthesis (#+ Synthesis)])
+   [synthesis (#+ Synthesis)]
+   ["." extension]])
 
 (do-template [<name>]
   [(exception: #export (<name>)
@@ -61,7 +61,7 @@
 
 (type: #export (Buffer statement) (Row [Name statement]))
 
-(type: #export (Outputs statement) (Dictionary File (Buffer statement)))
+(type: #export (Outputs statement) (Dictionary Path (Buffer statement)))
 
 (type: #export (State anchor expression statement)
   {#context Context
@@ -216,7 +216,7 @@
 
 (def: #export (save-buffer! target)
   (All [anchor expression statement]
-    (-> File (Operation anchor expression statement Any)))
+    (-> Path (Operation anchor expression statement Any)))
   (do //.monad
     [buffer ..buffer]
     (extension.update (update@ #outputs (dictionary.put target buffer)))))
diff --git a/stdlib/source/lux/tool/compiler/phase/translation/common/reference.lux b/stdlib/source/lux/tool/compiler/phase/translation/common/reference.lux
new file mode 100644
index 000000000..5d85bfd16
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/phase/translation/common/reference.lux
@@ -0,0 +1,70 @@
+(.module:
+  [lux #*
+   [control
+    pipe]
+   [data
+    [text
+     format]]
+   [type (#+ :share)]]
+  [//
+   ["/." //
+    ["//." // ("#/." monad)
+     [synthesis (#+ Synthesis)]
+     [//
+      ["." reference (#+ Register Variable Reference)]]]]])
+
+(signature: #export (System expression)
+  (: (-> Register expression)
+     local)
+  (: (-> Register expression)
+     foreign)
+  (: (All [anchor statement]
+       (-> Variable (///.Operation anchor expression statement)))
+     variable)
+  (: (All [anchor statement]
+       (-> Name (///.Operation anchor expression statement)))
+     constant)
+  (: (All [anchor statement]
+       (-> Reference (///.Operation anchor expression statement)))
+     reference))
+
+(def: (variable-maker prefix variable)
+  (All [expression]
+    (-> Text (-> Text expression)
+        (-> Register expression)))
+  (|>> .int %i (format prefix) variable))
+
+(def: #export (system constant variable)
+  (All [expression]
+    (-> (-> Text expression) (-> Text expression)
+        (System expression)))
+  (let [local (variable-maker "l" variable)
+        foreign (variable-maker "f" variable)
+        variable (:share [expression]
+                         {(-> Text expression)
+                          variable}
+                         {(All [anchor statement]
+                            (-> Variable (///.Operation anchor expression statement)))
+                          (|>> (case> (#reference.Local register)
+                                      (local register)
+                                      
+                                      (#reference.Foreign register)
+                                      (foreign register))
+                               /////wrap)})
+        constant (:share [expression]
+                         {(-> Text expression)
+                          constant}
+                         {(All [anchor statement]
+                            (-> Name (///.Operation anchor expression statement)))
+                          (|>> ///.remember (/////map constant))})]
+    (structure
+     (def: local local)
+     (def: foreign foreign)
+     (def: variable variable)
+     (def: constant constant)
+     (def: reference
+       (|>> (case> (#reference.Constant value)
+                   (constant value)
+                   
+                   (#reference.Variable value)
+                   (variable value)))))))
diff --git a/stdlib/source/lux/tool/compiler/phase/translation/js/primitive.lux b/stdlib/source/lux/tool/compiler/phase/translation/js/primitive.lux
new file mode 100644
index 000000000..d99eec0e9
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/phase/translation/js/primitive.lux
@@ -0,0 +1,53 @@
+(.module:
+  [lux (#- int)
+   [control
+    [pipe (#+ cond> new>)]]
+   [data
+    [number
+     ["." i64]
+     ["." frac]]
+    [text
+     format]]
+   [host
+    ["_" js (#+ Expression)]]]
+  [//
+   ["//." runtime (#+ Operation)]
+   [//
+    ["//." // ("#/." monad)]]])
+
+(def: #export bit
+  (-> Bit (Operation Expression))
+  (|>> _.boolean /////wrap))
+
+(def: high
+  (-> Int Int)
+  (i64.logic-right-shift 32))
+
+(def: low
+  (-> Int Int)
+  (let [mask (dec (i64.left-shift 32 1))]
+    (|>> (i64.and mask))))
+
+(def: #export (int value)
+  (-> Int (Operation Expression))
+  (/////wrap (//runtime.i64//new (|> value ..high _.i32)
+                                 (|> value ..low _.i32))))
+
+(def: #export frac
+  (-> Frac (Operation Expression))
+  (|>> (cond> [(f/= frac.positive-infinity)]
+              [(new> _.positive-infinity [])]
+              
+              [(f/= frac.negative-infinity)]
+              [(new> _.negative-infinity [])]
+              
+              [(f/= frac.not-a-number)]
+              [(new> _.not-a-number [])]
+              
+              ## else
+              [_.number])
+       /////wrap))
+
+(def: #export text
+  (-> Text (Operation Expression))
+  (|>> _.string  /////wrap))
diff --git a/stdlib/source/lux/tool/compiler/phase/translation/js/reference.lux b/stdlib/source/lux/tool/compiler/phase/translation/js/reference.lux
new file mode 100644
index 000000000..0e4cd1489
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/phase/translation/js/reference.lux
@@ -0,0 +1,12 @@
+(.module:
+  [lux #*
+   [host
+    ["_" js (#+ Expression)]]]
+  [//
+   [//
+    [common
+     ["." reference]]]])
+
+(def: #export system
+  (reference.system (: (-> Text Expression) _.var)
+                    (: (-> Text Expression) _.var)))
diff --git a/stdlib/source/lux/tool/compiler/phase/translation/js/runtime.lux b/stdlib/source/lux/tool/compiler/phase/translation/js/runtime.lux
new file mode 100644
index 000000000..c8e86dcb5
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/phase/translation/js/runtime.lux
@@ -0,0 +1,718 @@
+(.module:
+  [lux #*
+   ["." function]
+   [control
+    [monad (#+ do)]
+    ["p" parser]]
+   [data
+    [number (#+ hex)]
+    ["." text
+     format]
+    [collection
+     ["." list ("#/." functor)]]]
+   ["." macro
+    ["." code]
+    ["s" syntax (#+ syntax:)]]
+   [host
+    ["_" js (#+ Expression Var Computation Statement)]]]
+  ["." ///
+   ["//." //
+    ["." synthesis]]]
+  )
+
+(do-template [<name> <base>]
+  [(type: #export <name>
+     (<base> Var Expression Statement))]
+
+  [Operation ///.Operation]
+  [Phase ///.Phase]
+  [Handler ///.Handler]
+  [Bundle ///.Bundle]
+  )
+
+(type: #export (Generator i)
+  (-> i Phase (Operation Expression)))
+
+(def: prefix Text "LuxRuntime")
+
+(def: #export variant-tag-field "_lux_tag")
+(def: #export variant-flag-field "_lux_flag")
+(def: #export variant-value-field "_lux_value")
+
+(def: #export unit Computation (_.string synthesis.unit))
+
+(def: #export (flag value)
+  (-> Bit Computation)
+  (if value
+    (_.string "")
+    _.null))
+
+(def: #export (variant tag last? value)
+  (-> Expression Expression Expression Computation)
+  (_.object (list [..variant-tag-field tag]
+                  [..variant-flag-field last?]
+                  [..variant-value-field value])))
+
+(def: none
+  Computation
+  (..variant (_.i32 +0) (flag #0) unit))
+
+(def: some
+  (-> Expression Computation)
+  (..variant (_.i32 +1) (flag #1)))
+
+(def: left
+  (-> Expression Computation)
+  (..variant (_.i32 +0) (flag #0)))
+
+(def: right
+  (-> Expression Computation)
+  (..variant (_.i32 +1) (flag #1)))
+
+(def: sanitize
+  (-> Text Text)
+  (|>> (text.replace-all "/" "_SL")
+       (text.replace-all "-" "_DS")
+       (text.replace-all "^" "_CR")
+       (text.replace-all "=" "_EQ")
+       (text.replace-all "+" "_PL")
+       (text.replace-all "*" "_ST")))
+
+(def: variable
+  (-> Text Var)
+  (|>> ..sanitize
+       _.var))
+
+(def: runtime-name
+  (-> Text Var)
+  (|>> ..sanitize
+       (format prefix "$")
+       _.var))
+
+(def: (feature name definition)
+  (-> Var (-> Var Expression) Statement)
+  (_.define name (definition name)))
+
+(syntax: (code-name {definition-name s.local-identifier})
+  (wrap (list (code.local-identifier (format "@" definition-name)))))
+
+(syntax: #export (with-vars {vars (s.tuple (p.some s.local-identifier))}
+                   body)
+  (wrap (list (` (let [(~+ (|> vars
+                               (list/map (function (_ var)
+                                           (list (code.local-identifier var)
+                                                 (` (_.var (~ (code.text var)))))))
+                               list.concat))]
+                   (~ body))))))
+
+(syntax: (runtime: {declaration (p.or s.local-identifier
+                                      (s.form (p.and s.local-identifier
+                                                     (p.some s.local-identifier))))}
+           code)
+  (case declaration
+    (#.Left name)
+    (macro.with-gensyms [g!_]
+      (let [nameC (code.local-identifier name)
+            code-nameC (code.local-identifier (format "@" name))
+            runtime-nameC (` (runtime-name (~ (code.text name))))]
+        (wrap (list (` (def: #export (~ nameC) Var (~ runtime-nameC)))
+                    (` (def: (~ code-nameC)
+                         Statement
+                         (..feature (~ runtime-nameC)
+                                    (function ((~ g!_) (~ nameC))
+                                      (~ code)))))))))
+    
+    (#.Right [name inputs])
+    (macro.with-gensyms [g!_]
+      (let [nameC (code.local-identifier name)
+            code-nameC (code.local-identifier (format "@" name))
+            runtime-nameC (` (runtime-name (~ (code.text name))))
+            inputsC (list/map code.local-identifier inputs)
+            inputs-typesC (list/map (function.constant (` _.Expression)) inputs)]
+        (wrap (list (` (def: #export ((~ nameC) (~+ inputsC))
+                         (-> (~+ inputs-typesC) Computation)
+                         (_.apply/* (~ runtime-nameC) (list (~+ inputsC)))))
+                    (` (def: (~ code-nameC)
+                         Statement
+                         (..feature (~ runtime-nameC)
+                                    (function ((~ g!_) (~ g!_))
+                                      (..with-vars [(~+ inputsC)]
+                                        (_.function (~ g!_) (list (~+ inputsC))
+                                          (~ code)))))))))))))
+
+(runtime: (lux//try op)
+  (with-vars [ex]
+    (_.try (_.return (_.apply/1 op ..unit))
+           [ex (_.return (|> ex (_.do "toString" (list))))])))
+
+(def: length (_.the "length"))
+
+(runtime: (lux//program-args)
+  (with-vars [process output idx]
+    (_.if (_.and (_.not (_.= (_.type-of process)
+                             _.undefined))
+                 (|> process (_.the "argv")))
+      ($_ _.then
+          (_.define output ..none)
+          (_.for idx
+                 (|> process (_.the "argv") ..length (_.- (_.i32 +1)))
+                 (_.>= (_.i32 +0) idx)
+                 (_.-- idx)
+                 (_.set output (..some (_.array (list (|> process (_.the "argv") (_.at idx))
+                                                      output)))))
+          (_.return output))
+      (_.return ..none))))
+
+(def: runtime//lux
+  Statement
+  ($_ _.then
+      @lux//try
+      @lux//program-args
+      ))
+
+(runtime: (product//left product index)
+  (with-vars [index-min-length]
+    ($_ _.then
+        (_.define index-min-length (_.+ (_.i32 +1) index))
+        (_.if (_.> index-min-length
+                   (..length product))
+          ## No need for recursion.
+          (_.return (_.at index product))
+          ## Needs recursion.
+          (_.return (product//left (_.at (|> product ..length (_.- (_.i32 +1)))
+                                         product)
+                                   (_.- (..length product)
+                                        index-min-length)))
+          ))))
+
+(runtime: (product//right product index)
+  (with-vars [index-min-length]
+    ($_ _.then
+        (_.define index-min-length (_.+ (_.i32 +1) index))
+        (_.cond (list [(_.= index-min-length
+                            (..length product))
+                       ## Last element.
+                       (_.return (_.at index product))]
+                      [(_.< index-min-length
+                            (..length product))
+                       ## Needs recursion.
+                       (_.return (product//right (_.at (|> product ..length (_.- (_.i32 +1)))
+                                                       product)
+                                                 (_.- (..length product)
+                                                      index-min-length)))])
+                ## Must slice
+                (_.return (_.do "slice" (list index) product))))))
+
+(runtime: (sum//get sum wanted-tag wants-last)
+  (let [no-match! (_.return _.null)
+        sum-tag (|> sum (_.the ..variant-tag-field))
+        sum-flag (|> sum (_.the ..variant-flag-field))
+        sum-value (|> sum (_.the ..variant-value-field))
+        is-last? (_.= ..unit sum-flag)
+        extact-match! (_.return sum-value)
+        test-recursion! (_.if is-last?
+                          ## Must recurse.
+                          (_.return (sum//get sum-value (_.- sum-tag wanted-tag) wants-last))
+                          no-match!)
+        extrac-sub-variant! (_.return (..variant (_.- wanted-tag sum-tag) sum-flag sum-value))]
+    (_.cond (list [(_.= wanted-tag sum-tag)
+                   (_.if (_.= wants-last sum-flag)
+                     extact-match!
+                     test-recursion!)]
+                  [(_.< wanted-tag sum-tag)
+                   test-recursion!]
+                  [(_.and (_.> wanted-tag sum-tag)
+                          (_.= ..unit wants-last))
+                   extrac-sub-variant!])
+            no-match!)))
+
+(def: runtime//structure
+  Statement
+  ($_ _.then
+      @product//left
+      @product//right
+      @sum//get
+      ))
+
+(def: #export i64-high-field Text "H")
+(def: #export i64-low-field Text "L")
+
+(runtime: (i64//new high low)
+  (_.return (_.object (list [..i64-high-field high]
+                            [..i64-low-field low]))))
+
+(runtime: i64//2^16
+  (_.left-shift (_.i32 +16) (_.i32 +1)))
+
+(runtime: i64//2^32
+  (_.* i64//2^16 i64//2^16))
+
+(runtime: i64//2^64
+  (_.* i64//2^32 i64//2^32))
+
+(runtime: i64//2^63
+  (|> i64//2^64 (_./ (_.i32 +2))))
+
+(runtime: (i64//unsigned-low i64)
+  (_.return (_.? (|> i64 (_.the ..i64-low-field) (_.>= (_.i32 +0)))
+                 (|> i64 (_.the ..i64-low-field))
+                 (|> i64 (_.the ..i64-low-field) (_.+ i64//2^32)))))
+
+(runtime: (i64//to-number i64)
+  (_.return (|> i64 (_.the ..i64-high-field) (_.* i64//2^32)
+                (_.+ (i64//unsigned-low i64)))))
+
+(runtime: i64//zero
+  (i64//new (_.i32 +0) (_.i32 +0)))
+
+(runtime: i64//min
+  (i64//new (_.i32 (hex "+80000000")) (_.i32 +0)))
+
+(runtime: i64//max
+  (i64//new (_.i32 (hex "+7FFFFFFF")) (_.i32 (hex "+FFFFFFFF"))))
+
+(runtime: i64//one
+  (i64//new (_.i32 +0) (_.i32 +1)))
+
+(runtime: (i64//= left right)
+  (_.return (_.and (_.= (_.the ..i64-high-field left)
+                        (_.the ..i64-high-field right))
+                   (_.= (_.the ..i64-low-field left)
+                        (_.the ..i64-low-field right)))))
+
+(runtime: (i64//+ left right)
+  (let [up-16 (_.left-shift (_.i32 +16))
+        high-16 (_.logic-right-shift (_.i32 +16))
+        low-16 (_.bit-and (_.i32 (hex "+FFFF")))
+        hh (|>> (_.the ..i64-high-field) high-16)
+        hl (|>> (_.the ..i64-high-field) low-16)
+        lh (|>> (_.the ..i64-low-field) high-16)
+        ll (|>> (_.the ..i64-low-field) low-16)]
+    (with-vars [l48 l32 l16 l00
+                r48 r32 r16 r00
+                x48 x32 x16 x00]
+      ($_ _.then
+          (_.define l48 (hh left))
+          (_.define l32 (hl left))
+          (_.define l16 (lh left))
+          (_.define l00 (ll left))
+
+          (_.define r48 (hh right))
+          (_.define r32 (hl right))
+          (_.define r16 (lh right))
+          (_.define r00 (ll right))
+
+          (_.define x00 (_.+ l00 r00))
+          (_.define x16 (high-16 x00))
+          (_.set x00 (low-16 x00))
+          (_.set x16 (|> x16 (_.+ l16) (_.+ r16)))
+          (_.define x32 (high-16 x16))
+          (_.set x16 (low-16 x16))
+          (_.set x32 (|> x32 (_.+ l32) (_.+ r32)))
+          (_.define x48 (|> (high-16 x32) (_.+ l48) (_.+ r48) low-16))
+          (_.set x32 (low-16 x32))
+
+          (_.return (i64//new (_.bit-or (up-16 x48) x32)
+                              (_.bit-or (up-16 x16) x00)))
+          ))))
+
+(do-template [<name> <op>]
+  [(runtime: (<name> left right)
+     (_.return (i64//new (<op> (_.the ..i64-high-field left)
+                               (_.the ..i64-high-field right))
+                         (<op> (_.the ..i64-low-field left)
+                               (_.the ..i64-low-field right)))))]
+
+  [i64//xor _.bit-xor]
+  [i64//or  _.bit-or]
+  [i64//and _.bit-and]
+  )
+
+(runtime: (i64//not value)
+  (_.return (i64//new (_.bit-not (_.the ..i64-high-field value))
+                      (_.bit-not (_.the ..i64-low-field value)))))
+
+(runtime: (i64//negate value)
+  (_.if (i64//= i64//min value)
+    (_.return i64//min)
+    (_.return (i64//+ (i64//not value) i64//one))))
+
+(runtime: i64//-one
+  (i64//negate i64//one))
+
+(runtime: (i64//from-number value)
+  (_.cond (list [(_.not-a-number? value)
+                 (_.return i64//zero)]
+                [(_.<= (_.negate i64//2^63) value)
+                 (_.return i64//min)]
+                [(|> value (_.+ (_.i32 +1)) (_.>= i64//2^63))
+                 (_.return i64//max)]
+                [(|> value (_.< (_.i32 +0)))
+                 (_.return (|> value _.negate i64//from-number i64//negate))])
+          (_.return (i64//new (_./ i64//2^32 value)
+                              (_.% i64//2^32 value)))))
+
+(def: (cap-shift! shift)
+  (-> Var Statement)
+  (_.set shift (|> shift (_.bit-and (_.i32 +63)))))
+
+(def: (no-shift! shift input)
+  (-> Var Var [Expression Statement])
+  [(|> shift (_.= (_.i32 +0)))
+   (_.return input)])
+
+(def: small-shift?
+  (-> Var Expression)
+  (|>> (_.< (_.i32 +32))))
+
+(runtime: (i64//left-shift input shift)
+  ($_ _.then
+      (..cap-shift! shift)
+      (_.cond (list (..no-shift! shift input)
+                    [(..small-shift? shift)
+                     (let [high (_.bit-or (|> input (_.the ..i64-high-field) (_.left-shift shift))
+                                          (|> input (_.the ..i64-low-field) (_.logic-right-shift (_.- shift (_.i32 +32)))))
+                           low (|> input (_.the ..i64-low-field) (_.left-shift shift))]
+                       (_.return (i64//new high low)))])
+              (let [high (|> input (_.the ..i64-low-field) (_.left-shift (_.- (_.i32 +32) shift)))]
+                (_.return (i64//new high (_.i32 +0)))))))
+
+(runtime: (i64//arithmetic-right-shift input shift)
+  ($_ _.then
+      (..cap-shift! shift)
+      (_.cond (list (..no-shift! shift input)
+                    [(..small-shift? shift)
+                     (let [high (|> input (_.the ..i64-high-field) (_.arithmetic-right-shift shift))
+                           low (|> input (_.the ..i64-low-field) (_.logic-right-shift shift)
+                                   (_.bit-or (|> input (_.the ..i64-high-field) (_.left-shift (_.- shift (_.i32 +32))))))]
+                       (_.return (i64//new high low)))])
+              (let [high (_.? (|> input (_.the ..i64-high-field) (_.>= (_.i32 +0)))
+                              (_.i32 +0)
+                              (_.i32 -1))
+                    low (|> input (_.the ..i64-high-field) (_.arithmetic-right-shift (_.- (_.i32 +32) shift)))]
+                (_.return (i64//new high low))))))
+
+(runtime: (i64//logic-right-shift input shift)
+  ($_ _.then
+      (..cap-shift! shift)
+      (_.cond (list (..no-shift! shift input)
+                    [(..small-shift? shift)
+                     (let [high (|> input (_.the ..i64-high-field) (_.logic-right-shift shift))
+                           low (|> input (_.the ..i64-low-field) (_.logic-right-shift shift)
+                                   (_.bit-or (|> input (_.the ..i64-high-field) (_.left-shift (_.- shift (_.i32 +32))))))]
+                       (_.return (i64//new high low)))]
+                    [(|> shift (_.= (_.i32 +32)))
+                     (_.return (i64//new (_.i32 +0) (|> input (_.the ..i64-high-field))))])
+              (_.return (i64//new (_.i32 +0)
+                                  (|> input (_.the ..i64-high-field) (_.logic-right-shift (_.- (_.i32 +32) shift))))))))
+
+(def: runtime//bit
+  Statement
+  ($_ _.then
+      @i64//and
+      @i64//or
+      @i64//xor
+      @i64//not
+      @i64//left-shift
+      @i64//arithmetic-right-shift
+      @i64//logic-right-shift
+      ))
+
+(runtime: (i64//- left right)
+  (_.return (i64//+ left (i64//negate right))))
+
+(runtime: (i64//* left right)
+  (let [negative? (|>> (_.the ..i64-high-field) (_.< (_.i32 +0)))]
+    (_.cond (list [(negative? left)
+                   (_.if (negative? right)
+                     ## Both are negative
+                     (_.return (i64//* (i64//negate left) (i64//negate right)))
+                     ## Left is negative
+                     (_.return (i64//negate (i64//* (i64//negate left) right))))]
+                  [(negative? right)
+                   ## Right is negative
+                   (_.return (i64//negate (i64//* left (i64//negate right))))])
+            ## Both are positive
+            (let [up-16 (_.left-shift (_.i32 +16))
+                  high-16 (_.logic-right-shift (_.i32 +16))
+                  low-16 (_.bit-and (_.i32 (hex "+FFFF")))
+                  hh (|>> (_.the ..i64-high-field) high-16)
+                  hl (|>> (_.the ..i64-high-field) low-16)
+                  lh (|>> (_.the ..i64-low-field) high-16)
+                  ll (|>> (_.the ..i64-low-field) low-16)]
+              (with-vars [l48 l32 l16 l00
+                          r48 r32 r16 r00
+                          x48 x32 x16 x00]
+                ($_ _.then
+                    (_.define l48 (hh left))
+                    (_.define l32 (hl left))
+                    (_.define l16 (lh left))
+                    (_.define l00 (ll left))
+
+                    (_.define r48 (hh right))
+                    (_.define r32 (hl right))
+                    (_.define r16 (lh right))
+                    (_.define r00 (ll right))
+
+                    (_.define x00 (_.* l00 r00))
+                    (_.define x16 (high-16 x00))
+                    (_.set x00 (low-16 x00))
+                    
+                    (_.set x16 (|> x16 (_.+ (_.* l16 r00))))
+                    (_.define x32 (high-16 x16)) (_.set x16 (low-16 x16))
+                    (_.set x16 (|> x16 (_.+ (_.* l00 r16))))
+                    (_.set x32 (|> x32 (_.+ (high-16 x16)))) (_.set x16 (low-16 x16))
+
+                    (_.set x32 (|> x32 (_.+ (_.* l32 r00))))
+                    (_.define x48 (high-16 x32)) (_.set x32 (low-16 x32))
+                    (_.set x32 (|> x32 (_.+ (_.* l16 r16))))
+                    (_.set x48 (|> x48 (_.+ (high-16 x32)))) (_.set x32 (low-16 x32))
+                    (_.set x32 (|> x32 (_.+ (_.* l00 r32))))
+                    (_.set x48 (|> x48 (_.+ (high-16 x32)))) (_.set x32 (low-16 x32))
+                    
+                    (_.set x48 (|> x48
+                                   (_.+ (_.* l48 r00))
+                                   (_.+ (_.* l32 r16))
+                                   (_.+ (_.* l16 r32))
+                                   (_.+ (_.* l00 r48))
+                                   low-16))
+
+                    (_.return (i64//new (_.bit-or (up-16 x48) x32)
+                                        (_.bit-or (up-16 x16) x00)))
+                    ))))))
+
+(runtime: (i64//< left right)
+  (let [negative? (|>> (_.the ..i64-high-field) (_.< (_.i32 +0)))]
+    (with-vars [-left? -right?]
+      ($_ _.then
+          (_.define -left? (negative? left))
+          (_.define -right? (negative? right))
+          (_.cond (list [(_.and -left? (_.not right))
+                         (_.return _.true)]
+                        [(_.and (_.not -left?) right)
+                         (_.return _.false)])
+                  (_.return (negative? (i64//- left right))))))))
+
+(def: (i64//<= subject param)
+  (-> Expression Expression Expression)
+  (_.or (i64//< subject param)
+        (i64//= subject param)))
+
+(runtime: (i64/// subject parameter)
+  (let [negative? (function (_ value)
+                    (i64//< value i64//zero))
+        valid-division-check [(i64//= i64//zero parameter)
+                              (_.throw (_.string "Cannot divide by zero!"))]
+        short-circuit-check [(i64//= i64//zero subject)
+                             (_.return i64//zero)]]
+    (_.cond (list valid-division-check
+                  short-circuit-check
+
+                  [(i64//= i64//min subject)
+                   (_.cond (list [(_.or (i64//= i64//one parameter)
+                                        (i64//= i64//-one parameter))
+                                  (_.return i64//min)]
+                                 [(i64//= i64//min parameter)
+                                  (_.return i64//one)])
+                           (with-vars [approximation]
+                             ($_ _.then
+                                 (_.define approximation (i64//left-shift (i64/// (i64//arithmetic-right-shift subject (_.i32 +1))
+                                                                                  parameter)
+                                                                          (_.i32 +1)))
+                                 (_.if (i64//= i64//zero approximation)
+                                   (_.return (_.? (negative? parameter)
+                                                  i64//one
+                                                  i64//-one))
+                                   (let [remainder (i64//- subject
+                                                           (i64//* parameter
+                                                                   approximation))
+                                         result (i64//+ approximation
+                                                        (i64/// remainder
+                                                                parameter))]
+                                     (_.return result))))))]
+                  [(i64//= i64//min parameter)
+                   (_.return i64//zero)]
+
+                  [(negative? subject)
+                   (_.return (_.? (negative? parameter)
+                                  (i64/// (i64//negate subject)
+                                          (i64//negate parameter))
+                                  (i64//negate (i64/// (i64//negate subject)
+                                                       parameter))))]
+
+                  [(negative? parameter)
+                   (_.return (i64//negate (i64/// subject (i64//negate parameter))))])
+            (with-vars [result remainder]
+              ($_ _.then
+                  (_.define result i64//zero)
+                  (_.define remainder subject)
+                  (_.while (i64//<= remainder parameter)
+                           (with-vars [approximate approximate-result approximate-remainder log2 delta]
+                             (let [rough-estimate (|> (i64//to-number remainder)
+                                                      (_./ (i64//to-number parameter))
+                                                      (_.apply/1 (_.var "Math.floor")))
+                                   approximate-result' (i64//from-number approximate)
+                                   approx-remainder (i64//* approximate-result parameter)]
+                               ($_ _.then
+                                   (_.define approximate (_.apply/2 (_.var "Math.max") (_.i32 +1) rough-estimate))
+                                   (_.define log2 (|> approximate
+                                                      (_.apply/1 (_.var "Math.log"))
+                                                      (_./ (_.var "Math.LN2"))
+                                                      (_.apply/1 (_.var "Math.ceil"))))
+                                   (_.define delta (_.? (_.<= (_.i32 +48) log2)
+                                                        (_.i32 +1)
+                                                        (_.apply/2 (_.var "Math.pow")
+                                                                   (_.i32 +2)
+                                                                   (_.- (_.i32 +48)
+                                                                        log2))))
+                                   (_.define approximate-result approximate-result')
+                                   (_.define approximate-remainder approx-remainder)
+                                   (_.while (_.or (negative? approximate-remainder)
+                                                  (i64//< remainder
+                                                          approximate-remainder))
+                                            ($_ _.then
+                                                (_.set approximate (_.- delta approximate))
+                                                (_.set approximate-result approximate-result')
+                                                (_.set approximate-remainder approx-remainder)))
+                                   (_.set result (i64//+ result
+                                                         (_.? (i64//= i64//zero approximate-result)
+                                                              i64//one
+                                                              approximate-result)))
+                                   (_.set remainder (i64//- remainder approximate-remainder))))))
+                  (_.return result)))
+            )))
+
+(runtime: (i64//% subject parameter)
+  (let [flat (i64//* (i64/// subject parameter)
+                     parameter)]
+    (_.return (i64//- subject flat))))
+
+(def: runtime//i64
+  Statement
+  ($_ _.then
+      @i64//2^16
+      @i64//2^32
+      @i64//2^64
+      @i64//2^63
+      @i64//unsigned-low
+      @i64//zero
+      @i64//new
+      @i64//min
+      @i64//max
+      @i64//one
+      @i64//=
+      @i64//+
+      @i64//negate
+      @i64//to-number
+      @i64//from-number
+      @i64//-
+      @i64//*
+      @i64//<
+      @i64///
+      @i64//%
+      runtime//bit
+      ))
+
+(runtime: (text//index text part start)
+  (with-vars [idx]
+    ($_ _.then
+        (_.define idx (|> text (_.do "indexOf" (list part (i64//to-number start)))))
+        (_.if (_.= (_.i32 -1) idx)
+          (_.return ..none)
+          (_.return (..some (i64//from-number idx)))))))
+
+(runtime: (text//clip text start end)
+  (let [out-of-bounds? (|>> (_.the ..i64-low-field) (_.> (..length text)))]
+    (_.if (_.or (out-of-bounds? start)
+                (out-of-bounds? end))
+      (_.return ..none)
+      (_.return (..some (|> text (_.do "substring" (list (_.the ..i64-low-field start)
+                                                         (_.the ..i64-low-field end)))))))))
+
+(runtime: (text//char text idx)
+  (with-vars [result]
+    ($_ _.then
+        (_.define result (|> text (_.do "charCodeAt" (list (_.the ..i64-low-field idx)))))
+        (_.if (_.not-a-number? result)
+          (_.return ..none)
+          (_.return (..some (i64//from-number result)))))))
+
+(def: runtime//text
+  Statement
+  ($_ _.then
+      @text//index
+      @text//clip
+      @text//char
+      ))
+
+(runtime: (io//log message)
+  (with-vars [console print]
+    (let [end! (_.return ..unit)]
+      (_.cond (list [(|> console _.type-of (_.= _.undefined) _.not
+                         (_.and (_.the "log" console)))
+                     ($_ _.then
+                         (_.statement (|> console (_.do "log" (list message))))
+                         end!)]
+                    [(|> print _.type-of (_.= _.undefined) _.not)
+                     ($_ _.then
+                         (_.statement (_.apply/1 print message))
+                         end!)])
+              end!))))
+
+(runtime: (io//error message)
+  (_.throw message))
+
+(def: runtime//io
+  Statement
+  ($_ _.then
+      @io//log
+      @io//error
+      ))
+
+(runtime: (js//get object field)
+  (with-vars [temp]
+    (_.if (|> temp (_.= _.undefined) _.not)
+      (_.return (..some temp))
+      (_.return ..none))))
+
+(runtime: (js//set object field input)
+  ($_ _.then
+      (_.set (_.at field object) input)
+      (_.return object)))
+
+(runtime: (js//delete object field)
+  ($_ _.then
+      (_.delete (_.at field object))
+      (_.return object)))
+
+(runtime: (js//call object method inputs)
+  (_.return (_.apply/2 (_.at method object) object inputs)))
+
+(def: runtime//js
+  Statement
+  ($_ _.then
+      @js//get
+      @js//set
+      @js//delete
+      @js//call
+      ))
+
+(def: runtime
+  Statement
+  ($_ _.then
+      runtime//lux
+      runtime//structure
+      runtime//i64
+      runtime//text
+      runtime//io
+      runtime//js
+      ))
+
+(def: #export artifact Text (format prefix ".js"))
+
+(def: #export translate
+  (Operation Any)
+  (///.with-buffer
+    (do ////.monad
+      [_ (///.save! ["" ..prefix] ..runtime)]
+      (///.save-buffer! ..artifact))))
diff --git a/stdlib/source/lux/tool/compiler/phase/translation/js/structure.lux b/stdlib/source/lux/tool/compiler/phase/translation/js/structure.lux
new file mode 100644
index 000000000..4949ddacf
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/phase/translation/js/structure.lux
@@ -0,0 +1,32 @@
+(.module:
+  [lux #*
+   [control
+    ["." monad (#+ do)]]
+   [host
+    ["_" js (#+ Expression)]]]
+  [//
+   ["//." runtime (#+ Generator)]
+   ["//." primitive]
+   ["//." ///
+    [analysis (#+ Variant Tuple)]
+    ["." synthesis (#+ Synthesis)]]])
+
+(def: #export (tuple elemsS+ translate)
+  (Generator (Tuple Synthesis))
+  (case elemsS+
+    #.Nil
+    (//primitive.text synthesis.unit)
+
+    (#.Cons singletonS #.Nil)
+    (translate singletonS)
+
+    _
+    (do /////.monad
+      [elemsT+ (monad.map @ translate elemsS+)]
+      (wrap (_.array elemsT+)))))
+
+(def: #export (variant [lefts right? valueS] translate)
+  (Generator (Variant Synthesis))
+  (do /////.monad
+    [valueT (translate valueS)]
+    (wrap (//runtime.variant (_.i32 (.int lefts)) (//runtime.flag right?) valueT))))
diff --git a/stdlib/source/lux/tool/compiler/phase/translation/scheme/primitive.jvm.lux b/stdlib/source/lux/tool/compiler/phase/translation/scheme/primitive.jvm.lux
index dc643bcbc..86bf44c0f 100644
--- a/stdlib/source/lux/tool/compiler/phase/translation/scheme/primitive.jvm.lux
+++ b/stdlib/source/lux/tool/compiler/phase/translation/scheme/primitive.jvm.lux
@@ -1,25 +1,19 @@
 (.module:
-  [lux (#- i64)]
+  [lux (#- i64)
+   [host
+    ["_" scheme (#+ Expression)]]]
   [//
    [runtime (#+ Operation)]
-   [// (#+ State)
-    ["//." // ("#/." monad)
-     [///
-      [host
-       ["_" scheme (#+ Expression)]]]]]])
+   [//
+    ["//." // ("#/." monad)]]])
 
-(def: #export bit
-  (-> Bit (Operation Expression))
-  (|>> _.bool /////wrap))
+(do-template [<name> <type> <code>]
+  [(def: #export <name>
+     (-> <type> (Operation Expression))
+     (|>> <code> /////wrap))]
 
-(def: #export i64
-  (-> (I64 Any) (Operation Expression))
-  (|>> .int _.int /////wrap))
-
-(def: #export f64
-  (-> Frac (Operation Expression))
-  (|>> _.float /////wrap))
-
-(def: #export text
-  (-> Text (Operation Expression))
-  (|>> _.string /////wrap))
+  [bit  Bit  _.bool]
+  [i64  Int  _.int]
+  [f64  Frac _.float]
+  [text Text _.string]
+  )
diff --git a/stdlib/source/lux/tool/compiler/phase/translation/scheme/reference.jvm.lux b/stdlib/source/lux/tool/compiler/phase/translation/scheme/reference.jvm.lux
index 161d2adea..b28cb1898 100644
--- a/stdlib/source/lux/tool/compiler/phase/translation/scheme/reference.jvm.lux
+++ b/stdlib/source/lux/tool/compiler/phase/translation/scheme/reference.jvm.lux
@@ -1,48 +1,12 @@
 (.module:
   [lux #*
-   [control
-    pipe]
-   [data
-    [text
-     format]]]
+   [host
+    ["_" scheme (#+ Expression)]]]
   [//
-   [runtime (#+ Operation)]
-   ["/." //
-    ["//." // ("#/." monad)
-     [analysis (#+ Variant Tuple)]
-     [synthesis (#+ Synthesis)]
-     [//
-      ["." reference (#+ Register Variable Reference)]
-      [//
-       [host
-        ["_" scheme (#+ Expression Global Var)]]]]]]])
+   [//
+    [common
+     ["." reference]]]])
 
-(do-template [<name> <prefix>]
-  [(def: #export <name>
-     (-> Register Var)
-     (|>> .int %i (format <prefix>) _.var))]
-
-  [local'   "l"]
-  [foreign' "f"]
-  )
-
-(def: #export variable
-  (-> Variable (Operation Var))
-  (|>> (case> (#reference.Local register)
-              (local' register)
-              
-              (#reference.Foreign register)
-              (foreign' register))
-       /////wrap))
-
-(def: #export constant
-  (-> Name (Operation Global))
-  (|>> ///.remember (/////map _.global)))
-
-(def: #export reference
-  (-> Reference (Operation Expression))
-  (|>> (case> (#reference.Constant value)
-              (..constant value)
-              
-              (#reference.Variable value)
-              (..variable value))))
+(def: #export system
+  (reference.system (: (-> Text Expression) _.global)
+                    (: (-> Text Expression) _.var)))
diff --git a/stdlib/source/lux/tool/compiler/phase/translation/scheme/runtime.jvm.lux b/stdlib/source/lux/tool/compiler/phase/translation/scheme/runtime.jvm.lux
index d254e8c7d..904f40726 100644
--- a/stdlib/source/lux/tool/compiler/phase/translation/scheme/runtime.jvm.lux
+++ b/stdlib/source/lux/tool/compiler/phase/translation/scheme/runtime.jvm.lux
@@ -1,5 +1,6 @@
 (.module:
   [lux #*
+   ["." function]
    [control
     ["p" parser ("#/." monad)]
     [monad (#+ do)]]
@@ -9,19 +10,17 @@
      format]
     [collection
      ["." list ("#/." monad)]]]
-   ["." function]
    [macro
     ["." code]
-    ["s" syntax (#+ syntax:)]]]
+    ["s" syntax (#+ syntax:)]]
+   [host
+    ["_" scheme (#+ Expression Computation Var)]]]
   ["." ///
    ["//." //
     [analysis (#+ Variant)]
     ["." synthesis]
     [//
-     ["." name]
-     [//
-      [host
-       ["_" scheme (#+ Expression Computation Var)]]]]]])
+     ["." name]]]])
 
 (do-template [<name> <base>]
   [(type: #export <name>
diff --git a/stdlib/source/lux/tool/compiler/phase/translation/scheme/structure.jvm.lux b/stdlib/source/lux/tool/compiler/phase/translation/scheme/structure.jvm.lux
index dc1b88591..aa4742fb1 100644
--- a/stdlib/source/lux/tool/compiler/phase/translation/scheme/structure.jvm.lux
+++ b/stdlib/source/lux/tool/compiler/phase/translation/scheme/structure.jvm.lux
@@ -1,16 +1,15 @@
 (.module:
   [lux #*
    [control
-    ["." monad (#+ do)]]]
+    ["." monad (#+ do)]]
+   [host
+    ["_" scheme (#+ Expression)]]]
   [//
    ["." runtime (#+ Operation Phase)]
    ["." primitive]
    ["." ///
     [analysis (#+ Variant Tuple)]
-    ["." synthesis (#+ Synthesis)]
-    [///
-     [host
-      ["_" scheme (#+ Expression)]]]]])
+    ["." synthesis (#+ Synthesis)]]])
 
 (def: #export (tuple translate elemsS+)
   (-> Phase (Tuple Synthesis) (Operation Expression))