aboutsummaryrefslogtreecommitdiff
path: root/source
diff options
context:
space:
mode:
Diffstat (limited to 'source')
-rw-r--r--source/lux.lux1684
1 files changed, 932 insertions, 752 deletions
diff --git a/source/lux.lux b/source/lux.lux
index 34b15fd49..db579f2d8 100644
--- a/source/lux.lux
+++ b/source/lux.lux
@@ -1,4 +1,4 @@
-## Base interfaces & classes
+## First things first, must define functions
(jvm-interface Function
(: apply (-> [java.lang.Object] java.lang.Object)))
@@ -22,938 +22,1118 @@
## (jvm-invokevirtual lux.Function "apply2" [java.lang.Object java.lang.Object]
## this [arg1 arg2]) [arg3]))]))
+
+## 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]))
+
+## (deftype (List a)
+## (| #Nil
+## (#Cons (, a (List a)))))
+(def' List
+ (#AllT [#Nil "List" "a"
+ (#VariantT (#Cons [["lux;Nil" (#TupleT #Nil)]
+ (#Cons [["lux;Cons" (#TupleT (#Cons [(#BoundT "a")
+ (#Cons [(#AppT [(#BoundT "List") (#BoundT "a")])
+ #Nil])]))]
+ #Nil])]))]))
+
+## (deftype #rec Type
+## (| #AnyT
+## #NothingT
+## (#DataT Text)
+## (#TupleT (List Type))
+## (#VariantT (List (, Text Type)))
+## (#RecordT (List (, Text Type)))
+## (#LambdaT (, Type Type))
+## (#BoundT Text)
+## (#VarT Int)
+## (#AllT (, (List (, Text Type)) Text Text Type))
+## (#AppT (, Type Type))))
+(def' Type
+ (case' (#AppT [(#BoundT "Type") (#BoundT "")])
+ Type
+ (case' (#AppT [List (#TupleT (#Cons [Text (#Cons [Type #Nil])]))])
+ TypeEnv
+ (#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;TupleT" (#AppT [List (#AppT [(#BoundT "Type") (#BoundT "")])])]
+ (#Cons [["lux;VariantT" TypeEnv]
+ (#Cons [["lux;RecordT" TypeEnv]
+ (#Cons [["lux;LambdaT" (#TupleT (#Cons [Type (#Cons [Type #Nil])]))]
+ (#Cons [["lux;BoundT" Text]
+ (#Cons [["lux;VarT" Int]
+ (#Cons [["lux;AllT" (#TupleT (#Cons [TypeEnv (#Cons [Text (#Cons [Text (#Cons [Type #Nil])])])]))]
+ (#Cons [["lux;AppT" (#TupleT (#Cons [Type (#Cons [Type #Nil])]))]
+ #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 (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 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 Macro
+## (-> (List Syntax) CompilerState
+## [CompilerState (List Syntax)]))
+(def' Macro
+ (case' (#AppT [List Syntax])
+ SyntaxList
+ (#LambdaT [SyntaxList
+ (#LambdaT [CompilerState
+ (#TupleT (#Cons [CompilerState (#Cons [SyntaxList #Nil])]))])])))
+
## Base functions & macros
+## (def (_meta data)
+## (All [a] (-> a (Meta Cursor a)))
+## (#Meta [["" -1 -1] data]))
(def' _meta
- (lambda' _ data
- (#Meta [["" -1 -1] data])))
+ (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])]))
+## ))))
+## (declare-macro 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])]))
- )))
-(declare-macro let')
+## (def' lambda
+## (check' Macro
+## (lambda' _ tokens
+## (lambda' _ state
+## (let' output (case' tokens
+## (#Cons [(#Meta [_ (#Tuple (#Cons [arg args']))]) (#Cons [body #Nil])])
+## (_meta (#Form (#Cons [(_meta (#Symbol ["" "lambda'"]))
+## (#Cons [(_meta (#Symbol ["" ""]))
+## (#Cons [arg
+## (#Cons [(case' args'
+## #Nil
+## body
-(def' lambda
- (lambda' _ tokens
- (lambda' _ state
- (let' output (case' tokens
- (#Cons [(#Meta [_ (#Tuple (#Cons [arg args']))]) (#Cons [body #Nil])])
- (_meta (#Form (#Cons [(_meta (#Symbol ["" "lambda'"]))
- (#Cons [(_meta (#Symbol ["" ""]))
- (#Cons [arg
- (#Cons [(case' args'
- #Nil
- body
+## _
+## (_meta (#Form (#Cons [(_meta (#Symbol ["lux" "lambda"]))
+## (#Cons [(_meta (#Tuple args'))
+## (#Cons [body #Nil])])]))))
+## #Nil])])])])))
- _
- (_meta (#Form (#Cons [(_meta (#Symbol ["lux" "lambda"]))
- (#Cons [(_meta (#Tuple args'))
- (#Cons [body #Nil])])]))))
- #Nil])])])])))
+## (#Cons [(#Meta [_ (#Symbol self)]) (#Cons [(#Meta [_ (#Tuple (#Cons [arg args']))]) (#Cons [body #Nil])])])
+## (_meta (#Form (#Cons [(_meta (#Symbol ["" "lambda'"]))
+## (#Cons [(_meta (#Symbol self))
+## (#Cons [arg
+## (#Cons [(case' args'
+## #Nil
+## body
- (#Cons [(#Meta [_ (#Symbol self)]) (#Cons [(#Meta [_ (#Tuple (#Cons [arg args']))]) (#Cons [body #Nil])])])
- (_meta (#Form (#Cons [(_meta (#Symbol ["" "lambda'"]))
- (#Cons [(_meta (#Symbol self))
- (#Cons [arg
- (#Cons [(case' args'
- #Nil
- body
+## _
+## (_meta (#Form (#Cons [(_meta (#Symbol ["lux" "lambda"]))
+## (#Cons [(_meta (#Tuple args'))
+## (#Cons [body #Nil])])]))))
+## #Nil])])])]))))
+## (#Right [state (#Cons [output #Nil])]))
+## ))))
+## (declare-macro lambda)
- _
- (_meta (#Form (#Cons [(_meta (#Symbol ["lux" "lambda"]))
- (#Cons [(_meta (#Tuple args'))
- (#Cons [body #Nil])])]))))
- #Nil])])])]))))
- (#Right [state (#Cons [output #Nil])]))
- )))
-(declare-macro lambda)
+## (def' def
+## (check' Macro
+## (lambda [tokens state]
+## (let' output (case' tokens
+## (#Cons [(#Meta [_ (#Symbol name)]) (#Cons [body #Nil])])
+## (_meta (#Form (#Cons [(_meta (#Symbol ["" "def'"])) tokens])))
-(def' def
- (lambda [tokens state]
- (let' output (case' tokens
- (#Cons [(#Meta [_ (#Symbol name)]) (#Cons [body #Nil])])
- (_meta (#Form (#Cons [(_meta (#Symbol ["" "def'"])) tokens])))
+## (#Cons [(#Meta [_ (#Form (#Cons [(#Meta [_ (#Symbol name)]) args]))])
+## (#Cons [body #Nil])])
+## (_meta (#Form (#Cons [(_meta (#Symbol ["" "def'"]))
+## (#Cons [(_meta (#Symbol name))
+## (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["lux" "lambda"]))
+## (#Cons [(_meta (#Symbol name))
+## (#Cons [(_meta (#Tuple args))
+## (#Cons [body #Nil])])])])))
+## #Nil])])]))))
+## (#Right [state (#Cons [output #Nil])])))))
+## (declare-macro def)
- (#Cons [(#Meta [_ (#Form (#Cons [(#Meta [_ (#Symbol name)]) args]))])
- (#Cons [body #Nil])])
- (_meta (#Form (#Cons [(_meta (#Symbol ["" "def'"]))
- (#Cons [(_meta (#Symbol name))
- (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol ["lux" "lambda"]))
- (#Cons [(_meta (#Symbol name))
- (#Cons [(_meta (#Tuple args))
- (#Cons [body #Nil])])])])))
- #Nil])])]))))
- (#Right [state (#Cons [output #Nil])]))))
-(declare-macro def)
+## (def (defmacro tokens state)
+## (let' [fn-name fn-def] (case' tokens
+## (#Cons [(#Meta [_ (#Form (#Cons [(#Meta [_ (#Symbol fn-name)]) args]))])
+## (#Cons [body #Nil])])
+## [fn-name
+## (_meta (#Form (#Cons [(_meta (#Symbol ["lux" "def"]))
+## (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol fn-name)) args])))
+## (#Cons [body
+## #Nil])])])))])
+## (let' declaration (_meta (#Form (#Cons [(_meta (#Symbol ["" "declare-macro"])) (#Cons [(_meta (#Symbol fn-name)) #Nil])])))
+## (#Right [state (#Cons [fn-def (#Cons [declaration #Nil])])]))))
+## (declare-macro defmacro)
-(def (defmacro tokens state)
- (let' [fn-name fn-def] (case' tokens
- (#Cons [(#Meta [_ (#Form (#Cons [(#Meta [_ (#Symbol fn-name)]) args]))])
- (#Cons [body #Nil])])
- [fn-name
- (_meta (#Form (#Cons [(_meta (#Symbol ["lux" "def"]))
- (#Cons [(_meta (#Form (#Cons [(_meta (#Symbol fn-name)) args])))
- (#Cons [body
- #Nil])])])))])
- (let' declaration (_meta (#Form (#Cons [(_meta (#Symbol ["" "declare-macro"])) (#Cons [(_meta (#Symbol fn-name)) #Nil])])))
- (#Right [state (#Cons [fn-def (#Cons [declaration #Nil])])]))))
-(declare-macro defmacro)
+## (defmacro (comment tokens state)
+## (#Right [state #Nil]))
-(defmacro (comment tokens state)
- (#Right [state #Nil]))
+## (def (int+ x y)
+## (jvm-ladd x y))
-(def (int+ x y)
- (jvm-ladd x y))
+## (def (id x)
+## x)
-(def (id x)
- x)
+## (def (print x)
+## (jvm-invokevirtual java.io.PrintStream "print" [java.lang.Object]
+## (jvm-getstatic java.lang.System "out") [x]))
-(def (print x)
- (jvm-invokevirtual java.io.PrintStream "print" [java.lang.Object]
- (jvm-getstatic java.lang.System "out") [x]))
+## (def (println x)
+## (jvm-invokevirtual java.io.PrintStream "println" [java.lang.Object]
+## (jvm-getstatic java.lang.System "out") [x]))
-(def (println x)
- (jvm-invokevirtual java.io.PrintStream "println" [java.lang.Object]
- (jvm-getstatic java.lang.System "out") [x]))
+## (def (fold f init xs)
+## (case' xs
+## #Nil
+## init
-(def (fold f init xs)
- (case' xs
- #Nil
- init
-
- (#Cons [x xs'])
- (fold f (f init x) xs')))
+## (#Cons [x xs'])
+## (fold f (f init x) xs')))
-(def (reverse list)
- (fold (lambda [tail head]
- (#Cons [head tail]))
- #Nil
- list))
+## (def (reverse list)
+## (fold (lambda [tail head]
+## (#Cons [head tail]))
+## #Nil
+## list))
-(defmacro (list xs state)
- (let' xs' (reverse xs)
- (let' output (fold (lambda [tail head]
- (_meta (#Form (#Cons [(_meta (#Tag ["lux" "Cons"]))
- (#Cons [(_meta (#Tuple (#Cons [head (#Cons [tail #Nil])])))
- #Nil])]))))
- (_meta (#Tag ["lux" "Nil"]))
- xs')
- (#Right [state (#Cons [output #Nil])]))))
+## (defmacro (list xs state)
+## (let' xs' (reverse xs)
+## (let' output (fold (lambda [tail head]
+## (_meta (#Form (#Cons [(_meta (#Tag ["lux" "Cons"]))
+## (#Cons [(_meta (#Tuple (#Cons [head (#Cons [tail #Nil])])))
+## #Nil])]))))
+## (_meta (#Tag ["lux" "Nil"]))
+## xs')
+## (#Right [state (#Cons [output #Nil])]))))
-(defmacro (list+ xs state)
- (case' (reverse xs)
- #Nil
- [#Nil state]
+## (defmacro (list+ xs state)
+## (case' (reverse xs)
+## #Nil
+## [#Nil state]
- (#Cons [last init'])
- (let' output (fold (lambda [tail head]
- (_meta (#Form (list (_meta (#Tag ["lux" "Cons"])) (_meta (#Tuple (list head tail)))))))
- last
- init')
- (#Right [state (#Cons [output #Nil])]))))
+## (#Cons [last init'])
+## (let' output (fold (lambda [tail head]
+## (_meta (#Form (list (_meta (#Tag ["lux" "Cons"])) (_meta (#Tuple (list head tail)))))))
+## last
+## init')
+## (#Right [state (#Cons [output #Nil])]))))
-(def (as-pairs xs)
- (case' xs
- (#Cons [x (#Cons [y xs'])])
- (#Cons [[x y] (as-pairs xs')])
+## (def (as-pairs xs)
+## (case' xs
+## (#Cons [x (#Cons [y xs'])])
+## (#Cons [[x y] (as-pairs xs')])
- _
- #Nil))
+## _
+## #Nil))
-(defmacro (let tokens state)
- (case' tokens
- (#Cons [(#Meta [_ (#Tuple bindings)]) (#Cons [body #Nil])])
- (let' output (fold (lambda [body binding]
- (case' binding
- [label value]
- (_meta (#Form (list (_meta (#Symbol ["lux" "let'"])) label value body)))))
- body
- (reverse (as-pairs bindings)))
- (#Right [state (list output)]))))
+## (defmacro (let tokens state)
+## (case' tokens
+## (#Cons [(#Meta [_ (#Tuple bindings)]) (#Cons [body #Nil])])
+## (let' output (fold (lambda [body binding]
+## (case' binding
+## [label value]
+## (_meta (#Form (list (_meta (#Symbol ["lux" "let'"])) label value body)))))
+## body
+## (reverse (as-pairs bindings)))
+## (#Right [state (list output)]))))
+
+## (def (. f g)
+## (lambda [x] (f (g x))))
-(def (. f g)
- (lambda [x] (f (g x))))
+## (def (++ xs ys)
+## (case' xs
+## #Nil
+## ys
-(def (++ xs ys)
- (case' xs
- #Nil
- ys
+## (#Cons [x xs'])
+## (#Cons [x (++ xs' ys)])))
- (#Cons [x xs'])
- (#Cons [x (++ xs' ys)])))
+## (def concat
+## (fold ++ #Nil))
-(def concat
- (fold ++ #Nil))
+## (def (map f xs)
+## (case' xs
+## #Nil
+## #Nil
-(def (map f xs)
- (case' xs
- #Nil
- #Nil
+## (#Cons [x xs'])
+## (#Cons [(f x) (map f xs')])))
- (#Cons [x xs'])
- (#Cons [(f x) (map f xs')])))
+## (def flat-map (. concat map))
-(def flat-map (. concat map))
+## (def (wrap-meta content)
+## (_meta (#Form (list (_meta (#Tag ["lux" "Meta"]))
+## (_meta (#Tuple (list (_meta (#Tuple (list (_meta (#Form (list (_meta (#Tag ["lux" "Text"])) (_meta (#Text "")))))
+## (_meta (#Form (list (_meta (#Tag ["lux" "Int"])) (_meta (#Int -1)))))
+## (_meta (#Form (list (_meta (#Tag ["lux" "Int"])) (_meta (#Int -1))))))))
+## (_meta content))))))))
-(def (wrap-meta content)
- (_meta (#Form (list (_meta (#Tag ["lux" "Meta"]))
- (_meta (#Tuple (list (_meta (#Tuple (list (_meta (#Form (list (_meta (#Tag ["lux" "Text"])) (_meta (#Text "")))))
- (_meta (#Form (list (_meta (#Tag ["lux" "Int"])) (_meta (#Int -1)))))
- (_meta (#Form (list (_meta (#Tag ["lux" "Int"])) (_meta (#Int -1))))))))
- (_meta content))))))))
+## (def (untemplate-list tokens)
+## (case' tokens
+## #Nil
+## (_meta (#Tag ["lux" "Nil"]))
-(def (untemplate-list tokens)
- (case' tokens
- #Nil
- (_meta (#Tag ["lux" "Nil"]))
+## (#Cons [token tokens'])
+## (_meta (#Form (list (_meta (#Tag ["lux" "Cons"]))
+## (_meta (#Tuple (list token (untemplate-list tokens')))))))))
- (#Cons [token tokens'])
- (_meta (#Form (list (_meta (#Tag ["lux" "Cons"]))
- (_meta (#Tuple (list token (untemplate-list tokens')))))))))
+## (def (untemplate token)
+## (case' token
+## (#Meta [_ (#Bool value)])
+## (wrap-meta (#Form (list (_meta (#Tag ["lux" "Bool"])) (_meta (#Bool value)))))
-(def (untemplate token)
- (case' token
- (#Meta [_ (#Bool value)])
- (wrap-meta (#Form (list (_meta (#Tag ["lux" "Bool"])) (_meta (#Bool value)))))
-
- (#Meta [_ (#Int value)])
- (wrap-meta (#Form (list (_meta (#Tag ["lux" "Int"])) (_meta (#Int value)))))
+## (#Meta [_ (#Int value)])
+## (wrap-meta (#Form (list (_meta (#Tag ["lux" "Int"])) (_meta (#Int value)))))
- (#Meta [_ (#Real value)])
- (wrap-meta (#Form (list (_meta (#Tag ["lux" "Real"])) (_meta (#Real value)))))
+## (#Meta [_ (#Real value)])
+## (wrap-meta (#Form (list (_meta (#Tag ["lux" "Real"])) (_meta (#Real value)))))
- (#Meta [_ (#Char value)])
- (wrap-meta (#Form (list (_meta (#Tag ["lux" "Char"])) (_meta (#Char value)))))
+## (#Meta [_ (#Char value)])
+## (wrap-meta (#Form (list (_meta (#Tag ["lux" "Char"])) (_meta (#Char value)))))
- (#Meta [_ (#Text value)])
- (wrap-meta (#Form (list (_meta (#Tag ["lux" "Text"])) (_meta (#Text value)))))
+## (#Meta [_ (#Text value)])
+## (wrap-meta (#Form (list (_meta (#Tag ["lux" "Text"])) (_meta (#Text value)))))
- (#Meta [_ (#Tag [module name])])
- (wrap-meta (#Form (list (_meta (#Tag ["lux" "Tag"])) (_meta (#Tuple (list (_meta (#Text module)) (_meta (#Text name))))))))
+## (#Meta [_ (#Tag [module name])])
+## (wrap-meta (#Form (list (_meta (#Tag ["lux" "Tag"])) (_meta (#Tuple (list (_meta (#Text module)) (_meta (#Text name))))))))
- (#Meta [_ (#Symbol [module name])])
- (wrap-meta (#Form (list (_meta (#Tag ["lux" "Symbol"])) (_meta (#Tuple (list (_meta (#Text module)) (_meta (#Text name))))))))
+## (#Meta [_ (#Symbol [module name])])
+## (wrap-meta (#Form (list (_meta (#Tag ["lux" "Symbol"])) (_meta (#Tuple (list (_meta (#Text module)) (_meta (#Text name))))))))
- (#Meta [_ (#Tuple elems)])
- (wrap-meta (#Form (list (_meta (#Tag ["lux" "Tuple"])) (untemplate-list (map untemplate elems)))))
+## (#Meta [_ (#Tuple elems)])
+## (wrap-meta (#Form (list (_meta (#Tag ["lux" "Tuple"])) (untemplate-list (map untemplate elems)))))
- (#Meta [_ (#Form (#Cons [(#Meta [_ (#Symbol [_ "~"])]) (#Cons [(#Meta [_ unquoted]) #Nil])]))])
- (_meta unquoted)
+## (#Meta [_ (#Form (#Cons [(#Meta [_ (#Symbol [_ "~"])]) (#Cons [(#Meta [_ unquoted]) #Nil])]))])
+## (_meta unquoted)
- (#Meta [_ (#Form elems)])
- (wrap-meta (#Form (list (_meta (#Tag ["lux" "Form"])) (untemplate-list (map untemplate elems)))))
- ))
+## (#Meta [_ (#Form elems)])
+## (wrap-meta (#Form (list (_meta (#Tag ["lux" "Form"])) (untemplate-list (map untemplate elems)))))
+## ))
-(defmacro (` tokens state)
- (case' tokens
- (#Cons [template #Nil])
- (#Right [state (list (untemplate template))])))
+## (defmacro (` tokens state)
+## (case' tokens
+## (#Cons [template #Nil])
+## (#Right [state (list (untemplate template))])))
-(defmacro (if tokens state)
- (case' tokens
- (#Cons [test (#Cons [then (#Cons [else #Nil])])])
- (#Right [state
- (list (` (case' (~ test)
- true (~ then)
- false (~ else))))])))
+## (defmacro (if tokens state)
+## (case' tokens
+## (#Cons [test (#Cons [then (#Cons [else #Nil])])])
+## (#Right [state
+## (list (` (case' (~ test)
+## true (~ then)
+## false (~ else))))])))
-(def (filter p xs)
- (case' xs
- #Nil
- #Nil
+## (def (filter p xs)
+## (case' xs
+## #Nil
+## #Nil
- (#Cons [x xs'])
- (if (p x)
- (#Cons [x (filter p xs')])
- (filter p xs'))))
+## (#Cons [x xs'])
+## (if (p x)
+## (#Cons [x (filter p xs')])
+## (filter p xs'))))
-(def (return val)
- (lambda [state]
- (#Right [state val])))
+## (def (return val)
+## (lambda [state]
+## (#Right [state val])))
-(def (fail msg)
- (lambda [_]
- (#Left msg)))
+## (def (fail msg)
+## (lambda [_]
+## (#Left msg)))
-(def (bind f v)
- (lambda [state]
- (case' (v state)
- (#Right [state' x])
- (f x state')
+## (def (bind f v)
+## (lambda [state]
+## (case' (v state)
+## (#Right [state' x])
+## (f x state')
- (#Left msg)
- (#Left msg))))
+## (#Left msg)
+## (#Left msg))))
-(def (first pair)
- (case' pair
- [f s]
- f))
+## (def (first pair)
+## (case' pair
+## [f s]
+## f))
-(def (second pair)
- (case' pair
- [f s]
- s))
+## (def (second pair)
+## (case' pair
+## [f s]
+## s))
-(defmacro (loop tokens)
- (case' tokens
- (#Cons [bindings (#Cons [body #Nil])])
- (let [pairs (as-pairs bindings)]
- (return (list (#Form (#Cons [(` (lambda (~ (#Symbol ["lux" "recur"])) (~ (#Tuple (map first pairs)))
- (~ body)))
- (map second pairs)])))))))
+## (defmacro (loop tokens)
+## (case' tokens
+## (#Cons [bindings (#Cons [body #Nil])])
+## (let [pairs (as-pairs bindings)]
+## (return (list (#Form (#Cons [(` (lambda (~ (#Symbol ["lux" "recur"])) (~ (#Tuple (map first pairs)))
+## (~ body)))
+## (map second pairs)])))))))
-(defmacro (export tokens)
- (return (map (lambda [t] (` (export' (~ t))))
- tokens)))
+## (defmacro (export tokens)
+## (return (map (lambda [t] (` (export' (~ t))))
+## tokens)))
-(defmacro (and tokens)
- (let [as-if (case' tokens
- #Nil
- (` true)
+## (defmacro (and tokens)
+## (let [as-if (case' tokens
+## #Nil
+## (` true)
- (#Cons [init tests])
- (fold (lambda [prev next]
- (` (if (~ prev) (~ next) false)))
- init
- tokens)
- )]
- (return (list as-if))))
+## (#Cons [init tests])
+## (fold (lambda [prev next]
+## (` (if (~ prev) (~ next) false)))
+## init
+## tokens)
+## )]
+## (return (list as-if))))
-(defmacro (or tokens)
- (let [as-if (case' tokens
- #Nil
- (` false)
+## (defmacro (or tokens)
+## (let [as-if (case' tokens
+## #Nil
+## (` false)
- (#Cons [init tests])
- (fold (lambda [prev next]
- (` (if (~ prev) true (~ next))))
- init
- tokens)
- )]
- (return (list as-if))))
+## (#Cons [init tests])
+## (fold (lambda [prev next]
+## (` (if (~ prev) true (~ next))))
+## init
+## tokens)
+## )]
+## (return (list as-if))))
-(def (not x)
- (case' x
- true false
- false true))
+## (def (not x)
+## (case' x
+## true false
+## false true))
-(defmacro (|> tokens)
- (case' tokens
- (#Cons [init apps])
- (return (list (fold (lambda [acc app]
- (case' app
- (#Form parts)
- (#Form (++ parts (list acc)))
+## (defmacro (|> tokens)
+## (case' tokens
+## (#Cons [init apps])
+## (return (list (fold (lambda [acc app]
+## (case' app
+## (#Form parts)
+## (#Form (++ parts (list acc)))
- _
- (` ((~ app) (~ acc)))))
- init
- apps)))))
+## _
+## (` ((~ app) (~ acc)))))
+## init
+## apps)))))
-(defmacro ($ tokens)
- (case' tokens
- (#Cons [op (#Cons [init args])])
- (return (list (fold (lambda [acc elem]
- (` ((~ op) (~ acc) (~ elem))))
- init
- args)))))
+## (defmacro ($ tokens)
+## (case' tokens
+## (#Cons [op (#Cons [init args])])
+## (return (list (fold (lambda [acc elem]
+## (` ((~ op) (~ acc) (~ elem))))
+## init
+## args)))))
-(def (const x)
- (lambda [_] x))
+## (def (const x)
+## (lambda [_] x))
-(def (int> x y)
- (jvm-lgt x y))
+## (def (int> x y)
+## (jvm-lgt x y))
-(def (int< x y)
- (jvm-llt x y))
+## (def (int< x y)
+## (jvm-llt x y))
-(def inc (int+ 1))
-(def dec (int+ -1))
+## (def inc (int+ 1))
+## (def dec (int+ -1))
-(def (repeat n x)
- (if (int> n 0)
- (#Cons [x (repeat (dec n) x)])
- #Nil))
+## (def (repeat n x)
+## (if (int> n 0)
+## (#Cons [x (repeat (dec n) x)])
+## #Nil))
-(def size
- (fold (lambda [acc _] (inc acc)) 0))
+## (def size
+## (fold (lambda [acc _] (inc acc)) 0))
-(def (last xs)
- (case' xs
- #Nil #None
- (#Cons [x #Nil]) (#Some x)
- (#Cons [_ xs']) (last xs')))
+## (def (last xs)
+## (case' xs
+## #Nil #None
+## (#Cons [x #Nil]) (#Some x)
+## (#Cons [_ xs']) (last xs')))
-(def (init xs)
- (case' xs
- #Nil #None
- (#Cons [_ #Nil]) (#Some #Nil)
- (#Cons [x xs']) (case' (init xs')
- (#Some xs'')
- (#Some (#Cons [x xs'']))
+## (def (init xs)
+## (case' xs
+## #Nil #None
+## (#Cons [_ #Nil]) (#Some #Nil)
+## (#Cons [x xs']) (case' (init xs')
+## (#Some xs'')
+## (#Some (#Cons [x xs'']))
- _
- (#Some (#Cons [x #Nil])))))
+## _
+## (#Some (#Cons [x #Nil])))))
-(defmacro (cond tokens)
- (case' (reverse tokens)
- (#Cons [else branches'])
- (return (list (fold (lambda [else branch]
- (case' branch
- [test then]
- (` (if (~ test) (~ then) (~ else)))))
- else
- (|> branches' reverse as-pairs))))))
+## (defmacro (cond tokens)
+## (case' (reverse tokens)
+## (#Cons [else branches'])
+## (return (list (fold (lambda [else branch]
+## (case' branch
+## [test then]
+## (` (if (~ test) (~ then) (~ else)))))
+## else
+## (|> branches' reverse as-pairs))))))
-(def (interleave xs ys)
- (case' [xs ys]
- [(#Cons [x xs']) (#Cons [y ys'])]
- (list+ x y (interleave xs' ys'))
+## (def (interleave xs ys)
+## (case' [xs ys]
+## [(#Cons [x xs']) (#Cons [y ys'])]
+## (list+ x y (interleave xs' ys'))
- _
- #Nil))
+## _
+## #Nil))
-(def (interpose sep xs)
- (case' xs
- #Nil
- xs
+## (def (interpose sep xs)
+## (case' xs
+## #Nil
+## xs
- (#Cons [x #Nil])
- xs
+## (#Cons [x #Nil])
+## xs
- (#Cons [x xs'])
- (list+ x sep (interpose sep xs'))))
+## (#Cons [x xs'])
+## (list+ x sep (interpose sep xs'))))
-(def (empty? xs)
- (case' xs
- #Nil true
- _ false))
+## (def (empty? xs)
+## (case' xs
+## #Nil true
+## _ false))
-## ## ## (do-template [<name> <op>]
-## ## ## (def (<name> p xs)
-## ## ## (case xs
-## ## ## #Nil true
-## ## ## (#Cons [x xs']) (<op> (p x) (<name> p xs'))))
+## ## ## ## (do-template [<name> <op>]
+## ## ## ## (def (<name> p xs)
+## ## ## ## (case xs
+## ## ## ## #Nil true
+## ## ## ## (#Cons [x xs']) (<op> (p x) (<name> p xs'))))
-## ## ## [every? and]
-## ## ## [any? or])
+## ## ## ## [every? and]
+## ## ## ## [any? or])
-(def (range from to)
- (if (int< from to)
- (#Cons [from (range (inc from) to)])
- #Nil))
+## (def (range from to)
+## (if (int< from to)
+## (#Cons [from (range (inc from) to)])
+## #Nil))
-(def (tuple->list tuple)
- (case' tuple
- (#Meta [_ (#Tuple list)])
- list))
+## (def (tuple->list tuple)
+## (case' tuple
+## (#Meta [_ (#Tuple list)])
+## list))
-(def (zip2 xs ys)
- (case' [xs ys]
- [(#Cons [x xs']) (#Cons [y ys'])]
- (#Cons [[x y] (zip2 xs' ys')])
+## (def (zip2 xs ys)
+## (case' [xs ys]
+## [(#Cons [x xs']) (#Cons [y ys'])]
+## (#Cons [[x y] (zip2 xs' ys')])
- _
- #Nil))
+## _
+## #Nil))
-(def (get key map)
- (case' map
- #Nil
- #None
+## (def (get key map)
+## (case' map
+## #Nil
+## #None
- (#Cons [[k v] map'])
- (if (jvm-invokevirtual java.lang.Object "equals" [java.lang.Object]
- k [key])
- (#Some v)
- (get key map'))))
+## (#Cons [[k v] map'])
+## (if (jvm-invokevirtual java.lang.Object "equals" [java.lang.Object]
+## k [key])
+## (#Some v)
+## (get key map'))))
-(def (get-ident x)
- (case' x
- (#Meta [_ (#Symbol [_ ident])])
- ident))
+## (def (get-ident x)
+## (case' x
+## (#Meta [_ (#Symbol [_ ident])])
+## ident))
-(def (text-++ x y)
- (jvm-invokevirtual java.lang.String "concat" [java.lang.String]
- x [y]))
+## (def (text-++ x y)
+## (jvm-invokevirtual java.lang.String "concat" [java.lang.String]
+## x [y]))
-(def (show-env env)
- (|> env (map first) (interpose ", ") (fold text-++ "")))
+## (def (show-env env)
+## (|> env (map first) (interpose ", ") (fold text-++ "")))
-(def (apply-template env template)
- (case' template
- (#Meta [_ (#Symbol [_ ident])])
- (case' (get ident env)
- (#Some subst)
- subst
+## (def (apply-template env template)
+## (case' template
+## (#Meta [_ (#Symbol [_ ident])])
+## (case' (get ident env)
+## (#Some subst)
+## subst
- _
- template)
+## _
+## template)
- (#Meta [_ (#Tuple elems)])
- (_meta (#Tuple (map (apply-template env) elems)))
+## (#Meta [_ (#Tuple elems)])
+## (_meta (#Tuple (map (apply-template env) elems)))
- (#Meta [_ (#Form elems)])
- (_meta (#Form (map (apply-template env) elems)))
+## (#Meta [_ (#Form elems)])
+## (_meta (#Form (map (apply-template env) elems)))
- (#Meta [_ (#Record members)])
- (_meta (#Record (map (lambda [kv]
- (case' kv
- [slot value]
- [(apply-template env slot) (apply-template env value)]))
- members)))
+## (#Meta [_ (#Record members)])
+## (_meta (#Record (map (lambda [kv]
+## (case' kv
+## [slot value]
+## [(apply-template env slot) (apply-template env value)]))
+## members)))
- _
- template))
+## _
+## template))
-(defmacro (do-template tokens)
- (case' tokens
- (#Cons [bindings (#Cons [template data])])
- (let [bindings-list (map get-ident (tuple->list bindings))
- data-lists (map tuple->list data)
- apply (lambda [env] (apply-template env template))]
- (|> data-lists
- (map (. apply (zip2 bindings-list)))
- return))))
+## (defmacro (do-template tokens)
+## (case' tokens
+## (#Cons [bindings (#Cons [template data])])
+## (let [bindings-list (map get-ident (tuple->list bindings))
+## data-lists (map tuple->list data)
+## apply (lambda [env] (apply-template env template))]
+## (|> data-lists
+## (map (. apply (zip2 bindings-list)))
+## return))))
-## ## ## (do-template [<name> <offset>]
-## ## ## (def <name> (int+ <offset>))
+## ## ## ## (do-template [<name> <offset>]
+## ## ## ## (def <name> (int+ <offset>))
-## ## ## [inc 1]
-## ## ## [dec -1])
+## ## ## ## [inc 1]
+## ## ## ## [dec -1])
-(def (int= x y)
- (jvm-leq x y))
+## (def (int= x y)
+## (jvm-leq x y))
-(def (int% x y)
- (jvm-lrem x y))
+## (def (int% x y)
+## (jvm-lrem x y))
-(def (int>= x y)
- (or (int= x y)
- (int> x y)))
+## (def (int>= x y)
+## (or (int= x y)
+## (int> x y)))
-(do-template [<name> <cmp>]
- (def (<name> x y)
- (if (<cmp> x y)
- x
- y))
+## (do-template [<name> <cmp>]
+## (def (<name> x y)
+## (if (<cmp> x y)
+## x
+## y))
- [max int>]
- [min int<])
+## [max int>]
+## [min int<])
-(do-template [<name> <cmp>]
- (def (<name> n) (<cmp> n 0))
+## (do-template [<name> <cmp>]
+## (def (<name> n) (<cmp> n 0))
- [neg? int<]
- [pos? int>=])
+## [neg? int<]
+## [pos? int>=])
-(def (even? n)
- (int= 0 (int% n 0)))
+## (def (even? n)
+## (int= 0 (int% n 0)))
-(def (odd? n)
- (not (even? n)))
+## (def (odd? n)
+## (not (even? n)))
-(do-template [<name> <done> <step>]
- (def (<name> n xs)
- (if (int> n 0)
- (case' xs
- #Nil #Nil
- (#Cons [x xs']) <step>)
- <done>))
+## (do-template [<name> <done> <step>]
+## (def (<name> n xs)
+## (if (int> n 0)
+## (case' xs
+## #Nil #Nil
+## (#Cons [x xs']) <step>)
+## <done>))
- [take #Nil (list+ x (take (dec n) xs'))]
- [drop xs (drop (dec n) xs')])
+## [take #Nil (list+ x (take (dec n) xs'))]
+## [drop xs (drop (dec n) xs')])
-(do-template [<name> <done> <step>]
- (def (<name> f xs)
- (case' xs
- #Nil #Nil
- (#Cons [x xs']) (if (f x) <step> #Nil)))
+## (do-template [<name> <done> <step>]
+## (def (<name> f xs)
+## (case' xs
+## #Nil #Nil
+## (#Cons [x xs']) (if (f x) <step> #Nil)))
- [take-while #Nil (list+ x (take-while f xs'))]
- [drop-while xs (drop-while f xs')])
+## [take-while #Nil (list+ x (take-while f xs'))]
+## [drop-while xs (drop-while f xs')])
-(defmacro (get@ tokens)
- (let [output (case' tokens
- (#Cons [tag (#Cons [record #Nil])])
- (` (get@' (~ tag) (~ record)))
+## (defmacro (get@ tokens)
+## (let [output (case' tokens
+## (#Cons [tag (#Cons [record #Nil])])
+## (` (get@' (~ tag) (~ record)))
- (#Cons [tag #Nil])
- (` (lambda [record] (get@' (~ tag) record))))]
- (return (list output))))
+## (#Cons [tag #Nil])
+## (` (lambda [record] (get@' (~ tag) record))))]
+## (return (list output))))
-(defmacro (set@ tokens)
- (let [output (case' tokens
- (#Cons [tag (#Cons [value (#Cons [record #Nil])])])
- (` (set@' (~ tag) (~ value) (~ record)))
+## (defmacro (set@ tokens)
+## (let [output (case' tokens
+## (#Cons [tag (#Cons [value (#Cons [record #Nil])])])
+## (` (set@' (~ tag) (~ value) (~ record)))
- (#Cons [tag (#Cons [value #Nil])])
- (` (lambda [record] (set@' (~ tag) (~ value) record)))
+## (#Cons [tag (#Cons [value #Nil])])
+## (` (lambda [record] (set@' (~ tag) (~ value) record)))
- (#Cons [tag #Nil])
- (` (lambda [value record] (set@' (~ tag) value record))))]
- (return (list output))))
+## (#Cons [tag #Nil])
+## (` (lambda [value record] (set@' (~ tag) value record))))]
+## (return (list output))))
-(defmacro (update@ tokens)
- (let [output (case' tokens
- (#Cons [tag (#Cons [func (#Cons [record #Nil])])])
- (` (let [_record_ (~ record)]
- (set@' (~ tag) ((~ func) (get@' (~ tag) _record_)) _record_)))
+## (defmacro (update@ tokens)
+## (let [output (case' tokens
+## (#Cons [tag (#Cons [func (#Cons [record #Nil])])])
+## (` (let [_record_ (~ record)]
+## (set@' (~ tag) ((~ func) (get@' (~ tag) _record_)) _record_)))
- (#Cons [tag (#Cons [func #Nil])])
- (` (lambda [record]
- (` (set@' (~ tag) ((~ func) (get@' (~ tag) record)) record))))
+## (#Cons [tag (#Cons [func #Nil])])
+## (` (lambda [record]
+## (` (set@' (~ tag) ((~ func) (get@' (~ tag) record)) record))))
- (#Cons [tag #Nil])
- (` (lambda [func record]
- (set@' (~ tag) (func (get@' (~ tag) record)) record))))]
- (return (list output))))
+## (#Cons [tag #Nil])
+## (` (lambda [func record]
+## (set@' (~ tag) (func (get@' (~ tag) record)) record))))]
+## (return (list output))))
-(def (show-int int)
- (jvm-invokevirtual java.lang.Object "toString" []
- int []))
+## (def (show-int int)
+## (jvm-invokevirtual java.lang.Object "toString" []
+## int []))
-## (def gensym
-## (lambda [state]
-## [(update@ #gen-seed inc state)
-## (#Symbol ($ text-++ "__" (show-int (get@ #gen-seed state)) "__"))]))
+## ## (def gensym
+## ## (lambda [state]
+## ## [(update@ #gen-seed inc state)
+## ## (#Symbol ($ text-++ "__" (show-int (get@ #gen-seed state)) "__"))]))
-## (do-template [<name> <member>]
-## (def (<name> pair)
-## (case' pair
-## [f s]
-## <member>))
+## ## (do-template [<name> <member>]
+## ## (def (<name> pair)
+## ## (case' pair
+## ## [f s]
+## ## <member>))
-## [first f]
-## [second s])
+## ## [first f]
+## ## [second s])
-(def (show-syntax syntax)
- (case' syntax
- (#Meta [_ (#Bool value)])
- (jvm-invokevirtual java.lang.Object "toString" []
- value [])
+## (def (show-syntax syntax)
+## (case' syntax
+## (#Meta [_ (#Bool value)])
+## (jvm-invokevirtual java.lang.Object "toString" []
+## value [])
- (#Meta [_ (#Int value)])
- (jvm-invokevirtual java.lang.Object "toString" []
- value [])
+## (#Meta [_ (#Int value)])
+## (jvm-invokevirtual java.lang.Object "toString" []
+## value [])
- (#Meta [_ (#Real value)])
- (jvm-invokevirtual java.lang.Object "toString" []
- value [])
+## (#Meta [_ (#Real value)])
+## (jvm-invokevirtual java.lang.Object "toString" []
+## value [])
- (#Meta [_ (#Char value)])
- (jvm-invokevirtual java.lang.Object "toString" []
- value [])
+## (#Meta [_ (#Char value)])
+## (jvm-invokevirtual java.lang.Object "toString" []
+## value [])
- (#Meta [_ (#Text value)])
- (jvm-invokevirtual java.lang.Object "toString" []
- value [])
+## (#Meta [_ (#Text value)])
+## (jvm-invokevirtual java.lang.Object "toString" []
+## value [])
- (#Meta [_ (#Symbol [module name])])
- ($ text-++ module ";" name)
+## (#Meta [_ (#Symbol [module name])])
+## ($ text-++ module ";" name)
- (#Meta [_ (#Tag [module name])])
- ($ text-++ "#" module ";" name)
+## (#Meta [_ (#Tag [module name])])
+## ($ text-++ "#" module ";" name)
- (#Meta [_ (#Tuple members)])
- ($ text-++ "[" (fold text-++ "" (interpose " " (map show-syntax members))) "]")
+## (#Meta [_ (#Tuple members)])
+## ($ text-++ "[" (fold text-++ "" (interpose " " (map show-syntax members))) "]")
- (#Meta [_ (#Form members)])
- ($ text-++ "(" (fold text-++ "" (interpose " " (map show-syntax members))) ")")
- ))
+## (#Meta [_ (#Form members)])
+## ($ text-++ "(" (fold text-++ "" (interpose " " (map show-syntax members))) ")")
+## ))
-(defmacro (do tokens)
- (case' tokens
- (#Cons [(#Meta [_ (#Tuple bindings)]) (#Cons [body #Nil])])
- (let [output (fold (lambda [body binding]
- (case' binding
- [lhs rhs]
- (` (bind (lambda [(~ lhs)] (~ body))
- (~ rhs)))))
- body
- (reverse (as-pairs bindings)))]
- (return (list output)))))
+## (defmacro (do tokens)
+## (case' tokens
+## (#Cons [(#Meta [_ (#Tuple bindings)]) (#Cons [body #Nil])])
+## (let [output (fold (lambda [body binding]
+## (case' binding
+## [lhs rhs]
+## (` (bind (lambda [(~ lhs)] (~ body))
+## (~ rhs)))))
+## body
+## (reverse (as-pairs bindings)))]
+## (return (list output)))))
-(def (map% f xs)
- (case' xs
- #Nil
- (return xs)
+## (def (map% f xs)
+## (case' xs
+## #Nil
+## (return xs)
- (#Cons [x xs'])
- (do [y (f x)
- ys (map% f xs')]
- (return (#Cons [y ys])))))
+## (#Cons [x xs'])
+## (do [y (f x)
+## ys (map% f xs')]
+## (return (#Cons [y ys])))))
-(defmacro ($keys tokens)
- (case' tokens
- (#Cons [(#Meta [_ (#Tuple fields)]) #Nil])
- (return (list (_meta (#Record (map (lambda [slot]
- (case' slot
- (#Meta [_ (#Tag [module name])])
- [($ text-++ module ";" name) (_meta (#Symbol [module name]))]))
- fields)))))))
+## (defmacro ($keys tokens)
+## (case' tokens
+## (#Cons [(#Meta [_ (#Tuple fields)]) #Nil])
+## (return (list (_meta (#Record (map (lambda [slot]
+## (case' slot
+## (#Meta [_ (#Tag [module name])])
+## [($ text-++ module ";" name) (_meta (#Symbol [module name]))]))
+## fields)))))))
-(defmacro ($or tokens)
- (case' tokens
- (#Cons [(#Meta [_ (#Tuple patterns)]) (#Cons [body #Nil])])
- (return (flat-map (lambda [pattern] (list pattern body))
- patterns))))
+## (defmacro ($or tokens)
+## (case' tokens
+## (#Cons [(#Meta [_ (#Tuple patterns)]) (#Cons [body #Nil])])
+## (return (flat-map (lambda [pattern] (list pattern body))
+## patterns))))
-(def null jvm-null)
+## (def null jvm-null)
-(defmacro (^ tokens)
- (case' tokens
- (#Cons [(#Meta [_ (#Symbol [_ class-name])]) #Nil])
- (return (list (` (#TData [(~ (_meta (#Text class-name))) (list)]))))
+## (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 (` (#TData [(~ (_meta (#Text class-name))) (~ (untemplate-list params))]))))))
+## (#Cons [(#Meta [_ (#Symbol [_ class-name])]) (#Cons [(#Meta [_ (#Tuple params)]) #Nil])])
+## (return (list (` (#DataT [(~ (_meta (#Text class-name))) (~ (untemplate-list params))]))))))
-(defmacro (, members)
- (return (list (_meta (#Form (list+ (_meta (#Tag ["lux" "TTuple"])) (untemplate-list members)))))))
+## (defmacro (, members)
+## (return (list (_meta (#Form (list+ (_meta (#Tag ["lux" "TupleT"])) (untemplate-list members)))))))
-(defmacro (| members)
- (let [members' (map (lambda [m]
- (case' m
- (#Meta [_ (#Tag [module name])])
- [($ text-++ module ";" name) (` (#Tuple (list)))]
+## (defmacro (| members)
+## (let [members' (map (lambda [m]
+## (case' m
+## (#Meta [_ (#Tag [module name])])
+## [($ text-++ module ";" name) (` (#Tuple (list)))]
- (#Meta [_ (#Form (#Cons [(#Meta [_ (#Tag [module name])]) (#Cons [value #Nil])]))])
- [($ text-++ module ";" name) (` (#Tuple (~ value)))]))
- members)]
- (return (list (_meta (#Form (list+ (_meta (#Tag ["lux" "TVariant"])) (untemplate-list members))))))))
+## (#Meta [_ (#Form (#Cons [(#Meta [_ (#Tag [module name])]) (#Cons [value #Nil])]))])
+## [($ text-++ module ";" name) (` (#Tuple (~ value)))]))
+## members)]
+## (return (list (_meta (#Form (list+ (_meta (#Tag ["lux" "VariantT"])) (untemplate-list members))))))))
-(defmacro (& members)
- (let [members' (map (lambda [m]
- (case' m
- (#Meta [_ (#Form (#Cons [(#Meta [_ (#Tag [module name])]) (#Cons [value #Nil])]))])
- [($ text-++ module ";" name) (` (#Tuple (~ value)))]))
- members)]
- (return (list (_meta (#Form (list+ (_meta (#Tag ["lux" "TRecord"])) (untemplate-list members))))))))
+## (defmacro (& members)
+## (let [members' (map (lambda [m]
+## (case' m
+## (#Meta [_ (#Form (#Cons [(#Meta [_ (#Tag [module name])]) (#Cons [value #Nil])]))])
+## [($ text-++ module ";" name) (` (#Tuple (~ value)))]))
+## members)]
+## (return (list (_meta (#Form (list+ (_meta (#Tag ["lux" "RecordT"])) (untemplate-list members))))))))
-(defmacro (-> tokens)
- (case' (reverse tokens)
- (#Cons [f-return f-args])
- (fold (lambda [f-return f-arg]
- (` (#TLambda [(~ f-arg) (~ f-return)])))
- f-return
- f-args)))
+## (defmacro (-> tokens)
+## (case' (reverse tokens)
+## (#Cons [f-return f-args])
+## (fold (lambda [f-return f-arg]
+## (` (#LambdaT [(~ f-arg) (~ f-return)])))
+## f-return
+## f-args)))
-(def (text= x y)
- (jvm-invokevirtual java.lang.Object "equals" [java.lang.Object]
- x [y]))
+## (def (text= x y)
+## (jvm-invokevirtual java.lang.Object "equals" [java.lang.Object]
+## x [y]))
-(def (replace-ident ident value syntax)
- (let [[module name] ident]
- (case' syntax
- (#Meta [_ (#Symbol [?module ?name])])
- (if (and (text= module ?module)
- (text= name ?name))
- value
- syntax)
+## (def (replace-ident ident value syntax)
+## (let [[module name] ident]
+## (case' syntax
+## (#Meta [_ (#Symbol [?module ?name])])
+## (if (and (text= module ?module)
+## (text= name ?name))
+## value
+## syntax)
- (#Meta [_ (#Form members)])
- (_meta (#Form (map (replace-ident ident value) members)))
+## (#Meta [_ (#Form members)])
+## (_meta (#Form (map (replace-ident ident value) members)))
- (#Meta [_ (#Tuple members)])
- (_meta (#Tuple (map (replace-ident ident value) members)))
+## (#Meta [_ (#Tuple members)])
+## (_meta (#Tuple (map (replace-ident ident value) members)))
- (#Meta [_ (#Record members)])
- (_meta (#Record (map (lambda [kv]
- (case' kv
- [k v]
- [k (replace-ident ident value v)]))
- members)))
+## (#Meta [_ (#Record members)])
+## (_meta (#Record (map (lambda [kv]
+## (case' kv
+## [k v]
+## [k (replace-ident ident value v)]))
+## members)))
- _
- syntax)))
+## _
+## syntax)))
-(defmacro (All tokens)
- (let [[name args body] (case' tokens
- (#Cons [(#Meta [_ (#Symbol [_ name])]) (#Cons [(#Meta [_ (#Tuple args)]) (#Cons [body #Nil])])])
- [name args body]
+## (defmacro (All tokens)
+## (let [[name args body] (case' tokens
+## (#Cons [(#Meta [_ (#Symbol [_ name])]) (#Cons [(#Meta [_ (#Tuple args)]) (#Cons [body #Nil])])])
+## [name args body]
- (#Cons [(#Meta [_ (#Tuple args)]) (#Cons [body #Nil])])
- ["" args body])
- rolled (fold (lambda [body arg]
- (case' arg
- (#Meta [_ (#Symbol [arg-module arg-name])])
- (` (#TAll (list) "" (~ (_meta (#Text arg-name))) (~ (replace-ident [arg-module arg-name]
- (` (#TBound (~ (#Text arg-name))))
- body))))))
- body
- args)]
- (case' rolled
- (#Meta [_ (#Form (#Cons [(#Meta [_ (#Tag ["lux" "TAll"])]) (#Cons [env (#Cons [(#Meta [_ (#Text "")]) (#Cons [(#Meta [_ (#Text arg-name)]) (#Cons [body #Nil])])])])]))])
- (return (list (` (#TAll (~ env) (~ (#Text name)) (~ (#Text arg-name))
- (~ (replace-ident arg-name (` (#TBound (~ (#Text name))))
- body)))))))))
+## (#Cons [(#Meta [_ (#Tuple args)]) (#Cons [body #Nil])])
+## ["" args body])
+## rolled (fold (lambda [body arg]
+## (case' arg
+## (#Meta [_ (#Symbol [arg-module arg-name])])
+## (` (#AllT (list) "" (~ (_meta (#Text arg-name))) (~ (replace-ident [arg-module arg-name]
+## (` (#BoundT (~ (#Text arg-name))))
+## body))))))
+## body
+## args)]
+## (case' rolled
+## (#Meta [_ (#Form (#Cons [(#Meta [_ (#Tag ["lux" "AllT"])]) (#Cons [env (#Cons [(#Meta [_ (#Text "")]) (#Cons [(#Meta [_ (#Text arg-name)]) (#Cons [body #Nil])])])])]))])
+## (return (list (` (#AllT (~ env) (~ (#Text name)) (~ (#Text arg-name))
+## (~ (replace-ident arg-name (` (#BoundT (~ (#Text name))))
+## body)))))))))
-(defmacro (Exists tokens)
- (case' tokens
- (#Cons [args (#Cons [body #Nil])])
- (return (list (` (All (~ args) (~ body)))))))
+## (defmacro (Exists tokens)
+## (case' tokens
+## (#Cons [args (#Cons [body #Nil])])
+## (return (list (` (All (~ args) (~ body)))))))
-(def Any #TAny)
-(def Nothing #TNothing)
-(def Bool (^ java.lang.Boolean))
-(def Int (^ java.lang.Long))
-(def Real (^ java.lang.Double))
-(def Char (^ java.lang.Character))
-(def Text (^ java.lang.String))
+## (def Any #AnyT)
+## (def Nothing #NothingT)
+## (def Bool (^ java.lang.Boolean))
+## (def Int (^ java.lang.Long))
+## (def Real (^ java.lang.Double))
+## (def Char (^ java.lang.Character))
+## (def Text (^ java.lang.String))
-## (deftype (List a)
-## (| #Nil
-## (#Cons (, a (List a)))))
+## ## (deftype (List a)
+## ## (| #Nil
+## ## (#Cons (, a (List a)))))
-## (deftype #rec Type
-## (| #TAny
-## #TNothing
-## (#TData Text)
-## (#TTuple (List Type))
-## (#TVariant (List (, Text Type)))
-## (#TRecord (List (, Text Type)))
-## (#TLambda (, Type Type))
-## (#TBound Text)
-## (#TVar Int)
-## (#TAll (, (List (, Text Type)) Text Text Type))
-## (#TApp (, Type Type))))
+## ## (deftype #rec Type
+## ## (| #AnyT
+## ## #NothingT
+## ## (#DataT Text)
+## ## (#TupleT (List Type))
+## ## (#VariantT (List (, Text Type)))
+## ## (#RecordT (List (, Text Type)))
+## ## (#LambdaT (, Type Type))
+## ## (#BoundT Text)
+## ## (#VarT Int)
+## ## (#AllT (, (List (, Text Type)) Text Text Type))
+## ## (#AppT (, Type Type))))
-## (deftype (Either l r)
-## (| (#Left l)
-## (#Right r)))
+## ## (deftype (Either l r)
+## ## (| (#Left l)
+## ## (#Right r)))
-## (deftype #rec Syntax
-## (| (#Bool Bool)
-## (#Int Int)
-## (#Real Real)
-## (#Char Char)
-## (#Text Text)
-## (#Form (List Syntax))
-## (#Tuple (List Syntax))
-## (#Record (List (, Text Syntax)))))
+## ## (deftype #rec Syntax
+## ## (| (#Bool Bool)
+## ## (#Int Int)
+## ## (#Real Real)
+## ## (#Char Char)
+## ## (#Text Text)
+## ## (#Form (List Syntax))
+## ## (#Tuple (List Syntax))
+## ## (#Record (List (, Text Syntax)))))
-## (deftype Macro
-## (-> (List Syntax) CompilerState
-## (Either Text (, CompilerState (List Syntax)))))
+## ## (deftype Macro
+## ## (-> (List Syntax) CompilerState
+## ## (Either Text (, CompilerState (List Syntax)))))
-## (def (macro-expand syntax)
-## (case' syntax
-## (#Form (#Cons [(#Symbol macro-name) args]))
-## (do [macro (get-macro macro-name)]
-## ((coerce macro Macro) args))))
+## ## (def (macro-expand syntax)
+## ## (case' syntax
+## ## (#Form (#Cons [(#Symbol macro-name) args]))
+## ## (do [macro (get-macro macro-name)]
+## ## ((coerce macro Macro) args))))
-## (defmacro (case tokens)
-## (case' tokens
-## (#Cons value branches)
-## (loop [kind #Pattern
-## pieces branches
-## new-pieces (list)]
-## (case' pieces
-## #Nil
-## (return (list (' (case' (~ value) (~@ new-pieces)))))
+## ## (defmacro (case tokens)
+## ## (case' tokens
+## ## (#Cons value branches)
+## ## (loop [kind #Pattern
+## ## pieces branches
+## ## new-pieces (list)]
+## ## (case' pieces
+## ## #Nil
+## ## (return (list (' (case' (~ value) (~@ new-pieces)))))
-## (#Cons piece pieces')
-## (let [[kind' expanded more-pieces] (case' kind
-## #Body
-## [#Pattern (list piece) #Nil]
+## ## (#Cons piece pieces')
+## ## (let [[kind' expanded more-pieces] (case' kind
+## ## #Body
+## ## [#Pattern (list piece) #Nil]
-## #Pattern
-## (do [expansion (macro-expand piece)]
-## (case' expansion
-## #Nil
-## [#Pattern #Nil #Nil]
+## ## #Pattern
+## ## (do [expansion (macro-expand piece)]
+## ## (case' expansion
+## ## #Nil
+## ## [#Pattern #Nil #Nil]
-## (#Cons exp #Nil)
-## [#Body (list exp) #Nil]
+## ## (#Cons exp #Nil)
+## ## [#Body (list exp) #Nil]
-## (#Cons exp exps)
-## [#Body (list exp) exps]))
-## )]
-## (recur kind' (++ expanded new-pieces) (++ more-pieces pieces))))
-## )))
+## ## (#Cons exp exps)
+## ## [#Body (list exp) exps]))
+## ## )]
+## ## (recur kind' (++ expanded new-pieces) (++ more-pieces pieces))))
+## ## )))
-## (def (defsyntax tokens)
-## ...)
+## ## (def (defsyntax tokens)
+## ## ...)
-## (deftype (State s a)
-## (-> s (, s a)))
+## ## (deftype (State s a)
+## ## (-> s (, s a)))
-## (deftype (Parser a)
-## (State (List Syntax) a))
+## ## (deftype (Parser a)
+## ## (State (List Syntax) a))
-## (def (parse-ctor tokens)
-## (Parser (, Syntax (List Syntax)))
-## (case tokens
-## (list+ (#Symbol name) tokens')
-## [tokens' [(#Symbol name) (list)]]
+## ## (def (parse-ctor tokens)
+## ## (Parser (, Syntax (List Syntax)))
+## ## (case tokens
+## ## (list+ (#Symbol name) tokens')
+## ## [tokens' [(#Symbol name) (list)]]
-## (list+ (#Form (list+ (#Symbol name) args)) tokens')
-## [tokens' [(#Symbol name) args]]))
+## ## (list+ (#Form (list+ (#Symbol name) args)) tokens')
+## ## [tokens' [(#Symbol name) args]]))
-## (defsyntax (defsig
-## [[name args] parse-ctor]
-## [anns ($+ $1)])
-## (let [def-body (fold (lambda [body arg] (` (lambda [(~ arg)] (~ body))))
-## (` (#Record (~ (untemplate-list ...))))
-## args)]
-## (return (list (` (def (~ name) (~ def-body)))))))
+## ## (defsyntax (defsig
+## ## [[name args] parse-ctor]
+## ## [anns ($+ $1)])
+## ## (let [def-body (fold (lambda [body arg] (` (lambda [(~ arg)] (~ body))))
+## ## (` (#Record (~ (untemplate-list ...))))
+## ## args)]
+## ## (return (list (` (def (~ name) (~ def-body)))))))
-## (defsyntax (defstruct
-## [[name args] parse-ctor]
-## signature
-## [defs ($+ $1)])
-## (let [def-body (fold (lambda [body arg] (` (lambda [(~ arg)] (~ body))))
-## (` (#Record (~ (untemplate-list ...))))
-## args)]
-## (return (list (` (def (~ name)
-## (: (~ def-body) (~ signature))))))))
+## ## (defsyntax (defstruct
+## ## [[name args] parse-ctor]
+## ## signature
+## ## [defs ($+ $1)])
+## ## (let [def-body (fold (lambda [body arg] (` (lambda [(~ arg)] (~ body))))
+## ## (` (#Record (~ (untemplate-list ...))))
+## ## args)]
+## ## (return (list (` (def (~ name)
+## ## (: (~ def-body) (~ signature))))))))
-## (defsig (Monad m)
-## (: return (All [a] (-> a (m a))))
-## (: bind (All [a b] (-> (-> a (m b)) (m a) (m b)))))
+## ## (defsig (Monad m)
+## ## (: return (All [a] (-> a (m a))))
+## ## (: bind (All [a b] (-> (-> a (m b)) (m a) (m b)))))
-## (defstruct ListMonad (Monad List)
-## (def (return x)
-## (list x))
+## ## (defstruct ListMonad (Monad List)
+## ## (def (return x)
+## ## (list x))
-## (def bind (. concat map)))
+## ## (def bind (. concat map)))
-## (defsig (Eq a)
-## (: = (-> a a Bool)))
+## ## (defsig (Eq a)
+## ## (: = (-> a a Bool)))
-## (defstruct (List_Eq A_Eq)
-## (All [a] (-> (Eq a) (Eq (List a))))
+## ## (defstruct (List_Eq A_Eq)
+## ## (All [a] (-> (Eq a) (Eq (List a))))
-## (def (= xs ys)
-## (and (= (length xs) (length ys))
-## (map (lambda [[x y]]
-## (with A_Eq
-## (= x y)))
-## (zip2 xs ys)))))
+## ## (def (= xs ys)
+## ## (and (= (length xs) (length ys))
+## ## (map (lambda [[x y]]
+## ## (with A_Eq
+## ## (= x y)))
+## ## (zip2 xs ys)))))
-## (def (with tokens)
-## ...)
+## ## (def (with tokens)
+## ## ...)
-## TODO: Full pattern-matching
-## TODO: Type-related macros
-## TODO: (Im|Ex)ports-related macros
-## TODO: Macro-related macros
+## ## TODO: Full pattern-matching
+## ## TODO: Type-related macros
+## ## TODO: (Im|Ex)ports-related macros
+## ## TODO: Macro-related macros
-## (import "lux")
-## (module-alias "lux" "l")
-## (def-alias "lux;map" "map")
+## ## (import "lux")
+## ## (module-alias "lux" "l")
+## ## (def-alias "lux;map" "map")
-## (def (require tokens)
-## (case tokens
-## ...))
+## ## (def (require tokens)
+## ## (case tokens
+## ## ...))
-## (require lux #as l #refer [map])
+## ## (require lux #as l #refer [map])
generated by cgit v1.3.1 (git 2.54.0) at 2026-08-30 12:57:58 +0000