- Changed the names of the tags of the Syntax type to differentiate them better from the tags of the Type type.

1 files changed, 226 insertions, 226 deletions

diff --git a/source/lux.lux b/source/lux.lux
index f2a6f70da..3b7bb9702 100644
--- a/source/lux.lux
+++ b/source/lux.lux
@@ -131,16 +131,16 @@
 (_lux_export Meta)
 
 ## (deftype (Syntax' w)
-##   (| (#Bool Bool)
-##      (#Int Int)
-##      (#Real Real)
-##      (#Char Char)
-##      (#Text Text)
-##      (#Symbol (, Text Text))
-##      (#Tag (, Text Text))
-##      (#Form (List (w (Syntax' w))))
-##      (#Tuple (List (w (Syntax' w))))
-##      (#Record (List (, (w (Syntax' w)) (w (Syntax' w)))))))
+##   (| (#BoolS Bool)
+##      (#IntS Int)
+##      (#RealS Real)
+##      (#CharS Char)
+##      (#TextS Text)
+##      (#SymbolS (, Text Text))
+##      (#TagS (, Text Text))
+##      (#FormS (List (w (Syntax' w))))
+##      (#TupleS (List (w (Syntax' w))))
+##      (#RecordS (List (, (w (Syntax' w)) (w (Syntax' w)))))))
 (_lux_def Syntax'
           (_lux_case (#AppT [(#BoundT "w")
                              (#AppT [(#BoundT "Syntax'")
@@ -149,16 +149,16 @@
                      (_lux_case (#AppT [List Syntax])
                                 SyntaxList
                                 (#AllT [#None "Syntax'" "w"
-                                        (#VariantT (#Cons [["lux;Bool" Bool]
-                                                           (#Cons [["lux;Int" Int]
-                                                                   (#Cons [["lux;Real" Real]
-                                                                           (#Cons [["lux;Char" Char]
-                                                                                   (#Cons [["lux;Text" Text]
-                                                                                           (#Cons [["lux;Symbol" Ident]
-                                                                                                   (#Cons [["lux;Tag" Ident]
-                                                                                                           (#Cons [["lux;Form" SyntaxList]
-                                                                                                                   (#Cons [["lux;Tuple" SyntaxList]
-                                                                                                                           (#Cons [["lux;Record" (#AppT [List (#TupleT (#Cons [Syntax (#Cons [Syntax #Nil])]))])]
+                                        (#VariantT (#Cons [["lux;BoolS" Bool]
+                                                           (#Cons [["lux;IntS" Int]
+                                                                   (#Cons [["lux;RealS" Real]
+                                                                           (#Cons [["lux;CharS" Char]
+                                                                                   (#Cons [["lux;TextS" Text]
+                                                                                           (#Cons [["lux;SymbolS" Ident]
+                                                                                                   (#Cons [["lux;TagS" Ident]
+                                                                                                           (#Cons [["lux;FormS" SyntaxList]
+                                                                                                                   (#Cons [["lux;TupleS" SyntaxList]
+                                                                                                                           (#Cons [["lux;RecordS" (#AppT [List (#TupleT (#Cons [Syntax (#Cons [Syntax #Nil])]))])]
                                                                                                                                    #Nil])
                                                                                                                            ])])])])])])])])])
                                                    )]))))
@@ -319,32 +319,32 @@
 (_lux_def $text
           (_lux_: (#LambdaT [Text Syntax])
                   (_lux_lambda _ text
-                          (_meta (#Text text)))))
+                          (_meta (#TextS text)))))
 
 (_lux_def $symbol
           (_lux_: (#LambdaT [Ident Syntax])
                   (_lux_lambda _ ident
-                          (_meta (#Symbol ident)))))
+                          (_meta (#SymbolS ident)))))
 
 (_lux_def $tag
           (_lux_: (#LambdaT [Ident Syntax])
                   (_lux_lambda _ ident
-                          (_meta (#Tag ident)))))
+                          (_meta (#TagS ident)))))
 
 (_lux_def $form
           (_lux_: (#LambdaT [(#AppT [List Syntax]) Syntax])
                   (_lux_lambda _ tokens
-                          (_meta (#Form tokens)))))
+                          (_meta (#FormS tokens)))))
 
 (_lux_def $tuple
           (_lux_: (#LambdaT [(#AppT [List Syntax]) Syntax])
                   (_lux_lambda _ tokens
-                          (_meta (#Tuple tokens)))))
+                          (_meta (#TupleS tokens)))))
 
 (_lux_def $record
           (_lux_: (#LambdaT [(#AppT [List (#TupleT (#Cons [Syntax (#Cons [Syntax #Nil])]))]) Syntax])
                   (_lux_lambda _ tokens
-                          (_meta (#Record tokens)))))
+                          (_meta (#RecordS tokens)))))
 
 (_lux_def let'
           (_lux_: Macro
@@ -363,34 +363,34 @@
           (_lux_: Macro
                   (_lux_lambda _ tokens
                           (_lux_case tokens
-                                     (#Cons [(#Meta [_ (#Tuple (#Cons [arg args']))]) (#Cons [body #Nil])])
-                                     (return (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["" "_lux_lambda"]))
-                                                                           (#Cons [(_meta (#Symbol ["" ""]))
-                                                                                   (#Cons [arg
-                                                                                           (#Cons [(_lux_case args'
-                                                                                                              #Nil
-                                                                                                              body
-
-                                                                                                              _
-                                                                                                              (_meta (#Form (#Cons [(_meta (#Symbol ["lux" "lambda_"]))
-                                                                                                                                    (#Cons [(_meta (#Tuple args'))
-                                                                                                                                            (#Cons [body #Nil])])]))))
-                                                                                                   #Nil])])])])))
+                                     (#Cons [(#Meta [_ (#TupleS (#Cons [arg args']))]) (#Cons [body #Nil])])
+                                     (return (#Cons [(_meta (#FormS (#Cons [(_meta (#SymbolS ["" "_lux_lambda"]))
+                                                                            (#Cons [(_meta (#SymbolS ["" ""]))
+                                                                                    (#Cons [arg
+                                                                                            (#Cons [(_lux_case args'
+                                                                                                               #Nil
+                                                                                                               body
+
+                                                                                                               _
+                                                                                                               (_meta (#FormS (#Cons [(_meta (#SymbolS ["lux" "lambda_"]))
+                                                                                                                                      (#Cons [(_meta (#TupleS args'))
+                                                                                                                                              (#Cons [body #Nil])])]))))
+                                                                                                    #Nil])])])])))
                                                      #Nil]))
 
-                                     (#Cons [(#Meta [_ (#Symbol self)]) (#Cons [(#Meta [_ (#Tuple (#Cons [arg args']))]) (#Cons [body #Nil])])])
-                                     (return (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["" "_lux_lambda"]))
-                                                                           (#Cons [(_meta (#Symbol self))
-                                                                                   (#Cons [arg
-                                                                                           (#Cons [(_lux_case args'
-                                                                                                              #Nil
-                                                                                                              body
-
-                                                                                                              _
-                                                                                                              (_meta (#Form (#Cons [(_meta (#Symbol ["lux" "lambda_"]))
-                                                                                                                                    (#Cons [(_meta (#Tuple args'))
-                                                                                                                                            (#Cons [body #Nil])])]))))
-                                                                                                   #Nil])])])])))
+                                     (#Cons [(#Meta [_ (#SymbolS self)]) (#Cons [(#Meta [_ (#TupleS (#Cons [arg args']))]) (#Cons [body #Nil])])])
+                                     (return (#Cons [(_meta (#FormS (#Cons [(_meta (#SymbolS ["" "_lux_lambda"]))
+                                                                            (#Cons [(_meta (#SymbolS self))
+                                                                                    (#Cons [arg
+                                                                                            (#Cons [(_lux_case args'
+                                                                                                               #Nil
+                                                                                                               body
+
+                                                                                                               _
+                                                                                                               (_meta (#FormS (#Cons [(_meta (#SymbolS ["lux" "lambda_"]))
+                                                                                                                                      (#Cons [(_meta (#TupleS args'))
+                                                                                                                                              (#Cons [body #Nil])])]))))
+                                                                                                    #Nil])])])])))
                                                      #Nil]))
                                      
                                      _
@@ -401,55 +401,55 @@
           (_lux_: Macro
                   (lambda_ [tokens]
                            (_lux_case tokens
-                                      (#Cons [(#Meta [_ (#Tag ["" "export"])])
-                                              (#Cons [(#Meta [_ (#Form (#Cons [name args]))])
+                                      (#Cons [(#Meta [_ (#TagS ["" "export"])])
+                                              (#Cons [(#Meta [_ (#FormS (#Cons [name args]))])
                                                       (#Cons [type (#Cons [body #Nil])])])])
-                                      (return (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["" "_lux_def"]))
-                                                                            (#Cons [name
-                                                                                    (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["" "_lux_:"]))
-                                                                                                                  (#Cons [type
-                                                                                                                          (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["lux" "lambda_"]))
-                                                                                                                                                        (#Cons [name
-                                                                                                                                                                (#Cons [(_meta (#Tuple args))
-                                                                                                                                                                        (#Cons [body #Nil])])])])))
-                                                                                                                                  #Nil])])])))
-                                                                                            #Nil])])])))
-                                                      (#Cons [(_meta (#Form (#Cons [($symbol ["" "_lux_export"]) (#Cons [name #Nil])])))
+                                      (return (#Cons [(_meta (#FormS (#Cons [(_meta (#SymbolS ["" "_lux_def"]))
+                                                                             (#Cons [name
+                                                                                     (#Cons [(_meta (#FormS (#Cons [(_meta (#SymbolS ["" "_lux_:"]))
+                                                                                                                    (#Cons [type
+                                                                                                                            (#Cons [(_meta (#FormS (#Cons [(_meta (#SymbolS ["lux" "lambda_"]))
+                                                                                                                                                           (#Cons [name
+                                                                                                                                                                   (#Cons [(_meta (#TupleS args))
+                                                                                                                                                                           (#Cons [body #Nil])])])])))
+                                                                                                                                    #Nil])])])))
+                                                                                             #Nil])])])))
+                                                      (#Cons [(_meta (#FormS (#Cons [($symbol ["" "_lux_export"]) (#Cons [name #Nil])])))
                                                               #Nil])]))
 
-                                      (#Cons [(#Meta [_ (#Tag ["" "export"])]) (#Cons [name (#Cons [type (#Cons [body #Nil])])])])
-                                      (return (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["" "_lux_def"]))
-                                                                            (#Cons [name
-                                                                                    (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["" "_lux_:"]))
-                                                                                                                  (#Cons [type
-                                                                                                                          (#Cons [body
-                                                                                                                                  #Nil])])])))
-                                                                                            #Nil])])])))
-                                                      (#Cons [(_meta (#Form (#Cons [($symbol ["" "_lux_export"]) (#Cons [name #Nil])])))
+                                      (#Cons [(#Meta [_ (#TagS ["" "export"])]) (#Cons [name (#Cons [type (#Cons [body #Nil])])])])
+                                      (return (#Cons [(_meta (#FormS (#Cons [(_meta (#SymbolS ["" "_lux_def"]))
+                                                                             (#Cons [name
+                                                                                     (#Cons [(_meta (#FormS (#Cons [(_meta (#SymbolS ["" "_lux_:"]))
+                                                                                                                    (#Cons [type
+                                                                                                                            (#Cons [body
+                                                                                                                                    #Nil])])])))
+                                                                                             #Nil])])])))
+                                                      (#Cons [(_meta (#FormS (#Cons [($symbol ["" "_lux_export"]) (#Cons [name #Nil])])))
                                                               #Nil])]))
 
-                                      (#Cons [(#Meta [_ (#Form (#Cons [name args]))])
+                                      (#Cons [(#Meta [_ (#FormS (#Cons [name args]))])
                                               (#Cons [type (#Cons [body #Nil])])])
-                                      (return (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["" "_lux_def"]))
-                                                                            (#Cons [name
-                                                                                    (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["" "_lux_:"]))
-                                                                                                                  (#Cons [type
-                                                                                                                          (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["lux" "lambda_"]))
-                                                                                                                                                        (#Cons [name
-                                                                                                                                                                (#Cons [(_meta (#Tuple args))
-                                                                                                                                                                        (#Cons [body #Nil])])])])))
-                                                                                                                                  #Nil])])])))
-                                                                                            #Nil])])])))
+                                      (return (#Cons [(_meta (#FormS (#Cons [(_meta (#SymbolS ["" "_lux_def"]))
+                                                                             (#Cons [name
+                                                                                     (#Cons [(_meta (#FormS (#Cons [(_meta (#SymbolS ["" "_lux_:"]))
+                                                                                                                    (#Cons [type
+                                                                                                                            (#Cons [(_meta (#FormS (#Cons [(_meta (#SymbolS ["lux" "lambda_"]))
+                                                                                                                                                           (#Cons [name
+                                                                                                                                                                   (#Cons [(_meta (#TupleS args))
+                                                                                                                                                                           (#Cons [body #Nil])])])])))
+                                                                                                                                    #Nil])])])))
+                                                                                             #Nil])])])))
                                                       #Nil]))
 
                                       (#Cons [name (#Cons [type (#Cons [body #Nil])])])
-                                      (return (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["" "_lux_def"]))
-                                                                            (#Cons [name
-                                                                                    (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["" "_lux_:"]))
-                                                                                                                  (#Cons [type
-                                                                                                                          (#Cons [body
-                                                                                                                                  #Nil])])])))
-                                                                                            #Nil])])])))
+                                      (return (#Cons [(_meta (#FormS (#Cons [(_meta (#SymbolS ["" "_lux_def"]))
+                                                                             (#Cons [name
+                                                                                     (#Cons [(_meta (#FormS (#Cons [(_meta (#SymbolS ["" "_lux_:"]))
+                                                                                                                    (#Cons [type
+                                                                                                                            (#Cons [body
+                                                                                                                                    #Nil])])])))
+                                                                                             #Nil])])])))
                                                       #Nil]))
 
                                       _
@@ -460,7 +460,7 @@
 (def_ #export (defmacro tokens)
   Macro
   (_lux_case tokens
-             (#Cons [(#Meta [_ (#Form (#Cons [name args]))]) (#Cons [body #Nil])])
+             (#Cons [(#Meta [_ (#FormS (#Cons [name args]))]) (#Cons [body #Nil])])
              (return (#Cons [($form (#Cons [($symbol ["lux" "def_"])
                                             (#Cons [($form (#Cons [name args]))
                                                     (#Cons [($symbol ["lux" "Macro"])
@@ -470,7 +470,7 @@
                              (#Cons [($form (#Cons [($symbol ["" "_lux_declare-macro"]) (#Cons [name #Nil])]))
                                      #Nil])]))
 
-             (#Cons [(#Meta [_ (#Tag ["" "export"])]) (#Cons [(#Meta [_ (#Form (#Cons [name args]))]) (#Cons [body #Nil])])])
+             (#Cons [(#Meta [_ (#TagS ["" "export"])]) (#Cons [(#Meta [_ (#FormS (#Cons [name args]))]) (#Cons [body #Nil])])])
              (return (#Cons [($form (#Cons [($symbol ["lux" "def_"])
                                             (#Cons [($tag ["" "export"])
                                                     (#Cons [($form (#Cons [name args]))
@@ -491,18 +491,18 @@
 (defmacro (->' tokens)
   (_lux_case tokens
              (#Cons [input (#Cons [output #Nil])])
-             (return (#Cons [(_meta (#Form (#Cons [(_meta (#Tag ["lux" "LambdaT"]))
-                                                   (#Cons [(_meta (#Tuple (#Cons [input (#Cons [output #Nil])])))
-                                                           #Nil])])))
+             (return (#Cons [(_meta (#FormS (#Cons [(_meta (#TagS ["lux" "LambdaT"]))
+                                                    (#Cons [(_meta (#TupleS (#Cons [input (#Cons [output #Nil])])))
+                                                            #Nil])])))
                              #Nil]))
 
              (#Cons [input (#Cons [output others])])
-             (return (#Cons [(_meta (#Form (#Cons [(_meta (#Tag ["lux" "LambdaT"]))
-                                                   (#Cons [(_meta (#Tuple (#Cons [input
-                                                                                  (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["lux" "->'"]))
-                                                                                                                (#Cons [output others])])))
-                                                                                          #Nil])])))
-                                                           #Nil])])))
+             (return (#Cons [(_meta (#FormS (#Cons [(_meta (#TagS ["lux" "LambdaT"]))
+                                                    (#Cons [(_meta (#TupleS (#Cons [input
+                                                                                    (#Cons [(_meta (#FormS (#Cons [(_meta (#SymbolS ["lux" "->'"]))
+                                                                                                                   (#Cons [output others])])))
+                                                                                            #Nil])])))
+                                                            #Nil])])))
                              #Nil]))
 
              _
@@ -510,23 +510,23 @@
 
 (defmacro (All' tokens)
   (_lux_case tokens
-             (#Cons [(#Meta [_ (#Tuple #Nil)])
+             (#Cons [(#Meta [_ (#TupleS #Nil)])
                      (#Cons [body #Nil])])
              (return (#Cons [body
                              #Nil]))
 
-             (#Cons [(#Meta [_ (#Tuple (#Cons [(#Meta [_ (#Symbol ["" arg-name])]) other-args]))])
+             (#Cons [(#Meta [_ (#TupleS (#Cons [(#Meta [_ (#SymbolS ["" arg-name])]) other-args]))])
                      (#Cons [body #Nil])])
-             (return (#Cons [(_meta (#Form (#Cons [(_meta (#Tag ["lux" "AllT"]))
-                                                   (#Cons [(_meta (#Tuple (#Cons [(_meta (#Tag ["lux" "None"]))
-                                                                                  (#Cons [(_meta (#Text ""))
-                                                                                          (#Cons [(_meta (#Text arg-name))
-                                                                                                  (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["lux" "All'"]))
-                                                                                                                                (#Cons [(_meta (#Tuple other-args))
-                                                                                                                                        (#Cons [body
-                                                                                                                                                #Nil])])])))
-                                                                                                          #Nil])])])])))
-                                                           #Nil])])))
+             (return (#Cons [(_meta (#FormS (#Cons [(_meta (#TagS ["lux" "AllT"]))
+                                                    (#Cons [(_meta (#TupleS (#Cons [(_meta (#TagS ["lux" "None"]))
+                                                                                    (#Cons [(_meta (#TextS ""))
+                                                                                            (#Cons [(_meta (#TextS arg-name))
+                                                                                                    (#Cons [(_meta (#FormS (#Cons [(_meta (#SymbolS ["lux" "All'"]))
+                                                                                                                                   (#Cons [(_meta (#TupleS other-args))
+                                                                                                                                           (#Cons [body
+                                                                                                                                                   #Nil])])])))
+                                                                                                            #Nil])])])])))
+                                                            #Nil])])))
                              #Nil]))
 
              _
@@ -534,11 +534,11 @@
 
 (defmacro (B' tokens)
   (_lux_case tokens
-             (#Cons [(#Meta [_ (#Symbol ["" bound-name])])
+             (#Cons [(#Meta [_ (#SymbolS ["" bound-name])])
                      #Nil])
-             (return (#Cons [(_meta (#Form (#Cons [(_meta (#Tag ["lux" "BoundT"]))
-                                                   (#Cons [(_meta (#Text bound-name))
-                                                           #Nil])])))
+             (return (#Cons [(_meta (#FormS (#Cons [(_meta (#TagS ["lux" "BoundT"]))
+                                                    (#Cons [(_meta (#TextS bound-name))
+                                                            #Nil])])))
                              #Nil]))
 
              _
@@ -550,11 +550,11 @@
              (return tokens)
 
              (#Cons [x (#Cons [y xs])])
-             (return (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["lux" "$'"]))
-                                                   (#Cons [(_meta (#Form (#Cons [(_meta (#Tag ["lux" "AppT"]))
-                                                                                 (#Cons [(_meta (#Tuple (#Cons [x (#Cons [y #Nil])])))
-                                                                                         #Nil])])))
-                                                           xs])])))
+             (return (#Cons [(_meta (#FormS (#Cons [(_meta (#SymbolS ["lux" "$'"]))
+                                                    (#Cons [(_meta (#FormS (#Cons [(_meta (#TagS ["lux" "AppT"]))
+                                                                                   (#Cons [(_meta (#TupleS (#Cons [x (#Cons [y #Nil])])))
+                                                                                           #Nil])])))
+                                                            xs])])))
                              #Nil]))
 
              _
@@ -582,10 +582,10 @@
 
 (defmacro #export (list xs)
   (return (#Cons [(fold (lambda_ [tail head]
-                                 (_meta (#Form (#Cons [(_meta (#Tag ["lux" "Cons"]))
-                                                       (#Cons [(_meta (#Tuple (#Cons [head (#Cons [tail #Nil])])))
-                                                               #Nil])]))))
-                        (_meta (#Tag ["lux" "Nil"]))
+                                 (_meta (#FormS (#Cons [(_meta (#TagS ["lux" "Cons"]))
+                                                        (#Cons [(_meta (#TupleS (#Cons [head (#Cons [tail #Nil])])))
+                                                                #Nil])]))))
+                        (_meta (#TagS ["lux" "Nil"]))
                         (reverse xs))
                   #Nil])))
 
@@ -593,8 +593,8 @@
   (_lux_case (reverse xs)
              (#Cons [last init])
              (return (list (fold (lambda_ [tail head]
-                                          (_meta (#Form (list (_meta (#Tag ["lux" "Cons"]))
-                                                              (_meta (#Tuple (list head tail)))))))
+                                          (_meta (#FormS (list (_meta (#TagS ["lux" "Cons"]))
+                                                               (_meta (#TupleS (list head tail)))))))
                                  last
                                  init)))
 
@@ -604,13 +604,13 @@
 (defmacro #export (lambda tokens)
   (let' [name tokens'] (_lux_: (#TupleT (list Ident ($' List Syntax)))
                                (_lux_case tokens
-                                          (#Cons [(#Meta [_ (#Symbol name)]) tokens'])
+                                          (#Cons [(#Meta [_ (#SymbolS name)]) tokens'])
                                           [name tokens']
 
                                           _
                                           [["" ""] tokens]))
         (_lux_case tokens'
-                   (#Cons [(#Meta [_ (#Tuple args)]) (#Cons [body #Nil])])
+                   (#Cons [(#Meta [_ (#TupleS args)]) (#Cons [body #Nil])])
                    (_lux_case args
                               #Nil
                               (fail "lambda requires a non-empty arguments tuple.")
@@ -632,8 +632,8 @@
 
 (defmacro (def__ tokens)
   (_lux_case tokens
-             (#Cons [(#Meta [_ (#Tag ["" "export"])])
-                     (#Cons [(#Meta [_ (#Form (#Cons [name args]))])
+             (#Cons [(#Meta [_ (#TagS ["" "export"])])
+                     (#Cons [(#Meta [_ (#FormS (#Cons [name args]))])
                              (#Cons [type (#Cons [body #Nil])])])])
              (return (list ($form (list ($symbol ["" "_lux_def"])
                                         name
@@ -645,7 +645,7 @@
                                                                   body))))))
                            ($form (list ($symbol ["" "_lux_export"]) name))))
 
-             (#Cons [(#Meta [_ (#Tag ["" "export"])]) (#Cons [name (#Cons [type (#Cons [body #Nil])])])])
+             (#Cons [(#Meta [_ (#TagS ["" "export"])]) (#Cons [name (#Cons [type (#Cons [body #Nil])])])])
              (return (list ($form (list ($symbol ["" "_lux_def"])
                                         name
                                         ($form (list ($symbol ["" "_lux_:"])
@@ -653,7 +653,7 @@
                                                      body))))
                            ($form (list ($symbol ["" "_lux_export"]) name))))
 
-             (#Cons [(#Meta [_ (#Form (#Cons [name args]))])
+             (#Cons [(#Meta [_ (#FormS (#Cons [name args]))])
                      (#Cons [type (#Cons [body #Nil])])])
              (return (list ($form (list ($symbol ["" "_lux_def"])
                                         name
@@ -685,13 +685,13 @@
 
 (defmacro #export (let tokens)
   (_lux_case tokens
-             (#Cons [(#Meta [_ (#Tuple bindings)]) (#Cons [body #Nil])])
+             (#Cons [(#Meta [_ (#TupleS bindings)]) (#Cons [body #Nil])])
              (return (list (fold (_lux_: (->' Syntax (#TupleT (list Syntax Syntax))
                                               Syntax)
                                          (lambda [body binding]
                                            (_lux_case binding
                                                       [label value]
-                                                      (_meta (#Form (list (_meta (#Symbol ["lux" "let'"])) label value body))))))
+                                                      (_meta (#FormS (list (_meta (#SymbolS ["lux" "let'"])) label value body))))))
                                  body
                                  (fold (lambda [tail head] (#Cons [head tail]))
                                        #Nil
@@ -725,7 +725,7 @@
 (def__ (spliced? token)
   (->' Syntax Bool)
   (_lux_case token
-             (#Meta [_ (#Form (#Cons [(#Meta [_ (#Symbol ["" "~@"])]) (#Cons [_ #Nil])]))])
+             (#Meta [_ (#FormS (#Cons [(#Meta [_ (#SymbolS ["" "~@"])]) (#Cons [_ #Nil])]))])
              true
 
              _
@@ -733,19 +733,19 @@
 
 (def__ (wrap-meta content)
   (->' Syntax Syntax)
-  (_meta (#Form (list (_meta (#Tag ["lux" "Meta"]))
-                      (_meta (#Tuple (list (_meta (#Tuple (list (_meta (#Text "")) (_meta (#Int -1)) (_meta (#Int -1)))))
-                                           content)))))))
+  (_meta (#FormS (list (_meta (#TagS ["lux" "Meta"]))
+                       (_meta (#TupleS (list (_meta (#TupleS (list (_meta (#TextS "")) (_meta (#IntS -1)) (_meta (#IntS -1)))))
+                                             content)))))))
 
 (def__ (untemplate-list tokens)
   (->' ($' List Syntax) Syntax)
   (_lux_case tokens
              #Nil
-             (_meta (#Tag ["lux" "Nil"]))
+             (_meta (#TagS ["lux" "Nil"]))
 
              (#Cons [token tokens'])
-             (_meta (#Form (list (_meta (#Tag ["lux" "Cons"]))
-                                 (_meta (#Tuple (list token (untemplate-list tokens')))))))))
+             (_meta (#FormS (list (_meta (#TagS ["lux" "Cons"]))
+                                  (_meta (#TupleS (list token (untemplate-list tokens')))))))))
 
 (def__ (list:++ xs ys)
   (All' [a] (->' ($' List (B' a)) ($' List (B' a)) ($' List (B' a))))
@@ -772,7 +772,7 @@
              true
              (let [elems' (map (lambda [elem]
                                  (_lux_case elem
-                                            (#Meta [_ (#Form (#Cons [(#Meta [_ (#Symbol ["" "~@"])]) (#Cons [spliced #Nil])]))])
+                                            (#Meta [_ (#FormS (#Cons [(#Meta [_ (#SymbolS ["" "~@"])]) (#Cons [spliced #Nil])]))])
                                             spliced
 
                                             _
@@ -791,50 +791,50 @@
 (def__ (untemplate subst token)
   (->' Text Syntax Syntax)
   (_lux_case token
-             (#Meta [_ (#Bool value)])
-             (wrap-meta ($form (list ($tag ["lux" "Bool"]) (_meta (#Bool value)))))
+             (#Meta [_ (#BoolS value)])
+             (wrap-meta ($form (list ($tag ["lux" "BoolS"]) (_meta (#BoolS value)))))
 
-             (#Meta [_ (#Int value)])
-             (wrap-meta ($form (list ($tag ["lux" "Int"]) (_meta (#Int value)))))
+             (#Meta [_ (#IntS value)])
+             (wrap-meta ($form (list ($tag ["lux" "IntS"]) (_meta (#IntS value)))))
 
-             (#Meta [_ (#Real value)])
-             (wrap-meta ($form (list ($tag ["lux" "Real"]) (_meta (#Real value)))))
+             (#Meta [_ (#RealS value)])
+             (wrap-meta ($form (list ($tag ["lux" "RealS"]) (_meta (#RealS value)))))
 
-             (#Meta [_ (#Char value)])
-             (wrap-meta ($form (list ($tag ["lux" "Char"]) (_meta (#Char value)))))
+             (#Meta [_ (#CharS value)])
+             (wrap-meta ($form (list ($tag ["lux" "CharS"]) (_meta (#CharS value)))))
 
-             (#Meta [_ (#Text value)])
-             (wrap-meta ($form (list ($tag ["lux" "Text"]) (_meta (#Text value)))))
+             (#Meta [_ (#TextS value)])
+             (wrap-meta ($form (list ($tag ["lux" "TextS"]) (_meta (#TextS value)))))
 
-             (#Meta [_ (#Tag [module name])])
+             (#Meta [_ (#TagS [module name])])
              (let [module' (_lux_case module
                                       ""
                                       subst
 
                                       _
                                       module)]
-               (wrap-meta ($form (list ($tag ["lux" "Tag"]) ($tuple (list ($text module') ($text name)))))))
+               (wrap-meta ($form (list ($tag ["lux" "TagS"]) ($tuple (list ($text module') ($text name)))))))
 
-             (#Meta [_ (#Symbol [module name])])
+             (#Meta [_ (#SymbolS [module name])])
              (let [module' (_lux_case module
                                       ""
                                       subst
 
                                       _
                                       module)]
-               (wrap-meta ($form (list ($tag ["lux" "Symbol"]) ($tuple (list ($text module') ($text name)))))))
+               (wrap-meta ($form (list ($tag ["lux" "SymbolS"]) ($tuple (list ($text module') ($text name)))))))
 
-             (#Meta [_ (#Tuple elems)])
-             (splice (untemplate subst) ($tag ["lux" "Tuple"]) elems)
+             (#Meta [_ (#TupleS elems)])
+             (splice (untemplate subst) ($tag ["lux" "TupleS"]) elems)
 
-             (#Meta [_ (#Form (#Cons [(#Meta [_ (#Symbol ["" "~"])]) (#Cons [unquoted #Nil])]))])
+             (#Meta [_ (#FormS (#Cons [(#Meta [_ (#SymbolS ["" "~"])]) (#Cons [unquoted #Nil])]))])
              unquoted
 
-             (#Meta [_ (#Form elems)])
-             (splice (untemplate subst) ($tag ["lux" "Form"]) elems)
+             (#Meta [_ (#FormS elems)])
+             (splice (untemplate subst) ($tag ["lux" "FormS"]) elems)
 
-             (#Meta [_ (#Record fields)])
-             (wrap-meta ($form (list ($tag ["lux" "Record"])
+             (#Meta [_ (#RecordS fields)])
+             (wrap-meta ($form (list ($tag ["lux" "RecordS"])
                                      (untemplate-list (map (_lux_: (->' (#TupleT (list Syntax Syntax)) Syntax)
                                                                    (lambda [kv]
                                                                      (let [[k v] kv]
@@ -855,7 +855,7 @@
              (#Cons [init apps])
              (return (list (fold (lambda [acc app]
                                    (_lux_case app
-                                              (#Meta [_ (#Form parts)])
+                                              (#Meta [_ (#FormS parts)])
                                               ($form (list:++ parts (list acc)))
 
                                               _
@@ -927,8 +927,8 @@
 
 (defmacro #export (^ tokens)
   (_lux_case tokens
-             (#Cons [(#Meta [_ (#Symbol ["" class-name])]) #Nil])
-             (return (list (`' (#;DataT (~ (_meta (#Text class-name)))))))
+             (#Cons [(#Meta [_ (#SymbolS ["" class-name])]) #Nil])
+             (return (list (`' (#;DataT (~ (_meta (#TextS class-name)))))))
 
              _
              (fail "Wrong syntax for ^")))
@@ -948,12 +948,12 @@
 
 (defmacro (do tokens)
   (_lux_case tokens
-             (#Cons [monad (#Cons [(#Meta [_ (#Tuple bindings)]) (#Cons [body #Nil])])])
+             (#Cons [monad (#Cons [(#Meta [_ (#TupleS bindings)]) (#Cons [body #Nil])])])
              (let [body' (fold (_lux_: (-> Syntax (, Syntax Syntax) Syntax)
                                        (lambda [body' binding]
                                          (let [[var value] binding]
                                            (_lux_case var
-                                                      (#Meta [_ (#Tag ["" "let"])])
+                                                      (#Meta [_ (#TagS ["" "let"])])
                                                       (`' (;let (~ value) (~ body')))
 
                                                       _
@@ -999,7 +999,7 @@
 (def__ (get-ident x)
   (-> Syntax ($' Maybe Text))
   (_lux_case x
-             (#Meta [_ (#Symbol ["" sname])])
+             (#Meta [_ (#SymbolS ["" sname])])
              (#Some sname)
 
              _
@@ -1008,7 +1008,7 @@
 (def__ (tuple->list tuple)
   (-> Syntax ($' Maybe ($' List Syntax)))
   (_lux_case tuple
-             (#Meta [_ (#Tuple members)])
+             (#Meta [_ (#TupleS members)])
              (#Some members)
 
              _
@@ -1047,7 +1047,7 @@
 (def__ (apply-template env template)
   (-> RepEnv Syntax Syntax)
   (_lux_case template
-             (#Meta [_ (#Symbol ["" sname])])
+             (#Meta [_ (#SymbolS ["" sname])])
              (_lux_case (get-rep sname env)
                         (#Some subst)
                         subst
@@ -1055,13 +1055,13 @@
                         _
                         template)
 
-             (#Meta [_ (#Tuple elems)])
+             (#Meta [_ (#TupleS elems)])
              ($tuple (map (apply-template env) elems))
 
-             (#Meta [_ (#Form elems)])
+             (#Meta [_ (#FormS elems)])
              ($form (map (apply-template env) elems))
 
-             (#Meta [_ (#Record members)])
+             (#Meta [_ (#RecordS members)])
              ($record (map (_lux_: (-> (, Syntax Syntax) (, Syntax Syntax))
                                    (lambda [kv]
                                      (let [[slot value] kv]
@@ -1083,7 +1083,7 @@
 
 (defmacro #export (do-template tokens)
   (_lux_case tokens
-             (#Cons [(#Meta [_ (#Tuple bindings)]) (#Cons [(#Meta [_ (#Tuple templates)]) data])])
+             (#Cons [(#Meta [_ (#TupleS bindings)]) (#Cons [(#Meta [_ (#TupleS templates)]) data])])
              (_lux_case (_lux_: (, ($' Maybe ($' List Text)) ($' Maybe ($' List ($' List Syntax))))
                                 [(map% Maybe:Monad get-ident bindings)
                                  (map% Maybe:Monad tuple->list data)])
@@ -1155,7 +1155,7 @@
 (def__ (replace-syntax reps syntax)
   (-> RepEnv Syntax Syntax)
   (_lux_case syntax
-             (#Meta [_ (#Symbol ["" name])])
+             (#Meta [_ (#SymbolS ["" name])])
              (_lux_case (get-rep name reps)
                         (#Some replacement)
                         replacement
@@ -1163,18 +1163,18 @@
                         #None
                         syntax)
 
-             (#Meta [_ (#Form parts)])
-             (#Meta [_ (#Form (map (replace-syntax reps) parts))])
+             (#Meta [_ (#FormS parts)])
+             (#Meta [_ (#FormS (map (replace-syntax reps) parts))])
 
-             (#Meta [_ (#Tuple members)])
-             (#Meta [_ (#Tuple (map (replace-syntax reps) members))])
+             (#Meta [_ (#TupleS members)])
+             (#Meta [_ (#TupleS (map (replace-syntax reps) members))])
 
-             (#Meta [_ (#Record slots)])
-             (#Meta [_ (#Record (map (_lux_: (-> (, Syntax Syntax) (, Syntax Syntax))
-                                             (lambda [slot]
-                                               (let [[k v] slot]
-                                                 [(replace-syntax reps k) (replace-syntax reps v)])))
-                                     slots))])
+             (#Meta [_ (#RecordS slots)])
+             (#Meta [_ (#RecordS (map (_lux_: (-> (, Syntax Syntax) (, Syntax Syntax))
+                                              (lambda [slot]
+                                                (let [[k v] slot]
+                                                  [(replace-syntax reps k) (replace-syntax reps v)])))
+                                      slots))])
              
              _
              syntax)
@@ -1183,13 +1183,13 @@
 (defmacro #export (All tokens)
   (let [[self-ident tokens'] (_lux_: (, Text SyntaxList)
                                      (_lux_case tokens
-                                                (#Cons [(#Meta [_ (#Symbol ["" self-ident])]) tokens'])
+                                                (#Cons [(#Meta [_ (#SymbolS ["" self-ident])]) tokens'])
                                                 [self-ident tokens']
 
                                                 _
                                                 ["" tokens]))]
     (_lux_case tokens'
-               (#Cons [(#Meta [_ (#Tuple args)]) (#Cons [body #Nil])])
+               (#Cons [(#Meta [_ (#TupleS args)]) (#Cons [body #Nil])])
                (_lux_case (map% Maybe:Monad get-ident args)
                           (#Some idents)
                           (_lux_case idents
@@ -1309,12 +1309,12 @@
                  (_lux_: (-> Syntax ($' Lux Syntax))
                          (lambda [token]
                            (_lux_case token
-                                      (#Meta [_ (#Tag ident)])
+                                      (#Meta [_ (#TagS ident)])
                                       (do Lux:Monad
                                         [ident (normalize ident)]
                                         (;return (`' [(~ ($text (ident->text ident))) (;,)])))
 
-                                      (#Meta [_ (#Form (#Cons [(#Meta [_ (#Tag ident)]) (#Cons [value #Nil])]))])
+                                      (#Meta [_ (#FormS (#Cons [(#Meta [_ (#TagS ident)]) (#Cons [value #Nil])]))])
                                       (do Lux:Monad
                                         [ident (normalize ident)]
                                         (;return (`' [(~ ($text (ident->text ident))) (~ value)])))
@@ -1332,7 +1332,7 @@
                    (_lux_: (-> (, Syntax Syntax) ($' Lux Syntax))
                            (lambda [pair]
                              (_lux_case pair
-                                        [(#Meta [_ (#Tag ident)]) value]
+                                        [(#Meta [_ (#TagS ident)]) value]
                                         (do Lux:Monad
                                           [ident (normalize ident)]
                                           (;return (`' [(~ ($text (ident->text ident))) (~ value)])))
@@ -1362,34 +1362,34 @@
 (def__ #export (syntax:show syntax)
   (-> Syntax Text)
   (_lux_case syntax
-             (#Meta [_ (#Bool value)])
+             (#Meta [_ (#BoolS value)])
              (->text value)
 
-             (#Meta [_ (#Int value)])
+             (#Meta [_ (#IntS value)])
              (->text value)
 
-             (#Meta [_ (#Real value)])
+             (#Meta [_ (#RealS value)])
              (->text value)
 
-             (#Meta [_ (#Char value)])
+             (#Meta [_ (#CharS value)])
              ($ text:++ "#\"" (->text value) "\"")
 
-             (#Meta [_ (#Text value)])
+             (#Meta [_ (#TextS value)])
              value
 
-             (#Meta [_ (#Symbol ident)])
+             (#Meta [_ (#SymbolS ident)])
              (ident->text ident)
 
-             (#Meta [_ (#Tag ident)])
+             (#Meta [_ (#TagS ident)])
              (text:++ "#" (ident->text ident))
 
-             (#Meta [_ (#Tuple members)])
+             (#Meta [_ (#TupleS members)])
              ($ text:++ "[" (|> members (map syntax:show) (interpose " ") (fold text:++ "")) "]")
 
-             (#Meta [_ (#Form members)])
+             (#Meta [_ (#FormS members)])
              ($ text:++ "(" (|> members (map syntax:show) (interpose " ") (fold text:++ "")) ")")
 
-             (#Meta [_ (#Record slots)])
+             (#Meta [_ (#RecordS slots)])
              ($ text:++ "{"
                 (|> slots
                     (map (_lux_: (-> (, Syntax Syntax) Text)
@@ -1404,7 +1404,7 @@
 (def__ #export (macro-expand syntax)
   (-> Syntax ($' Lux ($' List Syntax)))
   (_lux_case syntax
-             (#Meta [_ (#Form (#Cons [(#Meta [_ (#Symbol macro-name)]) args]))])
+             (#Meta [_ (#FormS (#Cons [(#Meta [_ (#SymbolS macro-name)]) args]))])
              (do Lux:Monad
                [macro-name' (normalize macro-name)
                 ?macro (find-macro macro-name')]
@@ -1420,13 +1420,13 @@
                             [parts' (map% Lux:Monad macro-expand (list& ($symbol macro-name) args))]
                             (;return (list ($form (list:join parts')))))))
 
-             (#Meta [_ (#Form (#Cons [harg targs]))])
+             (#Meta [_ (#FormS (#Cons [harg targs]))])
              (do Lux:Monad
                [harg+ (macro-expand harg)
                 targs+ (map% Lux:Monad macro-expand targs)]
                (;return (list ($form (list:++ harg+ (list:join targs+))))))
 
-             (#Meta [_ (#Tuple members)])
+             (#Meta [_ (#TupleS members)])
              (do Lux:Monad
                [members' (map% Lux:Monad macro-expand members)]
                (;return (list ($tuple (list:join members')))))
@@ -1437,13 +1437,13 @@
 (def__ (walk-type type)
   (-> Syntax Syntax)
   (_lux_case type
-             (#Meta [_ (#Form (#Cons [(#Meta [_ (#Tag tag)]) parts]))])
+             (#Meta [_ (#FormS (#Cons [(#Meta [_ (#TagS tag)]) parts]))])
              ($form (#Cons [($tag tag) (map walk-type parts)]))
 
-             (#Meta [_ (#Tuple members)])
+             (#Meta [_ (#TupleS members)])
              ($tuple (map walk-type members))
 
-             (#Meta [_ (#Form (#Cons [type-fn args]))])
+             (#Meta [_ (#FormS (#Cons [type-fn args]))])
              (fold (lambda [type-fn arg] (`' (#;AppT [(~ type-fn) (~ arg)])))
                    (walk-type type-fn)
                    (map walk-type args))
@@ -1485,17 +1485,17 @@
 (defmacro #export (deftype tokens)
   (let [[export? tokens'] (: (, Bool (List Syntax))
                              (_lux_case tokens
-                                        (#Cons [(#Meta [_ (#Tag ["" "export"])]) tokens'])
+                                        (#Cons [(#Meta [_ (#TagS ["" "export"])]) tokens'])
                                         [true tokens']
 
                                         _
                                         [false tokens]))
         parts (: (Maybe (, Syntax (List Syntax) Syntax))
                  (_lux_case tokens'
-                            (#Cons [(#Meta [_ (#Symbol name)]) (#Cons [type #Nil])])
+                            (#Cons [(#Meta [_ (#SymbolS name)]) (#Cons [type #Nil])])
                             (#Some [($symbol name) #Nil type])
 
-                            (#Cons [(#Meta [_ (#Form (#Cons [(#Meta [_ (#Symbol name)]) args]))]) (#Cons [type #Nil])])
+                            (#Cons [(#Meta [_ (#FormS (#Cons [(#Meta [_ (#SymbolS name)]) args]))]) (#Cons [type #Nil])])
                             (#Some [($symbol name) args type])
 
                             _
@@ -1546,20 +1546,20 @@
 (defmacro #export (def tokens)
   (let [[export? tokens'] (: (, Bool (List Syntax))
                              (_lux_case tokens
-                                        (#Cons [(#Meta [_ (#Tag ["" "export"])]) tokens'])
+                                        (#Cons [(#Meta [_ (#TagS ["" "export"])]) tokens'])
                                         [true tokens']
 
                                         _
                                         [false tokens]))
         parts (: (Maybe (, Syntax (List Syntax) (Maybe Syntax) Syntax))
                  (_lux_case tokens'
-                            (#Cons [(#Meta [_ (#Form (#Cons [name args]))]) (#Cons [type (#Cons [body #Nil])])])
+                            (#Cons [(#Meta [_ (#FormS (#Cons [name args]))]) (#Cons [type (#Cons [body #Nil])])])
                             (#Some [name args (#Some type) body])
                             
                             (#Cons [name (#Cons [type (#Cons [body #Nil])])])
                             (#Some [name #Nil (#Some type) body])
                             
-                            (#Cons [(#Meta [_ (#Form (#Cons [name args]))]) (#Cons [body #Nil])])
+                            (#Cons [(#Meta [_ (#FormS (#Cons [name args]))]) (#Cons [body #Nil])])
                             (#Some [name args #None body])
                             
                             (#Cons [name (#Cons [body #Nil])])
@@ -1605,7 +1605,7 @@
                                     (lambda expander [branch]
                                        (let [[pattern body] branch]
                                          (_lux_case pattern
-                                                    (#Meta [_ (#Form (#Cons [(#Meta [_ (#Symbol macro-name)]) macro-args]))])
+                                                    (#Meta [_ (#FormS (#Cons [(#Meta [_ (#SymbolS macro-name)]) macro-args]))])
                                                     (do Lux:Monad
                                                       [expansion (macro-expand ($form (list& ($symbol macro-name) body macro-args)))
                                                        expansions (map% Lux:Monad expander (as-pairs expansion))]
@@ -1701,7 +1701,7 @@
                    (: (-> Syntax (Lux (, Ident Syntax)))
                       (lambda [token]
                         (case token
-                          (\ (#Meta [_ (#Form (list (#Meta [_ (#Symbol ["" "_lux_:"])]) type (#Meta [_ (#Symbol name)])))]))
+                          (\ (#Meta [_ (#FormS (list (#Meta [_ (#SymbolS ["" "_lux_:"])]) type (#Meta [_ (#SymbolS name)])))]))
                           (do Lux:Monad
                             [name' (normalize name)]
                             (;return (: (, Ident Syntax) [name' type])))
@@ -1719,14 +1719,14 @@
 (defmacro #export (defsig tokens)
   (let [[export? tokens'] (: (, Bool (List Syntax))
                              (case tokens
-                               (\ (list& (#Meta [_ (#Tag ["" "export"])]) tokens'))
+                               (\ (list& (#Meta [_ (#TagS ["" "export"])]) tokens'))
                                [true tokens']
 
                                _
                                [false tokens]))
         ?parts (: (Maybe (, Syntax (List Syntax) (List Syntax)))
                   (case tokens'
-                    (\ (list& (#Meta [_ (#Form (list& name args))]) sigs))
+                    (\ (list& (#Meta [_ (#FormS (list& name args))]) sigs))
                     (#Some [name args sigs])
 
                     (\ (list& name sigs))
@@ -1758,7 +1758,7 @@
                    (: (-> Syntax (Lux (, Syntax Syntax)))
                       (lambda [token]
                         (case token
-                          (\ (#Meta [_ (#Form (list (#Meta [_ (#Symbol ["" "_lux_def"])]) (#Meta [_ (#Symbol name)]) value))]))
+                          (\ (#Meta [_ (#FormS (list (#Meta [_ (#SymbolS ["" "_lux_def"])]) (#Meta [_ (#SymbolS name)]) value))]))
                           (do Lux:Monad
                             [name' (normalize name)]
                             (;return (: (, Syntax Syntax) [($tag name') value])))
@@ -1771,14 +1771,14 @@
 (defmacro #export (defstruct tokens)
   (let [[export? tokens'] (: (, Bool (List Syntax))
                              (case tokens
-                               (\ (list& (#Meta [_ (#Tag ["" "export"])]) tokens'))
+                               (\ (list& (#Meta [_ (#TagS ["" "export"])]) tokens'))
                                [true tokens']
 
                                _
                                [false tokens]))
         ?parts (: (Maybe (, Syntax (List Syntax) Syntax (List Syntax)))
                   (case tokens'
-                    (\ (list& (#Meta [_ (#Form (list& name args))]) type defs))
+                    (\ (list& (#Meta [_ (#FormS (list& name args))]) type defs))
                     (#Some [name args type defs])
 
                     (\ (list& name type defs))
@@ -1965,7 +1965,7 @@
   (case tokens
     (\ (list struct body))
     (case struct
-      (#Meta [_ (#Symbol vname)])
+      (#Meta [_ (#SymbolS vname)])
       (let [vname' (ident->text vname)]
         (case state
           {#source source #modules modules #module-aliases module-aliases
@@ -2015,7 +2015,7 @@
 ##   (_lux_case tokens
 ##          (#Cons [bindings (#Cons [body #Nil])])
 ##          (let [pairs (as-pairs bindings)]
-##            (return (list (#Form (#Cons [(` (lambda (~ (#Symbol ["" "recur"])) (~ (#Tuple (map first pairs)))
+##            (return (list (#FormS (#Cons [(` (lambda (~ (#SymbolS ["" "recur"])) (~ (#TupleS (map first pairs)))
 ##                                               (~ body)))
 ##                                         (map second pairs)])))))))