- Added some compiler optimizations.

- Removed the (unnecessary) lux/control/dict & lux/control/stack modules.
- The "Meta" type is now a record instead of a variant.

13 files changed, 215 insertions, 307 deletions

diff --git a/source/lux.lux b/source/lux.lux
index cf56f326a..422fb4fad 100644
--- a/source/lux.lux
+++ b/source/lux.lux
@@ -155,7 +155,9 @@
 (_lux_declare-tags [#name #inner-closures #locals #closure] Env)
 
 ## (deftype Cursor
-##   (, Text Int Int))
+##   (& #module Text
+##      #line   Int
+##      #column Int))
 (_lux_def Cursor
   (#NamedT ["lux" "Cursor"]
            (#TupleT (#Cons Text (#Cons Int (#Cons Int #Nil))))))
@@ -163,18 +165,17 @@
 (_lux_declare-tags [#module #line #column] Cursor)
 
 ## (deftype (Meta m v)
-##   (| (#Meta m v)))
+##   (& #meta  m
+##      #datum v))
 (_lux_def Meta
   (#NamedT ["lux" "Meta"]
            (#UnivQ #Nil
                    (#UnivQ #Nil
-                           (#VariantT (#Cons ## "lux;Meta"
-                                       (#TupleT (#Cons (#BoundT 3)
-                                                       (#Cons (#BoundT 1)
-                                                              #Nil)))
-                                       #Nil))))))
+                           (#TupleT (#Cons (#BoundT 3)
+                                           (#Cons (#BoundT 1)
+                                                  #Nil)))))))
 (_lux_export Meta)
-(_lux_declare-tags [#Meta] Meta)
+(_lux_declare-tags [#meta #datum] Meta)
 
 ## (deftype (AST' w)
 ##   (| (#BoolS Bool)
@@ -414,13 +415,13 @@
 
 ## (def (_meta data)
 ##   (-> (AST' (Meta Cursor)) AST)
-##   (#Meta [["" -1 -1] data]))
+##   [["" -1 -1] data])
 (_lux_def _meta
   (_lux_: (#LambdaT (#AppT AST'
                            (#AppT Meta Cursor))
                     AST)
           (_lux_lambda _ data
-            (#Meta _cursor data))))
+            [_cursor data])))
 
 ## (def (return x)
 ##   (All [a]
@@ -523,7 +524,7 @@
   (_lux_: Macro
           (_lux_lambda _ tokens
             (_lux_case tokens
-              (#Cons (#Meta _ (#TupleS (#Cons arg args'))) (#Cons body #Nil))
+              (#Cons [_ (#TupleS (#Cons arg args'))] (#Cons body #Nil))
               (return (#Cons (_meta (#FormS (#Cons (_meta (#SymbolS "" "_lux_lambda"))
                                                    (#Cons (_meta (#SymbolS "" ""))
                                                           (#Cons arg
@@ -538,7 +539,7 @@
                                                                         #Nil))))))
                              #Nil))
 
-              (#Cons (#Meta _ (#SymbolS self)) (#Cons (#Meta _ (#TupleS (#Cons arg args'))) (#Cons body #Nil)))
+              (#Cons [_ (#SymbolS self)] (#Cons [_ (#TupleS (#Cons arg args'))] (#Cons body #Nil)))
               (return (#Cons (_meta (#FormS (#Cons (_meta (#SymbolS "" "_lux_lambda"))
                                                    (#Cons (_meta (#SymbolS self))
                                                           (#Cons arg
@@ -561,8 +562,8 @@
   (_lux_: Macro
           (lambda'' [tokens]
                     (_lux_case tokens
-                      (#Cons [(#Meta [_ (#TagS ["" "export"])])
-                              (#Cons [(#Meta [_ (#FormS (#Cons [name args]))])
+                      (#Cons [[_ (#TagS ["" "export"])]
+                              (#Cons [[_ (#FormS (#Cons [name args]))]
                                       (#Cons [type (#Cons [body #Nil])])])])
                       (return (#Cons [(_meta (#FormS (#Cons [(_meta (#SymbolS ["" "_lux_def"]))
                                                              (#Cons [name
@@ -577,7 +578,7 @@
                                       (#Cons [(_meta (#FormS (#Cons [(symbol$ ["" "_lux_export"]) (#Cons [name #Nil])])))
                                               #Nil])]))
 
-                      (#Cons [(#Meta [_ (#TagS ["" "export"])]) (#Cons [name (#Cons [type (#Cons [body #Nil])])])])
+                      (#Cons [[_ (#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_:"]))
@@ -588,7 +589,7 @@
                                       (#Cons [(_meta (#FormS (#Cons [(symbol$ ["" "_lux_export"]) (#Cons [name #Nil])])))
                                               #Nil])]))
 
-                      (#Cons [(#Meta [_ (#FormS (#Cons [name args]))])
+                      (#Cons [[_ (#FormS (#Cons [name args]))]
                               (#Cons [type (#Cons [body #Nil])])])
                       (return (#Cons [(_meta (#FormS (#Cons [(_meta (#SymbolS ["" "_lux_def"]))
                                                              (#Cons [name
@@ -620,7 +621,7 @@
 (def'' (defmacro tokens)
   Macro
   (_lux_case tokens
-    (#Cons [(#Meta [_ (#FormS (#Cons [name args]))]) (#Cons [body #Nil])])
+    (#Cons [[_ (#FormS (#Cons [name args]))] (#Cons [body #Nil])])
     (return (#Cons [(form$ (#Cons [(symbol$ ["lux" "def''"])
                                    (#Cons [(form$ (#Cons [name args]))
                                            (#Cons [(symbol$ ["lux" "Macro"])
@@ -630,7 +631,7 @@
                     (#Cons [(form$ (#Cons [(symbol$ ["" "_lux_declare-macro"]) (#Cons [name #Nil])]))
                             #Nil])]))
 
-    (#Cons [(#Meta [_ (#TagS ["" "export"])]) (#Cons [(#Meta [_ (#FormS (#Cons [name args]))]) (#Cons [body #Nil])])])
+    (#Cons [[_ (#TagS ["" "export"])] (#Cons [[_ (#FormS (#Cons [name args]))] (#Cons [body #Nil])])])
     (return (#Cons [(form$ (#Cons [(symbol$ ["lux" "def''"])
                                    (#Cons [(tag$ ["" "export"])
                                            (#Cons [(form$ (#Cons [name args]))
@@ -730,7 +731,7 @@
 (def'' (replace-syntax reps syntax)
   (->' RepEnv AST AST)
   (_lux_case syntax
-    (#Meta _ (#SymbolS "" name))
+    [_ (#SymbolS "" name)]
     (_lux_case (get-rep name reps)
       (#Some replacement)
       replacement
@@ -738,19 +739,19 @@
       #None
       syntax)
 
-    (#Meta _ (#FormS parts))
-    (#Meta _ (#FormS (map (replace-syntax reps) parts)))
+    [meta (#FormS parts)]
+    [meta (#FormS (map (replace-syntax reps) parts))]
 
-    (#Meta _ (#TupleS members))
-    (#Meta _ (#TupleS (map (replace-syntax reps) members)))
+    [meta (#TupleS members)]
+    [meta (#TupleS (map (replace-syntax reps) members))]
 
-    (#Meta _ (#RecordS slots))
-    (#Meta _ (#RecordS (map (_lux_: (->' (#TupleT (#Cons AST (#Cons AST #Nil))) (#TupleT (#Cons AST (#Cons AST #Nil))))
-                                    (lambda'' [slot]
-                                              (_lux_case slot
-                                                [k v]
-                                                [(replace-syntax reps k) (replace-syntax reps v)])))
-                            slots)))
+    [meta (#RecordS slots)]
+    [meta (#RecordS (map (_lux_: (->' (#TupleT (#Cons AST (#Cons AST #Nil))) (#TupleT (#Cons AST (#Cons AST #Nil))))
+                                 (lambda'' [slot]
+                                           (_lux_case slot
+                                             [k v]
+                                             [(replace-syntax reps k) (replace-syntax reps v)])))
+                         slots))]
     
     _
     syntax)
@@ -759,47 +760,47 @@
 (def'' (update-bounds ast)
   (->' AST AST)
   (_lux_case ast
-    (#Meta _ (#BoolS value))
+    [_ (#BoolS value)]
     (bool$ value)
 
-    (#Meta _ (#IntS value))
+    [_ (#IntS value)]
     (int$ value)
 
-    (#Meta _ (#RealS value))
+    [_ (#RealS value)]
     (real$ value)
 
-    (#Meta _ (#CharS value))
+    [_ (#CharS value)]
     (char$ value)
 
-    (#Meta _ (#TextS value))
+    [_ (#TextS value)]
     (text$ value)
 
-    (#Meta _ (#SymbolS value))
+    [_ (#SymbolS value)]
     (symbol$ value)
 
-    (#Meta _ (#TagS value))
+    [_ (#TagS value)]
     (tag$ value)
 
-    (#Meta _ (#TupleS members))
+    [_ (#TupleS members)]
     (tuple$ (map update-bounds members))
 
-    (#Meta _ (#RecordS pairs))
+    [_ (#RecordS pairs)]
     (record$ (map (_lux_: (->' (#TupleT (#Cons AST (#Cons AST #Nil))) (#TupleT (#Cons AST (#Cons AST #Nil))))
                           (lambda'' [pair]
                                     (let'' [name val] pair
                                            [name (update-bounds val)])))
                   pairs))
 
-    (#Meta _ (#FormS (#Cons (#Meta _ (#TagS "lux" "BoundT")) (#Cons (#Meta _ (#IntS idx)) #Nil))))
+    [_ (#FormS (#Cons [_ (#TagS "lux" "BoundT")] (#Cons [_ (#IntS idx)] #Nil)))]
     (form$ (#Cons (tag$ ["lux" "BoundT"]) (#Cons (int$ (_jvm_ladd 2 idx)) #Nil)))
 
-    (#Meta _ (#FormS members))
+    [_ (#FormS members)]
     (form$ (map update-bounds members)))
   )
 
 (defmacro (All' tokens)
   (_lux_case tokens
-    (#Cons (#Meta _ (#TupleS (#Cons (#Meta _ (#SymbolS "" arg-name)) other-args)))
+    (#Cons [_ (#TupleS (#Cons [_ (#SymbolS "" arg-name)] other-args))]
            (#Cons body #Nil))
     (let'' bound-var (_meta (#FormS (#Cons (tag$ ["lux" "BoundT"]) (#Cons (int$ 1) #Nil))))
            (let'' body' (replace-syntax (#Cons [arg-name bound-var] #Nil)
@@ -860,13 +861,13 @@
 (defmacro (lambda' tokens)
   (let'' [name tokens'] (_lux_: (#TupleT (list Ident ($' List AST)))
                                 (_lux_case tokens
-                                  (#Cons [(#Meta [_ (#SymbolS name)]) tokens'])
+                                  (#Cons [[_ (#SymbolS name)] tokens'])
                                   [name tokens']
 
                                   _
                                   [["" ""] tokens]))
          (_lux_case tokens'
-           (#Cons [(#Meta [_ (#TupleS args)]) (#Cons [body #Nil])])
+           (#Cons [[_ (#TupleS args)] (#Cons [body #Nil])])
            (_lux_case args
              #Nil
              (fail "lambda' requires a non-empty arguments tuple.")
@@ -888,8 +889,8 @@
 
 (defmacro (def''' tokens)
   (_lux_case tokens
-    (#Cons [(#Meta [_ (#TagS ["" "export"])])
-            (#Cons [(#Meta [_ (#FormS (#Cons [name args]))])
+    (#Cons [[_ (#TagS ["" "export"])]
+            (#Cons [[_ (#FormS (#Cons [name args]))]
                     (#Cons [type (#Cons [body #Nil])])])])
     (return (list (form$ (list (symbol$ ["" "_lux_def"])
                                name
@@ -901,7 +902,7 @@
                                                          body))))))
                   (form$ (list (symbol$ ["" "_lux_export"]) name))))
 
-    (#Cons [(#Meta [_ (#TagS ["" "export"])]) (#Cons [name (#Cons [type (#Cons [body #Nil])])])])
+    (#Cons [[_ (#TagS ["" "export"])] (#Cons [name (#Cons [type (#Cons [body #Nil])])])])
     (return (list (form$ (list (symbol$ ["" "_lux_def"])
                                name
                                (form$ (list (symbol$ ["" "_lux_:"])
@@ -909,7 +910,7 @@
                                             body))))
                   (form$ (list (symbol$ ["" "_lux_export"]) name))))
 
-    (#Cons [(#Meta [_ (#FormS (#Cons [name args]))])
+    (#Cons [[_ (#FormS (#Cons [name args]))]
             (#Cons [type (#Cons [body #Nil])])])
     (return (list (form$ (list (symbol$ ["" "_lux_def"])
                                name
@@ -940,7 +941,7 @@
 
 (defmacro (let' tokens)
   (_lux_case tokens
-    (#Cons [(#Meta [_ (#TupleS bindings)]) (#Cons [body #Nil])])
+    (#Cons [[_ (#TupleS bindings)] (#Cons [body #Nil])])
     (return (list (foldL (_lux_: (->' AST (#TupleT (list AST AST))
                                       AST)
                                  (lambda' [body binding]
@@ -968,7 +969,7 @@
 (def''' (spliced? token)
   (->' AST Bool)
   (_lux_case token
-    (#Meta [_ (#FormS (#Cons [(#Meta [_ (#SymbolS ["" "~@"])]) (#Cons [_ #Nil])]))])
+    [_ (#FormS (#Cons [[_ (#SymbolS ["" "~@"])] (#Cons [_ #Nil])]))]
     true
 
     _
@@ -976,9 +977,8 @@
 
 (def''' (wrap-meta content)
   (->' AST AST)
-  (_meta (#FormS (list (_meta (#TagS ["lux" "Meta"]))
-                       (_meta (#TupleS (list (_meta (#TupleS (list (_meta (#TextS "")) (_meta (#IntS -1)) (_meta (#IntS -1)))))
-                                             content)))))))
+  (tuple$ (list (tuple$ (list (text$ "") (int$ -1) (int$ -1)))
+                content)))
 
 (def''' (untemplate-list tokens)
   (->' ($' List AST) AST)
@@ -1017,7 +1017,7 @@
       true
       (let' [elems' (map (lambda' [elem]
                                   (_lux_case elem
-                                    (#Meta [_ (#FormS (#Cons [(#Meta [_ (#SymbolS ["" "~@"])]) (#Cons [spliced #Nil])]))])
+                                    [_ (#FormS (#Cons [[_ (#SymbolS ["" "~@"])] (#Cons [spliced #Nil])]))]
                                     spliced
 
                                     _
@@ -1039,22 +1039,22 @@
 (def''' (untemplate replace? subst token)
   (->' Bool Text AST AST)
   (_lux_case (_lux_: (#TupleT (list Bool AST)) [replace? token])
-    [_ (#Meta [_ (#BoolS value)])]
+    [_ [_ (#BoolS value)]]
     (wrap-meta (form$ (list (tag$ ["lux" "BoolS"]) (_meta (#BoolS value)))))
 
-    [_ (#Meta [_ (#IntS value)])]
+    [_ [_ (#IntS value)]]
     (wrap-meta (form$ (list (tag$ ["lux" "IntS"]) (_meta (#IntS value)))))
 
-    [_ (#Meta [_ (#RealS value)])]
+    [_ [_ (#RealS value)]]
     (wrap-meta (form$ (list (tag$ ["lux" "RealS"]) (_meta (#RealS value)))))
 
-    [_ (#Meta [_ (#CharS value)])]
+    [_ [_ (#CharS value)]]
     (wrap-meta (form$ (list (tag$ ["lux" "CharS"]) (_meta (#CharS value)))))
 
-    [_ (#Meta [_ (#TextS value)])]
+    [_ [_ (#TextS value)]]
     (wrap-meta (form$ (list (tag$ ["lux" "TextS"]) (_meta (#TextS value)))))
 
-    [_ (#Meta [_ (#TagS [module name])])]
+    [_ [_ (#TagS [module name])]]
     (let' [module' (_lux_case module
                      ""
                      subst
@@ -1063,7 +1063,7 @@
                      module)]
           (wrap-meta (form$ (list (tag$ ["lux" "TagS"]) (tuple$ (list (text$ module') (text$ name)))))))
 
-    [_ (#Meta [_ (#SymbolS [module name])])]
+    [_ [_ (#SymbolS [module name])]]
     (let' [module' (_lux_case module
                      ""
                      subst
@@ -1072,17 +1072,17 @@
                      module)]
           (wrap-meta (form$ (list (tag$ ["lux" "SymbolS"]) (tuple$ (list (text$ module') (text$ name)))))))
 
-    [_ (#Meta [_ (#TupleS elems)])]
+    [_ [_ (#TupleS elems)]]
     (splice replace? (untemplate replace? subst) (tag$ ["lux" "TupleS"]) elems)
 
-    [true (#Meta [_ (#FormS (#Cons [(#Meta [_ (#SymbolS ["" "~"])]) (#Cons [unquoted #Nil])]))])]
+    [true [_ (#FormS (#Cons [[_ (#SymbolS ["" "~"])] (#Cons [unquoted #Nil])]))]]
     unquoted
 
-    [_ (#Meta [meta (#FormS elems)])]
-    (let' [(#Meta [_ form']) (splice replace? (untemplate replace? subst) (tag$ ["lux" "FormS"]) elems)]
-          (#Meta [meta form']))
+    [_ [meta (#FormS elems)]]
+    (let' [[_ form'] (splice replace? (untemplate replace? subst) (tag$ ["lux" "FormS"]) elems)]
+          [meta form'])
 
-    [_ (#Meta [_ (#RecordS fields)])]
+    [_ [_ (#RecordS fields)]]
     (wrap-meta (form$ (list (tag$ ["lux" "RecordS"])
                             (untemplate-list (map (_lux_: (->' (#TupleT (list AST AST)) AST)
                                                           (lambda' [kv]
@@ -1110,16 +1110,17 @@
 (defmacro #export (|> tokens)
   (_lux_case tokens
     (#Cons [init apps])
-    (return (list (foldL (lambda' [acc app]
-                                  (_lux_case app
-                                    (#Meta [_ (#TupleS parts)])
-                                    (tuple$ (list:++ parts (list acc)))
+    (return (list (foldL (_lux_: (->' AST AST AST)
+                                 (lambda' [acc app]
+                                          (_lux_case app
+                                            [_ (#TupleS parts)]
+                                            (tuple$ (list:++ parts (list acc)))
 
-                                    (#Meta [_ (#FormS parts)])
-                                    (form$ (list:++ parts (list acc)))
+                                            [_ (#FormS parts)]
+                                            (form$ (list:++ parts (list acc)))
 
-                                    _
-                                    (`' ((~ app) (~ acc)))))
+                                            _
+                                            (`' ((~ app) (~ acc))))))
                          init
                          apps)))
 
@@ -1189,7 +1190,7 @@
 
 (defmacro #export (^ tokens)
   (_lux_case tokens
-    (#Cons (#Meta _ (#SymbolS "" class-name)) #Nil)
+    (#Cons [_ (#SymbolS "" class-name)] #Nil)
     (return (list (`' (#;DataT (~ (_meta (#TextS class-name)))))))
 
     _
@@ -1198,7 +1199,8 @@
 (defmacro #export (-> tokens)
   (_lux_case (reverse tokens)
     (#Cons output inputs)
-    (return (list (foldL (lambda' [o i] (`' (#;LambdaT (~ i) (~ o))))
+    (return (list (foldL (_lux_: (->' AST AST AST)
+                                 (lambda' [o i] (`' (#;LambdaT (~ i) (~ o)))))
                          output
                          inputs)))
     
@@ -1210,12 +1212,12 @@
 
 (defmacro (do tokens)
   (_lux_case tokens
-    (#Cons monad (#Cons (#Meta _ (#TupleS bindings)) (#Cons body #Nil)))
+    (#Cons monad (#Cons [_ (#TupleS bindings)] (#Cons body #Nil)))
     (let' [body' (foldL (_lux_: (-> AST (, AST AST) AST)
                                 (lambda' [body' binding]
                                          (let' [[var value] binding]
                                                (_lux_case var
-                                                 (#Meta _ (#TagS "" "let"))
+                                                 [_ (#TagS "" "let")]
                                                  (`' (;let' (~ value) (~ body')))
 
                                                  _
@@ -1261,7 +1263,7 @@
 (def''' (get-ident x)
   (-> AST ($' Maybe Ident))
   (_lux_case x
-    (#Meta _ (#SymbolS sname))
+    [_ (#SymbolS sname)]
     (#Some sname)
 
     _
@@ -1270,7 +1272,7 @@
 (def''' (get-name x)
   (-> AST ($' Maybe Text))
   (_lux_case x
-    (#Meta _ (#SymbolS "" sname))
+    [_ (#SymbolS "" sname)]
     (#Some sname)
 
     _
@@ -1279,7 +1281,7 @@
 (def''' (tuple->list tuple)
   (-> AST ($' Maybe ($' List AST)))
   (_lux_case tuple
-    (#Meta _ (#TupleS members))
+    [_ (#TupleS members)]
     (#Some members)
 
     _
@@ -1288,7 +1290,7 @@
 (def''' (apply-template env template)
   (-> RepEnv AST AST)
   (_lux_case template
-    (#Meta _ (#SymbolS "" sname))
+    [_ (#SymbolS "" sname)]
     (_lux_case (get-rep sname env)
       (#Some subst)
       subst
@@ -1296,13 +1298,13 @@
       _
       template)
 
-    (#Meta _ (#TupleS elems))
+    [_ (#TupleS elems)]
     (tuple$ (map (apply-template env) elems))
 
-    (#Meta _ (#FormS elems))
+    [_ (#FormS elems)]
     (form$ (map (apply-template env) elems))
 
-    (#Meta _ (#RecordS members))
+    [_ (#RecordS members)]
     (record$ (map (_lux_: (-> (, AST AST) (, AST AST))
                           (lambda' [kv]
                                    (let' [[slot value] kv]
@@ -1324,7 +1326,7 @@
 
 (defmacro #export (do-template tokens)
   (_lux_case tokens
-    (#Cons [(#Meta [_ (#TupleS bindings)]) (#Cons [(#Meta [_ (#TupleS templates)]) data])])
+    (#Cons [[_ (#TupleS bindings)] (#Cons [[_ (#TupleS templates)] data])])
     (_lux_case (_lux_: (, ($' Maybe ($' List Text)) ($' Maybe ($' List ($' List AST))))
                        [(map% Maybe/Monad get-name bindings)
                         (map% Maybe/Monad tuple->list data)])
@@ -1413,19 +1415,20 @@
 (defmacro #export (All tokens)
   (let' [[self-name tokens] (_lux_: (, Text ASTList)
                                     (_lux_case tokens
-                                      (#Cons (#Meta _ (#SymbolS "" self-name)) tokens)
+                                      (#Cons [_ (#SymbolS "" self-name)] tokens)
                                       [self-name tokens]
 
                                       _
                                       ["" tokens]))]
         (_lux_case tokens
-          (#Cons (#Meta _ (#TupleS (#Cons harg targs))) (#Cons body #Nil))
+          (#Cons [_ (#TupleS (#Cons harg targs))] (#Cons body #Nil))
           (_lux_case (map% Maybe/Monad get-name (#Cons harg targs))
             (#Some names)
-            (let' [body' (foldL (lambda' [body' name']
-                                         (`' (#;UnivQ #;Nil (~ (|> body'
-                                                                   (update-bounds)
-                                                                   (replace-syntax (list [name' (make-bound 1)])))))))
+            (let' [body' (foldL (_lux_: (-> AST Text AST)
+                                        (lambda' [body' name']
+                                                 (`' (#;UnivQ #;Nil (~ (|> body'
+                                                                           (update-bounds)
+                                                                           (replace-syntax (list [name' (make-bound 1)]))))))))
                                 (replace-syntax (list [self-name (make-bound -2)])
                                                 body)
                                 names)]
@@ -1547,7 +1550,7 @@
 (def''' (macro-expand token)
   (-> AST ($' Lux ($' List AST)))
   (_lux_case token
-    (#Meta [_ (#FormS (#Cons [(#Meta [_ (#SymbolS macro-name)]) args]))])
+    [_ (#FormS (#Cons [[_ (#SymbolS macro-name)] args]))]
     (do Lux/Monad
       [macro-name' (normalize macro-name)
        ?macro (find-macro macro-name')]
@@ -1567,7 +1570,7 @@
 (def''' (macro-expand-all syntax)
   (-> AST ($' Lux ($' List AST)))
   (_lux_case syntax
-    (#Meta [_ (#FormS (#Cons [(#Meta [_ (#SymbolS macro-name)]) args]))])
+    [_ (#FormS (#Cons [[_ (#SymbolS macro-name)] args]))]
     (do Lux/Monad
       [macro-name' (normalize macro-name)
        ?macro (find-macro macro-name')]
@@ -1583,13 +1586,13 @@
           [parts' (map% Lux/Monad macro-expand-all (list& (symbol$ macro-name) args))]
           (wrap (list (form$ (list:join parts')))))))
 
-    (#Meta [_ (#FormS (#Cons [harg targs]))])
+    [_ (#FormS (#Cons [harg targs]))]
     (do Lux/Monad
       [harg+ (macro-expand-all harg)
        targs+ (map% Lux/Monad macro-expand-all targs)]
       (wrap (list (form$ (list:++ harg+ (list:join targs+))))))
 
-    (#Meta [_ (#TupleS members)])
+    [_ (#TupleS members)]
     (do Lux/Monad
       [members' (map% Lux/Monad macro-expand-all members)]
       (wrap (list (tuple$ (list:join members')))))
@@ -1600,14 +1603,15 @@
 (def''' (walk-type type)
   (-> AST AST)
   (_lux_case type
-    (#Meta [_ (#FormS (#Cons [(#Meta [_ (#TagS tag)]) parts]))])
+    [_ (#FormS (#Cons [[_ (#TagS tag)] parts]))]
     (form$ (#Cons [(tag$ tag) (map walk-type parts)]))
 
-    (#Meta [_ (#TupleS members)])
+    [_ (#TupleS members)]
     (tuple$ (map walk-type members))
 
-    (#Meta [_ (#FormS (#Cons [type-fn args]))])
-    (foldL (lambda' [type-fn arg] (`' (#;AppT [(~ type-fn) (~ arg)])))
+    [_ (#FormS (#Cons [type-fn args]))]
+    (foldL (_lux_: (-> AST AST AST)
+                   (lambda' [type-fn arg] (`' (#;AppT [(~ type-fn) (~ arg)]))))
            (walk-type type-fn)
            (map walk-type args))
     
@@ -1662,16 +1666,16 @@
 (def''' (unfold-type-def type)
   (-> AST ($' Lux (, AST ($' Maybe ($' List AST)))))
   (_lux_case type
-    (#Meta _ (#FormS (#Cons (#Meta _ (#SymbolS "" "|")) cases)))
+    [_ (#FormS (#Cons [_ (#SymbolS "" "|")] cases))]
     (do Lux/Monad
       [members (map% Lux/Monad
                      (: (-> AST ($' Lux (, Text AST)))
                         (lambda' [case]
                                  (_lux_case case
-                                   (#Meta _ (#TagS "" member-name))
+                                   [_ (#TagS "" member-name)]
                                    (return [member-name (`' Unit)])
                                    
-                                   (#Meta _ (#FormS (#Cons (#Meta _ (#TagS "" member-name)) (#Cons member-type #Nil))))
+                                   [_ (#FormS (#Cons [_ (#TagS "" member-name)] (#Cons member-type #Nil)))]
                                    (return [member-name member-type])
 
                                    _
@@ -1683,13 +1687,13 @@
                           (map (: (-> Text AST)
                                   (lambda' [name] (tag$ ["" name]))))))]))
 
-    (#Meta _ (#FormS (#Cons (#Meta _ (#SymbolS "" "&")) pairs)))
+    [_ (#FormS (#Cons [_ (#SymbolS "" "&")] pairs))]
     (do Lux/Monad
       [members (map% Lux/Monad
                      (: (-> (, AST AST) ($' Lux (, Text AST)))
                         (lambda' [pair]
                                  (_lux_case pair
-                                   [(#Meta _ (#TagS "" member-name)) member-type]
+                                   [[_ (#TagS "" member-name)] member-type]
                                    (return [member-name member-type])
 
                                    _
@@ -1707,24 +1711,24 @@
 (defmacro #export (deftype tokens)
   (let' [[export? tokens'] (: (, Bool (List AST))
                               (_lux_case tokens
-                                (#Cons (#Meta _ (#TagS "" "export")) tokens')
+                                (#Cons [_ (#TagS "" "export")] tokens')
                                 [true tokens']
 
                                 _
                                 [false tokens]))
          [rec? tokens'] (: (, Bool (List AST))
                            (_lux_case tokens'
-                             (#Cons (#Meta _ (#TagS "" "rec")) tokens')
+                             (#Cons [_ (#TagS "" "rec")] tokens')
                              [true tokens']
 
                              _
                              [false tokens']))
          parts (: (Maybe (, Text (List AST) AST))
                   (_lux_case tokens'
-                    (#Cons (#Meta _ (#SymbolS "" name)) (#Cons type #Nil))
+                    (#Cons [_ (#SymbolS "" name)] (#Cons type #Nil))
                     (#Some name #Nil type)
 
-                    (#Cons (#Meta _ (#FormS (#Cons (#Meta _ (#SymbolS "" name)) args))) (#Cons type #Nil))
+                    (#Cons [_ (#FormS (#Cons [_ (#SymbolS "" name)] args))] (#Cons type #Nil))
                     (#Some name args type)
 
                     _
@@ -1780,7 +1784,8 @@
   (_lux_case (reverse tokens)
     (#Cons value actions)
     (let' [dummy (symbol$ ["" ""])]
-          (return (list (foldL (lambda' [post pre] (`' (_lux_case (~ pre) (~ dummy) (~ post))))
+          (return (list (foldL (_lux_: (-> AST AST AST)
+                                       (lambda' [post pre] (`' (_lux_case (~ pre) (~ dummy) (~ post)))))
                                value
                                actions))))
 
@@ -1790,20 +1795,20 @@
 (defmacro (def' tokens)
   (let' [[export? tokens'] (: (, Bool (List AST))
                               (_lux_case tokens
-                                (#Cons (#Meta _ (#TagS "" "export")) tokens')
+                                (#Cons [_ (#TagS "" "export")] tokens')
                                 [true tokens']
 
                                 _
                                 [false tokens]))
          parts (: (Maybe (, AST (List AST) (Maybe AST) AST))
                   (_lux_case tokens'
-                    (#Cons (#Meta _ (#FormS (#Cons name args))) (#Cons type (#Cons body #Nil)))
+                    (#Cons [_ (#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 _ (#FormS (#Cons name args))) (#Cons body #Nil))
+                    (#Cons [_ (#FormS (#Cons name args))] (#Cons body #Nil))
                     (#Some name args #None body)
                     
                     (#Cons name (#Cons body #Nil))
@@ -1849,7 +1854,7 @@
                            (lambda' expander [branch]
                                     (let' [[pattern body] branch]
                                           (_lux_case pattern
-                                            (#Meta _ (#FormS (#Cons (#Meta _ (#SymbolS macro-name)) macro-args)))
+                                            [_ (#FormS (#Cons [_ (#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))]
@@ -1908,7 +1913,7 @@
 (def' (symbol? ast)
   (-> AST Bool)
   (case ast
-    (#Meta _ (#SymbolS _))
+    [_ (#SymbolS _)]
     true
 
     _
@@ -1916,7 +1921,7 @@
 
 (defmacro #export (let tokens)
   (case tokens
-    (\ (list (#Meta _ (#TupleS bindings)) body))
+    (\ (list [_ (#TupleS bindings)] body))
     (if (multiple? 2 (length bindings))
       (|> bindings as-pairs reverse
           (foldL (: (-> AST (, AST AST) AST)
@@ -1936,7 +1941,7 @@
 (def' (ast:show ast)
   (-> AST Text)
   (case ast
-    (#Meta _ ast)
+    [_ ast]
     (case ast
       (\or (#BoolS val) (#IntS val) (#RealS val))
       (->text val)
@@ -1972,10 +1977,10 @@
 (defmacro #export (lambda tokens)
   (case (: (Maybe (, Ident AST (List AST) AST))
            (case tokens
-             (\ (list (#Meta _ (#TupleS (#Cons head tail))) body))
+             (\ (list [_ (#TupleS (#Cons head tail))] body))
              (#Some ["" ""] head tail body)
 
-             (\ (list (#Meta _ (#SymbolS [_ name])) (#Meta _ (#TupleS (#Cons head tail))) body))
+             (\ (list [_ (#SymbolS [_ name])] [_ (#TupleS (#Cons head tail))] body))
              (#Some ["" name] head tail body)
              
              _
@@ -2001,20 +2006,20 @@
 (defmacro #export (def tokens)
   (let [[export? tokens'] (: (, Bool (List AST))
                              (case tokens
-                               (#Cons (#Meta _ (#TagS "" "export")) tokens')
+                               (#Cons [_ (#TagS "" "export")] tokens')
                                [true tokens']
 
                                _
                                [false tokens]))
         parts (: (Maybe (, AST (List AST) (Maybe AST) AST))
                  (case tokens'
-                   (\ (list (#Meta _ (#FormS (#Cons name args))) type body))
+                   (\ (list [_ (#FormS (#Cons name args))] type body))
                    (#Some name args (#Some type) body)
                    
                    (\ (list name type body))
                    (#Some name #Nil (#Some type) body)
                    
-                   (\ (list (#Meta _ (#FormS (#Cons name args))) body))
+                   (\ (list [_ (#FormS (#Cons name args))] body))
                    (#Some name args #None body)
                    
                    (\ (list name body))
@@ -2062,17 +2067,17 @@
 (defmacro #export (defsig tokens)
   (let [[export? tokens'] (: (, Bool (List AST))
                              (case tokens
-                               (\ (list& (#Meta _ (#TagS "" "export")) tokens'))
+                               (\ (list& [_ (#TagS "" "export")] tokens'))
                                [true tokens']
 
                                _
                                [false tokens]))
         ?parts (: (Maybe (, Ident (List AST) (List AST)))
                   (case tokens'
-                    (\ (list& (#Meta _ (#FormS (list& (#Meta _ (#SymbolS name)) args))) sigs))
+                    (\ (list& [_ (#FormS (list& [_ (#SymbolS name)] args))] sigs))
                     (#Some name args sigs)
 
-                    (\ (list& (#Meta _ (#SymbolS name)) sigs))
+                    (\ (list& [_ (#SymbolS name)] sigs))
                     (#Some name #Nil sigs)
 
                     _
@@ -2086,7 +2091,7 @@
                        (: (-> AST (Lux (, Text AST)))
                           (lambda [token]
                             (case token
-                              (\ (#Meta _ (#FormS (list (#Meta _ (#SymbolS _ "_lux_:")) type (#Meta _ (#SymbolS ["" name]))))))
+                              (\ [_ (#FormS (list [_ (#SymbolS _ "_lux_:")] type [_ (#SymbolS ["" name])]))])
                               (wrap (: (, Text AST) [name type]))
 
                               _
@@ -2380,7 +2385,7 @@
                      (: (-> AST (Lux (, AST AST)))
                         (lambda [token]
                           (case token
-                            (\ (#Meta _ (#FormS (list (#Meta _ (#SymbolS _ "_lux_def")) (#Meta _ (#SymbolS tag-name)) value))))
+                            (\ [_ (#FormS (list [_ (#SymbolS _ "_lux_def")] [_ (#SymbolS tag-name)] value))])
                             (wrap (: (, AST AST) [(tag$ tag-name) value]))
 
                             _
@@ -2391,14 +2396,14 @@
 (defmacro #export (defstruct tokens)
   (let [[export? tokens'] (: (, Bool (List AST))
                              (case tokens
-                               (\ (list& (#Meta _ (#TagS "" "export")) tokens'))
+                               (\ (list& [_ (#TagS "" "export")] tokens'))
                                [true tokens']
 
                                _
                                [false tokens]))
         ?parts (: (Maybe (, AST (List AST) AST (List AST)))
                   (case tokens'
-                    (\ (list& (#Meta _ (#FormS (list& name args))) type defs))
+                    (\ (list& [_ (#FormS (list& name args))] type defs))
                     (#Some name args type defs)
 
                     (\ (list& name type defs))
@@ -2431,7 +2436,8 @@
   [(defmacro #export (<name> tokens)
      (case (reverse tokens)
        (\ (list& last init))
-       (return (list (foldL (lambda [post pre] (` <form>))
+       (return (list (foldL (: (-> AST AST AST)
+                               (lambda [post pre] (` <form>)))
                             last
                             init)))
        
@@ -2459,7 +2465,7 @@
         (: (-> AST (Lux Text))
            (lambda [def]
              (case def
-               (#Meta _ (#SymbolS "" name))
+               [_ (#SymbolS "" name)]
                (return name)
 
                _
@@ -2469,7 +2475,7 @@
 (def (parse-alias tokens)
   (-> (List AST) (Lux (, (Maybe Text) (List AST))))
   (case tokens
-    (\ (list& (#Meta _ (#TagS "" "as")) (#Meta _ (#SymbolS "" alias)) tokens'))
+    (\ (list& [_ (#TagS "" "as")] [_ (#SymbolS "" alias)] tokens'))
     (return (: (, (Maybe Text) (List AST)) [(#Some alias) tokens']))
     
     _
@@ -2478,17 +2484,17 @@
 (def (parse-referrals tokens)
   (-> (List AST) (Lux (, Referrals (List AST))))
   (case tokens
-    (\ (list& (#Meta _ (#TagS "" "refer")) referral tokens'))
+    (\ (list& [_ (#TagS "" "refer")] referral tokens'))
     (case referral
-      (#Meta _ (#TagS "" "all"))
+      [_ (#TagS "" "all")]
       (return (: (, Referrals (List AST)) [#All tokens']))
 
-      (\ (#Meta _ (#FormS (list& (#Meta _ (#TagS "" "only")) defs))))
+      (\ [_ (#FormS (list& [_ (#TagS "" "only")] defs))])
       (do Lux/Monad
         [defs' (extract-defs defs)]
         (return (: (, Referrals (List AST)) [(#Only defs') tokens'])))
 
-      (\ (#Meta _ (#FormS (list& (#Meta _ (#TagS "" "exclude")) defs))))
+      (\ [_ (#FormS (list& [_ (#TagS "" "exclude")] defs))])
       (do Lux/Monad
         [defs' (extract-defs defs)]
         (return (: (, Referrals (List AST)) [(#Exclude defs') tokens'])))
@@ -2502,7 +2508,7 @@
 (def (extract-symbol syntax)
   (-> AST (Lux Ident))
   (case syntax
-    (#Meta _ (#SymbolS ident))
+    [_ (#SymbolS ident)]
     (return ident)
 
     _
@@ -2511,7 +2517,7 @@
 (def (parse-openings tokens)
   (-> (List AST) (Lux (, (Maybe Openings) (List AST))))
   (case tokens
-    (\ (list& (#Meta _ (#TagS "" "open")) (#Meta _ (#FormS (list& (#Meta _ (#TextS prefix)) structs))) tokens'))
+    (\ (list& [_ (#TagS "" "open")] [_ (#FormS (list& [_ (#TextS prefix)] structs))] tokens'))
     (do Lux/Monad
       [structs' (map% Lux/Monad extract-symbol structs)]
       (return (: (, (Maybe Openings) (List AST)) [(#Some prefix structs') tokens'])))
@@ -2525,10 +2531,10 @@
         (: (-> AST (Lux AST))
            (lambda [token]
              (case token
-               (#Meta _ (#SymbolS "" sub-name))
+               [_ (#SymbolS "" sub-name)]
                (return (symbol$ ["" ($ text:++ super-name "/" sub-name)]))
 
-               (\ (#Meta _ (#FormS (list& (#Meta _ (#SymbolS "" sub-name)) parts))))
+               (\ [_ (#FormS (list& [_ (#SymbolS "" sub-name)] parts))])
                (return (form$ (list& (symbol$ ["" ($ text:++ super-name "/" sub-name)]) parts)))
 
                _
@@ -2542,10 +2548,10 @@
                     (: (-> AST (Lux (List Import)))
                        (lambda [token]
                          (case token
-                           (#Meta _ (#SymbolS "" m-name))
+                           [_ (#SymbolS "" m-name)]
                            (wrap (list [m-name #None #All #None]))
 
-                           (\ (#Meta _ (#FormS (list& (#Meta _ (#SymbolS "" m-name)) extra))))
+                           (\ [_ (#FormS (list& [_ (#SymbolS "" m-name)] extra))])
                            (do Lux/Monad
                              [alias+extra (parse-alias extra)
                               #let [[alias extra] alias+extra]
@@ -2724,10 +2730,11 @@
                                                                  (` (open (~ (symbol$ [m-name name])) (~ (text$ prefix)))))))
                                                           structs)))]]
                                 (wrap ($ list:++
-                                        (list (` (_lux_import (~ (text$ m-name)))))
-                                        (case m-alias
-                                          #None         (list)
-                                          (#Some alias) (list (` (_lux_alias (~ (text$ alias)) (~ (text$ m-name))))))
+                                        (: (List AST) (list (` (_lux_import (~ (text$ m-name))))))
+                                        (: (List AST)
+                                           (case m-alias
+                                             #None         (list)
+                                             (#Some alias) (list (` (_lux_alias (~ (text$ alias)) (~ (text$ m-name)))))))
                                         (map (: (-> Text AST)
                                                 (lambda [def]
                                                   (` (_lux_def (~ (symbol$ ["" def])) (~ (symbol$ [m-name def]))))))
@@ -2737,10 +2744,9 @@
         (wrap (list:join output')))
 
       _
-      (wrap (: (List AST)
-               (list:++ (map (lambda [m-name] (` (_lux_import (~ (text$ m-name)))))
-                             unknowns)
-                        (list (` (import (~@ tokens))))))))))
+      (wrap (list:++ (map (: (-> Text AST) (lambda [m-name] (` (_lux_import (~ (text$ m-name))))))
+                          unknowns)
+                     (: (List AST) (list (` (import (~@ tokens))))))))))
 
 (def (try-both f x1 x2)
   (All [a b]
@@ -2877,7 +2883,7 @@
   (case tokens
     (\ (list struct body))
     (case struct
-      (#Meta _ (#SymbolS name))
+      [_ (#SymbolS name)]
       (do Lux/Monad
         [struct-type (find-var-type name)
          output (resolve-type-tags struct-type)]
@@ -2939,7 +2945,7 @@
 
 (defmacro #export (get@ tokens)
   (case tokens
-    (\ (list (#Meta _ (#TagS slot')) record))
+    (\ (list [_ (#TagS slot')] record))
     (do Lux/Monad
       [slot (normalize slot')
        output (resolve-tag slot)
@@ -2981,11 +2987,11 @@
 
 (defmacro #export (open tokens)
   (case tokens
-    (\ (list& (#Meta _ (#SymbolS struct-name)) tokens'))
+    (\ (list& [_ (#SymbolS struct-name)] tokens'))
     (do Lux/Monad
       [@module get-module-name
        #let [prefix (case tokens'
-                      (\ (list (#Meta _ (#TextS prefix))))
+                      (\ (list [_ (#TextS prefix)]))
                       prefix
                       
                       _
@@ -3028,12 +3034,12 @@
                       (: (-> AST AST (Lux AST))
                          (lambda [so-far part]
                            (case part
-                             (#Meta _ (#SymbolS slot))
-                             (return (` (get@ (~ (tag$ slot)) (~ so-far))))
+                             [_ (#SymbolS slot)]
+                             (return (: AST (` (get@ (~ (tag$ slot)) (~ so-far)))))
 
-                             (\ (#Meta _ (#FormS (list& (#Meta _ (#SymbolS slot)) args))))
-                             (return (` ((get@ (~ (tag$ slot)) (~ so-far))
-                                         (~@ args))))
+                             (\ [_ (#FormS (list& [_ (#SymbolS slot)] args))])
+                             (return (: AST (` ((get@ (~ (tag$ slot)) (~ so-far))
+                                                (~@ args)))))
 
                              _
                              (fail "Wrong syntax for ::"))))
@@ -3045,7 +3051,7 @@
 
 (defmacro #export (set@ tokens)
   (case tokens
-    (\ (list (#Meta _ (#TagS slot')) value record))
+    (\ (list [_ (#TagS slot')] value record))
     (do Lux/Monad
       [slot (normalize slot')
        output (resolve-tag slot)
@@ -3080,7 +3086,7 @@
 
 (defmacro #export (update@ tokens)
   (case tokens
-    (\ (list (#Meta _ (#TagS slot')) fun record))
+    (\ (list [_ (#TagS slot')] fun record))
     (do Lux/Monad
       [slot (normalize slot')
        output (resolve-tag slot)
@@ -3115,9 +3121,9 @@
 
 (defmacro #export (\template tokens)
   (case tokens
-    (\ (list (#Meta _ (#TupleS data))
-             (#Meta _ (#TupleS bindings))
-             (#Meta _ (#TupleS templates))))
+    (\ (list [_ (#TupleS data)]
+             [_ (#TupleS bindings)]
+             [_ (#TupleS templates)]))
     (case (: (Maybe (List AST))
              (do Maybe/Monad
                [bindings' (map% Maybe/Monad get-name bindings)
@@ -3194,7 +3200,7 @@
 
 (defmacro #export (loop tokens)
   (case tokens
-    (\ (list (#Meta _ (#TupleS bindings)) body))
+    (\ (list [_ (#TupleS bindings)] body))
     (let [pairs (as-pairs bindings)
           vars (map first pairs)
           inits (map second pairs)]
@@ -3224,11 +3230,11 @@
     (fail "Wrong syntax for loop")))
 
 (defmacro #export (export tokens)
-  (return (map (lambda [token] (` (_lux_export (~ token)))) tokens)))
+  (return (map (: (-> AST AST) (lambda [token] (` (_lux_export (~ token))))) tokens)))
 
 (defmacro #export (\slots tokens)
   (case tokens
-    (\ (list body (#Meta _ (#TupleS (list& hslot' tslots')))))
+    (\ (list body [_ (#TupleS (list& hslot' tslots'))]))
     (do Lux/Monad
       [slots (: (Lux (, Ident (List Ident)))
                 (case (: (Maybe (, Ident (List Ident)))
diff --git a/source/lux/codata/stream.lux b/source/lux/codata/stream.lux
index b4c0e0239..5415213d7 100644
--- a/source/lux/codata/stream.lux
+++ b/source/lux/codata/stream.lux
@@ -128,5 +128,5 @@
      #let [patterns+ (: (List AST)
                         (do List/Monad
                           [pattern (l;reverse patterns)]
-                          (list (` [(~ pattern) (~ g!s)]) (` (L;! (~ g!s))))))]]
+                          (: (List AST) (list (` [(~ pattern) (~ g!s)]) (` (L;! (~ g!s)))))))]]
     (wrap (list g!s (` (;let [(~@ patterns+)] (~ body)))))))
diff --git a/source/lux/control/comonad.lux b/source/lux/control/comonad.lux
index 6225af338..052b8768d 100644
--- a/source/lux/control/comonad.lux
+++ b/source/lux/control/comonad.lux
@@ -29,12 +29,12 @@
 ## [Syntax]
 (defmacro #export (be tokens state)
   (case tokens
-    (\ (list monad (#;Meta [_ (#;TupleS bindings)]) body))
+    (\ (list monad [_ (#;TupleS bindings)] body))
     (let [body' (foldL (: (-> AST (, AST AST) AST)
                           (lambda [body' binding]
                             (let [[var value] binding]
                               (case var
-                                (#;Meta [_ (#;TagS ["" "let"])])
+                                [_ (#;TagS ["" "let"])]
                                 (` (;let (~ value) (~ body')))
 
                                 _
diff --git a/source/lux/control/dict.lux b/source/lux/control/dict.lux
deleted file mode 100644
index 0b2069cf3..000000000
--- a/source/lux/control/dict.lux
+++ /dev/null
@@ -1,18 +0,0 @@
-##  Copyright (c) Eduardo Julian. All rights reserved.
-##  This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
-##  If a copy of the MPL was not distributed with this file,
-##  You can obtain one at http://mozilla.org/MPL/2.0/.
-
-(;import lux)
-
-## Signatures
-(defsig #export (Dict d)
-  (: (All [k v]
-       (-> k (d k v) (Maybe v)))
-     get)
-  (: (All [k v]
-       (-> k v (d k v) (d k v)))
-     put)
-  (: (All [k v]
-       (-> k (d k v) (d k v)))
-     remove))
diff --git a/source/lux/control/monad.lux b/source/lux/control/monad.lux
index 707bf7497..df48da863 100644
--- a/source/lux/control/monad.lux
+++ b/source/lux/control/monad.lux
@@ -50,15 +50,15 @@
 ## [Syntax]
 (defmacro #export (do tokens state)
   (case tokens
-    ## (\ (list monad (#;Meta [_ (#;TupleS bindings)]) body))
-    (#;Cons [monad (#;Cons [(#;Meta [_ (#;TupleS bindings)]) (#;Cons [body #;Nil])])])
+    ## (\ (list monad [_ (#;TupleS bindings)] body))
+    (#;Cons [monad (#;Cons [[_ (#;TupleS bindings)] (#;Cons [body #;Nil])])])
     (let [g!map (symbol$ ["" " map "])
           g!join (symbol$ ["" " join "])
           body' (foldL (: (-> AST (, AST AST) AST)
                           (lambda [body' binding]
                             (let [[var value] binding]
                               (case var
-                                (#;Meta [_ (#;TagS ["" "let"])])
+                                [_ (#;TagS ["" "let"])]
                                 (` (;let (~ value) (~ body')))
 
                                 _
diff --git a/source/lux/control/stack.lux b/source/lux/control/stack.lux
deleted file mode 100644
index 206ab5cd7..000000000
--- a/source/lux/control/stack.lux
+++ /dev/null
@@ -1,20 +0,0 @@
-##  Copyright (c) Eduardo Julian. All rights reserved.
-##  This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
-##  If a copy of the MPL was not distributed with this file,
-##  You can obtain one at http://mozilla.org/MPL/2.0/.
-
-(;import lux)
-
-## [Signatures]
-(defsig #export (Stack s)
-  (: (All [a] (s a))
-     empty)
-  (: (All [a] (-> (s a) Bool))
-     empty?)
-  (: (All [a] (-> a (s a) (s a)))
-     push)
-  (: (All [a] (-> (s a) (Maybe (s a))))
-     pop)
-  (: (All [a] (-> (s a) (Maybe a)))
-     top)
-  )
diff --git a/source/lux/data/list.lux b/source/lux/data/list.lux
index 1277fc6ae..10bbb8086 100644
--- a/source/lux/data/list.lux
+++ b/source/lux/data/list.lux
@@ -8,9 +8,7 @@
                        (functor #as F #refer #all)
                        (monad #as M #refer #all)
                        (eq #as E)
-                       (ord #as O)
-                       (dict #as D #refer #all)
-                       (stack #as S))
+                       (ord #as O))
               (data (number (int #open ("i" Int/Number Int/Ord)))
                     bool)
               meta/macro))
@@ -20,15 +18,6 @@
 ##   (| #Nil
 ##      (#Cons (, a (List a)))))
 
-(deftype #export (PList k v)
-  (| (#PList (, (E;Eq k) (List (, k v))))))
-
-## [Constructors]
-(def #export (plist eq)
-  (All [k v]
-    (-> (E;Eq k) (PList k v)))
-  (#PList [eq #;Nil]))
-
 ## [Functions]
 (def #export (foldL f init xs)
   (All [a b]
@@ -225,17 +214,19 @@
 
 ## [Syntax]
 (defmacro #export (list xs state)
-  (#;Right [state (#;Cons [(foldL (lambda [tail head]
-                                    (` (#;Cons [(~ head) (~ tail)])))
-                                  (` #;Nil)
+  (#;Right [state (#;Cons [(foldL (: (-> AST AST AST)
+                                     (lambda [tail head]
+                                       (` (#;Cons [(~ head) (~ tail)]))))
+                                  (: AST (` #;Nil))
                                   (reverse xs))
                            #;Nil])]))
 
 (defmacro #export (list& xs state)
   (case (reverse xs)
     (#;Cons [last init])
-    (#;Right [state (list (foldL (lambda [tail head]
-                                   (` (#;Cons [(~ head) (~ tail)])))
+    (#;Right [state (list (foldL (: (-> AST AST AST)
+                                    (lambda [tail head]
+                                      (` (#;Cons [(~ head) (~ tail)]))))
                                  last
                                  init))])
 
@@ -281,57 +272,6 @@
     (using List/Monoid
       (foldL ++ unit mma))))
 
-(defstruct #export PList/Dict (Dict PList)
-  (def (D;get k (#PList [eq kvs]))
-    (loop [kvs kvs]
-      (case kvs
-        #;Nil
-        #;None
-        
-        (#;Cons [k' v'] kvs')
-        (if (:: eq (E;= k k'))
-          (#;Some v')
-          (recur kvs')))))
-
-  (def (D;put k v (#PList [eq kvs]))
-    (#PList [eq (loop [kvs kvs]
-                  (case kvs
-                    #;Nil
-                    (#;Cons [k v] kvs)
-                    
-                    (#;Cons [k' v'] kvs')
-                    (if (:: eq (E;= k k'))
-                      (#;Cons [k v] kvs')
-                      (#;Cons [k' v'] (recur kvs')))))]))
-
-  (def (D;remove k (#PList [eq kvs]))
-    (#PList [eq (loop [kvs kvs]
-                  (case kvs
-                    #;Nil
-                    kvs
-                    
-                    (#;Cons [[k' v'] kvs'])
-                    (if (:: eq (E;= k k'))
-                      kvs'
-                      (#;Cons [[k' v'] (recur kvs')]))))])))
-
-(defstruct #export List/Stack (S;Stack List)
-  (def S;empty (list))
-  (def (S;empty? xs)
-    (case xs
-      #;Nil true
-      _     false))
-  (def (S;push x xs)
-    (#;Cons x xs))
-  (def (S;pop xs)
-    (case xs
-      #;Nil          #;None
-      (#;Cons x xs') (#;Some xs')))
-  (def (S;top xs)
-    (case xs
-      #;Nil          #;None
-      (#;Cons x xs') (#;Some x))))
-
 ## [Functions]
 (def #export (sort ord xs)
   (All [a] (-> (O;Ord a) (List a) (List a)))
diff --git a/source/lux/data/text.lux b/source/lux/data/text.lux
index 3801e9675..0040a96c5 100644
--- a/source/lux/data/text.lux
+++ b/source/lux/data/text.lux
@@ -166,7 +166,7 @@
 
 (defmacro #export (<> tokens state)
   (case tokens
-    (\ (list (#;Meta _ (#;TextS template))))
+    (\ (list [_ (#;TextS template)]))
     (let [++ (symbol$ ["" ""])]
       (#;Right state (list (` (;let [(~ ++) (;:: Text/Monoid m;++)]
                                     (;$ (~ ++) (~@ (unravel-template template))))))))
diff --git a/source/lux/host/jvm.lux b/source/lux/host/jvm.lux
index 9795965bd..40021d8fa 100644
--- a/source/lux/host/jvm.lux
+++ b/source/lux/host/jvm.lux
@@ -96,7 +96,7 @@
                                                        (list)
 
                                                        (#;Some finally)
-                                                       (list (` (_jvm_finally (~ finally)))))))))))))
+                                                       (: (List AST) (list (` (_jvm_finally (~ finally))))))))))))))
 
 (defsyntax #export (definterface [name local-symbol^] [supers (tuple^ (*^ local-symbol^))] [members (*^ method-decl^)])
   (let [members' (map (: (-> (, (List Text) Text (List Text) Text) AST)
@@ -166,7 +166,7 @@
 
 (defsyntax #export (.? [field local-symbol^] obj)
   (case obj
-    (#;Meta [_ (#;SymbolS obj-name)])
+    [_ (#;SymbolS obj-name)]
     (do Lux/Monad
       [obj-type (find-var-type obj-name)]
       (case obj-type
@@ -184,7 +184,7 @@
 
 (defsyntax #export (.= [field local-symbol^] value obj)
   (case obj
-    (#;Meta [_ (#;SymbolS obj-name)])
+    [_ (#;SymbolS obj-name)]
     (do Lux/Monad
       [obj-type (find-var-type obj-name)]
       (case obj-type
@@ -203,7 +203,7 @@
 (defsyntax #export (.! [call method-call^] obj)
   (let [[m-name ?m-classes m-args] call]
     (case obj
-      (#;Meta [_ (#;SymbolS obj-name)])
+      [_ (#;SymbolS obj-name)]
       (do Lux/Monad
         [obj-type (find-var-type obj-name)]
         (case obj-type
diff --git a/source/lux/meta/ast.lux b/source/lux/meta/ast.lux
index ecf7d6e6e..a601739a1 100644
--- a/source/lux/meta/ast.lux
+++ b/source/lux/meta/ast.lux
@@ -28,7 +28,7 @@
 (do-template [<name> <type> <tag>]
   [(def #export (<name> x)
      (-> <type> AST)
-     (#;Meta _cursor (<tag> x)))]
+     [_cursor (<tag> x)])]
   
   [bool$   Bool               #;BoolS]
   [int$    Int                #;IntS]
diff --git a/source/lux/meta/lux.lux b/source/lux/meta/lux.lux
index 8a0ec5f46..92c43bbee 100644
--- a/source/lux/meta/lux.lux
+++ b/source/lux/meta/lux.lux
@@ -119,7 +119,7 @@
 (def #export (macro-expand syntax)
   (-> AST (Lux (List AST)))
   (case syntax
-    (#;Meta [_ (#;FormS (#;Cons [(#;Meta [_ (#;SymbolS macro-name)]) args]))])
+    [_ (#;FormS (#;Cons [[_ (#;SymbolS macro-name)] args]))]
     (do Lux/Monad
       [macro-name' (normalize macro-name)
        ?macro (find-macro macro-name')]
@@ -139,7 +139,7 @@
 (def #export (macro-expand-all syntax)
   (-> AST (Lux (List AST)))
   (case syntax
-    (#;Meta [_ (#;FormS (#;Cons [(#;Meta [_ (#;SymbolS macro-name)]) args]))])
+    [_ (#;FormS (#;Cons [[_ (#;SymbolS macro-name)] args]))]
     (do Lux/Monad
       [macro-name' (normalize macro-name)
        ?macro (find-macro macro-name')]
@@ -155,13 +155,13 @@
           [parts' (M;map% Lux/Monad macro-expand-all (list& (symbol$ macro-name) args))]
           (wrap (list (form$ (:: List/Monad (M;join parts'))))))))
 
-    (#;Meta [_ (#;FormS (#;Cons [harg targs]))])
+    [_ (#;FormS (#;Cons [harg targs]))]
     (do Lux/Monad
       [harg+ (macro-expand-all harg)
        targs+ (M;map% Lux/Monad macro-expand-all targs)]
       (wrap (list (form$ (list:++ harg+ (:: List/Monad (M;join (: (List (List AST)) targs+))))))))
 
-    (#;Meta [_ (#;TupleS members)])
+    [_ (#;TupleS members)]
     (do Lux/Monad
       [members' (M;map% Lux/Monad macro-expand-all members)]
       (wrap (list (tuple$ (:: List/Monad (M;join members'))))))
diff --git a/source/lux/meta/macro.lux b/source/lux/meta/macro.lux
index bfc274e59..f554f45b4 100644
--- a/source/lux/meta/macro.lux
+++ b/source/lux/meta/macro.lux
@@ -9,18 +9,18 @@
 (def #export (defmacro tokens state)
   Macro
   (case tokens
-    (#;Cons [(#;Meta [_ (#;FormS (#;Cons [name args]))]) (#;Cons [body #;Nil])])
-    (#;Right [state (#;Cons [(` ((~ (#;Meta ["" -1 -1] (#;SymbolS ["lux" "def"]))) ((~ name) (~@ args))
-                                 (~ (#;Meta ["" -1 -1] (#;SymbolS ["lux" "Macro"])))
+    (#;Cons [[_ (#;FormS (#;Cons [name args]))] (#;Cons [body #;Nil])])
+    (#;Right [state (#;Cons [(` ((~ [["" -1 -1] (#;SymbolS ["lux" "def"])]) ((~ name) (~@ args))
+                                 (~ [["" -1 -1] (#;SymbolS ["lux" "Macro"])])
                                  (~ body)))
-                             (#;Cons [(` ((~ (#;Meta ["" -1 -1] (#;SymbolS ["" "_lux_declare-macro"]))) (~ name)))
+                             (#;Cons [(` ((~ [["" -1 -1] (#;SymbolS ["" "_lux_declare-macro"])]) (~ name)))
                                       #;Nil])])])
 
-    (#;Cons [(#;Meta [_ (#;TagS ["" "export"])]) (#;Cons [(#;Meta [_ (#;FormS (#;Cons [name args]))]) (#;Cons [body #;Nil])])])
-    (#;Right [state (#;Cons [(` ((~ (#;Meta ["" -1 -1] (#;SymbolS ["lux" "def"]))) (~ (#;Meta ["" -1 -1] (#;TagS ["" "export"]))) ((~ name) (~@ args))
-                                 (~ (#;Meta ["" -1 -1] (#;SymbolS ["lux" "Macro"])))
+    (#;Cons [[_ (#;TagS ["" "export"])] (#;Cons [[_ (#;FormS (#;Cons [name args]))] (#;Cons [body #;Nil])])])
+    (#;Right [state (#;Cons [(` ((~ [["" -1 -1] (#;SymbolS ["lux" "def"])]) (~ [["" -1 -1] (#;TagS ["" "export"])]) ((~ name) (~@ args))
+                                 (~ [["" -1 -1] (#;SymbolS ["lux" "Macro"])])
                                  (~ body)))
-                             (#;Cons [(` ((~ (#;Meta ["" -1 -1] (#;SymbolS ["" "_lux_declare-macro"]))) (~ name)))
+                             (#;Cons [(` ((~ [["" -1 -1] (#;SymbolS ["" "_lux_declare-macro"])]) (~ name)))
                                       #;Nil])])])
 
     _
diff --git a/source/lux/meta/syntax.lux b/source/lux/meta/syntax.lux
index c7f691389..1732350ce 100644
--- a/source/lux/meta/syntax.lux
+++ b/source/lux/meta/syntax.lux
@@ -70,7 +70,7 @@
   [(def #export (<name> tokens)
      (Parser <type>)
      (case tokens
-       (#;Cons [(#;Meta [_ (<tag> x)]) tokens'])
+       (#;Cons [[_ (<tag> x)] tokens'])
        (#;Some [tokens' x])
 
        _
@@ -89,7 +89,7 @@
   [(def #export (<name> tokens)
      (Parser Text)
      (case tokens
-       (#;Cons [(#;Meta [_ (<tag> ["" x])]) tokens'])
+       (#;Cons [[_ (<tag> ["" x])] tokens'])
        (#;Some [tokens' x])
 
        _
@@ -110,7 +110,7 @@
   [(def #export (<name> v tokens)
      (-> <type> (Parser (,)))
      (case tokens
-       (#;Cons [(#;Meta [_ (<tag> x)]) tokens'])
+       (#;Cons [[_ (<tag> x)] tokens'])
        (if (<eq> v x)
          (#;Some [tokens' []])
          #;None)
@@ -132,7 +132,7 @@
      (All [a]
        (-> (Parser a) (Parser a)))
      (case tokens
-       (#;Cons [(#;Meta [_ (<tag> form)]) tokens'])
+       (#;Cons [[_ (<tag> form)] tokens'])
        (case (p form)
          (#;Some [#;Nil x]) (#;Some [tokens' x])
          _                  #;None)
@@ -212,24 +212,24 @@
 (defmacro #export (defsyntax tokens)
   (let [[exported? tokens] (: (, Bool (List AST))
                               (case tokens
-                                (\ (list& (#;Meta [_ (#;TagS ["" "export"])]) tokens'))
+                                (\ (list& [_ (#;TagS ["" "export"])] tokens'))
                                 [true tokens']
 
                                 _
                                 [false tokens]))]
     (case tokens
-      (\ (list (#;Meta [_ (#;FormS (list& (#;Meta [_ (#;SymbolS ["" name])]) args))])
+      (\ (list [_ (#;FormS (list& [_ (#;SymbolS ["" name])] args))]
                body))
       (do Lux/Monad
         [names+parsers (M;map% Lux/Monad
                                (: (-> AST (Lux (, AST AST)))
                                   (lambda [arg]
                                     (case arg
-                                      (\ (#;Meta [_ (#;TupleS (list (#;Meta [_ (#;SymbolS var-name)])
-                                                                    parser))]))
+                                      (\ [_ (#;TupleS (list [_ (#;SymbolS var-name)]
+                                                            parser))])
                                       (wrap [(symbol$ var-name) parser])
 
-                                      (\ (#;Meta [_ (#;SymbolS var-name)]))
+                                      (\ [_ (#;SymbolS var-name)])
                                       (wrap [(symbol$ var-name) (` id^)])
 
                                       _