Got JRuby to cooperate.

14 files changed, 531 insertions, 318 deletions

diff --git a/compilers.md b/compilers.md
index 5aabf4445..0bea1a06c 100644
--- a/compilers.md
+++ b/compilers.md
@@ -260,7 +260,10 @@ cd ~/lux/lux-ruby/ \
 ## Try
 
 ```
-cd ~/lux/lux-ruby/ && java -jar target/program.jar build --source ~/lux/stdlib/source --target ~/lux/stdlib/target --module test/lux
+## Compile Lux's Standard Library's tests using a JVM-based compiler.
+cd ~/lux/stdlib/ \
+&& lein clean \
+&& time java -jar ~/lux/lux-ruby/jvm_based_compiler.jar build --source ~/lux/stdlib/source --target ~/lux/stdlib/target --module test/lux
 ```
 
 ---
diff --git a/lux-bootstrapper/src/lux/compiler/jvm/proc/host.clj b/lux-bootstrapper/src/lux/compiler/jvm/proc/host.clj
index ec934ae7b..034d503a7 100644
--- a/lux-bootstrapper/src/lux/compiler/jvm/proc/host.clj
+++ b/lux-bootstrapper/src/lux/compiler/jvm/proc/host.clj
@@ -412,7 +412,9 @@
 
   (defn ^:private add-anon-class-<init> [^ClassWriter class-writer compile class-name super-class env ctor-args]
     (|let [[super-class-name super-class-params] super-class
-           init-types (->> ctor-args (&/|map (comp &host-generics/->type-signature &/|first)) (&/fold str ""))]
+           init-types (->> ctor-args
+                           (&/|map (comp &host-generics/gclass->signature &/|first))
+                           (&/fold str ""))]
       (&/with-writer (.visitMethod class-writer Opcodes/ACC_PUBLIC init-method (anon-class-<init>-signature env) nil nil)
         (|do [^MethodVisitor =method &/get-writer
               :let [_ (doto =method
@@ -421,7 +423,7 @@
               _ (&/map% (fn [type+term]
                           (|let [[type term] type+term]
                             (|do [_ (compile term)
-                                  :let [_ (prepare-ctor-arg =method type)]]
+                                  :let [_ (prepare-ctor-arg =method (&host-generics/gclass->class-name type))]]
                               (return nil))))
                         ctor-args)
               :let [_ (doto =method
diff --git a/lux-ruby/source/program.lux b/lux-ruby/source/program.lux
index e373e20b5..044e97923 100644
--- a/lux-ruby/source/program.lux
+++ b/lux-ruby/source/program.lux
@@ -1,6 +1,7 @@
 (.module:
   [lux #*
    [program (#+ program:)]
+   ["." debug]
    ["." host (#+ import:)]
    ["." meta]
    [abstract
@@ -76,12 +77,28 @@
    (toString [] java/lang/String)
    (getClass [] (java/lang/Class java/lang/Object))])
 
-(import: java/lang/Integer)
+(import: java/lang/Integer
+  ["#::."
+   (longValue [] java/lang/Long)])
 
 (import: java/lang/Long
   ["#::."
    (intValue [] java/lang/Integer)])
 
+(import: org/jruby/RubyString
+  ["#::."
+   (#static newInternalFromJavaExternal [org/jruby/Ruby java/lang/String] org/jruby/RubyString)
+   (asJavaString [] java/lang/String)])
+
+(import: org/jruby/runtime/builtin/IRubyObject)
+
+(import: org/jruby/Ruby
+  ["#::."
+   (getCurrentContext [] org/jruby/runtime/ThreadContext)
+   (getNil [] org/jruby/runtime/builtin/IRubyObject)])
+
+(import: org/jruby/RubyClass)
+
 (import: org/jruby/RubyArray
   ["#::."
    (getLength [] int)
@@ -91,12 +108,6 @@
   ["#::."
    (get [java/lang/Object] #? java/lang/Object)])
 
-(import: org/jruby/Ruby
-  ["#::."
-   (getCurrentContext [] org/jruby/runtime/ThreadContext)])
-
-(import: org/jruby/runtime/builtin/IRubyObject)
-
 (import: org/jruby/runtime/ThreadContext)
 
 (template [<name>]
@@ -123,140 +134,64 @@
 (import: org/jruby/runtime/builtin/InstanceVariables)
 (import: org/jruby/runtime/builtin/InternalVariables)
 
-(def: (lux_structure value)
-  (-> (Array java/lang/Object) org/jruby/runtime/builtin/IRubyObject)
-  (with_expansions [<checkers> (template [<name>]
-                                 [[<name> [] boolean]]
-
-                                 [isNil] [isTaint] [isClass] [isFrozen]
-                                 [isImmediate] [isModule] [isSpecialConst] [isTrue]
-                                 [isUntrusted] [hasVariables])
-                    <markers> (template [<name>]
-                                [[<name> [boolean] void]]
-
-                                [setFrozen] [setTaint] [setUntrusted])
-                    <nullaries> (template [<name>]
-                                  [[<name> [] org/jruby/runtime/builtin/IRubyObject]]
-
-                                  [dup] [checkArrayType] [inspect] [checkStringType]
-                                  [checkStringType19] [id] [rbClone] [anyToString])
-                    <class> (template [<name>]
-                              [[<name> [] org/jruby/RubyClass]]
-
-                              [getMetaClass] [getType] [getSingletonClass])
-                    <call> (template [<inputs>]
-                             [[callMethod <inputs>
-                               org/jruby/runtime/builtin/IRubyObject]]
-
-                             [[org/jruby/runtime/ThreadContext int java/lang/String]]
-                             [[org/jruby/runtime/ThreadContext int java/lang/String org/jruby/runtime/builtin/IRubyObject]]
-                             [[org/jruby/runtime/ThreadContext java/lang/String]]
-                             [[org/jruby/runtime/ThreadContext java/lang/String org/jruby/runtime/builtin/IRubyObject]]
-                             ## [[org/jruby/runtime/ThreadContext java/lang/String [org/jruby/runtime/builtin/IRubyObject]]]
-                             [[org/jruby/runtime/ThreadContext java/lang/String [org/jruby/runtime/builtin/IRubyObject] org/jruby/runtime/Block]]
-                             )
-                    <placeholders> (template [<name> <inputs> <output>]
-                                     [(org/jruby/runtime/builtin/IRubyObject
-                                       (<name> self (~~ (method_inputs <inputs>)))
-                                       <output>
-                                       (error! (template.text ["UNIMPLEMENTED METHOD: " <name>])))]
-
-                                     [getRuntime [] org/jruby/Ruby]
-                                     [copySpecialInstanceVariables [org/jruby/runtime/builtin/IRubyObject] void]
-                                     [syncVariables [org/jruby/runtime/builtin/IRubyObject] void]
-                                     [syncVariables [(java/util/List (org/jruby/runtime/builtin/Variable java/lang/Object))] void]
-                                     [dataWrapStruct [java/lang/Object] void]
-                                     [addFinalizer [org/jruby/runtime/builtin/IRubyObject] void]
-                                     [removeFinalizers [] void]
-                                     [getVariable [int] java/lang/Object]
-                                     [setVariable [int java/lang/Object] void]
-                                     [getVariableList [] (java/util/List (org/jruby/runtime/builtin/Variable java/lang/Object))]
-                                     [getVariableNameList [] (java/util/List java/lang/String)]
-                                     [getVariableCount [] int]
-                                     [getJavaClass [] (java/lang/Class java/lang/Object)]
-                                     [asJavaString [] java/lang/String]
-                                     [getInstanceVariables [] org/jruby/runtime/builtin/InstanceVariables]
-                                     [getInternalVariables [] org/jruby/runtime/builtin/InternalVariables]
-                                     [convertToInteger [] org/jruby/RubyInteger]
-                                     [convertToInteger [java/lang/String] org/jruby/RubyInteger]
-                                     [convertToInteger [int java/lang/String] org/jruby/RubyInteger]
-                                     [convertToArray [] org/jruby/RubyArray]
-                                     [convertToHash [] org/jruby/RubyHash]
-                                     [convertToFloat [] org/jruby/RubyFloat]
-                                     [convertToString [] org/jruby/RubyString]
-                                     [asString [] org/jruby/RubyString]
-                                     [respondsTo [java/lang/String] boolean]
-                                     [respondsToMissing [java/lang/String] boolean]
-                                     [respondsToMissing [java/lang/String boolean] boolean]
-                                     [dataGetStruct [] java/lang/Object]
-                                     [dataGetStructChecked [] java/lang/Object]
-                                     [infectBy [org/jruby/runtime/builtin/IRubyObject] org/jruby/runtime/builtin/IRubyObject]
-                                     [eql [org/jruby/runtime/builtin/IRubyObject] boolean]
-                                     [toJava [(java/lang/Class java/lang/Object)] java/lang/Object]
-
-                                     [op_eqq
-                                      [org/jruby/runtime/ThreadContext
-                                       org/jruby/runtime/builtin/IRubyObject]
-                                      org/jruby/runtime/builtin/IRubyObject]
-                                     
-                                     [op_equal
-                                      [org/jruby/runtime/ThreadContext
-                                       org/jruby/runtime/builtin/IRubyObject]
-                                      org/jruby/runtime/builtin/IRubyObject]
-                                     
-                                     [callSuper
-                                      [org/jruby/runtime/ThreadContext
-                                       [org/jruby/runtime/builtin/IRubyObject]
-                                       org/jruby/runtime/Block]
-                                      org/jruby/runtime/builtin/IRubyObject]
-                                     
-                                     [checkCallMethod
-                                      [org/jruby/runtime/ThreadContext
-                                       java/lang/String]
-                                      org/jruby/runtime/builtin/IRubyObject]
-                                     
-                                     [checkCallMethod
-                                      [org/jruby/runtime/ThreadContext
-                                       org/jruby/runtime/JavaSites$CheckedSites]
-                                      org/jruby/runtime/builtin/IRubyObject]
-
-                                     <checkers>
-                                     <markers>
-                                     <nullaries>
-                                     <class>
-                                     <call>
-                                     )]
-    (`` (host.object [] [program/StructureValue
-                         org/jruby/runtime/builtin/IRubyObject]
-          []
-          ## Methods
-          (program/StructureValue
-           [] (getValue self)
-           java/lang/Object
-           (:coerce (Array java/lang/Object) value))
-          
-          (org/jruby/runtime/builtin/IRubyObject
-           [] (callMethod self
-                          {thread_context org/jruby/runtime/ThreadContext}
-                          {member java/lang/String}
-                          {inputs [org/jruby/runtime/builtin/IRubyObject]})
-           org/jruby/runtime/builtin/IRubyObject
-           (exec
-             ("lux io log" (format "Was called: " (%.text member)))
-             (error! "OOPS!")))
-
-          <placeholders>
-          ))))
+(import: org/jruby/embed/internal/LocalContextProvider
+  ["#::."
+   (getRuntime [] org/jruby/Ruby)])
+
+(import: org/jruby/embed/ScriptingContainer
+  ["#::."
+   (new [])
+   (runScriptlet [java/lang/String] #try #? java/lang/Object)
+   (getProvider [] org/jruby/embed/internal/LocalContextProvider)])
+
+## TODO; Figure out a way to not need "interpreter" to be a global variable.
+(def: interpreter
+  (org/jruby/embed/ScriptingContainer::new))
+
+(template: (!ruby_runtime)
+  (|> ..interpreter
+      org/jruby/embed/ScriptingContainer::getProvider
+      org/jruby/embed/internal/LocalContextProvider::getRuntime))
+
+(template: (!ruby_thread_context)
+  (|> (!ruby_runtime)
+      org/jruby/Ruby::getCurrentContext))
+
+(def: initial_ruby_runtime
+  (!ruby_runtime))
+
+(import: org/jruby/java/proxies/JavaProxy
+  ["#::."
+   (new [org/jruby/Ruby org/jruby/RubyClass java/lang/Object])])
+
+(import: org/jruby/internal/runtime/methods/DynamicMethod)
+
+(import: org/jruby/runtime/callsite/CacheEntry
+  ["#::."
+   (new [org/jruby/internal/runtime/methods/DynamicMethod int])])
+
+(import: org/jruby/RubyFixnum
+  ["#::."
+   (new [org/jruby/Ruby long])
+   (getLongValue [] long)])
+
+(import: org/jruby/RubyFloat
+  ["#::."
+   (new [org/jruby/Ruby double])])
+
+(import: org/jruby/RubyBoolean
+  ["#::."
+   (#static newBoolean [org/jruby/Ruby boolean] org/jruby/RubyBoolean)])
+
+(import: org/jruby/RubyNil
+  ["#::."
+   (new [org/jruby/Ruby])])
 
 (import: org/jruby/RubyProc
   ["#::."
    (call [org/jruby/runtime/ThreadContext [org/jruby/runtime/builtin/IRubyObject]]
          #try org/jruby/runtime/builtin/IRubyObject)])
 
-(import: org/jruby/javasupport/JavaArray
-  ["#::."
-   (new [org/jruby/Ruby java/lang/Object])])
-
 (type: Translator
   (-> java/lang/Object (Try Any)))
 
@@ -321,6 +256,7 @@
                 [java/lang/Long #try.Success]
                 [java/lang/Double #try.Success]
                 [java/lang/String #try.Success]
+                [[java/lang/Object] #try.Success]
                 [org/jruby/RubyArray (read_tuple read)]
                 [org/jruby/RubyHash (read_variant read)]
                 [org/jruby/RubySymbol #try.Success]
@@ -329,42 +265,191 @@
           (exception.throw ..unknown_kind_of_object host_object)
           )))
 
-(exception: (cannot_apply_a_non_function {object java/lang/Object})
+(def: ruby_nil
+  org/jruby/runtime/builtin/IRubyObject
+  (org/jruby/Ruby::getNil ..initial_ruby_runtime))
+
+(def: lux_unit
+  org/jruby/RubyString
+  (org/jruby/RubyString::newInternalFromJavaExternal ..initial_ruby_runtime ""))
+
+(def: (wrapped_lux_value lux_structure value)
+  (-> (-> (Array java/lang/Object) org/jruby/runtime/builtin/IRubyObject)
+      (-> java/lang/Object org/jruby/runtime/builtin/IRubyObject))
+  (<| (case (host.check [java/lang/Object] value)
+        (#.Some value)
+        (|> value (:coerce (Array java/lang/Object)) lux_structure)
+
+        #.None)
+      (case (host.check java/lang/Boolean value)
+        (#.Some value)
+        (org/jruby/RubyBoolean::newBoolean ..initial_ruby_runtime value)
+        
+        #.None)
+      (case (host.check java/lang/Long value)
+        (#.Some value)
+        (org/jruby/RubyFixnum::new ..initial_ruby_runtime value)
+        
+        #.None)
+      (case (host.check java/lang/Double value)
+        (#.Some value)
+        (org/jruby/RubyFloat::new ..initial_ruby_runtime value)
+        
+        #.None)
+      (case (host.check java/lang/String value)
+        (#.Some value)
+        (org/jruby/RubyString::newInternalFromJavaExternal ..initial_ruby_runtime value)
+        
+        #.None)
+      (:coerce org/jruby/runtime/builtin/IRubyObject value)))
+
+(exception: (invalid_variant_access {field Text})
   (exception.report
-   ["Non-function" (java/lang/Object::toString object)]))
+   ["Field" (%.text field)]))
 
-(import: org/jruby/embed/internal/LocalContextProvider
-  ["#::."
-   (getRuntime [] org/jruby/Ruby)])
+(exception: (invalid_tuple_access {index Nat})
+  (exception.report
+   ["Index" (%.nat index)]))
+
+(def: (lux_wrapper_access lux_structure value)
+  (-> (-> (Array java/lang/Object) org/jruby/runtime/builtin/IRubyObject)
+      (-> (Array java/lang/Object) org/jruby/internal/runtime/methods/DynamicMethod))
+  (host.object [] org/jruby/internal/runtime/methods/DynamicMethod []
+    [{java/lang/String "[]"}]
+
+    (org/jruby/internal/runtime/methods/DynamicMethod
+     [] (call self
+              {thread_context org/jruby/runtime/ThreadContext}
+              {self org/jruby/runtime/builtin/IRubyObject}
+              {module org/jruby/RubyModule}
+              {method java/lang/String}
+              {args [org/jruby/runtime/builtin/IRubyObject]}
+              {block org/jruby/runtime/Block})
+     org/jruby/runtime/builtin/IRubyObject
+     (let [member (host.array_read 0 args)]
+       (case (host.check org/jruby/RubyFixnum member)
+         (#.Some member)
+         (case (array.read (org/jruby/RubyFixnum::getLongValue member) value)
+           (#.Some value)
+           (wrapped_lux_value lux_structure value)
+
+           #.None
+           (error! (exception.construct ..invalid_tuple_access [(org/jruby/RubyFixnum::getLongValue member)])))
+
+         #.None
+         (case (host.check org/jruby/RubyString member)
+           (#.Some member)
+           (case (:coerce Text (org/jruby/RubyString::asJavaString member))
+             (^ (static runtime.variant_tag_field))
+             (|> value
+                 (array.read 0)
+                 maybe.assume
+                 (:coerce java/lang/Integer)
+                 java/lang/Integer::longValue
+                 (org/jruby/RubyFixnum::new ..initial_ruby_runtime))
+
+             (^ (static runtime.variant_flag_field))
+             (case (array.read 1 value)
+               #.None
+               ..ruby_nil
+               
+               (#.Some flag)
+               ..lux_unit)
+             
+             (^ (static runtime.variant_value_field))
+             (case (array.read 2 value)
+               (#.Some value)
+               (wrapped_lux_value lux_structure value)
+
+               #.None
+               (error! (exception.construct ..nil_has_no_lux_representation [])))
+
+             field
+             (error! (exception.construct ..invalid_variant_access [field])))
+           
+           #.None
+           (error! (format "lux_wrapper_access INVALID INDEX"))))))))
+
+(def: (lux_wrapper_equality value)
+  (-> (Array java/lang/Object) org/jruby/internal/runtime/methods/DynamicMethod)
+  (host.object [] org/jruby/internal/runtime/methods/DynamicMethod []
+    [{java/lang/String "=="}]
+
+    (org/jruby/internal/runtime/methods/DynamicMethod
+     [] (call self
+              {thread_context org/jruby/runtime/ThreadContext}
+              {self org/jruby/runtime/builtin/IRubyObject}
+              {module org/jruby/RubyModule}
+              {method java/lang/String}
+              {args [org/jruby/runtime/builtin/IRubyObject]}
+              {block org/jruby/runtime/Block})
+     org/jruby/runtime/builtin/IRubyObject
+     (let [reference (host.array_read 0 args)]
+       (case (..read (:coerce java/lang/Object reference))
+         (#try.Success reference)
+         (org/jruby/RubyBoolean::newBoolean ..initial_ruby_runtime (is? (: Any reference) (: Any value)))
+         
+         (#try.Failure error)
+         (org/jruby/RubyBoolean::newBoolean ..initial_ruby_runtime false))))))
+
+(def: (lux_wrapper_length value)
+  (-> (Array java/lang/Object) org/jruby/internal/runtime/methods/DynamicMethod)
+  (host.object [] org/jruby/internal/runtime/methods/DynamicMethod []
+    [{java/lang/String "length"}]
+
+    (org/jruby/internal/runtime/methods/DynamicMethod
+     [] (call self
+              {thread_context org/jruby/runtime/ThreadContext}
+              {self org/jruby/runtime/builtin/IRubyObject}
+              {module org/jruby/RubyModule}
+              {method java/lang/String}
+              {args [org/jruby/runtime/builtin/IRubyObject]}
+              {block org/jruby/runtime/Block})
+     org/jruby/runtime/builtin/IRubyObject
+     (|> value
+         array.size
+         (org/jruby/RubyFixnum::new ..initial_ruby_runtime)))))
+
+(exception: (unknown_method {method Text})
+  (exception.report
+   ["Method" (%.text method)]))
 
-(import: org/jruby/embed/ScriptingContainer
-  ["#::."
-   (new [])
-   (runScriptlet [java/lang/String] #try #? java/lang/Object)
-   (getProvider [] org/jruby/embed/internal/LocalContextProvider)])
+(def: (lux_structure value)
+  (-> (Array java/lang/Object) org/jruby/runtime/builtin/IRubyObject)
+  (let [meta_class (host.object [] org/jruby/RubyClass []
+                     [{org/jruby/Ruby
+                       ..initial_ruby_runtime}]
 
-## TODO; Figure out a way to not need "interpreter" to be a global variable.
-(def: interpreter (org/jruby/embed/ScriptingContainer::new))
+                     (org/jruby/RubyClass
+                      [] (searchWithCache self
+                                          {method java/lang/String})
+                      org/jruby/runtime/callsite/CacheEntry
+                      (case (:coerce Text method)
+                        "[]"
+                        (org/jruby/runtime/callsite/CacheEntry::new (..lux_wrapper_access lux_structure value) 0)
+
+                        "=="
+                        (org/jruby/runtime/callsite/CacheEntry::new (..lux_wrapper_equality value) 1)
+
+                        "length"
+                        (org/jruby/runtime/callsite/CacheEntry::new (..lux_wrapper_length value) 2)
+
+                        _
+                        (error! (exception.construct ..unknown_method [(:coerce Text method)])))))]
+    (org/jruby/java/proxies/JavaProxy::new ..initial_ruby_runtime meta_class (:coerce java/lang/Object value))))
+
+(exception: (cannot_apply_a_non_function {object java/lang/Object})
+  (exception.report
+   ["Non-function" (java/lang/Object::toString object)]))
 
 (def: ensure_macro
   (-> Macro (Maybe org/jruby/RubyProc))
   (|>> (:coerce java/lang/Object) (host.check org/jruby/RubyProc)))
 
-(template: (!ruby_runtime)
-  (|> ..interpreter
-      org/jruby/embed/ScriptingContainer::getProvider
-      org/jruby/embed/internal/LocalContextProvider::getRuntime))
-
-(template: (!ruby_thread_context)
-  (|> (!ruby_runtime)
-      org/jruby/Ruby::getCurrentContext))
-
 (def: to_host
   (-> Any org/jruby/runtime/builtin/IRubyObject)
   (|>> (:coerce (Array java/lang/Object))
-       ..lux_structure
-       ## (org/jruby/javasupport/JavaArray::new (!ruby_runtime))
-       ))
+       ..lux_structure))
 
 (def: (call_macro inputs lux macro)
   (-> (List Code) Lux org/jruby/RubyProc (Try (Try [Lux (List Code)])))
@@ -416,8 +501,7 @@
                     @global (_.global global)]
                 (do try.monad
                   [#let [definition (_.set (list @global) input)]
-                   _ (run! definition)
-                   value (run! @global)]
+                   value (run! definition)]
                   (wrap [global value definition]))))
 
             (def: (ingest context content)
@@ -450,10 +534,6 @@
                                 _.nil)
                           program)))
 
-(import: org/jruby/RubyString
-  ["#::."
-   (#static newInternalFromJavaExternal [org/jruby/Ruby java/lang/String] org/jruby/RubyString)])
-
 (def: extender
   Extender
   ## TODO: Stop relying on coercions ASAP.
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)))]))))