Migrated documentation tool's code into stdlib.

11 files changed, 605 insertions, 699 deletions

diff --git a/luxdoc/project.clj b/luxdoc/project.clj
deleted file mode 100644
index de51950bb..000000000
--- a/luxdoc/project.clj
+++ /dev/null
@@ -1,11 +0,0 @@
-(defproject luxdoc "0.5.0"
-  :description "Documentation generator for the Lux programming language's ."
-  :url "https://github.com/LuxLang/luxdoc"
-  :license {:name "Lux License v0.1"
-            :url "https://github.com/LuxLang/lux/blob/master/license.txt"}
-  :plugins [[com.github.luxlang/lein-luxc "0.5.0"]]
-  :dependencies []
-  :repositories [["snapshots" "https://oss.sonatype.org/content/repositories/snapshots/"]
-                 ["releases" "https://oss.sonatype.org/service/local/staging/deploy/maven2/"]]
-  :source-paths ["source"]
-  :lux {:program "program"})
diff --git a/luxdoc/source/program.lux b/luxdoc/source/program.lux
deleted file mode 100644
index 94b5df37f..000000000
--- a/luxdoc/source/program.lux
+++ /dev/null
@@ -1,601 +0,0 @@
-##  Copyright (c) Eduardo Julian. All rights reserved.
-##  This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
-##  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
-  (lux [cli #+ program:]
-       [compiler #+ Monad<Lux>]
-       host
-       [lexer]
-       [macro]
-       [math]
-       [pipe]
-       [random]
-       [regex]
-       [test]
-       [type]
-       (codata [cont]
-               [env]
-               function
-               [io #- run]
-               [state]
-               (struct [stream #+ Stream "Stream/" Functor<Stream>]))
-       (concurrency [actor]
-                    [atom]
-                    [frp]
-                    [promise]
-                    [stm])
-       (control [applicative]
-                [bounded]
-                [codec]
-                [comonad]
-                [effect]
-                [enum]
-                [eq]
-                [fold]
-                [functor]
-                [hash]
-                monad
-                [monoid]
-                ["_;" number]
-                [ord])
-       (data [bit]
-             [bool]
-             [char]
-             [error]
-             [ident "Ident/" Codec<Text,Ident>]
-             [identity]
-             [log]
-             maybe
-             [number #* "Nat/" Codec<Text,Nat>]
-             [product]
-             [sum]
-             [text "Text/" Monoid<Text> Eq<Text>]
-             (error [exception])
-             (format [json])
-             (struct [array]
-                     [dict]
-                     [list #+ "List/" Monoid<List> Functor<List> Fold<List>]
-                     [queue]
-                     [set]
-                     [stack]
-                     [tree]
-                     [vector]
-                     [zipper])
-             text/format)
-       (macro [ast]
-              [poly]
-              ["s" syntax]
-              (poly ["poly_;" eq]
-                    ["poly_;" functor]
-                    ["poly_;" text-encoder])
-              (syntax [common]))
-       (math [complex]
-             [ratio]
-             [simple])
-       (type [auto]
-             [check])
-       ))
-
-(def: name-options "abcdefghijklmnopqrstuvwxyz")
-(def: name-options-count (text;size name-options))
-
-(def: (id->name id)
-  (-> Nat Text)
-  (if (n.> name-options-count id)
-    (format (id->name (n./ name-options-count id))
-            (id->name (n.% name-options-count id)))
-    (char;as-text (default #"?" (text;at id name-options)))))
-
-(def: type-var-names
-  (Stream Text)
-  (Stream/map id->name (stream;iterate n.inc +0)))
-
-(def: (type-arg? id)
-  (-> Nat Bool)
-  (n.= +1 (n.% +2 id)))
-
-(def: (arg-id level id)
-  (-> Nat Nat Nat)
-  (n.- (n./ +2 id) level))
-
-(def: (bound->name [type-fun-name type-fun-args] level id)
-  (-> [Text (List Text)] Nat Nat Text)
-  (if (type-arg? id)
-    (let [_arg-id (arg-id level id)]
-      (case (list;at _arg-id type-fun-args)
-        (#;Some found)
-        found
-
-        _
-        (|> type-var-names
-            (stream;filter (lambda [var-name] (not (list;member? text;Eq<Text> type-fun-args var-name))))
-            (stream;at _arg-id))))      
-    type-fun-name))
-
-(do-template [<name> <base> <tag>]
-  [(def: (<base> level type)
-     (-> Nat Type [Nat Type])
-     (case type
-       (<tag> env type')
-       (<base> (n.inc level) type')
-
-       _
-       [level type]))
-
-   (def: <name> (<base> +0))]
-
-  [unravel-univ unravel-univ' #;UnivQ]
-  [unravel-ex   unravel-ex'   #;ExQ])
-
-(def: (level->args offset level)
-  (-> Nat Nat (List Text))
-  (if (n.= +0 level)
-    (list)
-    (|> level
-        n.dec
-        (list;n.range +0)
-        (List/map (|>. (n.+ (n.inc offset)) id->name)))))
-
-(def: (prefix-lines prefix lines)
-  (-> Text Text Text)
-  (|> lines
-      text;split-lines
-      (List/map (Text/append prefix))
-      ## (list;interpose "\n")
-      (text;join-with "")))
-
-(def: (pprint-type-def level type-fun-info tags module sig? type-rec? type)
-  (-> Nat [Text (List Text)] (List Ident) Text Bool Bool Type Text)
-  (case tags
-    (^ (list [_ single-tag]))
-    (if sig?
-      (format "(: " (pprint-type-def level type-fun-info #;None module sig? type-rec? type) "\n   " single-tag ")")
-      (format "{#" single-tag " " (pprint-type-def level type-fun-info #;None module sig? type-rec? type) "}"))
-
-    _
-    (case [type-rec? type]
-      [_ (#;HostT name params)]
-      (case params
-        #;Nil
-        (format "(host " name ")")
-
-        _
-        (format "(host " name " " (|> params (List/map (pprint-type-def level type-fun-info #;None module sig? type-rec?)) (text;join-with " ")) ")"))
-
-      [_ #;VoidT]
-      "Void"
-
-      [_ #;UnitT]
-      "Unit"
-
-      [_ (#;SumT _)]
-      (let [members (type;flatten-variant type)]
-        (case tags
-          #;Nil
-          (format "(| "
-                  (|> members
-                      (List/map (pprint-type-def level type-fun-info #;None module sig? type-rec?))
-                      (text;join-with " "))
-                  ")")
-
-          _
-          (|> members
-              (list;zip2 tags)
-              (List/map (lambda [[[_ t-name] type]]
-                          (case type
-                            #;UnitT
-                            (format "#" t-name)
-
-                            (#;ProdT _)
-                            (let [types (type;flatten-tuple type)]
-                              (format "(#" t-name " "
-                                      (|> types
-                                          (List/map (pprint-type-def level type-fun-info #;None module sig? type-rec?))
-                                          (text;join-with " "))
-                                      ")"))
-
-                            _
-                            (format "(#" t-name " " (pprint-type-def level type-fun-info #;None module sig? type-rec? type) ")"))))
-              (text;join-with "\n"))))
-
-      [_ (#;ProdT _)]
-      (let [members (type;flatten-tuple type)]
-        (case tags
-          #;Nil
-          (format "[" (|> members (List/map (pprint-type-def level type-fun-info #;None module sig? type-rec?)) (text;join-with " ")) "]")
-
-          _
-          (let [member-docs (|> members
-                                (list;zip2 tags)
-                                (List/map (lambda [[[_ t-name] type]]
-                                            (if sig?
-                                              (format "(: " (pprint-type-def level type-fun-info #;None module sig? type-rec? type) "\n   "  t-name ")")
-                                              (format "#" t-name " " (pprint-type-def level type-fun-info #;None module sig? type-rec? type)))))
-                                (text;join-with "\n "))]
-            (if sig?
-              member-docs
-              (format "{" member-docs "}")))))
-
-      [_ (#;LambdaT input output)]
-      (let [[ins out] (type;flatten-function type)]
-        (format  "(-> " (|> ins (List/map (pprint-type-def level type-fun-info #;None module sig? type-rec?)) (text;join-with " "))
-                 " "
-                 (pprint-type-def level type-fun-info #;None module sig? type-rec? out)
-                 ")"))
-
-      [_ (#;BoundT idx)]
-      (bound->name type-fun-info level idx)
-
-      (^template [<tag> <pre> <post>]
-        [_ (<tag> id)]
-        (format <pre> (Nat/encode id) <post>))
-      ([#;VarT "⌈v:" "⌋"]
-       [#;ExT  "⟨e:" "⟩"])
-      
-      (^template [<tag> <name> <unravel>]
-        [_ (<tag> _)]
-        (let [[level' body] (<unravel> type)
-              args (level->args level level')
-              body-doc (pprint-type-def (n.+ level level') type-fun-info tags module sig? type-rec? body)]
-          (format "(" <name> " " "[" (text;join-with " " args) "]"
-                  (case tags
-                    #;Nil
-                    (format " " body-doc)
-
-                    _
-                    (format "\n" (prefix-lines "  " body-doc)))
-                  ")")))
-      ([#;UnivQ "All" unravel-univ]
-       [#;ExQ   "Ex"  unravel-ex])
-
-      [true (#;AppT (#;BoundT +0) (#;BoundT +1))]
-      (product;left type-fun-info)
-      
-      [_ (#;AppT fun param)]
-      (let [[type-fun type-args] (type;flatten-application type)]
-        (format  "(" (pprint-type-def level type-fun-info tags module sig? type-rec? type-fun) " " (|> type-args (List/map (pprint-type-def level type-fun-info #;None module sig? type-rec?)) (text;join-with " ")) ")"))
-      
-      [_ (#;NamedT [_module _name] type)]
-      (if (Text/= module _module)
-        _name
-        (Ident/encode [_module _name]))
-      )))
-
-(def: (pprint-type level type-fun-name module type)
-  (-> Nat Text Text Type Text)
-  (case type
-    (#;HostT name params)
-    (case params
-      #;Nil
-      (format "(host " name ")")
-
-      _
-      (format "(host " name " " (|> params (List/map (pprint-type level type-fun-name module)) (list;interpose " ") (text;join-with "")) ")"))
-
-    #;VoidT
-    "Void"
-
-    (#;SumT _)
-    (let [members (type;flatten-variant type)]
-      (format "(| " (|> members (List/map (pprint-type level type-fun-name module)) (list;interpose " ") (text;join-with "")) ")"))
-
-    #;UnitT
-    "Unit"
-
-    (#;ProdT _)
-    (let [members (type;flatten-tuple type)]
-      (format "[" (|> members (List/map (pprint-type level type-fun-name module)) (list;interpose " ") (text;join-with "")) "]"))
-
-    (#;LambdaT input output)
-    (let [[ins out] (type;flatten-function type)]
-      (format  "(-> "
-               (|> ins (List/map (pprint-type level type-fun-name module)) (list;interpose " ") (text;join-with ""))
-               " "
-               (pprint-type level type-fun-name module out)
-               ")"))
-
-    (#;BoundT idx)
-    (bound->name [type-fun-name (list)] level idx)
-
-    (^template [<tag> <pre> <post>]
-      (<tag> id)
-      (format <pre> (Nat/encode id) <post>))
-    ([#;VarT "⌈" "⌋"]
-     [#;ExT  "⟨" "⟩"])
-
-    (^template [<tag> <name> <unravel>]
-      (<tag> _)
-      (let [[level' body] (<unravel> type)
-            args (level->args level level')
-            body-doc (pprint-type (n.+ level level') type-fun-name module body)]
-        (format "(" <name> " " "[" (|> args (list;interpose " ") (text;join-with "")) "]"
-                (format " " body-doc)
-                ")")))
-    ([#;UnivQ "All" unravel-univ]
-     [#;ExQ   "Ex"  unravel-ex])
-
-    (#;AppT fun param)
-    (let [[type-fun type-args] (type;flatten-application type)]
-      (format  "(" (pprint-type level type-fun-name module type-fun) " " (|> type-args (List/map (pprint-type level type-fun-name module)) (list;interpose " ") (text;join-with "")) ")"))
-
-    (#;NamedT [_module _name] type)
-    (if (Text/= module _module)
-      _name
-      (Ident/encode [_module _name]))
-    ))
-
-(type: Markdown
-  Text)
-
-(type: DefOrg
-  {#types (List [Text Anns Type])
-   #macros (List [Text Anns])
-   #structs (List [Text Anns Type])
-   #values (List [Text Anns Type])})
-
-(def: (lux-module? module-name)
-  (-> Text Bool)
-  (or (Text/= "lux" module-name)
-      (text;starts-with? "lux/" module-name)))
-
-(do-template [<name> <joiner>]
-  [(def: (<name> docs)
-     (-> (List Markdown) Markdown)
-     (text;join-with "\n\n" docs))]
-
-  [join-def-docs     "\n\n"]
-  [join-doc-sections "\n\n"]
-  )
-
-(def: (cons h t)
-  (All [a] (-> a (List a) (List a)))
-  (#;Cons h t))
-
-(def: (add-def [name [def-type def-meta def-value]] org)
-  (-> [Text Def] DefOrg DefOrg)
-  (cond (compiler;type? def-meta)
-        (update@ #types (cons [name def-meta (:coerce Type def-value)]) org)
-        
-        (compiler;macro? def-meta)
-        (update@ #macros (cons [name def-meta]) org)
-
-        (compiler;struct? def-meta)
-        (update@ #structs (cons [name def-meta def-type]) org)
-
-        ## else
-        (update@ #values (cons [name def-meta def-type]) org)))
-
-(def: def-sorter
-  (All [r] (-> (List [Text r]) (List [Text r])))
-  (list;sort (: (All [r] (-> [Text r] [Text r] Bool))
-                (lambda [[n1 _] [n2 _]] (:: text;Ord<Text> < n1 n2)))))
-
-(def: (organize-defs defs)
-  (-> (List [Text Def]) DefOrg)
-  (let [init {#types (list)
-              #macros (list)
-              #structs (list)
-              #values (list)}]
-    (|> (List/fold add-def init defs)
-        (update@ #types def-sorter)
-        (update@ #macros def-sorter)
-        (update@ #structs def-sorter)
-        (update@ #values def-sorter))))
-
-(def: (unravel-type-func level type)
-  (-> Nat Type Type)
-  (if (n.> +0 level)
-    (case type
-      (#;UnivQ _env _type)
-      (unravel-type-func (n.dec level) _type)
-
-      _
-      type)
-    type))
-
-(def: (unrecurse-type type)
-  (-> Type Type)
-  (case type
-    (#;AppT (#;UnivQ _env _type) _)
-    _type
-
-    _
-    type))
-
-(def: #export (when! test f x)
-  (All [a] (-> Bool (-> a a) a a))
-  (if test
-    (f x)
-    x))
-
-(def: #export (if! test f g x)
-  (All [a b] (-> Bool (-> a b) (-> a b) a b))
-  (if test
-    (f x)
-    (g x)))
-
-(def: (doc-type module type def-meta)
-  (-> Text Type Anns (Lux Markdown))
-  (case type
-    (#;NamedT type-name type)
-    (do Monad<Lux>
-      [tags (compiler;tags-of type-name)
-       #let [[_ _name] type-name
-             type-rec? (compiler;type-rec? def-meta)
-             type-args (compiler;type-args def-meta)
-             sig? (compiler;sig? def-meta)
-             usage (case type-args
-                     #;Nil
-                     _name
-
-                     _
-                     (format "(" (text;join-with " " (list& _name type-args)) ")"))
-             nesting (list;size type-args)]]
-      (wrap (format (if sig? "(signature: " "(type: ") (if type-rec? "#rec " "") usage "\n"
-                    (|> (pprint-type-def (n.dec nesting)
-                                         [_name type-args]
-                                         tags module sig? type-rec?
-                                         (|> type
-                                             (unravel-type-func nesting)
-                                             (when! type-rec? unrecurse-type)))
-                        text;split-lines
-                        (List/map (Text/append "  "))
-                        (text;join-with "\n"))
-                    ")")))
-
-    _
-    (compiler;fail (format "A type definition must always be named! - " (type;to-text type)))))
-
-(def: (doc-types module types)
-  (-> Text (List [Text Anns Type]) (Lux Markdown))
-  (do Monad<Lux>
-    [type-docs (mapM @
-                     (: (-> [Text Anns Type] (Lux Markdown))
-                        (lambda [[name def-meta type]]
-                          (do Monad<Lux>
-                            [#let [?doc (compiler;get-doc def-meta)
-                                   name (|> name
-                                            (text;replace "<" "&lt;")
-                                            (text;replace ">" "&gt;"))]
-                             type-doc (doc-type module type def-meta)]
-                            (wrap (format "### " name "\n"
-                                          (case ?doc
-                                            (#;Some doc)
-                                            (format doc "\n")
-
-                                            _
-                                            "")
-                                          "```\n" type-doc "\n```")))))
-                     types)]
-    (|> type-docs
-        join-def-docs
-        (format "## Types\n")
-        wrap)))
-
-(def: (doc-macros module-name names)
-  (-> Text (List [Text Anns]) Markdown)
-  (|> names
-      (List/map (: (-> [Text Anns] Markdown)
-                   (lambda [[name def-meta]]
-                     (let [name (|> name
-                                    (text;replace "<" "&lt;")
-                                    (text;replace ">" "&gt;"))]
-                       (format "### " name "\n"
-                               (default ""
-                                 (do Monad<Maybe>
-                                   [doc (compiler;get-doc def-meta)]
-                                   (wrap (format "```\n" doc "\n```")))))))))
-      join-def-docs
-      (format "## Macros\n")))
-
-(do-template [<singular> <plural> <header>]
-  [(def: <singular>
-     (-> Text Type Markdown)
-     (pprint-type (n.dec +0) "?"))
-
-   (def: (<plural> module values)
-     (-> Text (List [Text Anns Type]) Markdown)
-     (|> values
-         (List/map (lambda [[name def-meta value-type]]
-                      (let [?doc (compiler;get-doc def-meta)
-                            usage (case (compiler;func-args def-meta)
-                                    #;Nil
-                                    name
-
-                                    args
-                                    (format "(" (text;join-with " " (list& name args)) ")"))
-                            usage (|> usage
-                                      (text;replace "<" "&lt;")
-                                      (text;replace ">" "&gt;"))]
-                        (format "### " usage "\n"
-                                (case ?doc
-                                  (#;Some doc)
-                                  (format "```\n" doc "\n```\n")
-
-                                  _
-                                  "")
-                                "`" (<singular> module value-type) "`"))))
-         join-def-docs
-         (format <header>)))]
-
-  [doc-struct doc-structs "## Structs\n"]
-  [doc-value  doc-values  "## Values\n"]
-  )
-
-(def: (enclose-lines pre+post block)
-  (-> [Text Text] Text Text)
-  (|> block
-      text;split-lines
-      (List/map (text;enclose pre+post))
-      (text;join-with "\n")))
-
-(def: (doc-module [[module-name module] org])
-  (-> [[Text Module] DefOrg] (Lux [Text Markdown]))
-  (do Monad<Lux>
-    [#let [(^slots [#types #macros #structs #values]) org
-           anns (|> module (get@ #;module-anns) compiler;get-doc)]
-     types-md (if (list;empty? types)
-                (wrap "")
-                (doc-types module-name types))
-     #let [doc-desc (case anns
-                      #;None
-                      ""
-
-                      (#;Some doc)
-                      (format "\n" (enclose-lines ["> " ""] doc) "\n"))
-           doc-body (join-doc-sections (list types-md
-                                             (if (list;empty? macros) "" (doc-macros module-name macros))
-                                             (if (list;empty? structs) "" (doc-structs module-name structs))
-                                             (if (list;empty? values) "" (doc-values module-name values))))]]
-    (wrap [module-name
-           (format "## " module-name "\n"
-                   doc-desc "\n"
-                   doc-body)])))
-
-(jvm-import java.io.File
-  (new [java.lang.String]))
-
-(jvm-import java.io.PrintWriter
-  (new [java.io.File] #io #try)
-  (println [java.lang.String] #io void))
-
-(jvm-import java.io.Writer
-  (flush [] #io #try void))
-
-(def: (save-docs! [module-name docs])
-  (-> [Text Markdown] (IO Unit))
-  (do Monad<IO>
-    [?target (|> (format (text;replace "/" "_" module-name) ".md")
-                 File.new
-                 PrintWriter.new)]
-    (case ?target
-      (#;Left _)
-      (wrap [])
-      
-      (#;Right target)
-      (do @
-        [_ (PrintWriter.println docs target)
-         _ (Writer.flush [] target)]
-        (wrap [])))))
-
-(macro: (gen-docs! _)
-  (do Monad<Lux>
-    [all-modules compiler;modules
-     #let [lux-modules (|> all-modules
-                           (list;filter (. lux-module? product;left))
-                           (list;sort (lambda [[left _] [right _]]
-                                        (:: text;Ord<Text> < left right))))]
-     lux-exports (mapM @ (. compiler;exports product;left) lux-modules)
-     module-docs (mapM @ doc-module
-                       (list;zip2 lux-modules
-                                  (List/map organize-defs lux-exports)))
-     #let [_ (io;run (mapM Monad<IO> save-docs! module-docs))]]
-    (wrap (list))))
-
-(gen-docs!)
-
-(program: args
-  (io (log! "Done!")))
diff --git a/stdlib/project.clj b/stdlib/project.clj
index e9ed11d34..79319f540 100644
--- a/stdlib/project.clj
+++ b/stdlib/project.clj
@@ -16,9 +16,10 @@
   :scm {:name "git"
         :url "https://github.com/LuxLang/lux.git"}
 
-  :dependencies []
-  
   :source-paths ["source"]
-  :test-paths ["test"]
-  :lux {:tests {:jvm "test"}}
+  :profiles {:library {:dependencies []
+                       :test-paths ["test"]
+                       :lux {:tests {:jvm "test"}}}
+             :documentation {:dependencies []
+                             :lux {:program {:jvm "program/scriptum"}}}}
   )
diff --git a/stdlib/source/lux.lux b/stdlib/source/lux.lux
index 1a35b4ebd..e0717c88c 100644
--- a/stdlib/source/lux.lux
+++ b/stdlib/source/lux.lux
@@ -5999,13 +5999,6 @@
     _
     (#Left (..wrong-syntax-error (name-of ..char)))))
 
-(def: #export (when test f)
-  (All [a] (-> Bit (-> a a) (-> a a)))
-  (function (_ value)
-    (if test
-      (f value)
-      value)))
-
 (def: target
   (Meta Text)
   (function (_ compiler)
diff --git a/stdlib/source/lux/control/comonad.lux b/stdlib/source/lux/control/comonad.lux
index 853c43615..980935216 100644
--- a/stdlib/source/lux/control/comonad.lux
+++ b/stdlib/source/lux/control/comonad.lux
@@ -2,17 +2,15 @@
   [lux #*
    [data
     [collection
-     ["." list ("list/." Fold)]
-     ["." sequence]]]]
+     ["." list ("list/." fold)]]]]
   [//
-   ["F" functor]])
+   ["." functor (#+ Functor)]])
 
-## [Signatures]
 (signature: #export (CoMonad w)
   {#.doc (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)
+  (: (Functor w)
+     &functor)
   (: (All [a]
        (-> (w a) a))
      unwrap)
@@ -20,18 +18,16 @@
        (-> (w a) (w (w a))))
      split))
 
-## [Types]
 (type: #export (CoFree F a)
   {#.doc "The CoFree CoMonad."}
   [a (F (CoFree F a))])
 
-## [Syntax]
 (def: _cursor Cursor ["" 0 0])
 
 (macro: #export (be tokens state)
   {#.doc (doc "A co-monadic parallel to the 'do' macro."
               (let [square (function (_ n) (i/* n n))]
-                (be sequence.comonad
+                (be comonad
                   [inputs (iterate inc +2)]
                   (square (head inputs)))))}
   (case tokens
@@ -53,7 +49,9 @@
                              body
                              (list.reverse (list.as-pairs bindings)))]
         (#.Right [state (#.Cons (` ({(~' @)
-                                     ({{#functor {#F.map (~ g!map)} #unwrap (~' unwrap) #split (~ g!split)}
+                                     ({{#&functor {#functor.map (~ g!map)}
+                                        #unwrap (~' unwrap)
+                                        #split (~ g!split)}
                                        (~ body')}
                                       (~' @))}
                                     (~ comonad)))
diff --git a/stdlib/source/lux/control/continuation.lux b/stdlib/source/lux/control/continuation.lux
index 66233773a..7a1fd7be8 100644
--- a/stdlib/source/lux/control/continuation.lux
+++ b/stdlib/source/lux/control/continuation.lux
@@ -3,29 +3,59 @@
    [control
     [functor (#+ Functor)]
     [apply (#+ Apply)]
-    monad]
-   function
+    [monad (#+ Monad do)]]
+   ["." function]
    [macro (#+ with-gensyms)
-    [code]
-    [syntax (#+ syntax:)]]])
+    ["." code]
+    ["s" syntax (#+ syntax:)]]])
 
 (type: #export (Cont i o)
   {#.doc "Continuations."}
   (-> (-> i o) o))
 
-(def: #export (continue k cont)
-  {#.doc "Forces a continuation thunk to be evaluated."}
+(def: #export (continue next cont)
+  {#.doc "Continues a thunk."}
   (All [i o] (-> (-> i o) (Cont i o) o))
-  (cont k))
+  (cont next))
 
 (def: #export (run cont)
   {#.doc "Forces a continuation thunk to be evaluated."}
   (All [a] (-> (Cont a a) a))
-  (cont id))
+  (cont function.identity))
+
+(def: #export (call/cc f)
+  {#.doc "Call with current continuation."}
+  (All [a b z]
+    (-> (-> (-> a (Cont b z))
+            (Cont a z))
+        (Cont a z)))
+  (function (_ k)
+    (f (function (_ a) (function (_ _) (k a)))
+       k)))
+
+(syntax: #export (pending expr)
+  {#.doc (doc "Turns any expression into a function that is pending a continuation."
+              (pending (some-function some-input)))}
+  (with-gensyms [g!_ g!k]
+    (wrap (list (` (.function ((~ g!_) (~ g!k)) ((~ g!k) (~ expr))))))))
+
+(def: #export (reset scope)
+  (All [i o] (-> (Cont i i) (Cont i o)))
+  (function (_ k)
+    (k (run scope))))
+
+(def: #export (shift f)
+  (All [a]
+    (-> (-> (-> a (Cont a a))
+            (Cont a a))
+        (Cont a a)))
+  (function (_ oc)
+    (f (function (_ a) (function (_ ic) (ic (oc a))))
+       function.identity)))
 
 (structure: #export functor (All [o] (Functor (All [i] (Cont i o))))
   (def: (map f fv)
-    (function (_ k) (fv (compose k f)))))
+    (function (_ k) (fv (function.compose k f)))))
 
 (structure: #export apply (All [o] (Apply (All [i] (Cont i o))))
   (def: &functor ..functor)
@@ -46,22 +76,6 @@
     (function (_ k)
       (ffa (continue k)))))
 
-(def: #export (call/cc f)
-  {#.doc "Call with current continuation."}
-  (All [a b z]
-    (-> (-> (-> a (Cont b z))
-            (Cont a z))
-        (Cont a z)))
-  (function (_ k)
-    (f (function (_ a) (function (_ _) (k a)))
-       k)))
-
-(syntax: #export (pending expr)
-  {#.doc (doc "Turns any expression into a function that is pending a continuation."
-              (pending (some-function some-input)))}
-  (with-gensyms [g!_ g!k]
-    (wrap (list (` (.function ((~ g!_) (~ g!k)) ((~ g!k) (~ expr))))))))
-
 (def: #export (portal init)
   (All [i o z]
     (-> i
@@ -74,17 +88,3 @@
                               (k [nexus val]))]
                 _ (k [nexus init])]
                (wrap (undefined))))))
-
-(def: #export (reset scope)
-  (All [i o] (-> (Cont i i) (Cont i o)))
-  (function (_ k)
-    (k (run scope))))
-
-(def: #export (shift f)
-  (All [a]
-    (-> (-> (-> a (Cont a a))
-            (Cont a a))
-        (Cont a a)))
-  (function (_ oc)
-    (f (function (_ a) (function (_ ic) (ic (oc a))))
-       id)))
diff --git a/stdlib/source/lux/data/collection/sequence.lux b/stdlib/source/lux/data/collection/sequence.lux
index 30b2bf46e..bd2c7ae03 100644
--- a/stdlib/source/lux/data/collection/sequence.lux
+++ b/stdlib/source/lux/data/collection/sequence.lux
@@ -1,16 +1,15 @@
 (.module:
   [lux #*
    [control
-    functor
-    monad
-    comonad
+    [functor (#+ Functor)]
+    [comonad (#+ CoMonad)]
     ["." continuation (#+ pending Cont)]
     ["p" parser]]
    [macro (#+ with-gensyms)
     ["." code]
     ["s" syntax (#+ syntax: Syntax)]]
    [data
-    bit
+    ["." bit]
     [collection
      [list ("list/." monad)]]]])
 
@@ -22,8 +21,11 @@
   (All [a]
     (-> a (List a) a (List a) (Sequence a)))
   (case xs
-    #.Nil           (pending [x (cycle' init full init full)])
-    (#.Cons x' xs') (pending [x (cycle' x' xs' init full)])))
+    #.Nil
+    (pending [x (cycle' init full init full)])
+    
+    (#.Cons x' xs')
+    (pending [x (cycle' x' xs' init full)])))
 
 (def: #export (iterate f x)
   {#.doc "Create a sequence by applying a function to a value, and to its result, on and on..."}
@@ -43,8 +45,11 @@
   (All [a]
     (-> (List a) (Maybe (Sequence a))))
   (case xs
-    #.Nil          #.None
-    (#.Cons x xs') (#.Some (cycle' x xs' x xs'))))
+    #.Nil
+    #.None
+    
+    (#.Cons x xs')
+    (#.Some (cycle' x xs' x xs'))))
 
 (do-template [<name> <return> <part>]
   [(def: #export (<name> s)
@@ -106,12 +111,12 @@
       (pending [x (filter p xs')])
       (filter p xs'))))
 
-(def: #export (partition p xs)
+(def: #export (partition left? xs)
   {#.doc (doc "Split a sequence in two based on a predicate."
               "The left side contains all entries for which the predicate is #1."
               "The right side contains all entries for which the predicate is #0.")}
   (All [a] (-> (-> a Bit) (Sequence a) [(Sequence a) (Sequence a)]))
-  [(filter p xs) (filter (complement p) xs)])
+  [(filter left? xs) (filter (bit.complement left?) xs)])
 
 (structure: #export functor (Functor Sequence)
   (def: (map f fa)
diff --git a/stdlib/source/lux/data/format/markdown.lux b/stdlib/source/lux/data/format/markdown.lux
index 757fca9b3..5fcf85cbf 100644
--- a/stdlib/source/lux/data/format/markdown.lux
+++ b/stdlib/source/lux/data/format/markdown.lux
@@ -38,14 +38,20 @@
 
   Text
 
+  (def: #export empty
+    Markdown
+    (:abstraction ""))
+
   (def: #export text
     (-> Text (Markdown Span))
     (|>> ..sanitize :abstraction))
 
+  (def: blank-line (format text.new-line text.new-line))
+
   (do-template [<name> <prefix>]
     [(def: #export (<name> content)
        (-> Text Markdown)
-       (:abstraction (format <prefix> (..sanitize content) text.new-line)))]
+       (:abstraction (format <prefix> " " (..sanitize content) ..blank-line)))]
 
     [heading/1 "#"]
     [heading/2 "##"]
@@ -55,8 +61,6 @@
     [heading/6 "######"]
     )
 
-  (def: blank-line (format text.new-line text.new-line))
-
   (def: (block content)
     (-> Text (Markdown Block))
     (:abstraction (format content ..blank-line)))
@@ -136,7 +140,9 @@
   (def: #export code
     {#.doc "A block of code."}
     (-> Text (Markdown Block))
-    (|>> ..indent ..block))
+    (let [open (format "```" text.new-line)
+          close (format text.new-line "```")]
+      (|>> (text.enclose [open close]) ..block)))
 
   (def: #export (image description url)
     (-> Text URL (Markdown Span))
diff --git a/stdlib/source/lux/data/text.lux b/stdlib/source/lux/data/text.lux
index 921e7c96c..a87aa0626 100644
--- a/stdlib/source/lux/data/text.lux
+++ b/stdlib/source/lux/data/text.lux
@@ -150,9 +150,6 @@
     #.None
     (#.Cons sample #.Nil)))
 
-(def: #export split-lines
-  (..split-all-with ..new-line))
-
 (def: #export (replace-once pattern value template)
   (-> Text Text Text Text)
   (<| (maybe.default template)
diff --git a/stdlib/source/lux/macro.lux b/stdlib/source/lux/macro.lux
index abfcd4d86..a4b439c62 100644
--- a/stdlib/source/lux/macro.lux
+++ b/stdlib/source/lux/macro.lux
@@ -185,7 +185,7 @@
   [get-record-ann     #.Record     (List [Code Code])]
   )
 
-(def: #export (get-doc anns)
+(def: #export (get-documentation anns)
   {#.doc "Looks-up a definition's documentation."}
   (-> Code (Maybe Text))
   (get-text-ann (name-of #.doc) anns))
@@ -201,12 +201,12 @@
      (-> Code Bit)
      (flag-set? (name-of <tag>)))]
 
-  [export?   #.export?   "exported"]
-  [macro?    #.macro?    "a macro"]
-  [type?     #.type?     "a type"]
-  [struct?   #.struct?   "a structure"]
-  [type-rec? #.type-rec? "a recursive type"]
-  [sig?      #.sig?      "a signature"]
+  [export?         #.export?   "exported"]
+  [macro?          #.macro?    "a macro"]
+  [type?           #.type?     "a type"]
+  [structure?      #.struct?   "a structure"]
+  [recursive-type? #.type-rec? "a recursive type"]
+  [signature?      #.sig?      "a signature"]
   )
 
 (def: #export (aliased? annotations)
@@ -242,9 +242,9 @@
                        args (parse-tuple _args)]
                       (monad.map @ parse-text args))))]
 
-  [func-args     #.func-args "Looks up the arguments of a function."]
-  [type-args     #.type-args "Looks up the arguments of a parameterized type."]
-  [declared-tags #.tags      "Looks up the tags of a tagged (variant or record) type."]
+  [function-arguments #.func-args "Looks up the arguments of a function."]
+  [type-arguments     #.type-args "Looks up the arguments of a parameterized type."]
+  [declared-tags      #.tags      "Looks up the tags of a tagged (variant or record) type."]
   )
 
 (def: (find-macro' modules this-module module name)
diff --git a/stdlib/source/program/scriptum.lux b/stdlib/source/program/scriptum.lux
new file mode 100644
index 000000000..a9a72ca36
--- /dev/null
+++ b/stdlib/source/program/scriptum.lux
@@ -0,0 +1,518 @@
+(.module:
+  [lux #*
+   [control
+    [pipe (#+ when>)]
+    ["." monad (#+ do)]
+    ["ex" exception (#+ exception:)]
+    [security
+     ["!" capability]]]
+   [cli (#+ program:)]
+   [data
+    ["." maybe]
+    ["." product]
+    ["." error (#+ Error)]
+    [format
+     ["md" markdown (#+ Markdown Span Block)]]
+    ["." text ("text/." equivalence)
+     format
+     ["." encoding]]
+    [collection
+     ["." sequence (#+ Sequence) ("sequence/." functor)]
+     ["." list ("list/." functor fold)]]]
+   ["." function]
+   ["." type]
+   ["." macro]
+   ["." io (#+ IO io)]
+   [world
+    ["." file (#+ File)]]])
+
+(def: name-options "abcdefghijklmnopqrstuvwxyz")
+(def: name-options-count (text.size name-options))
+
+(def: (parameter-type-name id)
+  (-> Nat Text)
+  (case (text.nth id ..name-options)
+    (#.Some char)
+    (text.from-code char)
+
+    #.None
+    (format (parameter-type-name (n// name-options-count id))
+            (parameter-type-name (n/% name-options-count id)))))
+
+(def: type-var-names
+  (Sequence Text)
+  (|> 0 (sequence.iterate inc) (sequence/map parameter-type-name)))
+
+(do-template [<name> <partition>]
+  [(def: (<name> id)
+     (-> Nat Bit)
+     (<partition> id))]
+
+  [type-func? n/even?]
+  [type-arg? n/odd?]
+  )
+
+(def: (arg-id level id)
+  (-> Nat Nat Nat)
+  (n/- (n// 2 id) level))
+
+(def: (parameter->name [type-func-name type-function-arguments] level id)
+  (-> [Text (List Text)] Nat Nat Text)
+  (if (type-arg? id)
+    (let [arg-id (..arg-id level id)]
+      (case (list.nth arg-id type-function-arguments)
+        (#.Some found)
+        found
+
+        _
+        (|> type-var-names
+            (sequence.filter (function (_ var-name)
+                               (not (list.member? text.equivalence type-function-arguments var-name))))
+            (sequence.nth arg-id))))      
+    type-func-name))
+
+(def: (level->args offset level)
+  (-> Nat Nat (List Text))
+  (if (n/= 0 level)
+    (list)
+    (|> level
+        dec
+        (list.n/range 0)
+        (list/map (|>> (n/+ (inc offset)) parameter-type-name)))))
+
+(def: (prefix-lines prefix lines)
+  (-> Text Text Text)
+  (|> lines
+      (text.split-all-with text.new-line)
+      (list/map (|>> (format prefix)))
+      (text.join-with text.new-line)))
+
+(def: (pprint-type-definition level type-func-info tags module signature? recursive-type? type)
+  (-> Nat [Text (List Text)] (List Name) Text Bit Bit Type Text)
+  (case tags
+    (^ (list [_ single-tag]))
+    (if signature?
+      (format "(: " (pprint-type-definition level type-func-info #.None module signature? recursive-type? type) text.new-line "   " single-tag ")")
+      (format "{#" single-tag " " (pprint-type-definition level type-func-info #.None module signature? recursive-type? type) "}"))
+
+    _
+    (case [recursive-type? type]
+      [_ (#.Primitive name params)]
+      (case params
+        #.Nil
+        (format "(primitive " (%t name) ")")
+
+        _
+        (format "(primitive " (%t name) " " (|> params (list/map (pprint-type-definition level type-func-info #.None module signature? recursive-type?)) (text.join-with " ")) ")"))
+
+      [_ (#.Sum _)]
+      (let [members (type.flatten-variant type)]
+        (case tags
+          #.Nil
+          (format "(| "
+                  (|> members
+                      (list/map (pprint-type-definition level type-func-info #.None module signature? recursive-type?))
+                      (text.join-with " "))
+                  ")")
+
+          _
+          (|> members
+              (list.zip2 tags)
+              (list/map (function (_ [[_ t-name] type])
+                          (case type
+                            (#.Product _)
+                            (let [types (type.flatten-tuple type)]
+                              (format "(#" t-name " "
+                                      (|> types
+                                          (list/map (pprint-type-definition level type-func-info #.None module signature? recursive-type?))
+                                          (text.join-with " "))
+                                      ")"))
+
+                            _
+                            (format "(#" t-name " " (pprint-type-definition level type-func-info #.None module signature? recursive-type? type) ")"))))
+              (text.join-with text.new-line))))
+
+      [_ (#.Product _)]
+      (let [members (type.flatten-tuple type)]
+        (case tags
+          #.Nil
+          (format "[" (|> members (list/map (pprint-type-definition level type-func-info #.None module signature? recursive-type?)) (text.join-with " ")) "]")
+
+          _
+          (let [member-docs (|> members
+                                (list.zip2 tags)
+                                (list/map (function (_ [[_ t-name] type])
+                                            (if signature?
+                                              (format "(: " (pprint-type-definition level type-func-info #.None module signature? recursive-type? type) text.new-line "   "  t-name ")")
+                                              (format "#" t-name " " (pprint-type-definition level type-func-info #.None module signature? recursive-type? type)))))
+                                (text.join-with (format text.new-line " ")))]
+            (if signature?
+              member-docs
+              (format "{" member-docs "}")))))
+
+      [_ (#.Function input output)]
+      (let [[ins out] (type.flatten-function type)]
+        (format  "(-> " (|> ins (list/map (pprint-type-definition level type-func-info #.None module signature? recursive-type?)) (text.join-with " "))
+                 " "
+                 (pprint-type-definition level type-func-info #.None module signature? recursive-type? out)
+                 ")"))
+
+      [_ (#.Parameter idx)]
+      (parameter->name type-func-info level idx)
+
+      (^template [<tag> <pre> <post>]
+        [_ (<tag> id)]
+        (format <pre> (%n id) <post>))
+      ([#.Var "⌈v:" "⌋"]
+       [#.Ex  "⟨e:" "⟩"])
+
+      (^template [<tag> <name> <flatten>]
+        [_ (<tag> _)]
+        (let [[level' body] (<flatten> type)
+              args (level->args level level')
+              body-doc (pprint-type-definition (n/+ level level') type-func-info tags module signature? recursive-type? body)]
+          (format "(" <name> " " "[" (text.join-with " " args) "]"
+                  (case tags
+                    #.Nil
+                    (format " " body-doc)
+
+                    _
+                    (format text.new-line (prefix-lines "  " body-doc)))
+                  ")")))
+      ([#.UnivQ "All" type.flatten-univ-q]
+       [#.ExQ   "Ex"  type.flatten-ex-q])
+
+      [true (#.Apply (#.Parameter 1) (#.Parameter 0))]
+      (product.left type-func-info)
+
+      [_ (#.Apply param fun)]
+      (let [[type-func type-arguments] (type.flatten-application type)]
+        (format  "(" (pprint-type-definition level type-func-info tags module signature? recursive-type? type-func) " " (|> type-arguments (list/map (pprint-type-definition level type-func-info #.None module signature? recursive-type?)) (text.join-with " ")) ")"))
+
+      [_ (#.Named [_module _name] type)]
+      (if (text/= module _module)
+        _name
+        (%name [_module _name]))
+      )))
+
+(def: (pprint-type level type-func-name module type)
+  (-> Nat Text Text Type Text)
+  (case type
+    (#.Primitive name params)
+    (case params
+      #.Nil
+      (format "(primitive " (%t name) ")")
+
+      _
+      (format "(primitive " (%t name) " " (|> params (list/map (pprint-type level type-func-name module)) (list.interpose " ") (text.join-with "")) ")"))
+
+    (#.Sum _)
+    (let [members (type.flatten-variant type)]
+      (format "(| " (|> members (list/map (pprint-type level type-func-name module)) (list.interpose " ") (text.join-with "")) ")"))
+
+    (#.Product _)
+    (let [members (type.flatten-tuple type)]
+      (format "[" (|> members (list/map (pprint-type level type-func-name module)) (list.interpose " ") (text.join-with "")) "]"))
+
+    (#.Function input output)
+    (let [[ins out] (type.flatten-function type)]
+      (format  "(-> "
+               (|> ins (list/map (pprint-type level type-func-name module)) (list.interpose " ") (text.join-with ""))
+               " "
+               (pprint-type level type-func-name module out)
+               ")"))
+
+    (#.Parameter idx)
+    (parameter->name [type-func-name (list)] level idx)
+
+    (^template [<tag> <pre> <post>]
+      (<tag> id)
+      (format <pre> (%n id) <post>))
+    ([#.Var "⌈" "⌋"]
+     [#.Ex  "⟨" "⟩"])
+
+    (^template [<tag> <name> <flatten>]
+      (<tag> _)
+      (let [[level' body] (<flatten> type)
+            args (level->args level level')
+            body-doc (pprint-type (n/+ level level') type-func-name module body)]
+        (format "(" <name> " " "[" (|> args (list.interpose " ") (text.join-with "")) "]"
+                (format " " body-doc)
+                ")")))
+    ([#.UnivQ "All" type.flatten-univ-q]
+     [#.ExQ   "Ex"  type.flatten-ex-q])
+
+    (#.Apply param fun)
+    (let [[type-func type-arguments] (type.flatten-application type)]
+      (format  "(" (pprint-type level type-func-name module type-func) " " (|> type-arguments (list/map (pprint-type level type-func-name module)) (list.interpose " ") (text.join-with "")) ")"))
+
+    (#.Named [_module _name] type)
+    (if (text/= module _module)
+      _name
+      (%name [_module _name]))
+    ))
+
+(type: (Mutation a)
+  (-> a a))
+
+(type: Value [Text Code Type])
+
+(type: Organization
+  {#types (List Value)
+   #macros (List [Text Code])
+   #structures (List Value)
+   #values (List Value)})
+
+(def: (lux-module? module-name)
+  (-> Text Bit)
+  (or (text/= "lux" module-name)
+      (text.starts-with? "lux/" module-name)))
+
+(def: (add-definition [name [def-type def-annotations def-value]] organization)
+  (-> [Text Definition] Organization Organization)
+  (cond (macro.type? def-annotations)
+        (update@ #types
+                 (: (Mutation (List Value))
+                    (|>> (#.Cons [name def-annotations (:coerce Type def-value)])))
+                 organization)
+
+        (macro.macro? def-annotations)
+        (update@ #macros
+                 (: (Mutation (List [Text Code]))
+                    (|>> (#.Cons [name def-annotations])))
+                 organization)
+
+        (macro.structure? def-annotations)
+        (update@ #structures
+                 (: (Mutation (List Value))
+                    (|>> (#.Cons [name def-annotations def-type])))
+                 organization)
+
+        ## else
+        (update@ #values
+                 (: (Mutation (List Value))
+                    (|>> (#.Cons [name def-annotations def-type])))
+                 organization)))
+
+(def: name-sort
+  (All [r] (-> [Text r] [Text r] Bit))
+  (let [text/< (:: text.order <)]
+    (function (_ [n1 _] [n2 _])
+      (text/< n1 n2))))
+
+(def: (organize-definitions defs)
+  (-> (List [Text Definition]) Organization)
+  (let [init {#types (list)
+              #macros (list)
+              #structures (list)
+              #values (list)}]
+    (|> (list/fold add-definition init defs)
+        (update@ #types (list.sort name-sort))
+        (update@ #macros (list.sort name-sort))
+        (update@ #structures (list.sort name-sort))
+        (update@ #values (list.sort name-sort)))))
+
+(def: (unravel-type-func level type)
+  (-> Nat Type Type)
+  (if (n/> 0 level)
+    (case type
+      (#.UnivQ _env _type)
+      (unravel-type-func (dec level) _type)
+
+      _
+      type)
+    type))
+
+(def: (unrecurse-type type)
+  (-> Type Type)
+  (case type
+    (#.Apply _ (#.UnivQ _env _type))
+    _type
+
+    _
+    type))
+
+(exception: #export (anonymous-type-definition {type Type})
+  (ex.report ["Type" (%type type)]))
+
+(def: (document-type module type def-annotations)
+  (-> Text Type Code (Meta (Markdown Block)))
+  (case type
+    (#.Named type-name type)
+    (do macro.monad
+      [tags (macro.tags-of type-name)
+       #let [[_ _name] type-name
+             recursive-type? (macro.recursive-type? def-annotations)
+             ## type (: Type
+             ##         (case [recursive-type? type]
+             ##           [#1 (#.Apply dummyT (#.UnivQ _closure recursiveT))]
+             ##           recursiveT
+
+             ##           _
+             ##           type))
+             type-arguments (macro.type-arguments def-annotations)
+             signature? (macro.signature? def-annotations)
+             usage (case type-arguments
+                     #.Nil
+                     _name
+
+                     _
+                     (format "(" (text.join-with " " (list& _name type-arguments)) ")"))
+             nesting (list.size type-arguments)]]
+      (wrap (md.code (format (if signature? "(signature: " "(type: ")
+                             (if recursive-type? "#rec " "")
+                             usage text.new-line
+                             (|> type
+                                 (unravel-type-func nesting)
+                                 (when> recursive-type? [unrecurse-type])
+                                 (pprint-type-definition (dec nesting) [_name type-arguments] (maybe.default (list) tags) module signature? recursive-type?)
+                                 (text.split-all-with text.new-line)
+                                 (list/map (|>> (format "  ")))
+                                 (text.join-with text.new-line))
+                             ")"))))
+
+    _
+    (macro.fail (ex.construct anonymous-type-definition type))))
+
+(def: (document-types module types)
+  (-> Text (List Value) (Meta (Markdown Block)))
+  (do macro.monad
+    [type-docs (monad.map @
+                          (: (-> Value (Meta (Markdown Block)))
+                             (function (_ [name def-annotations type])
+                               (do macro.monad
+                                 [#let [?doc (macro.get-documentation def-annotations)]
+                                  type-code (document-type module type def-annotations)]
+                                 (wrap ($_ md.then
+                                           (md.heading/3 name)
+                                           (case ?doc
+                                             (#.Some doc)
+                                             (md.paragraph (md.text doc))
+
+                                             _
+                                             md.empty)
+                                           type-code)))))
+                          types)]
+    (wrap (list/fold (function.flip md.then)
+                     (md.heading/2 "Types")
+                     type-docs))))
+
+(def: (document-macros module-name names)
+  (-> Text (List [Text Code]) (Markdown Block))
+  (|> names
+      (list/map (: (-> [Text Code] (Markdown Block))
+                   (function (_ [name def-annotations])
+                     ($_ md.then
+                         (md.heading/3 name)
+                         (<| (: (Markdown Block))
+                             (maybe.default md.empty)
+                             (do maybe.monad
+                               [documentation (macro.get-documentation def-annotations)]
+                               (wrap (md.code documentation))))))))
+      (list/fold (function.flip md.then)
+                 (md.heading/2 "Macros"))))
+
+(do-template [<singular> <plural> <header>]
+  [(def: (<singular> module type)
+     (-> Text Type (Markdown Block))
+     (md.code (pprint-type (dec 0) "?" module type)))
+
+   (def: (<plural> module values)
+     (-> Text (List Value) (Markdown Block))
+     (|> values
+         (list/map (function (_ [name def-annotations value-type])
+                     (let [?doc (macro.get-documentation def-annotations)
+                           usage (case (macro.function-arguments def-annotations)
+                                   #.Nil
+                                   name
+
+                                   args
+                                   (format "(" (text.join-with " " (list& name args)) ")"))]
+                       ($_ md.then
+                           (md.heading/3 usage)
+                           (case ?doc
+                             (#.Some doc)
+                             (md.code doc)
+
+                             _
+                             md.empty)
+                           (<singular> module value-type)))))
+         (list/fold (function.flip md.then)
+                    (md.heading/2 <header>))))]
+
+  [document-structure document-structures "Structures"]
+  [document-value     document-values     "Values"]
+  )
+
+(def: (enclose-lines pre+post block)
+  (-> [Text Text] Text Text)
+  (|> block
+      (text.split-all-with text.new-line)
+      (list/map (text.enclose pre+post))
+      (text.join-with text.new-line)))
+
+(def: (document-module [[module-name module] organization])
+  (-> [[Text Module] Organization] (Meta [Text (Markdown Block)]))
+  (do macro.monad
+    [#let [(^slots [#types #macros #structures #values]) organization
+           annotations (|> module
+                           (get@ #.module-annotations)
+                           (maybe.default (' {}))
+                           macro.get-documentation)
+           description (case annotations
+                         (#.Some doc-text)
+                         (md.quote (md.paragraph (md.text doc-text)))
+
+                         #.None
+                         md.empty)
+           empty-block (: (Markdown Block) md.empty)]
+     types-documentation (if (list.empty? types)
+                           (wrap empty-block)
+                           (document-types module-name types))
+     #let [documentation ($_ md.then
+                             types-documentation
+                             (if (list.empty? macros) empty-block (document-macros module-name macros))
+                             (if (list.empty? structures) empty-block (document-structures module-name structures))
+                             (if (list.empty? values) empty-block (document-values module-name values)))]]
+    (wrap [module-name
+           ($_ md.then
+               (md.heading/1 module-name)
+               description
+               documentation)])))
+
+(exception: #export (io-error {error Text})
+  error)
+
+(def: (save-documentation! [module-name documentation])
+  (-> [Text (Markdown Block)] (IO Any))
+  (let [path (format (text.replace-all "/" "_" module-name) ".md")]
+    (do io.monad
+      [outcome (do (error.with-error io.monad)
+                 [target (: (IO (Error (File IO)))
+                            (file.get-file io.monad file.system path))]
+                 (!.use (:: target over-write) (encoding.to-utf8 (md.markdown documentation))))]
+      (case outcome
+        (#error.Failure error)
+        (wrap (log! (ex.construct io-error error)))
+
+        (#error.Success _)
+        (wrap [])))))
+
+(macro: (gen-documentation! _)
+  (do macro.monad
+    [all-modules macro.modules
+     #let [lux-modules (|> all-modules
+                           (list.filter (function.compose lux-module? product.left))
+                           (list.sort name-sort))]
+     lux-exports (monad.map @ (function.compose macro.exports product.left)
+                            lux-modules)
+     module-documentation (|> (list/map organize-definitions lux-exports)
+                              (list.zip2 lux-modules)
+                              (monad.map @ document-module))
+     #let [_ (io.run (monad.map io.monad save-documentation! module-documentation))]]
+    (wrap (list))))
+
+(gen-documentation!)
+
+(program: args
+  (io (log! "Done!")))