Enabled compile-time code evaluation (i.e. "eval" function).

69 files changed, 2645 insertions, 471 deletions

diff --git a/stdlib/source/documentation/lux.lux b/stdlib/source/documentation/lux.lux
index 1f30de85c..987d9cce5 100644
--- a/stdlib/source/documentation/lux.lux
+++ b/stdlib/source/documentation/lux.lux
@@ -10,7 +10,27 @@
    ["." /]]
   ["." / #_
    ["#." abstract]
-   ["#." control]])
+   ["#." control]
+   ["#." data]
+   ... ["#." debug]
+   ... ["#." documentation]
+   ... ["#." locale]
+   ... ["#." macro
+   ...  ["#/." code]]
+   ... ["#." math]
+   ... ["#." meta]
+   ... ["#." program]
+   ... ["#." target]
+   ... ["#." test]
+   ... ["#." time]
+   ... ... ["#." tool] ... TODO: Update & expand tests for this
+   ... ["#." type]
+   ... ["#." world]
+   ... ["#." ffi]
+   ... ["#." extension]
+   ... ["#." target #_
+   ...  <target>]
+   ])
 
 (documentation: /.:of
   "Generates the type corresponding to a given expression."
@@ -28,7 +48,8 @@
             ""
             [..:of]
             [/abstract.documentation
-             /control.documentation]))
+             /control.documentation
+             /data.documentation]))
 
 (program: inputs
   (io.io (debug.log! ($.documentation ..documentation))))
diff --git a/stdlib/source/documentation/lux/abstract/monad.lux b/stdlib/source/documentation/lux/abstract/monad.lux
index 2d55ff0c5..07318bce9 100644
--- a/stdlib/source/documentation/lux/abstract/monad.lux
+++ b/stdlib/source/documentation/lux/abstract/monad.lux
@@ -25,9 +25,9 @@
   "Apply a function with monadic effects to a monadic value and yield a new monadic value."
   [(then monad function)])
 
-(documentation: /.seq
+(documentation: /.all
   "Run all the monadic values in the list and produce a list of the base values."
-  [(seq monad)])
+  [(all monad)])
 
 (documentation: /.map
   "Apply a monadic function to all values in a list."
@@ -48,7 +48,7 @@
             [..Monad
              ..do
              ..then
-             ..seq
+             ..all
              ..map
              ..only
              ..fold]
diff --git a/stdlib/source/documentation/lux/control/concurrency/frp.lux b/stdlib/source/documentation/lux/control/concurrency/frp.lux
index 2500b119d..728e93be5 100644
--- a/stdlib/source/documentation/lux/control/concurrency/frp.lux
+++ b/stdlib/source/documentation/lux/control/concurrency/frp.lux
@@ -32,9 +32,9 @@
   "A one-element channel containing the output from an async."
   [(of_async async)])
 
-(documentation: /.fold
+(documentation: /.aggregate
   "Asynchronous fold over channels."
-  [(fold f init channel)])
+  [(aggregate f init channel)])
 
 (documentation: /.sequential
   "Transforms the given list into a channel with the same elements."
@@ -50,7 +50,7 @@
              ..Subscriber
              ..only
              ..of_async
-             ..fold
+             ..aggregate
              ..sequential
              ($.default /.channel_is_already_closed)
              ($.default /.functor)
diff --git a/stdlib/source/documentation/lux/control/function.lux b/stdlib/source/documentation/lux/control/function.lux
index 88556dda7..62f7b7374 100644
--- a/stdlib/source/documentation/lux/control/function.lux
+++ b/stdlib/source/documentation/lux/control/function.lux
@@ -36,9 +36,9 @@
   [(= ((flipped f) "foo" "bar")
       (f "bar" "foo"))])
 
-(documentation: /.apply
+(documentation: /.on
   "Simple 1-argument function application."
-  [(apply input function)])
+  [(on input function)])
 
 (.def: .public documentation
   (.List $.Module)
@@ -48,7 +48,7 @@
              ..composite
              ..constant
              ..flipped
-             ..apply
+             ..on
              ($.default /.monoid)]
             [/contract.documentation
              /memo.documentation
diff --git a/stdlib/source/documentation/lux/control/parser.lux b/stdlib/source/documentation/lux/control/parser.lux
index 081c5a792..7c6691d60 100644
--- a/stdlib/source/documentation/lux/control/parser.lux
+++ b/stdlib/source/documentation/lux/control/parser.lux
@@ -15,13 +15,12 @@
    ["#." cli]
    ["#." code]
    ["#." environment]
-   ... ["#." json]
-   ... ["#." synthesis]
-   ... ["#." text]
-   ... ["#." tree]
-   ... ["#." type]
-   ... ["#." xml]
-   ])
+   ["#." json]
+   ["#." synthesis]
+   ["#." text]
+   ["#." tree]
+   ["#." type]
+   ["#." xml]])
 
 (documentation: /.Parser
   "A generic parser.")
@@ -171,10 +170,9 @@
              /cli.documentation
              /code.documentation
              /environment.documentation
-             ... /json.documentation
-             ... /synthesis.documentation
-             ... /text.documentation
-             ... /tree.documentation
-             ... /type.documentation
-             ... /xml.documentation
-             ]))
+             /json.documentation
+             /synthesis.documentation
+             /text.documentation
+             /tree.documentation
+             /type.documentation
+             /xml.documentation]))
diff --git a/stdlib/source/documentation/lux/control/parser/json.lux b/stdlib/source/documentation/lux/control/parser/json.lux
new file mode 100644
index 000000000..8dfa6a8d3
--- /dev/null
+++ b/stdlib/source/documentation/lux/control/parser/json.lux
@@ -0,0 +1,94 @@
+(.module:
+  [library
+   [lux #*
+    ["$" documentation (#+ documentation:)]
+    [data
+     [text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     ["." template]]]]
+  [\\library
+   ["." /]])
+
+(documentation: /.Parser
+  "A JSON parser.")
+
+(documentation: /.result
+  (format "Executes the parser against a JSON object."
+          \n "Verifies that all of the JSON was consumed by the parser.")
+  [(result parser json)])
+
+(documentation: /.any
+  "Just returns the JSON input without applying any logic.")
+
+(template [<name>]
+  [(`` (documentation: <name>
+         (format "Reads a JSON value as " (~~ (template.text [<name>])) ".")))]
+
+  [/.null]
+  [/.boolean]
+  [/.number]
+  [/.string]
+  )
+
+(template [<test> <check> <read>]
+  [(`` (documentation: <test>
+         (format "Asks whether a JSON value is a " (~~ (template.text [<read>])) ".")
+         [(<test> test)]))
+   (`` (documentation: <check>
+         (format "Ensures a JSON value is a " (~~ (template.text [<read>])) ".")
+         [(<check> test)]))]
+
+  [/.boolean? /.boolean! ..boolean]
+  [/.number?  /.number!  ..number]
+  [/.string?  /.string!  ..string]
+  )
+
+(documentation: /.nullable
+  "Enhances parser by adding NULL-handling."
+  [(nullable parser)])
+
+(documentation: /.array
+  "Parses the contents of a JSON array."
+  [(array parser)])
+
+(documentation: /.object
+  (format "Parses the contents of a JSON object."
+          \n "Use this with the 'field' combinator.")
+  [(object parser)])
+
+(documentation: /.field
+  (format "Parses a field inside a JSON object."
+          \n "Use this inside the 'object' combinator.")
+  [(field field_name parser)])
+
+(documentation: /.dictionary
+  "Parses a dictionary-like JSON object.")
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            ""
+            [..Parser
+             ..result
+             ..any
+
+             ..null
+             ..boolean
+             ..number
+             ..string
+             
+             ..boolean? ..boolean!
+             ..number? ..number!
+             ..string? ..string!
+             
+             ..nullable
+             ..array
+             ..object
+             ..field
+             ..dictionary
+             ($.default /.unconsumed_input)
+             ($.default /.empty_input)
+             ($.default /.unexpected_value)
+             ($.default /.value_mismatch)]
+            []))
diff --git a/stdlib/source/documentation/lux/control/parser/synthesis.lux b/stdlib/source/documentation/lux/control/parser/synthesis.lux
new file mode 100644
index 000000000..82b3224ea
--- /dev/null
+++ b/stdlib/source/documentation/lux/control/parser/synthesis.lux
@@ -0,0 +1,84 @@
+(.module:
+  [library
+   [lux (#- i64 local function loop)
+    ["$" documentation (#+ documentation:)]
+    [data
+     [text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     ["." template]]]]
+  [\\library
+   ["." /]])
+
+(documentation: /.Parser
+  "A parser for the Lux compiler's synthesis nodes using during optimization.")
+
+(documentation: /.result
+  (format "Executes the parser against the inputs."
+          \n "Ensures all inputs are consumed by the parser.")
+  [(result parser input)])
+
+(documentation: /.any
+  "Yields a synthesis node without subjecting it to any analysis.")
+
+(documentation: /.end!
+  "Ensures there are no more inputs.")
+
+(documentation: /.end?
+  "Checks whether there are no more inputs.")
+
+(template [<query> <assertion>]
+  [(`` (documentation: <query>
+         (format "Queries for a " (~~ (template.text [<query>])) " synthesis node.")))
+   (`` (documentation: <assertion>
+         (format "Checks for a specific " (~~ (template.text [<query>])) " synthesis node.")
+         [(<assertion> expected)]))]
+
+  [/.bit /.bit!]
+  [/.i64 /.i64!]
+  [/.f64 /.f64!]
+  [/.text /.text!]
+  [/.local /.local!]
+  [/.foreign /.foreign!]
+  [/.constant /.constant!]
+  )
+
+(documentation: /.tuple
+  "Parses the contents of a tuple."
+  [(tuple parser)])
+
+(documentation: /.function
+  "Parses the body of a function with the 'expected' arity."
+  [(function expected parser)])
+
+(documentation: /.loop
+  "Parses the initial values and the body of a loop."
+  [(loop init_parsers iteration_parser)])
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            ""
+            [..Parser
+             ..result
+             ..any
+             ..end!
+             ..end?
+
+             ..bit ..bit!
+             ..i64 ..i64!
+             ..f64 ..f64!
+             ..text ..text!
+             ..local ..local!
+             ..foreign ..foreign!
+             ..constant ..constant!
+             
+             ..tuple
+             ..function
+             ..loop
+             ($.default /.cannot_parse)
+             ($.default /.unconsumed_input)
+             ($.default /.expected_empty_input)
+             ($.default /.wrong_arity)
+             ($.default /.empty_input)]
+            []))
diff --git a/stdlib/source/documentation/lux/control/parser/text.lux b/stdlib/source/documentation/lux/control/parser/text.lux
new file mode 100644
index 000000000..52c1c6b07
--- /dev/null
+++ b/stdlib/source/documentation/lux/control/parser/text.lux
@@ -0,0 +1,221 @@
+(.module:
+  [library
+   [lux (#- and not local)
+    ["$" documentation (#+ documentation:)]
+    [data
+     [text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     ["." template]]]]
+  [\\library
+   ["." /]])
+
+(documentation: /.Offset
+  "An offset into a block of text.")
+
+(documentation: /.Parser
+  "A parser for text.")
+
+(documentation: /.Slice
+  "A slice of a block of text.")
+
+(documentation: /.result
+  (format "Executes a parser against a block of text."
+          \n "Verifies that the entire input has been processed.")
+  [(result parser input)])
+
+(documentation: /.offset
+  "Yields the current offset into the input.")
+
+(documentation: /.any
+  "Yields the next character without applying any logic.")
+
+(documentation: /.any!
+  "Yields the next character (as a slice) without applying any logic.")
+
+(template [<name> <caveat>]
+  [(`` (documentation: <name>
+         (format "Produce a character" (~~ (template.text [<caveat>])) " if the parser fails.")
+         [(<name> parser)]))]
+
+  [/.not  ""]
+  [/.not! " (as a slice)"]
+  )
+
+(documentation: /.this
+  "Checks that a specific text shows up in the input."
+  [(this reference)])
+
+(documentation: /.end!
+  "Ensure the parser's input is empty.")
+
+(documentation: /.next
+  "Yields the next character (without consuming it from the input).")
+
+(documentation: /.remaining
+  "Get all of the remaining input (without consuming it).")
+
+(documentation: /.range
+  "Only yields characters within a range."
+  [(range bottom top)])
+
+(template [<name> <desc>]
+  [(documentation: <name>
+     (format "Only yields " <desc> " characters."))]
+
+  [/.upper "uppercase"]
+  [/.lower "lowercase"]
+  [/.decimal "decimal"]
+  [/.octal "octal"]
+  )
+
+(documentation: /.alpha
+  "Yields alphabetic characters.")
+
+(documentation: /.alpha_num
+  "Yields alphanumeric characters.")
+
+(documentation: /.hexadecimal
+  "Yields hexadecimal digits.")
+
+(template [<name> <description_modifier>]
+  [(documentation: <name>
+     (format "Yields characters that are" <description_modifier> " part of a piece of text.")
+     [(<name> options)])]
+
+  [/.one_of ""]
+  [/.none_of " not"]
+  )
+
+(template [<name> <description_modifier>]
+  [(documentation: <name>
+     (format "Yields characters (as a slice) that are" <description_modifier> " part of a piece of text.")
+     [(<name> options)])]
+
+  [/.one_of! ""]
+  [/.none_of! " not"]
+  )
+
+(documentation: /.satisfies
+  "Yields characters that satisfy a predicate."
+  [(satisfies parser)])
+
+(documentation: /.space
+  "Yields white-space.")
+
+(documentation: /.and
+  "Yields the outputs of both parsers composed together."
+  [(and left right)])
+
+(documentation: /.and!
+  "Yields the outputs of both parsers composed together (as a slice)."
+  [(and! left right)])
+
+(template [<text> <slice>]
+  [(`` (documentation: <text>
+         (format "Yields " (~~ (template.text [<name>])) " characters as a single continuous text.")
+         [(<text> parser)]))
+   (`` (documentation: <slice>
+         (format "Yields " (~~ (template.text [<name>])) " characters as a single continuous text (as a slice).")
+         [(<slice> parser)]))]
+
+  [/.some /.some!]
+  [/.many /.many!]
+  )
+
+(template [<text> <slice> <doc_modifier>]
+  [(`` (documentation: <text>
+         (format "Yields " <doc_modifier> " N characters.")
+         [(<text> amount parser)]))
+   (`` (documentation: <slice>
+         (format "Yields " <doc_modifier> " N characters (as a slice).")
+         [(<slice> amount parser)]))]
+
+  [/.exactly  /.exactly!  "exactly"]
+  [/.at_most  /.at_most!  "at most"]
+  [/.at_least /.at_least! "at least"]
+  )
+
+(documentation: /.between
+  ""
+  [(between minimum additional parser)])
+
+(documentation: /.between!
+  ""
+  [(between! minimum additional parser)])
+
+(documentation: /.enclosed
+  ""
+  [(enclosed [start end] parser)])
+
+(documentation: /.local
+  "Applies a parser against the given input."
+  [(local local_input parser)])
+
+(documentation: /.slice
+  "Converts a slice to a block of text."
+  [(slice parser)])
+
+(documentation: /.then
+  "Embeds a text parser into an arbitrary parser that yields text."
+  [(then structured text)])
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            ""
+            [..Offset
+             ..Parser
+             ..Slice
+             ..result
+             ..offset
+
+             ..any ..any!
+             ..not ..not!
+             
+             ..this
+             ..end!
+             ..next
+             ..remaining
+             ..range
+
+             ..upper
+             ..lower
+             ..decimal
+             ..octal
+             
+             ..alpha
+             ..alpha_num
+             ..hexadecimal
+
+             ..one_of ..one_of!
+             ..none_of ..none_of!
+             
+             ..satisfies
+             ..space
+             ..and ..and!
+
+             ..some ..some!
+             ..many ..many!
+             
+
+             ..exactly ..exactly!
+             ..at_most ..at_most!
+             ..at_least ..at_least!
+             
+             ..between
+             ..between!
+             ..enclosed
+             ..local
+             ..slice
+             ..then
+
+             ($.default /.unconsumed_input)
+             ($.default /.expected_to_fail)
+             ($.default /.cannot_parse)
+             ($.default /.cannot_slice)
+             ($.default /.cannot_match)
+             ($.default /.character_should_be)
+             ($.default /.character_should_not_be)
+             ($.default /.character_does_not_satisfy_predicate)]
+            []))
diff --git a/stdlib/source/documentation/lux/control/parser/tree.lux b/stdlib/source/documentation/lux/control/parser/tree.lux
new file mode 100644
index 000000000..3c5cf1bf7
--- /dev/null
+++ b/stdlib/source/documentation/lux/control/parser/tree.lux
@@ -0,0 +1,72 @@
+(.module:
+  [library
+   [lux #*
+    ["$" documentation (#+ documentation:)]
+    [data
+     [text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     ["." template]]]]
+  [\\library
+   ["." /]])
+
+(documentation: /.Parser
+  "A parser of arbitrary trees.")
+
+(documentation: /.result'
+  "Applies the parser against a tree zipper."
+  [(result' parser zipper)])
+
+(documentation: /.result
+  "Applies the parser against a tree."
+  [(result parser tree)])
+
+(documentation: /.value
+  "Yields the value inside the current tree node.")
+
+(template [<name> <doc>]
+  [(documentation: <name>
+     <doc>)]
+
+  [/.down "Move down."]
+  [/.up "Move up."]
+
+  [/.right "Move to the right."]
+  [/.rightmost "Move to the rightmost node."]
+
+  [/.left "Move to the left."]
+  [/.leftmost "Move to the leftmost node."]
+  
+  [/.next "Move to the next node."]
+  [/.end "Move to the last node."]
+  
+  [/.previous "Move to the previous node."]
+  [/.start "Move to the root node."]
+  )
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            ""
+            [..Parser
+             ..result'
+             ..result
+             ..value
+
+             ..down
+             ..up
+
+             ..right
+             ..rightmost
+
+             ..left
+             ..leftmost
+             
+             ..next
+             ..end
+             
+             ..previous
+             ..start
+             
+             ($.default /.cannot_move_further)]
+            []))
diff --git a/stdlib/source/documentation/lux/control/parser/type.lux b/stdlib/source/documentation/lux/control/parser/type.lux
new file mode 100644
index 000000000..0d1785b06
--- /dev/null
+++ b/stdlib/source/documentation/lux/control/parser/type.lux
@@ -0,0 +1,142 @@
+(.module:
+  [library
+   [lux (#- local function)
+    ["$" documentation (#+ documentation:)]
+    [data
+     [text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     ["." template]]]]
+  [\\library
+   ["." /]])
+
+(documentation: /.Env
+  "An environment for type parsing.")
+
+(documentation: /.Parser
+  "A parser of Lux types.")
+
+(documentation: /.fresh
+  "An empty parsing environment.")
+
+(documentation: /.result
+  (format "Applies a parser against a type."
+          \n "Verifies that the parser fully consumes the type's information.")
+  [(result poly type)])
+
+(documentation: /.env
+  "Yields the current parsing environment.")
+
+(documentation: /.next
+  "Inspect a type in the input stream without consuming it.")
+
+(documentation: /.any
+  "Yields a type, without examination.")
+
+(documentation: /.local
+  "Apply a parser to the given inputs."
+  [(local types poly)])
+
+(documentation: /.with_extension
+  ""
+  [(with_extension type poly)])
+
+(template [<name>]
+  [(`` (documentation: <name>
+         (format "Parses the contents of a " (~~ (template.text [<name>])) " type.")
+         [(<name> poly)]))]
+
+  [/.variant]
+  [/.tuple]
+  )
+
+(documentation: /.polymorphic
+  ""
+  [(polymorphic poly)])
+
+(documentation: /.function
+  "Parses a function's inputs and output."
+  [(function in_poly out_poly)])
+
+(documentation: /.applied
+  "Parses a type application."
+  [(applied poly)])
+
+(template [<name> <doc>]
+  [(documentation: <name>
+     <doc>
+     [(<name> expected)])]
+
+  [/.exactly "Parses a type exactly."]
+  [/.sub "Parses a sub type."]
+  [/.super "Parses a super type."]
+  )
+
+(documentation: /.adjusted_idx
+  ""
+  [(adjusted_idx env idx)])
+
+(documentation: /.parameter!
+  ""
+  [(parameter! id)])
+
+(documentation: /.existential
+  "Yields an existential type.")
+
+(documentation: /.named
+  "Yields a named type.")
+
+(documentation: /.recursive
+  ""
+  [(recursive poly)])
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            (format "Parsing of Lux types."
+                    \n "Used mostly for polytypic programming.")
+            [..Env
+             ..Parser
+             ..fresh
+             ..result
+             ..env
+             ..next
+             ..any
+             ..local
+             ..with_extension
+
+             ..variant
+             ..tuple
+             
+             ..polymorphic
+             ..function
+             ..applied
+
+             ..exactly
+             ..sub
+             ..super
+             
+             ..adjusted_idx
+             ..parameter!
+             ..existential
+             ..named
+             ..recursive
+
+             ($.default /.not_existential)
+             ($.default /.not_recursive)
+             ($.default /.not_named)
+             ($.default /.not_parameter)
+             ($.default /.unknown_parameter)
+             ($.default /.not_function)
+             ($.default /.not_application)
+             ($.default /.not_polymorphic)
+             ($.default /.not_variant)
+             ($.default /.not_tuple)
+             ($.default /.types_do_not_match)
+             ($.default /.wrong_parameter)
+             ($.default /.empty_input)
+             ($.default /.unconsumed_input)
+             ($.default /.parameter)
+             ($.default /.recursive_self)
+             ($.default /.recursive_call)]
+            []))
diff --git a/stdlib/source/documentation/lux/control/parser/xml.lux b/stdlib/source/documentation/lux/control/parser/xml.lux
new file mode 100644
index 000000000..71390acdb
--- /dev/null
+++ b/stdlib/source/documentation/lux/control/parser/xml.lux
@@ -0,0 +1,60 @@
+(.module:
+  [library
+   [lux #*
+    ["$" documentation (#+ documentation:)]
+    [data
+     [text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     ["." template]]]]
+  [\\library
+   ["." /]])
+
+(documentation: /.Parser
+  "A parser of XML-encoded data.")
+
+(documentation: /.result
+  (format "Applies a parser against a stream of XML documents."
+          \n "Verifies that all of the inputs are consumed by the parser.")
+  [(result parser documents)])
+
+(documentation: /.text
+  "Yields text from a text node.")
+
+(documentation: /.tag
+  "Yields the tag from the next node.")
+
+(documentation: /.attribute
+  "Yields the value of an attribute in the current node."
+  [(attribute name)])
+
+(documentation: /.node
+  "Parses the contents of the next node if the tag matches."
+  [(node expected parser)])
+
+(documentation: /.any
+  "Yields the next node.")
+
+(documentation: /.somewhere
+  "Applies the parser somewhere among the remaining inputs; instead of demanding that the parser succeeds against the immediate inputs."
+  [(somewhere parser)])
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            ""
+            [..Parser
+             ..result
+             ..text
+             ..tag
+             ..attribute
+             ..node
+             ..any
+             ..somewhere
+             ($.default /.empty_input)
+             ($.default /.unexpected_input)
+             ($.default /.wrong_tag)
+             ($.default /.unknown_attribute)
+             ($.default /.unconsumed_inputs)
+             ($.default /.nowhere)]
+            []))
diff --git a/stdlib/source/documentation/lux/data.lux b/stdlib/source/documentation/lux/data.lux
new file mode 100644
index 000000000..0939016a1
--- /dev/null
+++ b/stdlib/source/documentation/lux/data.lux
@@ -0,0 +1,40 @@
+(.module:
+  [library
+   [lux #*
+    ["$" documentation (#+ documentation:)]
+    [data
+     [text (#+ \n)
+      ["%" format (#+ format)]]
+     [collection
+      ["." list]]]]]
+  ["." / #_
+   ["#." binary]
+   ["#." bit]
+   ["#." collection]
+   ["#." color]
+   ... ["#." identity]
+   ... ["#." name]
+   ... ["#." product]
+   ... ["#." sum]
+   ... ["#." text]
+   ... ["#." format #_
+   ...  ["#/." binary]
+   ...  ["#/." json]
+   ...  ["#/." tar]
+   ...  ["#/." xml]]
+   ])
+
+(.def: .public documentation
+  (.List $.Module)
+  (list.together
+   (list /binary.documentation
+         /bit.documentation
+         /collection.documentation
+         /color.documentation
+         ... /identity.documentation
+         ... /name.documentation
+         ... /product.documentation
+         ... /sum.documentation
+         ... /text.documentation
+         ... /format.documentation
+         )))
diff --git a/stdlib/source/documentation/lux/data/binary.lux b/stdlib/source/documentation/lux/data/binary.lux
new file mode 100644
index 000000000..c740e6660
--- /dev/null
+++ b/stdlib/source/documentation/lux/data/binary.lux
@@ -0,0 +1,91 @@
+(.module:
+  [library
+   [lux #*
+    ["$" documentation (#+ documentation:)]
+    [data
+     [text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     ["." template]]]]
+  [\\library
+   ["." /]])
+
+(documentation: /.Binary
+  "A binary BLOB of data.")
+
+(documentation: /.empty
+  "A fresh/empty binary BLOB of the specified size."
+  [(empty size)])
+
+(documentation: /.aggregate
+  ""
+  [(aggregate f init binary)])
+
+(documentation: /.read/8!
+  "Read 1 byte (8 bits) at the given index."
+  [(read/8! index binary)])
+
+(documentation: /.read/16!
+  "Read 2 bytes (16 bits) at the given index."
+  [(read/16! index binary)])
+
+(documentation: /.read/32!
+  "Read 4 bytes (32 bits) at the given index."
+  [(read/32! index binary)])
+
+(documentation: /.read/64!
+  "Read 8 bytes (64 bits) at the given index."
+  [(read/64! index binary)])
+
+(documentation: /.write/8!
+  "Write 1 byte (8 bits) at the given index."
+  [(write/8! index value binary)])
+
+(documentation: /.write/16!
+  "Write 2 bytes (16 bits) at the given index."
+  [(write/16! index value binary)])
+
+(documentation: /.write/32!
+  "Write 4 bytes (32 bits) at the given index."
+  [(write/32! index value binary)])
+
+(documentation: /.write/64!
+  "Write 8 bytes (64 bits) at the given index."
+  [(write/64! index value binary)])
+
+(documentation: /.copy
+  "Mutates the target binary BLOB by copying bytes from the source BLOB to it."
+  [(copy bytes source_offset source target_offset target)])
+
+(documentation: /.slice
+  "Yields a subset of the binary BLOB, so long as the specified range is valid."
+  [(slice offset length binary)])
+
+(documentation: /.after
+  "Yields a binary BLOB with at most the specified number of bytes removed."
+  [(after bytes binary)])
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            ""
+            [..Binary
+             ..empty
+             ..aggregate
+             ..read/8!
+             ..read/16!
+             ..read/32!
+             ..read/64!
+             ..write/8!
+             ..write/16!
+             ..write/32!
+             ..write/64!
+             ..copy
+             ..slice
+             ..after
+             ($.default /.index_out_of_bounds)
+             ($.default /.slice_out_of_bounds)
+             ($.default /.size)
+             ($.default /.equivalence)
+             ($.default /.monoid)]
+            []))
diff --git a/stdlib/source/documentation/lux/data/bit.lux b/stdlib/source/documentation/lux/data/bit.lux
new file mode 100644
index 000000000..e1379b85c
--- /dev/null
+++ b/stdlib/source/documentation/lux/data/bit.lux
@@ -0,0 +1,31 @@
+(.module:
+  [library
+   [lux #*
+    ["$" documentation (#+ documentation:)]
+    [data
+     [text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     ["." template]]]]
+  [\\library
+   ["." /]])
+
+(documentation: /.complement
+  (format "Generates the complement of a predicate."
+          \n "That is a predicate that returns the oposite of the original predicate."))
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            ""
+            [..complement
+             ($.default /.no)
+             ($.default /.yes)
+             ($.default /.off)
+             ($.default /.on)
+             ($.default /.equivalence)
+             ($.default /.hash)
+             ($.default /.disjunction)
+             ($.default /.conjunction)
+             ($.default /.codec)]
+            []))
diff --git a/stdlib/source/documentation/lux/data/collection.lux b/stdlib/source/documentation/lux/data/collection.lux
new file mode 100644
index 000000000..e96f59465
--- /dev/null
+++ b/stdlib/source/documentation/lux/data/collection.lux
@@ -0,0 +1,40 @@
+(.module:
+  [library
+   [lux #*
+    ["$" documentation (#+ documentation:)]
+    [data
+     [text (#+ \n)
+      ["%" format (#+ format)]]
+     [collection
+      ["." list]]]]]
+  ["." / #_
+   ["#." array]
+   ["#." bits]
+   ["#." dictionary]
+   ["#." list]
+   ["#." queue]
+   ["#." row]
+   ["#." sequence]
+   ... ["#." stack]
+   ... ["#." set
+   ...  ["#/." multi]
+   ...  ["#/." ordered]]
+   ... ["#." tree
+   ...  ["#/." finger]
+   ...  ["#/." zipper]]
+   ])
+
+(.def: .public documentation
+  (.List $.Module)
+  (list.together
+   (list /array.documentation
+         /bits.documentation
+         /dictionary.documentation
+         /list.documentation
+         /queue.documentation
+         /row.documentation
+         /sequence.documentation
+         ... /stack.documentation
+         ... /set.documentation
+         ... /tree.documentation
+         )))
diff --git a/stdlib/source/documentation/lux/data/collection/array.lux b/stdlib/source/documentation/lux/data/collection/array.lux
new file mode 100644
index 000000000..3bf22b587
--- /dev/null
+++ b/stdlib/source/documentation/lux/data/collection/array.lux
@@ -0,0 +1,124 @@
+(.module:
+  [library
+   [lux (#- example list)
+    ["$" documentation (#+ documentation:)]
+    [control
+     ["<>" parser
+      ["<.>" code]]]
+    [data
+     ["." text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     [syntax (#+ syntax:)]
+     ["." code]
+     ["." template]]]]
+  [\\library
+   ["." /]])
+
+(documentation: /.Array
+  "Mutable arrays.")
+
+(documentation: /.empty
+  "An empty array of the specified size."
+  [(empty size)])
+
+(documentation: /.size
+  ""
+  [(size array)])
+
+(documentation: /.read!
+  ""
+  [(read! index array)])
+
+(documentation: /.write!
+  "Mutate the array by writing a value to the specified index."
+  [(write! index value array)])
+
+(documentation: /.delete!
+  "Mutate the array by deleting the value at the specified index."
+  [(delete! index array)])
+
+(documentation: /.contains?
+  ""
+  [(contains? index array)])
+
+(documentation: /.update!
+  "Mutate the array by updating the value at the specified index."
+  [(update! index transform array)])
+
+(documentation: /.upsert!
+  (format "Mutate the array by updating the value at the specified index."
+          \n "If there is no value, update and write the default value given.")
+  [(upsert! index default transform array)])
+
+(documentation: /.copy!
+  "Writes the contents of one array into the other."
+  [(copy! length src_start src_array dest_start dest_array)])
+
+(documentation: /.occupancy
+  "Finds out how many cells in an array are occupied."
+  [(occupancy array)])
+
+(documentation: /.vacancy
+  "Finds out how many cells in an array are vacant."
+  [(vacancy array)])
+
+(documentation: /.filter!
+  "Delete every item of the array that fails to satisfy the predicate."
+  [(filter! p xs)])
+
+(documentation: /.example
+  "Yields the first item in the array that satisfies the predicate."
+  [(example p xs)])
+
+(documentation: /.example+
+  "Just like 'example', but with access to the index of each value."
+  [(example+ p xs)])
+
+(documentation: /.clone
+  "Yields a shallow clone of the array."
+  [(clone xs)])
+
+(documentation: /.of_list
+  ""
+  [(of_list xs)])
+
+(documentation: /.list
+  "Yields a list with every non-empty item in the array."
+  [(list array)])
+
+(documentation: /.list'
+  "Like 'list', but uses the 'default' value when encountering an empty cell in the array."
+  [(list' default array)])
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            ""
+            [..Array
+             ..empty
+             ..size
+             ..read!
+             ..write!
+             ..delete!
+             ..contains?
+             ..update!
+             ..upsert!
+             ..copy!
+             ..occupancy
+             ..vacancy
+             ..filter!
+             ..example
+             ..example+
+             ..clone
+             ..of_list
+             ..list
+             ..list'
+             ($.default /.type_name)
+             ($.default /.equivalence)
+             ($.default /.monoid)
+             ($.default /.functor)
+             ($.default /.fold)
+             ($.default /.every?)
+             ($.default /.any?)]
+            []))
diff --git a/stdlib/source/documentation/lux/data/collection/bits.lux b/stdlib/source/documentation/lux/data/collection/bits.lux
new file mode 100644
index 000000000..f5fe95dc3
--- /dev/null
+++ b/stdlib/source/documentation/lux/data/collection/bits.lux
@@ -0,0 +1,86 @@
+(.module:
+  [library
+   [lux (#- or and not)
+    ["$" documentation (#+ documentation:)]
+    [control
+     ["<>" parser
+      ["<.>" code]]]
+    [data
+     ["." text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     [syntax (#+ syntax:)]
+     ["." code]
+     ["." template]]]]
+  [\\library
+   ["." /]])
+
+(documentation: /.Bits
+  "A bit-map.")
+
+(documentation: /.size
+  "Measures the size of a bit-map by counting all the 1s in the bit-map."
+  [(size bits)])
+
+(documentation: /.capacity
+  ""
+  [(capacity bits)])
+
+(documentation: /.bit
+  ""
+  [(bit index bits)])
+
+(template [<name>]
+  [(documentation: <name>
+     ""
+     [(<name> index input)])]
+
+  [/.one]
+  [/.zero]
+  [/.flipped]
+  )
+
+(documentation: /.intersects?
+  ""
+  [(intersects? reference sample)])
+
+(documentation: /.not
+  ""
+  [(not input)])
+
+(template [<name>]
+  [(documentation: <name>
+     ""
+     [(<name> param subject)])]
+
+  [/.and]
+  [/.or]
+  [/.xor]
+  )
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            ""
+            [..Bits
+             ..size
+             ..capacity
+             ..bit
+
+             ..one
+             ..zero
+             ..flipped
+             
+             ..intersects?
+             ..not
+
+             ..and
+             ..or
+             ..xor
+             
+             ($.default /.Chunk)
+             ($.default /.chunk_size)
+             ($.default /.empty)
+             ($.default /.empty?)
+             ($.default /.equivalence)]
+            []))
diff --git a/stdlib/source/documentation/lux/data/collection/dictionary.lux b/stdlib/source/documentation/lux/data/collection/dictionary.lux
new file mode 100644
index 000000000..95d2f998a
--- /dev/null
+++ b/stdlib/source/documentation/lux/data/collection/dictionary.lux
@@ -0,0 +1,107 @@
+(.module:
+  [library
+   [lux #*
+    ["$" documentation (#+ documentation:)]
+    [control
+     ["<>" parser
+      ["<.>" code]]]
+    [data
+     ["." text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     [syntax (#+ syntax:)]
+     ["." code]
+     ["." template]]]]
+  [\\library
+   ["." /]]
+  ["." / #_
+   ["#." ordered]
+   ["#." plist]])
+
+(documentation: /.Dictionary
+  "A dictionary implemented as a Hash-Array Mapped Trie (HAMT).")
+
+(documentation: /.empty
+  "An empty dictionary."
+  [(empty key_hash)])
+
+(documentation: /.has
+  ""
+  [(has key val dict)])
+
+(documentation: /.lacks
+  ""
+  [(lacks key dict)])
+
+(documentation: /.value
+  ""
+  [(value key dict)])
+
+(documentation: /.key?
+  ""
+  [(key? dict key)])
+
+(documentation: /.has'
+  "Only puts the KV-pair if the key is not already present."
+  [(has' key val dict)])
+
+(documentation: /.revised
+  "Transforms the value located at key (if available), using the given function."
+  [(revised key f dict)])
+
+(documentation: /.revised'
+  (format "Updates the value at the key; if it exists."
+          \n "Otherwise, puts a value by applying the function to a default.")
+  [(revised' key default f dict)])
+
+(documentation: /.of_list
+  ""
+  [(of_list key_hash kvs)])
+
+(documentation: /.merged
+  (format "Merges 2 dictionaries."
+          \n "If any collisions with keys occur, the values of dict2 will overwrite those of dict1.")
+  [(merged dict2 dict1)])
+
+(documentation: /.merged_with
+  (format "Merges 2 dictionaries."
+          \n "If any collisions with keys occur, a new value will be computed by applying 'f' to the values of dict2 and dict1.")
+  [(merged_with f dict2 dict1)])
+
+(documentation: /.re_bound
+  "If there is a value under 'from_key', remove 'from_key' and store the value under 'to_key'."
+  [(re_bound from_key to_key dict)])
+
+(documentation: /.sub
+  "A sub-dictionary, with only the specified keys."
+  [(sub keys dict)])
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            ""
+            [..Dictionary
+             ..empty
+             ..has
+             ..lacks
+             ..value
+             ..key?
+             ..has'
+             ..revised
+             ..revised'
+             ..of_list
+             ..merged
+             ..merged_with
+             ..re_bound
+             ..sub
+             ($.default /.key_hash)
+             ($.default /.key_already_exists)
+             ($.default /.size)
+             ($.default /.empty?)
+             ($.default /.entries)
+             ($.default /.keys)
+             ($.default /.values)
+             ($.default /.equivalence)
+             ($.default /.functor)]
+            [/ordered.documentation
+             /plist.documentation]))
diff --git a/stdlib/source/documentation/lux/data/collection/dictionary/ordered.lux b/stdlib/source/documentation/lux/data/collection/dictionary/ordered.lux
new file mode 100644
index 000000000..adbb1303f
--- /dev/null
+++ b/stdlib/source/documentation/lux/data/collection/dictionary/ordered.lux
@@ -0,0 +1,84 @@
+(.module:
+  [library
+   [lux #*
+    ["$" documentation (#+ documentation:)]
+    [control
+     ["<>" parser
+      ["<.>" code]]]
+    [data
+     ["." text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     [syntax (#+ syntax:)]
+     ["." code]
+     ["." template]]]]
+  [\\library
+   ["." /]])
+
+(documentation: /.Dictionary
+  "A dictionary data-structure with ordered entries.")
+
+(documentation: /.empty
+  "An empty dictionary, employing the given order."
+  [(empty order)])
+
+(documentation: /.value
+  ""
+  [(value key dict)])
+
+(documentation: /.key?
+  ""
+  [(key? dict key)])
+
+(template [<name>]
+  [(`` (documentation: <name>
+         (format "Yields value under the " (~~ (template.text [<name>])) "imum key.")
+         [(<name> dict)]))]
+
+  [/.min]
+  [/.max]
+  )
+
+(documentation: /.size
+  ""
+  [(size dict)])
+
+(documentation: /.has
+  ""
+  [(has key value dict)])
+
+(documentation: /.lacks
+  ""
+  [(lacks key dict)])
+
+(documentation: /.revised
+  ""
+  [(revised key transform dict)])
+
+(documentation: /.of_list
+  ""
+  [(of_list order list)])
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            ""
+            [..Dictionary
+             ..empty
+             ..value
+             ..key?
+
+             ..min
+             ..max
+             
+             ..size
+             ..has
+             ..lacks
+             ..revised
+             ..of_list
+             ($.default /.empty?)
+             ($.default /.entries)
+             ($.default /.keys)
+             ($.default /.values)
+             ($.default /.equivalence)]
+            []))
diff --git a/stdlib/source/documentation/lux/data/collection/dictionary/plist.lux b/stdlib/source/documentation/lux/data/collection/dictionary/plist.lux
new file mode 100644
index 000000000..2450cc9eb
--- /dev/null
+++ b/stdlib/source/documentation/lux/data/collection/dictionary/plist.lux
@@ -0,0 +1,58 @@
+(.module:
+  [library
+   [lux #*
+    ["$" documentation (#+ documentation:)]
+    [control
+     ["<>" parser
+      ["<.>" code]]]
+    [data
+     ["." text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     [syntax (#+ syntax:)]
+     ["." code]
+     ["." template]]]]
+  [\\library
+   ["." /]])
+
+(documentation: /.PList
+  (format "A property list."
+          \n "It's a simple dictionary-like structure with Text keys."))
+
+(documentation: /.value
+  ""
+  [(value key properties)])
+
+(documentation: /.contains?
+  ""
+  [(contains? key properties)])
+
+(documentation: /.has
+  ""
+  [(has key val properties)])
+
+(documentation: /.revised
+  ""
+  [(revised key f properties)])
+
+(documentation: /.lacks
+  ""
+  [(lacks key properties)])
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            ""
+            [..PList
+             ..value
+             ..contains?
+             ..has
+             ..revised
+             ..lacks
+             ($.default /.empty)
+             ($.default /.size)
+             ($.default /.empty?)
+             ($.default /.keys)
+             ($.default /.values)
+             ($.default /.equivalence)]
+            []))
diff --git a/stdlib/source/documentation/lux/data/collection/list.lux b/stdlib/source/documentation/lux/data/collection/list.lux
new file mode 100644
index 000000000..1050ab7ce
--- /dev/null
+++ b/stdlib/source/documentation/lux/data/collection/list.lux
@@ -0,0 +1,239 @@
+(.module:
+  [library
+   [lux (#- example)
+    ["$" documentation (#+ documentation:)]
+    [control
+     ["<>" parser
+      ["<.>" code]]]
+    [data
+     ["." text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     [syntax (#+ syntax:)]
+     ["." code]
+     ["." template]]]]
+  [\\library
+   ["." /]])
+
+(documentation: /.aggregates
+  ""
+  [(aggregates f init inputs)])
+
+(documentation: /.reversed
+  ""
+  [(reversed xs)])
+
+(documentation: /.only
+  "A list with only values that satisfy the predicate."
+  [(only keep? xs)])
+
+(documentation: /.partition
+  "Divide the list into all elements that satisfy a predicate, and all elements that do not."
+  [(partition satisfies? list)])
+
+(documentation: /.pairs
+  (format "Cut the list into pairs of 2."
+          \n "Caveat emptor: If the list has an un-even number of elements, the last one will be skipped.")
+  [(pairs xs)])
+
+(template [<name>]
+  [(documentation: <name>
+     ""
+     [(<name> n xs)])]
+  
+  [/.first]
+  [/.after]
+  )
+
+(template [<name>]
+  [(documentation: <name>
+     ""
+     [(<name> predicate xs)])]
+
+  [/.while]
+  [/.until]
+  )
+
+(documentation: /.split_at
+  ""
+  [(split_at n xs)])
+
+(documentation: /.split_when
+  "Segment the list by using a predicate to tell when to cut."
+  [(split_when predicate xs)])
+
+(documentation: /.sub
+  "Segment the list into sub-lists of (at most) the given size."
+  [(sub size list)])
+
+(documentation: /.repeated
+  "A list of the value x, repeated n times."
+  [(repeated n x)])
+
+(documentation: /.iterations
+  "Generates a list element by element until the function returns #.None."
+  [(iterations f x)])
+
+(documentation: /.one
+  ""
+  [(one check xs)])
+
+(documentation: /.all
+  ""
+  [(all check xs)])
+
+(documentation: /.example
+  "Yields the first value in the list that satisfies the predicate."
+  [(example predicate xs)])
+
+(documentation: /.interposed
+  "Puts a value between every two elements in the list."
+  [(interposed sep xs)])
+
+(documentation: /.size
+  ""
+  [(size list)])
+
+(template [<name>]
+  [(documentation: <name>
+     ""
+     [(<name> predicate items)])]
+
+  [/.every?]
+  [/.any?]
+  )
+
+(documentation: /.item
+  "Fetches the element at the specified index."
+  [(item i xs)])
+
+(documentation: /.sorted
+  "A list ordered by a comparison function."
+  [(sorted < xs)])
+
+(documentation: /.empty?
+  ""
+  [(empty? xs)])
+
+(documentation: /.member?
+  ""
+  [(member? eq xs x)])
+
+(template [<name> <doc>]
+  [(documentation: <name>
+     <doc>
+     [(<name> xs)])]
+
+  [/.head "Yields the first element of a list."]
+  [/.tail "For a list of size N, yields the N-1 elements after the first one."]
+  )
+
+(documentation: /.indices
+  "Produces all the valid indices for a given size."
+  [(indices size)])
+
+(documentation: /.zipped
+  "Create list zippers with the specified number of input lists."
+  [(def: zipped/2 (zipped 2))
+   (def: zipped/3 (zipped 3))
+   (zipped/3 xs ys zs)
+   ((zipped 3) xs ys zs)])
+
+(documentation: /.zipped_with
+  "Create list zippers with the specified number of input lists."
+  [(def: zipped_with/2 (zipped_with 2))
+   (def: zipped_with/3 (zipped_with 3))
+   (zipped_with/2 + xs ys)
+   ((zipped_with 2) + xs ys)])
+
+(documentation: /.last
+  ""
+  [(last xs)])
+
+(documentation: /.inits
+  (format "For a list of size N, yields the first N-1 elements."
+          \n "Will yield a #.None for empty lists.")
+  [(inits xs)])
+
+(documentation: /.together
+  "The sequential combination of all the lists.")
+
+(documentation: /.with
+  "Enhances a monad with List functionality."
+  [(with monad)])
+
+(documentation: /.lifted
+  "Wraps a monadic value with List machinery."
+  [(lifted monad)])
+
+(documentation: /.enumeration
+  "Pairs every element in the list with its index, starting at 0."
+  [(enumeration xs)])
+
+(documentation: /.when
+  "Can be used as a guard in (co)monadic be/do expressions."
+  [(do monad
+     [value (do_something 1 2 3)
+      /.when (passes_test? value)]
+     (do_something_else 4 5 6))])
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            ""
+            [..aggregates
+             ..reversed
+             ..only
+             ..partition
+             ..pairs
+
+             ..first
+             ..after
+             
+             ..while
+             ..until
+             
+             ..split_at
+             ..split_when
+             ..sub
+             ..repeated
+             ..iterations
+             ..one
+             ..all
+             ..example
+             ..interposed
+             ..size
+
+             ..every?
+             ..any?
+             
+             ..item
+             ..sorted
+             ..empty?
+             ..member?
+
+             ..head
+             ..tail
+             
+             ..indices
+             ..zipped
+             ..zipped_with
+             ..last
+             ..inits
+             ..together
+             ..with
+             ..lifted
+             ..enumeration
+             ..when
+             ($.default /.fold)
+             ($.default /.equivalence)
+             ($.default /.hash)
+             ($.default /.monoid)
+             ($.default /.functor)
+             ($.default /.apply)
+             ($.default /.monad)
+             ($.default /.zipped/2)
+             ($.default /.zipped/3)
+             ($.default /.zipped_with/2)
+             ($.default /.zipped_with/3)]
+            []))
diff --git a/stdlib/source/documentation/lux/data/collection/queue.lux b/stdlib/source/documentation/lux/data/collection/queue.lux
new file mode 100644
index 000000000..5b866fe90
--- /dev/null
+++ b/stdlib/source/documentation/lux/data/collection/queue.lux
@@ -0,0 +1,62 @@
+(.module:
+  [library
+   [lux (#- list)
+    ["$" documentation (#+ documentation:)]
+    [control
+     ["<>" parser
+      ["<.>" code]]]
+    [data
+     ["." text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     [syntax (#+ syntax:)]
+     ["." code]
+     ["." template]]]]
+  [\\library
+   ["." /]]
+  ["." / #_
+   ["#." priority]])
+
+(documentation: /.Queue
+  "A first-in, first-out sequential data-structure.")
+
+(documentation: /.of_list
+  ""
+  [(of_list entries)])
+
+(documentation: /.list
+  ""
+  [(list queue)])
+
+(documentation: /.front
+  "Yields the first value in the queue, if any.")
+
+(documentation: /.member?
+  ""
+  [(member? equivalence queue member)])
+
+(documentation: /.next
+  ""
+  [(next queue)])
+
+(documentation: /.end
+  ""
+  [(end val queue)])
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            ""
+            [..Queue
+             ..of_list
+             ..list
+             ..front
+             ..member?
+             ..next
+             ..end
+             ($.default /.empty)
+             ($.default /.size)
+             ($.default /.empty?)
+             ($.default /.equivalence)
+             ($.default /.functor)]
+            [/priority.documentation]))
diff --git a/stdlib/source/documentation/lux/data/collection/queue/priority.lux b/stdlib/source/documentation/lux/data/collection/queue/priority.lux
new file mode 100644
index 000000000..e62869ecd
--- /dev/null
+++ b/stdlib/source/documentation/lux/data/collection/queue/priority.lux
@@ -0,0 +1,41 @@
+(.module:
+  [library
+   [lux (#- list)
+    ["$" documentation (#+ documentation:)]
+    [control
+     ["<>" parser
+      ["<.>" code]]]
+    [data
+     ["." text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     [syntax (#+ syntax:)]
+     ["." code]
+     ["." template]]]]
+  [\\library
+   ["." /]])
+
+(documentation: /.member?
+  ""
+  [(member? equivalence queue member)])
+
+(documentation: /.end
+  ""
+  [(end priority value queue)])
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            ""
+            [..member?
+             ..end
+             ($.default /.Priority)
+             ($.default /.max)
+             ($.default /.min)
+             ($.default /.Queue)
+             ($.default /.empty)
+             ($.default /.front)
+             ($.default /.size)
+             ($.default /.next)
+             ($.default /.empty?)]
+            []))
diff --git a/stdlib/source/documentation/lux/data/collection/row.lux b/stdlib/source/documentation/lux/data/collection/row.lux
new file mode 100644
index 000000000..e72e8974e
--- /dev/null
+++ b/stdlib/source/documentation/lux/data/collection/row.lux
@@ -0,0 +1,86 @@
+(.module:
+  [library
+   [lux (#- list)
+    ["$" documentation (#+ documentation:)]
+    [control
+     ["<>" parser
+      ["<.>" code]]]
+    [data
+     ["." text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     [syntax (#+ syntax:)]
+     ["." code]
+     ["." template]]]]
+  [\\library
+   ["." /]])
+
+(documentation: /.Row
+  "A sequential data-structure with fast random access.")
+
+(documentation: /.suffix
+  ""
+  [(suffix val row)])
+
+(documentation: /.within_bounds?
+  "Determines whether the index is within the bounds of the row."
+  [(within_bounds? row idx)])
+
+(documentation: /.item
+  ""
+  [(item idx row)])
+
+(documentation: /.has
+  ""
+  [(has idx val row)])
+
+(documentation: /.revised
+  ""
+  [(revised idx f row)])
+
+(documentation: /.prefix
+  ""
+  [(prefix row)])
+
+(documentation: /.list
+  ""
+  [(list row)])
+
+(documentation: /.member?
+  ""
+  [(member? equivalence row val)])
+
+(documentation: /.row
+  "Row literals."
+  [(: (Row Nat)
+      (row 12 34 56 78 90))])
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            ""
+            [..Row
+             ..suffix
+             ..within_bounds?
+             ..item
+             ..has
+             ..revised
+             ..prefix
+             ..list
+             ..member?
+             ..row
+             ($.default /.empty)
+             ($.default /.size)
+             ($.default /.index_out_of_bounds)
+             ($.default /.of_list)
+             ($.default /.empty?)
+             ($.default /.equivalence)
+             ($.default /.fold)
+             ($.default /.monoid)
+             ($.default /.functor)
+             ($.default /.apply)
+             ($.default /.monad)
+             ($.default /.reversed)
+             ($.default /.every?)
+             ($.default /.any?)]
+            []))
diff --git a/stdlib/source/documentation/lux/data/collection/sequence.lux b/stdlib/source/documentation/lux/data/collection/sequence.lux
new file mode 100644
index 000000000..64e976155
--- /dev/null
+++ b/stdlib/source/documentation/lux/data/collection/sequence.lux
@@ -0,0 +1,98 @@
+(.module:
+  [library
+   [lux (#- list)
+    ["$" documentation (#+ documentation:)]
+    [control
+     ["<>" parser
+      ["<.>" code]]]
+    [data
+     ["." text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     [syntax (#+ syntax:)]
+     ["." code]
+     ["." template]]]]
+  [\\library
+   ["." /]])
+
+(documentation: /.Sequence
+  "An infinite sequence of values.")
+
+(documentation: /.iterations
+  "A stateful way of infinitely calculating the values of a sequence."
+  [(iterations step init)])
+
+(documentation: /.repeated
+  "Repeat a value forever."
+  [(repeated x)])
+
+(documentation: /.cycle
+  (format "Go over the elements of a list forever."
+          \n "The list should not be empty.")
+  [(cycle [start next])])
+
+(documentation: /.item
+  ""
+  [(item idx sequence)])
+
+(template [<taker> <dropper>]
+  [(documentation: <taker>
+     ""
+     [(<taker> pred xs)])
+   (documentation: <dropper>
+     ""
+     [(<dropper> pred xs)])]
+  
+  [/.while /.until]
+  [/.first /.after]
+  )
+
+(template [<splitter>]
+  [(documentation: <splitter>
+     ""
+     [(<splitter> pred xs)])]
+  
+  [/.split_when]
+  [/.split_at]
+  )
+
+(documentation: /.only
+  "A new sequence only with items that satisfy the predicate."
+  [(only predicate sequence)])
+
+(documentation: /.partition
+  (format "Split a sequence in two based on a predicate."
+          \n "The left side contains all entries for which the predicate is #1."
+          \n "The right side contains all entries for which the predicate is #0.")
+  [(partition left? xs)])
+
+(documentation: /.^sequence&
+  (format "Allows destructuring of sequences in pattern-matching expressions."
+          \n "Caveat emptor: Only use it for destructuring, and not for testing values within the sequences.")
+  [(let [(^sequence& x y z _tail) (some_sequence_func +1 +2 +3)]
+     (func x y z))])
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            ""
+            [..Sequence
+             ..iterations
+             ..repeated
+             ..cycle
+             ..item
+
+             ..while ..until
+             ..first ..after
+             
+             ..split_when
+             ..split_at
+             
+             ..only
+             ..partition
+             ..^sequence&
+             ($.default /.head)
+             ($.default /.tail)
+             ($.default /.functor)
+             ($.default /.comonad)]
+            []))
diff --git a/stdlib/source/documentation/lux/data/color.lux b/stdlib/source/documentation/lux/data/color.lux
new file mode 100644
index 000000000..96a44b6ed
--- /dev/null
+++ b/stdlib/source/documentation/lux/data/color.lux
@@ -0,0 +1,126 @@
+(.module:
+  [library
+   [lux #*
+    ["$" documentation (#+ documentation:)]
+    [control
+     ["<>" parser
+      ["<.>" code]]]
+    [data
+     ["." text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     [syntax (#+ syntax:)]
+     ["." code]
+     ["." template]]]]
+  [\\library
+   ["." /]]
+  ["." / #_
+   ["#." named]])
+
+(documentation: /.RGB
+  "Red-Green-Blue color format.")
+
+(documentation: /.HSL
+  "Hue-Saturation-Lightness color format.")
+
+(documentation: /.CMYK
+  "Cyan-Magenta-Yellow-Key color format.")
+
+(documentation: /.HSB
+  "Hue-Saturation-Brightness color format.")
+
+(documentation: /.Color
+  "A color value, independent of color format.")
+
+(documentation: /.complement
+  "The opposite color."
+  [(complement color)])
+
+(documentation: /.interpolated
+  ""
+  [(interpolated ratio end start)])
+
+(template [<name>]
+  [(documentation: <name>
+     ""
+     [(<name> ratio color)])]
+
+  [/.darker]
+  [/.brighter]
+  [/.saturated]
+  [/.un_saturated]
+  )
+
+(syntax: (palette_documentation [[_ name] <code>.identifier])
+  (in (list (code.text (format "A " (text.replaced "_" "-" name) " palette.")))))
+
+(documentation: /.analogous
+  (palette_documentation /.analogous)
+  [(analogous spread variations color)])
+
+(documentation: /.monochromatic
+  (palette_documentation /.monochromatic)
+  [(monochromatic spread variations color)])
+
+(documentation: /.Alpha
+  "The degree of transparency of a pigment.")
+
+(documentation: /.transparent
+  "The maximum degree of transparency.")
+
+(documentation: /.translucent
+  "The average degree of transparency.")
+
+(documentation: /.opaque
+  "The minimum degree of transparency.")
+
+(documentation: /.Pigment
+  "A color with some degree of transparency.")
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            ""
+            [..RGB
+             ..HSL
+             ..CMYK
+             ..HSB
+             ..Color
+             ..complement
+             ..interpolated
+
+             ..darker
+             ..brighter
+             ..saturated
+             ..un_saturated
+             
+             ..analogous
+             ..monochromatic
+             ..Alpha
+             ..transparent
+             ..translucent
+             ..opaque
+             ..Pigment
+             ($.default /.of_rgb)
+             ($.default /.rgb)
+             ($.default /.equivalence)
+             ($.default /.hash)
+             ($.default /.black)
+             ($.default /.white)
+             ($.default /.addition)
+             ($.default /.subtraction)
+             ($.default /.hsl)
+             ($.default /.of_hsl)
+             ($.default /.hsb)
+             ($.default /.of_hsb)
+             ($.default /.cmyk)
+             ($.default /.of_cmyk)
+             ($.default /.gray_scale)
+             ($.default /.triad)
+             ($.default /.clash)
+             ($.default /.split_complement)
+             ($.default /.square)
+             ($.default /.tetradic)
+             ($.default /.Spread)
+             ($.default /.Palette)]
+            [/named.documentation]))
diff --git a/stdlib/source/documentation/lux/data/color/named.lux b/stdlib/source/documentation/lux/data/color/named.lux
new file mode 100644
index 000000000..6f9a080eb
--- /dev/null
+++ b/stdlib/source/documentation/lux/data/color/named.lux
@@ -0,0 +1,319 @@
+(.module:
+  [library
+   [lux #*
+    ["$" documentation (#+ documentation:)]
+    [control
+     ["<>" parser
+      ["<.>" code]]]
+    [data
+     ["." text (#+ \n)
+      ["%" format (#+ format)]]]
+    [macro
+     [syntax (#+ syntax:)]
+     ["." code]
+     ["." template]]
+    [math
+     [number
+      ["." nat ("#\." hex)]]]]]
+  [\\library
+   ["." /
+    ["/#" //]]])
+
+(template [<name>]
+  [(documentation: <name>
+     (let [[red green blue] (//.rgb <name>)
+           [_ name] (name_of <name>)]
+       (format "R:" (nat\encode red)
+               " G:" (nat\encode green)
+               " B:" (nat\encode blue)
+               " | " (text.replaced "_" " " name))))]
+
+  [/.alice_blue]
+  [/.antique_white]
+  [/.aqua]
+  [/.aquamarine]
+  [/.azure]
+  [/.beige]
+  [/.bisque]
+  [/.black]
+  [/.blanched_almond]
+  [/.blue]
+  [/.blue_violet]
+  [/.brown]
+  [/.burly_wood]
+  [/.cadet_blue]
+  [/.chartreuse]
+  [/.chocolate]
+  [/.coral]
+  [/.cornflower_blue]
+  [/.cornsilk]
+  [/.crimson]
+  [/.cyan]
+  [/.dark_blue]
+  [/.dark_cyan]
+  [/.dark_goldenrod]
+  [/.dark_gray]
+  [/.dark_green]
+  [/.dark_khaki]
+  [/.dark_magenta]
+  [/.dark_olive_green]
+  [/.dark_orange]
+  [/.dark_orchid]
+  [/.dark_red]
+  [/.dark_salmon]
+  [/.dark_sea_green]
+  [/.dark_slate_blue]
+  [/.dark_slate_gray]
+  [/.dark_turquoise]
+  [/.dark_violet]
+  [/.deep_pink]
+  [/.deep_sky_blue]
+  [/.dim_gray]
+  [/.dodger_blue]
+  [/.fire_brick]
+  [/.floral_white]
+  [/.forest_green]
+  [/.fuchsia]
+  [/.gainsboro]
+  [/.ghost_white]
+  [/.gold]
+  [/.goldenrod]
+  [/.gray]
+  [/.green]
+  [/.green_yellow]
+  [/.honey_dew]
+  [/.hot_pink]
+  [/.indian_red]
+  [/.indigo]
+  [/.ivory]
+  [/.khaki]
+  [/.lavender]
+  [/.lavender_blush]
+  [/.lawn_green]
+  [/.lemon_chiffon]
+  [/.light_blue]
+  [/.light_coral]
+  [/.light_cyan]
+  [/.light_goldenrod_yellow]
+  [/.light_gray]
+  [/.light_green]
+  [/.light_pink]
+  [/.light_salmon]
+  [/.light_sea_green]
+  [/.light_sky_blue]
+  [/.light_slate_gray]
+  [/.light_steel_blue]
+  [/.light_yellow]
+  [/.lime]
+  [/.lime_green]
+  [/.linen]
+  [/.magenta]
+  [/.maroon]
+  [/.medium_aquamarine]
+  [/.medium_blue]
+  [/.medium_orchid]
+  [/.medium_purple]
+  [/.medium_sea_green]
+  [/.medium_slate_blue]
+  [/.medium_spring_green]
+  [/.medium_turquoise]
+  [/.medium_violet_red]
+  [/.midnight_blue]
+  [/.mint_cream]
+  [/.misty_rose]
+  [/.moccasin]
+  [/.navajo_white]
+  [/.navy]
+  [/.old_lace]
+  [/.olive]
+  [/.olive_drab]
+  [/.orange]
+  [/.orange_red]
+  [/.orchid]
+  [/.pale_goldenrod]
+  [/.pale_green]
+  [/.pale_turquoise]
+  [/.pale_violet_red]
+  [/.papaya_whip]
+  [/.peach_puff]
+  [/.peru]
+  [/.pink]
+  [/.plum]
+  [/.powder_blue]
+  [/.purple]
+  [/.rebecca_purple]
+  [/.red]
+  [/.rosy_brown]
+  [/.royal_blue]
+  [/.saddle_brown]
+  [/.salmon]
+  [/.sandy_brown]
+  [/.sea_green]
+  [/.sea_shell]
+  [/.sienna]
+  [/.silver]
+  [/.sky_blue]
+  [/.slate_blue]
+  [/.slate_gray]
+  [/.snow]
+  [/.spring_green]
+  [/.steel_blue]
+  [/.tan]
+  [/.teal]
+  [/.thistle]
+  [/.tomato]
+  [/.turquoise]
+  [/.violet]
+  [/.wheat]
+  [/.white]
+  [/.white_smoke]
+  [/.yellow]
+  [/.yellow_green]
+  )
+
+(.def: .public documentation
+  (.List $.Module)
+  ($.module /._
+            ""
+            [..alice_blue
+             ..antique_white
+             ..aqua
+             ..aquamarine
+             ..azure
+             ..beige
+             ..bisque
+             ..black
+             ..blanched_almond
+             ..blue
+             ..blue_violet
+             ..brown
+             ..burly_wood
+             ..cadet_blue
+             ..chartreuse
+             ..chocolate
+             ..coral
+             ..cornflower_blue
+             ..cornsilk
+             ..crimson
+             ..cyan
+             ..dark_blue
+             ..dark_cyan
+             ..dark_goldenrod
+             ..dark_gray
+             ..dark_green
+             ..dark_khaki
+             ..dark_magenta
+             ..dark_olive_green
+             ..dark_orange
+             ..dark_orchid
+             ..dark_red
+             ..dark_salmon
+             ..dark_sea_green
+             ..dark_slate_blue
+             ..dark_slate_gray
+             ..dark_turquoise
+             ..dark_violet
+             ..deep_pink
+             ..deep_sky_blue
+             ..dim_gray
+             ..dodger_blue
+             ..fire_brick
+             ..floral_white
+             ..forest_green
+             ..fuchsia
+             ..gainsboro
+             ..ghost_white
+             ..gold
+             ..goldenrod
+             ..gray
+             ..green
+             ..green_yellow
+             ..honey_dew
+             ..hot_pink
+             ..indian_red
+             ..indigo
+             ..ivory
+             ..khaki
+             ..lavender
+             ..lavender_blush
+             ..lawn_green
+             ..lemon_chiffon
+             ..light_blue
+             ..light_coral
+             ..light_cyan
+             ..light_goldenrod_yellow
+             ..light_gray
+             ..light_green
+             ..light_pink
+             ..light_salmon
+             ..light_sea_green
+             ..light_sky_blue
+             ..light_slate_gray
+             ..light_steel_blue
+             ..light_yellow
+             ..lime
+             ..lime_green
+             ..linen
+             ..magenta
+             ..maroon
+             ..medium_aquamarine
+             ..medium_blue
+             ..medium_orchid
+             ..medium_purple
+             ..medium_sea_green
+             ..medium_slate_blue
+             ..medium_spring_green
+             ..medium_turquoise
+             ..medium_violet_red
+             ..midnight_blue
+             ..mint_cream
+             ..misty_rose
+             ..moccasin
+             ..navajo_white
+             ..navy
+             ..old_lace
+             ..olive
+             ..olive_drab
+             ..orange
+             ..orange_red
+             ..orchid
+             ..pale_goldenrod
+             ..pale_green
+             ..pale_turquoise
+             ..pale_violet_red
+             ..papaya_whip
+             ..peach_puff
+             ..peru
+             ..pink
+             ..plum
+             ..powder_blue
+             ..purple
+             ..rebecca_purple
+             ..red
+             ..rosy_brown
+             ..royal_blue
+             ..saddle_brown
+             ..salmon
+             ..sandy_brown
+             ..sea_green
+             ..sea_shell
+             ..sienna
+             ..silver
+             ..sky_blue
+             ..slate_blue
+             ..slate_gray
+             ..snow
+             ..spring_green
+             ..steel_blue
+             ..tan
+             ..teal
+             ..thistle
+             ..tomato
+             ..turquoise
+             ..violet
+             ..wheat
+             ..white
+             ..white_smoke
+             ..yellow
+             ..yellow_green]
+            []))
diff --git a/stdlib/source/library/lux.lux b/stdlib/source/library/lux.lux
index 6554978c9..6c1335fe9 100644
--- a/stdlib/source/library/lux.lux
+++ b/stdlib/source/library/lux.lux
@@ -691,33 +691,55 @@
 ...    #seed            Nat
 ...    #scope_type_vars (List Nat)
 ...    #extensions      Any
+...    #eval            (-> Type Code (-> Lux (Either Text [Lux Any])))
 ...    #host            Any})
 ("lux def type tagged" Lux
  (#Named ["library/lux" "Lux"]
-         (#Product ... "lux.info"
-          Info
-          (#Product ... "lux.source"
-           Source
-           (#Product ... "lux.location"
-            Location
-            (#Product ... "lux.current_module"
-             (#Apply Text Maybe)
-             (#Product ... "lux.modules"
-              (#Apply (#Product Text Module) List)
-              (#Product ... "lux.scopes"
-               (#Apply Scope List)
-               (#Product ... "lux.type_context"
-                Type_Context
-                (#Product ... "lux.expected"
-                 (#Apply Type Maybe)
-                 (#Product ... "lux.seed"
-                  Nat
-                  (#Product ... scope_type_vars
-                   (#Apply Nat List)
-                   (#Product ... extensions
-                    Any
-                    ... "lux.host"
-                    Any))))))))))))
+         ({Lux
+           (#Apply Nothing
+                   (#UnivQ #End
+                           (#Product
+                            ... info
+                            Info
+                            (#Product
+                             ... source
+                             Source
+                             (#Product
+                              ... location
+                              Location
+                              (#Product
+                               ... current_module
+                               (#Apply Text Maybe)
+                               (#Product
+                                ... modules
+                                (#Apply (#Product Text Module) List)
+                                (#Product
+                                 ... scopes
+                                 (#Apply Scope List)
+                                 (#Product
+                                  ... type_context
+                                  Type_Context
+                                  (#Product
+                                   ... expected
+                                   (#Apply Type Maybe)
+                                   (#Product
+                                    ... seed
+                                    Nat
+                                    (#Product
+                                     ... scope_type_vars
+                                     (#Apply Nat List)
+                                     (#Product
+                                      ... extensions
+                                      Any
+                                      (#Product
+                                       ... eval
+                                       (#Function Type
+                                                  (#Function Code
+                                                             (#Function Lux
+                                                                        (#Sum Text (#Product Lux Any)))))
+                                       ... host
+                                       Any))))))))))))))}
+          (#Apply (#Parameter 1) (#Parameter 0))))
  (record$ (#Item [(tag$ ["library/lux" "doc"])
                   (text$ ("lux text concat"
                           ("lux text concat" "Represents the state of the Lux compiler during a run." __paragraph)
@@ -725,7 +747,7 @@
                            ("lux text concat" "It is provided to macros during their invocation, so they can access compiler data." __paragraph)
                            "Caveat emptor: Avoid fiddling with it, unless you know what you're doing.")))]
                  #End))
- ["info" "source" "location" "current_module" "modules" "scopes" "type_context" "expected" "seed" "scope_type_vars" "extensions" "host"]
+ ["info" "source" "location" "current_module" "modules" "scopes" "type_context" "expected" "seed" "scope_type_vars" "extensions" "eval" "host"]
  #1)
 
 ... (type: .public (Meta a)
@@ -1223,7 +1245,7 @@
                   (failure "Wrong syntax for Ex")}
                  tokens)))
 
-(def:'' .private (list\reverse list)
+(def:'' .private (list\reversed list)
         #End
         (All [a] (#Function ($' List a) ($' List a)))
         (list\fold ("lux type check" (All [a] (#Function a (#Function ($' List a) ($' List a))))
@@ -1248,7 +1270,7 @@
            
            _
            (failure "Wrong syntax for ->")}
-          (list\reverse tokens)))
+          (list\reversed tokens)))
 
 (macro:' .public (list xs)
          (#Item [(tag$ ["library/lux" "doc"])
@@ -1261,7 +1283,7 @@
                                                               (#Item (tuple$ (#Item [head (#Item [tail #End])]))
                                                                      #End))))
                                     (tag$ ["library/lux" "End"])
-                                    (list\reverse xs))
+                                    (list\reversed xs))
                          #End)))
 
 (macro:' .public (list& xs)
@@ -1281,7 +1303,7 @@
 
            _
            (failure "Wrong syntax for list&")}
-          (list\reverse xs)))
+          (list\reversed xs)))
 
 (macro:' .public (Variant tokens)
          (#Item [(tag$ ["library/lux" "doc"])
@@ -1300,7 +1322,7 @@
            (in_meta (list (list\fold (function'' [left right] (form$ (list (tag$ ["library/lux" "Sum"]) left right)))
                                      last
                                      prevs)))}
-          (list\reverse tokens)))
+          (list\reversed tokens)))
 
 (macro:' .public (Tuple tokens)
          (#Item [(tag$ ["library/lux" "doc"])
@@ -1319,7 +1341,7 @@
            (in_meta (list (list\fold (function'' [left right] (form$ (list (tag$ ["library/lux" "Product"]) left right)))
                                      last
                                      prevs)))}
-          (list\reverse tokens)))
+          (list\reversed tokens)))
 
 (macro:' .private (function' tokens)
          (let'' [name tokens'] ({(#Item [[_ (#Identifier ["" name])] tokens'])
@@ -1340,7 +1362,7 @@
                                                                                                   arg))
                                                                                     body')))
                                                            body
-                                                           (list\reverse targs))))))}
+                                                           (list\reversed targs))))))}
                    args)
 
                   _
@@ -1412,7 +1434,7 @@
                                                    (form$ (list (record$ (list [label body])) value))}
                                                   binding)))
                                      body
-                                     (list\reverse (pairs bindings)))))
+                                     (list\reversed (pairs bindings)))))
 
            _
            (failure "Wrong syntax for let'")}
@@ -1512,7 +1534,7 @@
 
              _
              (failure "Wrong syntax for $_")}
-            (list\reverse tokens'))
+            (list\reversed tokens'))
            
            _
            (failure "Wrong syntax for $_")}
@@ -1588,7 +1610,7 @@
                                                                     value))}
                                                       var))))
                                    body
-                                   (list\reverse (pairs bindings)))]
+                                   (list\reversed (pairs bindings)))]
                  (in_meta (list (form$ (list (record$ (list [(record$ (list [(tag$ ["library/lux" "in"]) g!in] [(tag$ ["library/lux" "bind"]) g!bind]))
                                                              body']))
                                              monad)))))
@@ -1690,7 +1712,7 @@
                 {#info info #source    source  #current_module _ #modules modules
                  #scopes scopes #type_context types    #host    host
                  #seed seed #expected  expected #location  location #extensions extensions
-                 #scope_type_vars scope_type_vars} state]
+                 #scope_type_vars scope_type_vars #eval _eval} state]
                ({(#Some {#module_hash _ #module_aliases _ #definitions definitions #imports _ #tags tags #types types #module_annotations _ #module_state _})
                  ({(#Some constant)
                    ({(#Left real_name)
@@ -1749,7 +1771,7 @@
                                        leftI))
                            lastO
                            inits))}
-            (list\reverse elems))
+            (list\reversed elems))
            #0
            (do meta_monad
              [=elems (monad\map meta_monad untemplated elems)]
@@ -1874,7 +1896,7 @@
         ({{#info info #source    source  #current_module current_module #modules modules
            #scopes scopes #type_context types    #host    host
            #seed seed #expected  expected #location  location #extensions extensions
-           #scope_type_vars scope_type_vars}
+           #scope_type_vars scope_type_vars #eval _eval}
           ({(#Some module_name)
             (#Right [state module_name])
 
@@ -1979,7 +2001,7 @@
 
            _
            (failure "Wrong syntax for <|")}
-          (list\reverse tokens)))
+          (list\reversed tokens)))
 
 (def:''' .private (function\composite f g)
          (list [(tag$ ["library/lux" "doc"])
@@ -2101,7 +2123,7 @@
          #End
          (All [a]
            (-> ($' List ($' List a)) ($' List a)))
-         (list\fold list\compose #End (list\reverse xs)))
+         (list\fold list\compose #End (list\reversed xs)))
 
 (macro:' .public (template tokens)
          (list [(tag$ ["library/lux" "doc"])
@@ -2298,7 +2320,7 @@
                                #scopes   scopes   #type_context   types   #host host
                                #seed   seed #expected expected
                                #location location #extensions extensions
-                               #scope_type_vars scope_type_vars}
+                               #scope_type_vars scope_type_vars #eval _eval}
                               (#Right state (macro' modules current_module module name))}
                              state)))))
 
@@ -2563,12 +2585,12 @@
             #scopes   scopes   #type_context   types   #host host
             #seed   seed #expected expected
             #location location #extensions extensions
-            #scope_type_vars scope_type_vars}
+            #scope_type_vars scope_type_vars #eval _eval}
            (#Right {#info info #source source #current_module _ #modules modules
                     #scopes   scopes   #type_context   types   #host host
                     #seed   ("lux i64 +" 1 seed) #expected expected
                     #location location #extensions extensions
-                    #scope_type_vars scope_type_vars}
+                    #scope_type_vars scope_type_vars #eval _eval}
                    (local_identifier$ ($_ text\compose "__gensym__" prefix (nat\encode seed))))}
           state))
 
@@ -2607,7 +2629,7 @@
 
            _
            (failure "Wrong syntax for exec")}
-          (list\reverse tokens)))
+          (list\reversed tokens)))
 
 (macro:' .private (def:' tokens)
          (let' [parts (: (Maybe [Code Code (List Code) (Maybe Code) Code])
@@ -2687,14 +2709,14 @@
          ($_ text\compose "(" (|> xs
                                   (list\map code\encode)
                                   (list\interposed " ")
-                                  list\reverse
+                                  list\reversed
                                   (list\fold text\compose "")) ")")
          
          [_ (#Tuple xs)]
          ($_ text\compose "[" (|> xs
                                   (list\map code\encode)
                                   (list\interposed " ")
-                                  list\reverse
+                                  list\reversed
                                   (list\fold text\compose "")) "]")
          
          [_ (#Record kvs)]
@@ -2702,7 +2724,7 @@
                                   (list\map (function' [kv] ({[k v] ($_ text\compose (code\encode k) " " (code\encode v))}
                                                              kv)))
                                   (list\interposed " ")
-                                  list\reverse
+                                  list\reversed
                                   (list\fold text\compose "")) "}")}
         code))
 
@@ -2735,7 +2757,7 @@
          (failure ($_ text\compose "'lux.case' expects an even number of tokens: " (|> branches
                                                                                        (list\map code\encode)
                                                                                        (list\interposed " ")
-                                                                                       list\reverse
+                                                                                       list\reversed
                                                                                        (list\fold text\compose ""))))}
         branches))
 
@@ -2832,7 +2854,7 @@
          (case tokens
            (^ (list [_ (#Tuple bindings)] body))
            (if (multiple? 2 (list\size bindings))
-             (|> bindings pairs list\reverse
+             (|> bindings pairs list\reversed
                  (list\fold (: (-> [Code Code] Code Code)
                                (function' [lr body']
                                           (let' [[l r] lr]
@@ -2874,7 +2896,7 @@
                                                  (` ([(~ g!name) (~ g!blank)]
                                                      (.case (~ g!blank) (~ arg) (~ body'))))))))]
              (in_meta (list (nest (..local_identifier$ g!name) head
-                                  (list\fold (nest g!blank) body (list\reverse tail))))))
+                                  (list\fold (nest g!blank) body (list\reversed tail))))))
 
            #None
            (failure "Wrong syntax for function")))
@@ -3261,7 +3283,7 @@
 (template [<name> <form> <message> <documentation>]
   [(macro: .public (<name> tokens)
      {#.doc <documentation>}
-     (case (list\reverse tokens)
+     (case (list\reversed tokens)
        (^ (list& last init))
        (in_meta (list (list\fold (: (-> Code Code Code)
                                     (function (_ pre post) (` <form>)))
@@ -3458,7 +3480,7 @@
     (let [{#info info #source    source  #current_module _ #modules modules
            #scopes scopes #type_context types    #host    host
            #seed seed #expected  expected #location  location #extensions extensions
-           #scope_type_vars scope_type_vars} state]
+           #scope_type_vars scope_type_vars #eval _eval} state]
       (case (plist\value name modules)
         (#Some module)
         (#Right state module)
@@ -3515,7 +3537,7 @@
     (let [{#info info #source    source  #current_module _ #modules modules
            #scopes scopes #type_context types    #host    host
            #seed seed #expected  expected #location  location #extensions extensions
-           #scope_type_vars scope_type_vars} state]
+           #scope_type_vars scope_type_vars #eval _eval} state]
       (case expected
         (#Some type)
         (#Right state type)
@@ -4032,9 +4054,9 @@
           jumps ("lux i64 -" 1 relatives)]
       (if (n/< (list\size parts) jumps)
         (let [prefix (|> parts
-                         list\reverse
+                         list\reversed
                          (list\after jumps)
-                         list\reverse
+                         list\reversed
                          (text\interposed ..module_separator))
               clean ("lux text clip" relatives (|> module "lux text size" ("lux i64 -" relatives)) module)
               output (case ("lux text size" clean)
@@ -4128,7 +4150,7 @@
                                    {#info info #source    source  #current_module current_module #modules modules
                                     #scopes scopes #type_context types    #host    host
                                     #seed seed #expected  expected #location  location #extensions extensions
-                                    #scope_type_vars scope_type_vars}
+                                    #scope_type_vars scope_type_vars #eval _eval}
                                    [current_module modules])]
     (case (plist\value module modules)
       (#Some =module)
@@ -4196,7 +4218,7 @@
     {#info info #source    source  #current_module _ #modules modules
      #scopes scopes #type_context types    #host    host
      #seed seed #expected  expected #location  location #extensions extensions
-     #scope_type_vars scope_type_vars}
+     #scope_type_vars scope_type_vars #eval _eval}
     (list\one (: (-> Scope (Maybe Type))
                  (function (_ env)
                    (case env
@@ -4219,7 +4241,7 @@
         {#info info #source    source  #current_module _ #modules modules
          #scopes scopes #type_context types    #host    host
          #seed seed #expected  expected #location  location #extensions extensions
-         #scope_type_vars scope_type_vars} state]
+         #scope_type_vars scope_type_vars #eval _eval} state]
     (case (plist\value v_module modules)
       #None
       #None
@@ -4243,7 +4265,7 @@
         {#info info #source    source #current_module _  #modules modules
          #scopes scopes #type_context types    #host    host
          #seed seed #expected  expected #location  location #extensions extensions
-         #scope_type_vars scope_type_vars} state]
+         #scope_type_vars scope_type_vars #eval _eval} state]
     (case (plist\value v_module modules)
       #None
       (#Left (text\compose "Unknown definition: " (name\encode name)))
@@ -4301,7 +4323,7 @@
           (let [{#info _ #source _ #current_module _ #modules _
                  #scopes _ #type_context type_context #host _
                  #seed _ #expected _ #location _ #extensions extensions
-                 #scope_type_vars _} compiler
+                 #scope_type_vars _ #eval _eval} compiler
                  {#ex_counter _ #var_counter _ #var_bindings var_bindings} type_context]
             (case (type_variable type_id var_bindings)
               #None
@@ -4337,16 +4359,16 @@
       name
 
       _
-      ($_ text\compose "(" name " " (|> params (list\map type\encode) (list\interposed " ") list\reverse (list\fold text\compose "")) ")"))
+      ($_ text\compose "(" name " " (|> params (list\map type\encode) (list\interposed " ") list\reversed (list\fold text\compose "")) ")"))
 
     (#Sum _)
-    ($_ text\compose "(Or " (|> (flat_variant type) (list\map type\encode) (list\interposed " ") list\reverse (list\fold text\compose "")) ")")
+    ($_ text\compose "(Or " (|> (flat_variant type) (list\map type\encode) (list\interposed " ") list\reversed (list\fold text\compose "")) ")")
     
     (#Product _)
-    ($_ text\compose "[" (|> (flat_tuple type) (list\map type\encode) (list\interposed " ") list\reverse (list\fold text\compose "")) "]")
+    ($_ text\compose "[" (|> (flat_tuple type) (list\map type\encode) (list\interposed " ") list\reversed (list\fold text\compose "")) "]")
 
     (#Function _)
-    ($_ text\compose "(-> " (|> (flat_lambda type) (list\map type\encode) (list\interposed " ") list\reverse (list\fold text\compose "")) ")")
+    ($_ text\compose "(-> " (|> (flat_lambda type) (list\map type\encode) (list\interposed " ") list\reversed (list\fold text\compose "")) ")")
 
     (#Parameter id)
     (nat\encode id)
@@ -4367,7 +4389,7 @@
     (let [[func args] (flat_application type)]
       ($_ text\compose
           "(" (type\encode func) " "
-          (|> args (list\map type\encode) (list\interposed " ") list\reverse (list\fold text\compose ""))
+          (|> args (list\map type\encode) (list\interposed " ") list\reversed (list\fold text\compose ""))
           ")"))
     
     (#Named name _)
@@ -4435,7 +4457,7 @@
                     "      ''???'')"))}
   (if ("lux i64 =" 0 (n/% 2 (list\size tokens)))
     (failure "cond requires an uneven number of arguments.")
-    (case (list\reverse tokens)
+    (case (list\reversed tokens)
       (^ (list& else branches'))
       (in_meta (list (list\fold (: (-> [Code Code] Code Code)
                                    (function (_ branch else)
@@ -4834,14 +4856,14 @@
                                          (function (_ [s b] v)
                                            (` (..with@ (~ s) (~ v) (~ b)))))
                                       value
-                                      (list\reverse pairs))
+                                      (list\reversed pairs))
                [_ accesses'] (list\fold (: (-> [Code Code] [Code (List (List Code))] [Code (List (List Code))])
                                            (function (_ [new_slot new_binding] [old_record accesses'])
                                              [(` (value@ (~ new_slot) (~ new_binding)))
                                               (#Item (list new_binding old_record) accesses')]))
                                         [record (: (List (List Code)) #End)]
                                         pairs)
-               accesses (list\joined (list\reverse accesses'))]]
+               accesses (list\joined (list\reversed accesses'))]]
         (in (list (` (let [(~+ accesses)]
                        (~ update_expr)))))))
     
@@ -5525,7 +5547,7 @@
                                                      (list)
                                                      (list g!_ (` #.None))))))))
                                       (` (#.Some (~ body)))
-                                      (: (List [Code Code]) (list\reverse levels)))]
+                                      (: (List [Code Code]) (list\reversed levels)))]
     (list init_pattern inner_pattern_body)))
 
 (macro: .public (^multi tokens)
@@ -5608,7 +5630,7 @@
     {#info info #source    source #current_module _   #modules modules
      #scopes scopes #type_context types    #host    host
      #seed seed #expected  expected #location  location #extensions extensions
-     #scope_type_vars scope_type_vars}
+     #scope_type_vars scope_type_vars #eval _eval}
     (#Right [state scope_type_vars])))
 
 (macro: .public (:parameter tokens)
@@ -5625,7 +5647,7 @@
     (^ (list [_ (#Nat idx)]))
     (do meta_monad
       [stvs ..scope_type_vars]
-      (case (..item idx (list\reverse stvs))
+      (case (..item idx (list\reversed stvs))
         (#Some var_id)
         (in (list (` (#Ex (~ (nat$ var_id))))))
 
@@ -5999,11 +6021,11 @@
   [(def: (<name> g!meta untemplated_pattern elems)
      (-> Code (-> Code (Meta Code))
          (-> (List Code) (Meta Code)))
-     (case (list\reverse elems)
+     (case (list\reversed elems)
        (#Item [_ (#Form (#Item [[_ (#Identifier ["" "~+"])] (#Item [spliced #End])]))]
               inits)
        (do meta_monad
-         [=inits (monad\map meta_monad untemplated_pattern (list\reverse inits))]
+         [=inits (monad\map meta_monad untemplated_pattern (list\reversed inits))]
          (in (` [(~ g!meta) (<tag> (~ (untemplated_list& spliced =inits)))])))
 
        _
diff --git a/stdlib/source/library/lux/control/parser/json.lux b/stdlib/source/library/lux/control/parser/json.lux
index 65569ff9e..cc954fc1b 100644
--- a/stdlib/source/library/lux/control/parser/json.lux
+++ b/stdlib/source/library/lux/control/parser/json.lux
@@ -23,7 +23,6 @@
   ["." // ("#\." functor)])
 
 (type: .public (Parser a)
-  {#.doc "A JSON parser."}
   (//.Parser (List JSON) a))
 
 (exception: .public (unconsumed_input {input (List JSON)})
@@ -33,8 +32,6 @@
 (exception: .public empty_input)
 
 (def: .public (result parser json)
-  {#.doc (example "Executes the parser against a JSON object."
-                  "Verifies that all of the JSON was consumed by the parser.")}
   (All [a] (-> (Parser a) JSON (Try a)))
   (case (//.result parser (list json))
     (#try.Success [remainder output])
@@ -49,7 +46,6 @@
     (#try.Failure error)))
 
 (def: .public any
-  {#.doc "Just returns the JSON input without applying any logic."}
   (Parser JSON)
   (<| (function (_ inputs))
       (case inputs
@@ -63,9 +59,8 @@
   (exception.report
    ["Value" (/.format value)]))
 
-(template [<name> <type> <tag> <desc>]
+(template [<name> <type> <tag>]
   [(def: .public <name>
-     {#.doc (code.text ($_ text\compose "Reads a JSON value as " <desc> "."))}
      (Parser <type>)
      (do //.monad
        [head ..any]
@@ -76,10 +71,10 @@
          _
          (//.failure (exception.error ..unexpected_value [head])))))]
 
-  [null    /.Null    #/.Null    "null"]
-  [boolean /.Boolean #/.Boolean "boolean"]
-  [number  /.Number  #/.Number  "number"]
-  [string  /.String  #/.String  "string"]
+  [null    /.Null    #/.Null]
+  [boolean /.Boolean #/.Boolean]
+  [number  /.Number  #/.Number]
+  [string  /.String  #/.String]
   )
 
 (exception: .public [a] (value_mismatch {reference JSON} {sample JSON})
@@ -120,13 +115,11 @@
   )
 
 (def: .public (nullable parser)
-  {#.doc (example "Enhances parser by adding NULL-handling.")}
   (All [a] (-> (Parser a) (Parser (Maybe a))))
   (//.or ..null
          parser))
 
 (def: .public (array parser)
-  {#.doc "Parses the contents of a JSON array."}
   (All [a] (-> (Parser a) (Parser a)))
   (do //.monad
     [head ..any]
@@ -148,8 +141,6 @@
       (//.failure (exception.error ..unexpected_value [head])))))
 
 (def: .public (object parser)
-  {#.doc (example "Parses the contents of a JSON object."
-                  "Use this with the 'field' combinator.")}
   (All [a] (-> (Parser a) (Parser a)))
   (do //.monad
     [head ..any]
@@ -176,8 +167,6 @@
       (//.failure (exception.error ..unexpected_value [head])))))
 
 (def: .public (field field_name parser)
-  {#.doc (example "Parses a field inside a JSON object."
-                  "Use this inside the 'object' combinator.")}
   (All [a] (-> Text (Parser a) (Parser a)))
   (function (recur inputs)
     (case inputs
@@ -204,7 +193,6 @@
       (exception.except ..unconsumed_input inputs))))
 
 (def: .public dictionary
-  {#.doc "Parses a dictionary-like JSON object."}
   (All [a] (-> (Parser a) (Parser (Dictionary Text a))))
   (|>> (//.and ..string)
        //.some
diff --git a/stdlib/source/library/lux/control/parser/synthesis.lux b/stdlib/source/library/lux/control/parser/synthesis.lux
index dadf00655..b336a0d58 100644
--- a/stdlib/source/library/lux/control/parser/synthesis.lux
+++ b/stdlib/source/library/lux/control/parser/synthesis.lux
@@ -49,12 +49,9 @@
 (exception: .public empty_input)
 
 (type: .public Parser
-  {#.doc (example "A parser for the Lux compiler's synthesis nodes using during optimization.")}
   (//.Parser (List Synthesis)))
 
 (def: .public (result parser input)
-  {#.doc (example "Executes the parser against the inputs."
-                  "Ensures all inputs are consumed by the parser.")}
   (All [a] (-> (Parser a) (List Synthesis) (Try a)))
   (case (parser input)
     (#try.Failure error)
@@ -67,7 +64,6 @@
     (exception.except ..unconsumed_input unconsumed)))
 
 (def: .public any
-  {#.doc (example "Yields a synthesis node without subjecting it to any analysis.")}
   (Parser Synthesis)
   (.function (_ input)
     (case input
@@ -78,7 +74,6 @@
       (#try.Success [tail head]))))
 
 (def: .public end!
-  {#.doc "Ensures there are no more inputs."}
   (Parser Any)
   (.function (_ tokens)
     (case tokens
@@ -86,7 +81,6 @@
       _     (exception.except ..expected_empty_input [tokens]))))
 
 (def: .public end?
-  {#.doc "Checks whether there are no more inputs."}
   (Parser Bit)
   (.function (_ tokens)
     (#try.Success [tokens (case tokens
@@ -128,7 +122,6 @@
   )
 
 (def: .public (tuple parser)
-  {#.doc (example "Parses the contents of a tuple.")}
   (All [a] (-> (Parser a) (Parser a)))
   (.function (_ input)
     (case input
@@ -141,7 +134,6 @@
       (exception.except ..cannot_parse input))))
 
 (def: .public (function expected parser)
-  {#.doc (example "Parses the body of a function with the 'expected' arity.")}
   (All [a] (-> Arity (Parser a) (Parser [(Environment Synthesis) a])))
   (.function (_ input)
     (case input
@@ -156,7 +148,6 @@
       (exception.except ..cannot_parse input))))
 
 (def: .public (loop init_parsers iteration_parser)
-  {#.doc (example "Parses the initial values and the body of a loop.")}
   (All [a b] (-> (Parser a) (Parser b) (Parser [Register a b])))
   (.function (_ input)
     (case input
diff --git a/stdlib/source/library/lux/control/parser/text.lux b/stdlib/source/library/lux/control/parser/text.lux
index 46ed6e987..b95df4bfd 100644
--- a/stdlib/source/library/lux/control/parser/text.lux
+++ b/stdlib/source/library/lux/control/parser/text.lux
@@ -21,7 +21,6 @@
   ["." //])
 
 (type: .public Offset
-  {#.doc (example "An offset into a block of text.")}
   Nat)
 
 (def: start_offset
@@ -29,11 +28,9 @@
   0)
 
 (type: .public Parser
-  {#.doc (example "A parser for text.")}
   (//.Parser [Offset Text]))
 
 (type: .public Slice
-  {#.doc (example "A slice of a block of text.")}
   {#basis Offset
    #distance Offset})
 
@@ -56,8 +53,6 @@
 (exception: .public cannot_slice)
 
 (def: .public (result parser input)
-  {#.doc (example "Executes a parser against a block of text."
-                  "Verifies that the entire input has been processed.")}
   (All [a] (-> (Parser a) Text (Try a)))
   (case (parser [start_offset input])
     (#try.Failure msg)
@@ -69,7 +64,6 @@
       (exception.except ..unconsumed_input [end_offset input]))))
 
 (def: .public offset
-  {#.doc (example "Yields the current offset into the input.")}
   (Parser Offset)
   (function (_ (^@ input [offset tape]))
     (#try.Success [input offset])))
@@ -87,7 +81,6 @@
                    slices))))
 
 (def: .public any
-  {#.doc "Yields the next character without applying any logic."}
   (Parser Text)
   (function (_ [offset tape])
     (case (/.char offset tape)
@@ -98,7 +91,6 @@
       (exception.except ..cannot_parse []))))
 
 (def: .public any!
-  {#.doc "Yields the next character (as a slice) without applying any logic."}
   (Parser Slice)
   (function (_ [offset tape])
     (case (/.char offset tape)
@@ -110,9 +102,8 @@
       _
       (exception.except ..cannot_slice []))))
 
-(template [<name> <type> <any> <caveat>]
+(template [<name> <type> <any>]
   [(`` (def: .public (<name> parser)
-         {#.doc (example (~~ (template.text ["Produce a character" <caveat> " if the parser fails."])))}
          (All [a] (-> (Parser a) (Parser <type>)))
          (function (_ input)
            (case (parser input)
@@ -122,8 +113,8 @@
              _
              (exception.except ..expected_to_fail input)))))]
 
-  [not  Text  ..any ""]
-  [not! Slice ..any! " (as a slice)"]
+  [not  Text  ..any]
+  [not! Slice ..any!]
   )
 
 (exception: .public (cannot_match {reference Text})
@@ -131,7 +122,6 @@
    ["Reference" (/.format reference)]))
 
 (def: .public (this reference)
-  {#.doc (example "Checks that a specific text shows up in the input.")}
   (-> Text (Parser Any))
   (function (_ [offset tape])
     (case (/.index_of' offset reference tape)
@@ -145,7 +135,6 @@
       (exception.except ..cannot_match [reference]))))
 
 (def: .public end!
-  {#.doc "Ensure the parser's input is empty."}
   (Parser Any)
   (function (_ (^@ input [offset tape]))
     (if (n.= offset (/.size tape))
@@ -153,7 +142,6 @@
       (exception.except ..unconsumed_input input))))
 
 (def: .public next
-  {#.doc "Yields the next character (without consuming it from the input)."}
   (Parser Text)
   (function (_ (^@ input [offset tape]))
     (case (/.char offset tape)
@@ -164,13 +152,11 @@
       (exception.except ..cannot_parse []))))
 
 (def: .public remaining
-  {#.doc "Get all of the remaining input (without consuming it)."}
   (Parser Text)
   (function (_ (^@ input [offset tape]))
     (#try.Success [input (remaining' offset tape)])))
 
 (def: .public (range bottom top)
-  {#.doc "Only yields characters within a range."}
   (-> Nat Nat (Parser Text))
   (do //.monad
     [char any
@@ -182,7 +168,6 @@
 
 (template [<name> <bottom> <top> <desc>]
   [(def: .public <name>
-     {#.doc (code.text ($_ /\compose "Only yields " <desc> " characters."))}
      (Parser Text)
      (..range (char <bottom>) (char <top>)))]
 
@@ -193,17 +178,14 @@
   )
 
 (def: .public alpha
-  {#.doc "Yields alphabetic characters."}
   (Parser Text)
   (//.either lower upper))
 
 (def: .public alpha_num
-  {#.doc "Yields alphanumeric characters."}
   (Parser Text)
   (//.either alpha decimal))
 
 (def: .public hexadecimal
-  {#.doc "Yields hexadecimal digits."}
   (Parser Text)
   ($_ //.either
       decimal
@@ -265,7 +247,6 @@
    ["Character" (/.format (/.of_char character))]))
 
 (def: .public (satisfies parser)
-  {#.doc "Yields characters that satisfy a predicate."}
   (-> (-> Char Bit) (Parser Text))
   (function (_ [offset tape])
     (case (/.char offset tape)
@@ -278,12 +259,10 @@
       (exception.except ..cannot_parse []))))
 
 (def: .public space
-  {#.doc "Yields white-space."}
   (Parser Text)
   (..satisfies /.space?))
 
 (def: .public (and left right)
-  {#.doc (example "Yields the outputs of both parsers composed together.")}
   (-> (Parser Text) (Parser Text) (Parser Text))
   (do //.monad
     [=left left
@@ -291,7 +270,6 @@
     (in ($_ /\compose =left =right))))
 
 (def: .public (and! left right)
-  {#.doc (example "Yields the outputs of both parsers composed together (as a slice).")}
   (-> (Parser Slice) (Parser Slice) (Parser Slice))
   (do //.monad
     [[left::basis left::distance] left
@@ -300,7 +278,6 @@
 
 (template [<name> <base> <doc_modifier>]
   [(def: .public (<name> parser)
-     {#.doc (code.text ($_ /\compose "Yields " <doc_modifier> " characters as a single continuous text (as a slice)."))}
      (-> (Parser Text) (Parser Text))
      (|> parser <base> (\ //.monad map /.together)))]
 
@@ -310,7 +287,6 @@
 
 (template [<name> <base> <doc_modifier>]
   [(def: .public (<name> parser)
-     {#.doc (code.text ($_ /\compose "Yields " <doc_modifier> " characters as a single continuous text (as a slice)."))}
      (-> (Parser Slice) (Parser Slice))
      (with_slices (<base> parser)))]
 
@@ -320,7 +296,6 @@
 
 (template [<name> <base> <doc_modifier>]
   [(def: .public (<name> amount parser)
-     {#.doc (code.text ($_ /\compose "Yields " <doc_modifier> " N characters (as a slice)."))}
      (-> Nat (Parser Text) (Parser Text))
      (|> parser
          (<base> amount)
@@ -333,7 +308,6 @@
 
 (template [<name> <base> <doc_modifier>]
   [(def: .public (<name> amount parser)
-     {#.doc (code.text ($_ /\compose "Yields " <doc_modifier> " N characters (as a slice)."))}
      (-> Nat (Parser Slice) (Parser Slice))
      (with_slices
        (<base> amount parser)))]
@@ -361,7 +335,6 @@
       (//.after (this start))))
 
 (def: .public (local local_input parser)
-  {#.doc "Applies a parser against the given input."}
   (All [a] (-> Text (Parser a) (Parser a)))
   (function (_ real_input)
     (case (..result parser local_input)
@@ -372,7 +345,6 @@
       (#try.Success [real_input value]))))
 
 (def: .public (slice parser)
-  {#.doc (example "Converts a slice to a block of text.")}
   (-> (Parser Slice) (Parser Text))
   (do //.monad
     [[basis distance] parser]
@@ -385,7 +357,6 @@
         (exception.except ..cannot_slice [])))))
 
 (def: .public (then structured text)
-  {#.doc (example "Embeds a text parser into an arbitrary parser that yields text.")}
   (All [s a]
     (-> (Parser a)
         (//.Parser s Text)
diff --git a/stdlib/source/library/lux/control/parser/tree.lux b/stdlib/source/library/lux/control/parser/tree.lux
index cba23cf82..1f7a54a1a 100644
--- a/stdlib/source/library/lux/control/parser/tree.lux
+++ b/stdlib/source/library/lux/control/parser/tree.lux
@@ -13,23 +13,19 @@
   ["." //])
 
 (type: .public (Parser t a)
-  {#.doc (example "A parser of arbitrary trees.")}
   (//.Parser (Zipper t) a))
 
 (def: .public (result' parser zipper)
-  {#.doc (example "Applies the parser against a tree zipper.")}
   (All [t a] (-> (Parser t a) (Zipper t) (Try a)))
   (do try.monad
     [[zipper output] (//.result parser zipper)]
     (in output)))
 
 (def: .public (result parser tree)
-  {#.doc (example "Applies the parser against a tree.")}
   (All [t a] (-> (Parser t a) (Tree t) (Try a)))
   (result' parser (zipper.zipper tree)))
 
 (def: .public value
-  {#.doc (example "Yields the value inside the current tree node.")}
   (All [t] (Parser t t))
   (function (_ zipper)
     (#try.Success [zipper (zipper.value zipper)])))
diff --git a/stdlib/source/library/lux/control/parser/type.lux b/stdlib/source/library/lux/control/parser/type.lux
index e6ea2b3dd..029d130fd 100644
--- a/stdlib/source/library/lux/control/parser/type.lux
+++ b/stdlib/source/library/lux/control/parser/type.lux
@@ -1,6 +1,4 @@
 (.module:
-  {#.doc (.example "Parsing of Lux types."
-                   "Used mostly for polytypic programming.")}
   [library
    [lux (#- function local)
     [abstract
@@ -61,15 +59,12 @@
                 (text.interposed ""))]))
 
 (type: .public Env
-  {#.doc (example "An environment for type parsing.")}
   (Dictionary Nat [Type Code]))
 
 (type: .public (Parser a)
-  {#.doc (example "A parser of Lux types.")}
   (//.Parser [Env (List Type)] a))
 
 (def: .public fresh
-  {#.doc (example "An empty parsing environment.")}
   Env
   (dictionary.empty n.hash))
 
@@ -88,13 +83,10 @@
       (exception.except ..unconsumed_input remaining))))
 
 (def: .public (result poly type)
-  {#.doc (example "Applies a parser against a type."
-                  "Verifies that the parser fully consumes the type's information.")}
   (All [a] (-> (Parser a) Type (Try a)))
   (result' ..fresh poly (list type)))
 
 (def: .public env
-  {#.doc (example "Yields the current parsing environment.")}
   (Parser Env)
   (.function (_ [env inputs])
     (#try.Success [[env inputs] env])))
@@ -110,7 +102,6 @@
       (#try.Success [[env remaining] output]))))
 
 (def: .public next
-  {#.doc (example "Inspect a type in the input stream without consuming it.")}
   (Parser Type)
   (.function (_ [env inputs])
     (case inputs
@@ -121,7 +112,6 @@
       (#try.Success [[env inputs] headT]))))
 
 (def: .public any
-  {#.doc (example "Yields a type, without examination.")}
   (Parser Type)
   (.function (_ [env inputs])
     (case inputs
@@ -132,7 +122,6 @@
       (#try.Success [[env tail] headT]))))
 
 (def: .public (local types poly)
-  {#.doc (example "Apply a parser to the given inputs.")}
   (All [a] (-> (List Type) (Parser a) (Parser a)))
   (.function (_ [env pass_through])
     (case (result' env poly types)
@@ -222,7 +211,6 @@
           (in [funcL all_varsL output])))))
 
 (def: .public (function in_poly out_poly)
-  {#.doc (example "Parses a function's inputs and output.")}
   (All [i o] (-> (Parser i) (Parser o) (Parser [i o])))
   (do //.monad
     [headT any
@@ -233,7 +221,6 @@
       (//.failure (exception.error ..not_function headT)))))
 
 (def: .public (applied poly)
-  {#.doc (example "Parses a type application.")}
   (All [a] (-> (Parser a) (Parser a)))
   (do //.monad
     [headT any
@@ -242,9 +229,8 @@
       (//.failure (exception.error ..not_application headT))
       (..local (#.Item funcT paramsT) poly))))
 
-(template [<name> <test> <doc>]
+(template [<name> <test>]
   [(def: .public (<name> expected)
-     {#.doc (example <doc>)}
      (-> Type (Parser Any))
      (do //.monad
        [actual any]
@@ -252,12 +238,9 @@
          (in [])
          (//.failure (exception.error ..types_do_not_match [expected actual])))))]
 
-  [exactly type\=
-   "Parses a type exactly."]
-  [sub     check.subsumes?
-   "Parses a sub type."]
-  [super   (function.flipped check.subsumes?)
-   "Parses a super type."]
+  [exactly type\=]
+  [sub     check.subsumes?]
+  [super   (function.flipped check.subsumes?)]
   )
 
 (def: .public (adjusted_idx env idx)
@@ -299,7 +282,6 @@
       (//.failure (exception.error ..not_parameter headT)))))
 
 (def: .public existential
-  {#.doc (example "Yields an existential type.")}
   (Parser Nat)
   (do //.monad
     [headT any]
@@ -311,7 +293,6 @@
       (//.failure (exception.error ..not_existential headT)))))
 
 (def: .public named
-  {#.doc (example "Yields a named type.")}
   (Parser [Name Type])
   (do //.monad
     [inputT any]
diff --git a/stdlib/source/library/lux/control/parser/xml.lux b/stdlib/source/library/lux/control/parser/xml.lux
index 5785ecba8..2b0332544 100644
--- a/stdlib/source/library/lux/control/parser/xml.lux
+++ b/stdlib/source/library/lux/control/parser/xml.lux
@@ -18,7 +18,6 @@
   ["." //])
 
 (type: .public (Parser a)
-  {#.doc (example "A parser of XML-encoded data.")}
   (//.Parser [Attrs (List XML)] a))
 
 (exception: .public empty_input)
@@ -50,13 +49,10 @@
     (#try.Failure error)))
 
 (def: .public (result parser documents)
-  {#.doc (example "Applies a parser against a stream of XML documents."
-                  "Verifies that all of the inputs are consumed by the parser.")}
   (All [a] (-> (Parser a) (List XML) (Try a)))
   (..result' parser /.attributes documents))
 
 (def: .public text
-  {#.doc (example "Yields text from a text node.")}
   (Parser Text)
   (function (_ [attrs documents])
     (case documents
@@ -72,7 +68,6 @@
         (exception.except ..unexpected_input [])))))
 
 (def: .public tag
-  {#.doc (example "Yields the tag from the next node.")}
   (Parser Tag)
   (function (_ [attrs documents])
     (case documents
@@ -88,7 +83,6 @@
         (#try.Success [[attrs documents] tag])))))
 
 (def: .public (attribute name)
-  {#.doc (example "Yields the value of an attribute in the current node.")}
   (-> Attribute (Parser Text))
   (function (_ [attrs documents])
     (case (dictionary.value name attrs)
@@ -99,7 +93,6 @@
       (#try.Success [[attrs documents] value]))))
 
 (def: .public (node expected parser)
-  {#.doc (example "Parses the contents of the next node if the tag matches.")}
   (All [a] (-> Tag (Parser a) (Parser a)))
   (function (_ [attrs documents])
     (case documents
@@ -119,7 +112,6 @@
           (exception.except ..wrong_tag [expected actual]))))))
 
 (def: .public any
-  {#.doc (example "Yields the next node.")}
   (Parser XML)
   (function (_ [attrs documents])
     (case documents
@@ -132,7 +124,6 @@
 (exception: .public nowhere)
 
 (def: .public (somewhere parser)
-  {#.doc (example "Applies the parser somewhere among the remaining inputs; instead of demanding that the parser succeeds against the immediate inputs.")}
   (All [a] (-> (Parser a) (Parser a)))
   (function (recur [attrs input])
     (case (//.result parser [attrs input])
diff --git a/stdlib/source/library/lux/data/binary.lux b/stdlib/source/library/lux/data/binary.lux
index 13b9b5a9d..6028c1a68 100644
--- a/stdlib/source/library/lux/data/binary.lux
+++ b/stdlib/source/library/lux/data/binary.lux
@@ -33,9 +33,7 @@
    ["Offset" (%.nat offset)]
    ["Length" (%.nat length)]))
 
-(with_expansions [<documentation> (as_is {#.doc (example "A binary BLOB of data.")})
-                  <jvm> (as_is (type: .public Binary
-                                 <documentation>
+(with_expansions [<jvm> (as_is (type: .public Binary
                                  (ffi.type [byte]))
 
                                (ffi.import: java/lang/Object)
@@ -78,17 +76,14 @@
                   (length ffi.Number)])
                
                (type: .public Binary
-                 <documentation>
                  Uint8Array))
 
         @.python
         (type: .public Binary
-          <documentation>
           (primitive "bytearray"))
 
         @.scheme
         (as_is (type: .public Binary
-                 <documentation>
                  (primitive "bytevector"))
                
                (ffi.import: (make-bytevector [Nat] Binary))
@@ -98,7 +93,6 @@
 
        ... Default
        (type: .public Binary
-         <documentation>
          (array.Array (I64 Any)))))
 
 (template: (!size binary)
@@ -171,7 +165,6 @@
   (|>> !size))
 
 (def: .public (empty size)
-  {#.doc (example "A fresh/empty binary BLOB of the specified size.")}
   (-> Nat Binary)
   (for {@.old (ffi.array byte size)
         @.jvm (ffi.array byte size)
@@ -200,14 +193,12 @@
         output))))
 
 (def: .public (read/8! index binary)
-  {#.doc (example "Read 1 byte (8 bits) at the given index.")}
   (-> Nat Binary (Try I64))
   (if (n.< (..!size binary) index)
     (#try.Success (!read index binary))
     (exception.except ..index_out_of_bounds [(..!size binary) index])))
 
 (def: .public (read/16! index binary)
-  {#.doc (example "Read 2 bytes (16 bits) at the given index.")}
   (-> Nat Binary (Try I64))
   (if (n.< (..!size binary) (n.+ 1 index))
     (#try.Success ($_ i64.or
@@ -216,7 +207,6 @@
     (exception.except ..index_out_of_bounds [(..!size binary) index])))
 
 (def: .public (read/32! index binary)
-  {#.doc (example "Read 4 bytes (32 bits) at the given index.")}
   (-> Nat Binary (Try I64))
   (if (n.< (..!size binary) (n.+ 3 index))
     (#try.Success ($_ i64.or
@@ -227,7 +217,6 @@
     (exception.except ..index_out_of_bounds [(..!size binary) index])))
 
 (def: .public (read/64! index binary)
-  {#.doc (example "Read 8 bytes (64 bits) at the given index.")}
   (-> Nat Binary (Try I64))
   (if (n.< (..!size binary) (n.+ 7 index))
     (#try.Success ($_ i64.or
@@ -242,7 +231,6 @@
     (exception.except ..index_out_of_bounds [(..!size binary) index])))
 
 (def: .public (write/8! index value binary)
-  {#.doc (example "Write 1 byte (8 bits) at the given index.")}
   (-> Nat (I64 Any) Binary (Try Binary))
   (if (n.< (..!size binary) index)
     (#try.Success (|> binary
@@ -250,7 +238,6 @@
     (exception.except ..index_out_of_bounds [(..!size binary) index])))
 
 (def: .public (write/16! index value binary)
-  {#.doc (example "Write 2 bytes (16 bits) at the given index.")}
   (-> Nat (I64 Any) Binary (Try Binary))
   (if (n.< (..!size binary) (n.+ 1 index))
     (#try.Success (|> binary
@@ -259,7 +246,6 @@
     (exception.except ..index_out_of_bounds [(..!size binary) index])))
 
 (def: .public (write/32! index value binary)
-  {#.doc (example "Write 4 bytes (32 bits) at the given index.")}
   (-> Nat (I64 Any) Binary (Try Binary))
   (if (n.< (..!size binary) (n.+ 3 index))
     (#try.Success (|> binary
@@ -270,7 +256,6 @@
     (exception.except ..index_out_of_bounds [(..!size binary) index])))
 
 (def: .public (write/64! index value binary)
-  {#.doc (example "Write 8 bytes (64 bits) at the given index.")}
   (-> Nat (I64 Any) Binary (Try Binary))
   (if (n.< (..!size binary) (n.+ 7 index))
     (for {@.scheme (let [write_high (|>> (!write index (i64.right_shifted 56 value))
@@ -323,7 +308,6 @@
         ["Target output space" (%.nat target_output)])))
 
 (def: .public (copy bytes source_offset source target_offset target)
-  {#.doc (example "Mutates the target binary BLOB by copying bytes from the source BLOB to it.")}
   (-> Nat Nat Binary Nat Binary (Try Binary))
   (with_expansions [<jvm> (as_is (do try.monad
                                    [_ (java/lang/System::arraycopy source (.int source_offset) target (.int target_offset) (.int bytes))]
@@ -345,7 +329,6 @@
                  (#try.Success target))))))))
 
 (def: .public (slice offset length binary)
-  {#.doc (example "Yields a subset of the binary BLOB, so long as the specified range is valid.")}
   (-> Nat Nat Binary (Try Binary))
   (let [size (..!size binary)
         limit (n.+ length offset)]
@@ -359,7 +342,6 @@
              (..copy length offset binary 0 (..empty length)))))))
 
 (def: .public (after bytes binary)
-  {#.doc (example "Yields a binary BLOB with at most the specified number of bytes removed.")}
   (-> Nat Binary Binary)
   (case bytes
     0 binary
diff --git a/stdlib/source/library/lux/data/bit.lux b/stdlib/source/library/lux/data/bit.lux
index efdca1f5b..6d7b7c9c3 100644
--- a/stdlib/source/library/lux/data/bit.lux
+++ b/stdlib/source/library/lux/data/bit.lux
@@ -61,7 +61,5 @@
       _    (#.Left "Wrong syntax for Bit."))))
 
 (def: .public complement
-  {#.doc (example "Generates the complement of a predicate."
-                  "That is a predicate that returns the oposite of the original predicate.")}
   (All [a] (-> (-> a Bit) (-> a Bit)))
   (function.composite not))
diff --git a/stdlib/source/library/lux/data/collection/array.lux b/stdlib/source/library/lux/data/collection/array.lux
index ae6aa7b96..c7fe53e3f 100644
--- a/stdlib/source/library/lux/data/collection/array.lux
+++ b/stdlib/source/library/lux/data/collection/array.lux
@@ -22,7 +22,6 @@
   "#Array")
 
 (type: .public (Array a)
-  {#.doc "Mutable arrays."}
   (#.Primitive ..type_name (#.Item a #.End)))
 
 (with_expansions [<index_type> (primitive "java.lang.Long")
@@ -37,7 +36,6 @@
        (as_is))
   
   (def: .public (empty size)
-    {#.doc (.example "An empty array of the specified size.")}
     (All [a] (-> Nat (Array a)))
     (for {@.old
           (:expected ("jvm anewarray" "(java.lang.Object )" size))
@@ -110,7 +108,6 @@
       #.None))
 
   (def: .public (write! index value array)
-    {#.doc (.example "Mutate the array by writing a value to the specified index.")}
     (All [a]
       (-> Nat a (Array a) (Array a)))
     (for {@.old
@@ -130,7 +127,6 @@
           @.scheme ("scheme array write" index value array)}))
 
   (def: .public (delete! index array)
-    {#.doc (.example "Mutate the array by deleting the value at the specified index.")}
     (All [a]
       (-> Nat (Array a) (Array a)))
     (if (n.< (size array) index)
@@ -160,7 +156,6 @@
     false))
 
 (def: .public (update! index transform array)
-  {#.doc (.example "Mutate the array by updating the value at the specified index.")}
   (All [a]
     (-> Nat (-> a a) (Array a) (Array a)))
   (case (read! index array)
@@ -171,8 +166,6 @@
     (write! index (transform value) array)))
 
 (def: .public (upsert! index default transform array)
-  {#.doc (.example "Mutate the array by updating the value at the specified index."
-                   "If there is no value, update and write the default value given.")}
   (All [a]
     (-> Nat a (-> a a) (Array a) (Array a)))
   (write! index
@@ -180,7 +173,6 @@
           array))
 
 (def: .public (copy! length src_start src_array dest_start dest_array)
-  {#.doc (.example "Writes the contents of one array into the other.")}
   (All [a]
     (-> Nat Nat (Array a) Nat (Array a)
         (Array a)))
@@ -197,7 +189,6 @@
                (list.indices length))))
 
 (def: .public (occupancy array)
-  {#.doc "Finds out how many cells in an array are occupied."}
   (All [a] (-> (Array a) Nat))
   (list\fold (function (_ idx count)
                (case (read! idx array)
@@ -210,12 +201,10 @@
              (list.indices (size array))))
 
 (def: .public (vacancy array)
-  {#.doc "Finds out how many cells in an array are vacant."}
   (All [a] (-> (Array a) Nat))
   (n.- (..occupancy array) (..size array)))
 
 (def: .public (filter! p xs)
-  {#.doc (.example "Delete every item of the array that fails to satisfy the predicate.")}
   (All [a]
     (-> (Predicate a) (Array a) (Array a)))
   (list\fold (function (_ idx xs')
@@ -231,7 +220,6 @@
              (list.indices (size xs))))
 
 (def: .public (example p xs)
-  {#.doc (.example "Yields the first item in the array that satisfies the predicate.")}
   (All [a]
     (-> (Predicate a) (Array a) (Maybe a)))
   (let [arr_size (size xs)]
@@ -248,7 +236,6 @@
         #.None))))
 
 (def: .public (example+ p xs)
-  {#.doc "Just like 'example', but with access to the index of each value."}
   (All [a]
     (-> (-> Nat a Bit) (Array a) (Maybe [Nat a])))
   (let [arr_size (size xs)]
@@ -265,7 +252,6 @@
         #.None))))
 
 (def: .public (clone xs)
-  {#.doc (.example "Yields a shallow clone of the array.")}
   (All [a] (-> (Array a) (Array a)))
   (let [arr_size (size xs)]
     (list\fold (function (_ idx ys)
@@ -290,7 +276,6 @@
   (-- 0))
 
 (def: .public (list array)
-  {#.doc (.example "Yields a list with every non-empty item in the array.")}
   (All [a] (-> (Array a) (List a)))
   (loop [idx (-- (size array))
          output #.End]
@@ -308,7 +293,6 @@
                output)))))
 
 (def: .public (list' default array)
-  {#.doc (.example "Like 'list', but uses the 'default' value when encountering an empty cell in the array.")}
   (All [a] (-> a (Array a) (List a)))
   (loop [idx (-- (size array))
          output #.End]
diff --git a/stdlib/source/library/lux/data/collection/bits.lux b/stdlib/source/library/lux/data/collection/bits.lux
index b5059ea8a..6c375247c 100644
--- a/stdlib/source/library/lux/data/collection/bits.lux
+++ b/stdlib/source/library/lux/data/collection/bits.lux
@@ -21,7 +21,6 @@
   i64.width)
 
 (type: .public Bits
-  {#.doc (example "A bit-map.")}
   (Array Chunk))
 
 (def: empty_chunk
@@ -33,7 +32,6 @@
   (array.empty 0))
 
 (def: .public (size bits)
-  {#.doc (example "Measures the size of a bit-map by counting all the 1s in the bit-map.")}
   (-> Bits Nat)
   (array\fold (function (_ chunk total)
                 (|> chunk i64.ones (n.+ total)))
diff --git a/stdlib/source/library/lux/data/collection/dictionary.lux b/stdlib/source/library/lux/data/collection/dictionary.lux
index 6773a3b95..faab0f7b2 100644
--- a/stdlib/source/library/lux/data/collection/dictionary.lux
+++ b/stdlib/source/library/lux/data/collection/dictionary.lux
@@ -556,7 +556,6 @@
                 colls)))
 
 (type: .public (Dictionary k v)
-  {#.doc "A dictionary implemented as a Hash-Array Mapped Trie (HAMT)."}
   {#hash (Hash k)
    #root (Node k v)})
 
@@ -565,7 +564,6 @@
   (value@ #..hash))
 
 (def: .public (empty key_hash)
-  {#.doc (example "An empty dictionary.")}
   (All [k v] (-> (Hash k) (Dictionary k v)))
   {#hash key_hash
    #root empty_node})
@@ -594,14 +592,12 @@
 (exception: .public key_already_exists)
 
 (def: .public (has' key val dict)
-  {#.doc "Only puts the KV-pair if the key is not already present."}
   (All [k v] (-> k v (Dictionary k v) (Try (Dictionary k v))))
   (case (value key dict)
     #.None     (#try.Success (has key val dict))
     (#.Some _) (exception.except ..key_already_exists [])))
 
 (def: .public (revised key f dict)
-  {#.doc "Transforms the value located at key (if available), using the given function."}
   (All [k v] (-> k (-> v v) (Dictionary k v) (Dictionary k v)))
   (case (value key dict)
     #.None
@@ -611,8 +607,6 @@
     (has key (f val) dict)))
 
 (def: .public (revised' key default f dict)
-  {#.doc (example "Updates the value at the key; if it exists."
-                  "Otherwise, puts a value by applying the function to a default.")}
   (All [k v] (-> k v (-> v v) (Dictionary k v) (Dictionary k v)))
   (..has key
          (f (maybe.else default
@@ -651,16 +645,12 @@
   )
 
 (def: .public (merged dict2 dict1)
-  {#.doc (example "Merges 2 dictionaries."
-                  "If any collisions with keys occur, the values of dict2 will overwrite those of dict1.")}
   (All [k v] (-> (Dictionary k v) (Dictionary k v) (Dictionary k v)))
   (list\fold (function (_ [key val] dict) (has key val dict))
              dict1
              (entries dict2)))
 
 (def: .public (merged_with f dict2 dict1)
-  {#.doc (example "Merges 2 dictionaries."
-                  "If any collisions with keys occur, a new value will be computed by applying 'f' to the values of dict2 and dict1.")}
   (All [k v] (-> (-> v v v) (Dictionary k v) (Dictionary k v) (Dictionary k v)))
   (list\fold (function (_ [key val2] dict)
                (case (value key dict)
@@ -673,7 +663,6 @@
              (entries dict2)))
 
 (def: .public (re_bound from_key to_key dict)
-  {#.doc (example "If there is a value under 'from_key', remove 'from_key' and store the value under 'to_key'.")}
   (All [k v] (-> k k (Dictionary k v) (Dictionary k v)))
   (case (value from_key dict)
     #.None
@@ -685,7 +674,6 @@
         (has to_key val))))
 
 (def: .public (sub keys dict)
-  {#.doc "A sub-dictionary, with only the specified keys."}
   (All [k v] (-> (List k) (Dictionary k v) (Dictionary k v)))
   (let [[key_hash _] dict]
     (list\fold (function (_ key new_dict)
diff --git a/stdlib/source/library/lux/data/collection/dictionary/ordered.lux b/stdlib/source/library/lux/data/collection/dictionary/ordered.lux
index 567c1f457..f19843db9 100644
--- a/stdlib/source/library/lux/data/collection/dictionary/ordered.lux
+++ b/stdlib/source/library/lux/data/collection/dictionary/ordered.lux
@@ -46,12 +46,10 @@
   )
 
 (type: .public (Dictionary k v)
-  {#.doc (example "A dictionary data-structure with ordered entries.")}
   {#&order (Order k)
    #root (Maybe (Node k v))})
 
 (def: .public (empty order)
-  {#.doc (example "An empty dictionary, employing the given order.")}
   (All [k v] (-> (Order k) (Dictionary k v)))
   {#&order order
    #root #.None})
diff --git a/stdlib/source/library/lux/data/collection/dictionary/plist.lux b/stdlib/source/library/lux/data/collection/dictionary/plist.lux
index c56994d6c..e98a2c51b 100644
--- a/stdlib/source/library/lux/data/collection/dictionary/plist.lux
+++ b/stdlib/source/library/lux/data/collection/dictionary/plist.lux
@@ -14,8 +14,6 @@
 
 ... https://en.wikipedia.org/wiki/Property_list
 (type: .public (PList a)
-  {#.doc (example "A property list."
-                  "It's a simple dictionary-like structure with Text keys.")}
   (List [Text a]))
 
 (def: .public empty
diff --git a/stdlib/source/library/lux/data/collection/list.lux b/stdlib/source/library/lux/data/collection/list.lux
index cb52d478d..a4bb340e7 100644
--- a/stdlib/source/library/lux/data/collection/list.lux
+++ b/stdlib/source/library/lux/data/collection/list.lux
@@ -51,7 +51,6 @@
         xs))
 
 (def: .public (only keep? xs)
-  {#.doc (.example "A list with only values that satisfy the predicate.")}
   (All [a]
     (-> (Predicate a) (List a) (List a)))
   (case xs
@@ -64,7 +63,6 @@
       (only keep? xs'))))
 
 (def: .public (partition satisfies? list)
-  {#.doc "Divide the list into all elements that satisfy a predicate, and all elements that do not."}
   (All [a] (-> (Predicate a) (List a) [(List a) (List a)]))
   (case list
     #.End
@@ -77,8 +75,6 @@
         [in (#.Item head out)]))))
 
 (def: .public (pairs xs)
-  {#.doc (.example "Cut the list into pairs of 2."
-                   "Caveat emptor: If the list has an un-even number of elements, the last one will be skipped.")}
   (All [a] (-> (List a) (List [a a])))
   (case xs
     (^ (list& x1 x2 xs'))
@@ -147,14 +143,12 @@
       (split_when' predicate (#.Item x ys) xs'))))
 
 (def: .public (split_when predicate xs)
-  {#.doc "Segment the list by using a predicate to tell when to cut."}
   (All [a]
     (-> (Predicate a) (List a) [(List a) (List a)]))
   (let [[ys' xs'] (split_when' predicate #.End xs)]
     [(reversed ys') xs']))
 
 (def: .public (sub size list)
-  {#.doc "Segment the list into sub-lists of (at most) the given size."}
   (All [a] (-> Nat (List a) (List (List a))))
   (case list
     #.End
@@ -165,7 +159,6 @@
       (#.Item pre (sub size post)))))
 
 (def: .public (repeated n x)
-  {#.doc "A list of the value x, repeated n times."}
   (All [a]
     (-> Nat a (List a)))
   (case n
@@ -183,7 +176,6 @@
     (list)))
 
 (def: .public (iterations f x)
-  {#.doc "Generates a list element by element until the function returns #.None."}
   (All [a]
     (-> (-> a (Maybe a)) a (List a)))
   (case (f x)
@@ -235,7 +227,6 @@
            (all check xs')))))
 
 (def: .public (example predicate xs)
-  {#.doc "Yields the first value in the list that satisfies the predicate."}
   (All [a]
     (-> (Predicate a) (List a) (Maybe a)))
   (..one (function (_ value)
@@ -245,7 +236,6 @@
          xs))
 
 (def: .public (interposed sep xs)
-  {#.doc "Puts a value between every two elements in the list."}
   (All [a]
     (-> a (List a) (List a)))
   (case xs
@@ -279,7 +269,6 @@
   )
 
 (def: .public (item i xs)
-  {#.doc "Fetches the element at the specified index."}
   (All [a]
     (-> Nat (List a) (Maybe a)))
   (case xs
@@ -371,7 +360,6 @@
     (|>> reversed (fold compose identity))))
 
 (def: .public (sorted < xs)
-  {#.doc (.example "A list ordered by a comparison function.")}
   (All [a] (-> (-> a a Bit) (List a) (List a)))
   (case xs
     #.End
@@ -421,7 +409,6 @@
   )
 
 (def: .public (indices size)
-  {#.doc "Produces all the valid indices for a given size."}
   (All [a] (-> Nat (List Nat)))
   (case size
     0 (list)
@@ -454,11 +441,6 @@
         _ (recur input' output')))))
 
 (macro: .public (zipped tokens state)
-  {#.doc (.example "Create list zippers with the specified number of input lists."
-                   (def: .public zipped/2 (zipped 2))
-                   (def: .public zipped/3 (zipped 3))
-                   (zipped/3 xs ys zs)
-                   ((zipped 3) xs ys zs))}
   (case tokens
     (^ (list [_ (#.Nat num_lists)]))
     (if (n.> 0 num_lists)
@@ -499,11 +481,6 @@
 (def: .public zipped/3 (zipped 3))
 
 (macro: .public (zipped_with tokens state)
-  {#.doc (.example "Create list zippers with the specified number of input lists."
-                   (def: .public zipped_with/2 (zipped_with 2))
-                   (def: .public zipped_with/3 (zipped_with 3))
-                   (zipped_with/2 + xs ys)
-                   ((zipped_with 2) + xs ys))}
   (case tokens
     (^ (list [_ (#.Nat num_lists)]))
     (if (n.> 0 num_lists)
@@ -559,8 +536,6 @@
     (last xs')))
 
 (def: .public (inits xs)
-  {#.doc (.example "For a list of size N, yields the first N-1 elements."
-                   "Will yield a #.None for empty lists.")}
   (All [a] (-> (List a) (Maybe (List a))))
   (case xs
     #.End
@@ -579,12 +554,10 @@
     ))
 
 (def: .public together
-  {#.doc (.example "The sequential combination of all the lists.")}
   (All [a] (-> (List (List a)) (List a)))
   (\ ..monad join))
 
 (implementation: .public (with monad)
-  {#.doc (.example "Enhances a monad with List functionality.")}
   (All [M] (-> (Monad M) (Monad (All [a] (M (List a))))))
 
   (def: &functor
@@ -605,12 +578,10 @@
       (in (..together lla)))))
 
 (def: .public (lifted monad)
-  {#.doc (.example "Wraps a monadic value with List machinery.")}
   (All [M a] (-> (Monad M) (-> (M a) (M (List a)))))
   (\ monad map (\ ..monad in)))
 
 (def: .public (enumeration xs)
-  {#.doc "Pairs every element in the list with its index, starting at 0."}
   (All [a] (-> (List a) (List [Nat a])))
   (loop [idx 0
          xs xs]
@@ -622,11 +593,6 @@
       (#.Item [idx x] (recur (++ idx) xs')))))
 
 (macro: .public (when tokens state)
-  {#.doc (.example "Can be used as a guard in (co)monadic be/do expressions."
-                   (do monad
-                     [value (do_something 1 2 3)
-                      ..when (passes_test? value)]
-                     (do_something_else 4 5 6)))}
   (case tokens
     (^ (.list test then))
     (#.Right [state (.list (` (.if (~ test)
diff --git a/stdlib/source/library/lux/data/collection/queue.lux b/stdlib/source/library/lux/data/collection/queue.lux
index a54543eae..e8caf83f7 100644
--- a/stdlib/source/library/lux/data/collection/queue.lux
+++ b/stdlib/source/library/lux/data/collection/queue.lux
@@ -12,7 +12,6 @@
       ["n" nat]]]]])
 
 (type: .public (Queue a)
-  {#.doc (example "A first-in, first-out sequential data-structure.")}
   {#front (List a)
    #rear (List a)})
 
@@ -32,7 +31,6 @@
     (list\compose front (list.reversed rear))))
 
 (def: .public front
-  {#.doc (example "Yields the first value in the queue, if any.")}
   (All [a] (-> (Queue a) (Maybe a)))
   (|>> (value@ #front) list.head))
 
diff --git a/stdlib/source/library/lux/data/collection/row.lux b/stdlib/source/library/lux/data/collection/row.lux
index e77ef1bdf..16929459e 100644
--- a/stdlib/source/library/lux/data/collection/row.lux
+++ b/stdlib/source/library/lux/data/collection/row.lux
@@ -183,7 +183,6 @@
                    #.End))))
 
 (type: .public (Row a)
-  {#.doc (example "A sequential data-structure with fast random access.")}
   {#level Level
    #size Nat
    #root (Hierarchy a)
@@ -242,7 +241,6 @@
 (exception: base_was_not_found)
 
 (def: .public (within_bounds? row idx)
-  {#.doc (example "Determines whether the index is within the bounds of the row.")}
   (All [a] (-> (Row a) Nat Bit))
   (n.< (value@ #size row) idx))
 
@@ -350,17 +348,15 @@
   (All [a] (-> (List a) (Row a)))
   (list\fold ..suffix ..empty))
 
-(def: .public (member? a/Equivalence row val)
+(def: .public (member? equivalence row val)
   (All [a] (-> (Equivalence a) (Row a) a Bit))
-  (list.member? a/Equivalence (list row) val))
+  (list.member? equivalence (list row) val))
 
 (def: .public empty?
   (All [a] (-> (Row a) Bit))
   (|>> (value@ #size) (n.= 0)))
 
 (syntax: .public (row [elems (<>.some <code>.any)])
-  {#.doc (example "Row literals."
-                  (row 12 34 56 78 90))}
   (in (.list (` (..of_list (.list (~+ elems)))))))
 
 (implementation: (node_equivalence Equivalence<a>)
diff --git a/stdlib/source/library/lux/data/collection/sequence.lux b/stdlib/source/library/lux/data/collection/sequence.lux
index 42cd682df..2bed3b721 100644
--- a/stdlib/source/library/lux/data/collection/sequence.lux
+++ b/stdlib/source/library/lux/data/collection/sequence.lux
@@ -20,25 +20,20 @@
       ["n" nat]]]]])
 
 (type: .public (Sequence a)
-  {#.doc "An infinite sequence of values."}
   (Cont [a (Sequence a)]))
 
 (def: .public (iterations step init)
-  {#.doc "A stateful way of infinitely calculating the values of a sequence."}
   (All [a b]
     (-> (-> a [a b]) a (Sequence b)))
   (let [[next x] (step init)]
     (//.pending [x (iterations step next)])))
 
 (def: .public (repeated x)
-  {#.doc "Repeat a value forever."}
   (All [a]
     (-> a (Sequence a)))
   (//.pending [x (repeated x)]))
 
 (def: .public (cycle [start next])
-  {#.doc (example "Go over the elements of a list forever."
-                  "The list should not be empty.")}
   (All [a]
     (-> [a (List a)] (Sequence a)))
   (loop [head start
@@ -103,7 +98,6 @@
   )
 
 (def: .public (only predicate sequence)
-  {#.doc (example "A new sequence only with items that satisfy the predicate.")}
   (All [a] (-> (-> a Bit) (Sequence a) (Sequence a)))
   (let [[head tail] (//.result sequence)]
     (if (predicate head)
@@ -111,9 +105,6 @@
       (only predicate tail))))
 
 (def: .public (partition left? xs)
-  {#.doc (example "Split a sequence in two based on a predicate."
-                  "The left side contains all entries for which the predicate is #1."
-                  "The right side contains all entries for which the predicate is #0.")}
   (All [a] (-> (-> a Bit) (Sequence a) [(Sequence a) (Sequence a)]))
   [(..only left? xs)
    (..only (bit.complement left?) xs)])
@@ -139,10 +130,6 @@
 (syntax: .public (^sequence& [patterns (<code>.form (<>.many <code>.any))
                               body <code>.any
                               branches (<>.some <code>.any)])
-  {#.doc (example "Allows destructuring of sequences in pattern-matching expressions."
-                  "Caveat emptor: Only use it for destructuring, and not for testing values within the sequences."
-                  (let [(^sequence& x y z _tail) (some_sequence_func +1 +2 +3)]
-                    (func x y z)))}
   (with_identifiers [g!sequence]
     (let [body+ (` (let [(~+ (list\join (list\map (function (_ pattern)
                                                     (list (` [(~ pattern) (~ g!sequence)])
diff --git a/stdlib/source/library/lux/data/color.lux b/stdlib/source/library/lux/data/color.lux
index 1cebc0408..d34918cf2 100644
--- a/stdlib/source/library/lux/data/color.lux
+++ b/stdlib/source/library/lux/data/color.lux
@@ -42,29 +42,25 @@
   (|>> (f.* rgb_factor) f.int .nat))
 
 (type: .public RGB
-  {#.doc (example "Red-Green-Blue color format.")}
   {#red Nat
    #green Nat
    #blue Nat})
 
 (type: .public HSL
-  {#.doc (example "Hue-Saturation-Lightness color format.")}
   [Frac Frac Frac])
 
 (type: .public CMYK
-  {#.doc (example "Cyan-Magenta-Yellow-Key color format.")}
   {#cyan Frac
    #magenta Frac
    #yellow Frac
    #key Frac})
 
 (type: .public HSB
-  {#.doc (example "Hue-Saturation-Brightness color format.")}
   [Frac Frac Frac])
 
 (abstract: .public Color
-  {#.doc (example "A color value, independent of color format.")}
-
+  {}
+  
   RGB
 
   (def: .public (of_rgb [red green blue])
@@ -128,7 +124,6 @@
     (|> ..top (n.- value)))
 
   (def: .public (complement color)
-    {#.doc (example "The opposite color.")}
     (-> Color Color)
     (let [[red green blue] (:representation color)]
       (:abstraction {#red (complement' red)
@@ -409,13 +404,7 @@
 (type: .public Palette
   (-> Spread Nat Color (List Color)))
 
-(syntax: (palette_documentation [name <code>.local_identifier])
-  (let [name (text.replaced "_" "-" name)
-        g!documentation (code.text (format "A " name " palette."))]
-    (in (list (` {#.doc (.example (~ g!documentation))})))))
-
 (`` (def: .public (analogous spread variations color)
-      (~~ (..palette_documentation analogous))
       Palette
       (let [[hue saturation brightness] (hsb color)
             spread (..normal spread)]
@@ -426,7 +415,6 @@
                   (list.indices variations)))))
 
 (`` (def: .public (monochromatic spread variations color)
-      (~~ (..palette_documentation monochromatic))
       Palette
       (let [[hue saturation brightness] (hsb color)
             spread (..normal spread)]
@@ -439,25 +427,20 @@
                            of_hsb))))))
 
 (type: .public Alpha
-  {#.doc (example "The degree of transparency of a pigment.")}
   Rev)
 
 (def: .public transparent
-  {#.doc (example "The maximum degree of transparency.")}
   Alpha
   rev\bottom)
 
 (def: .public translucent
-  {#.doc (example "The average degree of transparency.")}
   Alpha
   .5)
 
 (def: .public opaque
-  {#.doc (example "The minimum degree of transparency.")}
   Alpha
   rev\top)
 
 (type: .public Pigment
-  {#.doc (example "A color with some degree of transparency.")}
   {#color Color
    #alpha Alpha})
diff --git a/stdlib/source/library/lux/data/color/named.lux b/stdlib/source/library/lux/data/color/named.lux
index f94dacd1a..5e5e5bc65 100644
--- a/stdlib/source/library/lux/data/color/named.lux
+++ b/stdlib/source/library/lux/data/color/named.lux
@@ -1,30 +1,10 @@
 (.module:
   [library
    [lux #*
-    [control
-     ["<>" parser
-      ["<.>" code]]]
-    [data
-     ["." text
-      ["%" format (#+ format)]]]
-    [macro
-     ["." syntax (#+ syntax:)]
-     ["." code]]
     [math
      [number (#+ hex)]]]]
   ["." // (#+ Color)])
 
-(syntax: (documentation [<red> <code>.text
-                         <green> <code>.text
-                         <blue> <code>.text
-                         <name> <code>.local_identifier])
-  (|> <name>
-      (text.replaced "_" " ")
-      (format <red> <green> <blue> " | ")
-      code.text
-      list
-      in))
-
 (template [<red> <green> <blue> <name>]
   [(`` (def: .public <name>
          {#.doc (example (~~ (..documentation <red> <green> <blue> <name>)))}
diff --git a/stdlib/source/library/lux/ffi.jvm.lux b/stdlib/source/library/lux/ffi.jvm.lux
index d7f3c9544..bc91e8880 100644
--- a/stdlib/source/library/lux/ffi.jvm.lux
+++ b/stdlib/source/library/lux/ffi.jvm.lux
@@ -392,21 +392,21 @@
   (-> (Type Declaration) Code)
   (|>> ..signature code.text))
 
-(def: (make_get_const_parser class_name field_name)
+(def: (get_const_parser class_name field_name)
   (-> Text Text (Parser Code))
   (do <>.monad
     [.let [dotted_name (format "::" field_name)]
      _ (<code>.this! (code.identifier ["" dotted_name]))]
     (in (get_static_field class_name field_name))))
 
-(def: (make_get_var_parser class_name field_name self_name)
+(def: (get_var_parser class_name field_name self_name)
   (-> Text Text Text (Parser Code))
   (do <>.monad
     [.let [dotted_name (format "::" field_name)]
      _ (<code>.this! (code.identifier ["" dotted_name]))]
     (in (get_virtual_field class_name field_name (code.local_identifier self_name)))))
 
-(def: (make_put_var_parser class_name field_name self_name)
+(def: (put_var_parser class_name field_name self_name)
   (-> Text Text Text (Parser Code))
   (do <>.monad
     [.let [dotted_name (format "::" field_name)]
@@ -450,17 +450,17 @@
   (-> Text Text [Member_Declaration FieldDecl] (Parser Code))
   (case field
     (#ConstantField _)
-    (make_get_const_parser class_name field_name)
+    (get_const_parser class_name field_name)
     
     (#VariableField _)
-    (<>.either (make_get_var_parser class_name field_name self_name)
-               (make_put_var_parser class_name field_name self_name))))
+    (<>.either (get_var_parser class_name field_name self_name)
+               (put_var_parser class_name field_name self_name))))
 
 (def: (decorate_input [class value])
   (-> [(Type Value) Code] Code)
   (` [(~ (code.text (..signature class))) (~ value)]))
 
-(def: (make_constructor_parser class_name arguments)
+(def: (constructor_parser class_name arguments)
   (-> Text (List Argument) (Parser Code))
   (do <>.monad
     [args (: (Parser (List Code))
@@ -471,7 +471,7 @@
                     (list.zipped/2 (list\map product.right arguments))
                     (list\map ..decorate_input))))))))
 
-(def: (make_static_method_parser class_name method_name arguments)
+(def: (static_method_parser class_name method_name arguments)
   (-> Text Text (List Argument) (Parser Code))
   (do <>.monad
     [.let [dotted_name (format "::" method_name "!")]
@@ -497,30 +497,30 @@
                                 (list.zipped/2 (list\map product.right arguments))
                                 (list\map ..decorate_input))))))))]
 
-  [make_special_method_parser "jvm member invoke special"]
-  [make_virtual_method_parser "jvm member invoke virtual"]
+  [special_method_parser "jvm member invoke special"]
+  [virtual_method_parser "jvm member invoke virtual"]
   )
 
 (def: (method->parser class_name [[method_name _ _] meth_def])
   (-> Text [Member_Declaration Method_Definition] (Parser Code))
   (case meth_def
     (#ConstructorMethod strict? type_vars self_name args constructor_args return_expr exs)
-    (make_constructor_parser class_name args)
+    (constructor_parser class_name args)
     
     (#StaticMethod strict? type_vars args return_type return_expr exs)
-    (make_static_method_parser class_name method_name args)
+    (static_method_parser class_name method_name args)
 
     (#VirtualMethod final? strict? type_vars self_name args return_type return_expr exs)
-    (make_virtual_method_parser class_name method_name args self_name)
+    (virtual_method_parser class_name method_name args self_name)
     
     (#OverridenMethod strict? owner_class type_vars self_name args return_type return_expr exs)
-    (make_special_method_parser class_name method_name args self_name)
+    (special_method_parser class_name method_name args self_name)
 
     (#AbstractMethod type_vars args return_type exs)
-    (make_virtual_method_parser class_name method_name args "")
+    (virtual_method_parser class_name method_name args "")
 
     (#NativeMethod type_vars args return_type exs)
-    (make_virtual_method_parser class_name method_name args "")))
+    (virtual_method_parser class_name method_name args "")))
 
 (def: privacy_modifier^
   (Parser Privacy)
diff --git a/stdlib/source/library/lux/macro/syntax/definition.lux b/stdlib/source/library/lux/macro/syntax/definition.lux
index 14e907870..79fde60e7 100644
--- a/stdlib/source/library/lux/macro/syntax/definition.lux
+++ b/stdlib/source/library/lux/macro/syntax/definition.lux
@@ -124,7 +124,7 @@
             <code>.bit
             ))))
 
-(exception: .public (lacks_type! {definition Definition})
+(exception: .public (lacks_type {definition Definition})
   (exception.report
    ["Definition" (%.code (..format definition))]))
 
@@ -138,5 +138,5 @@
          (in [])
 
          (#.Right _)
-         (<>.lifted (exception.except ..lacks_type! [definition])))]
+         (<>.lifted (exception.except ..lacks_type [definition])))]
     (in definition)))
diff --git a/stdlib/source/library/lux/math/number/rev.lux b/stdlib/source/library/lux/math/number/rev.lux
index 3fc60202c..c7d5641ce 100644
--- a/stdlib/source/library/lux/math/number/rev.lux
+++ b/stdlib/source/library/lux/math/number/rev.lux
@@ -25,6 +25,7 @@
      Rev
      (.rev (//i64.left_shifted (//nat.- <power> //i64.width) 1)))]
 
+  [00 /1]
   [01 /2]
   [02 /4]
   [03 /8]
diff --git a/stdlib/source/library/lux/meta.lux b/stdlib/source/library/lux/meta.lux
index 7b6e893d3..0b4b809fc 100644
--- a/stdlib/source/library/lux/meta.lux
+++ b/stdlib/source/library/lux/meta.lux
@@ -599,3 +599,10 @@
 
     (#try.Failure error)
     (..failure error)))
+
+(def: .public (eval type code)
+  (-> Type Code (Meta Any))
+  (do {! ..monad}
+    [eval (\ ! map (value@ #.eval)
+             ..compiler_state)]
+    (eval type code)))
diff --git a/stdlib/source/library/lux/test.lux b/stdlib/source/library/lux/test.lux
index 29af87345..e92cd49e4 100644
--- a/stdlib/source/library/lux/test.lux
+++ b/stdlib/source/library/lux/test.lux
@@ -310,7 +310,7 @@
   Text
   (text.of_char 31))
 
-(def: encode_coverage
+(def: encoded_coverage
   (-> (List Text) Text)
   (list\fold (function (_ short aggregate)
                (case aggregate
@@ -318,7 +318,7 @@
                  _ (format aggregate ..coverage_separator short)))
              ""))
 
-(def: (decode_coverage module encoding)
+(def: (coverage module encoding)
   (-> Text Text (Set Name))
   (loop [remaining encoding
          output (set.of_list name.hash (list))]
@@ -366,7 +366,7 @@
 
 (def: (covering' module coverage test)
   (-> Text Text Test Test)
-  (let [coverage (..decode_coverage module coverage)]
+  (let [coverage (..coverage module coverage)]
     (|> (..context module test)
         (random\map (async\map (function (_ [tally documentation])
                                  [(revised@ #expected_coverage (set.union coverage) tally)
@@ -388,7 +388,7 @@
                                        (#.Item short aggregate)
                                        aggregate))
                                    #.End)
-                        ..encode_coverage)]]
+                        ..encoded_coverage)]]
     (in (list (` ((~! ..covering')
                   (~ (code.text module))
                   (~ (code.text coverage))
diff --git a/stdlib/source/library/lux/tool/compiler/default/init.lux b/stdlib/source/library/lux/tool/compiler/default/init.lux
index 04971dadd..c01a1f6c1 100644
--- a/stdlib/source/library/lux/tool/compiler/default/init.lux
+++ b/stdlib/source/library/lux/tool/compiler/default/init.lux
@@ -169,9 +169,9 @@
     (in [buffer registry])))
 
 ... TODO: Inline ASAP
-(def: (process_directive archive expander pre_payoad code)
+(def: (process_directive wrapper archive expander pre_payoad code)
   (All [directive]
-    (-> Archive Expander (Payload directive) Code
+    (-> ///phase.Wrapper Archive Expander (Payload directive) Code
         (All [anchor expression]
           (///directive.Operation anchor expression directive
                                   [Requirements (Payload directive)]))))
@@ -181,26 +181,26 @@
         (///generation.set_buffer pre_buffer))
      _ (///directive.lifted_generation
         (///generation.set_registry pre_registry))
-     requirements (let [execute! (directiveP.phase expander)]
+     requirements (let [execute! (directiveP.phase wrapper expander)]
                     (execute! archive code))
      post_payload (..get_current_payload pre_payoad)]
     (in [requirements post_payload])))
 
-(def: (iteration' archive expander reader source pre_payload)
+(def: (iteration' wrapper archive expander reader source pre_payload)
   (All [directive]
-    (-> Archive Expander Reader Source (Payload directive)
+    (-> ///phase.Wrapper Archive Expander Reader Source (Payload directive)
         (All [anchor expression]
           (///directive.Operation anchor expression directive
                                   [Source Requirements (Payload directive)]))))
   (do ///phase.monad
     [[source code] (///directive.lifted_analysis
                     (..read source reader))
-     [requirements post_payload] (process_directive archive expander pre_payload code)]
+     [requirements post_payload] (process_directive wrapper archive expander pre_payload code)]
     (in [source requirements post_payload])))
 
-(def: (iteration archive expander module source pre_payload aliases)
+(def: (iteration wrapper archive expander module source pre_payload aliases)
   (All [directive]
-    (-> Archive Expander Module Source (Payload directive) Aliases
+    (-> ///phase.Wrapper Archive Expander Module Source (Payload directive) Aliases
         (All [anchor expression]
           (///directive.Operation anchor expression directive
                                   (Maybe [Source Requirements (Payload directive)])))))
@@ -208,7 +208,7 @@
     [reader (///directive.lifted_analysis
              (..reader module aliases source))]
     (function (_ state)
-      (case (///phase.result' state (..iteration' archive expander reader source pre_payload))
+      (case (///phase.result' state (..iteration' wrapper archive expander reader source pre_payload))
         (#try.Success [state source&requirements&buffer])
         (#try.Success [state (#.Some source&requirements&buffer)])
 
@@ -228,11 +228,11 @@
   (-> .Module Aliases)
   (|>> (value@ #.module_aliases) (dictionary.of_list text.hash)))
 
-(def: .public (compiler expander prelude write_directive)
+(def: .public (compiler wrapper expander prelude write_directive)
   (All [anchor expression directive]
-    (-> Expander Module (-> directive Binary)
+    (-> ///phase.Wrapper Expander Module (-> directive Binary)
         (Instancer (///directive.State+ anchor expression directive) .Module)))
-  (let [execute! (directiveP.phase expander)]
+  (let [execute! (directiveP.phase wrapper expander)]
     (function (_ key parameters input)
       (let [dependencies (default_dependencies prelude input)]
         {#///.dependencies dependencies
@@ -243,7 +243,7 @@
                                                        (..begin dependencies hash input))
                            .let [module (value@ #///.module input)]]
                           (loop [iteration (<| (///phase.result' state)
-                                               (..iteration archive expander module source buffer ///syntax.no_aliases))]
+                                               (..iteration wrapper archive expander module source buffer ///syntax.no_aliases))]
                             (do !
                               [[state ?source&requirements&temporary_payload] iteration]
                               (case ?source&requirements&temporary_payload
@@ -284,5 +284,5 @@
                                                                                    (value@ #///directive.referrals)
                                                                                    (monad.map ! (execute! archive)))
                                                                              temporary_payload (..get_current_payload temporary_payload)]
-                                                                            (..iteration archive expander module source temporary_payload (..module_aliases analysis_module))))))})]))
+                                                                            (..iteration wrapper archive expander module source temporary_payload (..module_aliases analysis_module))))))})]))
                                 )))))}))))
diff --git a/stdlib/source/library/lux/tool/compiler/default/platform.lux b/stdlib/source/library/lux/tool/compiler/default/platform.lux
index 1ac28821f..b5eed68f8 100644
--- a/stdlib/source/library/lux/tool/compiler/default/platform.lux
+++ b/stdlib/source/library/lux/tool/compiler/default/platform.lux
@@ -64,15 +64,12 @@
 
 (with_expansions [<type_vars> (as_is anchor expression directive)
                   <Operation> (as_is ///generation.Operation <type_vars>)]
-  (type: .public Phase_Wrapper
-    (All [s i o] (-> (Phase s i o) Any)))
-  
   (type: .public (Platform <type_vars>)
     {#&file_system (file.System Async)
      #host (///generation.Host expression directive)
      #phase (///generation.Phase <type_vars>)
      #runtime (<Operation> [Registry Output])
-     #phase_wrapper (-> Archive (<Operation> Phase_Wrapper))
+     #phase_wrapper (-> Archive (<Operation> ///phase.Wrapper))
      #write (-> directive Binary)})
 
   ... TODO: Get rid of this
@@ -197,7 +194,7 @@
 
     (def: (phase_wrapper archive platform state)
       (All [<type_vars>]
-        (-> Archive <Platform> <State+> (Try [<State+> Phase_Wrapper])))
+        (-> Archive <Platform> <State+> (Try [<State+> ///phase.Wrapper])))
       (let [phase_wrapper (value@ #phase_wrapper platform)]
         (|> archive
             phase_wrapper
@@ -206,8 +203,8 @@
 
     (def: (complete_extensions host_directive_bundle phase_wrapper [analysers synthesizers generators directives])
       (All [<type_vars>]
-        (-> (-> Phase_Wrapper (///directive.Bundle <type_vars>))
-            Phase_Wrapper
+        (-> (-> ///phase.Wrapper (///directive.Bundle <type_vars>))
+            ///phase.Wrapper
             [(Dictionary Text ///analysis.Handler)
              (Dictionary Text ///synthesis.Handler)
              (Dictionary Text (///generation.Handler <type_vars>))
@@ -230,11 +227,11 @@
             ///analysis.Bundle
             <Platform>
             <Bundle>
-            (-> Phase_Wrapper (///directive.Bundle <type_vars>))
+            (-> ///phase.Wrapper (///directive.Bundle <type_vars>))
             (Program expression directive)
-            [Type Type Type] (-> Phase_Wrapper Extender)
+            [Type Type Type] (-> ///phase.Wrapper Extender)
             Import (List Context)
-            (Async (Try [<State+> Archive]))))
+            (Async (Try [<State+> Archive ///phase.Wrapper]))))
       (do {! (try.with async.monad)}
         [.let [state (//init.state (value@ #static.host static)
                                    module
@@ -247,7 +244,8 @@
          [archive analysis_state bundles] (ioW.thaw (value@ #host platform) (value@ #&file_system platform) static import compilation_sources)
          .let [with_missing_extensions
                (: (All [<type_vars>]
-                    (-> <Platform> (Program expression directive) <State+> (Async (Try <State+>))))
+                    (-> <Platform> (Program expression directive) <State+>
+                        (Async (Try [///phase.Wrapper <State+>]))))
                   (function (_ platform program state)
                     (async\in
                      (do try.monad
@@ -256,19 +254,20 @@
                            (initialize_state (extender phase_wrapper)
                                              (:expected (..complete_extensions host_directive_bundle phase_wrapper (:expected bundles)))
                                              analysis_state)
-                           (try\map (//init.with_default_directives expander host_analysis program anchorT,expressionT,directiveT (extender phase_wrapper))))))))]]
+                           (try\map (|>> (//init.with_default_directives expander host_analysis program anchorT,expressionT,directiveT (extender phase_wrapper))
+                                         [phase_wrapper])))))))]]
         (if (archive.archived? archive archive.runtime_module)
           (do !
-            [state (with_missing_extensions platform program state)]
-            (in [state archive]))
+            [[phase_wrapper state] (with_missing_extensions platform program state)]
+            (in [state archive phase_wrapper]))
           (do !
             [[state [archive payload]] (|> (..process_runtime archive platform)
                                            (///phase.result' state)
                                            async\in)
              _ (..cache_module static platform 0 payload)
              
-             state (with_missing_extensions platform program state)]
-            (in [state archive])))))
+             [phase_wrapper state] (with_missing_extensions platform program state)]
+            (in [state archive phase_wrapper])))))
 
     (def: compilation_log_separator
       (format text.new_line text.tab))
@@ -523,9 +522,9 @@
             try.trusted
             product.left))
 
-      (def: .public (compile import static expander platform compilation context)
+      (def: .public (compile phase_wrapper import static expander platform compilation context)
         (All [<type_vars>]
-          (-> Import Static Expander <Platform> Compilation <Context> <Return>))
+          (-> ///phase.Wrapper Import Static Expander <Platform> Compilation <Context> <Return>))
         (let [[compilation_sources compilation_host_dependencies compilation_libraries compilation_target compilation_module] compilation
               base_compiler (:sharing [<type_vars>]
                                       <Context>
@@ -533,7 +532,7 @@
                                       
                                       (///.Compiler <State+> .Module Any)
                                       (:expected
-                                       ((//init.compiler expander syntax.prelude (value@ #write platform)) $.key (list))))
+                                       ((//init.compiler phase_wrapper expander syntax.prelude (value@ #write platform)) $.key (list))))
               compiler (..parallel
                         context
                         (function (_ importer import! module_id [archive state] module)
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/analysis.lux b/stdlib/source/library/lux/tool/compiler/language/lux/analysis.lux
index aefd908c4..45216a70f 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/analysis.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/analysis.lux
@@ -553,4 +553,5 @@
    #.seed            0
    #.scope_type_vars (list)
    #.extensions      []
+   #.eval            (:as (-> Type Code (Meta Any)) [])
    #.host            []})
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/analysis/evaluation.lux b/stdlib/source/library/lux/tool/compiler/language/lux/analysis/evaluation.lux
index 1859802d6..8bba841e2 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/analysis/evaluation.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/analysis/evaluation.lux
@@ -27,7 +27,7 @@
          [descriptor (#+ Module)]]]]]]]])
 
 (type: .public Eval
-  (-> Archive Nat Type Code (Operation Any)))
+  (-> Archive Type Code (Operation Any)))
 
 (def: (context [module_id artifact_id])
   (-> Context Context)
@@ -42,12 +42,14 @@
         (generation.Phase anchor expression artifact)
         Eval))
   (let [analyze (analysisP.phase expander)]
-    (function (eval archive count type exprC)
+    (function (eval archive type exprC)
       (do phase.monad
         [exprA (type.with_type type
                  (analyze archive exprC))
          module (extensionP.lifted
-                 meta.current_module_name)]
+                 meta.current_module_name)
+         count (extensionP.lifted
+                meta.seed)]
         (phase.lifted (do try.monad
                         [exprS (|> exprA (synthesisP.phase archive) (phase.result synthesis_state))]
                         (phase.result generation_state
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis.lux
index ee12a8bf0..c8cfe9c0e 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis.lux
@@ -124,10 +124,10 @@
               (compile archive expansion))
 
             _
-            (/function.on compile argsC+ functionT functionA archive functionC)))
+            (/function.apply compile argsC+ functionT functionA archive functionC)))
 
         _
-        (/function.on compile argsC+ functionT functionA archive functionC)))
+        (/function.apply compile argsC+ functionT functionA archive functionC)))
 
     _
     (//.except ..unrecognized_syntax [location.dummy code'])))
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case.lux
index b3642f5f3..fc7575260 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case.lux
@@ -84,7 +84,7 @@
       (#.Var id)
       (do ///.monad
         [?caseT' (//type.with_env
-                   (check.read id))]
+                   (check.read' id))]
         (.case ?caseT'
           (#.Some caseT')
           (recur envs caseT')
@@ -110,7 +110,7 @@
         (do ///.monad
           [funcT' (//type.with_env
                     (do check.monad
-                      [?funct' (check.read funcT_id)]
+                      [?funct' (check.read' funcT_id)]
                       (.case ?funct'
                         (#.Some funct')
                         (in funct')
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/function.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/function.lux
index 69e75f374..8aa2f284f 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/function.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/function.lux
@@ -71,7 +71,7 @@
           (#.Var id)
           (do !
             [?expectedT' (//type.with_env
-                           (check.read id))]
+                           (check.read' id))]
             (case ?expectedT'
               (#.Some expectedT')
               (recur expectedT')
@@ -85,8 +85,7 @@
                  functionA (recur functionT)
                  _ (//type.with_env
                      (check.check expectedT functionT))]
-                (in functionA))
-              ))
+                (in functionA))))
 
           (#.Function inputT outputT)
           (<| (\ ! map (.function (_ [scope bodyA])
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/inference.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/inference.lux
index 0420b7811..452bf6bc1 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/inference.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/inference.lux
@@ -166,7 +166,8 @@
 
       (#.Var infer_id)
       (do ///.monad
-        [?inferT' (//type.with_env (check.read infer_id))]
+        [?inferT' (//type.with_env
+                    (check.read' infer_id))]
         (case ?inferT'
           (#.Some inferT')
           (general archive analyse inferT' args)
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/structure.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/structure.lux
index fe296c83e..886ffe065 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/structure.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/structure.lux
@@ -119,7 +119,7 @@
             (#.Var id)
             (do !
               [?expectedT' (//type.with_env
-                             (check.read id))]
+                             (check.read' id))]
               (case ?expectedT'
                 (#.Some expectedT')
                 (//type.with_type expectedT'
@@ -144,7 +144,8 @@
             (case funT
               (#.Var funT_id)
               (do !
-                [?funT' (//type.with_env (check.read funT_id))]
+                [?funT' (//type.with_env
+                          (check.read' funT_id))]
                 (case ?funT'
                   (#.Some funT')
                   (//type.with_type (#.Apply inputT funT')
@@ -208,7 +209,7 @@
         (#.Var id)
         (do !
           [?expectedT' (//type.with_env
-                         (check.read id))]
+                         (check.read' id))]
           (case ?expectedT'
             (#.Some expectedT')
             (//type.with_type expectedT'
@@ -237,7 +238,8 @@
         (case funT
           (#.Var funT_id)
           (do !
-            [?funT' (//type.with_env (check.read funT_id))]
+            [?funT' (//type.with_env
+                      (check.read' funT_id))]
             (case ?funT'
               (#.Some funT')
               (//type.with_type (#.Apply inputT funT')
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/directive.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/directive.lux
index cc34e04cf..3c6425da3 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/directive.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/directive.lux
@@ -1,16 +1,17 @@
 (.module:
   [library
    [lux #*
+    ["." meta]
     [abstract
      ["." monad (#+ do)]]
     [control
+     ["." try]
      ["." exception (#+ exception:)]]
     [data
      [text
       ["%" format (#+ format)]]
      [collection
-      ["." list ("#\." fold monoid)]]]
-    ["." meta]]]
+      ["." list ("#\." fold monoid)]]]]]
   ["." // #_
    ["#." extension]
    ["#." analysis
@@ -18,11 +19,14 @@
    ["/#" // #_
     ["/" directive (#+ Phase)]
     ["#." analysis
+     ["." evaluation]
      ["#/." macro (#+ Expander)]]
     [///
      ["//" phase]
      [reference (#+)
-      [variable (#+)]]]]])
+      [variable (#+)]]
+     [meta
+      [archive (#+ Archive)]]]]])
 
 (exception: .public (not_a_directive {code Code})
   (exception.report
@@ -36,44 +40,68 @@
   (exception.report
    ["Name" (%.name name)]))
 
+(type: Eval
+  (-> Type Code (Meta Any)))
+
+(def: (meta_eval archive bundle compiler_eval)
+  (-> Archive ///analysis.Bundle evaluation.Eval
+      Eval)
+  (function (_ type code lux)
+    (case (compiler_eval archive type code [bundle lux])
+      (#try.Success [[_bundle lux'] value])
+      (#try.Success [lux' value])
+      
+      (#try.Failure error)
+      (#try.Failure error))))
+
 (with_expansions [<lux_def_module> (as_is [|form_location| (#.Form (list& [|text_location| (#.Text "lux def module")] annotations))])]
-  (def: .public (phase expander)
-    (-> Expander Phase)
-    (let [analyze (//analysis.phase expander)]
+  (def: .public (phase wrapper expander)
+    (-> //.Wrapper Expander Phase)
+    (let [analysis (//analysis.phase expander)]
       (function (recur archive code)
-        (case code
-          (^ [_ (#.Form (list& [_ (#.Text name)] inputs))])
-          (//extension.apply archive recur [name inputs])
+        (do {! //.monad}
+          [state //.get_state
+           .let [compiler_eval (meta_eval archive
+                                          (value@ [#//extension.state #/.analysis #/.state #//extension.bundle] state)
+                                          (evaluation.evaluator expander
+                                                                (value@ [#//extension.state #/.synthesis #/.state] state)
+                                                                (value@ [#//extension.state #/.generation #/.state] state)
+                                                                (value@ [#//extension.state #/.generation #/.phase] state)))
+                 extension_eval (:as Eval (wrapper (:expected compiler_eval)))]
+           _ (//.set_state (with@ [#//extension.state #/.analysis #/.state #//extension.state #.eval] extension_eval state))]
+          (case code
+            (^ [_ (#.Form (list& [_ (#.Text name)] inputs))])
+            (//extension.apply archive recur [name inputs])
 
-          (^ [_ (#.Form (list& macro inputs))])
-          (do {! //.monad}
-            [expansion (/.lifted_analysis
-                        (do !
-                          [macroA (//analysis/type.with_type Macro
-                                    (analyze archive macro))]
-                          (case macroA
-                            (^ (///analysis.constant macro_name))
-                            (do !
-                              [?macro (//extension.lifted (meta.macro macro_name))
-                               macro (case ?macro
-                                       (#.Some macro)
-                                       (in macro)
-                                       
-                                       #.None
-                                       (//.except ..macro_was_not_found macro_name))]
-                              (//extension.lifted (///analysis/macro.expand expander macro_name macro inputs)))
-                            
-                            _
-                            (//.except ..invalid_macro_call code))))]
-            (case expansion
-              (^ (list& <lux_def_module> referrals))
-              (|> (recur archive <lux_def_module>)
-                  (\ ! map (revised@ #/.referrals (list\compose referrals))))
+            (^ [_ (#.Form (list& macro inputs))])
+            (do !
+              [expansion (/.lifted_analysis
+                          (do !
+                            [macroA (//analysis/type.with_type Macro
+                                      (analysis archive macro))]
+                            (case macroA
+                              (^ (///analysis.constant macro_name))
+                              (do !
+                                [?macro (//extension.lifted (meta.macro macro_name))
+                                 macro (case ?macro
+                                         (#.Some macro)
+                                         (in macro)
+                                         
+                                         #.None
+                                         (//.except ..macro_was_not_found macro_name))]
+                                (//extension.lifted (///analysis/macro.expand expander macro_name macro inputs)))
+                              
+                              _
+                              (//.except ..invalid_macro_call code))))]
+              (case expansion
+                (^ (list& <lux_def_module> referrals))
+                (|> (recur archive <lux_def_module>)
+                    (\ ! map (revised@ #/.referrals (list\compose referrals))))
 
-              _
-              (|> expansion
-                  (monad.map ! (recur archive))
-                  (\ ! map (list\fold /.merge_requirements /.no_requirements)))))
+                _
+                (|> expansion
+                    (monad.map ! (recur archive))
+                    (\ ! map (list\fold /.merge_requirements /.no_requirements)))))
 
-          _
-          (//.except ..not_a_directive code))))))
+            _
+            (//.except ..not_a_directive code)))))))
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/lux.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/lux.lux
index d26820e9a..e56a48572 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/lux.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/lux.lux
@@ -164,9 +164,8 @@
     (case args
       (^ (list typeC valueC))
       (do {! ////.monad}
-        [seed (///.lifted meta.seed)
-         actualT (\ ! map (|>> (:as Type))
-                    (eval archive seed Type typeC))
+        [actualT (\ ! map (|>> (:as Type))
+                    (eval archive Type typeC))
          _ (typeA.infer actualT)]
         (typeA.with_type actualT
           (analyse archive valueC)))
@@ -180,9 +179,8 @@
     (case args
       (^ (list typeC valueC))
       (do {! ////.monad}
-        [seed (///.lifted meta.seed)
-         actualT (\ ! map (|>> (:as Type))
-                    (eval archive seed Type typeC))
+        [actualT (\ ! map (|>> (:as Type))
+                    (eval archive Type typeC))
          _ (typeA.infer actualT)
          [valueT valueA] (typeA.with_inference
                            (analyse archive valueC))]
@@ -240,7 +238,8 @@
           (///bundle.install "error" (unary Text Nothing))
           (///bundle.install "exit" (unary Int Nothing)))))
 
-(def: I64* (type (I64 Any)))
+(def: I64*
+  (type (I64 Any)))
 
 (def: bundle::i64
   Bundle
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/function.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/function.lux
index 1e7ca8cc3..f26b13ade 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/function.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/function.lux
@@ -34,7 +34,7 @@
 
 (def: arity_arguments
   (-> Arity (List Synthesis))
-  (|>> dec
+  (|>> --
        (enum.range n.enum 1)
        (list\map (|>> /.variable/local))))
 
diff --git a/stdlib/source/library/lux/tool/compiler/phase.lux b/stdlib/source/library/lux/tool/compiler/phase.lux
index 92680654d..7e137387e 100644
--- a/stdlib/source/library/lux/tool/compiler/phase.lux
+++ b/stdlib/source/library/lux/tool/compiler/phase.lux
@@ -34,6 +34,9 @@
 (type: .public (Phase s i o)
   (-> Archive i (Operation s o)))
 
+(type: .public Wrapper
+  (All [s i o] (-> (Phase s i o) Any)))
+
 (def: .public (result' state operation)
   (All [s o]
     (-> s (Operation s o) (Try [s o])))
diff --git a/stdlib/source/program/compositor.lux b/stdlib/source/program/compositor.lux
index 7f0e29903..184914216 100644
--- a/stdlib/source/program/compositor.lux
+++ b/stdlib/source/program/compositor.lux
@@ -121,10 +121,10 @@
           analysis.Bundle
           (IO (Platform <parameters>))
           (generation.Bundle <parameters>)
-          (-> platform.Phase_Wrapper (directive.Bundle <parameters>))
+          (-> phase.Wrapper (directive.Bundle <parameters>))
           (Program expression artifact)
           [Type Type Type]
-          (-> platform.Phase_Wrapper Extender)
+          (-> phase.Wrapper Extender)
           Service
           [Packager file.Path]
           (Async Any)))
@@ -137,20 +137,21 @@
             (do (try.with async.monad)
               [.let [[compilation_sources compilation_host_dependencies compilation_libraries compilation_target compilation_module] compilation]
                import (/import.import (value@ #platform.&file_system platform) compilation_libraries)
-               [state archive] (:sharing [<parameters>]
-                                         (Platform <parameters>)
-                                         platform
-                                         
-                                         (Async (Try [(directive.State+ <parameters>)
-                                                      Archive]))
-                                         (:expected (platform.initialize static compilation_module expander host_analysis platform generation_bundle host_directive_bundle program anchorT,expressionT,directiveT extender
-                                                                         import compilation_sources)))
+               [state archive phase_wrapper] (:sharing [<parameters>]
+                                                       (Platform <parameters>)
+                                                       platform
+                                                       
+                                                       (Async (Try [(directive.State+ <parameters>)
+                                                                    Archive
+                                                                    phase.Wrapper]))
+                                                       (:expected (platform.initialize static compilation_module expander host_analysis platform generation_bundle host_directive_bundle program anchorT,expressionT,directiveT extender
+                                                                                       import compilation_sources)))
                [archive state] (:sharing [<parameters>]
                                          (Platform <parameters>)
                                          platform
                                          
                                          (Async (Try [Archive (directive.State+ <parameters>)]))
-                                         (:expected (platform.compile import static expander platform compilation [archive state])))
+                                         (:expected (platform.compile phase_wrapper import static expander platform compilation [archive state])))
                _ (ioW.freeze (value@ #platform.&file_system platform) static archive)
                program_context (async\in ($/program.context archive))
                host_dependencies (..load_host_dependencies (value@ #platform.&file_system platform) compilation_host_dependencies)
diff --git a/stdlib/source/test/lux/macro.lux b/stdlib/source/test/lux/macro.lux
index 93f2f8530..a335aa996 100644
--- a/stdlib/source/test/lux/macro.lux
+++ b/stdlib/source/test/lux/macro.lux
@@ -103,6 +103,7 @@
           #.seed            seed
           #.scope_type_vars (list)
           #.extensions      []
+          #.eval            (:as (-> Type Code (Meta Any)) [])
           #.host            []}])))
 
 (def: expander
diff --git a/stdlib/source/test/lux/macro/syntax/definition.lux b/stdlib/source/test/lux/macro/syntax/definition.lux
index 11074fbc7..e76d65a7b 100644
--- a/stdlib/source/test/lux/macro/syntax/definition.lux
+++ b/stdlib/source/test/lux/macro/syntax/definition.lux
@@ -51,6 +51,7 @@
    #.seed            0
    #.scope_type_vars (list)
    #.extensions      []
+   #.eval            (:as (-> Type Code (Meta Any)) [])
    #.host            []})
 
 (def: .public test
@@ -84,12 +85,12 @@
                              
                              (#try.Success actual)
                              (\ /.equivalence = expected actual))))
-                (_.cover [/.lacks_type!]
+                (_.cover [/.lacks_type]
                          (let [expected (with@ #/.value (#.Right untyped_value) expected)]
                            (case (<code>.result (/.typed compiler)
                                                 (list (/.format expected)))
                              (#try.Failure error)
-                             (exception.match? /.lacks_type! error)
+                             (exception.match? /.lacks_type error)
                              
                              (#try.Success actual)
                              false)))
diff --git a/stdlib/source/test/lux/meta.lux b/stdlib/source/test/lux/meta.lux
index a56457c9c..742523a67 100644
--- a/stdlib/source/test/lux/meta.lux
+++ b/stdlib/source/test/lux/meta.lux
@@ -65,6 +65,7 @@
                          #.seed            expected_seed
                          #.scope_type_vars (list)
                          #.extensions      []
+                         #.eval            (:as (-> Type Code (Meta Any)) [])
                          #.host            []}]]
     ($_ _.and
         (_.cover [/.result]
@@ -112,6 +113,7 @@
                          #.seed            expected_seed
                          #.scope_type_vars (list)
                          #.extensions      []
+                         #.eval            (:as (-> Type Code (Meta Any)) [])
                          #.host            []}]]
     ($_ _.and
         (_.cover [/.failure]
@@ -212,6 +214,7 @@
                          #.seed            expected_seed
                          #.scope_type_vars (list)
                          #.extensions      []
+                         #.eval            (:as (-> Type Code (Meta Any)) [])
                          #.host            []}]]
     (<| (_.for [.Module])
         ($_ _.and
@@ -310,6 +313,7 @@
                          #.seed            expected_seed
                          #.scope_type_vars (list)
                          #.extensions      []
+                         #.eval            (:as (-> Type Code (Meta Any)) [])
                          #.host            []}]]
     ($_ _.and
         (_.cover [/.seed]
@@ -401,6 +405,7 @@
                     #.seed            0
                     #.scope_type_vars (list)
                     #.extensions      []
+                    #.eval            (:as (-> Type Code (Meta Any)) [])
                     #.host            []}])))]]
     ($_ _.and
         (_.cover [.Global .Alias /.globals]
@@ -522,6 +527,7 @@
                     #.seed            0
                     #.scope_type_vars (list)
                     #.extensions      []
+                    #.eval            (:as (-> Type Code (Meta Any)) [])
                     #.host            []}])))]]
     ($_ _.and
         (_.cover [/.export]
@@ -703,6 +709,7 @@
                #.seed            0
                #.scope_type_vars (list)
                #.extensions      []
+               #.eval            (:as (-> Type Code (Meta Any)) [])
                #.host            []})]]
     ($_ _.and
         (_.cover [/.tag_lists]
@@ -812,6 +819,7 @@
                #.seed            0
                #.scope_type_vars (list)
                #.extensions      []
+               #.eval            (:as (-> Type Code (Meta Any)) [])
                #.host            []})]]
     ($_ _.and
         (_.cover [.Scope /.locals]
@@ -918,6 +926,7 @@
                                  #.seed            expected_seed
                                  #.scope_type_vars (list)
                                  #.extensions      []
+                                 #.eval            (:as (-> Type Code (Meta Any)) [])
                                  #.host            []}]]
             ($_ _.and
                 (_.for [/.functor]