More adjustments for Common Lisp.

7 files changed, 499 insertions, 439 deletions

diff --git a/stdlib/source/lux.lux b/stdlib/source/lux.lux
index 0b8941ba7..276a8e6e7 100644
--- a/stdlib/source/lux.lux
+++ b/stdlib/source/lux.lux
@@ -8,13 +8,13 @@
  [dummy_location (9 #1 (0 #0))]
  #0)
 
-("lux def" new_line
+("lux def" \n
  ("lux i64 char" +10)
  [dummy_location (9 #1 (0 #0))]
  #0)
 
 ("lux def" __paragraph
- ("lux text concat" new_line new_line)
+ ("lux text concat" \n \n)
  [dummy_location (9 #1 (0 #0))]
  #0)
 
@@ -1476,11 +1476,11 @@
 (macro:' #export (_$ tokens)
          (#Cons [(tag$ ["lux" "doc"])
                  (text$ ("lux text concat"
-                         ("lux text concat" "## Left-association for the application of binary functions over variadic arguments." ..new_line)
+                         ("lux text concat" "## Left-association for the application of binary functions over variadic arguments." ..\n)
                          ("lux text concat"
-                          ("lux text concat" "(_$ text\compose ''Hello, '' name ''. How are you?'')" ..new_line)
+                          ("lux text concat" "(_$ text\compose ''Hello, '' name ''. How are you?'')" ..\n)
                           ("lux text concat"
-                           ("lux text concat" "## =>" ..new_line)
+                           ("lux text concat" "## =>" ..\n)
                            "(text\compose (text\compose ''Hello, '' name) ''. How are you?'')"))))]
                 #Nil)
          ({(#Cons op tokens')
@@ -1498,11 +1498,11 @@
 (macro:' #export ($_ tokens)
          (#Cons [(tag$ ["lux" "doc"])
                  (text$ ("lux text concat"
-                         ("lux text concat" "## Right-association for the application of binary functions over variadic arguments." ..new_line)
+                         ("lux text concat" "## Right-association for the application of binary functions over variadic arguments." ..\n)
                          ("lux text concat"
-                          ("lux text concat" "($_ text\compose ''Hello, '' name ''. How are you?'')" ..new_line)
+                          ("lux text concat" "($_ text\compose ''Hello, '' name ''. How are you?'')" ..\n)
                           ("lux text concat"
-                           ("lux text concat" "## =>" ..new_line)
+                           ("lux text concat" "## =>" ..\n)
                            "(text\compose ''Hello, '' (text\compose name ''. How are you?''))"))))]
                 #Nil)
          ({(#Cons op tokens')
@@ -2133,9 +2133,9 @@
          (list [(tag$ ["lux" "doc"])
                 (text$ ($_ "lux text concat"
                            "## By specifying a pattern (with holes), and the input data to fill those holes, repeats the pattern as many times as necessary." __paragraph
-                           "(template [<name> <diff>]" ..new_line
+                           "(template [<name> <diff>]" ..\n
                            "  " "[(def: #export <name> (-> Int Int) (+ <diff>))]" __paragraph
-                           "  " "[inc +1]" ..new_line
+                           "  " "[inc +1]" ..\n
                            "  " "[dec -1]"))])
          ({(#Cons [[_ (#Tuple bindings)] (#Cons [[_ (#Tuple templates)] data])])
            ({[(#Some bindings') (#Some data')]
@@ -2616,10 +2616,10 @@
          (list [(tag$ ["lux" "doc"])
                 (text$ ($_ "lux text concat"
                            "## Sequential execution of expressions (great for side-effects)." __paragraph
-                           "(exec" ..new_line
-                           "  " "(log! ''#1'')" ..new_line
-                           "  " "(log! ''#2'')" ..new_line
-                           "  " "(log! ''#3'')" ..new_line
+                           "(exec" ..\n
+                           "  " "(log! ''#1'')" ..\n
+                           "  " "(log! ''#2'')" ..\n
+                           "  " "(log! ''#3'')" ..\n
                            "''YOLO'')"))])
          ({(#Cons value actions)
            (let' [dummy (local_identifier$ "")]
@@ -2777,12 +2777,12 @@
 (macro:' #export (case tokens)
          (list [(tag$ ["lux" "doc"])
                 (text$ ($_ "lux text concat"
-                           "## The pattern-matching macro." ..new_line
-                           "## Allows the usage of macros within the patterns to provide custom syntax." ..new_line
-                           "(case (: (List Int) (list +1 +2 +3))" ..new_line
-                           "  " "(#Cons x (#Cons y (#Cons z #Nil)))" ..new_line
+                           "## The pattern-matching macro." ..\n
+                           "## Allows the usage of macros within the patterns to provide custom syntax." ..\n
+                           "(case (: (List Int) (list +1 +2 +3))" ..\n
+                           "  " "(#Cons x (#Cons y (#Cons z #Nil)))" ..\n
                            "  " "(#Some ($_ * x y z))" __paragraph
-                           "  " "_" ..new_line
+                           "  " "_" ..\n
                            "  " "#None)"))])
          ({(#Cons value branches)
            (do meta_monad
@@ -2796,13 +2796,13 @@
 (macro:' #export (^ tokens)
          (list [(tag$ ["lux" "doc"])
                 (text$ ($_ "lux text concat"
-                           "## Macro-expanding patterns." ..new_line
-                           "## It's a special macro meant to be used with 'case'." ..new_line
-                           "(case (: (List Int) (list +1 +2 +3))" ..new_line
-                           "  (^ (list x y z))" ..new_line
+                           "## Macro-expanding patterns." ..\n
+                           "## It's a special macro meant to be used with 'case'." ..\n
+                           "(case (: (List Int) (list +1 +2 +3))" ..\n
+                           "  (^ (list x y z))" ..\n
                            "  (#Some ($_ * x y z))"
                            __paragraph
-                           "  _" ..new_line
+                           "  _" ..\n
                            "  #None)"))])
          (case tokens
            (#Cons [_ (#Form (#Cons pattern #Nil))] (#Cons body branches))
@@ -2821,17 +2821,17 @@
 (macro:' #export (^or tokens)
          (list [(tag$ ["lux" "doc"])
                 (text$ ($_ "lux text concat"
-                           "## Or-patterns." ..new_line
-                           "## It's a special macro meant to be used with 'case'." ..new_line
+                           "## Or-patterns." ..\n
+                           "## It's a special macro meant to be used with 'case'." ..\n
                            "(type: Weekday #Monday #Tuesday #Wednesday #Thursday #Friday #Saturday #Sunday)"
                            __paragraph
-                           "(def: (weekend? day)" ..new_line
-                           "  (-> Weekday Bit)" ..new_line
-                           "  (case day" ..new_line
-                           "    (^or #Saturday #Sunday)" ..new_line
+                           "(def: (weekend? day)" ..\n
+                           "  (-> Weekday Bit)" ..\n
+                           "  (case day" ..\n
+                           "    (^or #Saturday #Sunday)" ..\n
                            "    #1"
                            __paragraph
-                           "    _" ..new_line
+                           "    _" ..\n
                            "    #0))"))])
          (case tokens
            (^ (list& [_ (#Form patterns)] body branches))
@@ -2859,10 +2859,10 @@
 (macro:' #export (let tokens)
          (list [(tag$ ["lux" "doc"])
                 (text$ ($_ "lux text concat"
-                           "## Creates local bindings." ..new_line
-                           "## Can (optionally) use pattern-matching macros when binding." ..new_line
-                           "(let [x (foo bar)" ..new_line
-                           "      y (baz quux)]" ..new_line
+                           "## Creates local bindings." ..\n
+                           "## Can (optionally) use pattern-matching macros when binding." ..\n
+                           "(let [x (foo bar)" ..\n
+                           "      y (baz quux)]" ..\n
                            "  (op x y))"))])
          (case tokens
            (^ (list [_ (#Tuple bindings)] body))
@@ -2885,12 +2885,12 @@
 (macro:' #export (function tokens)
          (list [(tag$ ["lux" "doc"])
                 (text$ ($_ "lux text concat"
-                           "## Syntax for creating functions." ..new_line
-                           "## Allows for giving the function itself a name, for the sake of recursion." ..new_line
-                           "(: (All [a b] (-> a b a))" ..new_line
+                           "## Syntax for creating functions." ..\n
+                           "## Allows for giving the function itself a name, for the sake of recursion." ..\n
+                           "(: (All [a b] (-> a b a))" ..\n
                            "   (function (_ x y) x))"
                            __paragraph
-                           "(: (All [a b] (-> a b a))" ..new_line
+                           "(: (All [a b] (-> a b a))" ..\n
                            "   (function (const x y) x))"))])
          (case (: (Maybe [Text Code (List Code) Code])
                   (case tokens
@@ -3001,14 +3001,14 @@
 (macro:' #export (def: tokens)
          (list [(tag$ ["lux" "doc"])
                 (text$ ($_ "lux text concat"
-                           "## Defines global constants/functions." ..new_line
-                           "(def: (rejoin_pair pair)" ..new_line
-                           "  (-> [Code Code] (List Code))" ..new_line
-                           "  (let [[left right] pair]" ..new_line
+                           "## Defines global constants/functions." ..\n
+                           "(def: (rejoin_pair pair)" ..\n
+                           "  (-> [Code Code] (List Code))" ..\n
+                           "  (let [[left right] pair]" ..\n
                            "    (list left right)))"
                            __paragraph
-                           "(def: branching_exponent" ..new_line
-                           "  Int" ..new_line
+                           "(def: branching_exponent" ..\n
+                           "  Int" ..\n
                            "  +5)"))])
          (let [[exported? tokens'] (export^ tokens)
                parts (: (Maybe [Code (List Code) (Maybe Code) Code (List [Code Code])])
@@ -3084,15 +3084,15 @@
 (macro:' #export (macro: tokens)
          (list [(tag$ ["lux" "doc"])
                 (text$ ($_ "lux text concat"
-                           "## Macro-definition macro." ..new_line
-                           "(macro: #export (name_of tokens)" ..new_line
-                           "  (case tokens" ..new_line
-                           "    (^template [<tag>]" ..new_line
-                           "      [(^ (list [_ (<tag> [prefix name])]))" ..new_line
-                           "      (return (list (` [(~ (text$ prefix)) (~ (text$ name))])))])" ..new_line
+                           "## Macro-definition macro." ..\n
+                           "(macro: #export (name_of tokens)" ..\n
+                           "  (case tokens" ..\n
+                           "    (^template [<tag>]" ..\n
+                           "      [(^ (list [_ (<tag> [prefix name])]))" ..\n
+                           "      (return (list (` [(~ (text$ prefix)) (~ (text$ name))])))])" ..\n
                            "    ([#Identifier] [#Tag])"
                            __paragraph
-                           "    _" ..new_line
+                           "    _" ..\n
                            "    (fail ''Wrong syntax for name_of'')))"))])
          (let [[exported? tokens] (export^ tokens)
                name+args+meta+body?? (: (Maybe [Name (List Code) (List [Code Code]) Code])
@@ -3133,17 +3133,17 @@
 
 (macro: #export (signature: tokens)
   {#.doc (text$ ($_ "lux text concat"
-                    "## Definition of signatures ala ML." ..new_line
-                    "(signature: #export (Ord a)" ..new_line
-                    "  (: (Equivalence a)" ..new_line
-                    "     eq)" ..new_line
-                    "  (: (-> a a Bit)" ..new_line
-                    "     <)" ..new_line
-                    "  (: (-> a a Bit)" ..new_line
-                    "     <=)" ..new_line
-                    "  (: (-> a a Bit)" ..new_line
-                    "     >)" ..new_line
-                    "  (: (-> a a Bit)" ..new_line
+                    "## Definition of signatures ala ML." ..\n
+                    "(signature: #export (Ord a)" ..\n
+                    "  (: (Equivalence a)" ..\n
+                    "     eq)" ..\n
+                    "  (: (-> a a Bit)" ..\n
+                    "     <)" ..\n
+                    "  (: (-> a a Bit)" ..\n
+                    "     <=)" ..\n
+                    "  (: (-> a a Bit)" ..\n
+                    "     >)" ..\n
+                    "  (: (-> a a Bit)" ..\n
                     "     >=))"))}
   (let [[exported? tokens'] (export^ tokens)
         ?parts (: (Maybe [Name (List Code) Code (List Code)])
@@ -3234,14 +3234,14 @@
 
 (def: #export (error! message)
   {#.doc (text$ ($_ "lux text concat"
-                    "## Causes an error, with the given error message." ..new_line
+                    "## Causes an error, with the given error message." ..\n
                     "(error! ''OH NO!'')"))}
   (-> Text Nothing)
   ("lux io error" message))
 
 (macro: (default tokens state)
   {#.doc (text$ ($_ "lux text concat"
-                    "## Allows you to provide a default value that will be used" ..new_line
+                    "## Allows you to provide a default value that will be used" ..\n
                     "## if a (Maybe x) value turns out to be #.None."
                     __paragraph
                     "(default +20 (#.Some +10)) ## => +10"
@@ -3530,18 +3530,18 @@
 
 (macro: #export (structure: tokens)
   {#.doc (text$ ($_ "lux text concat"
-                    "## Definition of structures ala ML." ..new_line
-                    "(structure: #export order (Order Int)" ..new_line
-                    "  (def: &equivalence equivalence)" ..new_line
-                    "  (def: (< test subject)" ..new_line
-                    "    (< test subject))" ..new_line
-                    "  (def: (<= test subject)" ..new_line
-                    "    (or (< test subject)" ..new_line
-                    "        (= test subject)))" ..new_line
-                    "  (def: (> test subject)" ..new_line
-                    "    (> test subject))" ..new_line
-                    "  (def: (>= test subject)" ..new_line
-                    "    (or (> test subject)" ..new_line
+                    "## Definition of structures ala ML." ..\n
+                    "(structure: #export order (Order Int)" ..\n
+                    "  (def: &equivalence equivalence)" ..\n
+                    "  (def: (< test subject)" ..\n
+                    "    (< test subject))" ..\n
+                    "  (def: (<= test subject)" ..\n
+                    "    (or (< test subject)" ..\n
+                    "        (= test subject)))" ..\n
+                    "  (def: (> test subject)" ..\n
+                    "    (> test subject))" ..\n
+                    "  (def: (>= test subject)" ..\n
+                    "    (or (> test subject)" ..\n
                     "        (= test subject))))"))}
   (let [[exported? tokens'] (export^ tokens)
         ?parts (: (Maybe [Code (List Code) Code Code (List Code)])
@@ -3581,7 +3581,7 @@
 
 (macro: #export (type: tokens)
   {#.doc (text$ ($_ "lux text concat"
-                    "## The type-definition macro." ..new_line
+                    "## The type-definition macro." ..\n
                     "(type: (List a) #Nil (#Cons a (List a)))"))}
   (let [[exported? tokens'] (export^ tokens)
         [rec? tokens'] (case tokens'
@@ -3707,7 +3707,7 @@
                     (return name)
 
                     _
-                    (fail "only/exclude requires identifiers."))))
+                    (fail "#only/#+ and #exclude/#- require identifiers."))))
              defs))
 
 (def: (parse_referrals tokens)
@@ -3850,9 +3850,9 @@
                        _ ($_ text\compose prefix ..module_separator clean))]
           (return output))
         (fail ($_ "lux text concat"
-                  "Cannot climb the module hierarchy..." ..new_line
-                  "Importing module: " module ..new_line
-                  "   Relative Root: " relative_root ..new_line))))))
+                  "Cannot climb the module hierarchy..." ..\n
+                  "Importing module: " module ..\n
+                  "   Relative Root: " relative_root ..\n))))))
 
 (def: (alter_domain alteration domain import)
   (-> Nat Text Importation Importation)
@@ -3945,7 +3945,7 @@
                                   [current_module current_module_name]
                                   (fail ($_ text\compose
                                             "Wrong syntax for import @ " current_module
-                                            ..new_line (code\encode token)))))))
+                                            ..\n (code\encode token)))))))
                          imports)]
     (wrap (list\join imports'))))
 
@@ -3976,13 +3976,13 @@
       
       #None
       (#Left ($_ text\compose
-                 "Unknown module: " (text\encode module) ..new_line
+                 "Unknown module: " (text\encode module) ..\n
                  "Current module: " (case current_module
                                       (#Some current_module)
                                       (text\encode current_module)
 
                                       #None
-                                      "???") ..new_line
+                                      "???") ..\n
                                       "Known modules: " (|> modules
                                                             (list\map (function (_ [name module])
                                                                         (text$ name)))
@@ -4203,10 +4203,10 @@
 
 (macro: #export (^open tokens)
   {#.doc (text$ ($_ "lux text concat"
-                    "## Same as the 'open' macro, but meant to be used as a pattern-matching macro for generating local bindings." ..new_line
-                    "## Takes an 'alias' text for the generated local bindings." ..new_line
-                    "(def: #export (range (^open ''.'') from to)" ..new_line
-                    "  (All [a] (-> (Enum a) a a (List a)))" ..new_line
+                    "## Same as the 'open' macro, but meant to be used as a pattern-matching macro for generating local bindings." ..\n
+                    "## Takes an 'alias' text for the generated local bindings." ..\n
+                    "(def: #export (range (^open ''.'') from to)" ..\n
+                    "  (All [a] (-> (Enum a) a a (List a)))" ..\n
                     "  (range' <= succ from to))"))}
   (case tokens
     (^ (list& [_ (#Form (list [_ (#Text alias)]))] body branches))
@@ -4254,11 +4254,11 @@
 
 (macro: #export (cond tokens)
   {#.doc (text$ ($_ "lux text concat"
-                    "## Branching structures with multiple test conditions." ..new_line
-                    "(cond (even? num) ''even''" ..new_line
+                    "## Branching structures with multiple test conditions." ..\n
+                    "(cond (even? num) ''even''" ..\n
                     "      (odd? num) ''odd''"
                     __paragraph
-                    "      ## else_branch" ..new_line
+                    "      ## else_branch" ..\n
                     "      ''???'')"))}
   (if ("lux i64 =" 0 (n/% 2 (list\size tokens)))
     (fail "cond requires an uneven number of arguments.")
@@ -4289,14 +4289,14 @@
 
 (macro: #export (get@ tokens)
   {#.doc (text$ ($_ "lux text concat"
-                    "## Accesses the value of a record at a given tag." ..new_line
+                    "## Accesses the value of a record at a given tag." ..\n
                     "(get@ #field my_record)"
                     __paragraph
-                    "## Can also work with multiple levels of nesting:" ..new_line
+                    "## Can also work with multiple levels of nesting:" ..\n
                     "(get@ [#foo #bar #baz] my_record)"
                     __paragraph
-                    "## And, if only the slot/path is given, generates an accessor function:" ..new_line
-                    "(let [getter (get@ [#foo #bar #baz])]" ..new_line
+                    "## And, if only the slot/path is given, generates an accessor function:" ..\n
+                    "(let [getter (get@ [#foo #bar #baz])]" ..\n
                     "  (getter my_record))"))}
   (case tokens
     (^ (list [_ (#Tag slot')] record))
@@ -4370,13 +4370,13 @@
   {#.doc (text$ ($_ "lux text concat"
                     "## Opens a structure and generates a definition for each of its members (including nested members)."
                     __paragraph
-                    "## For example:" ..new_line
+                    "## For example:" ..\n
                     "(open: ''i:.'' number)"
                     __paragraph
-                    "## Will generate:" ..new_line
-                    "(def: i:+ (\ number +))" ..new_line
-                    "(def: i:- (\ number -))" ..new_line
-                    "(def: i:* (\ number *))" ..new_line
+                    "## Will generate:" ..\n
+                    "(def: i:+ (\ number +))" ..\n
+                    "(def: i:- (\ number -))" ..\n
+                    "(def: i:* (\ number *))" ..\n
                     "..."))}
   (case tokens
     (^ (list [_ (#Text alias)] struct))
@@ -4411,9 +4411,9 @@
 
 (macro: #export (|>> tokens)
   {#.doc (text$ ($_ "lux text concat"
-                    "## Similar to the piping macro, but rather than taking an initial object to work on, creates a function for taking it." ..new_line
-                    "(|>> (list\map int\encode) (interpose '' '') (fold text\compose ''''))" ..new_line
-                    "## =>" ..new_line
+                    "## Similar to the piping macro, but rather than taking an initial object to work on, creates a function for taking it." ..\n
+                    "(|>> (list\map int\encode) (interpose '' '') (fold text\compose ''''))" ..\n
+                    "## =>" ..\n
                     "(function (_ <arg>) (fold text\compose '''' (interpose '' '' (list\map int\encode <arg>))))"))}
   (do meta_monad
     [g!_ (gensym "_")
@@ -4422,9 +4422,9 @@
 
 (macro: #export (<<| tokens)
   {#.doc (text$ ($_ "lux text concat"
-                    "## Similar to the piping macro, but rather than taking an initial object to work on, creates a function for taking it." ..new_line
-                    "(<<| (fold text\compose '''') (interpose '' '') (list\map int\encode))" ..new_line
-                    "## =>" ..new_line
+                    "## Similar to the piping macro, but rather than taking an initial object to work on, creates a function for taking it." ..\n
+                    "(<<| (fold text\compose '''') (interpose '' '') (list\map int\encode))" ..\n
+                    "## =>" ..\n
                     "(function (_ <arg>) (fold text\compose '''' (interpose '' '' (list\map int\encode <arg>))))"))}
   (do meta_monad
     [g!_ (gensym "_")
@@ -4453,10 +4453,10 @@
 
       _
       (fail ($_ text\compose "Wrong syntax for refer @ " current_module
-                ..new_line (|> options
-                               (list\map code\encode)
-                               (interpose " ")
-                               (list\fold text\compose "")))))))
+                ..\n (|> options
+                         (list\map code\encode)
+                         (interpose " ")
+                         (list\fold text\compose "")))))))
 
 (def: (write_refer module_name [r_defs r_opens])
   (-> Text Refer (Meta (List Code)))
@@ -4549,17 +4549,17 @@
                     __paragraph
                     "## Can take optional annotations and allows the specification of modules to import."
                     __paragraph
-                    "## Example" ..new_line
-                    "(.module: {#.doc ''Some documentation...''}" ..new_line
-                    "  [lux #*" ..new_line
-                    "   [control" ..new_line
-                    "    [''M'' monad #*]]" ..new_line
-                    "   [data" ..new_line
-                    "    maybe" ..new_line
-                    "    [''.'' name (''#/.'' codec)]]" ..new_line
-                    "   [macro" ..new_line
-                    "    code]]" ..new_line
-                    "  [//" ..new_line
+                    "## Example" ..\n
+                    "(.module: {#.doc ''Some documentation...''}" ..\n
+                    "  [lux #*" ..\n
+                    "   [control" ..\n
+                    "    [''M'' monad #*]]" ..\n
+                    "   [data" ..\n
+                    "    maybe" ..\n
+                    "    [''.'' name (''#/.'' codec)]]" ..\n
+                    "   [macro" ..\n
+                    "    code]]" ..\n
+                    "  [//" ..\n
                     "   [type (''.'' equivalence)]])"))}
   (do meta_monad
     [#let [[_meta _imports] (: [(List [Code Code]) (List Code)]
@@ -4587,31 +4587,31 @@
 
 (macro: #export (\ tokens)
   {#.doc (text$ ($_ "lux text concat"
-                    "## Allows accessing the value of a structure's member." ..new_line
+                    "## Allows accessing the value of a structure's member." ..\n
                     "(\ codec encode)"
                     __paragraph
-                    "## Also allows using that value as a function." ..new_line
+                    "## Also allows using that value as a function." ..\n
                     "(\ codec encode +123)"))}
   (case tokens
     (^ (list struct [_ (#Identifier member)]))
-    (return (list (` (let [(^open ".") (~ struct)] (~ (identifier$ member))))))
+    (return (list (` (let [(^open (~ (text$ ..self_reference))) (~ struct)] (~ (identifier$ member))))))
 
-    (^ (list& struct [_ (#Identifier member)] args))
-    (return (list (` ((let [(^open ".") (~ struct)] (~ (identifier$ member))) (~+ args)))))
+    (^ (list& struct member args))
+    (return (list (` ((..\ (~ struct) (~ member)) (~+ args)))))
     
     _
     (fail "Wrong syntax for \")))
 
 (macro: #export (set@ tokens)
   {#.doc (text$ ($_ "lux text concat"
-                    "## Sets the value of a record at a given tag." ..new_line
+                    "## Sets the value of a record at a given tag." ..\n
                     "(set@ #name ''Lux'' lang)"
                     __paragraph
-                    "## Can also work with multiple levels of nesting:" ..new_line
+                    "## Can also work with multiple levels of nesting:" ..\n
                     "(set@ [#foo #bar #baz] value my_record)"
                     __paragraph
-                    "## And, if only the slot/path and (optionally) the value are given, generates a mutator function:" ..new_line
-                    "(let [setter (set@ [#foo #bar #baz] value)] (setter my_record))" ..new_line
+                    "## And, if only the slot/path and (optionally) the value are given, generates a mutator function:" ..\n
+                    "(let [setter (set@ [#foo #bar #baz] value)] (setter my_record))" ..\n
                     "(let [setter (set@ [#foo #bar #baz])] (setter value my_record))"))}
   (case tokens
     (^ (list [_ (#Tag slot')] value record))
@@ -4677,28 +4677,30 @@
     (do meta_monad
       [g!_ (gensym "_")
        g!record (gensym "record")]
-      (wrap (list (` (function ((~ g!_) (~ g!record)) (..set@ (~ selector) (~ value) (~ g!record)))))))
+      (wrap (list (` (function ((~ g!_) (~ g!record))
+                       (..set@ (~ selector) (~ value) (~ g!record)))))))
 
     (^ (list selector))
     (do meta_monad
       [g!_ (gensym "_")
        g!value (gensym "value")
        g!record (gensym "record")]
-      (wrap (list (` (function ((~ g!_) (~ g!value) (~ g!record)) (..set@ (~ selector) (~ g!value) (~ g!record)))))))
+      (wrap (list (` (function ((~ g!_) (~ g!value) (~ g!record))
+                       (..set@ (~ selector) (~ g!value) (~ g!record)))))))
 
     _
     (fail "Wrong syntax for set@")))
 
 (macro: #export (update@ tokens)
   {#.doc (text$ ($_ "lux text concat"
-                    "## Modifies the value of a record at a given tag, based on some function." ..new_line
+                    "## Modifies the value of a record at a given tag, based on some function." ..\n
                     "(update@ #age inc person)"
                     __paragraph
-                    "## Can also work with multiple levels of nesting:" ..new_line
+                    "## Can also work with multiple levels of nesting:" ..\n
                     "(update@ [#foo #bar #baz] func my_record)"
                     __paragraph
-                    "## And, if only the slot/path and (optionally) the value are given, generates a mutator function:" ..new_line
-                    "(let [updater (update@ [#foo #bar #baz] func)] (updater my_record))" ..new_line
+                    "## And, if only the slot/path and (optionally) the value are given, generates a mutator function:" ..\n
+                    "(let [updater (update@ [#foo #bar #baz] func)] (updater my_record))" ..\n
                     "(let [updater (update@ [#foo #bar #baz])] (updater func my_record))"))}
   (case tokens
     (^ (list [_ (#Tag slot')] fun record))
@@ -4750,52 +4752,54 @@
     (do meta_monad
       [g!_ (gensym "_")
        g!record (gensym "record")]
-      (wrap (list (` (function ((~ g!_) (~ g!record)) (..update@ (~ selector) (~ fun) (~ g!record)))))))
+      (wrap (list (` (function ((~ g!_) (~ g!record))
+                       (..update@ (~ selector) (~ fun) (~ g!record)))))))
 
     (^ (list selector))
     (do meta_monad
       [g!_ (gensym "_")
        g!fun (gensym "fun")
        g!record (gensym "record")]
-      (wrap (list (` (function ((~ g!_) (~ g!fun) (~ g!record)) (..update@ (~ selector) (~ g!fun) (~ g!record)))))))
+      (wrap (list (` (function ((~ g!_) (~ g!fun) (~ g!record))
+                       (..update@ (~ selector) (~ g!fun) (~ g!record)))))))
     
     _
     (fail "Wrong syntax for update@")))
 
 (macro: #export (^template tokens)
   {#.doc (text$ ($_ "lux text concat"
-                    "## It's similar to template, but meant to be used during pattern-matching." ..new_line
-                    "(def: (beta_reduce env type)" ..new_line
-                    "  (-> (List Type) Type Type)" ..new_line
-                    "  (case type" ..new_line
-                    "    (#.Primitive name params)" ..new_line
+                    "## It's similar to template, but meant to be used during pattern-matching." ..\n
+                    "(def: (beta_reduce env type)" ..\n
+                    "  (-> (List Type) Type Type)" ..\n
+                    "  (case type" ..\n
+                    "    (#.Primitive name params)" ..\n
                     "    (#.Primitive name (list\map (beta_reduce env) params))"
                     __paragraph
-                    "    (^template [<tag>]" ..new_line
-                    "      [(<tag> left right)" ..new_line
-                    "      (<tag> (beta_reduce env left) (beta_reduce env right))])" ..new_line
+                    "    (^template [<tag>]" ..\n
+                    "      [(<tag> left right)" ..\n
+                    "      (<tag> (beta_reduce env left) (beta_reduce env right))])" ..\n
                     "    ([#.Sum] [#.Product])"
                     __paragraph
-                    "    (^template [<tag>]" ..new_line
-                    "      [(<tag> left right)" ..new_line
-                    "      (<tag> (beta_reduce env left) (beta_reduce env right))])" ..new_line
+                    "    (^template [<tag>]" ..\n
+                    "      [(<tag> left right)" ..\n
+                    "      (<tag> (beta_reduce env left) (beta_reduce env right))])" ..\n
                     "    ([#.Function] [#.Apply])"
                     __paragraph
-                    "    (^template [<tag>]" ..new_line
-                    "      [(<tag> old_env def)" ..new_line
-                    "      (case old_env" ..new_line
-                    "        #.Nil" ..new_line
+                    "    (^template [<tag>]" ..\n
+                    "      [(<tag> old_env def)" ..\n
+                    "      (case old_env" ..\n
+                    "        #.Nil" ..\n
                     "        (<tag> env def)"
                     __paragraph
-                    "        _" ..new_line
-                    "        type)])" ..new_line
+                    "        _" ..\n
+                    "        type)])" ..\n
                     "    ([#.UnivQ] [#.ExQ])"
                     __paragraph
-                    "    (#.Parameter idx)" ..new_line
+                    "    (#.Parameter idx)" ..\n
                     "    (default type (list.nth idx env))"
                     __paragraph
-                    "    _" ..new_line
-                    "    type" ..new_line
+                    "    _" ..\n
+                    "    type" ..\n
                     "  ))"))}
   (case tokens
     (^ (list& [_ (#Form (list [_ (#Tuple bindings)]
@@ -4889,7 +4893,7 @@
   (-> Nat Location Location Text)
   (if ("lux i64 =" old_line new_line)
     (text\join_with "" (repeat (.int ("lux i64 -" old_column new_column)) " "))
-    (let [extra_lines (text\join_with "" (repeat (.int ("lux i64 -" old_line new_line)) ..new_line))
+    (let [extra_lines (text\join_with "" (repeat (.int ("lux i64 -" old_line new_line)) ..\n))
           space_padding (text\join_with "" (repeat (.int ("lux i64 -" baseline new_column)) " "))]
       (text\compose extra_lines space_padding))))
 
@@ -4955,8 +4959,8 @@
   (case fragment
     (#Doc_Comment comment)
     (|> comment
-        (text\split_all_with ..new_line)
-        (list\map (function (_ line) ($_ text\compose "## " line ..new_line)))
+        (text\split_all_with ..\n)
+        (list\map (function (_ line) ($_ text\compose "## " line ..\n)))
         (text\join_with ""))
 
     (#Doc_Example example)
@@ -4969,13 +4973,13 @@
   {#.doc (text$ ($_ "lux text concat"
                     "## Creates code documentation, embedding text as comments and properly formatting the forms it's being given."
                     __paragraph
-                    "## For Example:" ..new_line
-                    "(doc ''Allows arbitrary looping, using the 'recur' form to re-start the loop.''" ..new_line
-                    "     ''Can be used in monadic code to create monadic loops.''" ..new_line
-                    "     (loop [count +0" ..new_line
-                    "            x init]" ..new_line
-                    "       (if (< +10 count)" ..new_line
-                    "         (recur (inc count) (f x))" ..new_line
+                    "## For Example:" ..\n
+                    "(doc ''Allows arbitrary looping, using the 'recur' form to re-start the loop.''" ..\n
+                    "     ''Can be used in monadic code to create monadic loops.''" ..\n
+                    "     (loop [count +0" ..\n
+                    "            x init]" ..\n
+                    "       (if (< +10 count)" ..\n
+                    "         (recur (inc count) (f x))" ..\n
                     "         x)))"))}
   (return (list (` [(~ location_code)
                     (#.Text (~ (|> tokens
@@ -5165,8 +5169,8 @@
 
 (macro: #export (with_expansions tokens)
   {#.doc (doc "Controlled macro-expansion."
-              "Bind an arbitraty number of Codes resulting from macro-expansion to local bindings."
-              "Wherever a binding appears, the bound codes will be spliced in there."
+              "Bind an arbitraty number of Code nodes resulting from macro-expansion to local bindings."
+              "Wherever a binding appears, the bound Code nodes will be spliced in there."
               (test: "Code operations & structures"
                 (with_expansions
                   [<tests> (template [<expr> <text> <pattern>]
@@ -5677,6 +5681,32 @@
   (function (_ compiler)
     (#Right [compiler (get@ [#info #target] compiler)])))
 
+(def: (resolve_target choice)
+  (-> Code (Meta Text))
+  (case choice
+    [_ (#Text platform)]
+    (..return platform)
+
+    [_ (#Identifier identifier)]
+    (do meta_monad
+      [identifier (..resolve_global_identifier identifier)
+       type+value (..find_def_value identifier)
+       #let [[type value] type+value]]
+      (case (..flatten_alias type)
+        (^or (#Primitive "#Text" #Nil)
+             (#Named ["lux" "Text"] (#Primitive "#Text" #Nil)))
+        (wrap (:coerce ..Text value))
+
+        _
+        (fail ($_ text\compose
+                  "Invalid target platform (must be a value of type Text): " (name\encode identifier)
+                  " : " (..code\encode (..type_to_code type))))))
+
+    _
+    (fail ($_ text\compose
+              "Invalid target platform syntax: " (..code\encode choice)
+              ..\n "Must be either a text literal or an identifier."))))
+
 (def: (target_pick target options default)
   (-> Text (List [Code Code]) (Maybe Code) (Meta (List Code)))
   (case options
@@ -5689,32 +5719,11 @@
       (return (list default)))
 
     (#Cons [key pick] options')
-    (with_expansions [<try_again> (target_pick target options' default)]
-      (case key
-        [_ (#Text platform)]
-        (if (text\= target platform)
-          (return (list pick))
-          <try_again>)
-
-        [_ (#Identifier identifier)]
-        (do meta_monad
-          [identifier (..resolve_global_identifier identifier)
-           type+value (..find_def_value identifier)
-           #let [[type value] type+value]]
-          (case (..flatten_alias type)
-            (#Named ["lux" "Text"] (#Primitive "#Text" #Nil))
-            (if (text\= target (:coerce ..Text value))
-              (wrap (list pick))
-              <try_again>)
-
-            _
-            (fail ($_ text\compose
-                      "Invalid target platform (must be a value of type Text): " (name\encode identifier)
-                      " : " (..code\encode (..type_to_code type))))))
-
-        _
-        <try_again>))
-    ))
+    (do meta_monad
+      [platform (..resolve_target key)]
+      (if (text\= target platform)
+        (return (list pick))
+        (target_pick target options' default)))))
 
 (macro: #export (for tokens)
   (do meta_monad
@@ -5799,58 +5808,71 @@
     (#Cons [init inits'])
     (` (#.Cons (~ init) (~ (untemplate_list& last inits'))))))
 
-(def: (untemplate_pattern pattern)
-  (-> Code (Meta Code))
-  (case pattern
-    (^template [<tag> <name> <gen>]
-      [[_ (<tag> value)]
+(def: (untemplate_record g!meta untemplate_pattern fields)
+  (-> Code (-> Code (Meta Code))
+      (-> (List [Code Code]) (Meta Code)))
+  (do meta_monad
+    [=fields (monad\map meta_monad
+                        (function (_ [key value])
+                          (do meta_monad
+                            [=key (untemplate_pattern key)
+                             =value (untemplate_pattern value)]
+                            (wrap (` [(~ =key) (~ =value)]))))
+                        fields)]
+    (wrap (` [(~ g!meta) (#.Record (~ (untemplate_list =fields)))]))))
+
+(template [<tag> <name>]
+  [(def: (<name> g!meta untemplate_pattern elems)
+     (-> Code (-> Code (Meta Code))
+         (-> (List Code) (Meta Code)))
+     (case (list\reverse elems)
+       (#Cons [_ (#Form (#Cons [[_ (#Identifier ["" "~+"])] (#Cons [spliced #Nil])]))]
+              inits)
        (do meta_monad
-         [g!meta (gensym "g!meta")]
-         (wrap (` [(~ g!meta) (<tag> (~ (<gen> value)))])))])
-    ([#Bit    "Bit"    bit$]
-     [#Nat    "Nat"    nat$]
-     [#Int    "Int"    int$]
-     [#Rev    "Rev"    rev$]
-     [#Frac   "Frac"   frac$]
-     [#Text   "Text"   text$]
-     [#Tag    "Tag"    name$]
-     [#Identifier "Identifier" name$])
-
-    [_ (#Record fields)]
-    (do meta_monad
-      [=fields (monad\map meta_monad
-                          (function (_ [key value])
-                            (do meta_monad
-                              [=key (untemplate_pattern key)
-                               =value (untemplate_pattern value)]
-                              (wrap (` [(~ =key) (~ =value)]))))
-                          fields)
-       g!meta (gensym "g!meta")]
-      (wrap (` [(~ g!meta) (#.Record (~ (untemplate_list =fields)))])))
-
-    [_ (#Form (#Cons [[_ (#Identifier ["" "~"])] (#Cons [unquoted #Nil])]))]
-    (return unquoted)
-
-    [_ (#Form (#Cons [[_ (#Identifier ["" "~+"])] (#Cons [spliced #Nil])]))]
-    (fail "Cannot use (~+) inside of ^code unless it is the last element in a form or a tuple.")
+         [=inits (monad\map meta_monad untemplate_pattern (list\reverse inits))]
+         (wrap (` [(~ g!meta) (<tag> (~ (untemplate_list& spliced =inits)))])))
 
-    (^template [<tag>]
-      [[_ (<tag> elems)]
-       (case (list\reverse elems)
-         (#Cons [_ (#Form (#Cons [[_ (#Identifier ["" "~+"])] (#Cons [spliced #Nil])]))]
-                inits)
-         (do meta_monad
-           [=inits (monad\map meta_monad untemplate_pattern (list\reverse inits))
-            g!meta (gensym "g!meta")]
-           (wrap (` [(~ g!meta) (<tag> (~ (untemplate_list& spliced =inits)))])))
+       _
+       (do meta_monad
+         [=elems (monad\map meta_monad untemplate_pattern elems)]
+         (wrap (` [(~ g!meta) (<tag> (~ (untemplate_list =elems)))])))))]
 
-         _
-         (do meta_monad
-           [=elems (monad\map meta_monad untemplate_pattern elems)
-            g!meta (gensym "g!meta")]
-           (wrap (` [(~ g!meta) (<tag> (~ (untemplate_list =elems)))]))))])
-    ([#Tuple] [#Form])
-    ))
+  [#.Tuple untemplate_tuple]
+  [#.Form untemplate_form]
+  )
+
+(def: (untemplate_pattern pattern)
+  (-> Code (Meta Code))
+  (do meta_monad
+    [g!meta (gensym "g!meta")]
+    (case pattern
+      (^template [<tag> <gen>]
+        [[_ (<tag> value)]
+         (wrap (` [(~ g!meta) (<tag> (~ (<gen> value)))]))])
+      ([#.Bit        bit$]
+       [#.Nat        nat$]
+       [#.Int        int$]
+       [#.Rev        rev$]
+       [#.Frac       frac$]
+       [#.Text       text$]
+       [#.Tag        name$]
+       [#.Identifier name$])
+
+      [_ (#Form (#Cons [[_ (#Identifier ["" "~"])] (#Cons [unquoted #Nil])]))]
+      (return unquoted)
+
+      [_ (#Form (#Cons [[_ (#Identifier ["" "~+"])] (#Cons [spliced #Nil])]))]
+      (fail "Cannot use (~+) inside of ^code unless it is the last element in a form or a tuple.")
+
+      (^template [<tag> <untemplate>]
+        [[_ (<tag> elems)]
+         (<untemplate> g!meta untemplate_pattern elems)])
+      ([#.Tuple ..untemplate_tuple]
+       [#.Form ..untemplate_form])
+
+      [_ (#Record fields)]
+      (..untemplate_record g!meta untemplate_pattern fields)
+      )))
 
 (macro: #export (^code tokens)
   (case tokens
diff --git a/stdlib/source/lux/target/common_lisp.lux b/stdlib/source/lux/target/common_lisp.lux
index 25ee6e44d..766c63a6d 100644
--- a/stdlib/source/lux/target/common_lisp.lux
+++ b/stdlib/source/lux/target/common_lisp.lux
@@ -6,7 +6,7 @@
     ["." text
      ["%" format (#+ format)]]
     [collection
-     ["." list ("#\." monad fold)]]]
+     ["." list ("#\." monad fold monoid)]]]
    [macro
     ["." template]]
    [math
@@ -35,7 +35,7 @@
        (`` (abstract: #export (<brand> brand) Any))
        (`` (type: #export (<type> brand)
              (<super> (<brand> brand)))))]
-    
+
     [Expression Code]
     [Computation Expression]
     [Access Computation]
@@ -50,6 +50,7 @@
        (`` (type: #export <type> (<super> <brand>))))]
 
     [Label Code]
+    [Tag Expression]
     [Literal Expression]
     [Var/1 Var]
     [Var/* Input]
@@ -191,10 +192,10 @@
                   body)))
 
   (def: #export (destructuring-bind [bindings expression] body)
-    (-> [Var/* (Expression Any)] (Expression Any) (Computation Any))
-    (..form (list (..var "destructuring-bind")
-                  (:transmutation bindings) expression
-                  body)))
+    (-> [Var/* (Expression Any)] (List (Expression Any)) (Computation Any))
+    (..form (list& (..var "destructuring-bind")
+                   (:transmutation bindings) expression
+                   body)))
 
   (template [<call> <input_var>+ <input_type>+ <function>+]
     [(`` (def: #export (<call> [(~~ (template.splice <input_var>+))] function)
@@ -232,6 +233,7 @@
       [hash-table-size/1 "hash-table-size"]
       [hash-table-rehash-size/1 "hash-table-rehash-size"]
       [code-char/1 "code-char"]
+      [char-code/1 "char-code"]
       [string/1 "string"]
       [write-line/1 "write-line"]
       [pprint/1 "pprint"]]]
@@ -340,13 +342,13 @@
 
   (template [<lux_name> <host_name>]
     [(def: #export (<lux_name> bindings body)
-       (-> (List [Var/1 (Expression Any)]) (Expression Any) (Computation Any))
-       (..form (list (..var <host_name>)
-                     (|> bindings
-                         (list\map (function (_ [name value])
-                                     (..form (list name value))))
-                         ..form)
-                     body)))]
+       (-> (List [Var/1 (Expression Any)]) (List (Expression Any)) (Computation Any))
+       (..form (list& (..var <host_name>)
+                      (|> bindings
+                          (list\map (function (_ [name value])
+                                      (..form (list name value))))
+                          ..form)
+                      body)))]
 
     [let  "let"]
     [let* "let*"]
@@ -360,9 +362,15 @@
     (-> Var/1 Var/* (Expression Any) (Expression Any))
     (..form (list (..var "defun") name (:transmutation inputs) body)))
 
-  (def: #export (progn pre post)
-    (-> (Expression Any) (Expression Any) (Computation Any))
-    (..form (list (..var "progn") pre post)))
+  (template [<name> <symbol>]
+    [(def: #export <name>
+       (-> (List (Expression Any)) (Computation Any))
+       (|>> (list& (..var <symbol>)) ..form))]
+
+    [progn "progn"]
+    [tagbody "tagbody"]
+    [values/* "values"]
+    )
 
   (def: #export (setq name value)
     (-> Var/1 (Expression Any) (Expression Any))
@@ -413,8 +421,8 @@
     (|>> :abstraction))
 
   (def: #export (block name body)
-    (-> Label (Expression Any) (Computation Any))
-    (..form (list (..var "block") (:transmutation name) body)))
+    (-> Label (List (Expression Any)) (Computation Any))
+    (..form (list& (..var "block") (:transmutation name) body)))
 
   (def: #export (return-from target value)
     (-> Label (Expression Any) (Computation Any))
@@ -422,10 +430,31 @@
 
   (def: #export (cond clauses else)
     (-> (List [(Expression Any) (Expression Any)]) (Expression Any) (Computation Any))
-    (list\fold (function (_ [test then] next)
-                 (..if test then next))
-               (:transmutation else)
-               (list.reverse clauses)))
+    (..form (list& (..var "cond")
+                   (list\compose (list\map (function (_ [test then])
+                                             (..form (list test then)))
+                                           clauses)
+                                 (list (..form (list (..bool true) else)))))))
+
+  (def: #export tag
+    (-> Text Tag)
+    (|>> :abstraction))
+
+  (def: #export go
+    (-> Tag (Expression Any))
+    (|>> (list (..var "go"))
+         ..form))
+
+  (def: #export values-list/1
+    (-> (Expression Any) (Expression Any))
+    (|>> (list (..var "values-list"))
+         ..form))
+
+  (def: #export (multiple-value-setq bindings values)
+    (-> Var/* (Expression Any) (Expression Any))
+    (..form (list (..var "multiple-value-setq")
+                  (:transmutation bindings)
+                  values)))
   )
 
 (def: #export (while condition body)
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/common_lisp/common.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/common_lisp/common.lux
index 2a64aeb1e..b47bade2d 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/common_lisp/common.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/common_lisp/common.lux
@@ -53,7 +53,7 @@
 (template: (!unary function)
   (|>> list _.apply/* (|> (_.constant function))))
 
-## TODO: Get rid of this ASAP
+## ## TODO: Get rid of this ASAP
 ## (def: lux::syntax_char_case!
 ##   (..custom [($_ <>.and
 ##                  <s>.any
@@ -74,18 +74,18 @@
 ##                                                            branchG])))
 ##                                               conditionals))]
 ##                  (wrap (_.let (list [@input inputG])
-##                          (list\fold (function (_ [test then] else)
-##                                       (_.if test then else))
-##                                     elseG
-##                                     conditionalsG)))))]))
+##                          (list (list\fold (function (_ [test then] else)
+##                                             (_.if test then else))
+##                                           elseG
+##                                           conditionalsG))))))]))
 
-## (def: lux_procs
-##   Bundle
-##   (|> /.empty
-##       (/.install "syntax char case!" lux::syntax_char_case!)
-##       (/.install "is" (binary (product.uncurry _.eq?/2)))
-##       (/.install "try" (unary //runtime.lux//try))
-##       ))
+(def: lux_procs
+  Bundle
+  (|> /.empty
+      ## (/.install "syntax char case!" lux::syntax_char_case!)
+      (/.install "is" (binary _.eq/2))
+      ## (/.install "try" (unary //runtime.lux//try))
+      ))
 
 ## (def: (capped operation parameter subject)
 ##   (-> (-> Expression Expression Expression)
@@ -128,13 +128,17 @@
           ## (/.install "decode" (unary //runtime.f64//decode))
           )))
 
-## (def: (text//index [offset sub text])
-##   (Trinary Expression)
-##   (//runtime.text//index offset sub text))
+(def: (text//index [offset sub text])
+  (Trinary (Expression Any))
+  (//runtime.text//index offset sub text))
+
+(def: (text//clip [offset length text])
+  (Trinary (Expression Any))
+  (//runtime.text//clip offset length text))
 
-## (def: (text//clip [paramO extraO subjectO])
-##   (Trinary Expression)
-##   (//runtime.text//clip paramO extraO subjectO))
+(def: (text//char [index text])
+  (Binary (Expression Any))
+  (_.char-code/1 (_.char/2 [text index])))
 
 (def: text_procs
   Bundle
@@ -144,16 +148,17 @@
           ## (/.install "<" (binary (product.uncurry _.string<?/2)))
           (/.install "concat" (binary (function (_ [left right])
                                         (_.concatenate/3 [(_.symbol "string") left right]))))
-          ## (/.install "index" (trinary ..text//index))
-          ## (/.install "size" (unary _.string-length/1))
-          ## (/.install "char" (binary (product.uncurry //runtime.text//char)))
-          ## (/.install "clip" (trinary ..text//clip))
+          (/.install "index" (trinary ..text//index))
+          (/.install "size" (unary _.length/1))
+          (/.install "char" (binary ..text//char))
+          (/.install "clip" (trinary ..text//clip))
           )))
 
 (def: (io//log! message)
   (Unary (Expression Any))
-  (_.progn (_.write-line/1 message)
-           //runtime.unit))
+  (_.progn (list (_.pprint/1 message)
+                 ## (_.write-line/1 message)
+                 //runtime.unit)))
 
 (def: io_procs
   Bundle
@@ -168,7 +173,7 @@
   Bundle
   (<| (/.prefix "lux")
       (|> /.empty
-          ## (dictionary.merge lux_procs)
+          (dictionary.merge lux_procs)
           (dictionary.merge i64_procs)
           (dictionary.merge f64_procs)
           (dictionary.merge text_procs)
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/common_lisp/case.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/common_lisp/case.lux
index 1c669ae52..08250d5d9 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/common_lisp/case.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/common_lisp/case.lux
@@ -7,7 +7,7 @@
    [data
     ["." text]
     [collection
-     ["." list ("#\." functor fold)]
+     ["." list ("#\." functor fold monoid)]
      ["." set]]]
    [math
     [number
@@ -47,7 +47,7 @@
     [valueG (expression archive valueS)
      bodyG (expression archive bodyS)]
     (wrap (_.let (list [(..register register) valueG])
-            bodyG))))
+            (list bodyG)))))
 
 (def: #export (if expression archive [testS thenS elseS])
   (Generator [Synthesis Synthesis Synthesis])
@@ -94,10 +94,9 @@
   (_.setq @savepoint (_.cons/2 [@cursor @savepoint])))
 
 (def: restore!
-  (Expression Any)
-  ($_ _.progn
-      (_.setq @cursor (_.car/1 @savepoint))
-      (_.setq @savepoint (_.cdr/1 @savepoint))))
+  (List (Expression Any))
+  (list (_.setq @cursor (_.car/1 @savepoint))
+        (_.setq @savepoint (_.cdr/1 @savepoint))))
 
 (def: @fail (_.label "lux_pm_fail"))
 (def: @done (_.label "lux_pm_done"))
@@ -109,19 +108,23 @@
   (_.setq @cursor (_.nthcdr/2 [(_.int (.int pops)) @cursor])))
 
 (template [<name> <flag> <prep>]
-  [(def: (<name> simple? idx)
-     (-> Bit Nat (Expression Any))
+  [(def: (<name> simple? idx next!)
+     (-> Bit Nat (Maybe (Expression Any)) (Expression Any))
      (.let [<failure_condition> (_.eq/2 [@variant @temp])]
        (_.let (list [@variant ..peek])
-         ($_ _.progn
-             (_.setq @temp (|> idx <prep> .int _.int (//runtime.sum//get @variant <flag>)))
-             (.if simple?
-               (_.when <failure_condition>
-                       fail!)
-               (_.if <failure_condition>
-                 fail!
-                 (..push! @temp))
-               )))))]
+         (list& (_.setq @temp (|> idx <prep> .int _.int (//runtime.sum//get @variant <flag>)))
+                (.if simple?
+                  (_.when <failure_condition>
+                          fail!)
+                  (_.if <failure_condition>
+                    fail!
+                    (..push! @temp)))
+                (.case next!
+                  (#.Some next!)
+                  (list next!)
+                  
+                  #.None
+                  (list))))))]
 
   [left_choice  _.nil         (<|)]
   [right_choice (_.string "") inc]
@@ -129,12 +132,12 @@
 
 (def: (alternation pre! post!)
   (-> (Expression Any) (Expression Any) (Expression Any))
-  (_.progn (<| (_.block ..@fail)
-               (_.progn ..save!)
-               pre!)
-           ($_ _.progn
+  (_.progn ($_ list\compose
+               (list (_.block ..@fail
+                              (list ..save!
+                                    pre!)))
                ..restore!
-               post!)))
+               (list post!))))
 
 (def: (pattern_matching' expression archive)
   (Generator Path)
@@ -186,12 +189,12 @@
 
       (^template [<complex> <simple> <choice>]
         [(^ (<complex> idx))
-         (///////phase\wrap (<choice> false idx))
+         (///////phase\wrap (<choice> false idx #.None))
 
          (^ (<simple> idx nextP))
          (|> nextP
              recur
-             (\ ///////phase.monad map (_.progn (<choice> true idx))))])
+             (\ ///////phase.monad map (|>> #.Some (<choice> true idx))))])
       ([/////synthesis.side/left  /////synthesis.simple_left_side  ..left_choice]
        [/////synthesis.side/right /////synthesis.simple_right_side ..right_choice])
 
@@ -208,27 +211,29 @@
       (.let [[extra_pops nextP'] (////synthesis/case.count_pops nextP)]
         (do ///////phase.monad
           [next! (recur nextP')]
-          (///////phase\wrap ($_ _.progn
-                                 (..multi_pop! (n.+ 2 extra_pops))
-                                 next!))))
-
-      (^template [<tag> <combinator>]
-        [(^ (<tag> preP postP))
-         (do ///////phase.monad
-           [pre! (recur preP)
-            post! (recur postP)]
-           (wrap (<combinator> pre! post!)))])
-      ([/////synthesis.path/alt ..alternation]
-       [/////synthesis.path/seq _.progn]))))
+          (///////phase\wrap (_.progn (list (..multi_pop! (n.+ 2 extra_pops))
+                                            next!)))))
+
+      (^ (/////synthesis.path/alt preP postP))
+      (do ///////phase.monad
+        [pre! (recur preP)
+         post! (recur postP)]
+        (wrap (..alternation pre! post!)))
+
+      (^ (/////synthesis.path/seq preP postP))
+      (do ///////phase.monad
+        [pre! (recur preP)
+         post! (recur postP)]
+        (wrap (_.progn (list pre! post!)))))))
 
 (def: (pattern_matching expression archive pathP)
   (Generator Path)
   (do ///////phase.monad
     [pattern_matching! (pattern_matching' expression archive pathP)]
     (wrap (_.block ..@done
-                   (_.progn (_.block ..@fail
-                                     pattern_matching!)
-                            (_.error/1 (_.string ////synthesis/case.pattern_matching_error)))))))
+                   (list (_.block ..@fail
+                                  (list pattern_matching!))
+                         (_.error/1 (_.string ////synthesis/case.pattern_matching_error)))))))
 
 (def: #export (case expression archive [valueS pathP])
   (Generator [Synthesis Path])
@@ -246,4 +251,4 @@
                         [@savepoint (_.list/* (list))]
                         [@temp _.nil]
                         storage)
-            pattern_matching!))))
+            (list pattern_matching!)))))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/common_lisp/function.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/common_lisp/function.lux
index 23f60e9d0..2a5896e92 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/common_lisp/function.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/common_lisp/function.lux
@@ -6,6 +6,8 @@
     pipe]
    [data
     ["." product]
+    [text
+     ["%" format (#+ format)]]
     [collection
      ["." list ("#\." functor fold)]]]
    [target
@@ -58,12 +60,11 @@
 (def: #export (function expression archive [environment arity bodyS])
   (Generator (Abstraction Synthesis))
   (do {! ///////phase.monad}
-    [[function_name bodyG] (/////generation.with_new_context archive
-                             (do !
-                               [@self (\ ! map (|>> ///reference.artifact _.var)
-                                         (/////generation.context archive))]
-                               (/////generation.with_anchor @self
-                                 (expression archive bodyS))))
+    [@scope (\ ! map (|>> %.nat (format "function_scope") _.tag) /////generation.next)
+     @output (\ ! map (|>> %.nat (format "loop_output") _.var) /////generation.next)
+     [function_name bodyG] (/////generation.with_new_context archive
+                             (/////generation.with_anchor [@scope 1]
+                               (expression archive bodyS)))
      closureG+ (monad.map ! (expression archive) environment)
      #let [@curried (_.var "curried")
            @missing (_.var "missing")
@@ -78,20 +79,24 @@
     (with_closure closureG+
       (_.labels (list [@self [(_.args& (list) @curried)
                               (_.let (list [@num_args (_.length/1 @curried)])
-                                (_.cond (list [(_.=/2 [arityG @num_args])
-                                               (_.let (list initialize_self!)
-                                                 (_.destructuring-bind initialize!
-                                                                       bodyG))]
+                                (list (_.cond (list [(_.=/2 [arityG @num_args])
+                                                     (_.let (list [@output _.nil]
+                                                                  initialize_self!)
+                                                       (list (_.destructuring-bind initialize!
+                                                                                   (list (_.tagbody
+                                                                                          (list @scope
+                                                                                                (_.setq @output bodyG)))
+                                                                                         @output))))]
 
-                                              [(_.>/2 [arityG @num_args])
-                                               (let [arity_inputs (_.subseq/3 [@curried (_.int +0) arityG])
-                                                     extra_inputs (_.subseq/3 [@curried arityG @num_args])]
-                                                 (_.apply/2 [(_.apply/2 [(_.function/1 @self)
-                                                                         arity_inputs])
-                                                             extra_inputs]))])
-                                        ## (|> @num_args (_.< arityG))
-                                        (_.lambda (_.args& (list) @missing)
-                                                  (_.apply/2 [(_.function/1 @self)
-                                                              (_.append/2 [@curried @missing])]))))]])
+                                                    [(_.>/2 [arityG @num_args])
+                                                     (let [arity_inputs (_.subseq/3 [@curried (_.int +0) arityG])
+                                                           extra_inputs (_.subseq/3 [@curried arityG @num_args])]
+                                                       (_.apply/2 [(_.apply/2 [(_.function/1 @self)
+                                                                               arity_inputs])
+                                                                   extra_inputs]))])
+                                              ## (|> @num_args (_.< arityG))
+                                              (_.lambda (_.args& (list) @missing)
+                                                        (_.apply/2 [(_.function/1 @self)
+                                                                    (_.append/2 [@curried @missing])])))))]])
                 (_.function/1 @self)))
     ))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/common_lisp/loop.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/common_lisp/loop.lux
index 14aa89668..7256e926d 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/common_lisp/loop.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/common_lisp/loop.lux
@@ -41,20 +41,29 @@
     ## true loop
     _
     (do {! ///////phase.monad}
-      [@scope (\ ! map (|>> %.nat (format "scope") _.var) /////generation.next)
+      [@scope (\ ! map (|>> %.nat (format "loop_scope") _.tag) /////generation.next)
+       @output (\ ! map (|>> %.nat (format "loop_output") _.var) /////generation.next)
        initsG+ (monad.map ! (expression archive) initsS+)
-       bodyG (/////generation.with_anchor @scope
+       bodyG (/////generation.with_anchor [@scope start]
                (expression archive bodyS))]
-      (wrap (_.labels (list [@scope {#_.input (|> initsS+
-                                                  list.enumeration
-                                                  (list\map (|>> product.left (n.+ start) //case.register))
-                                                  _.args)
-                                     #_.output bodyG}])
-                      (_.funcall/+ [(_.function/1 @scope) initsG+]))))))
+      (wrap (_.let (|> initsG+
+                       list.enumeration
+                       (list\map (function (_ [idx init])
+                                   [(|> idx (n.+ start) //case.register)
+                                    init]))
+                       (list& [@output _.nil]))
+              (list (_.tagbody (list @scope
+                                     (_.setq @output bodyG)))
+                    @output))))))
 
 (def: #export (recur expression archive argsS+)
   (Generator (List Synthesis))
   (do {! ///////phase.monad}
-    [@scope /////generation.anchor
-     argsO+ (monad.map ! (expression archive) argsS+)]
-    (wrap (_.call/* @scope argsO+))))
+    [[tag offset] /////generation.anchor
+     argsO+ (monad.map ! (expression archive) argsS+)
+     #let [bindings (|> argsO+
+                        list.enumeration
+                        (list\map (|>> product.left (n.+ offset) //case.register))
+                        _.args)]]
+    (wrap (_.progn (list (_.multiple-value-setq bindings (_.values/* argsO+))
+                         (_.go tag))))))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/common_lisp/runtime.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/common_lisp/runtime.lux
index b8c9149d3..73f885ebd 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/common_lisp/runtime.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/common_lisp/runtime.lux
@@ -22,7 +22,7 @@
     [number (#+ hex)
      ["." i64]]]
    ["@" target
-    ["_" common_lisp (#+ Expression Var/1 Computation Literal)]]]
+    ["_" common_lisp (#+ Expression Computation Literal)]]]
   ["." /// #_
    ["#." reference]
    ["//#" /// #_
@@ -42,7 +42,7 @@
 
 (template [<name> <base>]
   [(type: #export <name>
-     (<base> Var/1 (Expression Any) (Expression Any)))]
+     (<base> [_.Tag Register] (Expression Any) (Expression Any)))]
 
   [Operation /////generation.Operation]
   [Phase /////generation.Phase]
@@ -157,10 +157,8 @@
                                   ..none)]))))
 
 (def: runtime//lux
-  ($_ _.progn
-      @lux//try
-      @lux//program_args
-      ))
+  (_.progn (list @lux//try
+                 @lux//program_args)))
 
 (def: last_index
   (|>> _.length/1 [(_.int +1)] _.-/2))
@@ -175,23 +173,22 @@
   (runtime: (tuple//left lefts tuple)
     (with_vars [last_index_right]
       (_.let (list [last_index_right (..last_index tuple)])
-        (_.if (_.>/2 [lefts last_index_right])
-          ## No need for recursion
-          (_.elt/2 [tuple lefts])
-          ## Needs recursion
-          (!recur tuple//left)))))
+        (list (_.if (_.>/2 [lefts last_index_right])
+                ## No need for recursion
+                (_.elt/2 [tuple lefts])
+                ## Needs recursion
+                (!recur tuple//left))))))
 
   (runtime: (tuple//right lefts tuple)
     (with_vars [last_index_right right_index]
       (_.let (list [last_index_right (..last_index tuple)]
                    [right_index (_.+/2 [(_.int +1) lefts])])
-        (_.cond (list [(_.=/2 [last_index_right right_index])
-                       (_.elt/2 [tuple right_index])]
-                      [(_.>/2 [last_index_right right_index])
-                       ## Needs recursion.
-                       (!recur tuple//right)])
-                (_.subseq/3 [tuple right_index (_.length/1 tuple)]))
-        ))))
+        (list (_.cond (list [(_.=/2 [last_index_right right_index])
+                             (_.elt/2 [tuple right_index])]
+                            [(_.>/2 [last_index_right right_index])
+                             ## Needs recursion.
+                             (!recur tuple//right)])
+                      (_.subseq/3 [tuple right_index (_.length/1 tuple)])))))))
 
 ## TODO: Find a way to extract parts of the sum without "nth", which
 ## does a linear search, and is thus expensive.
@@ -203,34 +200,31 @@
           sum_value (_.nth/2 [(_.int +2) sum])
           test_recursion! (_.if sum_flag
                             ## Must iterate.
-                            ($_ _.progn
-                                (_.setq wantedTag (_.-/2 [sum_tag wantedTag]))
-                                (_.setq sum sum_value))
+                            (_.progn (list (_.setq wantedTag (_.-/2 [sum_tag wantedTag]))
+                                           (_.setq sum sum_value)))
                             no_match!)]
-      (<| (_.progn (_.setq sum_tag (_.nth/2 [(_.int +0) sum])))
-          (_.progn (_.setq sum_flag (_.nth/2 [(_.int +1) sum])))
-          (_.block @exit)
-          (_.while (_.bool true))
-          (_.cond (list [(_.=/2 [sum_tag wantedTag])
-                         (_.if (_.equal/2 [wantsLast sum_flag])
-                           (return! sum_value)
-                           test_recursion!)]
+      (_.progn (list (_.setq sum_tag (_.nth/2 [(_.int +0) sum]))
+                     (_.setq sum_flag (_.nth/2 [(_.int +1) sum]))
+                     (_.block @exit
+                              (list (_.while (_.bool true)
+                                             (_.cond (list [(_.=/2 [sum_tag wantedTag])
+                                                            (_.if (_.equal/2 [wantsLast sum_flag])
+                                                              (return! sum_value)
+                                                              test_recursion!)]
 
-                        [(_.>/2 [sum_tag wantedTag])
-                         test_recursion!]
+                                                           [(_.>/2 [sum_tag wantedTag])
+                                                            test_recursion!]
 
-                        [(_.and (_.</2 [sum_tag wantedTag])
-                                wantsLast)
-                         (return! (variant' (_.-/2 [wantedTag sum_tag]) sum_flag sum_value))])
+                                                           [(_.and (_.</2 [sum_tag wantedTag])
+                                                                   wantsLast)
+                                                            (return! (variant' (_.-/2 [wantedTag sum_tag]) sum_flag sum_value))])
 
-                  no_match!)))))
+                                                     no_match!)))))))))
 
 (def: runtime//adt
-  ($_ _.progn
-      @tuple//left
-      @tuple//right
-      @sum//get
-      ))
+  (_.progn (list @tuple//left
+                 @tuple//right
+                 @sum//get)))
 
 (runtime: (i64//right_shift shift input)
   (_.if (_.=/2 [(_.int +0) shift])
@@ -244,56 +238,47 @@
           [mask] _.logand/2))))
 
 (def: runtime//i64
-  ($_ _.progn
-      @i64//right_shift
-      ))
+  @i64//right_shift)
 
-(runtime: (text//clip from to text)
-  (_.subseq/3 [text from to]))
+(runtime: (text//clip offset length text)
+  (_.subseq/3 [text offset (_.+/2 [offset length])]))
 
-(runtime: (text//index reference start space)
+(runtime: (text//index offset sub text)
   (with_vars [index]
-    (_.let (list [index (_.search/3 [reference space start])])
-      (_.if index
-        (..some index)
-        ..none))))
+    (_.let (list [index (_.search/3 [sub text offset])])
+      (list (_.if index
+              (..some index)
+              ..none)))))
 
 (def: runtime//text
-  ($_ _.progn
-      @text//index
-      @text//clip
-      ))
+  (_.progn (list @text//index
+                 @text//clip)))
 
 (runtime: (io//exit code)
-  ($_ _.progn
-      (_.conditional+ (list "sbcl")
-                      (_.call/* (_.var "sb-ext:quit") (list code)))
-      (_.conditional+ (list "clisp")
-                      (_.call/* (_.var "ext:exit") (list code)))
-      (_.conditional+ (list "ccl")
-                      (_.call/* (_.var "ccl:quit") (list code)))
-      (_.conditional+ (list "allegro")
-                      (_.call/* (_.var "excl:exit") (list code)))
-      (_.call/* (_.var "cl-user::quit") (list code))))
+  (_.progn (list (_.conditional+ (list "sbcl")
+                                 (_.call/* (_.var "sb-ext:quit") (list code)))
+                 (_.conditional+ (list "clisp")
+                                 (_.call/* (_.var "ext:exit") (list code)))
+                 (_.conditional+ (list "ccl")
+                                 (_.call/* (_.var "ccl:quit") (list code)))
+                 (_.conditional+ (list "allegro")
+                                 (_.call/* (_.var "excl:exit") (list code)))
+                 (_.call/* (_.var "cl-user::quit") (list code)))))
 
 (runtime: (io//current_time _)
   (_.*/2 [(_.int +1,000)
           (_.get-universal-time/0 [])]))
 
 (def: runtime//io
-  ($_ _.progn
-      @io//exit
-      @io//current_time
-      ))
+  (_.progn (list @io//exit
+                 @io//current_time)))
 
 (def: runtime
-  ($_ _.progn
-      runtime//adt
-      runtime//lux
-      runtime//i64
-      runtime//text
-      runtime//io
-      ))
+  (_.progn (list runtime//adt
+                 runtime//lux
+                 runtime//i64
+                 runtime//text
+                 runtime//io)))
 
 (def: #export generate
   (Operation [Registry Output])