- 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.

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)]