- Fixed a few type-related bugs.

- Variants now need types to be specified both when constructing them as when deconstructing them (in pattern-matching).
- Simplified DataT types by no-longer requiring a list of params, so only the tame name is necessary.

1 files changed, 184 insertions, 174 deletions

diff --git a/source/lux.lux b/source/lux.lux
index 34d766b52..357366d58 100644
--- a/source/lux.lux
+++ b/source/lux.lux
@@ -25,11 +25,11 @@
 
 ## Basic types
 (def' Any #AnyT)
-(def' Bool (#DataT ["java.lang.Boolean" #Nil]))
-(def' Int (#DataT ["java.lang.Long" #Nil]))
-(def' Real (#DataT ["java.lang.Double" #Nil]))
-(def' Char (#DataT ["java.lang.Character" #Nil]))
-(def' Text (#DataT ["java.lang.String" #Nil]))
+(def' Bool (#DataT "java.lang.Boolean"))
+(def' Int (#DataT "java.lang.Long"))
+(def' Real (#DataT "java.lang.Double"))
+(def' Char (#DataT "java.lang.Character"))
+(def' Text (#DataT "java.lang.String"))
 
 ## (deftype (List a)
 ##   (| #Nil
@@ -62,7 +62,7 @@
                 (#AppT [(#AllT [#Nil "Type" ""
                                 (#VariantT (#Cons [["lux;AnyT" (#TupleT #Nil)]
                                                    (#Cons [["lux;NothingT" (#TupleT #Nil)]
-                                                           (#Cons [["lux;DataT" (#TupleT (#Cons [Text (#Cons [(#AppT [List Type]) #Nil])]))]
+                                                           (#Cons [["lux;DataT" Text]
                                                                    (#Cons [["lux;TupleT" (#AppT [List (#AppT [(#BoundT "Type") (#BoundT "")])])]
                                                                            (#Cons [["lux;VariantT" TypeEnv]
                                                                                    (#Cons [["lux;RecordT" TypeEnv]
@@ -74,175 +74,187 @@
                                                                                                                                    #Nil])])])])])])])])])])]))])
                         #NothingT]))))
 
-## (deftype (Maybe a)
-##   (| #None
-##      (#Some a)))
-(def' Maybe
-  (#AllT [#Nil "Maybe" "a"
-          (#VariantT (#Cons [["lux;None" (#TupleT #Nil)]
-                             (#Cons [["lux;Some" (#BoundT "a")]
-                                     #Nil])]))]))
+## ## (deftype (Maybe a)
+## ##   (| #None
+## ##      (#Some a)))
+## (def' Maybe
+##   (#AllT [#Nil "Maybe" "a"
+##           (#VariantT (#Cons [["lux;None" (#TupleT #Nil)]
+##                              (#Cons [["lux;Some" (#BoundT "a")]
+##                                      #Nil])]))]))
+
+## ## (deftype (Bindings k v)
+## ##   (& #counter Int
+## ##      #mappings (List (, k v))))
+## (def' Bindings
+##   (#AllT [#Nil "Bindings" "k"
+##           (#AllT [#Nil "" "v"
+##                   (#RecordT (#Cons [["lux;counter" Int]
+##                                     (#Cons [["lux;mappings" (#AppT [List
+##                                                                     (#TupleT (#Cons [(#BoundT "k")
+##                                                                                      (#Cons [(#BoundT "v")
+##                                                                                              #Nil])]))])]
+##                                             #Nil])]))])]))
+
+## ## (deftype (Env k v)
+## ##   (& #name Text
+## ##      #inner-closures Int
+## ##      #locals  (Bindings k v)
+## ##      #closure (Bindings k v)))
+## (def' Env
+##   (#AllT [#Nil "Env" "k"
+##           (#AllT [#Nil "" "v"
+##                   (#RecordT (#Cons [["lux;name" Text]
+##                                     (#Cons [["lux;inner-closures" Int]
+##                                             (#Cons [["lux;locals" (#AppT [(#AppT [Bindings (#BoundT "k")])
+##                                                                           (#BoundT "v")])]
+##                                                     (#Cons [["lux;closure" (#AppT [(#AppT [Bindings (#BoundT "k")])
+##                                                                                    (#BoundT "v")])]
+##                                                             #Nil])])])]))])]))
+
+## ## (deftype Cursor
+## ##   (, Text Int Int))
+## (def' Cursor
+##   (#TupleT (#Cons [Text (#Cons [Int (#Cons [Int #Nil])])])))
+
+## ## (deftype (Meta m v)
+## ##   (| (#Meta (, m v))))
+## (def' Meta
+##   (#AllT [#Nil "Meta" "m"
+##           (#AllT [#Nil "" "v"
+##                   (#VariantT (#Cons [["lux;Meta" (#TupleT (#Cons [(#BoundT "m")
+##                                                                   (#Cons [(#BoundT "v")
+##                                                                           #Nil])]))]
+##                                      #Nil]))])]))
+
+## ## (def' Reader
+## ##   (List (Meta Cursor Text)))
+## (def' Reader
+##   (#AppT [List
+##           (#AppT [(#AppT [Meta Cursor])
+##                   Text])]))
+
+## ## (deftype Compiler_State
+## ##   (& #source         (Maybe Reader)
+## ##      #modules        (List Any)
+## ##      #module-aliases (List Any)
+## ##      #global-env     (Maybe (Env Text Any))
+## ##      #local-envs     (List (Env Text Any))
+## ##      #types          (Bindings Int Type)
+## ##      #writer         (^ org.objectweb.asm.ClassWriter)
+## ##      #loader         (^ java.net.URLClassLoader)
+## ##      #eval-ctor      Int))
+## (def' Compiler_State
+##   (#RecordT (#Cons [["lux;source" (#AppT [Maybe Reader])]
+##                     (#Cons [["lux;modules" (#AppT [List Any])]
+##                             (#Cons [["lux;module-aliases" (#AppT [List Any])]
+##                                     (#Cons [["lux;global-env" (#AppT [Maybe (#AppT [(#AppT [Env Text]) Any])])]
+##                                             (#Cons [["lux;local-envs" (#AppT [List (#AppT [(#AppT [Env Text]) Any])])]
+##                                                     (#Cons [["lux;types" (#AppT [(#AppT [Bindings Int]) Type])]
+##                                                             (#Cons [["lux;writer" (#DataT "org.objectweb.asm.ClassWriter")]
+##                                                                     (#Cons [["lux;loader" (#DataT "java.lang.ClassLoader")]
+##                                                                             (#Cons [["lux;eval-ctor" Int]
+##                                                                                     #Nil])])])])])])])])])))
 
-## (deftype (Bindings k v)
-##   (& #counter Int
-##      #mappings (List (, k v))))
-(def' Bindings
-  (#AllT [#Nil "Bindings" "k"
-          (#AllT [#Nil "" "v"
-                  (#RecordT (#Cons [["lux;counter" Int]
-                                    (#Cons [["lux;mappings" (#AppT [List
-                                                                    (#TupleT (#Cons [(#BoundT "k")
-                                                                                     (#Cons [(#BoundT "v")
-                                                                                             #Nil])]))])]
-                                            #Nil])]))])]))
-
-## (deftype (Env k v)
-##   (& #name Text
-##      #inner-closures Int
-##      #locals  (Bindings k v)
-##      #closure (Bindings k v)))
-(def' Env
-  (#AllT [#Nil "Env" "k"
-          (#AllT [#Nil "" "v"
-                  (#RecordT (#Cons [["lux;name" Text]
-                                    (#Cons [["lux;inner-closures" Int]
-                                            (#Cons [["lux;locals" (#AppT [(#AppT [Bindings (#BoundT "k")])
-                                                                          (#BoundT "v")])]
-                                                    (#Cons [["lux;closure" (#AppT [(#AppT [Bindings (#BoundT "k")])
-                                                                                   (#BoundT "v")])]
-                                                            #Nil])])])]))])]))
-
-## (deftype Cursor
-##   (, Text Int Int))
-(def' Cursor
-  (#TupleT (#Cons [Text (#Cons [Int (#Cons [Int #Nil])])])))
-
-## (deftype (Meta m v)
-##   (| (#Meta (, m v))))
-(def' Meta
-  (#AllT [#Nil "Meta" "m"
-          (#AllT [#Nil "" "v"
-                  (#VariantT (#Cons [["lux;Meta" (#TupleT (#Cons [(#BoundT "m")
-                                                                  (#Cons [(#BoundT "v")
-                                                                          #Nil])]))]
-                                     #Nil]))])]))
+## ## (deftype #rec Syntax
+## ##   (Meta Cursor (| (#Bool Bool)
+## ##                   (#Int Int)
+## ##                   (#Real Real)
+## ##                   (#Char Char)
+## ##                   (#Text Text)
+## ##                   (#Form (List Syntax))
+## ##                   (#Tuple (List Syntax))
+## ##                   (#Record (List (, Text Syntax))))))
+## (def' Syntax
+##   (case' (#AppT [(#BoundT "Syntax") (#BoundT "")])
+##          Syntax
+##          (case' (#AppT [List Syntax])
+##                 SyntaxList
+##                 (#AppT [(#AllT [#Nil "Syntax" ""
+##                                 (#VariantT (#Cons [["lux;Bool" Bool]
+##                                                    (#Cons [["lux;Int" Int]
+##                                                            (#Cons [["lux;Real" Real]
+##                                                                    (#Cons [["lux;Char" Char]
+##                                                                            (#Cons [["lux;Text" Text]
+##                                                                                    (#Cons [["lux;Form" SyntaxList]
+##                                                                                            (#Cons [["lux;Tuple" SyntaxList]
+##                                                                                                    (#Cons [["lux;Record" (#AppT [List (#TupleT (#Cons [Text (#Cons [Syntax #Nil])]))])]
+##                                                                                                            #Nil])])])])])])])]))])
+##                         #NothingT]))))
 
-## (def' Reader
-##   (List (Meta Cursor Text)))
-(def' Reader
-  (#AppT [List
-          (#AppT [(#AppT [Meta Cursor])
-                  Text])]))
-
-## (deftype CompilerState
-##   (& #source         (Maybe Reader)
-##      #modules        (List Any)
-##      #module-aliases (List Any)
-##      #global-env     (Maybe (Env Text Any))
-##      #local-envs     (List (Env Text Any))
-##      #types          (Bindings Int Type)
-##      #writer         (^ org.objectweb.asm.ClassWriter)
-##      #loader         (^ java.net.URLClassLoader)
-##      #eval-ctor      Int))
-(def' CompilerState
-  (#RecordT (#Cons [["lux;source" (#AppT [Maybe Reader])]
-                    (#Cons [["lux;modules" (#AppT [List Any])]
-                            (#Cons [["lux;module-aliases" (#AppT [List Any])]
-                                    (#Cons [["lux;global-env" (#AppT [Maybe (#AppT [(#AppT [Env Text]) Any])])]
-                                            (#Cons [["lux;local-envs" (#AppT [List (#AppT [(#AppT [Env Text]) Any])])]
-                                                    (#Cons [["lux;types" (#AppT [(#AppT [Bindings Int]) Type])]
-                                                            (#Cons [["lux;writer" (#DataT ["org.objectweb.asm.ClassWriter" #Nil])]
-                                                                    (#Cons [["lux;loader" (#DataT ["java.lang.ClassLoader" #Nil])]
-                                                                            (#Cons [["lux;eval-ctor" Int]
-                                                                                    #Nil])])])])])])])])])))
-
-## (deftype #rec Syntax
-##   (Meta Cursor (| (#Bool Bool)
-##                   (#Int Int)
-##                   (#Real Real)
-##                   (#Char Char)
-##                   (#Text Text)
-##                   (#Form (List Syntax))
-##                   (#Tuple (List Syntax))
-##                   (#Record (List (, Text Syntax))))))
-(def' Syntax
-  (case' (#AppT [(#BoundT "Syntax") (#BoundT "")])
-         Syntax
-         (case' (#AppT [List Syntax])
-                SyntaxList
-                (#AppT [(#AllT [#Nil "Syntax" ""
-                                (#VariantT (#Cons [["lux;Bool" Bool]
-                                                   (#Cons [["lux;Int" Int]
-                                                           (#Cons [["lux;Real" Real]
-                                                                   (#Cons [["lux;Char" Char]
-                                                                           (#Cons [["lux;Text" Text]
-                                                                                   (#Cons [["lux;Form" SyntaxList]
-                                                                                           (#Cons [["lux;Tuple" SyntaxList]
-                                                                                                   (#Cons [["lux;Record" (#AppT [List (#TupleT (#Cons [Text (#Cons [Syntax #Nil])]))])]
-                                                                                                           #Nil])])])])])])])]))])
-                        #NothingT]))))
+## ## (deftype (Either l r)
+## ##   (| (#Left l)
+## ##      (#Right r)))
+## (def' Either
+##   (#AllT [#Nil "_" "l"
+##           (#AllT [#Nil "" "r"
+##                   (#VariantT (#Cons [["lux;Left" (#BoundT "l")]
+##                                      (#Cons [["lux;Right" (#BoundT "r")]
+##                                              #Nil])]))])]))
 
-## (deftype (Either l r)
-##   (| (#Left l)
-##      (#Right r)))
-(def' Either
-  (#AllT [#Nil "Either" "l"
-          (#AllT [#Nil "" "r"
-                  (#VariantT (#Cons [["lux;Left" (#BoundT "l")]
-                                     (#Cons [["lux;Right" (#BoundT "r")]
-                                             #Nil])]))])]))
-
-## (deftype Macro
-##   (-> (List Syntax) CompilerState
-##       (Either Text [CompilerState (List Syntax)])))
-(def' Macro
-  (case' (#AppT [List Syntax])
-         SyntaxList
-         (#LambdaT [SyntaxList
-                    (#LambdaT [CompilerState
-                               (#AppT [(#AppT [Either Text])
-                                       (#TupleT (#Cons [CompilerState
-                                                        (#Cons [SyntaxList #Nil])]))])])])))
-
-## Base functions & macros
-## (def (_meta data)
-##   (All [a] (-> a (Meta Cursor a)))
-##   (#Meta [["" -1 -1] data]))
-(def' _meta
-  (check' (#AllT [#Nil "" "a"
-                  (#LambdaT [(#BoundT "a")
-                             (#AppT [(#AppT [Meta Cursor])
-                                     (#BoundT "a")])])])
-          (lambda' _ data
-                   (#Meta [["" -1 -1] data]))))
+## ## (deftype Macro
+## ##   (-> (List Syntax) Compiler_State
+## ##       (Either Text [Compiler_State (List Syntax)])))
+## (def' Macro
+##   (case' (#AppT [List Syntax])
+##          SyntaxList
+##          (#LambdaT [SyntaxList
+##                     (#LambdaT [CompilerState
+##                                (#AppT [(#AppT [Either Text])
+##                                        (#TupleT (#Cons [CompilerState
+##                                                         (#Cons [SyntaxList #Nil])]))])])])))
+
+## ## Base functions & macros
+## ## (def (_meta data)
+## ##   (All [a] (-> a (Meta Cursor a)))
+## ##   (#Meta [["" -1 -1] data]))
+## (def' _meta
+##   (check' (#AllT [#Nil "_" "a"
+##                   (#LambdaT [(#BoundT "a")
+##                              (#AppT [(#AppT [Meta Cursor])
+##                                      (#BoundT "a")])])])
+##           (lambda' _ data
+##                    (#Meta [["" -1 -1] data]))))
+
+## ## (def' let'
+## ##   (check' Macro
+## ##           (lambda' _ tokens
+## ##                    (lambda' _ state
+## ##                        (case' tokens
+## ##                               (#Cons [lhs (#Cons [rhs (#Cons [body #Nil])])])
+## ##                               (#Right [state
+## ##                                        (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["" "case'"]))
+## ##                                                                      (#Cons [rhs (#Cons [lhs (#Cons [body #Nil])])])])))
+## ##                                                #Nil])])
+
+## ##                               _
+## ##                               (#Left "Wrong syntax for let'"))
+## ##                        ))))
+## ## (def' let'
+## ##   (check' Macro
+## ##           (lambda' _ tokens
+## ##               (lambda' _ state
+## ##                   (#Left "Wrong syntax for let'")
+## ##                   ))))
+## (def' let'
+##   (check' (#AppT [(#AppT [Either Text])
+##                   (#TupleT (#Cons [CompilerState
+##                                    (#Cons [(#AppT [List Syntax]) #Nil])]))])
+##           (#Left "Wrong syntax for let'")))
 
 ## (def' let'
-##   (check' Macro
-##           (lambda' _ tokens
-##                    (lambda' _ state
-##                        (case' tokens
-##                               (#Cons [lhs (#Cons [rhs (#Cons [body #Nil])])])
-##                               (#Right [state
-##                                        (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["" "case'"]))
-##                                                                      (#Cons [rhs (#Cons [lhs (#Cons [body #Nil])])])])))
-##                                                #Nil])])
-
-##                               _
-##                               (#Left "Wrong syntax for let'"))
-##                        ))))
-(def' let'
-  (lambda' _ tokens
-      (lambda' _ state
-          (case' tokens
-                 (#Cons [lhs (#Cons [rhs (#Cons [body #Nil])])])
-                 (#Right [state
-                          (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["" "case'"]))
-                                                        (#Cons [rhs (#Cons [lhs (#Cons [body #Nil])])])])))
-                                  #Nil])])
-
-                 _
-                 (#Left "Wrong syntax for let'"))
-          )))
+##   (lambda' _ tokens
+##       (lambda' _ state
+##           (case' tokens
+##                  (#Cons [lhs (#Cons [rhs (#Cons [body #Nil])])])
+##                  (#Right [state
+##                           (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["" "case'"]))
+##                                                         (#Cons [rhs (#Cons [lhs (#Cons [body #Nil])])])])))
+##                                   #Nil])])
+
+##                  _
+##                  (#Left "Wrong syntax for let'"))
+##           )))
 ## (declare-macro' let')
 
 ## ## ## (All  21268
@@ -1048,10 +1060,8 @@
 ## ## (defmacro (^ tokens)
 ## ##   (case' tokens
 ## ##          (#Cons [(#Meta [_ (#Symbol [_ class-name])]) #Nil])
-## ##          (return (list (` (#DataT [(~ (_meta (#Text class-name))) (list)]))))
-
-## ##          (#Cons [(#Meta [_ (#Symbol [_ class-name])]) (#Cons [(#Meta [_ (#Tuple params)]) #Nil])])
-## ##          (return (list (` (#DataT [(~ (_meta (#Text class-name))) (~ (untemplate-list params))]))))))
+## ##          (return (list (` (#DataT (~ (_meta (#Text class-name)))))))
+## ##          ))
 
 ## ## (defmacro (, members)
 ## ##   (return (list (_meta (#Form (list+ (_meta (#Tag ["lux" "TupleT"])) (untemplate-list members)))))))