Got JRuby to cooperate.

11 files changed, 278 insertions, 150 deletions

diff --git a/stdlib/source/lux/host.old.lux b/stdlib/source/lux/host.old.lux
index cc7fe53e4..3a69f2464 100644
--- a/stdlib/source/lux/host.old.lux
+++ b/stdlib/source/lux/host.old.lux
@@ -1322,7 +1322,7 @@
                         {unchecked (p.maybe s.any)})
   {#.doc (doc "Checks whether an object is an instance of a particular class."
               "Caveat emptor: Cannot check for polymorphism, so avoid using parameterized classes."
-              (case (check String "YOLO")
+              (case (check java/lang/String "YOLO")
                 (#.Some value_as_string)
                 #.None))}
   (with_gensyms [g!_ g!unchecked]
diff --git a/stdlib/source/lux/target/ruby.lux b/stdlib/source/lux/target/ruby.lux
index c170f3504..e884d6c70 100644
--- a/stdlib/source/lux/target/ruby.lux
+++ b/stdlib/source/lux/target/ruby.lux
@@ -2,17 +2,26 @@
   [lux (#- Location Code static int if cond function or and not comment)
    ["@" target]
    ["." host]
+   [abstract
+    [equivalence (#+ Equivalence)]
+    [hash (#+ Hash)]
+    ["." enum]]
    [control
-    [pipe (#+ case> cond> new>)]]
+    [pipe (#+ case> cond> new>)]
+    [parser
+     ["<.>" code]]]
    [data
     ["." text
      ["%" format (#+ format)]]
     [collection
      ["." list ("#\." functor fold)]]]
    [macro
-    ["." template]]
+    [syntax (#+ syntax:)]
+    ["." template]
+    ["." code]]
    [math
     [number
+     ["n" nat]
      ["f" frac]]]
    [type
     abstract]])
@@ -39,6 +48,18 @@
 (abstract: #export (Code brand)
   Text
 
+  (structure: #export code_equivalence
+    (All [brand] (Equivalence (Code brand)))
+
+    (def: (= reference subject)
+      (\ text.equivalence = (:representation reference) (:representation subject))))
+
+  (structure: #export code_hash
+    (All [brand] (Hash (Code brand)))
+
+    (def: &equivalence ..code_equivalence)
+    (def: hash (|>> :representation (\ text.hash hash))))
+
   (def: #export manual
     (-> Text Code)
     (|>> :abstraction))
@@ -201,6 +222,15 @@
         (format (:representation func))
         :abstraction))
 
+  (def: #export (apply_lambda/* args lambda)
+    (-> (List Expression) Expression Computation)
+    (|> args
+        (list\map (|>> :representation))
+        (text.join_with ..input_separator)
+        (text.enclose ["[" "]"])
+        (format (:representation lambda))
+        :abstraction))
+
   (def: #export (the field object)
     (-> Text Expression Access)
     (:abstraction (format (:representation object) "." field)))
@@ -251,9 +281,9 @@
     (<| :abstraction
         ..block
         (format "if " (:representation test)
-                text.new_line (..nest (:representation then!))
+                (..nest (:representation then!))
                 text.new_line "else"
-                text.new_line (..nest (:representation else!)))))
+                (..nest (:representation else!)))))
 
   (template [<name> <block>]
     [(def: #export (<name> test then!)
@@ -261,7 +291,7 @@
        (<| :abstraction
            ..block
            (format <block> " " (:representation test)
-                   text.new_line (..nest (:representation then!)))))]
+                   (..nest (:representation then!)))))]
 
     [when "if"]
     [while "while"]
@@ -274,7 +304,7 @@
         (format "for " (:representation var)
                 " in " (:representation array)
                 " do "
-                text.new_line (..nest (:representation iteration!)))))
+                (..nest (:representation iteration!)))))
 
   (type: #export Rescue
     {#classes (List Text)
@@ -285,13 +315,12 @@
     (-> Statement (List Rescue) Statement)
     (<| :abstraction
         ..block
-        (format "begin"
-                text.new_line (:representation body!)
+        (format "begin" (..nest (:representation body!))
                 (|> rescues
                     (list\map (.function (_ [classes exception rescue])
                                 (format text.new_line "rescue " (text.join_with ..input_separator classes)
                                         " => " (:representation exception)
-                                        text.new_line (..nest (:representation rescue)))))
+                                        (..nest (:representation rescue)))))
                     (text.join_with text.new_line)))))
 
   (def: #export (return value)
@@ -315,7 +344,7 @@
     )
 
   (def: #export (function name args body!)
-    (-> LVar (List Var) Statement Statement)
+    (-> LVar (List LVar) Statement Statement)
     (<| :abstraction
         ..block
         (format "def " (:representation name)
@@ -323,7 +352,7 @@
                     (list\map (|>> :representation))
                     (text.join_with ..input_separator)
                     (text.enclose ["(" ")"]))
-                text.new_line (:representation body!))))
+                (..nest (:representation body!)))))
 
   (def: #export (lambda name args body!)
     (-> (Maybe LVar) (List Var) Statement Literal)
@@ -392,3 +421,38 @@
                (..if test then! next!))
              else!
              (list.reverse clauses)))
+
+(syntax: (arity_inputs {arity <code>.nat})
+  (wrap (case arity
+          0 (.list)
+          _ (|> (dec arity)
+                (enum.range n.enum 0)
+                (list\map (|>> %.nat code.local_identifier))))))
+
+(syntax: (arity_types {arity <code>.nat})
+  (wrap (list.repeat arity (` ..Expression))))
+
+(template [<arity> <function>+]
+  [(with_expansions [<apply> (template.identifier ["apply/" <arity>])
+                     <inputs> (arity_inputs <arity>)
+                     <types> (arity_types <arity>)
+                     <definitions> (template.splice <function>+)]
+     (def: #export (<apply> function <inputs>)
+       (-> Expression <types> Computation)
+       (..apply/* (.list <inputs>) function))
+
+     (template [<function>]
+       [(`` (def: #export (~~ (template.identifier [<function> "/" <arity>]))
+              (<apply> (..local <function>))))]
+
+       <definitions>))]
+
+  [1
+   [["print"]]]
+
+  [2
+   []]
+
+  [3
+   []]
+  )
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/ruby/common.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/ruby/common.lux
index d43f3833a..9f04b35d2 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/ruby/common.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/ruby/common.lux
@@ -71,22 +71,17 @@
           (/.install "=" (binary (product.uncurry _.=)))
           (/.install "+" (binary (..keep_i64 (product.uncurry _.+))))
           (/.install "-" (binary (..keep_i64 (product.uncurry _.-))))
-          )))
-
-(def: int_procs
-  Bundle
-  (<| (/.prefix "int")
-      (|> /.empty
           (/.install "<" (binary (product.uncurry _.<)))
           (/.install "*" (binary (..keep_i64 (product.uncurry _.*))))
           (/.install "/" (binary (product.uncurry _./)))
           (/.install "%" (binary (product.uncurry _.%)))
-          (/.install "frac" (unary (_./ (_.float +1.0))))
-          (/.install "char" (unary (_.do "chr" (list)))))))
+          (/.install "f64" (unary (_./ (_.float +1.0))))
+          (/.install "char" (unary (_.do "chr" (list (_.string "UTF-8")))))
+          )))
 
-(def: frac_procs
+(def: f64_procs
   Bundle
-  (<| (/.prefix "frac")
+  (<| (/.prefix "f64")
       (|> /.empty
           (/.install "+" (binary (product.uncurry _.+)))
           (/.install "-" (binary (product.uncurry _.-)))
@@ -155,8 +150,7 @@
   (<| (/.prefix "lux")
       (|> lux_procs
           (dictionary.merge ..i64_procs)
-          (dictionary.merge ..int_procs)
-          (dictionary.merge ..frac_procs)
+          (dictionary.merge ..f64_procs)
           (dictionary.merge ..text_procs)
           (dictionary.merge ..io_procs)
           )))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/js/runtime.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/js/runtime.lux
index 53213d3f1..f434e9dbd 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/js/runtime.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/js/runtime.lux
@@ -213,8 +213,7 @@
                          test_recursion!)]
                       [(_.< wanted_tag sum_tag)
                        test_recursion!]
-                      [(_.and (_.> wanted_tag sum_tag)
-                              (_.= ..unit wants_last))
+                      [(_.= ..unit wants_last)
                        extrac_sub_variant!])
                 no_match!))))
 
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/lua/runtime.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/lua/runtime.lux
index 20d825912..fd1cfa2b4 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/lua/runtime.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/lua/runtime.lux
@@ -220,8 +220,7 @@
                          test_recursion!)]
                       [(_.< wanted_tag sum_tag)
                        test_recursion!]
-                      [(_.and (_.> wanted_tag sum_tag)
-                              (_.= ..unit wants_last))
+                      [(_.= ..unit wants_last)
                        extrac_sub_variant!])
                 no_match!))))
 
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/python/runtime.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/python/runtime.lux
index 22234bcc4..933bcf6b0 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/python/runtime.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/python/runtime.lux
@@ -66,7 +66,7 @@
 (def: (flag value)
   (-> Bit Literal)
   (if value
-    (_.unicode "")
+    ..unit
     _.none))
 
 (def: (variant' tag last? value)
@@ -243,24 +243,26 @@
         sum_tag (_.nth (_.int +0) sum)
         sum_flag (_.nth (_.int +1) sum)
         sum_value (_.nth (_.int +2) sum)
-        is_last? (_.= (_.unicode "") sum_flag)
+        is_last? (_.= ..unit sum_flag)
         test_recursion! (_.if is_last?
                           ## Must recurse.
-                          (_.return (sum//get sum_value wantsLast (_.- sum_tag wantedTag)))
+                          ($_ _.then
+                              (_.set (list sum) sum_value)
+                              (_.set (list wantedTag) (_.- sum_tag wantedTag)))
                           no_match!)]
-    (_.cond (list [(_.= sum_tag wantedTag)
-                   (_.if (_.= wantsLast sum_flag)
-                     (_.return sum_value)
-                     test_recursion!)]
+    (<| (_.while (_.bool true))
+        (_.cond (list [(_.= wantedTag sum_tag)
+                       (_.if (_.= wantsLast sum_flag)
+                         (_.return sum_value)
+                         test_recursion!)]
 
-                  [(_.> sum_tag wantedTag)
-                   test_recursion!]
+                      [(_.< wantedTag sum_tag)
+                       test_recursion!]
 
-                  [(_.and (_.< sum_tag wantedTag)
-                          (_.= (_.unicode "") wantsLast))
-                   (_.return (variant' (_.- wantedTag sum_tag) sum_flag sum_value))])
+                      [(_.= ..unit wantsLast)
+                       (_.return (variant' (_.- wantedTag sum_tag) sum_flag sum_value))])
 
-            no_match!)))
+                no_match!))))
 
 (def: runtime//adt
   (Statement Any)
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/reference.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/reference.lux
index 6bfd7182e..5f4d3fbd1 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/reference.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/reference.lux
@@ -18,13 +18,17 @@
 ## into the local variables of some scoping function.
 (def: #export universe
   (for {## In the case of Lua, there is a limit of 200 locals in a function's scope.
-        @.lua (not ("lua script universe"))}
+        @.lua (not ("lua script universe"))
+        ## Cannot make all definitions be local variables because of limitations with JRuby.
+        @.ruby (not ("ruby script universe"))}
        #0))
 
 (def: universe_label
   Text
-  (for {@.lua (format "u" (%.nat (if ..universe 1 0)))}
-       ""))
+  (with_expansions [<label> (format "u" (%.nat (if ..universe 1 0)))]
+    (for {@.lua <label>
+          @.ruby <label>}
+         "")))
 
 (def: #export (artifact [module artifact])
   (-> Context Text)
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/case.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/case.lux
index fd9916a9b..428ac6279 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/case.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/case.lux
@@ -52,7 +52,7 @@
     (wrap (|> bodyO
               _.return
               (_.lambda #.None (list (..register register)))
-              (_.do "call" (list valueO))))))
+              (_.apply_lambda/* (list valueO))))))
 
 (def: #export (if expression archive [testS thenS elseS])
   (Generator [Synthesis Synthesis Synthesis])
@@ -239,14 +239,40 @@
                        pattern_matching!)
               (_.statement (_.raise (_.string case.pattern_matching_error)))))))
 
+(def: #export dependencies
+  (-> Path (List LVar))
+  (|>> case.storage
+       (get@ #case.dependencies)
+       set.to_list
+       (list\map (function (_ variable)
+                   (.case variable
+                     (#///////variable.Local register)
+                     (..register register)
+                     
+                     (#///////variable.Foreign register)
+                     (..capture register))))))
+
 (def: #export (case expression archive [valueS pathP])
   (Generator [Synthesis Path])
   (do ///////phase.monad
     [initG (expression archive valueS)
-     pattern_matching! (pattern_matching expression archive pathP)]
-    (wrap (|> ($_ _.then
-                  (_.set (list @cursor) (_.array (list initG)))
-                  (_.set (list @savepoint) (_.array (list)))
-                  pattern_matching!)
-              (_.lambda #.None (list))
-              (_.do "call" (list))))))
+     [[case_module case_artifact] pattern_matching!] (/////generation.with_new_context archive
+                                                       (pattern_matching expression archive pathP))
+     #let [## @case (_.local (///reference.artifact [case_module case_artifact]))
+           ## @dependencies+ (..dependencies (/////synthesis.path/seq (/////synthesis.path/then valueS)
+           ##                                                         pathP))
+           ## directive (_.function @case @dependencies+
+           ##             ($_ _.then
+           ##                 (_.set (list @cursor) (_.array (list initG)))
+           ##                 (_.set (list @savepoint) (_.array (list)))
+           ##                 pattern_matching!))
+           directive (_.lambda #.None (list)
+                               ($_ _.then
+                                   (_.set (list @cursor) (_.array (list initG)))
+                                   (_.set (list @savepoint) (_.array (list)))
+                                   pattern_matching!))]
+     ## _ (/////generation.execute! directive)
+     ## _ (/////generation.save! (%.nat case_artifact) directive)
+     ]
+    ## (wrap (_.apply/* @dependencies+ @case))
+    (wrap (_.apply_lambda/* (list) directive))))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/function.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/function.lux
index d153670b7..e2ace391d 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/function.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/function.lux
@@ -9,7 +9,7 @@
     [collection
      ["." list ("#\." functor fold)]]]
    [target
-    ["_" ruby (#+ LVar Expression Statement)]]]
+    ["_" ruby (#+ LVar GVar Expression Statement)]]]
   ["." // #_
    [runtime (#+ Operation Phase Generator Phase! Generator!)]
    ["#." reference]
@@ -35,25 +35,29 @@
   (do {! ///////phase.monad}
     [functionO (expression archive functionS)
      argsO+ (monad.map ! (expression archive) argsS+)]
-    (wrap (_.do "call" argsO+ functionO))))
+    (wrap (_.apply_lambda/* argsO+ functionO))))
 
 (def: #export capture
   (-> Register LVar)
   (|>> (///reference.foreign //reference.system) :assume))
 
-(def: (with_closure inits function_definition)
-  (-> (List Expression) Expression Expression)
+(def: (with_closure inits self function_definition)
+  (-> (List Expression) Text Expression [Statement Expression])
   (case inits
     #.Nil
-    function_definition
+    (let [@self (_.global self)]
+      [(_.set (list @self) function_definition)
+       @self])
 
     _
-    (|> function_definition
-        _.return
-        (_.lambda #.None
-                  (|> (list.enumeration inits)
-                      (list\map (|>> product.left ..capture))))
-        (_.do "call" inits))))
+    (let [@self (_.local self)]
+      [(_.function @self
+         (|> (list.enumeration inits)
+             (list\map (|>> product.left ..capture)))
+         ($_ _.then
+             (_.set (list @self) function_definition)
+             (_.return @self)))
+       (_.apply/* inits @self)])))
 
 (def: input
   (|>> inc //case.register))
@@ -61,14 +65,14 @@
 (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 (\ ! map ///reference.artifact
-                                                 (/////generation.context archive))]
-                               (/////generation.with_anchor (_.local function_name)
-                                 (expression archive bodyS))))
+    [[[function_module function_artifact] bodyO] (/////generation.with_new_context archive
+                                                   (do !
+                                                     [function_name (\ ! map ///reference.artifact
+                                                                       (/////generation.context archive))]
+                                                     (/////generation.with_anchor (_.local function_name)
+                                                       (expression archive bodyS))))
      closureO+ (monad.map ! (expression archive) environment)
-     #let [function_name (///reference.artifact function_name)
+     #let [function_name (///reference.artifact [function_module function_artifact])
            @curried (_.local "curried")
            arityO (|> arity .int _.int)
            limitO (|> arity dec .int _.int)
@@ -80,29 +84,31 @@
                                         pre!
                                         (_.set (list (..input post)) (_.nth (|> post .int _.int) @curried))))
                                   initialize_self!
-                                  (list.indices arity))]]
-    (wrap (with_closure closureO+
-            (_.lambda (#.Some @self) (list (_.variadic @curried))
-                      ($_ _.then
-                          (_.set (list @num_args) (_.the "length" @curried))
-                          (_.cond (list [(|> @num_args (_.= arityO))
-                                         ($_ _.then
-                                             initialize!
-                                             (_.return bodyO))]
-                                        [(|> @num_args (_.> arityO))
-                                         (let [slice (.function (_ from to)
-                                                       (_.array_range from to @curried))
-                                               arity_args (_.splat (slice (_.int +0) limitO))
-                                               output_func_args (_.splat (slice arityO @num_args))]
-                                           (_.return (|> @self
-                                                         (_.do "call" (list arity_args))
-                                                         (_.do "call" (list output_func_args)))))])
-                                  ## (|> @num_args (_.< arityO))
-                                  (let [@missing (_.local "missing")]
-                                    (_.return (_.lambda #.None (list (_.variadic @missing))
-                                                        (_.return (|> @self
-                                                                      (_.do "call" (list (_.splat (|> (_.array (list))
-                                                                                                      (_.do "concat" (list @curried))
-                                                                                                      (_.do "concat" (list @missing))))))))))))
-                          ))))
-    ))
+                                  (list.indices arity))
+           [declaration instatiation] (with_closure closureO+ function_name
+                                        (_.lambda (#.Some @self) (list (_.variadic @curried))
+                                                  ($_ _.then
+                                                      (_.set (list @num_args) (_.the "length" @curried))
+                                                      (_.cond (list [(|> @num_args (_.= arityO))
+                                                                     ($_ _.then
+                                                                         initialize!
+                                                                         (_.return bodyO))]
+                                                                    [(|> @num_args (_.> arityO))
+                                                                     (let [slice (.function (_ from to)
+                                                                                   (_.array_range from to @curried))
+                                                                           arity_args (_.splat (slice (_.int +0) limitO))
+                                                                           output_func_args (_.splat (slice arityO @num_args))]
+                                                                       (_.return (|> @self
+                                                                                     (_.apply_lambda/* (list arity_args))
+                                                                                     (_.apply_lambda/* (list output_func_args)))))])
+                                                              ## (|> @num_args (_.< arityO))
+                                                              (let [@missing (_.local "missing")]
+                                                                (_.return (_.lambda #.None (list (_.variadic @missing))
+                                                                                    (_.return (|> @self
+                                                                                                  (_.apply_lambda/* (list (_.splat (|> (_.array (list))
+                                                                                                                                       (_.do "concat" (list @curried))
+                                                                                                                                       (_.do "concat" (list @missing))))))))))))
+                                                      )))]
+     _ (/////generation.execute! declaration)
+     _ (/////generation.save! (%.nat function_artifact) declaration)]
+    (wrap instatiation)))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/loop.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/loop.lux
index 3a6152337..4bdf1bc55 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/loop.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/loop.lux
@@ -36,21 +36,53 @@
 
 (def: #export (scope expression archive [start initsS+ bodyS])
   (Generator (Scope Synthesis))
-  (do {! ///////phase.monad}
-    [@loop (\ ! map ..loop_name /////generation.next)
-     initsO+ (monad.map ! (expression archive) initsS+)
-     bodyO (/////generation.with_anchor @loop
-             (expression archive bodyS))]
-    (wrap (|> (_.return bodyO)
-              (_.lambda (#.Some @loop)
-                        (|> initsS+
-                            list.enumeration
-                            (list\map (|>> product.left (n.+ start) //case.register))))
-              (_.apply/* initsO+)))))
+  (case initsS+
+    ## function/false/non-independent loop
+    #.Nil
+    (expression archive bodyS)
+
+    ## true loop
+    _
+    (do {! ///////phase.monad}
+      [@loop (\ ! map ..loop_name /////generation.next)
+       initsO+ (monad.map ! (expression archive) initsS+)
+       [[loop_module loop_artifact] bodyO] (/////generation.with_new_context archive
+                                             (do !
+                                               [@loop (\ ! map (|>> ///reference.artifact _.local)
+                                                         (/////generation.context archive))]
+                                               (/////generation.with_anchor @loop
+                                                 (expression archive bodyS))))
+       #let [@loop (|> [loop_module loop_artifact] ///reference.artifact _.local)
+             locals (|> initsS+
+                        list.enumeration
+                        (list\map (|>> product.left (n.+ start) //case.register)))
+             actual_loop (_.statement
+                          (_.lambda (#.Some @loop) locals
+                                    (_.return bodyO)))
+             [directive instantiation] (: [Statement Expression]
+                                          (case (|> (synthesis.path/then bodyS)
+                                                    //case.dependencies
+                                                    (set.from_list _.code_hash)
+                                                    (set.difference (set.from_list _.code_hash locals))
+                                                    set.to_list)
+                                            #.Nil
+                                            [actual_loop
+                                             @loop]
+
+                                            foreigns
+                                            [(_.statement
+                                              (_.lambda (#.Some @loop) foreigns
+                                                        ($_ _.then
+                                                            actual_loop
+                                                            (_.return @loop))))
+                                             (_.apply_lambda/* foreigns @loop)]))]
+       _ (/////generation.execute! directive)
+       _ (/////generation.save! (%.nat loop_artifact) directive)]
+      (wrap (_.apply_lambda/* initsO+ instantiation)))))
 
 (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))))
+    (wrap (_.apply_lambda/* argsO+ @scope))))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/runtime.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/runtime.lux
index 76460e39a..d74915164 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/runtime.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/runtime.lux
@@ -67,36 +67,6 @@
     ..unit
     _.nil))
 
-(def: #export variant_tag_field "_lux_tag")
-(def: #export variant_flag_field "_lux_flag")
-(def: #export variant_value_field "_lux_value")
-
-(def: (variant' tag last? value)
-  (-> Expression Expression Expression Literal)
-  (_.hash (list [(_.string ..variant_tag_field) tag]
-                [(_.string ..variant_flag_field) last?]
-                [(_.string ..variant_value_field) value])))
-
-(def: #export (variant tag last? value)
-  (-> Nat Bit Expression Literal)
-  (variant' (_.int (.int tag)) (..flag last?) value))
-
-(def: #export none
-  Literal
-  (..variant 0 #0 ..unit))
-
-(def: #export some
-  (-> Expression Literal)
-  (..variant 1 #1))
-
-(def: #export left
-  (-> Expression Literal)
-  (..variant 0 #0))
-
-(def: #export right
-  (-> Expression Literal)
-  (..variant 1 #1))
-
 (def: (feature name definition)
   (-> LVar (-> LVar Statement) Statement)
   (definition name))
@@ -188,6 +158,35 @@
                       (_.return (_.array_range right_index (..tuple_size tuple) tuple)))
               )))))
 
+(def: #export variant_tag_field "_lux_tag")
+(def: #export variant_flag_field "_lux_flag")
+(def: #export variant_value_field "_lux_value")
+
+(runtime: (sum//make tag last? value)
+  (_.return (_.hash (list [(_.string ..variant_tag_field) tag]
+                          [(_.string ..variant_flag_field) last?]
+                          [(_.string ..variant_value_field) value]))))
+
+(def: #export (variant tag last? value)
+  (-> Nat Bit Expression Computation)
+  (sum//make (_.int (.int tag)) (..flag last?) value))
+
+(def: #export none
+  Computation
+  (..variant 0 #0 ..unit))
+
+(def: #export some
+  (-> Expression Computation)
+  (..variant 1 #1))
+
+(def: #export left
+  (-> Expression Computation)
+  (..variant 0 #0))
+
+(def: #export right
+  (-> Expression Computation)
+  (..variant 1 #1))
+
 (runtime: (sum//get sum wantsLast wantedTag)
   (let [no_match! (_.return _.nil)
         sum_tag (_.nth (_.string ..variant_tag_field) sum)
@@ -196,34 +195,37 @@
         is_last? (_.= ..unit sum_flag)
         test_recursion! (_.if is_last?
                           ## Must recurse.
-                          (_.return (sum//get sum_value wantsLast (_.- sum_tag wantedTag)))
+                          ($_ _.then
+                              (_.set (list sum) sum_value)
+                              (_.set (list wantedTag) (_.- sum_tag wantedTag)))
                           no_match!)]
-    (_.cond (list [(_.= sum_tag wantedTag)
-                   (_.if (_.= wantsLast sum_flag)
-                     (_.return sum_value)
-                     test_recursion!)]
+    (<| (_.while (_.bool true))
+        (_.cond (list [(_.= sum_tag wantedTag)
+                       (_.if (_.= wantsLast sum_flag)
+                         (_.return sum_value)
+                         test_recursion!)]
 
-                  [(_.> sum_tag wantedTag)
-                   test_recursion!]
+                      [(_.< wantedTag sum_tag)
+                       test_recursion!]
 
-                  [(_.and (_.< sum_tag wantedTag)
-                          (_.= ..unit wantsLast))
-                   (_.return (variant' (_.- wantedTag sum_tag) sum_flag sum_value))])
+                      [(_.= ..unit wantsLast)
+                       (_.return (sum//make (_.- wantedTag sum_tag) sum_flag sum_value))])
 
-            no_match!)))
+                no_match!))))
 
 (def: runtime//adt
   Statement
   ($_ _.then
       @tuple//left
       @tuple//right
+      @sum//make
       @sum//get
       ))
 
 (runtime: (lux//try risky)
   (with_vars [error value]
     (_.begin ($_ _.then
-                 (_.set (list value) (_.do "call" (list ..unit) risky))
+                 (_.set (list value) (_.apply_lambda/* (list ..unit) risky))
                  (_.return (..right value)))
              (list [(list) error
                     (_.return (..left (_.the "message" error)))]))))