- Fixed some bugs.

- Some refactoring.
- Added some alternative snippets of code that new-luxc can handle better.

21 files changed, 451 insertions, 333 deletions

diff --git a/luxc/src/lux/analyser/proc/common.clj b/luxc/src/lux/analyser/proc/common.clj
index 1dce02b2c..7031a9135 100644
--- a/luxc/src/lux/analyser/proc/common.clj
+++ b/luxc/src/lux/analyser/proc/common.clj
@@ -289,7 +289,7 @@
   ^:private analyse-nat-to-int   &type/Nat  &type/Int    ["nat" "to-int"]
   ^:private analyse-int-to-nat   &type/Int  &type/Nat    ["int" "to-nat"]
   
-  ^:private analyse-nat-to-char  &type/Nat  &type/Text   ["nat" "to-char"]
+  ^:private analyse-nat-char  &type/Nat  &type/Text   ["nat" "char"]
   
   ^:private analyse-int-to-frac  &type/Int  &type/Frac   ["int" "to-frac"]
   ^:private analyse-frac-to-int  &type/Frac &type/Int    ["frac" "to-int"]
@@ -365,18 +365,6 @@
 
 (do-template [<name> <proc>]
   (defn <name> [analyse exo-type ?values]
-    (|do [:let [(&/$Nil) ?values]
-          _ (&type/check exo-type &type/Frac)
-          _cursor &/cursor]
-      (return (&/|list (&&/|meta exo-type _cursor
-                                 (&&/$proc (&/T ["math" <proc>]) (&/|list) (&/|list)))))))
-
-  ^:private analyse-math-e  "e"
-  ^:private analyse-math-pi "pi"
-  )
-
-(do-template [<name> <proc>]
-  (defn <name> [analyse exo-type ?values]
     (|do [:let [(&/$Cons ?input (&/$Nil)) ?values]
           =input (&&/analyse-1 analyse &type/Frac ?input)
           _ (&type/check exo-type &type/Frac)
@@ -426,7 +414,7 @@
         (return (&/|list (&&/|meta exo-type _cursor
                                    (&&/$proc (&/T ["atom" "new"]) (&/|list =init) (&/|list)))))))))
 
-(defn ^:private analyse-atom-get [analyse exo-type ?values]
+(defn ^:private analyse-atom-read [analyse exo-type ?values]
   (&type/with-var
     (fn [$var]
       (|do [:let [(&/$Cons ?atom (&/$Nil)) ?values]
@@ -434,7 +422,7 @@
             _ (&type/check exo-type $var)
             _cursor &/cursor]
         (return (&/|list (&&/|meta exo-type _cursor
-                                   (&&/$proc (&/T ["atom" "get"]) (&/|list =atom) (&/|list)))))))))
+                                   (&&/$proc (&/T ["atom" "read"]) (&/|list =atom) (&/|list)))))))))
 
 (defn ^:private analyse-atom-compare-and-swap [analyse exo-type ?values]
   (&type/with-var
@@ -519,7 +507,7 @@
          "lux nat min" (analyse-nat-min analyse exo-type ?values)
          "lux nat max" (analyse-nat-max analyse exo-type ?values)
          "lux nat to-int" (analyse-nat-to-int analyse exo-type ?values)
-         "lux nat to-char" (analyse-nat-to-char analyse exo-type ?values)
+         "lux nat char" (analyse-nat-char analyse exo-type ?values)
          
          "lux int +" (analyse-int-add analyse exo-type ?values)
          "lux int -" (analyse-int-sub analyse exo-type ?values)
@@ -564,8 +552,6 @@
          "lux frac to-deg" (analyse-frac-to-deg analyse exo-type ?values)
          "lux frac to-int" (analyse-frac-to-int analyse exo-type ?values)
          
-         "lux math e" (analyse-math-e analyse exo-type ?values)
-         "lux math pi" (analyse-math-pi analyse exo-type ?values)
          "lux math cos" (analyse-math-cos analyse exo-type ?values)
          "lux math sin" (analyse-math-sin analyse exo-type ?values)
          "lux math tan" (analyse-math-tan analyse exo-type ?values)
@@ -586,7 +572,7 @@
          "lux math pow" (analyse-math-pow analyse exo-type ?values)
          
          "lux atom new" (analyse-atom-new analyse exo-type ?values)
-         "lux atom get" (analyse-atom-get analyse exo-type ?values)
+         "lux atom read" (analyse-atom-read analyse exo-type ?values)
          "lux atom compare-and-swap" (analyse-atom-compare-and-swap analyse exo-type ?values)
          
          "lux process concurrency-level" (analyse-process-concurrency-level analyse exo-type ?values)
diff --git a/luxc/src/lux/compiler/jvm/proc/common.clj b/luxc/src/lux/compiler/jvm/proc/common.clj
index 3c948e8bc..bead93256 100644
--- a/luxc/src/lux/compiler/jvm/proc/common.clj
+++ b/luxc/src/lux/compiler/jvm/proc/common.clj
@@ -415,7 +415,7 @@
   ^:private compile-frac-to-deg "java.lang.Double" "frac-to-deg" "(D)J" &&/unwrap-double &&/wrap-long
   )
 
-(defn ^:private compile-nat-to-char [compile ?values special-args]
+(defn ^:private compile-nat-char [compile ?values special-args]
   (|do [:let [(&/$Cons ?x (&/$Nil)) ?values]
         ^MethodVisitor *writer* &/get-writer
         _ (compile ?x)
@@ -667,19 +667,6 @@
                   &&/wrap-long)]]
     (return nil)))
 
-(do-template [<name> <field>]
-  (defn <name> [compile ?values special-args]
-    (|do [:let [(&/$Nil) ?values]
-          ^MethodVisitor *writer* &/get-writer
-          :let [_ (doto *writer*
-                    (.visitFieldInsn Opcodes/GETSTATIC "java/lang/Math" <field> "D")
-                    &&/wrap-double)]]
-      (return nil)))
-
-  ^:private compile-math-e  "E"
-  ^:private compile-math-pi "PI"
-  )
-
 (do-template [<name> <method>]
   (defn <name> [compile ?values special-args]
     (|do [:let [(&/$Cons ?input (&/$Nil)) ?values]
@@ -749,7 +736,7 @@
                   (.visitMethodInsn Opcodes/INVOKESPECIAL "java/util/concurrent/atomic/AtomicReference" "<init>" "(Ljava/lang/Object;)V"))]]
     (return nil)))
 
-(defn ^:private compile-atom-get [compile ?values special-args]
+(defn ^:private compile-atom-read [compile ?values special-args]
   (|do [:let [(&/$Cons ?atom (&/$Nil)) ?values]
         ^MethodVisitor *writer* &/get-writer
         _ (compile ?atom)
@@ -865,7 +852,7 @@
       "max" (compile-nat-max compile ?values special-args)
       "min" (compile-nat-min compile ?values special-args)
       "to-int"    (compile-nat-to-int compile ?values special-args)
-      "to-char"   (compile-nat-to-char compile ?values special-args)
+      "char"   (compile-nat-char compile ?values special-args)
       )
     
     "deg"
@@ -922,8 +909,6 @@
 
     "math"
     (case proc
-      "e" (compile-math-e compile ?values special-args)
-      "pi" (compile-math-pi compile ?values special-args)
       "cos" (compile-math-cos compile ?values special-args)
       "sin" (compile-math-sin compile ?values special-args)
       "tan" (compile-math-tan compile ?values special-args)
@@ -947,7 +932,7 @@
     "atom"
     (case proc
       "new" (compile-atom-new compile ?values special-args)
-      "get" (compile-atom-get compile ?values special-args)
+      "read" (compile-atom-read compile ?values special-args)
       "compare-and-swap" (compile-atom-compare-and-swap compile ?values special-args)
       )
 
diff --git a/new-luxc/source/luxc/lang/analysis/case.lux b/new-luxc/source/luxc/lang/analysis/case.lux
index 5d4c592aa..949e18a26 100644
--- a/new-luxc/source/luxc/lang/analysis/case.lux
+++ b/new-luxc/source/luxc/lang/analysis/case.lux
@@ -35,6 +35,15 @@
   (format "   Type: " (%type type) "\n"
           "Pattern: " (%code pattern)))
 
+(def: (re-quantify envs baseT)
+  (-> (List (List Type)) Type Type)
+  (case envs
+    #;Nil
+    baseT
+
+    (#;Cons head tail)
+    (re-quantify tail (#;UnivQ head baseT))))
+
 ## Type-checking on the input value is done during the analysis of a
 ## "case" expression, to ensure that the patterns being used make
 ## sense for the type of the input value.
@@ -44,52 +53,74 @@
 ## type-check the input with respect to the patterns.
 (def: (simplify-case-type caseT)
   (-> Type (Meta Type))
-  (case caseT
-    (#;Var id)
-    (do macro;Monad<Meta>
-      [?caseT' (&;with-type-env
-                 (tc;read id))]
-      (case ?caseT'
-        (#;Some caseT')
-        (simplify-case-type caseT')
+  (loop [envs (: (List (List Type))
+                 (list))
+         caseT caseT]
+    (case caseT
+      (#;Var id)
+      (do macro;Monad<Meta>
+        [?caseT' (&;with-type-env
+                   (tc;read id))]
+        (case ?caseT'
+          (#;Some caseT')
+          (recur envs caseT')
 
-        _
-        (&;throw Cannot-Simplify-Type-For-Pattern-Matching (%type caseT))))
+          _
+          (&;throw Cannot-Simplify-Type-For-Pattern-Matching (%type caseT))))
 
-    (#;Named name unnamedT)
-    (simplify-case-type unnamedT)
+      (#;Named name unnamedT)
+      (recur envs unnamedT)
 
-    (^or (#;UnivQ _) (#;ExQ _))
-    (do macro;Monad<Meta>
-      [[ex-id exT] (&;with-type-env
-                     tc;existential)]
-      (simplify-case-type (maybe;assume (type;apply (list exT) caseT))))
+      (#;UnivQ env unquantifiedT)
+      (recur (#;Cons env envs) unquantifiedT)
 
-    (#;Apply inputT funcT)
-    (case funcT
-      (#;Var funcT-id)
+      ## (^template [<tag> <instancer>]
+      ##   (<tag> _)
+      ##   (do macro;Monad<Meta>
+      ##     [[_ instanceT] (&;with-type-env
+      ##                      <instancer>)]
+      ##     (recur (maybe;assume (type;apply (list instanceT) caseT)))))
+      ## ([#;UnivQ tc;var]
+      ##  [#;ExQ tc;existential])
+      
+      (#;ExQ _)
       (do macro;Monad<Meta>
-        [funcT' (&;with-type-env
-                  (do tc;Monad<Check>
-                    [?funct' (tc;read funcT-id)]
-                    (case ?funct'
-                      (#;Some funct')
-                      (wrap funct')
+        [[ex-id exT] (&;with-type-env
+                       tc;existential)]
+        (recur envs (maybe;assume (type;apply (list exT) caseT))))
 
-                      _
-                      (tc;throw Cannot-Simplify-Type-For-Pattern-Matching (%type caseT)))))]
-        (simplify-case-type (#;Apply inputT funcT')))
+      (#;Apply inputT funcT)
+      (case funcT
+        (#;Var funcT-id)
+        (do macro;Monad<Meta>
+          [funcT' (&;with-type-env
+                    (do tc;Monad<Check>
+                      [?funct' (tc;read funcT-id)]
+                      (case ?funct'
+                        (#;Some funct')
+                        (wrap funct')
 
-      _
-      (case (type;apply (list inputT) funcT)
-        (#;Some outputT)
-        (:: macro;Monad<Meta> wrap outputT)
+                        _
+                        (tc;throw Cannot-Simplify-Type-For-Pattern-Matching (%type caseT)))))]
+          (recur envs (#;Apply inputT funcT')))
 
-        #;None
-        (&;throw Cannot-Simplify-Type-For-Pattern-Matching (%type caseT))))
+        _
+        (case (type;apply (list inputT) funcT)
+          (#;Some outputT)
+          (recur envs outputT)
 
-    _
-    (:: macro;Monad<Meta> wrap caseT)))
+          #;None
+          (&;throw Cannot-Simplify-Type-For-Pattern-Matching (%type caseT))))
+
+      (#;Product _)
+      (|> caseT
+          type;flatten-tuple
+          (list/map (re-quantify envs))
+          type;tuple
+          (:: macro;Monad<Meta> wrap))
+
+      _
+      (:: macro;Monad<Meta> wrap (re-quantify envs caseT)))))
 
 ## This function handles several concerns at once, but it must be that
 ## way because those concerns are interleaved when doing
diff --git a/new-luxc/source/luxc/lang/analysis/inference.lux b/new-luxc/source/luxc/lang/analysis/inference.lux
index c6f0323f7..e89ab2e1e 100644
--- a/new-luxc/source/luxc/lang/analysis/inference.lux
+++ b/new-luxc/source/luxc/lang/analysis/inference.lux
@@ -132,9 +132,9 @@
     ))
 
 ## Turns a record type into the kind of function type suitable for inference.
-(def: #export (record type)
+(def: #export (record inferT)
   (-> Type (Meta Type))
-  (case type
+  (case inferT
     (#;Named name unnamedT)
     (record unnamedT)
 
@@ -146,17 +146,25 @@
     ([#;UnivQ]
      [#;ExQ])
 
+    (#;Apply inputT funcT)
+    (case (type;apply (list inputT) funcT)
+      (#;Some outputT)
+      (record outputT)
+
+      #;None
+      (&;throw Invalid-Type-Application (%type inferT)))
+
     (#;Product _)
-    (macro/wrap (type;function (type;flatten-tuple type) type))
+    (macro/wrap (type;function (type;flatten-tuple inferT) inferT))
 
     _
-    (&;throw Not-A-Record-Type (%type type))))
+    (&;throw Not-A-Record-Type (%type inferT))))
 
 ## Turns a variant type into the kind of function type suitable for inference.
-(def: #export (variant tag expected-size type)
+(def: #export (variant tag expected-size inferT)
   (-> Nat Nat Type (Meta Type))
   (loop [depth +0
-         currentT type]
+         currentT inferT]
     (case currentT
       (#;Named name unnamedT)
       (do macro;Monad<Meta>
@@ -182,12 +190,12 @@
                 (#;Some caseT)
                 (macro/wrap (if (n.= +0 depth)
                               (type;function (list caseT) currentT)
-                              (let [replace! (replace-bound (|> depth n.dec (n.* +2)) type)]
+                              (let [replace! (replace-bound (|> depth n.dec (n.* +2)) inferT)]
                                 (type;function (list (replace! caseT))
                                   (replace! currentT)))))
 
                 #;None
-                (&common;variant-out-of-bounds-error type expected-size tag))
+                (&common;variant-out-of-bounds-error inferT expected-size tag))
               
               (n.< expected-size actual-size)
               (&;throw Smaller-Variant-Than-Expected
@@ -198,12 +206,20 @@
               (let [caseT (type;variant (list;drop boundary cases))]
                 (macro/wrap (if (n.= +0 depth)
                               (type;function (list caseT) currentT)
-                              (let [replace! (replace-bound (|> depth n.dec (n.* +2)) type)]
+                              (let [replace! (replace-bound (|> depth n.dec (n.* +2)) inferT)]
                                 (type;function (list (replace! caseT))
                                   (replace! currentT))))))
               
               ## else
-              (&common;variant-out-of-bounds-error type expected-size tag)))
+              (&common;variant-out-of-bounds-error inferT expected-size tag)))
+
+      (#;Apply inputT funcT)
+      (case (type;apply (list inputT) funcT)
+        (#;Some outputT)
+        (variant tag expected-size outputT)
+
+        #;None
+        (&;throw Invalid-Type-Application (%type inferT)))
 
       _
-      (&;throw Not-A-Variant-Type (%type type)))))
+      (&;throw Not-A-Variant-Type (%type inferT)))))
diff --git a/new-luxc/source/luxc/lang/analysis/procedure/common.lux b/new-luxc/source/luxc/lang/analysis/procedure/common.lux
index 489414c2a..f5afca5bf 100644
--- a/new-luxc/source/luxc/lang/analysis/procedure/common.lux
+++ b/new-luxc/source/luxc/lang/analysis/procedure/common.lux
@@ -172,7 +172,7 @@
       (|> (dict;new text;Hash<Text>)
           (install "log" (unary Text Unit))
           (install "error" (unary Text Bottom))
-          (install "exit" (unary Nat Bottom))
+          (install "exit" (unary Int Bottom))
           (install "current-time" (nullary Int)))))
 
 (def: bit-procs
@@ -202,7 +202,7 @@
           (install "min" (nullary Nat))
           (install "max" (nullary Nat))
           (install "to-int" (unary Nat Int))
-          (install "to-text" (unary Nat Text)))))
+          (install "char" (unary Nat Text)))))
 
 (def: int-procs
   Bundle
@@ -277,28 +277,28 @@
           (install "lower" (unary Text Text))
           )))
 
-(def: (array-get proc)
+(def: (array//get proc)
   (-> Text Proc)
   (function [analyse eval args]
     (do macro;Monad<Meta>
       [[var-id varT] (&;with-type-env tc;var)]
-      ((binary Nat (type (Array varT)) varT proc)
+      ((binary (type (Array varT)) Nat (type (Maybe varT)) proc)
        analyse eval args))))
 
-(def: (array-put proc)
+(def: (array//put proc)
   (-> Text Proc)
   (function [analyse eval args]
     (do macro;Monad<Meta>
       [[var-id varT] (&;with-type-env tc;var)]
-      ((trinary Nat varT (type (Array varT)) (type (Array varT)) proc)
+      ((trinary (type (Array varT)) Nat varT (type (Array varT)) proc)
        analyse eval args))))
 
-(def: (array-remove proc)
+(def: (array//remove proc)
   (-> Text Proc)
   (function [analyse eval args]
     (do macro;Monad<Meta>
       [[var-id varT] (&;with-type-env tc;var)]
-      ((binary Nat (type (Array varT)) (type (Array varT)) proc)
+      ((binary (type (Array varT)) Nat (type (Array varT)) proc)
        analyse eval args))))
 
 (def: array-procs
@@ -306,9 +306,9 @@
   (<| (prefix "array")
       (|> (dict;new text;Hash<Text>)
           (install "new" (unary Nat Array))
-          (install "get" array-get)
-          (install "put" array-put)
-          (install "remove" array-remove)
+          (install "get" array//get)
+          (install "put" array//put)
+          (install "remove" array//remove)
           (install "size" (unary (type (Ex [a] (Array a))) Nat))
           )))
 
@@ -359,12 +359,12 @@
       ((unary (type (Atom varT)) varT proc)
        analyse eval args))))
 
-(def: (atom-compare-and-swap proc)
+(def: (atom//compare-and-swap proc)
   (-> Text Proc)
   (function [analyse eval args]
     (do macro;Monad<Meta>
       [[var-id varT] (&;with-type-env tc;var)]
-      ((trinary varT varT (type (Atom varT)) Bool proc)
+      ((trinary (type (Atom varT)) varT varT Bool proc)
        analyse eval args))))
 
 (def: atom-procs
@@ -373,7 +373,7 @@
       (|> (dict;new text;Hash<Text>)
           (install "new" atom-new)
           (install "read" atom-read)
-          (install "compare-and-swap" atom-compare-and-swap)
+          (install "compare-and-swap" atom//compare-and-swap)
           )))
 
 (def: process-procs
diff --git a/new-luxc/source/luxc/lang/synthesis/loop.lux b/new-luxc/source/luxc/lang/synthesis/loop.lux
index ac72e69b2..a5da743d5 100644
--- a/new-luxc/source/luxc/lang/synthesis/loop.lux
+++ b/new-luxc/source/luxc/lang/synthesis/loop.lux
@@ -152,7 +152,7 @@
                                _
                                _var))
                            environment))]
-            (~ (recur bodyS))))
+            (~ bodyS)))
 
         (^ [_ (#;Form (list& [_ (#;Text "lux call")] funcS argsS))])
         (` ("lux call" (~ (recur funcS)) (~@ (list/map recur argsS))))
@@ -160,15 +160,7 @@
         (^ [_ (#;Form (list& [_ (#;Text "lux recur")] argsS))])
         (` ("lux recur" (~@ (list/map recur argsS))))
         
-        (^ [_ (#;Form (list& [_ (#;Text procedure)] argsS))])
-        (` ((~ (code;text procedure)) (~@ (list/map recur argsS))))
-
-        (^ [_ (#;Form (list [_ (#;Int var)]))])
-        (if (variableL;captured? var)
-          (` ((~ (code;int (resolve-captured var)))))
-          (` ((~ (code;int (|> offset nat-to-int (i.+ var)))))))
-
-        (^ [_ (#;Form (list [_ (#;Text "lux let")] [_ (#;Nat register)] inputS bodyS))])
+        (^code ("lux let" (~ [_ (#;Nat register)]) (~ inputS) (~ bodyS)))
         (` ("lux let" (~ (code;nat (n.+ offset register)))
             (~ (recur inputS))
             (~ (recur bodyS))))
@@ -183,6 +175,14 @@
             [(~@ (list/map recur initsS))]
             (~ (recur bodyS))))
 
+        (^ [_ (#;Form (list [_ (#;Int var)]))])
+        (if (variableL;captured? var)
+          (` ((~ (code;int (resolve-captured var)))))
+          (` ((~ (code;int (|> offset nat-to-int (i.+ var)))))))
+
+        (^ [_ (#;Form (list& [_ (#;Text procedure)] argsS))])
+        (` ((~ (code;text procedure)) (~@ (list/map recur argsS))))
+
         _
         exprS
         ))))
diff --git a/new-luxc/source/luxc/lang/translation.lux b/new-luxc/source/luxc/lang/translation.lux
index fbecf2da5..80484b7e8 100644
--- a/new-luxc/source/luxc/lang/translation.lux
+++ b/new-luxc/source/luxc/lang/translation.lux
@@ -128,8 +128,9 @@
                                        (analyse valueC))))
                valueT (&;with-type-env
                         (tc;clean valueT))
-               ## #let [_ (if (or (text/= "list/size" def-name))
+               ## #let [_ (if (or (text/= "string~" def-name))
                ##           (log! (format "{" def-name "}\n"
+               ##                         "     TYPE: " (%type valueT) "\n"
                ##                         " ANALYSIS: " (%code valueA) "\n"
                ##                         "SYNTHESIS: " (%code (expressionS;synthesize valueA))))
                ##           [])]
diff --git a/new-luxc/source/luxc/lang/translation/procedure/common.jvm.lux b/new-luxc/source/luxc/lang/translation/procedure/common.jvm.lux
index 6c1b18932..01f2a33c7 100644
--- a/new-luxc/source/luxc/lang/translation/procedure/common.jvm.lux
+++ b/new-luxc/source/luxc/lang/translation/procedure/common.jvm.lux
@@ -224,7 +224,7 @@
 ## [[Arrays]]
 (def: (array//new lengthI)
   Unary
-  (|>. lengthI jvm-intI ($i;ANEWARRAY ($t;descriptor $Object))))
+  (|>. lengthI jvm-intI ($i;ANEWARRAY ($t;binary-name "java.lang.Object"))))
 
 (def: (array//get [arrayI idxI])
   Binary
@@ -348,9 +348,8 @@
      (|>. inputI <prepare> <transform>))]
 
   [nat//to-int id id]
-  [nat//to-char ($i;unwrap #$;Long)
-   (<| ($i;INVOKESTATIC "java.lang.Character" "toString" ($t;method (list $t;char) (#;Some $String) (list)) false)
-       $i;I2C $i;L2I)]
+  [nat//char ($i;unwrap #$;Long)
+   ((|>. $i;L2I $i;I2C ($i;INVOKESTATIC "java.lang.Character" "toString" ($t;method (list $t;char) (#;Some $String) (list)) false)))]
   
   [int//to-nat id id]
   [int//to-frac ($i;unwrap #$;Long) (<| ($i;wrap #$;Double) $i;L2D)]
@@ -397,7 +396,7 @@
    ($i;wrap #$;Boolean)]
   [text//lt ($i;CHECKCAST "java.lang.String") ($i;CHECKCAST "java.lang.String")
    ($i;INVOKEVIRTUAL "java.lang.String" "compareTo" ($t;method (list $String) (#;Some $t;int) (list)) false)
-   (predicateI $i;IF_ICMPEQ)]
+   (<| (predicateI $i;IF_ICMPEQ) ($i;int -1))]
   [text//concat ($i;CHECKCAST "java.lang.String") ($i;CHECKCAST "java.lang.String")
    ($i;INVOKEVIRTUAL "java.lang.String" "concat" ($t;method (list $String) (#;Some $String) (list)) false)
    id]
@@ -563,7 +562,8 @@
 ## [[Processes]]
 (def: (process//concurrency-level [])
   Nullary
-  (|>. ($i;GETSTATIC hostL;runtime-class "concurrency_level" $t;int)
+  (|>. ($i;INVOKESTATIC "java.lang.Runtime" "getRuntime" ($t;method (list) (#;Some ($t;class "java.lang.Runtime" (list))) (list)) false)
+       ($i;INVOKEVIRTUAL "java.lang.Runtime" "availableProcessors" ($t;method (list) (#;Some $t;int) (list)) false)
        lux-intI))
 
 (def: (process//future procedureI)
@@ -593,82 +593,87 @@
 
 (def: bit-procs
   Bundle
-  (|> (dict;new text;Hash<Text>)
-      (install "bit count" (unary bit//count))
-      (install "bit and" (binary bit//and))
-      (install "bit or" (binary bit//or))
-      (install "bit xor" (binary bit//xor))
-      (install "bit shift-left" (binary bit//shift-left))
-      (install "bit unsigned-shift-right" (binary bit//unsigned-shift-right))
-      (install "bit shift-right" (binary bit//shift-right))
-      ))
+  (<| (prefix "bit")
+      (|> (dict;new text;Hash<Text>)
+          (install "count" (unary bit//count))
+          (install "and" (binary bit//and))
+          (install "or" (binary bit//or))
+          (install "xor" (binary bit//xor))
+          (install "shift-left" (binary bit//shift-left))
+          (install "unsigned-shift-right" (binary bit//unsigned-shift-right))
+          (install "shift-right" (binary bit//shift-right))
+          )))
 
 (def: nat-procs
   Bundle
-  (|> (dict;new text;Hash<Text>)
-      (install "nat +" (binary nat//add))
-      (install "nat -" (binary nat//sub))
-      (install "nat *" (binary nat//mul))
-      (install "nat /" (binary nat//div))
-      (install "nat %" (binary nat//rem))
-      (install "nat =" (binary nat//eq))
-      (install "nat <" (binary nat//lt))
-      (install "nat min" (nullary nat//min))
-      (install "nat max" (nullary nat//max))
-      (install "nat to-int" (unary nat//to-int))
-      (install "nat to-char" (unary nat//to-char))))
+  (<| (prefix "nat")
+      (|> (dict;new text;Hash<Text>)
+          (install "+" (binary nat//add))
+          (install "-" (binary nat//sub))
+          (install "*" (binary nat//mul))
+          (install "/" (binary nat//div))
+          (install "%" (binary nat//rem))
+          (install "=" (binary nat//eq))
+          (install "<" (binary nat//lt))
+          (install "min" (nullary nat//min))
+          (install "max" (nullary nat//max))
+          (install "to-int" (unary nat//to-int))
+          (install "char" (unary nat//char)))))
 
 (def: int-procs
   Bundle
-  (|> (dict;new text;Hash<Text>)
-      (install "int +" (binary int//add))
-      (install "int -" (binary int//sub))
-      (install "int *" (binary int//mul))
-      (install "int /" (binary int//div))
-      (install "int %" (binary int//rem))
-      (install "int =" (binary int//eq))
-      (install "int <" (binary int//lt))
-      (install "int min" (nullary int//min))
-      (install "int max" (nullary int//max))
-      (install "int to-nat" (unary int//to-nat))
-      (install "int to-frac" (unary int//to-frac))))
+  (<| (prefix "int")
+      (|> (dict;new text;Hash<Text>)
+          (install "+" (binary int//add))
+          (install "-" (binary int//sub))
+          (install "*" (binary int//mul))
+          (install "/" (binary int//div))
+          (install "%" (binary int//rem))
+          (install "=" (binary int//eq))
+          (install "<" (binary int//lt))
+          (install "min" (nullary int//min))
+          (install "max" (nullary int//max))
+          (install "to-nat" (unary int//to-nat))
+          (install "to-frac" (unary int//to-frac)))))
 
 (def: deg-procs
   Bundle
-  (|> (dict;new text;Hash<Text>)
-      (install "deg +" (binary deg//add))
-      (install "deg -" (binary deg//sub))
-      (install "deg *" (binary deg//mul))
-      (install "deg /" (binary deg//div))
-      (install "deg %" (binary deg//rem))
-      (install "deg =" (binary deg//eq))
-      (install "deg <" (binary deg//lt))
-      (install "deg scale" (binary deg//scale))
-      (install "deg reciprocal" (binary deg//reciprocal))
-      (install "deg min" (nullary deg//min))
-      (install "deg max" (nullary deg//max))
-      (install "deg to-frac" (unary deg//to-frac))))
+  (<| (prefix "deg")
+      (|> (dict;new text;Hash<Text>)
+          (install "+" (binary deg//add))
+          (install "-" (binary deg//sub))
+          (install "*" (binary deg//mul))
+          (install "/" (binary deg//div))
+          (install "%" (binary deg//rem))
+          (install "=" (binary deg//eq))
+          (install "<" (binary deg//lt))
+          (install "scale" (binary deg//scale))
+          (install "reciprocal" (binary deg//reciprocal))
+          (install "min" (nullary deg//min))
+          (install "max" (nullary deg//max))
+          (install "to-frac" (unary deg//to-frac)))))
 
 (def: frac-procs
   Bundle
-  (|> (dict;new text;Hash<Text>)
-      (install "frac +" (binary frac//add))
-      (install "frac -" (binary frac//sub))
-      (install "frac *" (binary frac//mul))
-      (install "frac /" (binary frac//div))
-      (install "frac %" (binary frac//rem))
-      (install "frac =" (binary frac//eq))
-      (install "frac <" (binary frac//lt))
-      (install "frac smallest" (nullary frac//smallest))
-      (install "frac min" (nullary frac//min))
-      (install "frac max" (nullary frac//max))
-      (install "frac not-a-number" (nullary frac//not-a-number))
-      (install "frac positive-infinity" (nullary frac//positive-infinity))
-      (install "frac negative-infinity" (nullary frac//negative-infinity))
-      (install "frac to-deg" (unary frac//to-deg))
-      (install "frac to-int" (unary frac//to-int))
-      (install "frac encode" (unary frac//encode))
-      (install "frac decode" (unary frac//decode))))
+  (<| (prefix "frac")
+      (|> (dict;new text;Hash<Text>)
+          (install "+" (binary frac//add))
+          (install "-" (binary frac//sub))
+          (install "*" (binary frac//mul))
+          (install "/" (binary frac//div))
+          (install "%" (binary frac//rem))
+          (install "=" (binary frac//eq))
+          (install "<" (binary frac//lt))
+          (install "smallest" (nullary frac//smallest))
+          (install "min" (nullary frac//min))
+          (install "max" (nullary frac//max))
+          (install "not-a-number" (nullary frac//not-a-number))
+          (install "positive-infinity" (nullary frac//positive-infinity))
+          (install "negative-infinity" (nullary frac//negative-infinity))
+          (install "to-deg" (unary frac//to-deg))
+          (install "to-int" (unary frac//to-int))
+          (install "encode" (unary frac//encode))
+          (install "decode" (unary frac//decode)))))
 
 (def: text-procs
   Bundle
@@ -690,59 +695,64 @@
 
 (def: array-procs
   Bundle
-  (|> (dict;new text;Hash<Text>)
-      (install "array new" (unary array//new))
-      (install "array get" (binary array//get))
-      (install "array put" (trinary array//put))
-      (install "array remove" (binary array//remove))
-      (install "array size" (unary array//size))
-      ))
+  (<| (prefix "array")
+      (|> (dict;new text;Hash<Text>)
+          (install "new" (unary array//new))
+          (install "get" (binary array//get))
+          (install "put" (trinary array//put))
+          (install "remove" (binary array//remove))
+          (install "size" (unary array//size))
+          )))
 
 (def: math-procs
   Bundle
-  (|> (dict;new text;Hash<Text>)
-      (install "math cos" (unary math//cos))
-      (install "math sin" (unary math//sin))
-      (install "math tan" (unary math//tan))
-      (install "math acos" (unary math//acos))
-      (install "math asin" (unary math//asin))
-      (install "math atan" (unary math//atan))
-      (install "math cosh" (unary math//cosh))
-      (install "math sinh" (unary math//sinh))
-      (install "math tanh" (unary math//tanh))
-      (install "math exp" (unary math//exp))
-      (install "math log" (unary math//log))
-      (install "math root2" (unary math//root2))
-      (install "math root3" (unary math//root3))
-      (install "math ceil" (unary math//ceil))
-      (install "math floor" (unary math//floor))
-      (install "math round" (unary math//round))
-      (install "math atan2" (binary math//atan2))
-      (install "math pow" (binary math//pow))
-      ))
+  (<| (prefix "math")
+      (|> (dict;new text;Hash<Text>)
+          (install "cos" (unary math//cos))
+          (install "sin" (unary math//sin))
+          (install "tan" (unary math//tan))
+          (install "acos" (unary math//acos))
+          (install "asin" (unary math//asin))
+          (install "atan" (unary math//atan))
+          (install "cosh" (unary math//cosh))
+          (install "sinh" (unary math//sinh))
+          (install "tanh" (unary math//tanh))
+          (install "exp" (unary math//exp))
+          (install "log" (unary math//log))
+          (install "root2" (unary math//root2))
+          (install "root3" (unary math//root3))
+          (install "ceil" (unary math//ceil))
+          (install "floor" (unary math//floor))
+          (install "round" (unary math//round))
+          (install "atan2" (binary math//atan2))
+          (install "pow" (binary math//pow))
+          )))
 
 (def: io-procs
   Bundle
-  (|> (dict;new text;Hash<Text>)
-      (install "io log" (unary io//log))
-      (install "io error" (unary io//error))
-      (install "io exit" (unary io//exit))
-      (install "io current-time" (nullary io//current-time))))
+  (<| (prefix "io")
+      (|> (dict;new text;Hash<Text>)
+          (install "log" (unary io//log))
+          (install "error" (unary io//error))
+          (install "exit" (unary io//exit))
+          (install "current-time" (nullary io//current-time)))))
 
 (def: atom-procs
   Bundle
-  (|> (dict;new text;Hash<Text>)
-      (install "atom new" (unary atom//new))
-      (install "atom read" (unary atom//read))
-      (install "atom compare-and-swap" (trinary atom//compare-and-swap))))
+  (<| (prefix "atom")
+      (|> (dict;new text;Hash<Text>)
+          (install "new" (unary atom//new))
+          (install "read" (unary atom//read))
+          (install "compare-and-swap" (trinary atom//compare-and-swap)))))
 
 (def: process-procs
   Bundle
-  (|> (dict;new text;Hash<Text>)
-      (install "process concurrency-level" (nullary process//concurrency-level))
-      (install "process future" (unary process//future))
-      (install "process schedule" (binary process//schedule))
-      ))
+  (<| (prefix "process")
+      (|> (dict;new text;Hash<Text>)
+          (install "concurrency-level" (nullary process//concurrency-level))
+          (install "future" (unary process//future))
+          (install "schedule" (binary process//schedule))
+          )))
 
 (def: #export procedures
   Bundle
diff --git a/stdlib/source/lux/concurrency/atom.lux b/stdlib/source/lux/concurrency/atom.lux
index 2837d6177..f2e1cc14e 100644
--- a/stdlib/source/lux/concurrency/atom.lux
+++ b/stdlib/source/lux/concurrency/atom.lux
@@ -13,7 +13,7 @@
 
 (def: #export (read atom)
   (All [a] (-> (Atom a) (IO a)))
-  (io ("lux atom get" atom)))
+  (io ("lux atom read" atom)))
 
 (def: #export (compare-and-swap current new atom)
   {#;doc "Only mutates an atom if you can present it's current value.
@@ -29,7 +29,7 @@
 
           The retries will be done with the new values of the atom, as they show up."}
   (All [a] (-> (-> a a) (Atom a) (IO Unit)))
-  (io (let [old ("lux atom get" atom)]
+  (io (let [old ("lux atom read" atom)]
         (if ("lux atom compare-and-swap" atom old (f old))
           []
           (io;run (update f atom))))))
diff --git a/stdlib/source/lux/concurrency/promise.lux b/stdlib/source/lux/concurrency/promise.lux
index 75bcc52fd..9baaded11 100644
--- a/stdlib/source/lux/concurrency/promise.lux
+++ b/stdlib/source/lux/concurrency/promise.lux
@@ -89,7 +89,9 @@
 
 (struct: #export _ (F;Functor Promise)
   (def: (map f fa)
-    (let [fb (promise ($ +1))]
+    (let [fb (promise ($ +1))
+          ## fb (promise' #;None)
+          ]
       (exec (await (function [a] (resolve (f a) fb))
                    fa)
         fb))))
@@ -102,7 +104,9 @@
            #observers (list)}))
 
   (def: (apply ff fa)
-    (let [fb (promise ($ +1))]
+    (let [fb (promise ($ +1))
+          ## fb (promise' #;None)
+          ]
       (exec (await (function [f]
                      (io (await (function [a] (resolve (f a) fb))
                                 fa)))
@@ -114,7 +118,9 @@
   (def: applicative Applicative<Promise>)
 
   (def: (join mma)
-    (let [ma (promise ($ +0))]
+    (let [ma (promise ($ +0))
+          ## ma (promise' #;None)
+          ]
       (exec (await (function [ma']
                      (io (await (function [a'] (resolve a' ma))
                                 ma')))
@@ -132,7 +138,9 @@
 (def: #export (alt left right)
   {#;doc "Heterogeneous alternative combinator."}
   (All [a b] (-> (Promise a) (Promise b) (Promise (| a b))))
-  (let [a|b (promise (Either ($ +0) ($ +1)))]
+  (let [a|b (promise (| ($ +0) ($ +1)))
+        ## a|b (promise' #;None)
+        ]
     (with-expansions
       [<sides> (do-template [<promise> <tag>]
                  [(await (function [value] (resolve (<tag> value) a|b))
@@ -147,7 +155,9 @@
 (def: #export (either left right)
   {#;doc "Homogeneous alternative combinator."}
   (All [a] (-> (Promise a) (Promise a) (Promise a)))
-  (let [left||right (promise ($ +0))]
+  (let [left||right (promise ($ +0))
+        ## left||right (promise' #;None)
+        ]
     (`` (exec (~~ (do-template [<promise>]
                     [(await (function [value] (resolve value left||right))
                             <promise>)]
@@ -159,7 +169,9 @@
 (def: #export (future computation)
   {#;doc "Runs an I/O computation on its own process and returns an Promise that will eventually host its result."}
   (All [a] (-> (IO a) (Promise a)))
-  (let [!out (promise ($ +0))]
+  (let [!out (promise ($ +0))
+        ## !out (promise' #;None)
+        ]
     (exec ("lux process future" (io (io;run (resolve (io;run computation)
                                                      !out))))
       !out)))
diff --git a/stdlib/source/lux/control/applicative.lux b/stdlib/source/lux/control/applicative.lux
index 187950aa9..d2b505941 100644
--- a/stdlib/source/lux/control/applicative.lux
+++ b/stdlib/source/lux/control/applicative.lux
@@ -1,10 +1,10 @@
 (;module:
   lux
-  (.. ["F" functor]))
+  (.. [functor #+ Functor]))
 
 (sig: #export (Applicative f)
   {#;doc "Applicative functors."}
-  (: (F;Functor f)
+  (: (Functor f)
      functor)
   (: (All [a]
        (-> a (f a)))
@@ -16,15 +16,20 @@
 (struct: #export (compose Applicative<F> Applicative<G>)
   {#;doc "Applicative functor composition."}
   (All [F G] (-> (Applicative F) (Applicative G) (Applicative (All [a] (F (G a))))))
-  (def: functor (F;compose (get@ #functor Applicative<F>)
-                           (get@ #functor Applicative<G>)))
+  
+  (def: functor (functor;compose (get@ #functor Applicative<F>)
+                                 (get@ #functor Applicative<G>)))
   (def: wrap
     (|>. (:: Applicative<G> wrap) (:: Applicative<F> wrap)))
   (def: (apply fgf fgx)
+    ## (let [fgf' (:: Applicative<F> apply
+    ##                (:: Applicative<F> wrap (:: Applicative<G> apply))
+    ##                fgf)]
+    ##   (:: Applicative<F> apply fgf' fgx))
     (let [applyF (:: Applicative<F> apply)
           applyG (:: Applicative<G> apply)]
       ($_ applyF
           (:: Applicative<F> wrap applyG)
           fgf
-          fgx)))
-  )
+          fgx))
+    ))
diff --git a/stdlib/source/lux/data/coll/array.lux b/stdlib/source/lux/data/coll/array.lux
index 2dbf07803..c697e5681 100644
--- a/stdlib/source/lux/data/coll/array.lux
+++ b/stdlib/source/lux/data/coll/array.lux
@@ -78,7 +78,19 @@
                       xs'
                       (delete idx xs')))))
              xs
-             (list;indices (size xs))))
+             (list;indices (size xs)))
+  ## (list/fold (function [idx xs']
+  ##              (case (read idx xs)
+  ##                #;None
+  ##                xs'
+
+  ##                (#;Some x)
+  ##                (if (p x)
+  ##                  xs'
+  ##                  (delete idx xs'))))
+  ##            xs
+  ##            (list;indices (size xs)))
+  )
 
 (def: #export (find p xs)
   (All [a]
@@ -195,7 +207,17 @@
                           (#;Some x)
                           (write idx (f x) mb))))
                    (new arr-size)
-                   (list;n.range +0 (n.dec arr-size)))))))
+                   (list;n.range +0 (n.dec arr-size)))
+        ## (list/fold (function [idx mb]
+        ##              (case (read idx ma)
+        ##                #;None
+        ##                mb
+
+        ##                (#;Some x)
+        ##                (write idx (f x) mb)))
+        ##            (new arr-size)
+        ##            (list;n.range +0 (n.dec arr-size)))
+        ))))
 
 (struct: #export _ (Fold Array)
   (def: (fold f init xs)
diff --git a/stdlib/source/lux/data/coll/dict.lux b/stdlib/source/lux/data/coll/dict.lux
index d5528dc09..cee6a83fc 100644
--- a/stdlib/source/lux/data/coll/dict.lux
+++ b/stdlib/source/lux/data/coll/dict.lux
@@ -120,7 +120,8 @@
 (def: (insert! idx value old-array)
   (All [a] (-> Index a (Array a) (Array a)))
   (let [old-size (array;size old-array)]
-    (|> (: (Array ($ +0))
+    (|> ## (array;new (n.inc old-size))
+        (: (Array ($ +0))
            (array;new (n.inc old-size)))
         (array;copy idx +0 old-array +0)
         (array;write idx value)
@@ -233,8 +234,10 @@
                                                         (array;write insertion-idx (#;Left sub-node) base)]])
                                   )))
                             [+0 [clean-bitmap
+                                 ## (array;new (n.dec h-size))
                                  (: (Base ($ +0) ($ +1))
-                                    (array;new (n.dec h-size)))]]
+                                    (array;new (n.dec h-size)))
+                                 ]]
                             (list;indices (array;size h-array)))))
 
 ## When #Base nodes grow too large, they're promoted to #Hierarchy to
@@ -264,8 +267,10 @@
                                    (undefined))]
                                 default))
                             [+0
+                             ## (array;new hierarchy-nodes-size)
                              (: (Array (Node ($ +0) ($ +1)))
-                                (array;new hierarchy-nodes-size))]
+                                (array;new hierarchy-nodes-size))
+                             ]
                             hierarchy-indices)))
 
 ## All empty nodes look the same (a #Base node with clean bitmap is
@@ -287,13 +292,20 @@
     ## a sub-node. If impossible, I introduced a new singleton sub-node.
     (#Hierarchy _size hierarchy)
     (let [idx (level-index level hash)
+          ## [_size' sub-node] (case (array;read idx hierarchy)
+          ##                     (#;Some sub-node)
+          ##                     [_size sub-node]
+
+          ##                     _
+          ##                     [(n.inc _size) empty])
           [_size' sub-node] (: [Nat (Node ($ +0) ($ +1))]
                                (case (array;read idx hierarchy)
                                  (#;Some sub-node)
                                  [_size sub-node]
 
                                  _
-                                 [(n.inc _size) empty]))]
+                                 [(n.inc _size) empty]))
+          ]
       (#Hierarchy _size'
                   (update! idx (put' (level-up level) hash key val Hash<k> sub-node)
                            hierarchy)))
@@ -327,7 +339,8 @@
                                                  ## the same, a new
                                                  ## #Collisions node
                                                  ## is added.
-                                                 (#Collisions hash (|> (: (Array [($ +0) ($ +1)])
+                                                 (#Collisions hash (|> ## (array;new +2)
+                                                                       (: (Array [($ +0) ($ +1)])
                                                                           (array;new +2))
                                                                        (array;write +0 [key' val'])
                                                                        (array;write +1 [key val])))
@@ -373,7 +386,8 @@
       ## If the hashes are not equal, I create a new #Base node that
       ## contains the old #Collisions node, plus the new KV-pair.
       (|> (#Base (bit-position level _hash)
-                 (|> (: (Base ($ +0) ($ +1))
+                 (|> ## (array;new +1)
+                     (: (Base ($ +0) ($ +1))
                         (array;new +1))
                      (array;write +0 (#;Left node))))
           (put' level hash key val Hash<k>)))
diff --git a/stdlib/source/lux/data/coll/list.lux b/stdlib/source/lux/data/coll/list.lux
index 4d4090835..d7bbe0161 100644
--- a/stdlib/source/lux/data/coll/list.lux
+++ b/stdlib/source/lux/data/coll/list.lux
@@ -483,7 +483,9 @@
     (do Monad<M>
       [lMla MlMla
        lla (: (($ +0) (List (List ($ +1))))
-              (M;seq @ lMla))]
+              (M;seq @ lMla))
+       ## lla (M;seq @ lMla)
+       ]
       (wrap (concat lla)))))
 
 (def: #export (lift Monad<M>)
diff --git a/stdlib/source/lux/data/coll/sequence.lux b/stdlib/source/lux/data/coll/sequence.lux
index f85558c5e..f76c824a7 100644
--- a/stdlib/source/lux/data/coll/sequence.lux
+++ b/stdlib/source/lux/data/coll/sequence.lux
@@ -74,14 +74,16 @@
   (All [a] (-> Level (Base a) (Node a)))
   (if (n.= +0 level)
     (#Base tail)
-    (|> (: (Hierarchy ($ +0))
+    (|> ## (new-hierarchy [])
+        (: (Hierarchy ($ +0))
            (new-hierarchy []))
         (array;write +0 (new-path (level-down level) tail))
         #Hierarchy)))
 
 (def: (new-tail singleton)
   (All [a] (-> a (Base a)))
-  (|> (: (Base ($ +0))
+  (|> ## (array;new +1)
+      (: (Base ($ +0))
          (array;new +1))
       (array;write +0 singleton)))
 
@@ -110,7 +112,8 @@
 (def: (expand-tail val tail)
   (All [a] (-> a (Base a) (Base a)))
   (let [tail-size (array;size tail)]
-    (|> (: (Base ($ +0))
+    (|> ## (array;new (n.inc tail-size))
+        (: (Base ($ +0))
            (array;new (n.inc tail-size)))
         (array;copy tail-size +0 tail +0)
         (array;write tail-size val)
@@ -208,7 +211,8 @@
             ## If so, a brand-new root must be established, that is
             ## 1-level taller.
             (|> vec
-                (set@ #root (|> (: (Hierarchy ($ +0))
+                (set@ #root (|> ## (new-hierarchy [])
+                                (: (Hierarchy ($ +0))
                                    (new-hierarchy []))
                                 (array;write +0 (#Hierarchy (get@ #root vec)))
                                 (array;write +1 (new-path (get@ #level vec) (get@ #tail vec)))))
@@ -259,8 +263,10 @@
              (n.< vec-size idx))
       (if (n.>= (tail-off vec-size) idx)
         (|> vec
+            ## (update@ #tail (|>. array;clone (array;write (branch-idx idx) val)))
             (update@ #tail (: (-> (Base ($ +0)) (Base ($ +0)))
-                              (|>. array;clone (array;write (branch-idx idx) val)))))
+                              (|>. array;clone (array;write (branch-idx idx) val))))
+            )
         (|> vec
             (update@ #root (put' (get@ #level vec) idx val))))
       vec)))
@@ -294,7 +300,26 @@
       (maybe;assume
        (do maybe;Monad<Maybe>
          [new-tail (base-for (n.- +2 vec-size) vec)
-          #let [[level' root'] (: [Level (Hierarchy ($ +0))]
+          #let [## [level' root'] (let [init-level (get@ #level vec)]
+                ##                  (loop [level init-level
+                ##                         root (maybe;default (new-hierarchy [])
+                ##                                             (pop-tail vec-size init-level (get@ #root vec)))
+                ##                         ## root (: (Hierarchy ($ +0))
+                ##                         ##         (maybe;default (new-hierarchy [])
+                ##                         ##                        (pop-tail vec-size init-level (get@ #root vec))))
+                ##                         ]
+                ##                    (if (n.> branching-exponent level)
+                ##                      (case [(array;read +1 root) (array;read +0 root)]
+                ##                        [#;None (#;Some (#Hierarchy sub-node))]
+                ##                        (recur (level-down level) sub-node)
+
+                ##                        ## [#;None (#;Some (#Base _))]
+                ##                        ## (undefined)
+
+                ##                        _
+                ##                        [level root])
+                ##                      [level root])))
+                [level' root'] (: [Level (Hierarchy ($ +0))]
                                   (let [init-level (get@ #level vec)]
                                     (loop [level init-level
                                            root (: (Hierarchy ($ +0))
@@ -310,7 +335,8 @@
 
                                           _
                                           [level root])
-                                        [level root]))))]]
+                                        [level root]))))
+                ]]
          (wrap (|> vec
                    (update@ #size n.dec)
                    (set@ #level level')
@@ -326,6 +352,7 @@
 (def: #export (from-list list)
   (All [a] (-> (List a) (Sequence a)))
   (list/fold add
+             ## empty
              (: (Sequence ($ +0))
                 empty)
              list))
@@ -353,7 +380,9 @@
       
       [(#Hierarchy h1) (#Hierarchy h2)]
       (:: (array;Eq<Array> (Eq<Node> Eq<a>)) = h1 h2)
-      )))
+
+      _
+      false)))
 
 (struct: #export (Eq<Sequence> Eq<a>) (All [a] (-> (Eq a) (Eq (Sequence a))))
   (def: (= v1 v2)
diff --git a/stdlib/source/lux/data/number.lux b/stdlib/source/lux/data/number.lux
index 5b8e1946d..446e1e152 100644
--- a/stdlib/source/lux/data/number.lux
+++ b/stdlib/source/lux/data/number.lux
@@ -8,7 +8,7 @@
                 enum
                 interval
                 codec)
-       (data ["E" error]
+       (data ["e" error]
              [maybe]
              [bit])))
 
@@ -162,10 +162,10 @@
      (def: (decode input)
        (case (<decoder> [input])
          (#;Some value)
-         (#E;Success value)
+         (#e;Success value)
 
          #;None
-         (#E;Error <error>))))]
+         (#e;Error <error>))))]
 
   [Frac "lux frac encode" "lux frac decode" "Could not decode Frac"]
   )
@@ -199,16 +199,16 @@
                    (let [digit (maybe;assume (get-char input idx))]
                      (case ("lux text index" <char-set> digit +0)
                        #;None
-                       (#E;Error ("lux text concat" <error> repr))
+                       (#e;Error ("lux text concat" <error> repr))
 
                        (#;Some index)
                        (recur (n.inc idx)
                               (|> output (n.* <base>) (n.+ index)))))
-                   (#E;Success output))))
+                   (#e;Success output))))
 
              _
-             (#E;Error ("lux text concat" <error> repr)))
-           (#E;Error ("lux text concat" <error> repr))))))]
+             (#e;Error ("lux text concat" <error> repr)))
+           (#e;Error ("lux text concat" <error> repr))))))]
 
   [Binary@Codec<Text,Nat> +2  "01"               "Invalid binary syntax for Nat: "]
   [Octal@Codec<Text,Nat>  +8  "01234567"         "Invalid octal syntax for Nat: "]
@@ -250,13 +250,13 @@
                  (let [digit (maybe;assume (get-char input idx))]
                    (case ("lux text index" <char-set> digit +0)
                      #;None
-                     (#E;Error <error>)
+                     (#e;Error <error>)
 
                      (#;Some index)
                      (recur (n.inc idx)
                             (|> output (i.* <base>) (i.+ (:! Int index))))))
-                 (#E;Success (i.* sign output)))))
-           (#E;Error <error>)))))]
+                 (#e;Success (i.* sign output)))))
+           (#e;Error <error>)))))]
 
   [Binary@Codec<Text,Int> 2  "01"               "Invalid binary syntax for Int: "]
   [Octal@Codec<Text,Int>  8  "01234567"         "Invalid octal syntax for Int: "]
@@ -289,12 +289,12 @@
            (case ("lux text char" repr +0)
              (^multi (^ (#;Some (char ".")))
                      [(:: <nat> decode ("lux text concat" "+" (de-prefix repr)))
-                      (#;Some output)])
-             (#E;Success (:! Deg output))
+                      (#e;Success output)])
+             (#e;Success (:! Deg output))
 
              _
-             (#E;Error ("lux text concat" <error> repr)))
-           (#E;Error ("lux text concat" <error> repr))))))]
+             (#e;Error ("lux text concat" <error> repr)))
+           (#e;Error ("lux text concat" <error> repr))))))]
 
   [Binary@Codec<Text,Deg> Binary@Codec<Text,Nat> +1 "Invalid binary syntax: "]
   [Octal@Codec<Text,Deg>  Octal@Codec<Text,Nat>  +3 "Invalid octal syntax: "]
@@ -327,7 +327,7 @@
                decimal-part (maybe;assume ("lux text clip" repr (n.inc split-index) ("lux text size" repr)))]
            (case [(:: <int> decode whole-part)
                   (:: <int> decode decimal-part)]
-             (^multi [(#;Some whole) (#;Some decimal)]
+             (^multi [(#e;Success whole) (#e;Success decimal)]
                      (i.>= 0 decimal))
              (let [sign (if (i.< 0 whole)
                           -1.0
@@ -340,19 +340,19 @@
                                         (f.* <base> output))))
                    adjusted-decimal (|> decimal int-to-frac (f./ div-power))
                    dec-deg (case (:: Hex@Codec<Text,Deg> decode ("lux text concat" "." decimal-part))
-                             (#E;Success dec-deg)
+                             (#e;Success dec-deg)
                              dec-deg
 
-                             (#E;Error error)
+                             (#e;Error error)
                              (error! error))]
-               (#E;Success (f.+ (int-to-frac whole)
+               (#e;Success (f.+ (int-to-frac whole)
                                 (f.* sign adjusted-decimal))))
 
              _
-             (#E;Error ("lux text concat" <error> repr))))
+             (#e;Error ("lux text concat" <error> repr))))
 
          _
-         (#E;Error ("lux text concat" <error> repr)))))]
+         (#e;Error ("lux text concat" <error> repr)))))]
 
   [Binary@Codec<Text,Frac> Binary@Codec<Text,Int> 2.0 "01" "Invalid binary syntax: "]
   )
@@ -524,14 +524,14 @@
                                ("lux text concat" (<to> whole-part))
                                ("lux text concat" (if (f.= -1.0 sign) "-" "")))]
              (case (:: Binary@Codec<Text,Frac> decode as-binary)
-               (#E;Error _)
-               (#E;Error ("lux text concat" <error> repr))
+               (#e;Error _)
+               (#e;Error ("lux text concat" <error> repr))
 
                output
                output))
 
            _
-           (#E;Error ("lux text concat" <error> repr))))))]
+           (#e;Error ("lux text concat" <error> repr))))))]
 
   [Octal@Codec<Text,Frac> "Invalid octaladecimal syntax: " binary-to-octal octal-to-binary]
   [Hex@Codec<Text,Frac>   "Invalid hexadecimal syntax: "   binary-to-hex   hex-to-binary]
@@ -543,26 +543,26 @@
      (case tokens
        (#;Cons [meta (#;Text repr)] #;Nil)
        (case (:: <nat> decode repr)
-         (#E;Success value)
-         (#E;Success [state (list [meta (#;Nat value)])])
+         (#e;Success value)
+         (#e;Success [state (list [meta (#;Nat value)])])
 
-         (^multi (#E;Error _)
-                 [(:: <int> decode repr) (#E;Success value)])
-         (#E;Success [state (list [meta (#;Int value)])])
+         (^multi (#e;Error _)
+                 [(:: <int> decode repr) (#e;Success value)])
+         (#e;Success [state (list [meta (#;Int value)])])
 
-         (^multi (#E;Error _)
-                 [(:: <deg> decode repr) (#E;Success value)])
-         (#E;Success [state (list [meta (#;Deg value)])])
+         (^multi (#e;Error _)
+                 [(:: <deg> decode repr) (#e;Success value)])
+         (#e;Success [state (list [meta (#;Deg value)])])
 
-         (^multi (#E;Error _)
-                 [(:: <frac> decode repr) (#E;Success value)])
-         (#E;Success [state (list [meta (#;Frac value)])])
+         (^multi (#e;Error _)
+                 [(:: <frac> decode repr) (#e;Success value)])
+         (#e;Success [state (list [meta (#;Frac value)])])
 
          _
-         (#E;Error <error>))
+         (#e;Error <error>))
 
        _
-       (#E;Error <error>)))]
+       (#e;Error <error>)))]
 
   [bin Binary@Codec<Text,Nat> Binary@Codec<Text,Int> Binary@Codec<Text,Deg> Binary@Codec<Text,Frac>
    "Invalid binary syntax."
@@ -757,11 +757,11 @@
                   (recur (digits-sub! power digits)
                          (n.inc idx)
                          (bit;set (n.- idx (n.dec bit;width)) output))))
-              (#E;Success (:! Deg output))))
+              (#e;Success (:! Deg output))))
 
           #;None
-          (#E;Error ("lux text concat" "Wrong syntax for Deg: " input)))
-        (#E;Error ("lux text concat" "Wrong syntax for Deg: " input))))
+          (#e;Error ("lux text concat" "Wrong syntax for Deg: " input)))
+        (#e;Error ("lux text concat" "Wrong syntax for Deg: " input))))
     ))
 
 (def: (log2 input)
diff --git a/stdlib/source/lux/data/text.lux b/stdlib/source/lux/data/text.lux
index 0611e6e79..fe57508cc 100644
--- a/stdlib/source/lux/data/text.lux
+++ b/stdlib/source/lux/data/text.lux
@@ -20,7 +20,12 @@
 
 (def: #export (contains? sub text)
   (-> Text Text Bool)
-  ("lux text contains?" text sub))
+  (case ("lux text index" text sub +0)
+    (#;Some _)
+    true
+
+    _
+    false))
 
 (do-template [<name> <proc>]
   [(def: #export (<name> input)
@@ -213,7 +218,7 @@
 
 (def: #export (from-code code)
   (-> Nat Text)
-  ("lux nat to-char" code))
+  ("lux nat char" code))
 
 (def: #export (space? char)
   {#;doc "Checks whether the character is white-space."}
diff --git a/stdlib/source/lux/lang/type.lux b/stdlib/source/lux/lang/type.lux
index 974561605..d4a3d7d1b 100644
--- a/stdlib/source/lux/lang/type.lux
+++ b/stdlib/source/lux/lang/type.lux
@@ -30,7 +30,7 @@
         (<tag> env def)
 
         _
-        type))
+        (<tag> (list/map (beta-reduce env) old-env) def)))
     ([#;UnivQ]
      [#;ExQ])
     
diff --git a/stdlib/source/lux/macro/syntax.lux b/stdlib/source/lux/macro/syntax.lux
index 917b7e094..0f2777ed8 100644
--- a/stdlib/source/lux/macro/syntax.lux
+++ b/stdlib/source/lux/macro/syntax.lux
@@ -228,15 +228,16 @@
                                                  (with-brackets (spaced (list/map constructor-arg$ constructor-args)))
                                                  (with-brackets (spaced (list/map (method-def$ id) methods))))))]
                   (wrap (list (` ((~ (code;text def-code)))))))))}
-  (let [[exported? tokens] (case tokens
-                             (^ (list& [_ (#;Tag ["" "hidden"])] tokens'))
-                             [(#;Some #;Left) tokens']
+  (let [[exported? tokens] (: [(Maybe (Either Unit Unit)) (List Code)]
+                              (case tokens
+                                (^ (list& [_ (#;Tag ["" "hidden"])] tokens'))
+                                [(#;Some #;Left) tokens']
 
-                             (^ (list& [_ (#;Tag ["" "export"])] tokens'))
-                             [(#;Some #;Right) tokens']
+                                (^ (list& [_ (#;Tag ["" "export"])] tokens'))
+                                [(#;Some #;Right) tokens']
 
-                             _
-                             [#;None tokens])
+                                _
+                                [#;None tokens]))
         ?parts (: (Maybe [Text (List Code) Code Code])
                   (case tokens
                     (^ (list [_ (#;Form (list& [_ (#;Symbol ["" name])] args))]
@@ -270,10 +271,10 @@
            #let [g!state (code;symbol ["" "*compiler*"])
                  error-msg (code;text (text/compose "Wrong syntax for " name))
                  export-ast (: (List Code) (case exported?
-                                             (#;Some #E;Error)
+                                             (#;Some #;Left)
                                              (list (' #hidden))
 
-                                             (#;Some #E;Success)
+                                             (#;Some #;Right)
                                              (list (' #export))
 
                                              _
diff --git a/stdlib/source/lux/math.lux b/stdlib/source/lux/math.lux
index d1671537d..700bc9919 100644
--- a/stdlib/source/lux/math.lux
+++ b/stdlib/source/lux/math.lux
@@ -9,20 +9,17 @@
               [code])))
 
 ## [Values]
-(do-template [<name> <value>]
+(do-template [<name> <value> <doc>]
   [(def: #export <name>
+     {#;doc <doc>}
      Frac
-     (<value>))]
+     <value>)]
 
-  [e  "lux math e"]
-  [pi "lux math pi"]
+  [e   2.7182818284590452354  "The base of the natural logarithm."]
+  [pi  3.14159265358979323846 "The ratio of a circle's circumference to its diameter."]
+  [tau 6.28318530717958647692 "The ratio of a circle's circumference to its radius."]
   )
 
-(def: #export tau
-  {#;doc "The same as 2*PI."}
-  Frac
-  6.28318530717958647692)
-
 (do-template [<name> <method>]
   [(def: #export (<name> input)
      (-> Frac Frac)
diff --git a/stdlib/source/lux/type/opaque.lux b/stdlib/source/lux/type/opaque.lux
index 3b50fcbc2..636acd6e2 100644
--- a/stdlib/source/lux/type/opaque.lux
+++ b/stdlib/source/lux/type/opaque.lux
@@ -68,28 +68,30 @@
            this-module (|> this-module
                            (update@ #;defs (put down-cast (: Def
                                                              [Macro macro-anns
-                                                              (function [tokens]
-                                                                (case tokens
-                                                                  (^ (list value))
-                                                                  (wrap (list (` ((: (All [(~@ type-varsC)]
-                                                                                       (-> (~ representation-declaration) (~ opaque-declaration)))
-                                                                                     (|>. :!!))
-                                                                                  (~ value)))))
-
-                                                                  _
-                                                                  (macro;fail ($_ text/compose "Wrong syntax for " down-cast))))])))
+                                                              (: Macro
+                                                                 (function [tokens]
+                                                                   (case tokens
+                                                                     (^ (list value))
+                                                                     (wrap (list (` ((: (All [(~@ type-varsC)]
+                                                                                          (-> (~ representation-declaration) (~ opaque-declaration)))
+                                                                                        (|>. :!!))
+                                                                                     (~ value)))))
+
+                                                                     _
+                                                                     (macro;fail ($_ text/compose "Wrong syntax for " down-cast)))))])))
                            (update@ #;defs (put up-cast (: Def
                                                            [Macro macro-anns
-                                                            (function [tokens]
-                                                              (case tokens
-                                                                (^ (list value))
-                                                                (wrap (list (` ((: (All [(~@ type-varsC)]
-                                                                                     (-> (~ opaque-declaration) (~ representation-declaration)))
-                                                                                   (|>. :!!))
-                                                                                (~ value)))))
-
-                                                                _
-                                                                (macro;fail ($_ text/compose "Wrong syntax for " up-cast))))]))))]]
+                                                            (: Macro
+                                                               (function [tokens]
+                                                                 (case tokens
+                                                                   (^ (list value))
+                                                                   (wrap (list (` ((: (All [(~@ type-varsC)]
+                                                                                        (-> (~ opaque-declaration) (~ representation-declaration)))
+                                                                                      (|>. :!!))
+                                                                                   (~ value)))))
+
+                                                                   _
+                                                                   (macro;fail ($_ text/compose "Wrong syntax for " up-cast)))))]))))]]
     (function [compiler]
       (#E;Success [(update@ #;modules (put this-module-name this-module) compiler)
                    []]))))