- Added the (untested) inference of tuple destructuring.

- Removed several (unnecessary) type annotations.

1 files changed, 67 insertions, 76 deletions

diff --git a/source/lux.lux b/source/lux.lux
index c1e7b0046..d661b9268 100644
--- a/source/lux.lux
+++ b/source/lux.lux
@@ -691,8 +691,7 @@
 
 (def'' (make-env xs ys)
   (#LambdaT ($' List Text) (#LambdaT ($' List AST) RepEnv))
-  (_lux_case (_lux_: (#TupleT (#Cons ($' List Text) (#Cons ($' List AST) #Nil)))
-                     [xs ys])
+  (_lux_case [xs ys]
     [(#Cons x xs') (#Cons y ys')]
     (#Cons [x y] (make-env xs' ys'))
 
@@ -823,13 +822,12 @@
     (foldL f (f init x) xs')))
 
 (defmacro' #export (All tokens)
-  (let'' [self-name tokens] (_lux_: (#TupleT (#Cons Text (#Cons ASTList #Nil)))
-                                    (_lux_case tokens
-                                      (#Cons [_ (#SymbolS "" self-name)] tokens)
-                                      [self-name tokens]
+  (let'' [self-name tokens] (_lux_case tokens
+                              (#Cons [_ (#SymbolS "" self-name)] tokens)
+                              [self-name tokens]
 
-                                      _
-                                      ["" tokens]))
+                              _
+                              ["" tokens])
          (_lux_case tokens
            (#Cons [_ (#TupleS args)] (#Cons body #Nil))
            (parse-univq-args args
@@ -850,13 +848,12 @@
          ))
 
 (defmacro' #export (Ex tokens)
-  (let'' [self-name tokens] (_lux_: (#TupleT (#Cons Text (#Cons ASTList #Nil)))
-                                    (_lux_case tokens
-                                      (#Cons [_ (#SymbolS "" self-name)] tokens)
-                                      [self-name tokens]
+  (let'' [self-name tokens] (_lux_case tokens
+                              (#Cons [_ (#SymbolS "" self-name)] tokens)
+                              [self-name tokens]
 
-                                      _
-                                      ["" tokens]))
+                              _
+                              ["" tokens])
          (_lux_case tokens
            (#Cons [_ (#TupleS args)] (#Cons body #Nil))
            (parse-univq-args args
@@ -1313,7 +1310,7 @@
                    (resolve-global-symbol [subst name])
 
                    _
-                   (wrap (_lux_: Ident [module name])))
+                   (wrap [module name]))
        #let [[module name] real-name]]
       (return (wrap-meta (form$ (@list (tag$ ["lux" "SymbolS"]) (tuple$ (@list (text$ module) (text$ name))))))))
 
@@ -1330,7 +1327,7 @@
     (do Lux/Monad
       [output (splice replace? (untemplate replace? subst) (tag$ ["lux" "FormS"]) elems)
        #let [[_ form'] output]]
-      (return (_lux_: AST [meta form'])))
+      (return [meta form']))
 
     [_ [_ (#RecordS fields)]]
     (do Lux/Monad
@@ -1576,7 +1573,7 @@
     ["" name]
     (do Lux/Monad
       [module-name get-module-name]
-      (wrap (_lux_: Ident [module-name name])))
+      (wrap [module-name name]))
 
     _
     (return ident)))
@@ -1910,20 +1907,18 @@
                     #None))]
         (_lux_case parts
           (#Some name args ?type body)
-          (let' [body' (: AST
-                          (_lux_case args
-                            #Nil
-                            body
+          (let' [body' (_lux_case args
+                         #Nil
+                         body
 
-                            _
-                            (` (lambda' (~ name) [(~@ args)] (~ body)))))
-                 body'' (: AST
-                           (_lux_case ?type
-                             (#Some type)
-                             (` (: (~ type) (~ body')))
-                             
-                             #None
-                             body'))]
+                         _
+                         (` (lambda' (~ name) [(~@ args)] (~ body))))
+                 body'' (_lux_case ?type
+                          (#Some type)
+                          (` (: (~ type) (~ body')))
+                          
+                          #None
+                          body')]
                 (return (@list& (` (;_lux_def (~ name) (~ body'')))
                                 (if export?
                                   (@list (` (;_lux_export (~ name))))
@@ -2081,14 +2076,14 @@
     (#Some ident head tail body)
     (let [g!blank (symbol$ ["" ""])
           g!name (symbol$ ident)
-          body+ (: AST (foldL (: (-> AST AST AST)
-                                 (lambda' [body' arg]
-                                          (if (symbol? arg)
-                                            (` (;_lux_lambda (~ g!blank) (~ arg) (~ body')))
-                                            (` (;_lux_lambda (~ g!blank) (~ g!blank)
-                                                        (case (~ g!blank) (~ arg) (~ body')))))))
-                              body
-                              (reverse tail)))]
+          body+ (foldL (: (-> AST AST AST)
+                          (lambda' [body' arg]
+                                   (if (symbol? arg)
+                                     (` (;_lux_lambda (~ g!blank) (~ arg) (~ body')))
+                                     (` (;_lux_lambda (~ g!blank) (~ g!blank)
+                                                 (case (~ g!blank) (~ arg) (~ body')))))))
+                       body
+                       (reverse tail))]
       (return (@list (if (symbol? head)
                        (` (;_lux_lambda (~ g!name) (~ head) (~ body+)))
                        (` (;_lux_lambda (~ g!name) (~ g!blank) (case (~ g!blank) (~ head) (~ body+))))))))
@@ -2121,20 +2116,18 @@
                    #None))]
     (case parts
       (#Some name args ?type body)
-      (let [body (: AST
-                    (case args
-                      #Nil
-                      body
+      (let [body (case args
+                   #Nil
+                   body
 
-                      _
-                      (` (lambda (~ name) [(~@ args)] (~ body)))))
-            body (: AST
-                    (case ?type
-                      (#Some type)
-                      (` (: (~ type) (~ body)))
-                      
-                      #None
-                      body))]
+                   _
+                   (` (lambda (~ name) [(~@ args)] (~ body))))
+            body (case ?type
+                   (#Some type)
+                   (` (: (~ type) (~ body)))
+                   
+                   #None
+                   body)]
         (return (@list& (` (;_lux_def (~ name) (~ body)))
                         (if export?
                           (@list (` (;_lux_export (~ name))))
@@ -2163,12 +2156,12 @@
     (case name+args+body??
       (#Some [name args body])
       (let [name (symbol$ name)
-            decls (list:++ (: (List AST) (if exported? (@list (` (;_lux_export (~ name)))) #;Nil))
-                           (: (List AST) (@list (` (;;_lux_declare-macro (~ name))))))
-            def-sig (: AST
-                       (case args
-                         #;Nil name
-                         _     (` ((~ name) (~@ args)))))]
+            decls (: (List AST)
+                     (list:++ (if exported? (@list (` (;_lux_export (~ name)))) #;Nil)
+                              (@list (` (;;_lux_declare-macro (~ name))))))
+            def-sig (case args
+                      #;Nil name
+                      _     (` ((~ name) (~@ args))))]
         (return (@list& (` (;;def (~ def-sig) ;;Macro (~ body)))
                         decls)))
       
@@ -2212,15 +2205,14 @@
                def-name (symbol$ name)
                tags (: (List AST) (map (. (: (-> Text AST) (lambda [n] (tag$ ["" n]))) first) members))
                types (map second members)
-               sig-type (: AST (` (#TupleT (~ (untemplate-list types)))))
-               sig-decl (: AST (` (;_lux_declare-tags [(~@ tags)] (~ def-name))))
-               sig+ (: AST
-                       (case args
-                         #Nil
-                         sig-type
+               sig-type (` (#TupleT (~ (untemplate-list types))))
+               sig-decl (` (;_lux_declare-tags [(~@ tags)] (~ def-name)))
+               sig+ (case args
+                      #Nil
+                      sig-type
 
-                         _
-                         (` (#NamedT [(~ (text$ _module)) (~ (text$ _name))] (;All (~ def-name) [(~@ args)] (~ sig-type))))))]]
+                      _
+                      (` (#NamedT [(~ (text$ _module)) (~ (text$ _name))] (;All (~ def-name) [(~@ args)] (~ sig-type)))))]]
         (return (@list& (` (;_lux_def (~ def-name) (~ sig+)))
                         sig-decl
                         (if export?
@@ -2556,13 +2548,12 @@
                     #None))]
     (case ?parts
       (#Some name args type defs)
-      (let [defs' (: AST
-                     (case args
-                       #Nil
-                       (` (struct (~@ defs)))
+      (let [defs' (case args
+                    #Nil
+                    (` (struct (~@ defs)))
 
-                       _
-                       (` (lambda (~ name) [(~@ args)] (;struct (~@ defs))))))]
+                    _
+                    (` (lambda (~ name) [(~@ args)] (;struct (~@ defs)))))]
         (return (@list& (` (def (~ name) (~ type) (~ defs')))
                         (if export?
                           (@list (` (;_lux_export (~ name))))
@@ -3036,7 +3027,7 @@
   (-> Text Ident AST Type (Lux (List AST)))
   (do Lux/Monad
     [output (resolve-type-tags type)
-     #let [source+ (: AST (` (get@ (~ (tag$ [module name])) (~ source))))]]
+     #let [source+ (` (get@ (~ (tag$ [module name])) (~ source)))]]
     (case output
       (#Some [tags members])
       (do Lux/Monad
@@ -3087,7 +3078,7 @@
                           [m-name m-alias m-referrals m-openings]
                           (do Lux/Monad
                             [m-name (clean-module m-name)]
-                            (wrap (: Importation [m-name m-alias m-referrals m-openings]))))))
+                            (wrap [m-name m-alias m-referrals m-openings])))))
                    imports)
      unknowns' (map% Lux/Monad
                      (: (-> Importation (Lux (List Text)))
@@ -3178,11 +3169,11 @@
                          (lambda [so-far part]
                            (case part
                              [_ (#SymbolS slot)]
-                             (return (: AST (` (get@ (~ (tag$ slot)) (~ so-far)))))
+                             (return (` (get@ (~ (tag$ slot)) (~ so-far))))
 
                              (\ [_ (#FormS (@list& [_ (#SymbolS slot)] args))])
-                             (return (: AST (` ((get@ (~ (tag$ slot)) (~ so-far))
-                                                (~@ args)))))
+                             (return (` ((get@ (~ (tag$ slot)) (~ so-far))
+                                         (~@ args))))
 
                              _
                              (fail "Wrong syntax for ::"))))