- Changing tags so they're actually indices (part 3).

- Added several bug fixes
- Changed "Reader" to "Source" and "HostState" to "Host" in lux.lux
- Set up indexing of records via tags.
- Added lux.analyser.record namespace.
- Removed some (now) unnecessary code for working with records.
- Added the license (can't believe I missed it for so long.)

1 files changed, 58 insertions, 50 deletions

diff --git a/source/lux.lux b/source/lux.lux
index 91e00d317..04f9df811 100644
--- a/source/lux.lux
+++ b/source/lux.lux
@@ -122,6 +122,7 @@
                                                                #Nil])]))])
                               #Nil)))])]))
 (_lux_export Bindings)
+(_lux_declare-tags [#counter #mappings])
 
 ## (deftype (Env k v)
 ##   (& #name Text
@@ -143,6 +144,7 @@
                                                                     (#BoundT "v")])
                                                             #Nil])])])]))])]))
 (_lux_export Env)
+(_lux_declare-tags [#name #inner-closures #locals #closure])
 
 ## (deftype Cursor
 ##   (, Text Int Int))
@@ -243,19 +245,19 @@
                                                       (#Cons [(#BoundT "a")
                                                               #Nil])]))])])])]))
 
-## (deftype Reader
+## (deftype Source
 ##   (List (Meta Cursor Text)))
-(_lux_def Reader
+(_lux_def Source
   (#AppT [List
           (#AppT [(#AppT [Meta Cursor])
                   Text])]))
-(_lux_export Reader)
+(_lux_export Source)
 
-## (deftype HostState
+## (deftype Host
 ##   (& #writer    (^ org.objectweb.asm.ClassWriter)
 ##      #loader    (^ java.net.URLClassLoader)
 ##      #classes   (^ clojure.lang.Atom)))
-(_lux_def HostState
+(_lux_def Host
   (#RecordT (#Cons [## "lux;writer"
                     (#DataT "org.objectweb.asm.ClassWriter")
                     (#Cons [## "lux;loader"
@@ -263,6 +265,7 @@
                             (#Cons [## "lux;classes"
                                     (#DataT "clojure.lang.Atom")
                                     #Nil])])])))
+(_lux_declare-tags [#writer #loader #classes])
 
 ## (deftype (DefData' m)
 ##   (| (#TypeD Type)
@@ -283,6 +286,7 @@
                                                      Ident
                                                      #Nil])])])]))]))
 (_lux_export DefData')
+(_lux_declare-tags [#TypeD #ValueD #MacroD #AliasD])
 
 ## (deftype LuxVar
 ##   (| (#Local Int)
@@ -294,6 +298,7 @@
                              Ident
                              #Nil])])))
 (_lux_export LuxVar)
+(_lux_declare-tags [#Local #Global])
 
 ## (deftype (Module Compiler)
 ##   (& #module-aliases (List (, Text Text))
@@ -323,44 +328,46 @@
                                                                                    #Nil)))])
                                                     #Nil])])])]))]))
 (_lux_export Module)
+(_lux_declare-tags [#module-aliases #defs #imports #tags])
 
 ## (deftype #rec Compiler
-##   (& #source       Reader
+##   (& #source       Source
+##      #cursor       Cursor
 ##      #modules      (List (, Text (Module Compiler)))
 ##      #envs         (List (Env Text (, LuxVar Type)))
 ##      #types        (Bindings Int Type)
-##      #host         HostState
+##      #expected     Type
 ##      #seed         Int
 ##      #eval?        Bool
-##      #expected     Type
-##      #cursor       Cursor
+##      #host         Host
 ## ))
 (_lux_def Compiler
   (#AppT [(#AllT [(#Some #Nil) "lux;Compiler" ""
                   (#RecordT (#Cons [## "lux;source"
-                                    Reader
-                                    (#Cons [## "lux;modules"
-                                            (#AppT [List (#TupleT (#Cons [Text
-                                                                          (#Cons [(#AppT [Module (#AppT [(#BoundT "lux;Compiler") (#BoundT "")])])
-                                                                                  #Nil])]))])
-                                            (#Cons [## "lux;envs"
-                                                    (#AppT [List (#AppT [(#AppT [Env Text])
-                                                                         (#TupleT (#Cons [LuxVar (#Cons [Type #Nil])]))])])
-                                                    (#Cons [## "lux;types"
-                                                            (#AppT [(#AppT [Bindings Int]) Type])
-                                                            (#Cons [## "lux;host"
-                                                                    HostState
-                                                                    (#Cons [## "lux;seed"
-                                                                            Int
-                                                                            (#Cons [## "lux;eval?"
-                                                                                    Bool
-                                                                                    (#Cons [## "lux;expected"
-                                                                                            Type
-                                                                                            (#Cons [## "lux;cursor"
-                                                                                                    Cursor
+                                    Source
+                                    (#Cons [## "lux;cursor"
+                                            Cursor
+                                            (#Cons [## "lux;modules"
+                                                    (#AppT [List (#TupleT (#Cons [Text
+                                                                                  (#Cons [(#AppT [Module (#AppT [(#BoundT "lux;Compiler") (#BoundT "")])])
+                                                                                          #Nil])]))])
+                                                    (#Cons [## "lux;envs"
+                                                            (#AppT [List (#AppT [(#AppT [Env Text])
+                                                                                 (#TupleT (#Cons [LuxVar (#Cons [Type #Nil])]))])])
+                                                            (#Cons [## "lux;types"
+                                                                    (#AppT [(#AppT [Bindings Int]) Type])
+                                                                    (#Cons [## "lux;expected"
+                                                                            Type
+                                                                            (#Cons [## "lux;seed"
+                                                                                    Int
+                                                                                    (#Cons [## "lux;eval?"
+                                                                                            Bool
+                                                                                            (#Cons [## "lux;host"
+                                                                                                    Host
                                                                                                     #Nil])])])])])])])])]))])
           Void]))
 (_lux_export Compiler)
+(_lux_declare-tags [#source #cursor #modules #envs #types #expected #seed #eval? #host])
 
 ## (deftype Macro
 ##   (-> (List AST) (StateE Compiler (List AST))))
@@ -1016,18 +1023,19 @@
 (def''' Monad
   Type
   (All' [m]
-        (#RecordT (list ["lux;return" (All' [a] (->' (B' a) ($' (B' m) (B' a))))]
-                        ["lux;bind" (All' [a b] (->' (->' (B' a) ($' (B' m) (B' b)))
-                                                     ($' (B' m) (B' a))
-                                                     ($' (B' m) (B' b))))]))))
+        (#RecordT (list (All' [a] (->' (B' a) ($' (B' m) (B' a))))
+                        (All' [a b] (->' (->' (B' a) ($' (B' m) (B' b)))
+                                         ($' (B' m) (B' a))
+                                         ($' (B' m) (B' b))))))))
+(_lux_declare-tags [#return #bind])
 
 (def''' Maybe/Monad
   ($' Monad Maybe)
-  {#lux;return
+  {#return
    (lambda' return [x]
        (#Some x))
    
-   #lux;bind
+   #bind
    (lambda' [f ma]
        (_lux_case ma
          #None     #None
@@ -1035,12 +1043,12 @@
 
 (def''' Lux/Monad
   ($' Monad Lux)
-  {#lux;return
+  {#return
    (lambda' [x]
        (lambda' [state]
            (#Right [state x])))
    
-   #lux;bind
+   #bind
    (lambda' [f ma]
        (lambda' [state]
            (_lux_case (ma state)
@@ -1073,12 +1081,12 @@
 
 (defmacro (do tokens)
   (_lux_case tokens
-    (#Cons [monad (#Cons [(#Meta [_ (#TupleS bindings)]) (#Cons [body #Nil])])])
+    (#Cons monad (#Cons (#Meta _ (#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"])])
+                                            (#Meta _ (#TagS "" "let"))
                                             (`' (;let' (~ value) (~ body')))
 
                                             _
@@ -1108,11 +1116,11 @@
           #Nil
           (wrap #Nil)
           
-          (#Cons [x xs'])
+          (#Cons x xs')
           (do m
             [y (f x)
              ys (map% m f xs')]
-            (wrap (#Cons [y ys])))
+            (wrap (#Cons y ys)))
           )))
 
 (def''' (. f g)
@@ -1385,6 +1393,10 @@
       (#Cons [[k' v] dict'])
       (#Cons [[k' v'] (put k v dict')]))))
 
+(def''' (->text x)
+  (-> (^ java.lang.Object) Text)
+  (_jvm_invokevirtual "java.lang.Object" "toString" [] x []))
+
 (def''' (get-module-name state)
   ($' Lux Text)
   (_lux_case state
@@ -1405,7 +1417,7 @@
       ($' Maybe Macro))
   (do Maybe/Monad
     [$module (get module modules)
-     gdef (let' [{#module-aliases _ #defs bindings #imports _} (_lux_: ($' Module Compiler) $module)]
+     gdef (let' [{#module-aliases _ #defs bindings #imports _ #tags tags} (_lux_: ($' Module Compiler) $module)]
                 (get name bindings))]
     (_lux_case (_lux_: (, Bool ($' DefData' Macro)) gdef)
       [exported? (#MacroD macro')]
@@ -1432,7 +1444,7 @@
                       #envs   envs   #types   types   #host           host
                       #seed   seed   #eval? eval? #expected expected
                       #cursor cursor}
-                     (#Right [state (find-macro' modules current-module module name)]))))))
+                     (#Right state (find-macro' modules current-module module name)))))))
 
 (def''' (list:join xs)
   (All [a]
@@ -1494,10 +1506,6 @@
                    (as-pairs tokens))]
       (wrap (list (`' (#;RecordT (~ (untemplate-list pairs)))))))))
 
-(def''' (->text x)
-  (-> (^ java.lang.Object) Text)
-  (_jvm_invokevirtual "java.lang.Object" "toString" [] x []))
-
 (def''' (interpose sep xs)
   (All [a]
     (-> a ($' List a) ($' List a)))
@@ -2508,7 +2516,7 @@
                                  (if export?
                                    (list name)
                                    (list)))))
-                          (let [{#module-aliases _ #defs defs #imports _} =module]
+                          (let [{#module-aliases _ #defs defs #imports _ #tags tags} =module]
                             defs))]
         (#Right state (list:join to-alias)))
       
@@ -2721,7 +2729,7 @@
       #None
       #None
 
-      (#Some {#defs defs #module-aliases _ #imports _})
+      (#Some {#defs defs #module-aliases _ #imports _ #tags tags})
       (case (get v-name defs)
         #None
         #None
@@ -2742,7 +2750,7 @@
 ##            #seed   seed   #eval? eval? #expected expected} state]
 ##       (do Maybe/Monad
 ##         [module (get v-prefix modules)
-##          #let [{#defs defs #module-aliases _ #imports _} module]
+##          #let [{#defs defs #module-aliases _ #imports _ #tags tags} module]
 ##          def (get v-name defs)
 ##          #let [[_ def-data] def]]
 ##         (case def-data