aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorEduardo Julian2015-03-08 04:42:09 -0400
committerEduardo Julian2015-03-08 04:42:09 -0400
commit33f318849c0702b254eccf79f6ef9b7015e4537b (patch)
tree5ddfa65cb22db5771200610f3ce1d29a78b2b3a6
parent9b0c07dbf78bbdb6e13fbbd44e02fe322d9f145c (diff)
- In lux.lux, fixed a bug in the "list" macro that rendered it unusable.
- Fixed a bug when compiling lambda instantiation (the bug had to do with compiling the env variables passed to the closure). - Fixed a bug in the lexer wherein the backquote (`) wasn't being recognized.
-rw-r--r--source/lux.lux770
-rw-r--r--src/lux/compiler/lambda.clj4
-rw-r--r--src/lux/lexer.clj2
-rw-r--r--src/lux/macro.clj4
4 files changed, 390 insertions, 390 deletions
diff --git a/source/lux.lux b/source/lux.lux
index 7cafb2977..8aefa309a 100644
--- a/source/lux.lux
+++ b/source/lux.lux
@@ -100,9 +100,6 @@
(jvm-invokevirtual java.io.PrintStream "println" [java.lang.Object]
(jvm-getstatic java.lang.System "out") [x]))
-#(
-
-
(def (fold f init xs)
(case' xs
#Nil
@@ -117,32 +114,28 @@
#Nil
list))
-(def (list xs state)
+(defmacro (list xs state)
(let' xs' (reverse xs)
(let' output (fold (lambda [tail head]
(#Form (#Cons [(#Tag "Cons")
- (#Cons [(#Tuple (#Cons [head
- (#Cons [(#Form (#Cons [(#Tag "Cons")
- (#Cons [(#Tuple (#Cons [tail
- (#Cons [(#Tag "Nil") #Nil])])) #Nil])])) #Nil])])) #Nil])])))
+ (#Cons [(#Tuple (#Cons [head (#Cons [tail #Nil])]))
+ #Nil])])))
(#Tag "Nil")
- xs')
+ xs'
+ )
[(#Cons [output #Nil]) state])))
-(declare-macro list)
-(def (list+ xs state)
+(defmacro (list+ xs state)
(case' (reverse xs)
#Nil
[#Nil state]
(#Cons [last init'])
(let' output (fold (lambda [tail head]
- ## (#Form (list (#Tag "Cons") (#Tuple (list head tail))))
- (#Form (#Cons [(#Tag "Cons") (#Cons [(#Tuple (#Cons [head (#Cons [tail #Nil])])) #Nil])])))
+ (#Form (list (#Tag "Cons") (#Tuple (list head tail)))))
last
init')
[(#Cons [output #Nil]) state])))
-(declare-macro list+)
(def (as-pairs xs)
(case' xs
@@ -152,17 +145,16 @@
_
#Nil))
-(def (let tokens state)
- (case' tokens
- (#Cons [(#Tuple bindings) (#Cons [body #Nil])])
- (let' output (fold (lambda [body binding]
- (case' binding
- [label value]
- (#Form (list (#Ident "let'") label value body))))
- body
- (reverse (as-pairs bindings)))
- [(list output) state])))
-(declare-macro let)
+## (defmacro (let tokens state)
+## (case' tokens
+## (#Cons [(#Tuple bindings) (#Cons [body #Nil])])
+## (let' output (fold (lambda [body binding]
+## (case' binding
+## [label value]
+## (#Form (list (#Ident "lux;let'") label value body))))
+## body
+## (reverse (as-pairs bindings)))
+## [(list output) state])))
(def (++ xs ys)
(case' xs
@@ -180,66 +172,70 @@
(#Cons [x xs*])
(#Cons [(f x) (map f xs*)])))
-(def (filter p xs)
- (case' xs
- #Nil
+(def (untemplate-list tokens)
+ (case' tokens
#Nil
+ (#Tag "Nil")
- (#Cons [x xs*])
- (if (p x)
- (filter p xs*)
- (#Cons [x (filter p xs*)]))))
-)#
+ (#Cons [token tokens'])
+ (#Form (#Cons [(#Tag "Cons")
+ (#Cons [(#Tuple (#Cons [token (#Cons [(untemplate-list tokens') #Nil])]))
+ #Nil])]))))
-#((def (untemplate-list untemplate tokens)
- (case tokens
- #Nil
- (#Tag "Nil")
+(def (untemplate token)
+ (case' token
+ (#Bool value)
+ (#Form (list (#Tag "Bool") (#Bool value)))
- (#Cons [token tokens'])
- (#Form (list (#Tag "Cons") (untemplate token) (untemplate-list untemplate tokens')))))
+ (#Int value)
+ (#Form (list (#Tag "Int") (#Int value)))
-(def (untemplate token)
- (case token
- (#Bool elem)
- (#Form (list (#Tag "Bool") (#Bool elem)))
+ (#Real value)
+ (#Form (list (#Tag "Real") (#Real value)))
- (#Int elem)
- (#Form (list (#Tag "Int") (#Int elem)))
+ (#Char value)
+ (#Form (list (#Tag "Char") (#Char value)))
- (#Real elem)
- (#Form (list (#Tag "Real") (#Real elem)))
+ (#Text value)
+ (#Form (list (#Tag "Text") (#Text value)))
- (#Char elem)
- (#Form (list (#Tag "Char") (#Char elem)))
+ (#Tag value)
+ (#Form (list (#Tag "Tag") (#Text value)))
- (#Text elem)
- (#Form (list (#Tag "Text") (#Text elem)))
+ (#Ident value)
+ (#Form (list (#Tag "Ident") (#Text value)))
- (#Tag elem)
- (#Form (list (#Tag "Tag") (#Text elem)))
+ (#Tuple elems)
+ (#Form (list (#Tag "Tuple") (untemplate-list (map untemplate elems))))
- (#Ident elem)
- (#Form (list (#Tag "Ident") (#Text elem)))
+ (#Form (#Cons [(#Ident "~") (#Cons [unquoted #Nil])]))
+ unquoted
- (#Form (#Cons [(#Ident "~") (#Cons [unquoted #Nil])]))
- unquoted
+ (#Form elems)
+ (#Form (list (#Tag "Form") (untemplate-list (map untemplate elems))))
+ ))
- (#Tuple elems)
- (#Form (list (#Tag "Tuple") (untemplate-list untemplate elems)))
+(defmacro (` tokens state)
+ [(list (untemplate-list (map untemplate tokens)))
+ state])
- (#Form elems)
- (#Form (list (#Tag "Form") (untemplate-list untemplate elems)))
- ))
+(defmacro (if tokens state)
+ (case' tokens
+ (#Cons [test (#Cons [then (#Cons [else #Nil])])])
+ [(` (case' (~ test)
+ true (~ then)
+ false (~ else)))
+ state]))
-(def (' tokens state)
- [(map untemplate tokens) state])
-(declare-macro ')
+(def (filter p xs)
+ (case' xs
+ #Nil
+ #Nil
-## TODO: Full pattern-matching
-## TODO: Type-related macros
-## TODO: (Im|Ex)ports-related macros
-## TODO: Macro-related macros
+ (#Cons [x xs*])
+ (if (p x)
+ (filter p xs*)
+ (#Cons [x (filter p xs*)]))))
(def (return val)
(lambda [state]
@@ -247,121 +243,121 @@
(def (bind f v)
(lambda [state]
- (case (v state)
- [state' x]
- ((f x) state'))))
+ (case' (v state)
+ [state' x]
+ ((f x) state'))))
+
+#(
+
+## TODO: Full pattern-matching
+## TODO: Type-related macros
+## TODO: (Im|Ex)ports-related macros
+## TODO: Macro-related macros
-(def (if tokens)
- (case' tokens
- (#Cons [test (#Cons [then (#Cons [else #Nil])])])
- (return (list (' (case' (~ test)
- true (~ then)
- false (~ else)))))))
-(declare-macro if)
(def (apply-template env template)
- (case template
- (#Ident ident)
- (if-let [subst (get ident env)]
- subst
- template)
-
- (#Tuple elems)
- (#Tuple (map (apply-template env) elems))
-
- (#Form elems)
- (#Form (map (apply-template env) elems))
-
- (#Record members)
- (#Record (map (lambda [kv]
- (case kv
- [slot value]
- [(apply-template env slot) (apply-template env value)]))
- members))
-
- _
- template))
+(case template
+(#Ident ident)
+(if-let [subst (get ident env)]
+subst
+template)
+
+(#Tuple elems)
+(#Tuple (map (apply-template env) elems))
+
+(#Form elems)
+(#Form (map (apply-template env) elems))
+
+(#Record members)
+(#Record (map (lambda [kv]
+(case kv
+[slot value]
+[(apply-template env slot) (apply-template env value)]))
+members))
+
+_
+template))
(def (do-template tokens)
- (case tokens
- (list+ bindings template data)
- (let [bindings-list (tuple->list bindings)
- data-lists (map tuple->list data)]
- (return (map (lambda [env] (apply-template env template))
- (map (zip 2 bindings) data-lists))))))
+(case tokens
+(list+ bindings template data)
+(let [bindings-list (tuple->list bindings)
+data-lists (map tuple->list data)]
+(return (map (lambda [env] (apply-template env template))
+(map (zip 2 bindings) data-lists))))))
(declare-macro do-template)
(def gen-ident
- (lambda [state]
- [(update@ #gen-seed inc state)
- (#Ident ($ text-++ "__" (show-int (get@ #gen-seed state)) "__"))]))
+(lambda [state]
+[(update@ #gen-seed inc state)
+(#Ident ($ text-++ "__" (show-int (get@ #gen-seed state)) "__"))]))
(do-template [<name> <member>]
- (def (<name> pair)
- (case' pair
- [f s]
- <member>))
+(def (<name> pair)
+(case' pair
+[f s]
+<member>))
- [first f]
- [second s])
+[first f]
+[second s])
(def (loop tokens)
- (case' tokens
- (#Cons [bindings (#Cons [body #Nil])])
- (let [pairs (as-pairs bindings)]
- (return (list (' ((lambda (~ (#Ident "recur")) (~ (#Tuple (map first pairs)))
- (~ body))
- (~@ (map second pairs)))))))))
+(case' tokens
+(#Cons [bindings (#Cons [body #Nil])])
+(let [pairs (as-pairs bindings)]
+(return (list (' ((lambda (~ (#Ident "recur")) (~ (#Tuple (map first pairs)))
+(~ body))
+(~@ (map second pairs)))))))))
(declare-macro loop)
(def (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]
-
- #Pattern
- (do [expansion (macro-expand piece)]
- (case' expansion
- #Nil
- [#Pattern #Nil #Nil]
-
- (#Cons exp #Nil)
- [#Body (list exp) #Nil]
-
- (#Cons exp exps)
- [#Body (list exp) exps]))
- )]
- (recur kind' (++ expanded new-pieces) (++ more-pieces pieces))))
- )))
+(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]
+
+#Pattern
+(do [expansion (macro-expand piece)]
+(case' expansion
+#Nil
+[#Pattern #Nil #Nil]
+
+(#Cons exp #Nil)
+[#Body (list exp) #Nil]
+
+(#Cons exp exps)
+[#Body (list exp) exps]))
+)]
+(recur kind' (++ expanded new-pieces) (++ more-pieces pieces))))
+)))
(declare-macro case)
(def (do tokens state)
- (case tokens
- (list (#Tuple bindings) body)
- (let [output (fold (lambda [inner binding]
- (case binding
- [lhs rhs]
- (' (bind (lambda [(~ lhs)] (~ body))
- (~ rhs)))))
- body
- (reverse (as-pairs bindings)))]
- [(list output) state])))
+(case tokens
+(list (#Tuple bindings) body)
+(let [output (fold (lambda [inner binding]
+(case binding
+[lhs rhs]
+(' (bind (lambda [(~ lhs)] (~ body))
+(~ rhs)))))
+body
+(reverse (as-pairs bindings)))]
+[(list output) state])))
(declare-macro do)
(def (export tokens)
- (return (map (lambda [t]
- (' (export' (~ t))))
- tokens)))
+(return (map (lambda [t]
+(' (export' (~ t))))
+tokens)))
(declare-macro export)
## (import "lux")
@@ -375,31 +371,31 @@
## (require lux #as l #refer [map])
(def (type tokens)
- (case tokens
- (#Tuple elems)
- (return (list (' (#Tuple (~ (map untemplate elems))))))
-
- (#Record fields)
- (return (list (' (#Record (~ (map (lambda [kv]
- (case kv
- [(#Tag tag) val]
- [tag (untemplate val)]))
- fields))))))
-
- (#Form (list+ (#Ident "|") options))
- (do [options' (map% (lambda [opt]
- (case opt
- (#Tag tag)
- [tag (#Tuple (list))]
-
- (#Form (list (#Tag tag) value))
- [tag value]
-
- _
- (fail "")))
- options)]
- (#Variant options'))
- ))
+(case tokens
+(#Tuple elems)
+(return (list (' (#Tuple (~ (map untemplate elems))))))
+
+(#Record fields)
+(return (list (' (#Record (~ (map (lambda [kv]
+(case kv
+[(#Tag tag) val]
+[tag (untemplate val)]))
+fields))))))
+
+(#Form (list+ (#Ident "|") options))
+(do [options' (map% (lambda [opt]
+(case opt
+(#Tag tag)
+[tag (#Tuple (list))]
+
+(#Form (list (#Tag tag) value))
+[tag value]
+
+_
+(fail "")))
+options)]
+(#Variant options'))
+))
(declare-macro type)
## (type (| #Nil
@@ -410,307 +406,307 @@
## (type {#id Int #alive? Bool #name Text})
(def (All tokens)
- (let [[name args body] (case tokens
- (list (#Tuple args) body)
- ["" args body]
-
- (list (#Ident name) (#Tuple args) body)
- [name args body])]
- (return (list (' (#All (~ name) [(~@ (map (lambda [arg]
- (case arg
- (#Ident arg')
- (#Text arg')))
- args))]
- (~ body)))))))
+(let [[name args body] (case tokens
+(list (#Tuple args) body)
+["" args body]
+
+(list (#Ident name) (#Tuple args) body)
+[name args body])]
+(return (list (' (#All (~ name) [(~@ (map (lambda [arg]
+(case arg
+(#Ident arg')
+(#Text arg')))
+args))]
+(~ body)))))))
(declare-macro All)
(def (Exists tokens)
- (case tokens
- (list (#Ident name) body)
- (return (list (' (#Exists (~ name) (~ body)))))))
+(case tokens
+(list (#Ident name) body)
+(return (list (' (#Exists (~ name) (~ body)))))))
(declare-macro Exists)
(def (deftype tokens)
- (case tokens
- (list (#Ident name) definition)
- (return (list (' (def (~ (#Ident name))
- (type (~ definition))))))
-
- (list (#Form (list+ (#Ident name) args)) definition)
- (let [name' (#Ident name)]
- (return (list (' (def (~ name')
- (All (~ name') [(~@ args)]
- (type (~ definition))))))))
- ))
+(case tokens
+(list (#Ident name) definition)
+(return (list (' (def (~ (#Ident name))
+(type (~ definition))))))
+
+(list (#Form (list+ (#Ident name) args)) definition)
+(let [name' (#Ident name)]
+(return (list (' (def (~ name')
+(All (~ name') [(~@ args)]
+(type (~ definition))))))))
+))
(declare-macro deftype)
(def (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))))
+(let [as-if (case tokens
+#Nil
+(' true)
+
+(#Cons init tests)
+(fold (lambda [prev next]
+(' (if (~ prev) (~ next) false)))
+init
+tokens)
+)]
+(return (list as-if))))
(declare-macro and)
(def (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))))
+(let [as-if (case tokens
+#Nil
+(' false)
+
+(#Cons init tests)
+(fold (lambda [prev next]
+(' (if (~ prev) true (~ next))))
+init
+tokens)
+)]
+(return (list as-if))))
(declare-macro or)
(def (not x)
- (case x
- true false
- false true))
+(case x
+true false
+false true))
(def (get@ tokens)
- (let [output (case tokens
- (list (#Tag tag) record)
- (' (get@' (~ (#Tag tag)) (~ record)))
+(let [output (case tokens
+(list (#Tag tag) record)
+(' (get@' (~ (#Tag tag)) (~ record)))
- (list (#Tag tag))
- (' (lambda [record] (get@' (~ (#Tag tag)) record))))]
- (return (list output))))
+(list (#Tag tag))
+(' (lambda [record] (get@' (~ (#Tag tag)) record))))]
+(return (list output))))
(declare-macro get@)
(def (set@ tokens)
- (let [output (case tokens
- (list (#Tag tag) value record)
- (' (set@' (~ (#Tag tag)) (~ value) (~ record)))
+(let [output (case tokens
+(list (#Tag tag) value record)
+(' (set@' (~ (#Tag tag)) (~ value) (~ record)))
- (list (#Tag tag) value)
- (' (lambda [record] (set@' (~ (#Tag tag)) (~ value) record)))
+(list (#Tag tag) value)
+(' (lambda [record] (set@' (~ (#Tag tag)) (~ value) record)))
- (list (#Tag tag))
- (' (lambda [value record] (set@' (~ (#Tag tag)) value record))))]
- (return (list output))))
+(list (#Tag tag))
+(' (lambda [value record] (set@' (~ (#Tag tag)) value record))))]
+(return (list output))))
(declare-macro set@)
(def (update@ tokens)
- (let [output (case tokens
- (list tag func record)
- (` (let [_record_ (~ record)]
- (set@ (~ tag) _record_ ((~ func) (get@ (~ tag) _record_)))))
-
- (list (#Tag tag) func)
- (' (lambda [record]
- (` (set@ (~ tag) record ((~ func) (get@ (~ tag) record))))))
-
- (list (#Tag tag))
- (' (lambda [func record]
- (set@ (~ tag) record (func (get@ (~ tag) record))))))]
- (return (list output))))
+(let [output (case tokens
+(list tag func record)
+(` (let [_record_ (~ record)]
+(set@ (~ tag) _record_ ((~ func) (get@ (~ tag) _record_)))))
+
+(list (#Tag tag) func)
+(' (lambda [record]
+(` (set@ (~ tag) record ((~ func) (get@ (~ tag) record))))))
+
+(list (#Tag tag))
+(' (lambda [func record]
+(set@ (~ tag) record (func (get@ (~ tag) record))))))]
+(return (list output))))
(declare-macro update@)
(def (. f g)
- (lambda [x] (f (g x))))
+(lambda [x] (f (g x))))
(def (|> tokens)
- (case tokens
- (list+ init apps)
- (return (list (fold (lambda [acc app]
- (case app
- (#Form parts)
- (#Form (++ parts (list acc)))
-
- _
- (` (~ app) (~ acc))))
- init
- apps)))))
+(case tokens
+(list+ init apps)
+(return (list (fold (lambda [acc app]
+(case app
+(#Form parts)
+(#Form (++ parts (list acc)))
+
+_
+(` (~ app) (~ acc))))
+init
+apps)))))
(def ($ tokens)
- (case tokens
- (list+ op init args)
- (return (list (fold (lambda [acc elem]
- (` (~ op) (~ acc) (~ elem)))
- init
- args)))))
+(case tokens
+(list+ op init args)
+(return (list (fold (lambda [acc elem]
+(` (~ op) (~ acc) (~ elem)))
+init
+args)))))
(def ($keys tokens)
- (case tokens
- (list (#Tuple fields))
- (let [record (#Record (map (lambda [slot]
- (case slot
- (#Tag name)
- [(#Tag name) (#Ident name)]))
- fields))]
- (return (list record)))))
+(case tokens
+(list (#Tuple fields))
+(let [record (#Record (map (lambda [slot]
+(case slot
+(#Tag name)
+[(#Tag name) (#Ident name)]))
+fields))]
+(return (list record)))))
(def ($or tokens)
- (case tokens
- (list (#Tuple patterns) body)
- (return (flat-map (lambda [pattern] (list pattern body))
- patterns))))
+(case tokens
+(list (#Tuple patterns) body)
+(return (flat-map (lambda [pattern] (list pattern body))
+patterns))))
(def (-> tokens)
- (case (reverse tokens)
- (#Cons [f-return f-args])
- (fold (lambda [f-return f-arg]
- (#Lambda [f-arg f-return]))
- f-return f-args)))
+(case (reverse tokens)
+(#Cons [f-return f-args])
+(fold (lambda [f-return f-arg]
+(#Lambda [f-arg f-return]))
+f-return f-args)))
(def (defsyntax tokens)
- ...)
+...)
(def (defsig tokens)
- ...)
+...)
(def (defstruct tokens)
- ...)
+...)
(def (with tokens)
- ...)
+...)
## (deftype (List a)
## (| #Nil
## (#Cons [a (List a)])))
(def (complement f)
- (lambda [x] (not (f x))))
+(lambda [x] (not (f x))))
(def (cond tokens)
- (let [else (last tokens)
- branches (as-pairs (init tokens))]
- (return (list (fold (lambda [else branch]
- (case branch
- [test then]
- (` (if (~ test) (~ then) (~ else)))))
- else
- branches)))))
+(let [else (last tokens)
+branches (as-pairs (init tokens))]
+(return (list (fold (lambda [else branch]
+(case branch
+[test then]
+(` (if (~ test) (~ then) (~ else)))))
+else
+branches)))))
(declare-macro cond)
(def (constant x)
- (lambda [_] x))
+(lambda [_] x))
(def (repeat n x)
- (if (> n 0)
- (list+ x (repeat (dec n) x))
- #Nil))
+(if (> n 0)
+(list+ x (repeat (dec n) x))
+#Nil))
(def (size xs)
- (case xs
- #Nil 0
- (#Cons [_ xs']) (int+ 1 (size xs'))))
+(case xs
+#Nil 0
+(#Cons [_ xs']) (int+ 1 (size xs'))))
(def (last xs)
- (case xs
- #Nil #None
- (list x) (#Some x)
- (list+ _ xs') (last xs')))
+(case xs
+#Nil #None
+(list x) (#Some x)
+(list+ _ xs') (last xs')))
(def (init xs)
- (case xs
- #Nil #None
- (list _) (#Some #Nil)
- (#Cons [x xs']) (case (init xs')
- (#Some xs'')
- (#Cons [x xs''])
+(case xs
+#Nil #None
+(list _) (#Some #Nil)
+(#Cons [x xs']) (case (init xs')
+(#Some xs'')
+(#Cons [x xs''])
- _
- #None)))
+_
+#None)))
(do-template [<name> <offset>]
- (def <name> (int+ <offset>))
+(def <name> (int+ <offset>))
- [inc 1]
- [dec -1])
+[inc 1]
+[dec -1])
(def (interleave xs ys)
- (case [xs ys]
- [(#Cons [x xs']) (#Cons [y ys'])]
- (list+ x y (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
- (#Cons [x #Nil])
- xs
+(case xs
+(#Cons [x #Nil])
+xs
+
+(#Cons [x xs'])
+(list+ x sep (interpose sep xs'))
- (#Cons [x xs'])
- (list+ x sep (interpose sep xs'))
-
- _
- xs))
+_
+xs))
(def (flatten xss)
- (fold ++ (list) xs))
+(fold ++ (list) xs))
(def (flat-map f xs)
- (flatten (map f xs)))
+(flatten (map f xs)))
(do-template [<name> <cmp>]
- (def (<name> x y)
- (if (<cmp> x y)
- x
- y))
+(def (<name> x y)
+(if (<cmp> x y)
+x
+y))
- [max >]
- [min <])
+[max >]
+[min <])
(do-template [<name> <cmp>]
- (def (<name> n) (<cmp> n 0))
+(def (<name> n) (<cmp> n 0))
- [neg? <]
- [pos? >=])
+[neg? <]
+[pos? >=])
(def (even? n)
- (int= 0 (int% n 0)))
+(int= 0 (int% n 0)))
(def (odd? n)
- (not (even? n)))
+(not (even? n)))
(do-template [<name> <done> <step>]
- (def (<name> n xs)
- (if (> n 0)
- (case xs
- #Nil #Nil
- (list+ x xs') <step>)
- <done>))
+(def (<name> n xs)
+(if (> n 0)
+(case xs
+#Nil #Nil
+(list+ 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
- (list+ x xs') (if (f x) <step> #Nil)))
+(def (<name> f xs)
+(case xs
+#Nil #Nil
+(list+ 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')])
(def (empty? xs)
- (case xs
- #Nil true
- _ false))
+(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'))))
+(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 (< from to)
- (list+ from (range (inc from) to))
- #Nil))
+(if (< from to)
+(list+ from (range (inc from) to))
+#Nil))
)#
diff --git a/src/lux/compiler/lambda.clj b/src/lux/compiler/lambda.clj
index 5358519d9..004f09743 100644
--- a/src/lux/compiler/lambda.clj
+++ b/src/lux/compiler/lambda.clj
@@ -83,13 +83,13 @@
(.visitTypeInsn Opcodes/NEW lambda-class)
(.visitInsn Opcodes/DUP))]
_ (->> closed-over
- (sort #(match [%1 %2]
+ (sort #(match [(second %1) (second %2)]
[[::&a/Expression [::&a/captured _ ?cid1 _] _]
[::&a/Expression [::&a/captured _ ?cid2 _] _]]
(< ?cid1 ?cid2)))
(map-m (fn [[?name ?captured]]
(match ?captured
- [::&a/Expression [::&a/captured _ ?captured-id ?source] _]
+ [::&a/Expression [::&a/captured _ _ ?source] _]
(compile ?source)))))
:let [_ (.visitMethodInsn *writer* Opcodes/INVOKESPECIAL lambda-class "<init>" init-signature)]]
(return nil)))
diff --git a/src/lux/lexer.clj b/src/lux/lexer.clj
index 4ad36f669..fe899691c 100644
--- a/src/lux/lexer.clj
+++ b/src/lux/lexer.clj
@@ -41,7 +41,7 @@
(return (str prefix unescaped postfix)))
(lex-regex #"(?s)^([^\"\\]*)")]))
-(def ^:private +ident-re+ #"^([a-zA-Z\-\+\_\=!@$%^&*<>\.,/\\\|':\~\?][0-9a-zA-Z\-\+\_\=!@$%^&*<>\.,/\\\|':\~\?]*)(;[0-9a-zA-Z\-\+\_\=!@$%^&*<>\.,/\\\|':\~\?]+)?")
+(def ^:private +ident-re+ #"^([a-zA-Z\-\+\_\=!@$%^&*<>\.,/\\\|'`:\~\?][0-9a-zA-Z\-\+\_\=!@$%^&*<>\.,/\\\|'`:\~\?]*)(;[0-9a-zA-Z\-\+\_\=!@$%^&*<>\.,/\\\|'`:\~\?]+)?")
;; [Lexers]
(def ^:private lex-white-space
diff --git a/src/lux/macro.clj b/src/lux/macro.clj
index 7f1e7116b..071f95691 100644
--- a/src/lux/macro.clj
+++ b/src/lux/macro.clj
@@ -38,6 +38,7 @@
))
(defn ^:private ->clojure+ [->clojure xs]
+ ;; (prn '->clojure+ (aget xs 0))
(case (aget xs 0)
"Nil" (list)
"Cons" (let [tuple2 (aget xs 1)]
@@ -46,6 +47,9 @@
))
(defn ^:private ->clojure [x]
+ ;; (if (= "Tag" (aget x 0))
+ ;; (println " ->clojure" (pr-str (aget x 0)) (aget x 1))
+ ;; (println " ->clojure" (pr-str (aget x 0))))
(case (aget x 0)
"Bool" [::&parser/Bool (aget x 1)]
"Int" [::&parser/Int (aget x 1)]