- Updated the documentation of most modules left.

- Minor refactorings.

54 files changed, 796 insertions, 357 deletions

diff --git a/stdlib/source/lux/codata/io.lux b/stdlib/source/lux/codata/io.lux
index e612c24c9..60ea73834 100644
--- a/stdlib/source/lux/codata/io.lux
+++ b/stdlib/source/lux/codata/io.lux
@@ -3,7 +3,7 @@
 ##  If a copy of the MPL was not distributed with this file,
 ##  You can obtain one at http://mozilla.org/MPL/2.0/.
 
-(;module:
+(;module: {#;doc "A method for abstracting I/O and effectful computations to make it safe while writing pure functional code."}
   lux
   (lux (control functor
                 applicative
diff --git a/stdlib/source/lux/concurrency/actor.lux b/stdlib/source/lux/concurrency/actor.lux
index cea170b2c..650065a0e 100644
--- a/stdlib/source/lux/concurrency/actor.lux
+++ b/stdlib/source/lux/concurrency/actor.lux
@@ -3,7 +3,7 @@
 ##  If a copy of the MPL was not distributed with this file,
 ##  You can obtain one at http://mozilla.org/MPL/2.0/.
 
-(;module:
+(;module: {#;doc "The actor model of concurrency."}
   lux
   (lux (control monad)
        (codata [io #- run]
@@ -18,32 +18,35 @@
               ["s" syntax #+ syntax: Syntax]
               (syntax [common]))
        [type])
-  (.. [promise #+ Monad<Promise>]
+  (.. ["P" promise #+ Monad<Promise>]
       [stm #+ Monad<STM>]
       [frp]))
 
 ## [Types]
 (type: #export (Actor s m)
+  {#;doc "An actor, defined as all the necessities it requires."}
   {#mailbox (stm;Var m)
-   #kill-signal (promise;Promise Unit)
-   #obituary (promise;Promise [(Maybe Text) s (List m)])})
+   #kill-signal (P;Promise Unit)
+   #obituary (P;Promise [(Maybe Text) s (List m)])})
 
-(type: #export (Proc s m)
-  {#step (-> (Actor s m) (-> m s (promise;Promise (Error s))))
-   #end (-> (Maybe Text) s (promise;Promise Unit))})
+(type: #export (Behavior s m)
+  {#;doc "An actor's behavior when messages are received."}
+  {#step (-> (Actor s m) (-> m s (P;Promise (Error s))))
+   #end (-> (Maybe Text) s (P;Promise Unit))})
 
 ## [Values]
-(def: #export (spawn init [proc on-death])
-  {#;doc "Given a procedure and initial state, launches an actor and returns it."}
-  (All [s m] (-> s (Proc s m) (IO (Actor s m))))
-  (io (let [mailbox (stm;var (:! ($ +1) []))
-            kill-signal (promise;promise Unit)
-            obituary (promise;promise [(Maybe Text) ($ +0) (List ($ +1))])
+(def: #export (spawn init behavior)
+  {#;doc "Given a behavior and initial state, spawns an actor and returns it."}
+  (All [s m] (-> s (Behavior s m) (IO (Actor s m))))
+  (io (let [[step on-death] behavior
+            mailbox (stm;var (:! ($ +1) []))
+            kill-signal (P;promise Unit)
+            obituary (P;promise [(Maybe Text) ($ +0) (List ($ +1))])
             self {#mailbox mailbox
                   #kill-signal kill-signal
                   #obituary obituary}
             mailbox-chan (io;run (stm;follow "\tmailbox\t" mailbox))
-            proc (proc self)
+            step (step self)
             |mailbox| (stm;var mailbox-chan)
             _ (:: Monad<Promise> map
                   (lambda [_]
@@ -60,11 +63,11 @@
                           (#;Some [message messages'])
                           (do Monad<Promise>
                             [#let [_ (io;run (stm;write! messages' |mailbox|))]
-                             ?state' (proc message state)]
+                             ?state' (step message state)]
                             (case ?state'
                               (#;Left error)
                               (do @
-                                [#let [_ (io;run (promise;resolve [] kill-signal))
+                                [#let [_ (io;run (P;resolve [] kill-signal))
                                        _ (io;run (frp;close messages'))
                                        death-message (#;Some error)]
                                  _ (on-death death-message state)
@@ -86,12 +89,12 @@
 (def: #export poison
   {#;doc "Immediately kills the given actor (if it's not already dead)."}
   (All [s m] (-> (Actor s m) (io;IO Bool)))
-  (|>. (get@ #kill-signal) (promise;resolve [])))
+  (|>. (get@ #kill-signal) (P;resolve [])))
 
 (def: #export (alive? actor)
   (All [s m] (-> (Actor s m) Bool))
-  (case [(promise;poll (get@ #kill-signal actor))
-         (promise;poll (get@ #obituary actor))]
+  (case [(P;poll (get@ #kill-signal actor))
+         (P;poll (get@ #obituary actor))]
     [#;None #;None]
     true
 
@@ -99,18 +102,20 @@
     false))
 
 (def: #export (send message actor)
-  (All [s m] (-> m (Actor s m) (promise;Promise Bool)))
+  {#;doc "Communicate with an actor through message passing."}
+  (All [s m] (-> m (Actor s m) (P;Promise Bool)))
   (if (alive? actor)
     (exec (io;run (stm;write! message (get@ #mailbox actor)))
       (:: Monad<Promise> wrap true))
     (:: Monad<Promise> wrap false)))
 
-(def: #export (keep-alive init proc)
-  {#;doc "Given initial-state and a procedure, launches and actor that will reboot if it dies of errors.
-          However, it can still be killed."}
-  (All [s m] (-> s (Proc s m) (IO (Actor s m))))
+(def: #export (keep-alive init behavior)
+  {#;doc "Given initial-state and a behavior, spawns an actor that will reboot if it dies of errors.
+
+          However, if it is killed, it won't re-spawn."}
+  (All [s m] (-> s (Behavior s m) (IO (Actor s m))))
   (io (let [ka-actor (: (Actor (Actor ($ +0) ($ +1)) ($ +1))
-                        (io;run (spawn (io;run (spawn init proc))
+                        (io;run (spawn (io;run (spawn init behavior))
                                        {#step (lambda [*self* message server]
                                                 (do Monad<Promise>
                                                   [was-sent? (send message server)]
@@ -118,17 +123,19 @@
                                                     (wrap (#;Right server))
                                                     (do @
                                                       [[?cause state unprocessed-messages] (get@ #obituary server)]
-                                                      (exec (log! (format "ACTOR DIED:\n" (default "" ?cause) "\n RESTARTING"))
+                                                      (exec (log! (format "ACTOR DIED:" "\n"
+                                                                          (default "" ?cause) "\n"
+                                                                          "RESTARTING" "\n"))
                                                         (do @
-                                                          [#let [new-server (io;run (spawn state proc))
+                                                          [#let [new-server (io;run (spawn state behavior))
                                                                  mailbox (get@ #mailbox new-server)]
-                                                           _ (promise;future (mapM io;Monad<IO> ((flip stm;write!) mailbox) (#;Cons message unprocessed-messages)))]
+                                                           _ (P;future (mapM io;Monad<IO> ((flip stm;write!) mailbox) (#;Cons message unprocessed-messages)))]
                                                           (wrap (#;Right new-server))))
                                                       ))))
                                         #end (lambda [_ server] (exec (io;run (poison server))
                                                              (:: Monad<Promise> wrap [])))})))]
-        (update@ #obituary (: (-> (promise;Promise [(Maybe Text) (Actor ($ +0) ($ +1)) (List ($ +1))])
-                                  (promise;Promise [(Maybe Text) ($ +0) (List ($ +1))]))
+        (update@ #obituary (: (-> (P;Promise [(Maybe Text) (Actor ($ +0) ($ +1)) (List ($ +1))])
+                                  (P;Promise [(Maybe Text) ($ +0) (List ($ +1))]))
                               (lambda [process]
                                 (do Monad<Promise>
                                   [[_ server unprocessed-messages-0] process
@@ -193,23 +200,22 @@
                    state-type
                    [methods (s;many method^)]
                    [?stop (s;opt stop^)])
-  {#;doc (doc "Allows defining an actor, with a set of methods that can be called on it."
-              "The methods can return promisehronous outputs."
-              "The methods can access the actor's state through the *state* variable."
-              "The methods can also access the actor itself through the *self* variable."
+  {#;doc (doc "Allows defining an actor, with a pice of state and a set of methods that can be called on it."
+              "A method can access the actor's state through the *state* variable."
+              "A method can also access the actor itself through the *self* variable."
+              "A method may succeed or fail (in case of failure, the actor dies). This is handled through the Either type."
+              "A method's output must be a promise containing a 2-tuple with the updated state and a return value."
+              "All methods are run implicitly within the Promise monad."
 
               (actor: #export Adder
                 Int
                 
-                (method: (count! {to-add Int})
+                (method: (count! [to-add Int])
                   [Int Int]
-                  (if (>= 0 to-add)
-                    (do Monad<Promise>
-                      [#let [new-state (i.+ to-add *state*)]]
+                  (if (i.>= 0 to-add)
+                    (let [new-state (i.+ to-add *state*)]
                       (wrap (#;Right [new-state [*state* new-state]])))
-                    (do Monad<Promise>
-                      []
-                      (wrap (#;Left "Can't add negative numbers!")))))
+                    (wrap (#;Left "Can't add negative numbers!"))))
                 ))}
   (with-gensyms [g!message g!error g!return g!error g!output]
     (let [g!state-name (ast;symbol ["" (format _name "//STATE")])
@@ -217,62 +223,62 @@
           g!self (ast;symbol ["" "*self*"])
           g!state (ast;symbol ["" "*state*"])
           g!cause (ast;symbol ["" "*cause*"])
-          g!stop-body (default (` (:: promise;Monad<Promise> (~' wrap) [])) ?stop)
+          g!stop-body (default (` (:: P;Monad<Promise> (~' wrap) [])) ?stop)
           protocol (List/map (lambda [(^slots [#name #vars #args #return #body])]
-                               (` ((~ (ast;tag ["" name])) [(~@ (List/map product;right args))] (promise;Promise (~ return)))))
+                               (` ((~ (ast;tag ["" name])) [(~@ (List/map product;right args))] (P;Promise (~ return)))))
                              methods)
           protocol-pm (List/map (: (-> Method [AST AST])
                                    (lambda [(^slots [#name #vars #args #return #body])]
                                      (let [arg-names (|> (list;size args) (list;n.range +1) (List/map (|>. Nat/encode [""] ast;symbol)))
-                                           body-func (` (: (-> (~ g!state-name) (~@ (List/map product;right args)) (promise;Promise (Error [(~ g!state-name) (~ return)])))
+                                           body-func (` (: (-> (~ g!state-name) (~@ (List/map product;right args)) (P;Promise (Error [(~ g!state-name) (~ return)])))
                                                            (lambda (~ (ast;symbol ["" _name])) [(~ g!state) (~@ (List/map (|>. product;left [""] ast;symbol) args))]
-                                                             (do promise;Monad<Promise>
+                                                             (do P;Monad<Promise>
                                                                []
                                                                (~ body)))))]
                                        [(` [[(~@ arg-names)] (~ g!return)])
-                                        (` (do promise;Monad<Promise>
+                                        (` (do P;Monad<Promise>
                                              [(~ g!output) ((~ body-func) (~ g!state) (~@ arg-names))]
                                              (case (~ g!output)
                                                (#;Right [(~ g!state) (~ g!output)])
-                                               (exec (io;run (promise;resolve (~ g!output) (~ g!return)))
+                                               (exec (io;run (P;resolve (~ g!output) (~ g!return)))
                                                  ((~' wrap) (#;Right (~ g!state))))
 
                                                (#;Left (~ g!error))
                                                ((~' wrap) (#;Left (~ g!error))))
                                              ))])))
                                 methods)
-          g!proc (` {#step (lambda [(~ g!self) (~ g!message) (~ g!state)]
-                             (case (~ g!message)
-                               (~@ (if (n.= +1 (list;size protocol-pm))
-                                     (List/join (List/map (lambda [[pattern clause]]
-                                                            (list pattern clause))
-                                                          protocol-pm))
-                                     (List/join (List/map (lambda [[method [pattern clause]]]
-                                                            (list (` ((~ (ast;tag ["" (get@ #name method)])) (~ pattern)))
-                                                                  clause))
-                                                          (list;zip2 methods protocol-pm)))))
-                               ))
-                     #end (lambda [(~ g!cause) (~ g!state)]
-                            (do promise;Monad<Promise>
-                              []
-                              (~ g!stop-body)))})
+          g!behavior (` {#step (lambda [(~ g!self) (~ g!message) (~ g!state)]
+                                 (case (~ g!message)
+                                   (~@ (if (n.= +1 (list;size protocol-pm))
+                                         (List/join (List/map (lambda [[pattern clause]]
+                                                                (list pattern clause))
+                                                              protocol-pm))
+                                         (List/join (List/map (lambda [[method [pattern clause]]]
+                                                                (list (` ((~ (ast;tag ["" (get@ #name method)])) (~ pattern)))
+                                                                      clause))
+                                                              (list;zip2 methods protocol-pm)))))
+                                   ))
+                         #end (lambda [(~ g!cause) (~ g!state)]
+                                (do P;Monad<Promise>
+                                  []
+                                  (~ g!stop-body)))})
           g!actor-name (ast;symbol ["" _name])
           g!methods (List/map (: (-> Method AST)
                                  (lambda [(^slots [#name #vars #args #return #body])]
                                    (let [arg-names (|> (list;size args) (list;n.range +1) (List/map (|>. Nat/encode [""] ast;symbol)))
                                          type (` (-> (~@ (List/map product;right args))
                                                      (~ g!actor-name)
-                                                     (promise;Promise (~ return))))]
+                                                     (P;Promise (~ return))))]
                                      (` (def: (~@ (common;gen-export-level _ex-lev)) ((~ (ast;symbol ["" name])) (~@ arg-names) (~ g!self))
                                           (~ type)
-                                          (let [(~ g!output) (promise;promise (~ return))]
+                                          (let [(~ g!output) (P;promise (~ return))]
                                             (exec (send ((~ (ast;tag ["" name])) [[(~@ arg-names)] (~ g!output)]) (~ g!self))
                                               (~ g!output))))))))
                               methods)]
       (wrap (list& (` (type: (~@ (common;gen-export-level _ex-lev)) (~ g!state-name) (~ state-type)))
                    (` (type: (~@ (common;gen-export-level _ex-lev)) (~ g!protocol-name) (~@ protocol)))
                    (` (type: (~@ (common;gen-export-level _ex-lev)) (~ g!actor-name) (Actor (~ g!state-name) (~ g!protocol-name))))
-                   (` (def: (~@ (common;gen-export-level _ex-lev)) (~@ (actor-def-decl decl (` (Proc (~ g!state-name) (~ g!protocol-name)))))
-                        (~ g!proc)))
+                   (` (def: (~@ (common;gen-export-level _ex-lev)) (~@ (actor-def-decl decl (` (Behavior (~ g!state-name) (~ g!protocol-name)))))
+                        (~ g!behavior)))
                    g!methods))
       )))
diff --git a/stdlib/source/lux/concurrency/atom.lux b/stdlib/source/lux/concurrency/atom.lux
index 3905ee7ca..3b4687931 100644
--- a/stdlib/source/lux/concurrency/atom.lux
+++ b/stdlib/source/lux/concurrency/atom.lux
@@ -6,8 +6,7 @@
 (;module:
   lux
   (lux (codata [io #- run])
-       host)
-  )
+       host))
 
 (jvm-import (java.util.concurrent.atomic.AtomicReference V)
   (new [V])
@@ -15,6 +14,7 @@
   (get [] V))
 
 (type: #export (Atom a)
+  {#;doc "Atomic references that are safe to mutate concurrently."}
   (AtomicReference a))
 
 (def: #export (atom value)
@@ -25,11 +25,19 @@
   (All [a] (-> (Atom a) (IO a)))
   (io (AtomicReference.get [] atom)))
 
-(def: #export (compare-and-swap old new atom)
+(def: #export (compare-and-swap current new atom)
+  {#;doc "Only mutates an atom if you can present it's current value.
+
+          That guarantees that actor wasn't updated since you last read from it."}
   (All [a] (-> a a (Atom a) (IO Bool)))
-  (io (AtomicReference.compareAndSet [old new] atom)))
+  (io (AtomicReference.compareAndSet [current new] atom)))
 
 (def: #export (update f atom)
+  {#;doc "Updates an atom by applying a function to its current value.
+
+          If it fails to update it (because some other process wrote to it first), it will retry until it succeeds.
+
+          The retries will be done with the new values of the atom, as they show up."}
   (All [a] (-> (-> a a) (Atom a) (IO Unit)))
   (io (let [old (AtomicReference.get [] atom)]
         (if (AtomicReference.compareAndSet [old (f old)] atom)
diff --git a/stdlib/source/lux/concurrency/frp.lux b/stdlib/source/lux/concurrency/frp.lux
index 3a8e62fbb..1620618d5 100644
--- a/stdlib/source/lux/concurrency/frp.lux
+++ b/stdlib/source/lux/concurrency/frp.lux
@@ -19,12 +19,18 @@
 
 ## [Types]
 (type: #export (Chan a)
+  {#;doc "An asynchronous channel of values which may be closed.
+
+          Reading from a channel does not remove the read piece of data, as it can still be accessed if you have an earlier node of the channel."}
   (&;Promise (Maybe [a (Chan a)])))
 
 ## [Syntax]
 (syntax: #export (chan [?type (s;opt s;any)])
   {#;doc (doc "Makes an uninitialized Chan (in this case, of Unit)."
-               (chan Unit))}
+              (chan Unit)
+
+              "The type is optional."
+              (chan))}
   (case ?type
     (#;Some type)
     (wrap (list (` (: (Chan (~ type))
@@ -45,16 +51,17 @@
                          (filter p xs')))))
 
 (def: #export (write value chan)
+  {#;doc "Write to a channel, so long as it's still open."}
   (All [a] (-> a (Chan a) (IO (Maybe (Chan a)))))
   (case (&;poll chan)
     (^template [<case> <chan-to-write>]
-     <case>
-     (do Monad<IO>
-       [#let [new-tail (&;promise)]
-        done? (&;resolve (#;Some [value new-tail]) <chan-to-write>)]
-       (if done?
-         (wrap (#;Some new-tail))
-         (write value <chan-to-write>))))
+      <case>
+      (do Monad<IO>
+        [#let [new-tail (&;promise)]
+         done? (&;resolve (#;Some [value new-tail]) <chan-to-write>)]
+        (if done?
+          (wrap (#;Some new-tail))
+          (write value <chan-to-write>))))
     ([#;None                      chan]
      [(#;Some (#;Some [_ chan'])) chan'])
 
@@ -66,12 +73,12 @@
   (All [a] (-> (Chan a) (IO Bool)))
   (case (&;poll chan)
     (^template [<case> <chan-to-write>]
-     <case>
-     (do Monad<IO>
-       [done? (&;resolve #;None <chan-to-write>)]
-       (if done?
-         (wrap true)
-         (close <chan-to-write>))))
+      <case>
+      (do Monad<IO>
+        [done? (&;resolve #;None <chan-to-write>)]
+        (if done?
+          (wrap true)
+          (close <chan-to-write>))))
     ([#;None                      chan]
      [(#;Some (#;Some [_ chan'])) chan'])
 
@@ -93,6 +100,7 @@
                             (pipe' input' output')))))
 
 (def: #export (pipe input output)
+  {#;doc "Copy/pipe the contents of a channel on to another."}
   (All [a] (-> (Chan a) (Chan a) (&;Promise Unit)))
   (do &;Monad<Promise>
     [_ (pipe' input output)]
@@ -100,6 +108,7 @@
       (wrap []))))
 
 (def: #export (merge xss)
+  {#;doc "Fuse all the elements in a list of channels by piping them onto a new output channel."}
   (All [a] (-> (List (Chan a)) (Chan a)))
   (let [output (chan ($ +0))]
     (exec (do &;Monad<Promise>
@@ -109,6 +118,7 @@
       output)))
 
 (def: #export (fold f init xs)
+  {#;doc "Asynchronous fold over channels."}
   (All [a b] (-> (-> b a (&;Promise a)) a (Chan b) (&;Promise a)))
   (do &;Monad<Promise>
     [?x+xs xs]
@@ -140,6 +150,7 @@
         (#;Some [x xs']) (wrap (#;Some [x (no-dups' eq x xs')]))))))
 
 (def: #export (consume xs)
+  {#;doc "Reads the entirety of a channel's contents and returns them as a list."}
   (All [a] (-> (Chan a) (&;Promise (List a))))
   (do &;Monad<Promise>
     [?x+xs' xs]
@@ -152,10 +163,10 @@
         [=xs (consume xs')]
         (wrap (#;Cons x =xs))))))
 
-(def: #export (as-chan !x)
+(def: #export (as-chan p)
   (All [a] (-> (&;Promise a) (Chan a)))
   (do &;Monad<Promise>
-    [x !x]
+    [x p]
     (wrap (#;Some [x (wrap #;None)]))))
 
 ## [Structures]
diff --git a/stdlib/source/lux/concurrency/promise.lux b/stdlib/source/lux/concurrency/promise.lux
index 5eb95d0bb..1d33ee4ee 100644
--- a/stdlib/source/lux/concurrency/promise.lux
+++ b/stdlib/source/lux/concurrency/promise.lux
@@ -64,7 +64,7 @@
    #observers (List (-> a (IO Unit)))})
 
 (type: #export (Promise a)
-  {#;doc "Represents values produced by promisehronous computations (unlike IO, which is synchronous)."}
+  {#;doc "Represents values produced by asynchronous computations (unlike IO, which is synchronous)."}
   (Atom (Promise-State a)))
 
 (def: #hidden (promise' ?value)
@@ -74,7 +74,10 @@
 
 (syntax: #export (promise [?type (s;opt s;any)])
   {#;doc (doc "Makes an uninitialized Promise (in this example, of Unit)."
-              (promise Unit))}
+              (promise Unit)
+
+              "The type is optional."
+              (promise))}
   (case ?type
     (#;Some type)
     (wrap (list (` (: (Promise (~ type))
@@ -207,7 +210,7 @@
         left||right))))
 
 (def: #export (future computation)
-  {#;doc "Runs computation on it's own process and returns an Promise that will eventually host it's result."}
+  {#;doc "Runs an I/O computation on its own process and returns an Promise that will eventually host its result."}
   (All [a] (-> (IO a) (Promise a)))
   (let [!out (promise ($ +0))]
     (exec (Thread.start [] (Thread.new [(runnable (io;run (resolve (io;run computation)
@@ -215,6 +218,7 @@
       !out)))
 
 (def: #export (wait time)
+  {#;doc "Returns a Promise that will be resolved after the specified amount of milliseconds."}
   (-> Nat (Promise Unit))
   (let [!out (promise Unit)]
     (exec (ScheduledThreadPoolExecutor.schedule [(runnable (io;run (resolve [] !out)))
@@ -224,6 +228,7 @@
       !out)))
 
 (def: #export (time-out time promise)
+  {#;doc "Wait for a Promise to be resolved within the specified amount of milliseconds."}
   (All [a] (-> Nat (Promise a) (Promise (Maybe a))))
   (alt (wait time) promise))
 
diff --git a/stdlib/source/lux/concurrency/stm.lux b/stdlib/source/lux/concurrency/stm.lux
index b9f337024..06912a25a 100644
--- a/stdlib/source/lux/concurrency/stm.lux
+++ b/stdlib/source/lux/concurrency/stm.lux
@@ -30,6 +30,7 @@
    #observers (Dict Text (-> a (IO Unit)))})
 
 (type: #export (Var a)
+  {#;doc "A mutable cell containing a value, and observers that will be alerted of any change to it."}
   (Atom (Var-State a)))
 
 (type: (Tx-Frame a)
@@ -41,9 +42,11 @@
   (List (Ex [a] (Tx-Frame a))))
 
 (type: #export (STM a)
+  {#;doc "A computation which updates a transaction and produces a value."}
   (-> Tx [Tx a]))
 
 (def: #export (var value)
+  {#;doc "Creates a new STM var, with a default value."}
   (All [a] (-> a (Var a)))
   (atom;atom {#value value
               #observers (dict;new text;Hash<Text>)}))
@@ -128,6 +131,9 @@
       (write! new-value var))))
 
 (def: #export (unfollow label target)
+  {#;doc "Stop tracking the changes to a Var.
+
+          Caveat emptor: It won't close any Chan that used to track the changes."}
   (All [a] (-> Text (Var a) (IO Unit)))
   (do Monad<IO>
     [[value observers] (atom;get target)]
@@ -135,7 +141,7 @@
               target)))
 
 (def: #export (follow label target)
-  {#;doc "Creates a channel (identified by a given text) that will receive all changes to the value of the given var."}
+  {#;doc "Creates a channel (identified by a label) that will receive all changes to the value of the given var."}
   (All [a] (-> Text (Var a) (IO (frp;Chan a))))
   (let [head (frp;chan ($ +0))
         chan-var (var head)
@@ -181,17 +187,19 @@
         (ma tx')))))
 
 (def: #export (update! f var)
-  (All [a] (-> (-> a a) (Var a) (Promise [a a])))
-  (P;future (io (loop [_ []]
-                  (let [(^@ state [value observers]) (io;run (atom;get var))
-                        value' (f value)]
-                    (if (io;run (atom;compare-and-swap state
-                                                       [value' observers]
-                                                       var))
-                      [value value']
-                      (recur [])))))))
+  {#;doc "Will update a Var's value, and return a tuple with the old and the new values."}
+  (All [a] (-> (-> a a) (Var a) (IO [a a])))
+  (io (loop [_ []]
+        (let [(^@ state [value observers]) (io;run (atom;get var))
+              value' (f value)]
+          (if (io;run (atom;compare-and-swap state
+                                             [value' observers]
+                                             var))
+            [value value']
+            (recur []))))))
 
 (def: #export (update f var)
+  {#;doc "Will update a Var's value, and return a tuple with the old and the new values."}
   (All [a] (-> (-> a a) (Var a) (STM [a a])))
   (do Monad<STM>
     [a (read var)
diff --git a/stdlib/source/lux/control/applicative.lux b/stdlib/source/lux/control/applicative.lux
index 5d4cad0c0..63ed1bc00 100644
--- a/stdlib/source/lux/control/applicative.lux
+++ b/stdlib/source/lux/control/applicative.lux
@@ -8,6 +8,7 @@
   (.. ["F" functor]))
 
 (sig: #export (Applicative f)
+  {#;doc "Applicative functors."}
   (: (F;Functor f)
      functor)
   (: (All [a]
@@ -17,17 +18,18 @@
        (-> (f (-> a b)) (f a) (f b)))
      apply))
 
-(def: #export (compA Applicative<F> Applicative<G>)
+(struct: #export (compA Applicative<F> Applicative<G>)
+  {#;doc "Applicative functor composition."}
   (All [F G] (-> (Applicative F) (Applicative G) (Applicative (All [a] (F (G a))))))
-  (struct (def: functor (F;compF (get@ #functor Applicative<F>)
-                                 (get@ #functor Applicative<G>)))
-          (def: wrap
-            (|>. (:: Applicative<G> wrap) (:: Applicative<F> wrap)))
-          (def: (apply fgf fgx)
-            (let [applyF (:: Applicative<F> apply)
-                  applyG (:: Applicative<G> apply)]
-              ($_ applyF
-                  (:: Applicative<F> wrap applyG)
-                  fgf
-                  fgx)))
-          ))
+  (def: functor (F;compF (get@ #functor Applicative<F>)
+                         (get@ #functor Applicative<G>)))
+  (def: wrap
+    (|>. (:: Applicative<G> wrap) (:: Applicative<F> wrap)))
+  (def: (apply fgf fgx)
+    (let [applyF (:: Applicative<F> apply)
+          applyG (:: Applicative<G> apply)]
+      ($_ applyF
+          (:: Applicative<F> wrap applyG)
+          fgf
+          fgx)))
+  )
diff --git a/stdlib/source/lux/control/bounded.lux b/stdlib/source/lux/control/bounded.lux
index 291c4d8b6..a81135261 100644
--- a/stdlib/source/lux/control/bounded.lux
+++ b/stdlib/source/lux/control/bounded.lux
@@ -7,6 +7,7 @@
 
 ## Signatures
 (sig: #export (Bounded a)
+  {#;doc "A representation of top and bottom boundaries for an ordered type."}
   (: a
      top)
 
diff --git a/stdlib/source/lux/control/codec.lux b/stdlib/source/lux/control/codec.lux
index e9833ccc9..97fa8c4de 100644
--- a/stdlib/source/lux/control/codec.lux
+++ b/stdlib/source/lux/control/codec.lux
@@ -10,19 +10,20 @@
 
 ## [Signatures]
 (sig: #export (Codec m a)
+  {#;doc "A way to move back-and-forth between a type and an alternative representation for it."}
   (: (-> a m)
      encode)
   (: (-> m (Error a))
      decode))
 
 ## [Values]
-(def: #export (<.> (^open "bc:") (^open "ab:"))
+(struct: #export (compC Codec<c,b> Codec<b,a>)
+  {#;doc "Codec composition."}
   (All [a b c] (-> (Codec c b) (Codec b a) (Codec c a)))
-  (struct
-    (def: encode (|>. ab:encode bc:encode))
+  (def: encode (|>. (:: Codec<b,a> encode) (:: Codec<c,b> encode)))
 
-    (def: (decode cy)
-      (do Monad<Error>
-        [by (bc:decode cy)]
-        (ab:decode by)))
-    ))
+  (def: (decode cy)
+    (do Monad<Error>
+      [by (:: Codec<c,b> decode cy)]
+      (:: Codec<b,a> decode by)))
+  )
diff --git a/stdlib/source/lux/control/comonad.lux b/stdlib/source/lux/control/comonad.lux
index 420771d23..046511190 100644
--- a/stdlib/source/lux/control/comonad.lux
+++ b/stdlib/source/lux/control/comonad.lux
@@ -10,6 +10,9 @@
 
 ## [Signatures]
 (sig: #export (CoMonad w)
+  {#;doc "CoMonads are the opposite/complement to monads.
+
+          CoMonadic structures are often infinite in size and built upon lazily-evaluated functions."}
   (: (F;Functor w)
      functor)
   (: (All [a]
diff --git a/stdlib/source/lux/control/effect.lux b/stdlib/source/lux/control/effect.lux
index 6643acd26..ede2f9d8f 100644
--- a/stdlib/source/lux/control/effect.lux
+++ b/stdlib/source/lux/control/effect.lux
@@ -3,7 +3,8 @@
 ##  If a copy of the MPL was not distributed with this file,
 ##  You can obtain one at http://mozilla.org/MPL/2.0/.
 
-(;module: lux
+(;module: {#;doc "Algebraic effects."}
+  lux
   (lux (control ["F" functor]
                 applicative
                 monad)
@@ -12,7 +13,8 @@
              [number "Nat/" Codec<Text,Nat>]
              text/format
              error
-             [ident "Ident/" Eq<Ident>])
+             [ident "Ident/" Eq<Ident>]
+             [text])
        [compiler]
        [macro]
        (macro [ast]
@@ -22,10 +24,12 @@
 
 ## [Type]
 (type: #export (Eff F a)
+  {#;doc "A Free Monad implementation for algebraic effects."}
   (#Pure a)
   (#Effect (F (Eff F a))))
 
 (sig: #export (Handler E M)
+  {#;doc "A way to interpret effects into arbitrary monads."}
   (: (Monad M)
      monad)
   (: (All [a] (-> (E a) (M a)))
@@ -85,10 +89,10 @@
                    fefa))
       )))
 
-(type: #export (|@ L R)
+(type: #hidden (|@ L R)
   (All [a] (| (L a) (R a))))
 
-(def: #export (combine-functors left right)
+(def: #hidden (combine-functors left right)
   (All [L R]
     (-> (F;Functor L) (F;Functor R)
         (F;Functor (|@ L R))))
@@ -99,7 +103,7 @@
        (+1 r) (+1 (:: right map f r)))
      )))
 
-(def: #export (combine-handlers Monad<M> left right)
+(def: #hidden (combine-handlers Monad<M> left right)
   (All [L R M]
     (-> (Monad M)
         (Handler L M) (Handler R M)
@@ -115,12 +119,23 @@
 
 ## [Syntax]
 (syntax: #export (|E [effects (s;many s;any)])
+  {#;doc (doc "A way to combine smaller effect into a larger effect."
+              (type: EffABC (|E EffA EffB EffC)))}
   (wrap (list (` ($_ ;;|@ (~@ effects))))))
 
 (syntax: #export (|F [functors (s;many s;any)])
+  {#;doc (doc "A way to combine smaller effect functors into a larger functor."
+              (def: Functor<EffABC>
+                (Functor EffABC)
+                (|F Functor<EffA> Functor<EffB> Functor<EffC>)))}
   (wrap (list (` ($_ ;;combine-functors (~@ functors))))))
 
 (syntax: #export (|H monad [handlers (s;many s;any)])
+  {#;doc (doc "A way to combine smaller effect handlers into a larger handler."
+              (def: Handler<EffABC,IO>
+                (Handler EffABC io;IO)
+                (|H io;Monad<IO>
+                    Handler<EffA,IO> Handler<EffB,IO> Handler<EffC,IO>)))}
   (do @
     [g!combiner (compiler;gensym "")]
     (wrap (list (` (let [(~ g!combiner) (;;combine-handlers (~ monad))]
@@ -145,6 +160,13 @@
 (syntax: #export (effect: [exp-lvl common;export-level]
                    [name s;local-symbol]
                    [ops (s;many op^)])
+  {#;doc (doc "Define effects by specifying which operations and constants a handler must provide."
+              (effect: #export EffA
+                (opA [Nat Text] Bool)
+                (fieldA Nat))
+
+              "In this case, 'opA' will be a function (-> Nat Text Bool)."
+              "'fieldA' will be a value provided by a handler.")}
   (do @
     [g!output (compiler;gensym "g!output")
      #let [op-types (List/map (lambda [op]
@@ -204,6 +226,15 @@
                    [name s;local-symbol]
                    [[effect target-type target-monad] translation^]
                    [defs (s;many (common;def *compiler*))])
+  {#;doc (doc "Define effect handlers by implementing the operations and values of an effect."
+              (handler: _
+                (=> EffA [io;IO io;Monad<IO>])
+                (def: (opA size sample)
+                  (:: io;Monad<IO> wrap (n.< size (text;size sample))))
+
+                (def: fieldA (:: io;Monad<IO> wrap +10)))
+
+              "Since a name for the handler was not specified, 'handler:' will generate the name as Handler<EffA,IO>.")}
   (do @
     [(^@ effect [e-module _]) (compiler;un-alias effect)
      g!input (compiler;gensym "g!input")
@@ -244,6 +275,7 @@
                        )))))))
 
 (def: #export (with-handler handler body)
+  {#;doc "Handles an effectful computation with the given handler to produce a monadic value."}
   (All [E M a] (-> (Handler E M) (Eff E a) (M a)))
   (case body
     (#Pure value)
@@ -276,6 +308,13 @@
 (def: g!functor AST (ast;symbol ["" "\t@E\t"]))
 
 (syntax: #export (doE functor [bindings (s;tuple (s;some s;any))] body)
+  {#;doc (doc "An alternative to the 'do' macro for monads."
+              (io;run (with-handler Handler<EffABC,IO>
+                        (doE Functor<EffABC>
+                          [a (lift fieldA)
+                           b (lift fieldB)
+                           c (lift fieldC)]
+                          (wrap ($_ n.+ a b c))))))}
   (do @
     [g!output (compiler;gensym "")]
     (wrap (list (` (let [(~ g!functor) (~ functor)]
@@ -330,6 +369,13 @@
 
 (syntax: #export (lift [value (s;alt s;symbol
                                      s;any)])
+  {#;doc (doc "A way to (automatically) lift effectful fields and operations from simple effects into the larger space of composite effects."
+              (io;run (with-handler Handler<EffABC,IO>
+                        (doE Functor<EffABC>
+                          [a (lift fieldA)
+                           b (lift fieldB)
+                           c (lift fieldC)]
+                          (wrap ($_ n.+ a b c))))))}
   (case value
     (#;Left var)
     (do @
diff --git a/stdlib/source/lux/control/enum.lux b/stdlib/source/lux/control/enum.lux
index 63c041f95..a6c377fab 100644
--- a/stdlib/source/lux/control/enum.lux
+++ b/stdlib/source/lux/control/enum.lux
@@ -8,6 +8,7 @@
 
 ## [Signatures]
 (sig: #export (Enum e)
+  {#;doc "Enumerable types, with a notion of moving forward and backwards through a type's instances."}
   (: (ord;Ord e) ord)
   (: (-> e e) succ)
   (: (-> e e) pred))
@@ -20,5 +21,6 @@
     #;Nil))
 
 (def: #export (range (^open) from to)
+  {#;doc "An inclusive [from, to] range of values."}
   (All [a] (-> (Enum a) a a (List a)))
   (range' <= succ from to))
diff --git a/stdlib/source/lux/control/eq.lux b/stdlib/source/lux/control/eq.lux
index 357780fcd..40f29a446 100644
--- a/stdlib/source/lux/control/eq.lux
+++ b/stdlib/source/lux/control/eq.lux
@@ -6,6 +6,7 @@
 (;module: lux)
 
 (sig: #export (Eq a)
+  {#;doc "Equality for a type's instances."}
   (: (-> a a Bool)
      =))
 
diff --git a/stdlib/source/lux/control/fold.lux b/stdlib/source/lux/control/fold.lux
index 6e56dacee..66f083ac6 100644
--- a/stdlib/source/lux/control/fold.lux
+++ b/stdlib/source/lux/control/fold.lux
@@ -7,6 +7,7 @@
 
 ## [Signatures]
 (sig: #export (Fold F)
+  {#;doc "Iterate over a structure's values to build a summary value."}
   (: (All [a b]
        (-> (-> b a a) a (F b) a))
      fold))
diff --git a/stdlib/source/lux/control/functor.lux b/stdlib/source/lux/control/functor.lux
index 711c5ae16..5c76ba76a 100644
--- a/stdlib/source/lux/control/functor.lux
+++ b/stdlib/source/lux/control/functor.lux
@@ -10,7 +10,8 @@
        (-> (-> a b) (f a) (f b)))
      map))
 
-(def: #export (compF Functor<F> Functor<G>)
+(struct: #export (compF Functor<F> Functor<G>)
+  {#;doc "Functor composition."}
   (All [F G] (-> (Functor F) (Functor G) (Functor (All [a] (F (G a))))))
-  (struct (def: (map f fga)
-            (:: Functor<F> map (:: Functor<G> map f) fga))))
+  (def: (map f fga)
+    (:: Functor<F> map (:: Functor<G> map f) fga)))
diff --git a/stdlib/source/lux/control/hash.lux b/stdlib/source/lux/control/hash.lux
index d8ae926ad..6e222e5d7 100644
--- a/stdlib/source/lux/control/hash.lux
+++ b/stdlib/source/lux/control/hash.lux
@@ -9,6 +9,9 @@
 
 ## [Signatures]
 (sig: #export (Hash a)
+  {#;doc "A way to produce hash-codes for a type's instances.
+
+          A necessity when working with some data-structures, such as dictionaries or sets."}
   (: (Eq a)
      eq)
   (: (-> a Nat)
diff --git a/stdlib/source/lux/control/monad.lux b/stdlib/source/lux/control/monad.lux
index 71a873704..b6c509064 100644
--- a/stdlib/source/lux/control/monad.lux
+++ b/stdlib/source/lux/control/monad.lux
@@ -79,13 +79,13 @@
                       body
                       (reverse (as-pairs bindings)))]
       (#;Right [state (#;Cons (` (;_lux_case (~ monad)
-                                             (~ g!@)
-                                             (;_lux_case (~ g!@)
-                                                         {#applicative {#A;functor {#F;map (~ g!map)}
-                                                                        #A;wrap (~' wrap)
-                                                                        #A;apply (~ g!apply)}
-                                                          #join (~ g!join)}
-                                                         (~ body'))))
+                                   (~ g!@)
+                                   (;_lux_case (~ g!@)
+                                     {#applicative {#A;functor {#F;map (~ g!map)}
+                                                    #A;wrap (~' wrap)
+                                                    #A;apply (~ g!apply)}
+                                      #join (~ g!join)}
+                                     (~ body'))))
                               #;Nil)]))
 
     _
@@ -93,6 +93,7 @@
 
 ## [Functions]
 (def: #export (seqM monad xs)
+  {#;doc "Run all the monadic values in the list and produce a list of the base values."}
   (All [M a]
     (-> (Monad M) (List (M a)) (M (List a))))
   (case xs
@@ -107,6 +108,7 @@
     ))
 
 (def: #export (mapM monad f xs)
+  {#;doc "Apply a monad-producing function to all values in a list."}
   (All [M a b]
     (-> (Monad M) (-> a (M b)) (List a) (M (List b))))
   (case xs
@@ -121,6 +123,7 @@
     ))
 
 (def: #export (foldM monad f init xs)
+  {#;doc "Fold a list with a monad-producing function."}
   (All [M a b]
     (-> (Monad M) (-> b a (M a)) a (List b)
         (M a)))
@@ -134,6 +137,7 @@
       (foldM monad f init' xs'))))
 
 (def: #export (liftM Monad<M> f)
+  {#;doc "Lift a normal function into the space of monads."}
   (All [M a b]
     (-> (Monad M) (-> a b) (-> (M a) (M b))))
   (lambda [ma]
diff --git a/stdlib/source/lux/control/monoid.lux b/stdlib/source/lux/control/monoid.lux
index 67f6d868c..77ef5e1cc 100644
--- a/stdlib/source/lux/control/monoid.lux
+++ b/stdlib/source/lux/control/monoid.lux
@@ -7,6 +7,9 @@
 
 ## Signatures
 (sig: #export (Monoid a)
+  {#;doc "A way to combine (append) values.
+
+          Includes an identity (unit) value which doesn't alter any other value when combined with."}
   (: a
      unit)
   (: (-> a a a)
diff --git a/stdlib/source/lux/control/number.lux b/stdlib/source/lux/control/number.lux
index d6e9a42b6..d017e72d4 100644
--- a/stdlib/source/lux/control/number.lux
+++ b/stdlib/source/lux/control/number.lux
@@ -9,6 +9,8 @@
 
 ## [Signatures]
 (sig: #export (Number n)
+  {#;doc "Everything that should be expected of a number type."}
+  
   (: (ord;Ord n)
      ord)
   
diff --git a/stdlib/source/lux/control/ord.lux b/stdlib/source/lux/control/ord.lux
index 7acc97172..0200d738a 100644
--- a/stdlib/source/lux/control/ord.lux
+++ b/stdlib/source/lux/control/ord.lux
@@ -10,6 +10,8 @@
 
 ## [Signatures]
 (sig: #export (Ord a)
+  {#;doc "A signature for types that possess some sense of ordering among their elements."}
+  
   (: (Eq a)
      eq)
   
diff --git a/stdlib/source/lux/data/error/exception.lux b/stdlib/source/lux/data/error/exception.lux
index 7c6fb5ab6..457a3a092 100644
--- a/stdlib/source/lux/data/error/exception.lux
+++ b/stdlib/source/lux/data/error/exception.lux
@@ -3,7 +3,7 @@
 ##  If a copy of the MPL was not distributed with this file,
 ##  You can obtain one at http://mozilla.org/MPL/2.0/.
 
-(;module:
+(;module: {#;doc "Exception-handling functionality built on top of the Error type."}
   lux
   (lux (control monad)
        (data [error #- fail]
@@ -15,6 +15,7 @@
 
 ## [Types]
 (type: #export Exception
+  {#;doc "An exception provides a way to decorate error messages."}
   (-> Text Text))
 
 ## [Values]
@@ -23,6 +24,9 @@
   (:: text;Monoid<Text> append))
 
 (def: #export (catch exception then try)
+  {#;doc "If a particular exception is detected on a possibly-erroneous value, handle it.
+
+          If no exception was detected, or a different one from the one being checked, then pass along the original value."}
   (All [a]
     (-> Exception (-> Text a) (Error a)
         (Error a)))
@@ -36,6 +40,7 @@
       (#;Left error))))
 
 (def: #export (otherwise to-do try)
+  {#;doc "If no handler could be found to catch the exception, then run a function as a last-resort measure."}
   (All [a]
     (-> (-> Text a) (Error a) a))
   (case try
@@ -46,14 +51,19 @@
     (to-do error)))
 
 (def: #export (return value)
+  {#;doc "A way to lift normal values into the error-handling context."}
   (All [a] (-> a (Error a)))
   (#;Right value))
 
 (def: #export (throw exception message)
+  {#;doc "Decorate an error message with an Exception and lift it into the error-handling context."}
   (All [a] (-> Exception Text (Error a)))
   (#;Left (exception message)))
 
 (syntax: #export (exception: [_ex-lev common;export-level] [name s;local-symbol])
+  {#;doc (doc "Define a new exception type."
+              "It moslty just serves as a way to tag error messages for later catching."
+              (exception: #export Some-Exception))}
   (do @
     [current-module compiler;current-module-name
      #let [g!message (ast;symbol ["" "message"])]]
diff --git a/stdlib/source/lux/data/log.lux b/stdlib/source/lux/data/log.lux
index 687f23478..e8e15d0ad 100644
--- a/stdlib/source/lux/data/log.lux
+++ b/stdlib/source/lux/data/log.lux
@@ -11,6 +11,7 @@
                ["M" monad #*]))
 
 (type: #export (Log l a)
+  {#;doc "Represents a value with an associated 'log' value to record arbitrary information."}
   [l a])
 
 (struct: #export Functor<Log> (All [l]
@@ -40,6 +41,7 @@
       [(:: mon append log1 log2) a])))
 
 (def: #export (log l)
+  {#;doc "Set the log to a particular value."}
   (All [l] (-> l (Log l Unit)))
   [l []])
 
diff --git a/stdlib/source/lux/data/number.lux b/stdlib/source/lux/data/number.lux
index 1a104071f..b2ad1df52 100644
--- a/stdlib/source/lux/data/number.lux
+++ b/stdlib/source/lux/data/number.lux
@@ -3,7 +3,7 @@
 ##  If a copy of the MPL was not distributed with this file,
 ##  You can obtain one at http://mozilla.org/MPL/2.0/.
 
-(;module:
+(;module: {#;doc "Implementations of common structures for Lux's primitive number types."}
   lux
   (lux (control number
                 monoid
@@ -223,21 +223,24 @@
         (bin "11001001"))]
   [Octal@Codec<Text,Nat>  "invokestatic:java.lang.Long:toOctalString:long"  8  oct "Invalid octal syntax."
    (doc "Given syntax for an octal number, generates a Nat."
-        (oct "0615243"))]
+        (oct "615243"))]
   [Hex@Codec<Text,Nat>    "invokestatic:java.lang.Long:toHexString:long"    16 hex "Invalid hexadecimal syntax."
    (doc "Given syntax for a hexadecimal number, generates a Nat."
         (hex "deadBEEF"))]
   )
 
-(do-template [<name> <field>]
-  [(def: #export <name> Real
+(do-template [<name> <field> <doc>]
+  [(def: #export <name>
+     {#;doc <doc>}
+     Real
      (_lux_proc ["jvm" <field>] []))]
 
-  [nan  "getstatic:java.lang.Double:NaN"]
-  [+inf "getstatic:java.lang.Double:POSITIVE_INFINITY"]
-  [-inf "getstatic:java.lang.Double:NEGATIVE_INFINITY"]
+  [nan  "getstatic:java.lang.Double:NaN"               "not-a-number"]
+  [+inf "getstatic:java.lang.Double:POSITIVE_INFINITY" "positive infinity"]
+  [-inf "getstatic:java.lang.Double:NEGATIVE_INFINITY" "negative infinity"]
   )
 
 (def: #export (nan? number)
+  {#;doc "Tests whether a real is actually not-a-number."}
   (-> Real Bool)
   (not (r.= number number)))
diff --git a/stdlib/source/lux/data/product.lux b/stdlib/source/lux/data/product.lux
index f542d7a38..9e5e72538 100644
--- a/stdlib/source/lux/data/product.lux
+++ b/stdlib/source/lux/data/product.lux
@@ -3,7 +3,8 @@
 ##  If a copy of the MPL was not distributed with this file,
 ##  You can obtain one at http://mozilla.org/MPL/2.0/.
 
-(;module: lux)
+(;module: {#;doc "Functionality for working with tuples (particularly 2-tuples)."}
+  lux)
 
 ## [Functions]
 (do-template [<name> <type> <output>]
diff --git a/stdlib/source/lux/data/struct/array.lux b/stdlib/source/lux/data/struct/array.lux
index 3a3c6bfaa..fa52df9f1 100644
--- a/stdlib/source/lux/data/struct/array.lux
+++ b/stdlib/source/lux/data/struct/array.lux
@@ -18,6 +18,7 @@
 
 ## [Types]
 (type: #export (Array a)
+  {#;doc "Mutable arrays."}
   (#;HostT "#Array" (#;Cons a #;Nil)))
 
 ## [Functions]
@@ -161,7 +162,7 @@
                               ))))
 
 ## [Structures]
-(struct: #export (Eq<Array> (^open "a:"))
+(struct: #export (Eq<Array> Eq<a>)
   (All [a] (-> (Eq a) (Eq (Array a))))
   (def: (= xs ys)
     (let [sxs (size xs)
@@ -174,7 +175,7 @@
                                true
 
                                [(#;Some x) (#;Some y)]
-                               (a:= x y)
+                               (:: Eq<a> = x y)
 
                                _
                                false)))
diff --git a/stdlib/source/lux/data/struct/dict.lux b/stdlib/source/lux/data/struct/dict.lux
index 56ab6ca64..3b153d229 100644
--- a/stdlib/source/lux/data/struct/dict.lux
+++ b/stdlib/source/lux/data/struct/dict.lux
@@ -560,17 +560,20 @@
   {#hash Hash<K>
    #root empty})
 
-(def: #export (put key val [Hash<K> node])
+(def: #export (put key val dict)
   (All [K V] (-> K V (Dict K V) (Dict K V)))
-  [Hash<K> (put' root-level (:: Hash<K> hash key) key val Hash<K> node)])
+  (let [[Hash<K> node] dict]
+    [Hash<K> (put' root-level (:: Hash<K> hash key) key val Hash<K> node)]))
 
-(def: #export (remove key [Hash<K> node])
+(def: #export (remove key dict)
   (All [K V] (-> K (Dict K V) (Dict K V)))
-  [Hash<K> (remove' root-level (:: Hash<K> hash key) key Hash<K> node)])
+  (let [[Hash<K> node] dict]
+    [Hash<K> (remove' root-level (:: Hash<K> hash key) key Hash<K> node)]))
 
-(def: #export (get key [Hash<K> node])
+(def: #export (get key dict)
   (All [K V] (-> K (Dict K V) (Maybe V)))
-  (get' root-level (:: Hash<K> hash key) key Hash<K> node))
+  (let [[Hash<K> node] dict]
+    (get' root-level (:: Hash<K> hash key) key Hash<K> node)))
 
 (def: #export (contains? key table)
   (All [K V] (-> K (Dict K V) Bool))
@@ -615,29 +618,35 @@
              kvs))
 
 (do-template [<name> <elem-type> <side>]
-  [(def: #export <name>
+  [(def: #export (<name> dict)
      (All [K V] (-> (Dict K V) (List <elem-type>)))
-     (|>. entries (List/map <side>)))]
+     (|> dict entries (List/map <side>)))]
 
   [keys   K product;left]
   [values V product;right]
   )
 
 (def: #export (merge dict2 dict1)
+  {#;doc "Merges 2 dictionaries.
+
+          If any collisions with keys occur, the values of dict2 will overwrite those of dict1."}
   (All [K V] (-> (Dict K V) (Dict K V) (Dict K V)))
   (List/fold (lambda [[key val] dict] (put key val dict))
              dict1
              (entries dict2)))
 
-(def: #export (merge-with f dict1 dict2)
+(def: #export (merge-with f dict2 dict1)
+  {#;doc "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) (Dict K V) (Dict K V) (Dict K V)))
-  (List/fold (lambda [[key val] dict]
+  (List/fold (lambda [[key val2] dict]
                (case (get key dict)
                  #;None
-                 (put key val dict)
+                 (put key val2 dict)
 
-                 (#;Some val')
-                 (put key (f val' val) dict)))
+                 (#;Some val1)
+                 (put key (f val2 val1) dict)))
              dict1
              (entries dict2)))
 
@@ -652,15 +661,16 @@
         (remove from-key)
         (put to-key val))))
 
-(def: #export (select keys (^@ old-dict [Hash<K> _]))
+(def: #export (select keys dict)
   {#;doc "Creates a sub-set of the given dict, with only the specified keys."}
   (All [K V] (-> (List K) (Dict K V) (Dict K V)))
-  (List/fold (lambda [key new-dict]
-               (case (get key old-dict)
-                 #;None       new-dict
-                 (#;Some val) (put key val new-dict)))
-             (new Hash<K>)
-             keys))
+  (let [[Hash<K> _] dict]
+    (List/fold (lambda [key new-dict]
+                 (case (get key dict)
+                   #;None       new-dict
+                   (#;Some val) (put key val new-dict)))
+               (new Hash<K>)
+               keys)))
 
 ## [Structures]
 (struct: #export (Eq<Dict> Eq<v>) (All [k v] (-> (Eq v) (Eq (Dict k v))))
diff --git a/stdlib/source/lux/data/struct/list.lux b/stdlib/source/lux/data/struct/list.lux
index cd7323669..3228e1d78 100644
--- a/stdlib/source/lux/data/struct/list.lux
+++ b/stdlib/source/lux/data/struct/list.lux
@@ -53,10 +53,14 @@
       (filter p xs'))))
 
 (def: #export (partition p xs)
+  {#;doc "Divide the list into all elements that satisfy a predicate, and all elements that don't."}
   (All [a] (-> (-> a Bool) (List a) [(List a) (List a)]))
   [(filter p xs) (filter (complement p) xs)])
 
 (def: #export (as-pairs xs)
+  {#;doc "Cut the list into pairs of 2.
+
+          Caveat emptor: If the list has an uneven number of elements, the last one will be skipped."}
   (All [a] (-> (List a) (List [a a])))
   (case xs
     (^ (#;Cons [x1 (#;Cons [x2 xs'])]))
@@ -125,12 +129,14 @@
       [ys xs])))
 
 (def: #export (split-with p xs)
+  {#;doc "Segment the list by using a predicate to tell when to cut."}
   (All [a]
     (-> (-> a Bool) (List a) [(List a) (List a)]))
   (let [[ys' xs'] (split-with' p #;Nil xs)]
     [(reverse ys') xs']))
 
 (def: #export (split-all n xs)
+  {#;doc "Segment the list in chunks of size n."}
   (All [a] (-> Nat (List a) (List (List a))))
   (case xs
     #;Nil
@@ -141,6 +147,7 @@
       (#;Cons pre (split-all n post)))))
 
 (def: #export (repeat n x)
+  {#;doc "A list of the value x, repeated n times."}
   (All [a]
     (-> Nat a (List a)))
   (if (n.> +0 n)
@@ -158,6 +165,7 @@
     (list)))
 
 (def: #export (iterate 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)
@@ -168,6 +176,7 @@
     (list x)))
 
 (def: #export (find p xs)
+  {#;doc "Returns the first value in the list for which the predicate is true."}
   (All [a]
     (-> (-> a Bool) (List a) (Maybe a)))
   (case xs
@@ -180,6 +189,7 @@
       (find p xs'))))
 
 (def: #export (interpose sep xs)
+  {#;doc "Puts a value between every two elements in the list."}
   (All [a]
     (-> a (List a) (List a)))
   (case xs
@@ -206,6 +216,7 @@
   [any?   false or])
 
 (def: #export (at i xs)
+  {#;doc "Fetches the element at the specified index."}
   (All [a]
     (-> Nat (List a) (Maybe a)))
   (case xs
@@ -218,7 +229,7 @@
       (at (n.dec i) xs'))))
 
 ## [Structures]
-(struct: #export (Eq<List> (^open "a:"))
+(struct: #export (Eq<List> Eq<a>)
   (All [a] (-> (Eq a) (Eq (List a))))
   (def: (= xs ys)
     (case [xs ys]
@@ -226,7 +237,7 @@
       true
 
       [(#;Cons x xs') (#;Cons y ys')]
-      (and (a:= x y)
+      (and (:: Eq<a> = x y)
            (= xs' ys'))
 
       [_ _]
@@ -288,12 +299,13 @@
 
 (do-template [<name> <type> <comp> <inc>]
   [(def: #export (<name> from to)
+     {#;doc "Generates an inclusive interval of values [from, to]."}
      (-> <type> <type> (List <type>))
      (if (<comp> to from)
        (list& from (<name> (<inc> from) to))
        (list)))]
 
-  [i.range Int i.<=  i.inc]
+  [i.range Int i.<= i.inc]
   [n.range Nat n.<= n.inc]
   )
 
@@ -310,8 +322,9 @@
     (#;Cons x' xs') (or (:: eq = x x')
                         (member? eq xs' x))))
 
-(do-template [<name> <output> <side>]
+(do-template [<name> <output> <side> <doc>]
   [(def: #export (<name> xs)
+     {#;doc <doc>}
      (All [a] (-> (List a) (Maybe <output>)))
      (case xs
        #;Nil
@@ -320,8 +333,8 @@
        (#;Cons x xs')
        (#;Some <side>)))]
 
-  [head a        x]
-  [tail (List a) xs']
+  [head a        x   "Returns the first element of a list."]
+  [tail (List a) xs' "For a list of size N, returns the N-1 elements after the first one."]
   )
 
 ## [Syntax]
@@ -373,7 +386,7 @@
 (def: #export zip3 (zip 3))
 
 (macro: #export (zip-with tokens state)
-  {#;doc (doc "Create list zip-with`s with the specified number of input lists."
+  {#;doc (doc "Create list zippers with the specified number of input lists."
               (def: #export zip2-with (zip-with 2))
               (def: #export zip3-with (zip-with 3))
               ((zip-with 2) i.+ xs ys))}
@@ -431,6 +444,9 @@
     (last xs')))
 
 (def: #export (inits xs)
+  {#;doc "For a list of size N, returns the first N-1 elements.
+
+          Empty lists will result in a #;None value being returned instead."}
   (All [a] (-> (List a) (Maybe (List a))))
   (case xs
     #;Nil
@@ -476,6 +492,7 @@
     (#;Cons [idx x] (enumerate' (n.inc idx) xs'))))
 
 (def: #export (enumerate xs)
+  {#;doc "Pairs every element in the list with it's index, starting at 0."}
   (All [a] (-> (List a) (List [Nat a])))
   (enumerate' +0 xs))
 
diff --git a/stdlib/source/lux/data/struct/queue.lux b/stdlib/source/lux/data/struct/queue.lux
index e22f0bb81..1c7fcdc3e 100644
--- a/stdlib/source/lux/data/struct/queue.lux
+++ b/stdlib/source/lux/data/struct/queue.lux
@@ -43,13 +43,13 @@
   (All [a] (-> (Queue a) Bool))
   (|>. (get@ [#front]) list;empty?))
 
-(def: #export (enqueued? a/Eq queue member)
+(def: #export (member? a/Eq queue member)
   (All [a] (-> (Eq a) (Queue a) a Bool))
   (let [(^slots [#front #rear]) queue]
     (or (list;member? a/Eq front member)
         (list;member? a/Eq rear member))))
 
-(def: #export (dequeue queue)
+(def: #export (pop queue)
   (All [a] (-> (Queue a) (Queue a)))
   (case (get@ #front queue)
     (^ (list)) ## Empty...
@@ -64,7 +64,7 @@
     (|> queue
         (set@ #front front'))))
 
-(def: #export (enqueue val queue)
+(def: #export (push val queue)
   (All [a] (-> a (Queue a) (Queue a)))
   (case (get@ #front queue)
     #;Nil
@@ -74,6 +74,7 @@
     (update@ #rear (|>. (#;Cons val)) queue)))
 
 ## [Structures]
-(struct: #export (Eq<Queue> Eq<a>) (All [a] (-> (Eq a) (Eq (Queue a))))
+(struct: #export (Eq<Queue> Eq<a>)
+  (All [a] (-> (Eq a) (Eq (Queue a))))
   (def: (= qx qy)
     (:: (list;Eq<List> Eq<a>) = (to-list qx) (to-list qy))))
diff --git a/stdlib/source/lux/data/struct/tree.lux b/stdlib/source/lux/data/struct/tree.lux
index 8603f5677..8620e46a7 100644
--- a/stdlib/source/lux/data/struct/tree.lux
+++ b/stdlib/source/lux/data/struct/tree.lux
@@ -39,9 +39,15 @@
 
 (def: (tree^ _)
   (-> Unit (Syntax Tree-AST))
-  (s;record (s;seq s;any (s;tuple (s;some (lambda [state] ((tree^ []) state)))))))
+  (s;either (s;record (s;seq s;any (s;tuple (s;some (lambda [state] ((tree^ []) state))))))
+            (s;seq s;any (:: s;Monad<Syntax> wrap (list)))))
 
 (syntax: #export (tree type [root (tree^ [])])
+  {#;doc (doc "Tree literals."
+              (tree Int 10)
+              (tree Int {10 [20
+                             {30 []}
+                             40]}))}
   (wrap (list (` (: (Tree (~ type))
                     (~ (loop [[value children] root]
                          (` {#value (~ value)
diff --git a/stdlib/source/lux/data/struct/vector.lux b/stdlib/source/lux/data/struct/vector.lux
index fbe3dbd97..e1640a0f0 100644
--- a/stdlib/source/lux/data/struct/vector.lux
+++ b/stdlib/source/lux/data/struct/vector.lux
@@ -349,6 +349,8 @@
 
 ## [Syntax]
 (syntax: #export (vector [elems (s;some s;any)])
+  {#;doc (doc "Vector literals."
+              (vector 10 20 30 40))}
   (wrap (list (` (from-list (list (~@ elems)))))))
 
 ## [Structures]
diff --git a/stdlib/source/lux/data/struct/zipper.lux b/stdlib/source/lux/data/struct/zipper.lux
index ddd8ae703..2a447a65b 100644
--- a/stdlib/source/lux/data/struct/zipper.lux
+++ b/stdlib/source/lux/data/struct/zipper.lux
@@ -16,6 +16,7 @@
 
 ## [Types]
 (type: #export (Zipper a)
+  {#;doc "Tree zippers, for easy navigation and editing over trees."}
   {#parent (Maybe (Zipper a))
    #lefts (Stack (Tree a))
    #rights (Stack (Tree a))
diff --git a/stdlib/source/lux/data/sum.lux b/stdlib/source/lux/data/sum.lux
index f01d88727..5cc9606b2 100644
--- a/stdlib/source/lux/data/sum.lux
+++ b/stdlib/source/lux/data/sum.lux
@@ -3,7 +3,8 @@
 ##  If a copy of the MPL was not distributed with this file,
 ##  You can obtain one at http://mozilla.org/MPL/2.0/.
 
-(;module: lux)
+(;module: {#;doc "Functionality for working with variants (particularly 2-variants)."}
+  lux)
 
 ## [Values]
 (do-template [<name> <type> <index>]
diff --git a/stdlib/source/lux/data/text.lux b/stdlib/source/lux/data/text.lux
index b1e751861..85d5d9dd5 100644
--- a/stdlib/source/lux/data/text.lux
+++ b/stdlib/source/lux/data/text.lux
@@ -214,10 +214,12 @@
         (wrap ($_ append pre value post))))))
 
 (def: #export (enclose [left right] content)
+  {#;doc "Surrounds the given content text with left and right side additions."}
   (-> [Text Text] Text Text)
   (let [(^open) Monoid<Text>]
     ($_ append left content right)))
 
 (def: #export (enclose' boundary content)
+  {#;doc "Surrounds the given content text with the same boundary text."}
   (-> Text Text Text)
   (enclose [boundary boundary] content))
diff --git a/stdlib/source/lux/data/text/format.lux b/stdlib/source/lux/data/text/format.lux
index fee9c576c..ebcb3fc48 100644
--- a/stdlib/source/lux/data/text/format.lux
+++ b/stdlib/source/lux/data/text/format.lux
@@ -28,7 +28,8 @@
   (wrap (list (` ($_ _append_ (~@ fragments))))))
 
 ## [Formatters]
-(type: (Formatter a)
+(type: #export (Formatter a)
+  {#;doc "A way to produce readable text from values."}
   (-> a Text))
 
 (do-template [<name> <type> <formatter>]
diff --git a/stdlib/source/lux/host.lux b/stdlib/source/lux/host.lux
index 69148bbd2..75ad3a1c5 100644
--- a/stdlib/source/lux/host.lux
+++ b/stdlib/source/lux/host.lux
@@ -1414,6 +1414,9 @@
                              (s;tuple (s;some (super-class-decl^ imports class-vars))))]
                    [annotations (annotations^ imports)]
                    [members (s;some (method-decl^ imports class-vars))])
+  {#;doc (doc "Allows defining JVM interfaces."
+              (interface: TestInterface
+                ([] foo [boolean String] void #throws [Exception])))}
   (let [def-code (format "interface:"
                          (spaced (list (class-decl$ class-decl)
                                        (with-brackets (spaced (map super-class-decl$ supers)))
@@ -1536,14 +1539,14 @@
                 (HttpServerRequest.setExpectMultipart [true])
                 (ReadStream.handler [(object [(Handler Buffer)]
                                        []
-                                       ((Handler A) (handle {buffer A}) void
+                                       ((Handler A) (handle [buffer A]) void
                                         (io;run (do Monad<IO>
                                                   [_ (write (Buffer.getBytes [] buffer) body)]
                                                   (wrap []))))
                                        )])
                 (ReadStream.endHandler [[(object [(Handler Void)]
                                            []
-                                           ((Handler A) (handle {_ A}) void
+                                           ((Handler A) (handle [_ A]) void
                                             (exec (do Monad<Promise>
                                                     [#let [_ (io;run (close body))]
                                                      response (handler (request$ vreq body))]
@@ -2157,6 +2160,10 @@
         (get-import name imports)))
 
 (def: #export (resolve-class class)
+  {#;doc (doc "Given a potentially unqualified class name, qualifies it if necessary."
+              (resolve-class "String")
+              =>
+              "java.lang.String")}
   (-> Text (Lux Text))
   (do Monad<Lux>
     [*compiler* get-compiler]
diff --git a/stdlib/source/lux/lexer.lux b/stdlib/source/lux/lexer.lux
index e27e1925a..04e9dfef1 100644
--- a/stdlib/source/lux/lexer.lux
+++ b/stdlib/source/lux/lexer.lux
@@ -85,6 +85,7 @@
     (#;Left message)))
 
 (def: #export any
+  {#;doc "Just returns the next character without applying any logic."}
   (Lexer Char)
   (lambda [input]
     (case [(text;at +0 input) (text;split +1 input)]
@@ -96,6 +97,7 @@
     ))
 
 (def: #export (seq left right)
+  {#;doc "Sequencing combinator."}
   (All [a b] (-> (Lexer a) (Lexer b) (Lexer [a b])))
   (do Monad<Lexer>
     [=left left
@@ -103,6 +105,7 @@
     (wrap [=left =right])))
 
 (def: #export (alt left right)
+  {#;doc "Heterogeneous alternative combinator."}
   (All [a b] (-> (Lexer a) (Lexer b) (Lexer (| a b))))
   (lambda [input]
     (case (left input)
@@ -118,6 +121,7 @@
       (#;Right [input' (+0 output)]))))
 
 (def: #export (not! p)
+  {#;doc "Ensure a lexer fails."}
   (All [a] (-> (Lexer a) (Lexer Unit)))
   (lambda [input]
     (case (p input)
@@ -128,6 +132,7 @@
       (#;Left "Expected to fail; yet succeeded."))))
 
 (def: #export (not p)
+  {#;doc "Produce a character if the lexer fails."}
   (All [a] (-> (Lexer a) (Lexer Char)))
   (lambda [input]
     (case (p input)
@@ -138,6 +143,7 @@
       (#;Left "Expected to fail; yet succeeded."))))
 
 (def: #export (either left right)
+  {#;doc "Homogeneous alternative combinator."}
   (All [a] (-> (Lexer a) (Lexer a) (Lexer a)))
   (lambda [input]
     (case (left input)
@@ -148,6 +154,7 @@
       output)))
 
 (def: #export (assert message test)
+  {#;doc "Fails with the given message if the test is false."}
   (-> Text Bool (Lexer Unit))
   (lambda [input]
     (if test
@@ -155,6 +162,7 @@
       (#;Left message))))
 
 (def: #export (some p)
+  {#;doc "0-or-more combinator."}
   (All [a] (-> (Lexer a) (Lexer (List a))))
   (lambda [input]
     (case (p input)
@@ -169,6 +177,7 @@
     ))
 
 (def: #export (many p)
+  {#;doc "1-or-more combinator."}
   (All [a] (-> (Lexer a) (Lexer (List a))))
   (do Monad<Lexer>
     [x p
@@ -176,6 +185,7 @@
     (wrap (#;Cons x xs))))
 
 (def: #export (exactly n p)
+  {#;doc "Lex exactly N times."}
   (All [a] (-> Nat (Lexer a) (Lexer (List a))))
   (if (n.> +0 n)
     (do Monad<Lexer>
@@ -185,6 +195,7 @@
     (:: Monad<Lexer> wrap (list))))
 
 (def: #export (at-most n p)
+  {#;doc "Lex at most N times."}
   (All [a] (-> Nat (Lexer a) (Lexer (List a))))
   (if (n.> +0 n)
     (lambda [input]
@@ -201,6 +212,7 @@
     (:: Monad<Lexer> wrap (list))))
 
 (def: #export (at-least n p)
+  {#;doc "Lex at least N times."}
   (All [a] (-> Nat (Lexer a) (Lexer (List a))))
   (do Monad<Lexer>
     [min-xs (exactly n p)
@@ -208,6 +220,7 @@
     (wrap (list;concat (list min-xs extras)))))
 
 (def: #export (between from to p)
+  {#;doc "Lex between N and M times."}
   (All [a] (-> Nat Nat (Lexer a) (Lexer (List a))))
   (do Monad<Lexer>
     [min-xs (exactly from p)
@@ -215,6 +228,7 @@
     (wrap (list;concat (list min-xs max-xs)))))
 
 (def: #export (opt p)
+  {#;doc "Optionality combinator."}
   (All [a] (-> (Lexer a) (Lexer (Maybe a))))
   (lambda [input]
     (case (p input)
@@ -226,6 +240,7 @@
       )))
 
 (def: #export (text test)
+  {#;doc "Lex a text if it matches the given sample."}
   (-> Text (Lexer Text))
   (lambda [input]
     (if (text;starts-with? test input)
@@ -235,21 +250,23 @@
       (#;Left (format "Invalid match: " test " @ " (:: text;Codec<Text,Text> encode input))))
     ))
 
-(def: #export (sep-by sep p)
+(def: #export (sep-by sep lexer)
+  {#;doc "Apply a lexer multiple times, checking that a separator lexer succeeds between each time."}
   (All [a b] (-> (Lexer b) (Lexer a) (Lexer (List a))))
   (do Monad<Lexer>
-    [?x (opt p)]
+    [?x (opt lexer)]
     (case ?x
       #;None
       (wrap #;Nil)
       
       (#;Some x)
       (do @
-        [xs' (some (seq sep p))]
+        [xs' (some (seq sep lexer))]
         (wrap (#;Cons x (map product;right xs'))))
       )))
 
 (def: #export end
+  {#;doc "Ensure the lexer's input is empty."}
   (Lexer Unit)
   (lambda [input]
     (case input
@@ -258,6 +275,7 @@
       )))
 
 (def: #export peek
+  {#;doc "Lex the next character (without consuming it from the input)."}
   (Lexer Char)
   (lambda [input]
     (case (text;at +0 input)
@@ -269,6 +287,7 @@
     ))
 
 (def: #export (char test)
+  {#;doc "Lex a character if it matches the given sample."}
   (-> Char (Lexer Char))
   (lambda [input]
     (case [(text;at +0 input) (text;split +1 input)]
@@ -283,11 +302,13 @@
     ))
 
 (def: #export get-input
+  {#;doc "Get all of the remaining input (without consuming it)."}
   (Lexer Text)
   (lambda [input]
     (#;Right [input input])))
 
 (def: #export (char-range bottom top)
+  {#;doc "Only lex characters within a range."}
   (-> Char Char (Lexer Char))
   (do Monad<Lexer>
     [input get-input
@@ -297,26 +318,30 @@
                     (Char/<= top char)))]
     (wrap char)))
 
-(do-template [<name> <bottom> <top>]
+(do-template [<name> <bottom> <top> <desc>]
   [(def: #export <name>
+     {#;doc (#;TextM (format "Only lex " <desc> " characters."))}
      (Lexer Char)
      (char-range <bottom> <top>))]
 
-  [upper     #"A" #"Z"]
-  [lower     #"a" #"z"]
-  [digit     #"0" #"9"]
-  [oct-digit #"0" #"7"]
+  [upper     #"A" #"Z" "uppercase"]
+  [lower     #"a" #"z" "lowercase"]
+  [digit     #"0" #"9" "decimal"]
+  [oct-digit #"0" #"7" "octal"]
   )
 
 (def: #export alpha
+  {#;doc "Only lex alphabetic characters."}
   (Lexer Char)
   (either lower upper))
 
 (def: #export alpha-num
+  {#;doc "Only lex alphanumeric characters."}
   (Lexer Char)
   (either alpha digit))
 
 (def: #export hex-digit
+  {#;doc "Only lex hexadecimal digits."}
   (Lexer Char)
   ($_ either
       digit
@@ -324,6 +349,7 @@
       (char-range #"A" #"F")))
 
 (def: #export (one-of options)
+  {#;doc "Only lex characters that are part of a piece of text."}
   (-> Text (Lexer Char))
   (lambda [input]
     (case (text;split +1 input)
@@ -341,6 +367,7 @@
       (#;Left "Can't parse character from empty text."))))
 
 (def: #export (none-of options)
+  {#;doc "Only lex characters that aren't part of a piece of text."}
   (-> Text (Lexer Char))
   (lambda [input]
     (case (text;split +1 input)
@@ -358,6 +385,7 @@
       (#;Left "Can't parse character from empty text."))))
 
 (def: #export (satisfies p)
+  {#;doc "Only lex characters that satisfy a predicate."}
   (-> (-> Char Bool) (Lexer Char))
   (lambda [input]
     (case (: (Maybe [Text Char])
@@ -374,22 +402,26 @@
       (#;Left "Can't parse character from empty text."))))
 
 (def: #export space
+  {#;doc "Only lex white-space."}
   (Lexer Char)
   (satisfies char;space?))
 
 (def: #export (some' p)
+  {#;doc "Lex some characters as a single continuous text."}
   (-> (Lexer Char) (Lexer Text))
   (do Monad<Lexer>
     [cs (some p)]
     (wrap (text;concat (map char;as-text cs)))))
 
 (def: #export (many' p)
+  {#;doc "Lex many characters as a single continuous text."}
   (-> (Lexer Char) (Lexer Text))
   (do Monad<Lexer>
     [cs (many p)]
     (wrap (text;concat (map char;as-text cs)))))
 
 (def: #export end?
+  {#;doc "Ask if the lexer's input is empty."}
   (Lexer Bool)
   (lambda [input]
     (#;Right [input (text;empty? input)])))
@@ -408,6 +440,7 @@
     (wrap output)))
 
 (def: #export (default value lexer)
+  {#;doc "If the given lexer fails, this lexer will succeed with the provided value."}
   (All [a] (-> a (Lexer a) (Lexer a)))
   (lambda [input]
     (case (lexer input)
@@ -418,6 +451,7 @@
       (#;Right input'+value))))
 
 (def: #export (codec codec lexer)
+  {#;doc "Lex a token by means of a codec."}
   (All [a] (-> (Codec Text a) (Lexer Text) (Lexer a)))
   (lambda [input]
     (case (lexer input)
diff --git a/stdlib/source/lux/macro.lux b/stdlib/source/lux/macro.lux
index b7d93bd86..f9cfce416 100644
--- a/stdlib/source/lux/macro.lux
+++ b/stdlib/source/lux/macro.lux
@@ -17,6 +17,12 @@
 
 (do-template [<macro> <func>]
   [(syntax: #export (<macro> [? omit^] token)
+     {#;doc (doc "Performs a macro-expansion and logs the resulting ASTs."
+                 "You can either use the resulting ASTs, or omit them."
+                 "By omitting them, this macro produces nothing (just like the lux;comment macro)."
+                 (<macro> (def: (foo bar baz)
+                            (-> Int Int Int)
+                            (i.+ bar baz))))}
      (do @
        [output (<func> token)
         #let [_ (List/map (. log! %ast)
diff --git a/stdlib/source/lux/macro/ast.lux b/stdlib/source/lux/macro/ast.lux
index 06ba2aaed..8976ca64d 100644
--- a/stdlib/source/lux/macro/ast.lux
+++ b/stdlib/source/lux/macro/ast.lux
@@ -54,21 +54,22 @@
   [record (List [AST AST]) #;RecordS]
   )
 
-(do-template [<name> <tag>]
+(do-template [<name> <tag> <doc>]
   [(def: #export (<name> name)
+     {#;doc <doc>}
      (-> Text AST)
      [_cursor (<tag> ["" name])])]
 
-  [local-symbol #;SymbolS]
-  [local-tag    #;TagS])
+  [local-symbol #;SymbolS "Produces a local symbol (a symbol with no module prefix)."]
+  [local-tag    #;TagS    "Produces a local tag (a tag with no module prefix)."])
 
 ## [Structures]
 (struct: #export _ (Eq AST)
   (def: (= x y)
     (case [x y]
       (^template [<tag> <eq>]
-       [[_ (<tag> x')] [_ (<tag> y')]]
-       (:: <eq> = x' y'))
+        [[_ (<tag> x')] [_ (<tag> y')]]
+        (:: <eq> = x' y'))
       ([#;BoolS   Eq<Bool>]
        [#;NatS    Eq<Nat>]
        [#;IntS    Eq<Int>]
@@ -80,12 +81,12 @@
        [#;TagS    Eq<Ident>])
 
       (^template [<tag>]
-       [[_ (<tag> xs')] [_ (<tag> ys')]]
-       (and (:: Eq<Nat> = (size xs') (size ys'))
-            (fold (lambda [[x' y'] old]
-                    (and old (= x' y')))
-                  true
-                  (zip2 xs' ys'))))
+        [[_ (<tag> xs')] [_ (<tag> ys')]]
+        (and (:: Eq<Nat> = (size xs') (size ys'))
+             (fold (lambda [[x' y'] old]
+                     (and old (= x' y')))
+                   true
+                   (zip2 xs' ys'))))
       ([#;FormS]
        [#;TupleS])
 
@@ -104,8 +105,8 @@
   (-> AST Text)
   (case ast
     (^template [<tag> <struct>]
-     [_ (<tag> value)]
-     (:: <struct> encode value))
+      [_ (<tag> value)]
+      (:: <struct> encode value))
     ([#;BoolS   Codec<Text,Bool>]
      [#;NatS    Codec<Text,Nat>]
      [#;IntS    Codec<Text,Int>]
@@ -119,8 +120,8 @@
     (Text/append  "#" (:: Codec<Text,Ident> encode ident))
 
     (^template [<tag> <open> <close>]
-     [_ (<tag> members)]
-     ($_ Text/append <open> (|> members (map to-text) (interpose " ") (text;join-with "")) <close>))
+      [_ (<tag> members)]
+      ($_ Text/append <open> (|> members (map to-text) (interpose " ") (text;join-with "")) <close>))
     ([#;FormS  "(" ")"]
      [#;TupleS "[" "]"])
 
@@ -128,21 +129,22 @@
     ($_ Text/append "{" (|> pairs (map (lambda [[left right]] ($_ Text/append (to-text left) " " (to-text right)))) (interpose " ") (text;join-with "")) "}")
     ))
 
-(def: #export (replace source target ast)
+(def: #export (replace original substitute ast)
+  {#;doc "Replaces all ASTs that look like 'original' with the 'substitute' in the given AST."}
   (-> AST AST AST AST)
-  (if (:: Eq<AST> = source ast)
-    target
+  (if (:: Eq<AST> = original ast)
+    substitute
     (case ast
       (^template [<tag>]
-       [cursor (<tag> parts)]
-       [cursor (<tag> (map (replace source target) parts))])
+        [cursor (<tag> parts)]
+        [cursor (<tag> (map (replace original substitute) parts))])
       ([#;FormS]
        [#;TupleS])
 
       [cursor (#;RecordS parts)]
       [cursor (#;RecordS (map (lambda [[left right]]
-                                [(replace source target left)
-                                 (replace source target right)])
+                                [(replace original substitute left)
+                                 (replace original substitute right)])
                               parts))]
 
       _
diff --git a/stdlib/source/lux/macro/syntax.lux b/stdlib/source/lux/macro/syntax.lux
index ce36cef19..d043a0b29 100644
--- a/stdlib/source/lux/macro/syntax.lux
+++ b/stdlib/source/lux/macro/syntax.lux
@@ -29,6 +29,7 @@
 
 ## [Types]
 (type: #export (Syntax a)
+  {#;doc "A Lux AST syntax parser."}
   (-> (List AST) (Error [(List AST) a])))
 
 ## [Structures]
@@ -91,6 +92,7 @@
 
 (do-template [<get-name> <ask-name> <demand-name> <type> <tag> <eq> <desc>]
   [(def: #export <get-name>
+     {#;doc (#;TextM ($_ Text/append "Parses the next " <desc> " input AST."))}
      (Syntax <type>)
      (lambda [tokens]
        (case tokens
@@ -101,6 +103,7 @@
          (#;Left ($_ Text/append "Can't parse " <desc> (remaining-inputs tokens))))))
 
    (def: #export (<ask-name> v)
+     {#;doc (#;TextM ($_ Text/append "Asks if the given " <desc> " is the next input AST."))}
      (-> <type> (Syntax Bool))
      (lambda [tokens]
        (case tokens
@@ -115,6 +118,7 @@
          (#;Right [tokens false]))))
 
    (def: #export (<demand-name> v)
+     {#;doc (#;TextM ($_ Text/append "Ensures the given " <desc> " is the next input AST."))}
      (-> <type> (Syntax Unit))
      (lambda [tokens]
        (case tokens
@@ -137,10 +141,11 @@
   [   tag    tag?    tag! Ident    #;TagS ident;Eq<Ident> "tag"]
   )
 
-(def: #export (assert message v)
+(def: #export (assert message test)
+  {#;doc "Fails with the given message if the test is false."}
   (-> Text Bool (Syntax Unit))
   (lambda [tokens]
-    (if v
+    (if test
       (#;Right [tokens []])
       (#;Left ($_ Text/append message (remaining-inputs tokens))))))
 
@@ -158,6 +163,7 @@
 
 (do-template [<name> <tag> <desc>]
   [(def: #export <name>
+     {#;doc (#;TextM ($_ Text/append "Parse a local " <desc> " (a " <desc> " that has no module prefix)."))}
      (Syntax Text)
      (lambda [tokens]
        (case tokens
@@ -165,14 +171,15 @@
          (#;Right [tokens' x])
 
          _
-         (#;Left ($_ Text/append "Can't parse " <desc> (remaining-inputs tokens))))))]
+         (#;Left ($_ Text/append "Can't parse local " <desc> (remaining-inputs tokens))))))]
 
-  [local-symbol #;SymbolS "local symbol"]
-  [   local-tag #;TagS    "local tag"]
+  [local-symbol #;SymbolS "symbol"]
+  [   local-tag #;TagS    "tag"]
   )
 
 (do-template [<name> <tag> <desc>]
   [(def: #export (<name> p)
+     {#;doc (#;TextM ($_ Text/append "Parse inside the contents of a " <desc> " as if they were the input ASTs."))}
      (All [a]
        (-> (Syntax a) (Syntax a)))
      (lambda [tokens]
@@ -190,6 +197,7 @@
   )
 
 (def: #export (record p)
+  {#;doc (#;TextM ($_ Text/append "Parse inside the contents of a record as if they were the input ASTs."))}
   (All [a]
     (-> (Syntax a) (Syntax a)))
   (lambda [tokens]
@@ -287,6 +295,7 @@
       _     (#;Right [tokens false]))))
 
 (def: #export (exactly n p)
+  {#;doc "Parse exactly N times."}
   (All [a] (-> Nat (Syntax a) (Syntax (List a))))
   (if (n.> +0 n)
     (do Monad<Syntax>
@@ -296,6 +305,7 @@
     (:: Monad<Syntax> wrap (list))))
 
 (def: #export (at-least n p)
+  {#;doc "Parse at least N times."}
   (All [a] (-> Nat (Syntax a) (Syntax (List a))))
   (do Monad<Syntax>
     [min (exactly n p)
@@ -303,6 +313,7 @@
     (wrap (List/append min extra))))
 
 (def: #export (at-most n p)
+  {#;doc "Parse at most N times."}
   (All [a] (-> Nat (Syntax a) (Syntax (List a))))
   (if (n.> +0 n)
     (lambda [input]
@@ -319,6 +330,7 @@
     (:: Monad<Syntax> wrap (list))))
 
 (def: #export (between from to p)
+  {#;doc "Parse between N and M times."}
   (All [a] (-> Nat Nat (Syntax a) (Syntax (List a))))
   (do Monad<Syntax>
     [min-xs (exactly from p)
@@ -366,31 +378,35 @@
       (#;Right [input' output])
       (#;Right [input' output]))))
 
-(def: #export (on compiler meta)
+(def: #export (on compiler action)
+  {#;doc "Run a Lux operation as if it was a Syntax parser."}
   (All [a] (-> Compiler (Lux a) (Syntax a)))
   (lambda [input]
-    (case (meta compiler)
+    (case (compiler;run compiler action)
       (#;Left error)
       (#;Left error)
 
-      (#;Right [_ value])
+      (#;Right value)
       (#;Right [input value])
       )))
 
 (def: #export (local local-inputs syntax)
+  {#;doc "Run a syntax parser with the given list of inputs, instead of the real ones."}
   (All [a] (-> (List AST) (Syntax a) (Syntax a)))
   (lambda [real-inputs]
     (case (syntax local-inputs)
       (#;Left error)
       (#;Left error)
 
-      (#;Right [unconsume-inputs value])
-      (case unconsume-inputs
+      (#;Right [unconsumed-inputs value])
+      (case unconsumed-inputs
         #;Nil
         (#;Right [real-inputs value])
 
         _
-        (#;Left "Unconsumed inputs.")))))
+        (#;Left (Text/append "Unconsumed inputs: "
+                             (|> (map ast;to-text unconsumed-inputs)
+                                 (text;join-with ", "))))))))
 
 ## [Syntax]
 (def: #hidden text.join-with text;join-with)
@@ -413,11 +429,14 @@
                                                  (with-brackets (spaced (map (method-def$ id) methods))))))]
                   (wrap (list (` (;_lux_proc ["jvm" (~ (ast;text def-code))] [])))))))}
   (let [[exported? tokens] (case tokens
+                             (^ (list& [_ (#;TagS ["" "hidden"])] tokens'))
+                             [(#;Some #;Left) tokens']
+
                              (^ (list& [_ (#;TagS ["" "export"])] tokens'))
-                             [true tokens']
+                             [(#;Some #;Right) tokens']
 
                              _
-                             [false tokens])
+                             [#;None tokens])
         ?parts (: (Maybe [Text (List AST) AST AST])
                   (case tokens
                     (^ (list [_ (#;FormS (list& [_ (#;SymbolS ["" name])] args))]
@@ -451,7 +470,15 @@
            #let [g!state (ast;symbol ["" "*compiler*"])
                  g!end (ast;symbol ["" ""])
                  error-msg (ast;text (Text/append "Wrong syntax for " name))
-                 export-ast (: (List AST) (if exported? (list (' #export)) (list)))]]
+                 export-ast (: (List AST) (case exported?
+                                            (#;Some #;Left)
+                                            (list (' #hidden))
+
+                                            (#;Some #;Right)
+                                            (list (' #export))
+
+                                            _
+                                            (list)))]]
           (wrap (list (` (macro: (~@ export-ast) ((~ (ast;symbol ["" name])) (~ g!tokens))
                            (~ meta)
                            (lambda [(~ g!state)]
diff --git a/stdlib/source/lux/macro/syntax/common.lux b/stdlib/source/lux/macro/syntax/common.lux
index 9d1887b87..69564fc7d 100644
--- a/stdlib/source/lux/macro/syntax/common.lux
+++ b/stdlib/source/lux/macro/syntax/common.lux
@@ -3,7 +3,9 @@
 ##  If a copy of the MPL was not distributed with this file,
 ##  You can obtain one at http://mozilla.org/MPL/2.0/.
 
-(;module:
+(;module: {#;doc "Commons syntax parsers and generators.
+
+                  The goal is to be able to reuse common syntax in macro definitions across libraries."}
   lux
   (lux (control monad)
        (data (struct [list])
@@ -20,6 +22,10 @@
   #Hidden)
 
 (def: #export export-level
+  {#;doc (doc "A parser for export levels."
+              "Such as:"
+              #export
+              #hidden)}
   (Syntax (Maybe Export-Level))
   (s;opt (s;alt (s;tag! ["" "export"])
                 (s;tag! ["" "hidden"]))))
@@ -42,6 +48,11 @@
    #decl-args (List Text)})
 
 (def: #export decl
+  {#;doc (doc "A parser for declaration syntax."
+              "Such as:"
+              quux
+              (foo bar baz))}
+  (Syntax Decl)
   (s;either (s;seq s;local-symbol
                    (:: s;Monad<Syntax> wrap (list)))
             (s;form (s;seq s;local-symbol
@@ -52,7 +63,7 @@
   {#def-name Text
    #def-type (Maybe AST)
    #def-value AST
-   #def-meta (List [Ident AST])
+   #def-anns (List [Ident AST])
    #def-args (List Text)
    })
 
@@ -66,17 +77,17 @@
             (s;seq (:: s;Monad<Syntax> wrap #;None)
                    s;any)))
 
-(def: _def-meta-tag^
+(def: _def-anns-tag^
   (Syntax Ident)
   (s;tuple (s;seq s;text s;text)))
 
-(def: (_def-meta^ _)
+(def: (_def-anns^ _)
   (-> Top (Syntax (List [Ident AST])))
   (s;alt (s;tag! ["lux" "Nil"])
          (s;form (do s;Monad<Syntax>
                    [_ (s;tag! ["lux" "Cons"])
-                    [head tail] (s;seq (s;tuple (s;seq _def-meta-tag^ s;any))
-                                       (_def-meta^ []))]
+                    [head tail] (s;seq (s;tuple (s;seq _def-anns-tag^ s;any))
+                                       (_def-anns^ []))]
                    (wrap [head tail])))
          ))
 
@@ -119,6 +130,7 @@
     ))
 
 (def: #export (def compiler)
+  {#;doc "A parser that first macro-expands and then analyses the input AST, to ensure it's a definition."}
   (-> Compiler (Syntax Def-Syntax))
   (do s;Monad<Syntax>
     [def-raw s;any
@@ -129,17 +141,18 @@
                        [_ (s;symbol! ["lux" "_lux_def"])
                         def-name s;local-symbol
                         [?def-type def-value] check^
-                        def-meta s;any
-                        def-meta (s;local (list def-meta)
-                                          (_def-meta^ []))
-                        #let [def-args (find-def-args def-meta)]]
+                        def-anns s;any
+                        def-anns (s;local (list def-anns)
+                                          (_def-anns^ []))
+                        #let [def-args (find-def-args def-anns)]]
                        (wrap {#def-name def-name
                               #def-type ?def-type
-                              #def-meta def-meta
+                              #def-anns def-anns
                               #def-value def-value
                               #def-args def-args}))))))
 
-(def: #export (typed-de compiler)
+(def: #export (typed-def compiler)
+  {#;doc "A parser for definitions that ensures the input syntax is typed."}
   (-> Compiler (Syntax Def-Syntax))
   (do s;Monad<Syntax>
     [_def (def compiler)
@@ -152,14 +165,17 @@
          )]
     (wrap _def)))
 
-(def: #export def-meta
+(def: #export def-anns
+  {#;doc "Parser for the common annotations syntax used by def: statements."}
   (Syntax (List [Ident AST]))
   (s;record (s;some (s;seq s;tag s;any))))
 
 (def: #export typed-arg
+  {#;doc "Parser for the common typed-argument syntax used by many macros."}
   (Syntax [Text AST])
   (s;tuple (s;seq s;local-symbol s;any)))
 
 (def: #export type-params
+  {#;doc "Parser for the common type var/param used by many macros."}
   (Syntax (List Text))
   (s;tuple (s;some s;local-symbol)))
diff --git a/stdlib/source/lux/macro/template.lux b/stdlib/source/lux/macro/template.lux
index e66d386d8..293c87509 100644
--- a/stdlib/source/lux/macro/template.lux
+++ b/stdlib/source/lux/macro/template.lux
@@ -15,40 +15,18 @@
               (syntax [common]))))
 
 ## [Syntax]
-(def: decl^
-  (Syntax [Text (List Text)])
-  (s;form (s;seq s;local-symbol (s;many s;local-symbol))))
-
-(def: (prepare bindings template)
-  (-> (Dict Text AST) AST AST)
-  (case template
-    (^=> [_ (#;SymbolS "" name)]
-         [(dict;get name bindings) (#;Some found)])
-    found
-    
-    (^template [<tag>]
-      [meta (<tag> parts)]
-      [meta (<tag> (map (prepare bindings ) parts))])
-    ([#;FormS]
-     [#;TupleS])
-
-    
-    [meta (#;RecordS pairs)]
-    [meta (#;RecordS (map (lambda [[slot value]]
-                            [(prepare bindings slot)
-                             (prepare bindings value)])
-                          pairs))]
-
-    _
-    template
-    ))
-
-(syntax: #export (template: [_ex-lev common;export-level] [[name args] decl^] template)
-  (let [bindings (fold (lambda [arg bindings]
-                         (dict;put arg (` ((~' ~) (~ (ast;symbol ["" arg])))) bindings))
-                       (: (Dict Text AST) (dict;new text;Hash<Text>))
-                       args)]
+(syntax: #export (template: [_ex-lev common;export-level] [[name args] common;decl] input-template)
+  {#;doc (doc "Define macros in the style of do-template and ^template."
+              "For simple macros that don't need any fancy features."
+              (template: (square x)
+                (i.* x x)))}
+  (let [output-template (fold (lambda [arg' template']
+                                (ast;replace arg'
+                                             (` ((~' ~) (~ arg')))
+                                             template'))
+                              input-template
+                              (map ast;local-symbol args))]
     (wrap (list (` (syntax: (~@ (common;gen-export-level _ex-lev)) ((~ (ast;symbol ["" name]))
                                                                     (~@ (map (|>. [""] ast;symbol) args)))
-                     ((~' wrap) (list (` (~ (prepare bindings template)))))))))
+                     ((~' wrap) (list (` (~ output-template))))))))
     ))
diff --git a/stdlib/source/lux/math.lux b/stdlib/source/lux/math.lux
index 110561901..4c7c2e92e 100644
--- a/stdlib/source/lux/math.lux
+++ b/stdlib/source/lux/math.lux
@@ -3,7 +3,7 @@
 ##  If a copy of the MPL was not distributed with this file,
 ##  You can obtain one at http://mozilla.org/MPL/2.0/.
 
-(;module: {#;doc "Common numerical operations."}
+(;module: {#;doc "Common mathematical constants and functions."}
   lux
   (lux (control monad)
        (data (struct [list "" Fold<List>])
@@ -25,7 +25,10 @@
   [pi "getstatic:java.lang.Math:PI"]
   )
 
-(def: #export tau Real 6.28318530717958647692)
+(def: #export tau
+  {#;doc "The same as 2*PI."}
+  Real
+  6.28318530717958647692)
 
 (do-template [<name> <method>]
   [(def: #export (<name> n)
@@ -153,4 +156,15 @@
     ))
 
 (syntax: #export (infix [expr (infix^ [])])
+  {#;doc (doc "Infix math syntax."
+              (infix [x i.* 10])
+              (infix [[x i.+ y] i.* [x i.- y]])
+              (infix [[x n.< y] and [y n.< z]])
+              (infix [#and x n.< y n.< z])
+              (infix [(n.* +3 +9) gcd +450])
+
+              "The rules for infix syntax are simple."
+              "If you want your binary function to work well with it."
+              "Then take the argument to the right (y) as your first argument,"
+              "and take the argument to the left (x) as your second argument.")}
   (wrap (list (infix-to-prefix expr))))
diff --git a/stdlib/source/lux/math/complex.lux b/stdlib/source/lux/math/complex.lux
index 1da82b290..9666abdab 100644
--- a/stdlib/source/lux/math/complex.lux
+++ b/stdlib/source/lux/math/complex.lux
@@ -3,7 +3,7 @@
 ##  If a copy of the MPL was not distributed with this file,
 ##  You can obtain one at http://mozilla.org/MPL/2.0/.
 
-(;module:
+(;module: {#;doc "Complex arithmetic."}
   lux
   (lux [math]
        (control eq
@@ -29,8 +29,12 @@
    #imaginary Real})
 
 (syntax: #export (complex real [?imaginary (s;opt s;any)])
+  {#;doc (doc "Complex literals."
+              (complex real imaginary)
+              "The imaginary part can be omitted if it's 0."
+              (complex real))}
   (wrap (list (` {#;;real (~ real)
-                  #;;imaginary (~ (default (` 0.0)
+                  #;;imaginary (~ (default (' 0.0)
                                     ?imaginary))}))))
 
 (def: #export i Complex (complex 0.0 1.0))
diff --git a/stdlib/source/lux/math/random.lux b/stdlib/source/lux/math/random.lux
index 0a76f3365..802dbfae6 100644
--- a/stdlib/source/lux/math/random.lux
+++ b/stdlib/source/lux/math/random.lux
@@ -3,7 +3,7 @@
 ##  If a copy of the MPL was not distributed with this file,
 ##  You can obtain one at http://mozilla.org/MPL/2.0/.
 
-(;module:
+(;module: {#;doc "Pseudo-random number generation (PRNG) algorithms."}
   [lux #- list]
   (lux (control functor
                 applicative
@@ -27,9 +27,11 @@
 
 ## [Exports]
 (type: #export #rec PRNG
+  {#;doc "An abstract way to represent any PRNG."}
   (-> Unit [PRNG Nat]))
 
 (type: #export (Random a)
+  {#;doc "A producer of random values based on a PRNG."}
   (-> PRNG [PRNG a]))
 
 (struct: #export _ (Functor Random)
@@ -134,6 +136,7 @@
   )
 
 (def: #export (seq left right)
+  {#;doc "Sequencing combinator."}
   (All [a b] (-> (Random a) (Random b) (Random [a b])))
   (do Monad<Random>
     [=left left
@@ -141,6 +144,7 @@
     (wrap [=left =right])))
 
 (def: #export (alt left right)
+  {#;doc "Heterogeneous alternative combinator."}
   (All [a b] (-> (Random a) (Random b) (Random (| a b))))
   (do Monad<Random>
     [? bool]
@@ -153,6 +157,7 @@
         (wrap (+1 =right))))))
 
 (def: #export (either left right)
+  {#;doc "Homogeneous alternative combinator."}
   (All [a] (-> (Random a) (Random a) (Random a)))
   (do Monad<Random>
     [? bool]
@@ -161,12 +166,14 @@
       right)))
 
 (def: #export (rec gen)
+  {#;doc "A combinator for producing recursive random generators."}
   (All [a] (-> (-> (Random a) (Random a)) (Random a)))
   (lambda [state]
     (let [gen' (gen (rec gen))]
       (gen' state))))
 
 (def: #export (filter pred gen)
+  {#;doc "Retries the generator until the output satisfies a predicate."}
   (All [a] (-> (-> a Bool) (Random a) (Random a)))
   (do Monad<Random>
     [sample gen]
@@ -210,11 +217,11 @@
   [stack ST;Stack (List/fold ST;push ST;empty)]
   )
 
-(def: #export (set a/Hash size value-gen)
+(def: #export (set Hash<a> size value-gen)
   (All [a] (-> (Hash a) Nat (Random a) (Random (S;Set a))))
   (if (n.> +0 size)
     (do Monad<Random>
-      [xs (set a/Hash (n.dec size) value-gen)]
+      [xs (set Hash<a> (n.dec size) value-gen)]
       (loop [_ []]
         (do @
           [x value-gen
@@ -222,13 +229,13 @@
           (if (n.= size (S;size xs+))
             (wrap xs+)
             (recur [])))))
-    (:: Monad<Random> wrap (S;new a/Hash))))
+    (:: Monad<Random> wrap (S;new Hash<a>))))
 
-(def: #export (dict a/Hash size key-gen value-gen)
+(def: #export (dict Hash<a> size key-gen value-gen)
   (All [k v] (-> (Hash k) Nat (Random k) (Random v) (Random (D;Dict k v))))
   (if (n.> +0 size)
     (do Monad<Random>
-      [kv (dict a/Hash (n.dec size) key-gen value-gen)]
+      [kv (dict Hash<a> (n.dec size) key-gen value-gen)]
       (loop [_ []]
         (do @
           [k key-gen
@@ -237,7 +244,7 @@
           (if (n.= size (D;size kv+))
             (wrap kv+)
             (recur [])))))
-    (:: Monad<Random> wrap (D;new a/Hash))))
+    (:: Monad<Random> wrap (D;new Hash<a>))))
 
 (def: #export (run prng calc)
   (All [a] (-> PRNG (Random a) [PRNG a]))
@@ -250,6 +257,9 @@
 (def: pcg-32-magic-mult Nat +6364136223846793005)
 
 (def: #export (pcg-32 [inc seed])
+  {#;doc "An implementation of the PCG32 algorithm.
+
+          For more information, please see: http://www.pcg-random.org/"}
   (-> [Nat Nat] PRNG)
   (lambda [_]
     (let [seed' (|> seed (n.* pcg-32-magic-mult) (n.+ inc))
@@ -260,6 +270,9 @@
 
 ## Xoroshiro128+ http://xoroshiro.di.unimi.it/
 (def: #export (xoroshiro-128+ [s0 s1])
+  {#;doc "An implementation of the Xoroshiro128+ algorithm.
+
+          For more information, please see: http://xoroshiro.di.unimi.it/"}
   (-> [Nat Nat] PRNG)
   (lambda [_]
     (let [result (n.+ s0 s1)
@@ -279,6 +292,7 @@
          vec))
 
 (def: #export (shuffle seed vector)
+  {#;doc "Shuffle a vector randomly based on a seed value."}
   (All [a] (-> Nat (V;Vector a) (V;Vector a)))
   (let [_size (V;size vector)
         _shuffle (foldM Monad<Random>
diff --git a/stdlib/source/lux/math/ratio.lux b/stdlib/source/lux/math/ratio.lux
index c0e077c8a..c4a369866 100644
--- a/stdlib/source/lux/math/ratio.lux
+++ b/stdlib/source/lux/math/ratio.lux
@@ -3,7 +3,7 @@
 ##  If a copy of the MPL was not distributed with this file,
 ##  You can obtain one at http://mozilla.org/MPL/2.0/.
 
-(;module:
+(;module: {#;doc "Rational arithmetic."}
   lux
   (lux [math]
        (control eq
@@ -154,6 +154,11 @@
       #;None
       (#;Left (Text/append "Invalid syntax for ratio: " input)))))
 
-(syntax: #export (ratio numerator denominator)
+(syntax: #export (ratio numerator [?denominator (s;opt s;any)])
+  {#;doc (doc "Rational literals."
+              (ratio numerator denominator)
+              "The denominator can be omitted if it's 1."
+              (ratio numerator))}
   (wrap (list (` (normalize {#;;numerator (~ numerator)
-                             #;;denominator (~ denominator)})))))
+                             #;;denominator (~ (default (' +1)
+                                                 ?denominator))})))))
diff --git a/stdlib/source/lux/math/simple.lux b/stdlib/source/lux/math/simple.lux
index 31a8bb3ca..4fa69a8a1 100644
--- a/stdlib/source/lux/math/simple.lux
+++ b/stdlib/source/lux/math/simple.lux
@@ -3,7 +3,7 @@
 ##  If a copy of the MPL was not distributed with this file,
 ##  You can obtain one at http://mozilla.org/MPL/2.0/.
 
-(;module:
+(;module: {#;doc "Polymorphic arithmetic operators that work with all primitive numeric types, without requiring any prefixes."}
   lux
   (lux (control monad)
        (data text/format
@@ -53,6 +53,14 @@
                                       s;symbol
                                       s;any
                                       s;end)])
+     {#;doc (doc (= (<name> +1 +2)
+                    (<nat-op> +1 +2))
+                 (= (<name> 1 2)
+                    (<int-op> 1 2))
+                 (= (<name> 1.0 2.0)
+                    (<real-op> 1.0 2.0))
+                 (= (<name> .1 .2)
+                    (<frac-op> .1 .2)))}
      (case args
        (+0 [x y])
        (do @
@@ -142,6 +150,14 @@
                                       s;symbol
                                       s;any
                                       s;end)])
+     {#;doc (doc (= (<name> +1 +2)
+                    (<nat-op> +1 +2))
+                 (= (<name> 1 2)
+                    (<int-op> 1 2))
+                 (= (<name> 1.0 2.0)
+                    (<real-op> 1.0 2.0))
+                 (= (<name> .1 .2)
+                    (<frac-op> .1 .2)))}
      (case args
        (+0 [x y])
        (do @
@@ -231,6 +247,10 @@
                                       s;symbol
                                       s;any
                                       s;end)])
+     {#;doc (doc (= (<name> +1 +2)
+                    (<nat-op> +1 +2))
+                 (= (<name> 1 2)
+                    (<int-op> 1 2)))}
      (case args
        (+0 [x y])
        (do @
@@ -295,6 +315,10 @@
                                       s;symbol
                                       s;any
                                       s;end)])
+     {#;doc (doc (= (<name> +1 +2)
+                    (<nat-op> +1 +2))
+                 (= (<name> 1 2)
+                    (<int-op> 1 2)))}
      (case args
        (+0 x)
        (do @
@@ -336,6 +360,10 @@
                                       s;symbol
                                       s;any
                                       s;end)])
+     {#;doc (doc (= (<name> +1 +2)
+                    (<nat-op> +1 +2))
+                 (= (<name> 1 2)
+                    (<int-op> 1 2)))}
      (case args
        (+0 x)
        (do @
diff --git a/stdlib/source/lux/pipe.lux b/stdlib/source/lux/pipe.lux
index 5c553b7ec..c0b99bd5b 100644
--- a/stdlib/source/lux/pipe.lux
+++ b/stdlib/source/lux/pipe.lux
@@ -70,12 +70,11 @@
                                 g!temp)))))))))
 
 (syntax: #export (!> [test body^] [then body^] prev)
-  {#;doc (doc
-          "Loops for pipes."
-          "Both the testing and calculating steps are pipes and must be given inside tuples."
-          (|> 1
-              (!> [(i.< 10)]
-                  [i.inc])))}
+  {#;doc (doc "Loops for pipes."
+              "Both the testing and calculating steps are pipes and must be given inside tuples."
+              (|> 1
+                  (!> [(i.< 10)]
+                      [i.inc])))}
   (with-gensyms [g!temp]
     (wrap (list (` (loop [(~ g!temp) (~ prev)]
                      (if (|> (~ g!temp) (~@ test))
diff --git a/stdlib/source/lux/regex.lux b/stdlib/source/lux/regex.lux
index e3cd95811..417abc086 100644
--- a/stdlib/source/lux/regex.lux
+++ b/stdlib/source/lux/regex.lux
@@ -421,6 +421,64 @@
 
 ## [Syntax]
 (syntax: #export (regex [pattern syntax;text])
+  {#;doc (doc "Create lexers using regular-expression syntax."
+              "For example:"
+              
+              "Literals"
+              (regex "a")
+              
+              "Wildcards"
+              (regex ".")
+              
+              "Escaping"
+              (regex "\\.")
+              
+              "Character classes"
+              (regex "\\d")
+              (regex "\\p{Lower}")
+              (regex "[abc]")
+              (regex "[a-z]")
+              (regex "[a-zA-Z]")
+              (regex "[a-z&&[def]]")
+              
+              "Negation"
+              (regex "[^abc]")
+              (regex "[^a-z]")
+              (regex "[^a-zA-Z]")
+              (regex "[a-z&&[^bc]]")
+              (regex "[a-z&&[^m-p]]")
+              
+              "Combinations"
+              (regex "aa")
+              (regex "a?")
+              (regex "a*")
+              (regex "a+")
+              
+              "Specific amounts"
+              (regex "a{2}")
+              
+              "At least"
+              (regex "a{1,}")
+              
+              "At most"
+              (regex "a{,1}")
+              
+              "Between"
+              (regex "a{1,2}")
+              
+              "Groups"
+              (regex "a(.)c")
+              (regex "a(b+)c")
+              (regex "(\\d{3})-(\\d{3})-(\\d{4})")
+              (regex "(\\d{3})-(?:\\d{3})-(\\d{4})")
+              (regex "(?<code>\\d{3})-\\k<code>-(\\d{4})")
+              (regex "(?<code>\\d{3})-\\k<code>-(\\d{4})-\\0")
+              (regex "(\\d{3})-((\\d{3})-(\\d{4}))")
+              
+              "Alternation"
+              (regex "a|b")
+              (regex "a(.)(.)|b(.)(.)")
+              )}
   (do @
     [current-module compiler;current-module-name]
     (case (&;run (&;&_ (regex^ current-module) &;end) pattern)
diff --git a/stdlib/source/lux/test.lux b/stdlib/source/lux/test.lux
index 2230282da..e2bff250e 100644
--- a/stdlib/source/lux/test.lux
+++ b/stdlib/source/lux/test.lux
@@ -3,7 +3,7 @@
 ##  If a copy of the MPL was not distributed with this file,
 ##  You can obtain one at http://mozilla.org/MPL/2.0/.
 
-(;module:
+(;module: {#;doc "Tools for unit & property-based/generative testing."}
   lux
   (lux [compiler #+ Monad<Lux> with-gensyms]
        (macro ["s" syntax #+ syntax: Syntax]
@@ -35,6 +35,7 @@
 
 ## [Types]
 (type: #export Test
+  {#;doc "Tests are asynchronous process which may fail."}
   (Promise (Error Unit)))
 
 ## [Values]
@@ -42,9 +43,10 @@
   (All [a] (-> Text Test))
   (:: Monad<Promise> wrap (#;Left message)))
 
-(def: #export (assert message test)
+(def: #export (assert message condition)
+  {#;doc "Check that a condition is true, and fail with the given message otherwise."}
   (-> Text Bool Test)
-  (if test
+  (if condition
     (:: Monad<Promise> wrap (#;Right []))
     (fail message)))
 
@@ -72,7 +74,9 @@
 
 (def: pcg-32-magic-inc Nat +12345)
 
-(type: #export Seed Nat)
+(type: #export Seed
+  {#;doc "The seed value used for random testing (if that feature is used)."}
+  Nat)
 
 (def: (try seed random-test)
   (-> Seed (R;Random Test) (Promise (Error Seed)))
@@ -106,7 +110,7 @@
           (repeat' seed' (n.dec times) random-test))
         ))))
 
-(def: #export (repeat ?seed times random-test)
+(def: #hidden (repeat ?seed times random-test)
   (-> (Maybe Nat) Nat (R;Random Test) Test)
   (repeat' (default (int-to-nat (io;run (System.currentTimeMillis [])))
              ?seed)
@@ -165,18 +169,62 @@
 
 (syntax: #export (test: description [body test^])
   {#;doc (doc "Macro for definint tests."
-              (test: "lux/pipe exports"
-                (all (match 1 (|> 20
-                                  (i.* 3)
-                                  (i.+ 4)
-                                  (_> 0 i.inc)))
-                     (match 10 (|> 5
-                                   (@> (i.+ @ @))))
-                     (match 15 (|> 5
-                                   (?> [i.even?] [(i.* 2)]
-                                       [i.odd?] [(i.* 3)]
-                                       [(_> -1)])))
-                     )))}
+              (test: "Simple macros and constructs"
+                ($_ seq
+                    (assert "Can write easy loops for iterative programming."
+                            (i.= 1000
+                                 (loop [counter 0
+                                        value 1]
+                                   (if (i.< 3 counter)
+                                     (recur (i.inc counter) (i.* 10 value))
+                                     value))))
+
+                    (assert "Can create lists easily through macros."
+                            (and (case (list 1 2 3)
+                                   (#;Cons 1 (#;Cons 2 (#;Cons 3 #;Nil)))
+                                   true
+
+                                   _
+                                   false)
+                                 
+                                 (case (list& 1 2 3 (list 4 5 6))
+                                   (#;Cons 1 (#;Cons 2 (#;Cons 3 (#;Cons 4 (#;Cons 5 (#;Cons 6 #;Nil))))))
+                                   true
+
+                                   _
+                                   false)))
+
+                    (assert "Can have defaults for Maybe values."
+                            (and (is "yolo" (default "yolo"
+                                              #;None))
+                                 
+                                 (is "lol" (default "yolo"
+                                             (#;Some "lol")))))
+                    ))
+              "Also works with random generation of values for property-based testing."
+              (test: "Addition & Substraction"
+                [x (:: @ map <prep> rand-gen)
+                 y (:: @ map <prep> rand-gen)]
+                (assert ""
+                        (and (|> x (- y) (+ y) (= x))
+                             (|> x (+ y) (- y) (= x)))))
+              "By default, random tests will be tried 100 times, you can specify the amount you want:"
+              (test: "Addition & Substraction"
+                #times +1234
+                [x (:: @ map <prep> rand-gen)
+                 y (:: @ map <prep> rand-gen)]
+                (assert ""
+                        (and (|> x (- y) (+ y) (= x))
+                             (|> x (+ y) (- y) (= x)))))
+              "If a test fails, you'll be shown a seed that you can then use to reproduce a failing scenario."
+              (test: "Addition & Substraction"
+                #seed +987654321
+                [x (:: @ map <prep> rand-gen)
+                 y (:: @ map <prep> rand-gen)]
+                (assert ""
+                        (and (|> x (- y) (+ y) (= x))
+                             (|> x (+ y) (- y) (= x)))))
+              )}
   (let [body (case body
                (#Property config bindings body)
                (let [[=seed =times] (case config
@@ -261,6 +309,7 @@
                               [])))))))))
 
 (def: #export (seq left right)
+  {#;doc "Sequencing combinator."}
   (-> Test Test Test)
   (do Monad<Promise>
     [=left left
@@ -274,6 +323,7 @@
       (wrap (#;Right [])))))
 
 (def: #export (alt left right)
+  {#;doc "Alternative combinator."}
   (-> Test Test Test)
   (do Monad<Promise>
     [=left left
diff --git a/stdlib/source/lux/type.lux b/stdlib/source/lux/type.lux
index 1fb0afa6f..cda44670b 100644
--- a/stdlib/source/lux/type.lux
+++ b/stdlib/source/lux/type.lux
@@ -3,7 +3,7 @@
 ##  If a copy of the MPL was not distributed with this file,
 ##  You can obtain one at http://mozilla.org/MPL/2.0/.
 
-(;module:
+(;module: {#;doc "Basic functionality for working with types."}
   lux
   (lux (control eq
                 monad)
@@ -145,12 +145,12 @@
   [flatten-tuple   #;ProdT]
   )
 
-(def: #export (apply-type type-fun param)
+(def: #export (apply-type type-func param)
   (-> Type Type (Maybe Type))
-  (case type-fun
+  (case type-func
     (^template [<tag>]
       (<tag> env body)
-      (#;Some (beta-reduce (list& type-fun param env) body)))
+      (#;Some (beta-reduce (list& type-func param env) body)))
     ([#;UnivQ] [#;ExQ])
 
     (#;AppT F A)
@@ -252,8 +252,8 @@
     ($_ Text/append "⟨e:" (Nat/encode id) "⟩")
 
     (#;AppT fun param)
-    (let [[type-fun type-args] (flatten-application type)]
-      ($_ Text/append  "(" (to-text type-fun) " " (|> type-args (List/map to-text) list;reverse (list;interpose " ") (List/fold Text/append "")) ")"))
+    (let [[type-func type-args] (flatten-application type)]
+      ($_ Text/append  "(" (to-text type-func) " " (|> type-args (List/map to-text) list;reverse (list;interpose " ") (List/fold Text/append "")) ")"))
 
     (^template [<tag> <desc>]
       (<tag> env body)
diff --git a/stdlib/source/lux/type/auto.lux b/stdlib/source/lux/type/auto.lux
index 27c1472c0..2266827c9 100644
--- a/stdlib/source/lux/type/auto.lux
+++ b/stdlib/source/lux/type/auto.lux
@@ -5,7 +5,8 @@
 
 (;module:
   lux
-  (lux (control monad)
+  (lux (control monad
+                [eq])
        (data [text "Text/" Eq<Text>]
              text/format
              [number]
@@ -324,6 +325,29 @@
 (syntax: #export (::: [member s;symbol]
                       [args (s;alt (s;seq (s;some s;symbol) s;end)
                                    (s;seq (s;some s;any) s;end))])
+  {#;doc (doc "Automatic structure selection (for type-class style polymorphism)."
+              "This feature layers type-class style polymorphism on top of Lux's signatures and structures."
+              "When calling a polymorphic function, or using a polymorphic constant,"
+              "this macro will check the types of the arguments, and the expected type for the whole expression"
+              "and it will search in the local scope, the module's scope and the imports' scope"
+              "in order to find suitable structures to satisfy those requirements."
+              "If a single alternative is found, that one will be used automatically."
+              "If no alternative is found, or if more than one alternative is found (ambiguity)"
+              "a compile-time error will be raised, to alert the user."
+              "Examples:"
+              "Nat equality"
+              (:: number;Eq<Nat> = x y)
+              (::: = x y)
+              "Can optionally add the prefix of the module where the signature was defined."
+              (::: eq;= x y)
+              "(List Nat) equality"
+              (::: =
+                   (list;n.range +1 +10)
+                   (list;n.range +1 +10))
+              "Functor map"
+              (::: map n.inc (list;n.range +0 +9))
+              "Caveat emptor: You need to make sure to import the module of any structure you want to use."
+              "Otherwise, this macro won't find it.")}
   (case args
     (#;Left [args _])
     (do @
diff --git a/stdlib/source/lux/type/check.lux b/stdlib/source/lux/type/check.lux
index 97a01d8ce..25cf19834 100644
--- a/stdlib/source/lux/type/check.lux
+++ b/stdlib/source/lux/type/check.lux
@@ -3,7 +3,9 @@
 ##  If a copy of the MPL was not distributed with this file,
 ##  You can obtain one at http://mozilla.org/MPL/2.0/.
 
-(;module:
+(;module: {#;doc "Type-checking functionality.
+
+                  Very useful for writing advanced macros."}
   lux
   (lux (control functor
                 applicative
@@ -109,6 +111,7 @@
       (#;Right [context output]))))
 
 (def: #export existential
+  {#;doc "A producer of existential types."}
   (Check [Id Type])
   (lambda [context]
     (let [id (get@ #ex-counter context)]
@@ -128,7 +131,7 @@
       #;None
       (#;Left (format "Unknown type-var: " (%n id))))))
 
-(def: #export (deref id)
+(def: #export (read-var id)
   (-> Id (Check Type))
   (lambda [context]
     (case (|> context (get@ #bindings) (dict;get id))
@@ -141,8 +144,8 @@
       #;None
       (#;Left (format "Unknown type-var: " (%n id))))))
 
-(def: (set-var id type)
-  (-> Id Type (Check []))
+(def: #export (write-var id type)
+  (-> Id Type (Check Unit))
   (lambda [context]
     (case (|> context (get@ #bindings) (dict;get id))
       (#;Some (#;Some bound))
@@ -155,8 +158,8 @@
       #;None
       (#;Left (format "Unknown type-var: " (%n id))))))
 
-(def: (reset-var id type)
-  (-> Id Type (Check []))
+(def: (rewrite-var id type)
+  (-> Id Type (Check Unit))
   (lambda [context]
     (case (|> context (get@ #bindings) (dict;get id))
       (#;Some _)
@@ -166,8 +169,8 @@
       #;None
       (#;Left (format "Unknown type-var: " (%n id))))))
 
-(def: (unset-var id)
-  (-> Id (Check []))
+(def: #export (clear-var id)
+  (-> Id (Check Unit))
   (lambda [context]
     (case (|> context (get@ #bindings) (dict;get id))
       (#;Some _)
@@ -185,27 +188,27 @@
       (do Monad<Check>
         [? (bound? id)]
         (if ?
-          (deref id)
+          (read-var id)
           (wrap type)))
       (do Monad<Check>
         [? (bound? id)]
         (if ?
           (do Monad<Check>
-            [=type (deref id)
+            [=type (read-var id)
              ==type (clean t-id =type)]
             (case ==type
               (#;VarT =id)
               (if (n.= t-id =id)
                 (do Monad<Check>
-                  [_ (unset-var id)]
+                  [_ (clear-var id)]
                   (wrap type))
                 (do Monad<Check>
-                  [_ (reset-var id ==type)]
+                  [_ (rewrite-var id ==type)]
                   (wrap type)))
 
               _
               (do Monad<Check>
-                [_ (reset-var id ==type)]
+                [_ (rewrite-var id ==type)]
                 (wrap type))))
           (wrap type))))
 
@@ -255,7 +258,7 @@
                  (get@ <tag> context)])))
 
    (def: (<set> value)
-     (-> <type> (Check []))
+     (-> <type> (Check Unit))
      (lambda [context]
        (#;Right [(set@ <tag> value context)
                  []])))]
@@ -265,14 +268,14 @@
   )
 
 (def: #export (delete-var id)
-  (-> Id (Check []))
+  (-> Id (Check Unit))
   (do Monad<Check>
     [? (bound? id)
      _ (if ?
          (wrap [])
          (do Monad<Check>
            [[ex-id ex] existential]
-           (set-var id ex)))
+           (write-var id ex)))
      bindings get-bindings
      bindings' (mapM @
                      (lambda [(^@ binding [b-id b-type])]
@@ -329,11 +332,11 @@
     (#;Left message)))
 
 (def: (fail-check expected actual)
-  (-> Type Type (Check []))
+  (-> Type Type (Check Unit))
   (fail (format "Expected: " (%type expected) "\n\n"
                 "Actual:   " (%type actual))))
 
-(def: success (Check []) (Check/wrap []))
+(def: success (Check Unit) (Check/wrap []))
 
 (def: (either left right)
   (All [a] (-> (Check a) (Check a) (Check a)))
@@ -358,7 +361,8 @@
   (#;Cons [ea status] fixpoints))
 
 (def: #export (check expected actual)
-  (-> Type Type (Check []))
+  {#;doc "Type-check to ensure that the 'expected' type subsumes the 'actual' type."}
+  (-> Type Type (Check Unit))
   (if (is expected actual)
     success
     (case [expected actual]
@@ -366,11 +370,11 @@
       (if (n.= e-id a-id)
         success
         (do Monad<Check>
-          [ebound (attempt (deref e-id))
-           abound (attempt (deref a-id))]
+          [ebound (attempt (read-var e-id))
+           abound (attempt (read-var a-id))]
           (case [ebound abound]
             [#;None #;None]
-            (set-var e-id actual)
+            (write-var e-id actual)
             
             [(#;Some etype) #;None]
             (check etype actual)
@@ -382,15 +386,15 @@
             (check etype atype))))
       
       [(#;VarT id) _]
-      (either (set-var id actual)
+      (either (write-var id actual)
               (do Monad<Check>
-                [bound (deref id)]
+                [bound (read-var id)]
                 (check bound actual)))
       
       [_ (#;VarT id)]
-      (either (set-var id expected)
+      (either (write-var id expected)
               (do Monad<Check>
-                [bound (deref id)]
+                [bound (read-var id)]
                 (check expected bound)))
 
       [(#;AppT (#;ExT eid) eA) (#;AppT (#;ExT aid) aA)]
@@ -400,7 +404,7 @@
 
       [(#;AppT (#;VarT id) A1) (#;AppT F2 A2)]
       (either (do Monad<Check>
-                [F1 (deref id)]
+                [F1 (read-var id)]
                 (check (#;AppT F1 A1) actual))
               (do Monad<Check>
                 [_ (check (#;VarT id) F2)
@@ -410,7 +414,7 @@
       
       [(#;AppT F1 A1) (#;AppT (#;VarT id) A2)]
       (either (do Monad<Check>
-                [F2 (deref id)]
+                [F2 (read-var id)]
                 (check expected (#;AppT F2 A2)))
               (do Monad<Check>
                 [_ (check F1 (#;VarT id))
@@ -509,6 +513,7 @@
       (fail-check expected actual))))
 
 (def: #export (checks? expected actual)
+  {#;doc "A simple type-checking function that just returns a yes/no answer."}
   (-> Type Type Bool)
   (case (run fresh-context (check expected actual))
     (#;Left error)
diff --git a/stdlib/test/test/lux/concurrency/actor.lux b/stdlib/test/test/lux/concurrency/actor.lux
index abf8828d7..7136ab30d 100644
--- a/stdlib/test/test/lux/concurrency/actor.lux
+++ b/stdlib/test/test/lux/concurrency/actor.lux
@@ -27,7 +27,7 @@
     (wrap [])))
 
 (test: "Actors"
-  (let [counter-proc (: (&;Proc Int (Promise Int))
+  (let [counter-proc (: (&;Behavior Int (Promise Int))
                         [(lambda [self output state]
                            (let [state' (i.inc state)]
                              (exec (io;run (promise;resolve state' output))
diff --git a/stdlib/test/test/lux/data/struct/queue.lux b/stdlib/test/test/lux/data/struct/queue.lux
index 98379e30a..095d066f6 100644
--- a/stdlib/test/test/lux/data/struct/queue.lux
+++ b/stdlib/test/test/lux/data/struct/queue.lux
@@ -17,7 +17,7 @@
   [size (:: @ map (n.% +100) R;nat)
    sample (R;queue size R;nat)
    non-member (|> R;nat
-                  (R;filter (. not (&;enqueued? number;Eq<Nat> sample))))]
+                  (R;filter (. not (&;member? number;Eq<Nat> sample))))]
   ($_ seq
       (assert "I can query the size of a queue (and empty queues have size 0)."
               (if (n.= +0 size)
@@ -25,10 +25,10 @@
                 (n.= size (&;size sample))))
 
       (assert "Enqueueing and dequeing affects the size of queues."
-              (and (n.= (n.inc size) (&;size (&;enqueue non-member sample)))
+              (and (n.= (n.inc size) (&;size (&;push non-member sample)))
                    (or (&;empty? sample)
-                       (n.= (n.dec size) (&;size (&;dequeue sample))))
-                   (n.= size (&;size (&;dequeue (&;enqueue non-member sample))))))
+                       (n.= (n.dec size) (&;size (&;pop sample))))
+                   (n.= size (&;size (&;pop (&;push non-member sample))))))
 
       (assert "Transforming to/from list can't change the queue."
               (let [(^open "&/") (&;Eq<Queue> number;Eq<Nat>)]
@@ -42,14 +42,14 @@
                 (#;Some _) true))
 
       (assert "I can query whether an element belongs to a queue."
-              (and (not (&;enqueued? number;Eq<Nat> sample non-member))
-                   (&;enqueued? number;Eq<Nat> (&;enqueue non-member sample)
-                                non-member)
+              (and (not (&;member? number;Eq<Nat> sample non-member))
+                   (&;member? number;Eq<Nat> (&;push non-member sample)
+                              non-member)
                    (case (&;peek sample)
                      #;None
                      (&;empty? sample)
                      
                      (#;Some first)
-                     (and (&;enqueued? number;Eq<Nat> sample first)
-                          (not (&;enqueued? number;Eq<Nat> (&;dequeue sample) first))))))
+                     (and (&;member? number;Eq<Nat> sample first)
+                          (not (&;member? number;Eq<Nat> (&;pop sample) first))))))
       ))