Extracted the type-parsing machinery into its own module.

6 files changed, 487 insertions, 465 deletions

diff --git a/stdlib/source/lux/control/parser/type.lux b/stdlib/source/lux/control/parser/type.lux
new file mode 100644
index 000000000..56942e5c4
--- /dev/null
+++ b/stdlib/source/lux/control/parser/type.lux
@@ -0,0 +1,348 @@
+(.module:
+  [lux (#- function log!)
+   [abstract
+    ["." monad (#+ do)]]
+   [control
+    ["." exception (#+ exception:)]
+    ["." function]]
+   [data
+    ["." name ("#@." codec)]
+    ["." error (#+ Error)]
+    [number
+     ["." nat ("#@." decimal)]]
+    ["." text ("#@." monoid)
+     format]
+    [collection
+     ["." list ("#@." functor)]
+     ["." dictionary (#+ Dictionary)]]]
+   [macro
+    ["." code]]
+   ["." type ("#@." equivalence)
+    ["." check]]]
+  ["." // (#+ Parser)])
+
+(template [<name>]
+  [(exception: #export (<name> {type Type})
+     (exception.report
+      ["Type" (%type type)]))]
+
+  [not-existential]
+  [not-recursive]
+  [not-named]
+  [not-parameter]
+  [unknown-parameter]
+  [not-function]
+  [not-application]
+  [not-polymorphic]
+  [not-variant]
+  [not-tuple]
+  )
+
+(template [<name>]
+  [(exception: #export (<name> {expected Type} {actual Type})
+     (exception.report
+      ["Expected" (%type expected)]
+      ["Actual" (%type actual)]))]
+
+  [types-do-not-match]
+  [wrong-parameter]
+  )
+
+(exception: #export (unconsumed {remaining (List Type)})
+  (exception.report
+   ["Types" (|> remaining
+                (list@map (|>> %type (format text.new-line "* ")))
+                (text.join-with ""))]))
+
+(type: #export Env
+  (Dictionary Nat [Type Code]))
+
+(type: #export (Poly a)
+  (Parser [Env (List Type)] a))
+
+(def: #export fresh Env (dictionary.new nat.hash))
+
+(def: (run' env types poly)
+  (All [a] (-> Env (List Type) (Poly a) (Error a)))
+  (case (//.run [env types] poly)
+    (#error.Failure error)
+    (#error.Failure error)
+
+    (#error.Success [[env' remaining] output])
+    (case remaining
+      #.Nil
+      (#error.Success output)
+
+      _
+      (exception.throw unconsumed remaining))))
+
+(def: #export (run type poly)
+  (All [a] (-> Type (Poly a) (Error a)))
+  (run' fresh (list type) poly))
+
+(def: #export env
+  (Poly Env)
+  (.function (_ [env inputs])
+    (#error.Success [[env inputs] env])))
+
+(def: (with-env temp poly)
+  (All [a] (-> Env (Poly a) (Poly a)))
+  (.function (_ [env inputs])
+    (case (//.run [temp inputs] poly)
+      (#error.Failure error)
+      (#error.Failure error)
+
+      (#error.Success [[_ remaining] output])
+      (#error.Success [[env remaining] output]))))
+
+(def: #export peek
+  (Poly Type)
+  (.function (_ [env inputs])
+    (case inputs
+      #.Nil
+      (#error.Failure "Empty stream of types.")
+
+      (#.Cons headT tail)
+      (#error.Success [[env inputs] headT]))))
+
+(def: #export any
+  (Poly Type)
+  (.function (_ [env inputs])
+    (case inputs
+      #.Nil
+      (#error.Failure "Empty stream of types.")
+
+      (#.Cons headT tail)
+      (#error.Success [[env tail] headT]))))
+
+(def: #export (local types poly)
+  (All [a] (-> (List Type) (Poly a) (Poly a)))
+  (.function (_ [env pass-through])
+    (case (run' env types poly)
+      (#error.Failure error)
+      (#error.Failure error)
+
+      (#error.Success output)
+      (#error.Success [[env pass-through] output]))))
+
+(def: (label idx)
+  (-> Nat Code)
+  (code.local-identifier ($_ text@compose "label" text.tab (nat@encode idx))))
+
+(def: #export (with-extension type poly)
+  (All [a] (-> Type (Poly a) (Poly [Code a])))
+  (.function (_ [env inputs])
+    (let [current-id (dictionary.size env)
+          g!var (label current-id)]
+      (case (//.run [(dictionary.put current-id [type g!var] env)
+                     inputs]
+                    poly)
+        (#error.Failure error)
+        (#error.Failure error)
+
+        (#error.Success [[_ inputs'] output])
+        (#error.Success [[env inputs'] [g!var output]])))))
+
+(template [<name> <flattener> <tag> <exception>]
+  [(def: #export (<name> poly)
+     (All [a] (-> (Poly a) (Poly a)))
+     (do //.monad
+       [headT any]
+       (let [members (<flattener> (type.un-name headT))]
+         (if (n/> 1 (list.size members))
+           (local members poly)
+           (//.fail (exception.construct <exception> headT))))))]
+
+  [variant type.flatten-variant #.Sum     not-variant]
+  [tuple   type.flatten-tuple   #.Product not-tuple]
+  )
+
+(def: polymorphic'
+  (Poly [Nat Type])
+  (do //.monad
+    [headT any
+     #let [[num-arg bodyT] (type.flatten-univ-q (type.un-name headT))]]
+    (if (n/= 0 num-arg)
+      (//.fail (exception.construct not-polymorphic headT))
+      (wrap [num-arg bodyT]))))
+
+(def: #export (polymorphic poly)
+  (All [a] (-> (Poly a) (Poly [Code (List Code) a])))
+  (do //.monad
+    [headT any
+     funcI (:: @ map dictionary.size ..env)
+     [num-args non-poly] (local (list headT) polymorphic')
+     env ..env
+     #let [funcL (label funcI)
+           [all-varsL env'] (loop [current-arg 0
+                                   env' env
+                                   all-varsL (: (List Code) (list))]
+                              (if (n/< num-args current-arg)
+                                (if (n/= 0 current-arg)
+                                  (let [varL (label (inc funcI))]
+                                    (recur (inc current-arg)
+                                           (|> env'
+                                               (dictionary.put funcI [headT funcL])
+                                               (dictionary.put (inc funcI) [(#.Parameter (inc funcI)) varL]))
+                                           (#.Cons varL all-varsL)))
+                                  (let [partialI (|> current-arg (n/* 2) (n/+ funcI))
+                                        partial-varI (inc partialI)
+                                        partial-varL (label partial-varI)
+                                        partialC (` ((~ funcL) (~+ (|> (list.indices num-args)
+                                                                       (list@map (|>> (n/* 2) inc (n/+ funcI) label))
+                                                                       list.reverse))))]
+                                    (recur (inc current-arg)
+                                           (|> env'
+                                               (dictionary.put partialI [.Nothing partialC])
+                                               (dictionary.put partial-varI [(#.Parameter partial-varI) partial-varL]))
+                                           (#.Cons partial-varL all-varsL))))
+                                [all-varsL env']))]]
+    (|> (do @
+          [output poly]
+          (wrap [funcL all-varsL output]))
+        (local (list non-poly))
+        (with-env env'))))
+
+(def: #export (function in-poly out-poly)
+  (All [i o] (-> (Poly i) (Poly o) (Poly [i o])))
+  (do //.monad
+    [headT any
+     #let [[inputsT outputT] (type.flatten-function (type.un-name headT))]]
+    (if (n/> 0 (list.size inputsT))
+      (//.and (local inputsT in-poly)
+              (local (list outputT) out-poly))
+      (//.fail (exception.construct not-function headT)))))
+
+(def: #export (apply poly)
+  (All [a] (-> (Poly a) (Poly a)))
+  (do //.monad
+    [headT any
+     #let [[funcT paramsT] (type.flatten-application (type.un-name headT))]]
+    (if (n/= 0 (list.size paramsT))
+      (//.fail (exception.construct not-application headT))
+      (local (#.Cons funcT paramsT) poly))))
+
+(template [<name> <test>]
+  [(def: #export (<name> expected)
+     (-> Type (Poly Any))
+     (do //.monad
+       [actual any]
+       (if (<test> expected actual)
+         (wrap [])
+         (//.fail (exception.construct types-do-not-match [expected actual])))))]
+
+  [exactly type@=]
+  [sub     check.checks?]
+  [super   (function.flip check.checks?)]
+  )
+
+(def: #export (adjusted-idx env idx)
+  (-> Env Nat Nat)
+  (let [env-level (n// 2 (dictionary.size env))
+        parameter-level (n// 2 idx)
+        parameter-idx (n/% 2 idx)]
+    (|> env-level dec (n/- parameter-level) (n/* 2) (n/+ parameter-idx))))
+
+(def: #export parameter
+  (Poly Code)
+  (do //.monad
+    [env ..env
+     headT any]
+    (case headT
+      (#.Parameter idx)
+      (case (dictionary.get (adjusted-idx env idx) env)
+        (#.Some [poly-type poly-code])
+        (wrap poly-code)
+
+        #.None
+        (//.fail (exception.construct unknown-parameter headT)))
+
+      _
+      (//.fail (exception.construct not-parameter headT)))))
+
+(def: #export (parameter! id)
+  (-> Nat (Poly Any))
+  (do //.monad
+    [env ..env
+     headT any]
+    (case headT
+      (#.Parameter idx)
+      (if (n/= id (adjusted-idx env idx))
+        (wrap [])
+        (//.fail (exception.construct wrong-parameter [(#.Parameter id) headT])))
+
+      _
+      (//.fail (exception.construct not-parameter headT)))))
+
+(def: #export existential
+  (Poly Nat)
+  (do //.monad
+    [headT any]
+    (case headT
+      (#.Ex ex-id)
+      (wrap ex-id)
+
+      _
+      (//.fail (exception.construct not-existential headT)))))
+
+(def: #export named
+  (Poly [Name Type])
+  (do //.monad
+    [inputT any]
+    (case inputT
+      (#.Named name anonymousT)
+      (wrap [name anonymousT])
+
+      _
+      (//.fail (exception.construct not-named inputT)))))
+
+(def: #export (recursive poly)
+  (All [a] (-> (Poly a) (Poly [Code a])))
+  (do //.monad
+    [headT any]
+    (case (type.un-name headT)
+      (#.Apply (#.Named ["lux" "Nothing"] _) (#.UnivQ _ headT'))
+      (do @
+        [[recT _ output] (|> poly
+                             (with-extension .Nothing)
+                             (with-extension headT)
+                             (local (list headT')))]
+        (wrap [recT output]))
+
+      _
+      (//.fail (exception.construct not-recursive headT)))))
+
+(def: #export recursive-self
+  (Poly Code)
+  (do //.monad
+    [env ..env
+     headT any]
+    (case (type.un-name headT)
+      (^multi (#.Apply (#.Named ["lux" "Nothing"] _) (#.Parameter funcT-idx))
+              (n/= 0 (adjusted-idx env funcT-idx))
+              [(dictionary.get 0 env) (#.Some [self-type self-call])])
+      (wrap self-call)
+
+      _
+      (//.fail (exception.construct not-recursive headT)))))
+
+(def: #export recursive-call
+  (Poly Code)
+  (do //.monad
+    [env ..env
+     [funcT argsT] (apply (//.and any (//.many any)))
+     _ (local (list funcT) (..parameter! 0))
+     allC (let [allT (list& funcT argsT)]
+            (|> allT
+                (monad.map @ (function.constant ..parameter))
+                (local allT)))]
+    (wrap (` ((~+ allC))))))
+
+(def: #export log!
+  (All [a] (Poly a))
+  (do //.monad
+    [current any
+     #let [_ (.log! ($_ text@compose
+                        "{" (name@encode (name-of ..log)) "} "
+                        (%type current)))]]
+    (//.fail "LOGGING")))
diff --git a/stdlib/source/lux/macro/poly.lux b/stdlib/source/lux/macro/poly.lux
index a3d78177a..695284e0a 100644
--- a/stdlib/source/lux/macro/poly.lux
+++ b/stdlib/source/lux/macro/poly.lux
@@ -1,356 +1,24 @@
 (.module:
-  [lux (#- function)
+  [lux #*
    [abstract
-    ["." monad (#+ Monad do)]
-    [equivalence]]
+    ["." monad (#+ do)]]
    [control
-    ["p" parser]
-    ["ex" exception (#+ exception:)]
-    ["." function]]
+    ["p" parser
+     ["<.>" type (#+ Env)]]]
    [data
     ["." product]
-    ["." bit]
     ["." maybe]
-    ["." name ("#;." codec)]
-    ["." error (#+ Error)]
-    ["." number (#+ hex)
-     ["." nat ("#;." decimal)]]
-    ["." text ("#;." monoid)
-     format]
+    ["." text]
     [collection
-     ["." list ("#;." fold monad monoid)]
-     ["dict" dictionary (#+ Dictionary)]]]
+     ["." list ("#@." fold functor)]
+     ["." dictionary]]]
    ["." macro (#+ with-gensyms)
     ["." code]
-    ["s" syntax (#+ Syntax syntax:)]
-    [syntax
-     ["cs" common
+    ["s" syntax (#+ syntax:)
+     [common
       ["csr" reader]
       ["csw" writer]]]]
-   ["." type ("#;." equivalence)
-    ["." check]]])
-
-(template [<name>]
-  [(exception: #export (<name> {type Type})
-     (%type type))]
-
-  [not-existential]
-  [not-recursive]
-  [not-named]
-  [not-parameter]
-  [unknown-parameter]
-  [not-function]
-  [not-application]
-  [not-polymorphic]
-  [not-variant]
-  [not-tuple]
-  )
-
-(template [<name>]
-  [(exception: #export (<name> {expected Type} {actual Type})
-     (ex.report ["Expected" (%type expected)]
-                ["Actual" (%type actual)]))]
-
-  [types-do-not-match]
-  [wrong-parameter]
-  )
-
-(exception: #export (unconsumed {remaining (List Type)})
-  (ex.report ["Types" (|> remaining
-                          (list;map (|>> %type (format text.new-line "* ")))
-                          (text.join-with ""))]))
-
-(type: #export Env (Dictionary Nat [Type Code]))
-
-(type: #export (Poly a)
-  (p.Parser [Env (List Type)] a))
-
-(def: #export fresh Env (dict.new nat.hash))
-
-(def: (run' env types poly)
-  (All [a] (-> Env (List Type) (Poly a) (Error a)))
-  (case (p.run [env types] poly)
-    (#error.Failure error)
-    (#error.Failure error)
-
-    (#error.Success [[env' remaining] output])
-    (case remaining
-      #.Nil
-      (#error.Success output)
-
-      _
-      (ex.throw unconsumed remaining))))
-
-(def: #export (run type poly)
-  (All [a] (-> Type (Poly a) (Error a)))
-  (run' fresh (list type) poly))
-
-(def: #export env
-  (Poly Env)
-  (.function (_ [env inputs])
-    (#error.Success [[env inputs] env])))
-
-(def: (with-env temp poly)
-  (All [a] (-> Env (Poly a) (Poly a)))
-  (.function (_ [env inputs])
-    (case (p.run [temp inputs] poly)
-      (#error.Failure error)
-      (#error.Failure error)
-
-      (#error.Success [[_ remaining] output])
-      (#error.Success [[env remaining] output]))))
-
-(def: #export peek
-  (Poly Type)
-  (.function (_ [env inputs])
-    (case inputs
-      #.Nil
-      (#error.Failure "Empty stream of types.")
-
-      (#.Cons headT tail)
-      (#error.Success [[env inputs] headT]))))
-
-(def: #export any
-  (Poly Type)
-  (.function (_ [env inputs])
-    (case inputs
-      #.Nil
-      (#error.Failure "Empty stream of types.")
-
-      (#.Cons headT tail)
-      (#error.Success [[env tail] headT]))))
-
-(def: #export (local types poly)
-  (All [a] (-> (List Type) (Poly a) (Poly a)))
-  (.function (_ [env pass-through])
-    (case (run' env types poly)
-      (#error.Failure error)
-      (#error.Failure error)
-
-      (#error.Success output)
-      (#error.Success [[env pass-through] output]))))
-
-(def: (label idx)
-  (-> Nat Code)
-  (code.local-identifier ($_ text;compose "label" text.tab (nat;encode idx))))
-
-(def: #export (with-extension type poly)
-  (All [a] (-> Type (Poly a) (Poly [Code a])))
-  (.function (_ [env inputs])
-    (let [current-id (dict.size env)
-          g!var (label current-id)]
-      (case (p.run [(dict.put current-id [type g!var] env)
-                    inputs]
-                   poly)
-        (#error.Failure error)
-        (#error.Failure error)
-
-        (#error.Success [[_ inputs'] output])
-        (#error.Success [[env inputs'] [g!var output]])))))
-
-(template [<name> <flattener> <tag> <exception>]
-  [(def: #export (<name> poly)
-     (All [a] (-> (Poly a) (Poly a)))
-     (do p.monad
-       [headT any]
-       (let [members (<flattener> (type.un-name headT))]
-         (if (n/> 1 (list.size members))
-           (local members poly)
-           (p.fail (ex.construct <exception> headT))))))]
-
-  [variant type.flatten-variant #.Sum     not-variant]
-  [tuple   type.flatten-tuple   #.Product not-tuple]
-  )
-
-(def: polymorphic'
-  (Poly [Nat Type])
-  (do p.monad
-    [headT any
-     #let [[num-arg bodyT] (type.flatten-univ-q (type.un-name headT))]]
-    (if (n/= 0 num-arg)
-      (p.fail (ex.construct not-polymorphic headT))
-      (wrap [num-arg bodyT]))))
-
-(def: #export (polymorphic poly)
-  (All [a] (-> (Poly a) (Poly [Code (List Code) a])))
-  (do p.monad
-    [headT any
-     funcI (:: @ map dict.size ..env)
-     [num-args non-poly] (local (list headT) polymorphic')
-     env ..env
-     #let [funcL (label funcI)
-           [all-varsL env'] (loop [current-arg 0
-                                   env' env
-                                   all-varsL (: (List Code) (list))]
-                              (if (n/< num-args current-arg)
-                                (if (n/= 0 current-arg)
-                                  (let [varL (label (inc funcI))]
-                                    (recur (inc current-arg)
-                                           (|> env'
-                                               (dict.put funcI [headT funcL])
-                                               (dict.put (inc funcI) [(#.Parameter (inc funcI)) varL]))
-                                           (#.Cons varL all-varsL)))
-                                  (let [partialI (|> current-arg (n/* 2) (n/+ funcI))
-                                        partial-varI (inc partialI)
-                                        partial-varL (label partial-varI)
-                                        partialC (` ((~ funcL) (~+ (|> (list.indices num-args)
-                                                                       (list;map (|>> (n/* 2) inc (n/+ funcI) label))
-                                                                       list.reverse))))]
-                                    (recur (inc current-arg)
-                                           (|> env'
-                                               (dict.put partialI [.Nothing partialC])
-                                               (dict.put partial-varI [(#.Parameter partial-varI) partial-varL]))
-                                           (#.Cons partial-varL all-varsL))))
-                                [all-varsL env']))]]
-    (|> (do @
-          [output poly]
-          (wrap [funcL all-varsL output]))
-        (local (list non-poly))
-        (with-env env'))))
-
-(def: #export (function in-poly out-poly)
-  (All [i o] (-> (Poly i) (Poly o) (Poly [i o])))
-  (do p.monad
-    [headT any
-     #let [[inputsT outputT] (type.flatten-function (type.un-name headT))]]
-    (if (n/> 0 (list.size inputsT))
-      (p.and (local inputsT in-poly)
-             (local (list outputT) out-poly))
-      (p.fail (ex.construct not-function headT)))))
-
-(def: #export (apply poly)
-  (All [a] (-> (Poly a) (Poly a)))
-  (do p.monad
-    [headT any
-     #let [[funcT paramsT] (type.flatten-application (type.un-name headT))]]
-    (if (n/= 0 (list.size paramsT))
-      (p.fail (ex.construct not-application headT))
-      (local (#.Cons funcT paramsT) poly))))
-
-(template [<name> <test>]
-  [(def: #export (<name> expected)
-     (-> Type (Poly Any))
-     (do p.monad
-       [actual any]
-       (if (<test> expected actual)
-         (wrap [])
-         (p.fail (ex.construct types-do-not-match [expected actual])))))]
-
-  [exactly type;=]
-  [sub     check.checks?]
-  [super   (function.flip check.checks?)]
-  )
-
-(def: (adjusted-idx env idx)
-  (-> Env Nat Nat)
-  (let [env-level (n// 2 (dict.size env))
-        parameter-level (n// 2 idx)
-        parameter-idx (n/% 2 idx)]
-    (|> env-level dec (n/- parameter-level) (n/* 2) (n/+ parameter-idx))))
-
-(def: #export parameter
-  (Poly Code)
-  (do p.monad
-    [env ..env
-     headT any]
-    (case headT
-      (#.Parameter idx)
-      (case (dict.get (adjusted-idx env idx) env)
-        (#.Some [poly-type poly-code])
-        (wrap poly-code)
-
-        #.None
-        (p.fail (ex.construct unknown-parameter headT)))
-
-      _
-      (p.fail (ex.construct not-parameter headT)))))
-
-(def: #export (parameter! id)
-  (-> Nat (Poly Any))
-  (do p.monad
-    [env ..env
-     headT any]
-    (case headT
-      (#.Parameter idx)
-      (if (n/= id (adjusted-idx env idx))
-        (wrap [])
-        (p.fail (ex.construct wrong-parameter [(#.Parameter id) headT])))
-
-      _
-      (p.fail (ex.construct not-parameter headT)))))
-
-(def: #export existential
-  (Poly Nat)
-  (do p.monad
-    [headT any]
-    (case headT
-      (#.Ex ex-id)
-      (wrap ex-id)
-
-      _
-      (p.fail (ex.construct not-existential headT)))))
-
-(def: #export named
-  (Poly [Name Type])
-  (do p.monad
-    [inputT any]
-    (case inputT
-      (#.Named name anonymousT)
-      (wrap [name anonymousT])
-
-      _
-      (p.fail (ex.construct not-named inputT)))))
-
-(def: #export (recursive poly)
-  (All [a] (-> (Poly a) (Poly [Code a])))
-  (do p.monad
-    [headT any]
-    (case (type.un-name headT)
-      (#.Apply (#.Named ["lux" "Nothing"] _) (#.UnivQ _ headT'))
-      (do @
-        [[recT _ output] (|> poly
-                             (with-extension .Nothing)
-                             (with-extension headT)
-                             (local (list headT')))]
-        (wrap [recT output]))
-
-      _
-      (p.fail (ex.construct not-recursive headT)))))
-
-(def: #export recursive-self
-  (Poly Code)
-  (do p.monad
-    [env ..env
-     headT any]
-    (case (type.un-name headT)
-      (^multi (#.Apply (#.Named ["lux" "Nothing"] _) (#.Parameter funcT-idx))
-              (n/= 0 (adjusted-idx env funcT-idx))
-              [(dict.get 0 env) (#.Some [self-type self-call])])
-      (wrap self-call)
-
-      _
-      (p.fail (ex.construct not-recursive headT)))))
-
-(def: #export recursive-call
-  (Poly Code)
-  (do p.monad
-    [env ..env
-     [funcT argsT] (apply (p.and any (p.many any)))
-     _ (local (list funcT) (..parameter! 0))
-     allC (let [allT (list& funcT argsT)]
-            (|> allT
-                (monad.map @ (function.constant ..parameter))
-                (local allT)))]
-    (wrap (` ((~+ allC))))))
-
-(def: #export log
-  (All [a] (Poly a))
-  (do p.monad
-    [current any
-     #let [_ (log! ($_ text;compose
-                       "{" (name;encode (name-of ..log)) "} "
-                       (%type current)))]]
-    (p.fail "LOGGING")))
+   ["." type]])
 
 (syntax: #export (poly: {export csr.export}
                    {name s.local-identifier}
@@ -361,10 +29,10 @@
                         (do macro.monad
                           [(~ g!type) (macro.find-type-def (~ g!type))]
                           (case (|> (~ body)
-                                    (.function ((~ g!_) (~ g!name)))
+                                    (function ((~ g!_) (~ g!name)))
                                     p.rec
                                     (do p.monad [])
-                                    (..run (~ g!type))
+                                    ((~! <type>.run) (~ g!type))
                                     (: (.Either .Text .Code)))
                             (#.Left (~ g!output))
                             (macro.fail (~ g!output))
@@ -379,7 +47,7 @@
 (def: (derivation-name poly args)
   (-> Text (List Text) (Maybe Text))
   (if (common-poly-name? poly)
-    (#.Some (list;fold (text.replace-once "?") poly args))
+    (#.Some (list@fold (text.replace-once "?") poly args))
     #.None))
 
 (syntax: #export (derived: {export csr.export}
@@ -393,7 +61,7 @@
             (wrap name)
 
             (^multi #.None
-                    [(derivation-name (product.right poly-func) (list;map product.right poly-args))
+                    [(derivation-name (product.right poly-func) (list@map product.right poly-args))
                      (#.Some derived-name)])
             (wrap derived-name)
 
@@ -404,7 +72,7 @@
                   custom-impl
 
                   #.None
-                  (` ((~ (code.identifier poly-func)) (~+ (list;map code.identifier poly-args)))))]]
+                  (` ((~ (code.identifier poly-func)) (~+ (list@map code.identifier poly-args)))))]]
     (wrap (.list (` (def: (~+ (csw.export export))
                       (~ (code.identifier ["" name]))
                       {#.struct? #1}
@@ -415,7 +83,7 @@
   (case type
     (#.Primitive name params)
     (` (#.Primitive (~ (code.text name))
-                    (list (~+ (list;map (to-code env) params)))))
+                    (list (~+ (list@map (to-code env) params)))))
 
     (^template [<tag>]
       (<tag> idx)
@@ -423,15 +91,15 @@
     ([#.Var] [#.Ex])
 
     (#.Parameter idx)
-    (let [idx (adjusted-idx env idx)]
+    (let [idx (<type>.adjusted-idx env idx)]
       (if (n/= 0 idx)
-        (|> (dict.get idx env) maybe.assume product.left (to-code env))
+        (|> (dictionary.get idx env) maybe.assume product.left (to-code env))
         (` (.$ (~ (code.nat (dec idx)))))))
 
     (#.Apply (#.Named ["lux" "Nothing"] _) (#.Parameter idx))
-    (let [idx (adjusted-idx env idx)]
+    (let [idx (<type>.adjusted-idx env idx)]
       (if (n/= 0 idx)
-        (|> (dict.get idx env) maybe.assume product.left (to-code env))
+        (|> (dictionary.get idx env) maybe.assume product.left (to-code env))
         (undefined)))
     
     (^template [<tag>]
@@ -442,7 +110,7 @@
 
     (^template [<tag> <macro> <flattener>]
       (<tag> left right)
-      (` (<macro> (~+ (list;map (to-code env) (<flattener> type))))))
+      (` (<macro> (~+ (list@map (to-code env) (<flattener> type))))))
     ([#.Sum  | type.flatten-variant]
      [#.Product & type.flatten-tuple])
 
@@ -451,7 +119,7 @@
 
     (^template [<tag>]
       (<tag> scope body)
-      (` (<tag> (list (~+ (list;map (to-code env) scope)))
+      (` (<tag> (list (~+ (list@map (to-code env) scope)))
                 (~ (to-code env body)))))
     ([#.UnivQ] [#.ExQ])
     ))
diff --git a/stdlib/source/lux/macro/poly/equivalence.lux b/stdlib/source/lux/macro/poly/equivalence.lux
index c39ad9412..50dabcd16 100644
--- a/stdlib/source/lux/macro/poly/equivalence.lux
+++ b/stdlib/source/lux/macro/poly/equivalence.lux
@@ -4,7 +4,8 @@
     [monad (#+ Monad do)]
     ["/" equivalence]]
    [control
-    ["p" parser]]
+    ["p" parser
+     ["<.>" type]]]
    [data
     ["." product]
     ["." bit]
@@ -42,8 +43,8 @@
 (poly: #export equivalence
   (`` (do @
         [#let [g!_ (code.local-identifier "_____________")]
-         *env* poly.env
-         inputT poly.peek
+         *env* <type>.env
+         inputT <type>.peek
          #let [@Equivalence (: (-> Type Code)
                                (function (_ type)
                                  (` ((~! /.Equivalence) (~ (poly.to-code *env* type))))))]]
@@ -55,18 +56,18 @@
                      (wrap (` (: (~ (@Equivalence inputT))
                                  <eq>))))]
 
-                  [(poly.exactly Any) (function ((~ g!_) (~ g!_) (~ g!_)) #1)]
-                  [(poly.sub Bit)     (~! bit.equivalence)]
-                  [(poly.sub Nat)     (~! nat.equivalence)]
-                  [(poly.sub Int)     (~! int.equivalence)]
-                  [(poly.sub Rev)     (~! rev.equivalence)]
-                  [(poly.sub Frac)    (~! frac.equivalence)]
-                  [(poly.sub Text)    (~! text.equivalence)]))
+                  [(<type>.exactly Any) (function ((~ g!_) (~ g!_) (~ g!_)) #1)]
+                  [(<type>.sub Bit)     (~! bit.equivalence)]
+                  [(<type>.sub Nat)     (~! nat.equivalence)]
+                  [(<type>.sub Int)     (~! int.equivalence)]
+                  [(<type>.sub Rev)     (~! rev.equivalence)]
+                  [(<type>.sub Frac)    (~! frac.equivalence)]
+                  [(<type>.sub Text)    (~! text.equivalence)]))
             ## Composite types
             (~~ (template [<name> <eq>]
                   [(do @
-                     [[_ argC] (poly.apply (p.and (poly.exactly <name>)
-                                                  equivalence))]
+                     [[_ argC] (<type>.apply (p.and (<type>.exactly <name>)
+                                                    equivalence))]
                      (wrap (` (: (~ (@Equivalence inputT))
                                  (<eq> (~ argC))))))]
 
@@ -79,16 +80,16 @@
                   [rose.Tree   (~! rose.equivalence)]
                   ))
             (do @
-              [[_ _ valC] (poly.apply ($_ p.and
-                                          (poly.exactly dictionary.Dictionary)
-                                          poly.any
-                                          equivalence))]
+              [[_ _ valC] (<type>.apply ($_ p.and
+                                            (<type>.exactly dictionary.Dictionary)
+                                            <type>.any
+                                            equivalence))]
               (wrap (` (: (~ (@Equivalence inputT))
                           ((~! dictionary.equivalence) (~ valC))))))
             ## Models
             (~~ (template [<type> <eq>]
                   [(do @
-                     [_ (poly.exactly <type>)]
+                     [_ (<type>.exactly <type>)]
                      (wrap (` (: (~ (@Equivalence inputT))
                                  <eq>))))]
 
@@ -99,13 +100,13 @@
                   [month.Month month.equivalence]
                   ))
             (do @
-              [_ (poly.apply (p.and (poly.exactly unit.Qty)
-                                    poly.any))]
+              [_ (<type>.apply (p.and (<type>.exactly unit.Qty)
+                                      <type>.any))]
               (wrap (` (: (~ (@Equivalence inputT))
                           unit.equivalence))))
             ## Variants
             (do @
-              [members (poly.variant (p.many equivalence))
+              [members (<type>.variant (p.many equivalence))
                #let [g!_ (code.local-identifier "_____________")
                      g!left (code.local-identifier "_____________left")
                      g!right (code.local-identifier "_____________right")]]
@@ -121,7 +122,7 @@
                               #0))))))
             ## Tuples
             (do @
-              [g!eqs (poly.tuple (p.many equivalence))
+              [g!eqs (<type>.tuple (p.many equivalence))
                #let [g!_ (code.local-identifier "_____________")
                      indices (list.indices (list.size g!eqs))
                      g!lefts (list@map (|>> nat@encode (text@compose "left") code.local-identifier) indices)
@@ -133,29 +134,29 @@
                                                      (` ((~ g!eq) (~ g!left) (~ g!right)))))))))))))
             ## Type recursion
             (do @
-              [[g!self bodyC] (poly.recursive equivalence)
+              [[g!self bodyC] (<type>.recursive equivalence)
                #let [g!_ (code.local-identifier "_____________")]]
               (wrap (` (: (~ (@Equivalence inputT))
                           ((~! /.rec) (.function ((~ g!_) (~ g!self))
                                         (~ bodyC)))))))
-            poly.recursive-self
+            <type>.recursive-self
             ## Type applications
             (do @
-              [[funcC argsC] (poly.apply (p.and equivalence (p.many equivalence)))]
+              [[funcC argsC] (<type>.apply (p.and equivalence (p.many equivalence)))]
               (wrap (` ((~ funcC) (~+ argsC)))))
             ## Parameters
-            poly.parameter
+            <type>.parameter
             ## Polymorphism
             (do @
-              [[funcC varsC bodyC] (poly.polymorphic equivalence)]
+              [[funcC varsC bodyC] (<type>.polymorphic equivalence)]
               (wrap (` (: (All [(~+ varsC)]
                             (-> (~+ (list@map (|>> (~) ((~! /.Equivalence)) (`)) varsC))
                                 ((~! /.Equivalence) ((~ (poly.to-code *env* inputT)) (~+ varsC)))))
                           (function ((~ funcC) (~+ varsC))
                             (~ bodyC))))))
-            poly.recursive-call
+            <type>.recursive-call
             ## If all else fails...
-            (|> poly.any
+            (|> <type>.any
                 (:: @ map (|>> %type (format "Cannot create Equivalence for: ") p.fail))
                 (:: @ join))
             ))))
diff --git a/stdlib/source/lux/macro/poly/functor.lux b/stdlib/source/lux/macro/poly/functor.lux
index 947f08ac8..4a2d44e38 100644
--- a/stdlib/source/lux/macro/poly/functor.lux
+++ b/stdlib/source/lux/macro/poly/functor.lux
@@ -4,7 +4,8 @@
     [monad (#+ Monad do)]
     ["." functor]]
    [control
-    ["p" parser]]
+    ["p" parser
+     ["<.>" type]]]
    [data
     ["." product]
     ["." text
@@ -23,10 +24,10 @@
     [#let [type-funcC (code.local-identifier "____________type-funcC")
            funcC (code.local-identifier "____________funcC")
            inputC (code.local-identifier "____________inputC")]
-     *env* poly.env
-     inputT poly.peek
-     [polyC varsC non-functorT] (poly.local (list inputT)
-                                            (poly.polymorphic poly.any))
+     *env* <type>.env
+     inputT <type>.peek
+     [polyC varsC non-functorT] (<type>.local (list inputT)
+                                              (<type>.polymorphic <type>.any))
      #let [num-vars (list.size varsC)]
      #let [@Functor (: (-> Type Code)
                        (function (_ unwrappedT)
@@ -35,18 +36,18 @@
                            (let [paramsC (|> num-vars dec list.indices (list;map (|>> %n code.local-identifier)))]
                              (` (All [(~+ paramsC)]
                                   ((~! functor.Functor) ((~ (poly.to-code *env* unwrappedT)) (~+ paramsC)))))))))
-           Arg<?> (: (-> Code (poly.Poly Code))
+           Arg<?> (: (-> Code (<type>.Poly Code))
                      (function (Arg<?> valueC)
                        ($_ p.either
                            ## Type-var
                            (do p.monad
                              [#let [varI (|> num-vars (n/* 2) dec)]
-                              _ (poly.parameter! varI)]
+                              _ (<type>.parameter! varI)]
                              (wrap (` ((~ funcC) (~ valueC)))))
                            ## Variants
                            (do @
                              [_ (wrap [])
-                              membersC (poly.variant (p.many (Arg<?> valueC)))]
+                              membersC (<type>.variant (p.many (Arg<?> valueC)))]
                              (wrap (` (case (~ valueC)
                                         (~+ (list;join (list;map (function (_ [tag memberC])
                                                                    (list (` ((~ (code.nat tag)) (~ valueC)))
@@ -54,17 +55,17 @@
                                                                  (list.enumerate membersC))))))))
                            ## Tuples
                            (do p.monad
-                             [pairsCC (: (poly.Poly (List [Code Code]))
-                                         (poly.tuple (loop [idx 0
-                                                            pairsCC (: (List [Code Code])
-                                                                       (list))]
-                                                       (p.either (let [slotC (|> idx %n (format "____________slot") code.local-identifier)]
-                                                                   (do @
-                                                                     [_ (wrap [])
-                                                                      memberC (Arg<?> slotC)]
-                                                                     (recur (inc idx)
-                                                                            (list;compose pairsCC (list [slotC memberC])))))
-                                                                 (wrap pairsCC)))))]
+                             [pairsCC (: (<type>.Poly (List [Code Code]))
+                                         (<type>.tuple (loop [idx 0
+                                                              pairsCC (: (List [Code Code])
+                                                                         (list))]
+                                                         (p.either (let [slotC (|> idx %n (format "____________slot") code.local-identifier)]
+                                                                     (do @
+                                                                       [_ (wrap [])
+                                                                        memberC (Arg<?> slotC)]
+                                                                       (recur (inc idx)
+                                                                              (list;compose pairsCC (list [slotC memberC])))))
+                                                                   (wrap pairsCC)))))]
                              (wrap (` (case (~ valueC)
                                         [(~+ (list;map product.left pairsCC))]
                                         [(~+ (list;map product.right pairsCC))]))))
@@ -73,7 +74,7 @@
                              [_ (wrap [])
                               #let [g! (code.local-identifier "____________")
                                     outL (code.local-identifier "____________outL")]
-                              [inT+ outC] (poly.function (p.many poly.any)
+                              [inT+ outC] (<type>.function (p.many <type>.any)
                                             (Arg<?> outL))
                               #let [inC+ (|> (list.size inT+)
                                              list.indices
@@ -83,15 +84,15 @@
                                           (~ outC))))))
                            ## Recursion
                            (do p.monad
-                             [_ poly.recursive-call]
+                             [_ <type>.recursive-call]
                              (wrap (` ((~' map) (~ funcC) (~ valueC)))))
                            ## Parameters
                            (do p.monad
-                             [_ poly.any]
+                             [_ <type>.any]
                              (wrap valueC))
                            )))]
-     [_ _ outputC] (: (poly.Poly [Code (List Code) Code])
-                      (p.either (poly.polymorphic
+     [_ _ outputC] (: (<type>.Poly [Code (List Code) Code])
+                      (p.either (<type>.polymorphic
                                  (Arg<?> inputC))
                                 (p.fail (format "Cannot create Functor for: " (%type inputT)))))]
     (wrap (` (: (~ (@Functor inputT))
diff --git a/stdlib/source/lux/macro/poly/json.lux b/stdlib/source/lux/macro/poly/json.lux
index f397de2a2..e0e122eb1 100644
--- a/stdlib/source/lux/macro/poly/json.lux
+++ b/stdlib/source/lux/macro/poly/json.lux
@@ -5,7 +5,8 @@
     [equivalence (#+ Equivalence)]
     ["." codec]]
    [control
-    ["p" parser]]
+    ["p" parser
+     ["<.>" type]]]
    [data
     ["." bit]
     maybe
@@ -97,15 +98,15 @@
                   (wrap (` (: (~ (@JSON//encode inputT))
                               <encoder>))))]
 
-               [(poly.exactly Any) (function ((~ g!_) (~ (code.identifier ["" "0"]))) #/.Null)]
-               [(poly.sub Bit)     (|>> #/.Boolean)]
-               [(poly.sub Nat)     (:: (~! ..nat-codec) (~' encode))]
-               [(poly.sub Int)     (:: (~! ..int-codec) (~' encode))]
-               [(poly.sub Frac)    (|>> #/.Number)]
-               [(poly.sub Text)    (|>> #/.String)])
+               [(<type>.exactly Any) (function ((~ g!_) (~ (code.identifier ["" "0"]))) #/.Null)]
+               [(<type>.sub Bit)     (|>> #/.Boolean)]
+               [(<type>.sub Nat)     (:: (~! ..nat-codec) (~' encode))]
+               [(<type>.sub Int)     (:: (~! ..int-codec) (~' encode))]
+               [(<type>.sub Frac)    (|>> #/.Number)]
+               [(<type>.sub Text)    (|>> #/.String)])
      <time> (template [<type> <codec>]
               [(do @
-                 [_ (poly.exactly <type>)]
+                 [_ (<type>.exactly <type>)]
                  (wrap (` (: (~ (@JSON//encode inputT))
                              (|>> (:: (~! <codec>) (~' encode)) #/.String)))))]
 
@@ -115,27 +116,27 @@
               [day.Day day.codec]
               [month.Month month.codec])]
     (do @
-      [*env* poly.env
+      [*env* <type>.env
        #let [@JSON//encode (: (-> Type Code)
                               (function (_ type)
                                 (` (-> (~ (poly.to-code *env* type)) /.JSON))))]
-       inputT poly.peek]
+       inputT <type>.peek]
       ($_ p.either
           <basic>
           <time>
           (do @
-            [unitT (poly.apply (p.after (poly.exactly unit.Qty)
-                                        poly.any))]
+            [unitT (<type>.apply (p.after (<type>.exactly unit.Qty)
+                                          <type>.any))]
             (wrap (` (: (~ (@JSON//encode inputT))
                         (:: (~! qty-codec) (~' encode))))))
           (do @
             [#let [g!_ (code.local-identifier "_______")
                    g!key (code.local-identifier "_______key")
                    g!val (code.local-identifier "_______val")]
-             [_ _ =val=] (poly.apply ($_ p.and
-                                         (poly.exactly d.Dictionary)
-                                         (poly.exactly .Text)
-                                         codec//encode))]
+             [_ _ =val=] (<type>.apply ($_ p.and
+                                           (<type>.exactly d.Dictionary)
+                                           (<type>.exactly .Text)
+                                           codec//encode))]
             (wrap (` (: (~ (@JSON//encode inputT))
                         (|>> ((~! d.entries))
                              ((~! list@map) (function ((~ g!_) [(~ g!key) (~ g!val)])
@@ -143,21 +144,21 @@
                              ((~! d.from-list) (~! text.hash))
                              #/.Object)))))
           (do @
-            [[_ =sub=] (poly.apply ($_ p.and
-                                       (poly.exactly .Maybe)
-                                       codec//encode))]
+            [[_ =sub=] (<type>.apply ($_ p.and
+                                         (<type>.exactly .Maybe)
+                                         codec//encode))]
             (wrap (` (: (~ (@JSON//encode inputT))
                         ((~! ..nullable) (~ =sub=))))))
           (do @
-            [[_ =sub=] (poly.apply ($_ p.and
-                                       (poly.exactly .List)
-                                       codec//encode))]
+            [[_ =sub=] (<type>.apply ($_ p.and
+                                         (<type>.exactly .List)
+                                         codec//encode))]
             (wrap (` (: (~ (@JSON//encode inputT))
                         (|>> ((~! list@map) (~ =sub=)) ((~! row.from-list)) #/.Array)))))
           (do @
             [#let [g!_ (code.local-identifier "_______")
                    g!input (code.local-identifier "_______input")]
-             members (poly.variant (p.many codec//encode))]
+             members (<type>.variant (p.many codec//encode))]
             (wrap (` (: (~ (@JSON//encode inputT))
                         (function ((~ g!_) (~ g!input))
                           (case (~ g!input)
@@ -167,7 +168,7 @@
                                                                               ((~ g!encode) (~ g!input))]))))
                                                      (list.enumerate members))))))))))
           (do @
-            [g!encoders (poly.tuple (p.many codec//encode))
+            [g!encoders (<type>.tuple (p.many codec//encode))
              #let [g!_ (code.local-identifier "_______")
                    g!members (|> (list.size g!encoders)
                                  list.indices
@@ -179,19 +180,19 @@
                                                       (list.zip2 g!members g!encoders)))]))))))
           ## Type recursion
           (do @
-            [[selfC non-recC] (poly.recursive codec//encode)
+            [[selfC non-recC] (<type>.recursive codec//encode)
              #let [g! (code.local-identifier "____________")]]
             (wrap (` (: (~ (@JSON//encode inputT))
                         ((~! ..rec-encode) (.function ((~ g!) (~ selfC))
                                              (~ non-recC)))))))
-          poly.recursive-self
+          <type>.recursive-self
           ## Type applications
           (do @
-            [partsC (poly.apply (p.many codec//encode))]
+            [partsC (<type>.apply (p.many codec//encode))]
             (wrap (` ((~+ partsC)))))
           ## Polymorphism
           (do @
-            [[funcC varsC bodyC] (poly.polymorphic codec//encode)]
+            [[funcC varsC bodyC] (<type>.polymorphic codec//encode)]
             (wrap (` (: (All [(~+ varsC)]
                           (-> (~+ (list@map (function (_ varC) (` (-> (~ varC) /.JSON)))
                                             varsC))
@@ -199,8 +200,8 @@
                                   /.JSON)))
                         (function ((~ funcC) (~+ varsC))
                           (~ bodyC))))))
-          poly.parameter
-          poly.recursive-call
+          <type>.parameter
+          <type>.recursive-call
           ## If all else fails...
           (p.fail (format "Cannot create JSON encoder for: " (type.to-text inputT)))
           ))))
@@ -213,15 +214,15 @@
                   (wrap (` (: (~ (@JSON//decode inputT))
                               (~! <decoder>)))))]
 
-               [(poly.exactly Any)  /.null]
-               [(poly.sub Bit)      /.boolean]
-               [(poly.sub Nat)      (p.codec ..nat-codec /.any)]
-               [(poly.sub Int)      (p.codec ..int-codec /.any)]
-               [(poly.sub Frac)     /.number]
-               [(poly.sub Text)     /.string])
+               [(<type>.exactly Any)  /.null]
+               [(<type>.sub Bit)      /.boolean]
+               [(<type>.sub Nat)      (p.codec ..nat-codec /.any)]
+               [(<type>.sub Int)      (p.codec ..int-codec /.any)]
+               [(<type>.sub Frac)     /.number]
+               [(<type>.sub Text)     /.string])
      <time> (template [<type> <codec>]
               [(do @
-                 [_ (poly.exactly <type>)]
+                 [_ (<type>.exactly <type>)]
                  (wrap (` (: (~ (@JSON//decode inputT))
                              ((~! p.codec) (~! <codec>) (~! /.string))))))]
 
@@ -232,38 +233,38 @@
               [month.Month month.codec])
      ]
     (do @
-      [*env* poly.env
+      [*env* <type>.env
        #let [@JSON//decode (: (-> Type Code)
                               (function (_ type)
                                 (` (/.Reader (~ (poly.to-code *env* type))))))]
-       inputT poly.peek]
+       inputT <type>.peek]
       ($_ p.either
           <basic>
           <time>
           (do @
-            [unitT (poly.apply (p.after (poly.exactly unit.Qty)
-                                        poly.any))]
+            [unitT (<type>.apply (p.after (<type>.exactly unit.Qty)
+                                          <type>.any))]
             (wrap (` (: (~ (@JSON//decode inputT))
                         ((~! p.codec) (~! qty-codec) (~! /.any))))))
           (do @
-            [[_ _ valC] (poly.apply ($_ p.and
-                                        (poly.exactly d.Dictionary)
-                                        (poly.exactly .Text)
-                                        codec//decode))]
+            [[_ _ valC] (<type>.apply ($_ p.and
+                                          (<type>.exactly d.Dictionary)
+                                          (<type>.exactly .Text)
+                                          codec//decode))]
             (wrap (` (: (~ (@JSON//decode inputT))
                         ((~! /.dictionary) (~ valC))))))
           (do @
-            [[_ subC] (poly.apply (p.and (poly.exactly .Maybe)
-                                         codec//decode))]
+            [[_ subC] (<type>.apply (p.and (<type>.exactly .Maybe)
+                                           codec//decode))]
             (wrap (` (: (~ (@JSON//decode inputT))
                         ((~! /.nullable) (~ subC))))))
           (do @
-            [[_ subC] (poly.apply (p.and (poly.exactly .List)
-                                         codec//decode))]
+            [[_ subC] (<type>.apply (p.and (<type>.exactly .List)
+                                           codec//decode))]
             (wrap (` (: (~ (@JSON//decode inputT))
                         ((~! /.array) ((~! p.some) (~ subC)))))))
           (do @
-            [members (poly.variant (p.many codec//decode))]
+            [members (<type>.variant (p.many codec//decode))]
             (wrap (` (: (~ (@JSON//decode inputT))
                         ($_ ((~! p.or))
                             (~+ (list@map (function (_ [tag memberC])
@@ -272,31 +273,31 @@
                                                    ((~! /.array)))))
                                           (list.enumerate members))))))))
           (do @
-            [g!decoders (poly.tuple (p.many codec//decode))]
+            [g!decoders (<type>.tuple (p.many codec//decode))]
             (wrap (` (: (~ (@JSON//decode inputT))
                         ((~! /.array) ($_ ((~! p.and)) (~+ g!decoders)))))))
           ## Type recursion
           (do @
-            [[selfC bodyC] (poly.recursive codec//decode)
+            [[selfC bodyC] (<type>.recursive codec//decode)
              #let [g! (code.local-identifier "____________")]]
             (wrap (` (: (~ (@JSON//decode inputT))
                         ((~! p.rec) (.function ((~ g!) (~ selfC))
                                       (~ bodyC)))))))
-          poly.recursive-self
+          <type>.recursive-self
           ## Type applications
           (do @
-            [[funcC argsC] (poly.apply (p.and codec//decode (p.many codec//decode)))]
+            [[funcC argsC] (<type>.apply (p.and codec//decode (p.many codec//decode)))]
             (wrap (` ((~ funcC) (~+ argsC)))))
           ## Polymorphism
           (do @
-            [[funcC varsC bodyC] (poly.polymorphic codec//decode)]
+            [[funcC varsC bodyC] (<type>.polymorphic codec//decode)]
             (wrap (` (: (All [(~+ varsC)]
                           (-> (~+ (list@map (|>> (~) /.Reader (`)) varsC))
                               (/.Reader ((~ (poly.to-code *env* inputT)) (~+ varsC)))))
                         (function ((~ funcC) (~+ varsC))
                           (~ bodyC))))))
-          poly.parameter
-          poly.recursive-call
+          <type>.parameter
+          <type>.recursive-call
           ## If all else fails...
           (p.fail (format "Cannot create JSON decoder for: " (type.to-text inputT)))
           ))))
diff --git a/stdlib/source/test/lux.lux b/stdlib/source/test/lux.lux
index 08bc451b1..ab5d2e1d4 100644
--- a/stdlib/source/test/lux.lux
+++ b/stdlib/source/test/lux.lux
@@ -59,7 +59,9 @@
      ##  ["._" concatenative]
      ##  ["._" predicate]
      ##  [monad
-     ##   ["._" free]]]
+     ##   ["._" free]]
+     ##  [parser
+     ##   [type (#+)]]]
      ## [data
      ##  ["._" env]
      ##  ["._" trace]
@@ -345,5 +347,6 @@
 (program: args
   (<| io
       _.run!
-      (_.times 100)
+      ## (_.times 100)
+      (_.seed 8070500311708372420)
       ..test))