- The output directory is now being used as the cache.

- "input" has been renamed as "source" and "output" has been renamed as "target".

29 files changed, 2390 insertions, 0 deletions

diff --git a/source/lux/codata/stream.lux b/source/lux/codata/stream.lux
new file mode 100644
index 000000000..1d6dd1b50
--- /dev/null
+++ b/source/lux/codata/stream.lux
@@ -0,0 +1,133 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (lux (control (lazy #as L #refer #all)
+                       (functor #as F #refer #all)
+                       (monad #as M #refer #all)
+                       (comonad #as CM #refer #all))
+              (meta lux
+                    macro
+                    syntax)
+              (data (list #as l #refer (#only list list& List/Monad)))))
+
+## [Types]
+(deftype #export (Stream a)
+  (Lazy (, a (Stream a))))
+
+## [Utils]
+(def (cycle' x xs init full)
+  (All [a]
+    (-> a (List a) a (List a) (Stream a)))
+  (case xs
+    #;Nil            (cycle' init full init full)
+    (#;Cons [y xs']) (... [x (cycle' y xs' init full)])))
+
+## [Functions]
+(def #export (iterate f x)
+  (All [a]
+    (-> (-> a a) a (Stream a)))
+  (... [x (iterate f (f x))]))
+
+(def #export (repeat x)
+  (All [a]
+    (-> a (Stream a)))
+  (... [x (repeat x)]))
+
+(def #export (cycle xs)
+  (All [a]
+    (-> (List a) (Maybe (Stream a))))
+  (case xs
+    #;Nil            #;None
+    (#;Cons [x xs']) (#;Some (cycle' x xs' x xs'))))
+
+(do-template [<name> <return> <part>]
+  [(def #export (<name> s)
+     (All [a] (-> (Stream a) <return>))
+     (let [[h t] (! s)]
+       <part>))]
+
+  [head a          h]
+  [tail (Stream a) t])
+
+(def #export (@ idx s)
+  (All [a] (-> Int (Stream a) a))
+  (let [[h t] (! s)]
+    (if (i> idx 0)
+      (@ (dec idx) t)
+      h)))
+
+(do-template [<taker> <dropper> <splitter> <det-type> <det-test> <det-step>]
+  [(def #export (<taker> det xs)
+     (All [a]
+       (-> <det-type> (Stream a) (List a)))
+     (let [[x xs'] (! xs)]
+       (if <det-test>
+         (list& x (<taker> <det-step> xs'))
+         (list))))
+
+   (def #export (<dropper> det xs)
+     (All [a]
+       (-> <det-type> (Stream a) (Stream a)))
+     (let [[x xs'] (! xs)]
+       (if <det-test>
+         (<dropper> <det-step> xs')
+         xs)))
+
+   (def #export (<splitter> det xs)
+     (All [a]
+       (-> <det-type> (Stream a) (, (List a) (Stream a))))
+     (let [[x xs'] (! xs)]
+       (if <det-test>
+         (let [[tail next] (<splitter> <det-step> xs')]
+           [(#;Cons [x tail]) next])
+         [(list) xs])))]
+  
+  [take-while drop-while split-with (-> a Bool) (det x)    det]
+  [take       drop       split      Int         (i> det 0) (dec det)]
+  )
+
+(def #export (unfold step init)
+  (All [a b]
+    (-> (-> a (, a b)) a (Stream b)))
+  (let [[next x] (step init)]
+    (... [x (unfold step next)])))
+
+(def #export (filter p xs)
+  (All [a] (-> (-> a Bool) (Stream a) (Stream a)))
+  (let [[x xs'] (! xs)]
+    (if (p x)
+      (... [x (filter p xs')])
+      (filter p xs'))))
+
+(def #export (partition p xs)
+  (All [a] (-> (-> a Bool) (Stream a) (, (Stream a) (Stream a))))
+  [(filter p xs) (filter (complement p) xs)])
+
+## [Structures]
+(defstruct #export Stream/Functor (Functor Stream)
+  (def (F;map f fa)
+    (let [[h t] (! fa)]
+      (... [(f h) (F;map f t)]))))
+
+(defstruct #export Stream/CoMonad (CoMonad Stream)
+  (def CM;_functor Stream/Functor)
+  (def CM;unwrap head)
+  (def (CM;split wa)
+    (:: Stream/Functor (F;map repeat wa))))
+
+## [Pattern-matching]
+(defsyntax #export (\stream body [patterns' (+^ id^)])
+  (do Lux/Monad
+    [patterns (map% Lux/Monad macro-expand-1 patterns')
+     g!s (gensym "s")
+     #let [patterns+ (: (List Syntax)
+                        (do List/Monad
+                          [pattern (l;reverse patterns)]
+                          (list (` [(~ pattern) (~ g!s)]) (` (L;! (~ g!s))))))]]
+    (M;wrap (list g!s (` (;let [(~@ patterns+)] (~ body)))))))
diff --git a/source/lux/control/comonad.lux b/source/lux/control/comonad.lux
new file mode 100644
index 000000000..1830ff44f
--- /dev/null
+++ b/source/lux/control/comonad.lux
@@ -0,0 +1,54 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (../functor #as F)
+         lux/data/list
+         lux/meta/macro)
+
+## Signatures
+(defsig #export (CoMonad w)
+  (: (F;Functor w)
+     _functor)
+  (: (All [a]
+       (-> (w a) a))
+     unwrap)
+  (: (All [a]
+       (-> (w a) (w (w a))))
+     split))
+
+## Functions
+(def #export (extend w f ma)
+  (All [w a b]
+    (-> (CoMonad w) (-> (w a) b) (w a) (w b)))
+  (using w
+    (using ;;_functor
+      (F;map f (;;split ma)))))
+
+## Syntax
+(defmacro #export (be tokens state)
+  (case tokens
+    (\ (list monad (#;Meta [_ (#;TupleS bindings)]) body))
+    (let [body' (foldL (: (-> Syntax (, Syntax Syntax) Syntax)
+                          (lambda [body' binding]
+                            (let [[var value] binding]
+                              (case var
+                                (#;Meta [_ (#;TagS ["" "let"])])
+                                (` (;let (~ value) (~ body')))
+
+                                _
+                                (` (extend (;lambda [(~ var)] (~ body'))
+                                           (~ value)))))))
+                       body
+                       (reverse (as-pairs bindings)))]
+      (#;Right [state (list (` (;case (~ monad)
+                                      {#;return ;return #;bind ;bind}
+                                      (~ body'))))]))
+
+    _
+    (#;Left "Wrong syntax for be")))
diff --git a/source/lux/control/functor.lux b/source/lux/control/functor.lux
new file mode 100644
index 000000000..6a9dcfff8
--- /dev/null
+++ b/source/lux/control/functor.lux
@@ -0,0 +1,15 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux)
+
+## Signatures
+(defsig #export (Functor f)
+  (: (All [a b]
+       (-> (-> a b) (f a) (f b)))
+     map))
diff --git a/source/lux/control/lazy.lux b/source/lux/control/lazy.lux
new file mode 100644
index 000000000..22dac74fe
--- /dev/null
+++ b/source/lux/control/lazy.lux
@@ -0,0 +1,47 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (lux/meta macro)
+         (.. (functor #as F #refer #all)
+             (monad #as M #refer #all))
+         (lux/data list))
+
+## Types
+(deftype #export (Lazy a)
+  (All [b]
+    (-> (-> a b) b)))
+
+## Syntax
+(defmacro #export (... tokens state)
+  (case tokens
+    (\ (list value))
+    (let [blank (symbol$ ["" ""])]
+      (#;Right [state (list (` (;lambda [(~ blank)] ((~ blank) (~ value)))))]))
+    
+    _
+    (#;Left "Wrong syntax for ...")))
+
+## Functions
+(def #export (! thunk)
+  (All [a]
+    (-> (Lazy a) a))
+  (thunk id))
+
+## Structs
+(defstruct #export Lazy/Functor (Functor Lazy)
+  (def (F;map f ma)
+    (lambda [k] (ma (. k f)))))
+
+(defstruct #export Lazy/Monad (Monad Lazy)
+  (def M;_functor Lazy/Functor)
+
+  (def (M;wrap a)
+    (... a))
+
+  (def M;join !))
diff --git a/source/lux/control/monad.lux b/source/lux/control/monad.lux
new file mode 100644
index 000000000..b5552f987
--- /dev/null
+++ b/source/lux/control/monad.lux
@@ -0,0 +1,99 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (.. (functor #as F)
+             (monoid #as M))
+         lux/meta/macro)
+
+## [Utils]
+(def (foldL f init xs)
+  (All [a b]
+    (-> (-> a b a) a (List b) a)) 
+  (case xs
+    #;Nil
+    init
+
+    (#;Cons [x xs'])
+    (foldL f (f init x) xs')))
+
+(def (reverse xs)
+  (All [a]
+    (-> (List a) (List a)))
+  (foldL (lambda [tail head] (#;Cons [head tail]))
+         #;Nil
+         xs))
+
+(def (as-pairs xs)
+  (All [a] (-> (List a) (List (, a a))))
+  (case xs
+    (#;Cons [x1 (#;Cons [x2 xs'])])
+    (#;Cons [[x1 x2] (as-pairs xs')])
+
+    _
+    #;Nil))
+
+## [Signatures]
+(defsig #export (Monad m)
+  (: (F;Functor m)
+     _functor)
+  (: (All [a]
+       (-> a (m a)))
+     wrap)
+  (: (All [a]
+       (-> (m (m a)) (m a)))
+     join))
+
+## [Syntax]
+(defmacro #export (do tokens state)
+  (case tokens
+    ## (\ (list monad (#;Meta [_ (#;TupleS bindings)]) body))
+    (#;Cons [monad (#;Cons [(#;Meta [_ (#;TupleS bindings)]) (#;Cons [body #;Nil])])])
+    (let [body' (foldL (: (-> Syntax (, Syntax Syntax) Syntax)
+                          (lambda [body' binding]
+                            (let [[var value] binding]
+                              (case var
+                                (#;Meta [_ (#;TagS ["" "let"])])
+                                (` (;let (~ value) (~ body')))
+
+                                _
+                                (` (;case ;;_functor
+                                          {#F;map F;map}
+                                          (;|> (~ value) (F;map (;lambda [(~ var)] (~ body'))) (;;join))))
+                                ## (` (;|> (~ value) (F;map (;lambda [(~ var)] (~ body'))) (;:: ;;_functor) (;;join)))
+                                ))))
+                       body
+                       (reverse (as-pairs bindings)))]
+      (#;Right [state (#;Cons [(` (;case (~ monad)
+                                         {#;;_functor ;;_functor #;;wrap ;;wrap #;;join ;;join}
+                                         (~ body')))
+                               #;Nil])]))
+
+    _
+    (#;Left "Wrong syntax for do")))
+
+## [Functions]
+(def #export (bind m f ma)
+  (All [m a b]
+    (-> (Monad m) (-> a (m b)) (m a) (m b)))
+  (using m
+    (;;join (:: ;;_functor (F;map f ma)))))
+
+(def #export (map% m f xs)
+  (All [m a b]
+    (-> (Monad m) (-> a (m b)) (List a) (m (List b))))
+  (case xs
+    #;Nil
+    (:: m (;;wrap #;Nil))
+    
+    (#;Cons [x xs'])
+    (do m
+      [y (f x)
+       ys (map% m f xs')]
+      (;;wrap (#;Cons [y ys])))
+    ))
diff --git a/source/lux/control/monoid.lux b/source/lux/control/monoid.lux
new file mode 100644
index 000000000..d32baabc5
--- /dev/null
+++ b/source/lux/control/monoid.lux
@@ -0,0 +1,24 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux)
+
+## Signatures
+(defsig #export (Monoid a)
+  (: a
+     unit)
+  (: (-> a a a)
+     ++))
+
+## Constructors
+(def #export (monoid$ unit ++)
+  (All [a]
+    (-> a (-> a a a) (Monoid a)))
+  (struct
+    (def unit unit)
+    (def ++ ++)))
diff --git a/source/lux/data/bool.lux b/source/lux/data/bool.lux
new file mode 100644
index 000000000..d4f223612
--- /dev/null
+++ b/source/lux/data/bool.lux
@@ -0,0 +1,33 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (lux/control (monoid #as m))
+         (.. (eq #as E)
+             (show #as S)))
+
+## [Structures]
+(defstruct #export Bool/Eq (E;Eq Bool)
+  (def (E;= x y)
+    (if x
+      y
+      (not y))))
+
+(defstruct #export Bool/Show (S;Show Bool)
+  (def (S;show x)
+    (if x "true" "false")))
+
+(do-template [<name> <unit> <op>]
+  [(defstruct #export <name> (m;Monoid Bool)
+     (def m;unit <unit>)
+     (def (m;++ x y)
+       (<op> x y)))]
+
+  [ Or/Monoid false or]
+  [And/Monoid true and]
+  )
diff --git a/source/lux/data/bounded.lux b/source/lux/data/bounded.lux
new file mode 100644
index 000000000..9d2dabde1
--- /dev/null
+++ b/source/lux/data/bounded.lux
@@ -0,0 +1,17 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux)
+
+## Signatures
+(defsig #export (Bounded a)
+  (: a
+     top)
+
+  (: a
+     bottom))
diff --git a/source/lux/data/char.lux b/source/lux/data/char.lux
new file mode 100644
index 000000000..42e57509e
--- /dev/null
+++ b/source/lux/data/char.lux
@@ -0,0 +1,20 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (.. (eq #as E)
+             (show #as S)))
+
+## [Structures]
+(defstruct #export Char/Eq (E;Eq Char)
+  (def (E;= x y)
+    (_jvm_ceq x y)))
+
+(defstruct #export Char/Show (S;Show Char)
+  (def (S;show x)
+    ($ text:++ "#\"" (_jvm_invokevirtual java.lang.Object toString [] x []) "\"")))
diff --git a/source/lux/data/dict.lux b/source/lux/data/dict.lux
new file mode 100644
index 000000000..63a66d49b
--- /dev/null
+++ b/source/lux/data/dict.lux
@@ -0,0 +1,83 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (lux/data (eq #as E)))
+
+## Signatures
+(defsig #export (Dict d)
+  (: (All [k v]
+       (-> k (d k v) (Maybe v)))
+     get)
+  (: (All [k v]
+       (-> k v (d k v) (d k v)))
+     put)
+  (: (All [k v]
+       (-> k (d k v) (d k v)))
+     remove))
+
+## Types
+(deftype #export (PList k v)
+  (| (#PList (, (E;Eq k) (List (, k v))))))
+
+## Constructors
+(def #export (plist eq)
+  (All [k v]
+    (-> (E;Eq k) (PList k v)))
+  (#PList [eq #;Nil]))
+
+## Utils
+(def (pl-get eq k kvs)
+  (All [k v]
+    (-> (E;Eq k) k (List (, k v)) (Maybe v)))
+  (case kvs
+    #;Nil
+    #;None
+    
+    (#;Cons [[k' v'] kvs'])
+    (if (:: eq (E;= k k'))
+      (#;Some v')
+      (pl-get eq k kvs'))))
+
+(def (pl-put eq k v kvs)
+  (All [k v]
+    (-> (E;Eq k) k v (List (, k v)) (List (, k v))))
+  (case kvs
+    #;Nil
+    (#;Cons [[k v] kvs])
+    
+    (#;Cons [[k' v'] kvs'])
+    (if (:: eq (E;= k k'))
+      (#;Cons [[k v] kvs'])
+      (#;Cons [[k' v'] (pl-put eq k v kvs')]))))
+
+(def (pl-remove eq k kvs)
+  (All [k v]
+    (-> (E;Eq k) k (List (, k v)) (List (, k v))))
+  (case kvs
+    #;Nil
+    kvs
+    
+    (#;Cons [[k' v'] kvs'])
+    (if (:: eq (E;= k k'))
+      kvs'
+      (#;Cons [[k' v'] (pl-remove eq k kvs')]))))
+
+## Structs
+(defstruct #export PList/Dict (Dict PList)
+  (def (get k plist)
+    (let [(#PList [eq kvs]) plist]
+      (pl-get eq k kvs)))
+
+  (def (put k v plist)
+    (let [(#PList [eq kvs]) plist]
+      (#PList [eq (pl-put eq k v kvs)])))
+
+  (def (remove k plist)
+    (let [(#PList [eq kvs]) plist]
+      (#PList [eq (pl-remove eq k kvs)]))))
diff --git a/source/lux/data/either.lux b/source/lux/data/either.lux
new file mode 100644
index 000000000..eba6438db
--- /dev/null
+++ b/source/lux/data/either.lux
@@ -0,0 +1,46 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (lux/data (list #refer (#exclude partition))))
+
+## [Types]
+## (deftype (Either l r)
+##   (| (#;Left l)
+##      (#;Right r)))
+
+## [Functions]
+(def #export (either f g e)
+  (All [a b c] (-> (-> a c) (-> b c) (Either a b) c))
+  (case e
+    (#;Left x)  (f x)
+    (#;Right x) (g x)))
+
+(do-template [<name> <side> <tag>]
+  [(def #export (<name> es)
+     (All [a b] (-> (List (Either a b)) (List <side>)))
+     (case es
+       #;Nil                    #;Nil
+       (#;Cons [(<tag> x) es']) (#;Cons [x (<name> es')])
+       (#;Cons [_ es'])         (<name> es')))]
+
+  [lefts  a #;Left]
+  [rights b #;Right]
+  )
+
+(def #export (partition es)
+  (All [a b] (-> (List (Either a b)) (, (List a) (List b))))
+  (foldL (: (All [a b]
+              (-> (, (List a) (List b)) (Either a b) (, (List a) (List b))))
+            (lambda [tails e]
+              (let [[ltail rtail] tails]
+                (case e
+                  (#;Left x)  [(#;Cons [x ltail]) rtail]
+                  (#;Right x) [ltail (#;Cons [x rtail])]))))
+         [(list) (list)]
+         (reverse es)))
diff --git a/source/lux/data/eq.lux b/source/lux/data/eq.lux
new file mode 100644
index 000000000..be3400208
--- /dev/null
+++ b/source/lux/data/eq.lux
@@ -0,0 +1,14 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux)
+
+## [Signatures]
+(defsig #export (Eq a)
+  (: (-> a a Bool)
+     =))
diff --git a/source/lux/data/error.lux b/source/lux/data/error.lux
new file mode 100644
index 000000000..cb5c309a6
--- /dev/null
+++ b/source/lux/data/error.lux
@@ -0,0 +1,34 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (lux/control (functor #as F #refer #all)
+                      (monad #as M #refer #all)))
+
+## [Types]
+(deftype #export (Error a)
+  (| (#Fail Text)
+     (#Ok a)))
+
+## [Structures]
+(defstruct #export Error/Functor (Functor Error)
+  (def (F;map f ma)
+    (case ma
+      (#Fail msg) (#Fail msg)
+      (#Ok datum) (#Ok (f datum)))))
+
+(defstruct #export Error/Monad (Monad Error)
+  (def M;_functor Error/Functor)
+
+  (def (M;wrap a)
+    (#Ok a))
+
+  (def (M;join mma)
+    (case mma
+      (#Fail msg) (#Fail msg)
+      (#Ok ma)    ma)))
diff --git a/source/lux/data/id.lux b/source/lux/data/id.lux
new file mode 100644
index 000000000..0e3bdbee6
--- /dev/null
+++ b/source/lux/data/id.lux
@@ -0,0 +1,28 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (lux/control (functor #as F #refer #all)
+                      (monad #as M #refer #all)))
+
+## [Types]
+(deftype #export (Id a)
+  (| (#Id a)))
+
+## [Structures]
+(defstruct #export Id/Functor (Functor Id)
+  (def (F;map f fa)
+    (let [(#Id a) fa]
+      (#Id (f a)))))
+
+(defstruct #export Id/Monad (Monad Id)
+  (def M;_functor Id/Functor)
+  (def (M;wrap a) (#Id a))
+  (def (M;join mma)
+    (let [(#Id ma) mma]
+      ma)))
diff --git a/source/lux/data/io.lux b/source/lux/data/io.lux
new file mode 100644
index 000000000..c08023df5
--- /dev/null
+++ b/source/lux/data/io.lux
@@ -0,0 +1,51 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (lux/meta macro)
+         (lux/control (functor #as F)
+                      (monad #as M))
+         lux/data/list)
+
+## Types
+(deftype #export (IO a)
+  (-> (,) a))
+
+## Syntax
+(defmacro #export (io tokens state)
+  (case tokens
+    (\ (list value))
+    (let [blank (symbol$ ["" ""])]
+      (#;Right [state (list (` (_lux_lambda (~ blank) (~ blank) (~ value))))]))
+
+    _
+    (#;Left "Wrong syntax for io")))
+
+## Structures
+(defstruct #export IO/Functor (F;Functor IO)
+  (def (F;map f ma)
+    (io (f (ma [])))))
+
+(defstruct #export IO/Monad (M;Monad IO)
+  (def M;_functor IO/Functor)
+  
+  (def (M;wrap x)
+    (io x))
+
+  (def (M;join mma)
+    (mma [])))
+
+## Functions
+(def #export (print x)
+  (-> Text (IO (,)))
+  (io (_jvm_invokevirtual java.io.PrintStream print [java.lang.Object]
+                          (_jvm_getstatic java.lang.System out) [x])))
+
+(def #export (println x)
+  (-> Text (IO (,)))
+  (print (text:++ x "\n")))
diff --git a/source/lux/data/list.lux b/source/lux/data/list.lux
new file mode 100644
index 000000000..450dee275
--- /dev/null
+++ b/source/lux/data/list.lux
@@ -0,0 +1,250 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (lux/control (monoid #as m #refer #all)
+                      (functor #as F #refer #all)
+                      (monad #as M #refer #all))
+         lux/meta/macro)
+
+## Types
+## (deftype (List a)
+##   (| #Nil
+##      (#Cons (, a (List a)))))
+
+## Functions
+(def #export (foldL f init xs)
+  (All [a b]
+    (-> (-> a b a) a (List b) a)) 
+  (case xs
+    #;Nil
+    init
+
+    (#;Cons [x xs'])
+    (foldL f (f init x) xs')))
+
+(def #export (foldR f init xs)
+  (All [a b]
+    (-> (-> b a a) a (List b) a)) 
+  (case xs
+    #;Nil
+    init
+
+    (#;Cons [x xs'])
+    (f x (foldR f init xs'))))
+
+(def #export (reverse xs)
+  (All [a]
+    (-> (List a) (List a)))
+  (foldL (lambda [tail head] (#;Cons [head tail]))
+         #;Nil
+         xs))
+
+(def #export (filter p xs)
+  (All [a]
+    (-> (-> a Bool) (List a) (List a)))
+  (case xs
+    #;Nil
+    #;Nil
+    
+    (#;Cons [x xs'])
+    (if (p x)
+      (#;Cons [x (filter p xs')])
+      (filter p xs'))))
+
+(def #export (partition p xs)
+  (All [a] (-> (-> a Bool) (List a) (, (List a) (List a))))
+  [(filter p xs) (filter (complement p) xs)])
+
+(def #export (as-pairs xs)
+  (All [a] (-> (List a) (List (, a a))))
+  (case xs
+    (\ (#;Cons [x1 (#;Cons [x2 xs'])]))
+    (#;Cons [[x1 x2] (as-pairs xs')])
+
+    _
+    #;Nil))
+
+(do-template [<name> <then> <else>]
+  [(def #export (<name> n xs)
+     (All [a]
+       (-> Int (List a) (List a)))
+     (if (i> n 0)
+       (case xs
+         #;Nil
+         #;Nil
+         
+         (#;Cons [x xs'])
+         <then>)
+       <else>))]
+  
+  [take (#;Cons [x (take (dec n) xs')]) #;Nil]
+  [drop (drop (dec n) xs') xs]
+  )
+
+(do-template [<name> <then> <else>]
+  [(def #export (<name> p xs)
+     (All [a]
+       (-> (-> a Bool) (List a) (List a)))
+     (case xs
+       #;Nil
+       #;Nil
+       
+       (#;Cons [x xs'])
+       (if (p x)
+         <then>
+         <else>)))]
+
+  [take-while (#;Cons [x (take-while p xs')]) #;Nil]
+  [drop-while (drop-while p xs') xs]
+  )
+
+(def #export (split n xs)
+  (All [a]
+    (-> Int (List a) (, (List a) (List a))))
+  (if (i> n 0)
+    (case xs
+      #;Nil
+      [#;Nil #;Nil]
+      
+      (#;Cons [x xs'])
+      (let [[tail rest] (split (dec n) xs')]
+        [(#;Cons [x tail]) rest]))
+    [#;Nil xs]))
+
+(def (split-with' p ys xs)
+  (All [a]
+    (-> (-> a Bool) (List a) (List a) (, (List a) (List a))))
+  (case xs
+    #;Nil
+    [ys xs]
+
+    (#;Cons [x xs'])
+    (if (p x)
+      (split-with' p (#;Cons [x ys]) xs')
+      [ys xs])))
+
+(def #export (split-with p xs)
+  (All [a]
+    (-> (-> a Bool) (List a) (, (List a) (List a))))
+  (let [[ys' xs'] (split-with' p #;Nil xs)]
+    [(reverse ys') xs']))
+
+(def #export (repeat n x)
+  (All [a]
+    (-> Int a (List a)))
+  (if (i> n 0)
+    (#;Cons [x (repeat (dec n) x)])
+    #;Nil))
+
+(def #export (iterate f x)
+  (All [a]
+    (-> (-> a (Maybe a)) a (List a)))
+  (case (f x)
+    (#;Some x')
+    (#;Cons [x (iterate f x')])
+
+    #;None
+    (#;Cons [x #;Nil])))
+
+(def #export (some f xs)
+  (All [a b]
+    (-> (-> a (Maybe b)) (List a) (Maybe b)))
+  (case xs
+    #;Nil
+    #;None
+
+    (#;Cons [x xs'])
+    (case (f x)
+      #;None
+      (some f xs')
+
+      (#;Some y)
+      (#;Some y))))
+
+(def #export (interpose sep xs)
+  (All [a]
+    (-> a (List a) (List a)))
+  (case xs
+    #;Nil
+    xs
+
+    (#;Cons [x #;Nil])
+    xs
+
+    (#;Cons [x xs'])
+    (#;Cons [x (#;Cons [sep (interpose sep xs')])])))
+
+(def #export (size list)
+  (-> List Int)
+  (foldL (lambda [acc _] (i+ 1 acc)) 0 list))
+
+(do-template [<name> <init> <op>]
+  [(def #export (<name> p xs)
+     (All [a]
+       (-> (-> a Bool) (List a) Bool))
+     (foldL (lambda [_1 _2] (<op> _1 (p _2))) <init> xs))]
+
+  [every? true  and]
+  [any?   false or])
+
+(def #export (@ i xs)
+  (All [a]
+    (-> Int (List a) (Maybe a)))
+  (case xs
+    #;Nil
+    #;None
+
+    (#;Cons [x xs'])
+    (if (i= 0 i)
+      (#;Some x)
+      (@ (dec i) xs'))))
+
+## Syntax
+(defmacro #export (list xs state)
+  (#;Right [state (#;Cons [(foldL (lambda [tail head]
+                                    (` (#;Cons [(~ head) (~ tail)])))
+                                  (` #;Nil)
+                                  (reverse xs))
+                           #;Nil])]))
+
+(defmacro #export (list& xs state)
+  (case (reverse xs)
+    (#;Cons [last init])
+    (#;Right [state (list (foldL (lambda [tail head]
+                                   (` (#;Cons [(~ head) (~ tail)])))
+                                 last
+                                 init))])
+
+    _
+    (#;Left "Wrong syntax for list&")))
+
+## Structures
+(defstruct #export List/Monoid (All [a]
+                                 (Monoid (List a)))
+  (def m;unit #;Nil)
+  (def (m;++ xs ys)
+    (case xs
+      #;Nil            ys
+      (#;Cons [x xs']) (#;Cons [x (m;++ xs' ys)]))))
+
+(defstruct #export List/Functor (Functor List)
+  (def (F;map f ma)
+    (case ma
+      #;Nil            #;Nil
+      (#;Cons [a ma']) (#;Cons [(f a) (F;map f ma')]))))
+
+(defstruct #export List/Monad (Monad List)
+  (def M;_functor List/Functor)
+
+  (def (M;wrap a)
+    (#;Cons [a #;Nil]))
+
+  (def (M;join mma)
+    (using List/Monoid
+      (foldL m;++ m;unit mma))))
diff --git a/source/lux/data/maybe.lux b/source/lux/data/maybe.lux
new file mode 100644
index 000000000..faec53c2e
--- /dev/null
+++ b/source/lux/data/maybe.lux
@@ -0,0 +1,42 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (lux/control (monoid #as m #refer #all)
+                      (functor #as F #refer #all)
+                      (monad #as M #refer #all)))
+
+## [Types]
+## (deftype (Maybe a)
+##   (| #;None
+##      (#;Some a)))
+
+## [Structures]
+(defstruct #export Maybe/Monoid (Monoid Maybe)
+  (def m;unit #;None)
+  (def (m;++ xs ys)
+    (case xs
+      #;None     ys
+      (#;Some x) (#;Some x))))
+
+(defstruct #export Maybe/Functor (Functor Maybe)
+  (def (F;map f ma)
+    (case ma
+      #;None     #;None
+      (#;Some a) (#;Some (f a)))))
+
+(defstruct #export Maybe/Monad (Monad Maybe)
+  (def M;_functor Maybe/Functor)
+
+  (def (M;wrap x)
+    (#;Some x))
+
+  (def (M;join mma)
+    (case mma
+      #;None      #;None
+      (#;Some xs) xs)))
diff --git a/source/lux/data/number.lux b/source/lux/data/number.lux
new file mode 100644
index 000000000..8da674d88
--- /dev/null
+++ b/source/lux/data/number.lux
@@ -0,0 +1,119 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (lux/control (monoid #as m))
+         (lux/data (eq #as E)
+                   (ord #as O)
+                   (bounded #as B)
+                   (show #as S)))
+
+## Signatures
+(defsig #export (Number n)
+  (do-template [<name>]
+    [(: (-> n n n) <name>)]
+    [+] [-] [*] [/] [%])
+
+  (: (-> Int n)
+     from-int)
+
+  (do-template [<name>]
+    [(: (-> n n) <name>)]
+    [negate] [signum] [abs])
+  )
+
+## [Structures]
+## Number
+(do-template [<name> <type> <+> <-> <*> </> <%> <=> <<> <from> <0> <1> <-1>]
+  [(defstruct #export <name> (Number <type>)
+     (def + <+>)
+     (def - <->)
+     (def * <*>)
+     (def / </>)
+     (def % <%>)
+     (def (from-int x)
+       (<from> x))
+     (def (negate x)
+       (<*> <-1> x))
+     (def (abs x)
+       (if (<<> x <0>)
+         (<*> <-1> x)
+         x))
+     (def (signum x)
+       (cond (<=> x <0>) <0>
+             (<<> x <0>) <-1>
+             ## else
+             <1>))
+     )]
+
+  [ Int/Number  Int i+ i- i* i/ i% i= i<       id 0   1   -1]
+  [Real/Number Real r+ r- r* r/ r% r= r< _jvm_l2d 0.0 1.0 -1.0])
+
+## Eq
+(defstruct #export Int/Eq (E;Eq Int)
+  (def E;= i=))
+
+(defstruct #export Real/Eq (E;Eq Real)
+  (def E;= r=))
+
+## Ord
+## (def #export Int/Ord (O;Ord Int)
+##   (O;ord$ Int/Eq  i< i>))
+
+## (def #export Real/Ord (O;Ord Real)
+##   (O;ord$ Real/Eq r< r>))
+
+(do-template [<name> <type> <eq> <lt> <gt>]
+  [(defstruct #export <name> (O;Ord <type>)
+     (def O;_eq <eq>)
+     (def O;< <lt>)
+     (def (O;<= x y)
+       (or (<lt> x y)
+           (using <eq> (E;= x y))))
+     (def O;> <gt>)
+     (def (O;>= x y)
+       (or (<gt> x y)
+           (using <eq> (E;= x y)))))]
+
+  [ Int/Ord  Int  Int/Eq i< i>]
+  [Real/Ord Real Real/Eq r< r>])
+
+## Bounded
+(do-template [<name> <type> <top> <bottom>]
+  [(defstruct #export <name> (B;Bounded <type>)
+     (def B;top <top>)
+     (def B;bottom <bottom>))]
+
+  [ Int/Bounded  Int (_jvm_getstatic java.lang.Long   MAX_VALUE) (_jvm_getstatic java.lang.Long   MIN_VALUE)]
+  [Real/Bounded Real (_jvm_getstatic java.lang.Double MAX_VALUE) (_jvm_getstatic java.lang.Double MIN_VALUE)])
+
+## Monoid
+(do-template [<name> <type> <unit> <++>]
+  [(defstruct #export <name> (m;Monoid <type>)
+     (def m;unit <unit>)
+     (def m;++ <++>))]
+
+  [ IntAdd/Monoid  Int 0   i+]
+  [ IntMul/Monoid  Int 1   i*]
+  [RealAdd/Monoid Real 0.0 r+]
+  [RealMul/Monoid Real 1.0 r*]
+  [ IntMax/Monoid  Int (::  Int/Bounded B;bottom)  (O;max  Int/Ord)]
+  [ IntMin/Monoid  Int (::  Int/Bounded B;top)     (O;min  Int/Ord)]
+  [RealMax/Monoid Real (:: Real/Bounded B;bottom)  (O;max Real/Ord)]
+  [RealMin/Monoid Real (:: Real/Bounded B;top)     (O;min Real/Ord)]
+  )
+
+## Show
+(do-template [<name> <type> <body>]
+  [(defstruct #export <name> (S;Show <type>)
+     (def (S;show x)
+       <body>))]
+
+  [ Int/Show  Int (_jvm_invokevirtual java.lang.Object toString [] x [])]
+  [Real/Show Real (_jvm_invokevirtual java.lang.Object toString [] x [])]
+  )
diff --git a/source/lux/data/ord.lux b/source/lux/data/ord.lux
new file mode 100644
index 000000000..80f2e4fb5
--- /dev/null
+++ b/source/lux/data/ord.lux
@@ -0,0 +1,44 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (../eq #as E))
+
+## [Signatures]
+(defsig #export (Ord a)
+  (: (E;Eq a)
+     _eq)
+  (do-template [<name>]
+    [(: (-> a a Bool) <name>)]
+
+    [<] [<=] [>] [>=]))
+
+## [Constructors]
+(def #export (ord$ eq < >)
+  (All [a]
+    (-> (E;Eq a) (-> a a Bool) (-> a a Bool) (Ord a)))
+  (struct
+    (def _eq eq)
+    (def < <)
+    (def (<= x y)
+      (or (< x y)
+          (:: eq (E;= x y))))
+    (def > >)
+    (def (>= x y)
+      (or (> x y)
+          (:: eq (E;= x y))))))
+
+## [Functions]
+(do-template [<name> <op>]
+  [(def #export (<name> ord x y)
+     (All [a]
+       (-> (Ord a) a a a))
+     (if (:: ord (<op> x y)) x y))]
+
+  [max ;;>]
+  [min ;;<])
diff --git a/source/lux/data/reader.lux b/source/lux/data/reader.lux
new file mode 100644
index 000000000..e91687c3a
--- /dev/null
+++ b/source/lux/data/reader.lux
@@ -0,0 +1,33 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import (lux #refer (#exclude Reader))
+         (lux/control (functor #as F #refer #all)
+                      (monad #as M #refer #all)))
+
+## [Types]
+(deftype #export (Reader r a)
+  (-> r a))
+
+## [Structures]
+(defstruct #export Reader/Functor (All [r]
+                                    (Functor (Reader r)))
+  (def (F;map f fa)
+    (lambda [env]
+      (f (fa env)))))
+
+(defstruct #export Reader/Monad (All [r]
+                                  (Monad (Reader r)))
+  (def M;_functor Reader/Functor)
+
+  (def (M;wrap x)
+    (lambda [env] x))
+
+  (def (M;join mma)
+    (lambda [env]
+      (mma env env))))
diff --git a/source/lux/data/show.lux b/source/lux/data/show.lux
new file mode 100644
index 000000000..f4e1cf762
--- /dev/null
+++ b/source/lux/data/show.lux
@@ -0,0 +1,14 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux)
+
+## Signatures
+(defsig #export (Show a)
+  (: (-> a Text)
+     show))
diff --git a/source/lux/data/state.lux b/source/lux/data/state.lux
new file mode 100644
index 000000000..bc9858a29
--- /dev/null
+++ b/source/lux/data/state.lux
@@ -0,0 +1,35 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (lux/control (functor #as F #refer #all)
+                      (monad #as M #refer #all)))
+
+## [Types]
+(deftype #export (State s a)
+  (-> s (, s a)))
+
+## [Structures]
+(defstruct #export State/Functor (Functor State)
+  (def (F;map f ma)
+    (lambda [state]
+      (let [[state' a] (ma state)]
+        [state' (f a)]))))
+
+(defstruct #export State/Monad (All [s]
+                                 (Monad (State s)))
+  (def M;_functor State/Functor)
+
+  (def (M;wrap x)
+    (lambda [state]
+      [state x]))
+
+  (def (M;join mma)
+    (lambda [state]
+      (let [[state' ma] (mma state)]
+        (ma state')))))
diff --git a/source/lux/data/text.lux b/source/lux/data/text.lux
new file mode 100644
index 000000000..a3192a1d5
--- /dev/null
+++ b/source/lux/data/text.lux
@@ -0,0 +1,146 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (lux/control (monoid #as m))
+         (lux/data (eq #as E)
+                   (ord #as O)
+                   (show #as S)))
+
+## [Functions]
+(def #export (size x)
+  (-> Text Int)
+  (_jvm_i2l (_jvm_invokevirtual java.lang.String length []
+                                x [])))
+
+(def #export (@ idx x)
+  (-> Int Text (Maybe Char))
+  (if (and (i< idx (size x))
+           (i>= idx 0))
+    (#;Some (_jvm_invokevirtual java.lang.String charAt [int]
+                                x [(_jvm_l2i idx)]))
+    #;None))
+
+(def #export (contains? x y)
+  (-> Text Text Bool)
+  (_jvm_invokevirtual java.lang.String contains [java.lang.CharSequence]
+                      x [y]))
+
+(do-template [<name> <method>]
+  [(def #export (<name> x)
+     (-> Text Text)
+     (_jvm_invokevirtual java.lang.String <method> []
+                         x []))]
+  [lower-case toLowerCase]
+  [upper-case toUpperCase]
+  [trim       trim]
+  )
+
+(def #export (sub' from to x)
+  (-> Int Int Text (Maybe Text))
+  (if (and (i< from to)
+           (i>= from 0)
+           (i<= to (size x)))
+    (_jvm_invokevirtual java.lang.String substring [int int]
+                        x [(_jvm_l2i from) (_jvm_l2i to)])
+    #;None))
+
+(def #export (sub from x)
+  (-> Int Text (Maybe Text))
+  (sub' from (size x) x))
+
+(def #export (split at x)
+  (-> Int Text (Maybe (, Text Text)))
+  (if (and (i< at (size x))
+           (i>= at 0))
+    (let [pre (_jvm_invokevirtual java.lang.String substring [int int]
+                                  x [(_jvm_l2i 0) (_jvm_l2i at)])
+          post (_jvm_invokevirtual java.lang.String substring [int]
+                                   x [(_jvm_l2i at)])]
+      (#;Some [pre post]))
+    #;None))
+
+(def #export (replace pattern value template)
+  (-> Text Text Text Text)
+  (_jvm_invokevirtual java.lang.String replace [java.lang.CharSequence java.lang.CharSequence]
+                      template [pattern value]))
+
+(do-template [<common> <general> <method>]
+  [(def #export (<general> pattern from x)
+     (-> Text Int Text (Maybe Int))
+     (if (and (i< from (size x)) (i>= from 0))
+       (case (_jvm_i2l (_jvm_invokevirtual java.lang.String <method> [java.lang.String int]
+                                           x [pattern (_jvm_l2i from)]))
+         -1  #;None
+         idx (#;Some idx))
+       #;None))
+   
+   (def #export (<common> pattern x)
+     (-> Text Text (Maybe Int))
+     (case (_jvm_i2l (_jvm_invokevirtual java.lang.String <method> [java.lang.String]
+                                         x [pattern]))
+       -1  #;None
+       idx (#;Some idx)))]
+
+  [index-of      index-of'      indexOf]
+  [last-index-of last-index-of' lastIndexOf]
+  )
+
+(def #export (starts-with? prefix x)
+  (-> Text Text Bool)
+  (case (index-of prefix x)
+    (#;Some 0)
+    true
+
+    _
+    false))
+
+(def #export (ends-with? postfix x)
+  (-> Text Text Bool)
+  (case (last-index-of postfix x)
+    (#;Some n)
+    (i= (i+ n (size postfix))
+        (size x))
+
+    _
+    false))
+
+## [Structures]
+(defstruct #export Text/Eq (E;Eq Text)
+  (def (E;= x y)
+    (_jvm_invokevirtual java.lang.Object equals [java.lang.Object]
+                        x [y])))
+
+(defstruct #export Text/Ord (O;Ord Text)
+  (def O;_eq Text/Eq)
+  (def (O;< x y)
+    (i< (_jvm_i2l (_jvm_invokevirtual java.lang.String compareTo [java.lang.String]
+                                      x [y]))
+        0))
+  (def (O;<= x y)
+    (i<= (_jvm_i2l (_jvm_invokevirtual java.lang.String compareTo [java.lang.String]
+                                       x [y]))
+         0))
+  (def (O;> x y)
+    (i> (_jvm_i2l (_jvm_invokevirtual java.lang.String compareTo [java.lang.String]
+                                      x [y]))
+        0))
+  (def (O;>= x y)
+    (i>= (_jvm_i2l (_jvm_invokevirtual java.lang.String compareTo [java.lang.String]
+                                       x [y]))
+         0)))
+
+(defstruct #export Text/Show (S;Show Text)
+  (def (S;show x)
+    x))
+
+(defstruct #export Text/Monoid (m;Monoid Text)
+  (def m;unit "")
+  (def (m;++ x y)
+    (_jvm_invokevirtual java.lang.String concat [java.lang.String]
+                        x [y])))
diff --git a/source/lux/data/writer.lux b/source/lux/data/writer.lux
new file mode 100644
index 000000000..f71492e35
--- /dev/null
+++ b/source/lux/data/writer.lux
@@ -0,0 +1,34 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (lux/control (monoid #as m #refer #all)
+                      (functor #as F #refer #all)
+                      (monad #as M #refer #all)))
+
+## [Types]
+(deftype #export (Writer l a)
+  (, l a))
+
+## [Structures]
+(defstruct #export Writer/Functor (All [l]
+                                    (Functor (Writer l)))
+  (def (F;map f fa)
+    (let [[log datum] fa]
+      [log (f datum)])))
+
+(defstruct #export (Writer/Monad mon) (All [l]
+                                        (-> (Monoid l) (Monad (Writer l))))
+  (def M;_functor Writer/Functor)
+
+  (def (M;wrap x)
+    [(:: mon m;unit) x])
+
+  (def (M;join mma)
+    (let [[log1 [log2 a]] mma]
+      [(:: mon (m;++ log1 log2)) a])))
diff --git a/source/lux/host/java.lux b/source/lux/host/java.lux
new file mode 100644
index 000000000..12525d3f2
--- /dev/null
+++ b/source/lux/host/java.lux
@@ -0,0 +1,312 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (lux (control (monoid #as m)
+                       (functor #as F)
+                       (monad #as M #refer (#only do)))
+              (data list
+                    (text #as text))
+              (meta lux
+                    macro
+                    syntax)))
+
+## (open List/Functor)
+
+## [Utils/Parsers]
+(def finally^
+  (Parser Syntax)
+  (form^ (do Parser/Monad
+           [_ (symbol?^ ["" "finally"])
+            expr id^
+            _ end^]
+           (M;wrap expr))))
+
+(def catch^
+  (Parser (, Text Ident Syntax))
+  (form^ (do Parser/Monad
+           [_ (symbol?^ ["" "catch"])
+            ex-class local-symbol^
+            ex symbol^
+            expr id^
+            _ end^]
+           (M;wrap [ex-class ex expr]))))
+
+(def method-decl^
+  (Parser (, (List Text) Text (List Text) Text))
+  (form^ (do Parser/Monad
+           [modifiers (*^ local-tag^)
+            name local-symbol^
+            inputs (tuple^ (*^ local-symbol^))
+            output local-symbol^
+            _ end^]
+           (M;wrap [modifiers name inputs output]))))
+
+(def field-decl^
+  (Parser (, (List Text) Text Text))
+  (form^ (do Parser/Monad
+           [modifiers (*^ local-tag^)
+            name local-symbol^
+            class local-symbol^
+            _ end^]
+           (M;wrap [modifiers name class]))))
+
+(def arg-decl^
+  (Parser (, Text Text))
+  (form^ (do Parser/Monad
+           [arg-name local-symbol^
+            arg-class local-symbol^
+            _ end^]
+           (M;wrap [arg-name arg-class]))))
+
+(def method-def^
+  (Parser (, (List Text) Text (List (, Text Text)) Text Syntax))
+  (form^ (do Parser/Monad
+           [modifiers (*^ local-tag^)
+            name local-symbol^
+            inputs (tuple^ (*^ arg-decl^))
+            output local-symbol^
+            body id^
+            _ end^]
+           (M;wrap [modifiers name inputs output body]))))
+
+(def method-call^
+  (Parser (, Text (List Text) (List Syntax)))
+  (form^ (do Parser/Monad
+           [method local-symbol^
+            arity-classes (tuple^ (*^ local-symbol^))
+            arity-args (tuple^ (*^ id^))
+            _ end^
+            _ (: (Parser (,))
+                 (if (i= (size arity-classes)
+                         (size arity-args))
+                   (M;wrap [])
+                   (lambda [_] #;None)))]
+           (M;wrap [method arity-classes arity-args])
+           )))
+
+## [Utils/Lux]
+## (def (find-class-field field class)
+##   (-> Text Text (Lux Type))
+##   ...)
+
+## (def (find-virtual-method method class)
+##   (-> Text Text (Lux (List (, (List Type) Type))))
+##   ...)
+
+## (def (find-static-method method class)
+##   (-> Text Text (Lux (List (, (List Type) Type))))
+##   ...)
+
+
+## [Syntax]
+(defsyntax #export (throw ex)
+  (emit (list (` (_jvm_throw (~ ex))))))
+
+(defsyntax #export (try body [catches (*^ catch^)] [finally (?^ finally^)])
+  (emit (list (` (_jvm_try (~ body)
+                           (~@ (list:++ (:: List/Functor (F;map (: (-> (, Text Ident Syntax) Syntax)
+                                                                   (lambda [catch]
+                                                                     (let [[class ex body] catch]
+                                                                       (` (_jvm_catch (~ (text$ class)) (~ (symbol$ ex)) (~ body))))))
+                                                                catches))
+                                        (case finally
+                                          #;None
+                                          (list)
+
+                                          (#;Some finally)
+                                          (list (` (_jvm_finally (~ finally))))))))))))
+
+(defsyntax #export (definterface [name local-symbol^] [supers (tuple^ (*^ local-symbol^))] [members (*^ method-decl^)])
+  (do Lux/Monad
+    [current-module get-module-name
+     #let [full-name (:: text;Text/Monoid (m;++ (text;replace "/" "." current-module)
+                                                name))]]
+    (let [members' (:: List/Functor (F;map (: (-> (, (List Text) Text (List Text) Text) Syntax)
+                                              (lambda [member]
+                                                (let [[modifiers name inputs output] member]
+                                                  (` ((~ (symbol$ ["" name])) [(~@ (:: List/Functor (F;map text$ inputs)))] (~ (text$ output)) [(~@ (:: List/Functor (F;map text$ modifiers)))])))))
+                                           members))]
+      (emit (list (` (_jvm_interface (~ (text$ full-name)) [(~@ (:: List/Functor (F;map text$ supers)))]
+                       (~@ members'))))))))
+
+(defsyntax #export (defclass [name local-symbol^] [super local-symbol^] [interfaces (tuple^ (*^ local-symbol^))]
+                     [fields (*^ field-decl^)]
+                     [methods (*^ method-def^)])
+  (do Lux/Monad
+    [current-module get-module-name
+     #let [full-name (:: text;Text/Monoid (m;++ (text;replace "/" "." current-module)
+                                                name))
+           fields' (:: List/Functor (F;map (: (-> (, (List Text) Text Text) Syntax)
+                                              (lambda [field]
+                                                (let [[modifiers name class] field]
+                                                  (` ((~ (symbol$ ["" name]))
+                                                      (~ (text$ class))
+                                                      [(~@ (:: List/Functor (F;map text$ modifiers)))])))))
+                                           fields))
+           methods' (:: List/Functor (F;map (: (-> (, (List Text) Text (List (, Text Text)) Text Syntax) Syntax)
+                                               (lambda [methods]
+                                                 (let [[modifiers name inputs output body] methods]
+                                                   (` ((~ (symbol$ ["" name]))
+                                                       [(~@ (:: List/Functor (F;map (: (-> (, Text Text) Syntax)
+                                                                                       (lambda [in]
+                                                                                         (let [[left right] in]
+                                                                                           (form$ (list (text$ left)
+                                                                                                        (text$ right))))))
+                                                                                    inputs)))]
+                                                       (~ (text$ output))
+                                                       [(~@ (:: List/Functor (F;map text$ modifiers)))]
+                                                       (~ body))))))
+                                            methods))]]
+    (emit (list (` (_jvm_class (~ (text$ full-name)) (~ (text$ super))
+                     [(~@ (:: List/Functor (F;map text$ interfaces)))]
+                     [(~@ fields')]
+                     [(~@ methods')]))))))
+
+(defsyntax #export (new [class local-symbol^] [arg-classes (tuple^ (*^ local-symbol^))] [args (tuple^ (*^ id^))])
+  (emit (list (` (_jvm_new (~ (text$ class))
+                           [(~@ (:: List/Functor (F;map text$ arg-classes)))]
+                           [(~@ args)])))))
+
+(defsyntax #export (instance? [class local-symbol^] obj)
+  (emit (list (` (_jvm_instanceof (~ (text$ class)) (~ obj))))))
+
+(defsyntax #export (locking lock body)
+  (do Lux/Monad
+    [g!lock (gensym "")
+     g!body (gensym "")]
+    (emit (list (` (;let [(~ g!lock) (~ lock)
+                          _ (_jvm_monitor-enter (~ g!lock))
+                          (~ g!body) (~ body)
+                          _ (_jvm_monitor-exit (~ g!lock))]
+                         (~ g!body)))))
+    ))
+
+(defsyntax #export (null? obj)
+  (emit (list (` (_jvm_null? (~ obj))))))
+
+(defsyntax #export (program [args symbol^] body)
+  (emit (list (` (_jvm_program (~ (symbol$ args))
+                   (~ body))))))
+
+## (defsyntax #export (.? [field local-symbol^] obj)
+##   (case obj
+##     (#;Meta [_ (#;SymbolS obj-name)])
+##     (do Lux/Monad
+##       [obj-type (find-var-type obj-name)]
+##       (case obj-type
+##         (#;DataT class)
+##         (do Lux/Monad
+##           [field-class (find-field field class)]
+##           (_jvm_getfield (~ (text$ class)) (~ (text$ field)) (~ (text$ field-class))))
+
+##         _
+##         (fail "Can only get field from object.")))
+
+##     _
+##     (do Lux/Monad
+##       [g!obj (gensym "")]
+##       (emit (list (` (;let [(~ g!obj) (~ obj)]
+##                            (.? (~ field) (~ g!obj)))))))))
+
+## (defsyntax #export (.= [field local-symbol^] value obj)
+##   (case obj
+##     (#;Meta [_ (#;SymbolS obj-name)])
+##     (do Lux/Monad
+##       [obj-type (find-var-type obj-name)]
+##       (case obj-type
+##         (#;DataT class)
+##         (do Lux/Monad
+##           [field-class (find-field field class)]
+##           (_jvm_putfield (~ (text$ class)) (~ (text$ field)) (~ (text$ field-class)) (~ value)))
+
+##         _
+##         (fail "Can only set field of object.")))
+
+##     _
+##     (do Lux/Monad
+##       [g!obj (gensym "")]
+##       (emit (list (` (;let [(~ g!obj) (~ obj)]
+##                            (.= (~ field) (~ value) (~ g!obj)))))))))
+
+## (defsyntax #export (.! [call method-call^] obj)
+##   (case obj
+##     (#;Meta [_ (#;SymbolS obj-name)])
+##     (do Lux/Monad
+##       [obj-type (find-var-type obj-name)]
+##       (case obj-type
+##         (#;DataT class)
+##         (do Lux/Monad
+##           [#let [[m-name ?m-classes m-args] call]
+##            all-m-details (find-virtual-method m-name class)
+##            m-ins (case [?m-classes all-m-details]
+##                    (\ [#;None (list [m-ins m-out])])
+##                    (M;wrap m-ins)
+
+##                    (\ [(#;Some m-ins) _])
+##                    (M;wrap m-ins)
+
+##                    _
+##                    #;None)]
+##           (emit (list (` (_jvm_invokevirtual (~ (text$ m-name)) (~ (text$ class)) [(~@ (:: List/Functor (F;map text$ m-ins)))]
+##                                              (~ obj) [(~@ m-args)])))))
+
+##         _
+##         (fail "Can only call method on object.")))
+
+##     _
+##     (do Lux/Monad
+##       [g!obj (gensym "")]
+##       (emit (list (` (;let [(~ g!obj) (~ obj)]
+##                            (.! (~@ *tokens*)))))))))
+
+## (defsyntax #export (..? [field local-symbol^] [class local-symbol^])
+##   (emit (list (` (_jvm_getstatic (~ (text$ class)) (~ (text$ field)))))))
+
+## (defsyntax #export (..= [field local-symbol^] value [class local-symbol^])
+##   (emit (list (` (_jvm_putstatic (~ (text$ class)) (~ (text$ field)) (~ value))))))
+
+## (defsyntax #export (..! [call method-call^] [class local-symbol^])
+##   (do Lux/Monad
+##     [#let [[m-name ?m-classes m-args] call]
+##      all-m-details (find-static-method m-name class)
+##      m-ins (case [?m-classes all-m-details]
+##              (\ [#;None (list [m-ins m-out])])
+##              (M;wrap m-ins)
+
+##              (\ [(#;Some m-ins) _])
+##              (M;wrap m-ins)
+
+##              _
+##              #;None)]
+##     (emit (list (` (_jvm_invokestatic (~ (text$ m-name)) (~ (text$ class))
+##                                       [(~@ (:: List/Functor (F;map text$ m-ins)))]
+##                                       [(~@ m-args)]))))
+##     ))
+
+## (definterface Function []
+##   (#public #abstract apply [java.lang.Object] java.lang.Object))
+
+## (_jvm_interface "Function" []
+##   (apply ["java.lang.Object"] "java.lang.Object" ["public" "abstract"]))
+
+## (defclass MyFunction [Function]
+##   (#public #static foo java.lang.Object)
+##   (#public <init> [] void
+##            (_jvm_invokespecial java.lang.Object <init> [] this []))
+##   (#public apply [(arg java.lang.Object)] java.lang.Object
+##            "YOLO"))
+
+## (_jvm_class "lux.MyFunction" "java.lang.Object" ["lux.Function"]
+##   [(foo "java.lang.Object" ["public" "static"])]
+##   (<init> [] "void"
+##           ["public"]
+##           (_jvm_invokespecial java.lang.Object <init> [] this []))
+##   (apply [(arg "java.lang.Object")] "java.lang.Object"
+##          ["public"]
+##          "YOLO"))
diff --git a/source/lux/math.lux b/source/lux/math.lux
new file mode 100644
index 000000000..2e29c5da7
--- /dev/null
+++ b/source/lux/math.lux
@@ -0,0 +1,60 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux)
+
+## [Constants]
+(do-template [<name> <value>]
+  [(def #export <name>
+     Real
+     (_jvm_getstatic java.lang.Math <value>))]
+
+  [e  E]
+  [pi PI]
+  )
+
+## [Functions]
+(do-template [<name> <method>]
+  [(def #export (<name> n)
+     (-> Real Real)
+     (_jvm_invokestatic java.lang.Math <method> [double] [n]))]
+
+  [cos cos]
+  [sin sin]
+  [tan tan]
+
+  [acos acos]
+  [asin asin]
+  [atan atan]
+  
+  [cosh cosh]
+  [sinh sinh]
+  [tanh tanh]
+
+  [ceil ceil]
+  [floor floor]
+  [round round]
+
+  [exp exp]
+  [log log]
+  
+  [cbrt cbrt]
+  [sqrt sqrt]
+
+  [->degrees toDegrees]
+  [->radians toRadians]
+  )
+
+(do-template [<name> <method>]
+  [(def #export (<name> x y)
+     (-> Real Real Real)
+     (_jvm_invokestatic java.lang.Math <method> [double double] [x y]))]
+
+  [atan2 atan2]
+  [pow pow]
+  )
diff --git a/source/lux/meta/lux.lux b/source/lux/meta/lux.lux
new file mode 100644
index 000000000..a28d6e5d4
--- /dev/null
+++ b/source/lux/meta/lux.lux
@@ -0,0 +1,287 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (.. macro)
+         (lux/control (monoid #as m)
+                      (functor #as F)
+                      (monad #as M #refer (#only do)))
+         (lux/data list
+                   maybe
+                   (show #as S)
+                   (number #as N)))
+
+## [Types]
+## (deftype (Lux a)
+##   (-> Compiler (Either Text (, Compiler a))))
+
+## [Utils]
+(def (ident->text ident)
+  (-> Ident Text)
+  (let [[pre post] ident]
+    ($ text:++ pre ";" post)))
+
+## [Structures]
+(defstruct #export Lux/Functor (F;Functor Lux)
+  (def (F;map f fa)
+    (lambda [state]
+      (case (fa state)
+        (#;Left msg)
+        (#;Left msg)
+
+        (#;Right [state' a])
+        (#;Right [state' (f a)])))))
+
+(defstruct #export Lux/Monad (M;Monad Lux)
+  (def M;_functor Lux/Functor)
+  (def (M;wrap x)
+    (lambda [state]
+      (#;Right [state x])))
+  (def (M;join mma)
+    (lambda [state]
+      (case (mma state)
+        (#;Left msg)
+        (#;Left msg)
+
+        (#;Right [state' ma])
+        (ma state')))))
+
+## Functions
+(def #export (get-module-name state)
+  (Lux Text)
+  (case (reverse (get@ #;envs state))
+    #;Nil
+    (#;Left "Can't get the module name without a module!")
+
+    (#;Cons [env _])
+    (#;Right [state (get@ #;name env)])))
+
+(def (get k plist)
+  (All [a]
+    (-> Text (List (, Text a)) (Maybe a)))
+  (case plist
+    #;Nil
+    #;None
+
+    (#;Cons [[k' v] plist'])
+    (if (text:= k k')
+      (#;Some v)
+      (get k plist'))))
+
+(def (find-macro' modules current-module module name)
+  (-> (List (, Text (Module Compiler))) Text Text Text
+      (Maybe Macro))
+  (do Maybe/Monad
+    [$module (get module modules)
+     gdef (|> (: (Module Compiler) $module) (get@ #;defs) (get name))]
+    (case (: (, Bool (DefData' Macro)) gdef)
+      [exported? (#;MacroD macro')]
+      (if (or exported? (text:= module current-module))
+        (#;Some macro')
+        #;None)
+
+      [_ (#;AliasD [r-module r-name])]
+      (find-macro' modules current-module r-module r-name)
+      
+      _
+      #;None)))
+
+(def #export (find-macro ident)
+  (-> Ident (Lux (Maybe Macro)))
+  (do Lux/Monad
+    [current-module get-module-name]
+    (let [[module name] ident]
+      (: (Lux (Maybe Macro))
+         (lambda [state]
+           (#;Right [state (find-macro' (get@ #;modules state) current-module module name)]))))))
+
+(def #export (normalize ident)
+  (-> Ident (Lux Ident))
+  (case ident
+    ["" name]
+    (do Lux/Monad
+      [module-name get-module-name]
+      (M;wrap (: Ident [module-name name])))
+
+    _
+    (:: Lux/Monad (M;wrap ident))))
+
+(def #export (macro-expand syntax)
+  (-> Syntax (Lux (List Syntax)))
+  (case syntax
+    (#;Meta [_ (#;FormS (#;Cons [(#;Meta [_ (#;SymbolS macro-name)]) args]))])
+    (do Lux/Monad
+      [macro-name' (normalize macro-name)
+       ?macro (find-macro macro-name')]
+      (case ?macro
+        (#;Some macro)
+        (do Lux/Monad
+          [expansion (macro args)
+           expansion' (M;map% Lux/Monad macro-expand expansion)]
+          (M;wrap (:: List/Monad (M;join expansion'))))
+        
+        #;None
+        (do Lux/Monad
+          [parts' (M;map% Lux/Monad macro-expand (list& (symbol$ macro-name) args))]
+          (M;wrap (list (form$ (:: List/Monad (M;join parts'))))))))
+
+    (#;Meta [_ (#;FormS (#;Cons [harg targs]))])
+    (do Lux/Monad
+      [harg+ (macro-expand harg)
+       targs+ (M;map% Lux/Monad macro-expand targs)]
+      (M;wrap (list (form$ (list:++ harg+ (:: List/Monad (M;join (: (List (List Syntax)) targs+))))))))
+
+    (#;Meta [_ (#;TupleS members)])
+    (do Lux/Monad
+      [members' (M;map% Lux/Monad macro-expand members)]
+      (M;wrap (list (tuple$ (:: List/Monad (M;join members'))))))
+
+    _
+    (:: Lux/Monad (M;wrap (list syntax)))))
+
+(def #export (gensym prefix state)
+  (-> Text (Lux Syntax))
+  (#;Right [(update@ #;seed inc state)
+            (symbol$ ["__gensym__" (:: N;Int/Show (S;show (get@ #;seed state)))])]))
+
+(def #export (emit datum)
+  (All [a]
+    (-> a (Lux a)))
+  (lambda [state]
+    (#;Right [state datum])))
+
+(def #export (fail msg)
+  (All [a]
+    (-> Text (Lux a)))
+  (lambda [_]
+    (#;Left msg)))
+
+(def #export (macro-expand-1 token)
+  (-> Syntax (Lux Syntax))
+  (do Lux/Monad
+    [token+ (macro-expand token)]
+    (case token+
+      (\ (list token'))
+      (M;wrap token')
+
+      _
+      (fail "Macro expanded to more than 1 element."))))
+
+(def #export (module-exists? module state)
+  (-> Text (Lux Bool))
+  (#;Right [state (case (get module (get@ #;modules state))
+                    (#;Some _)
+                    true
+                    
+                    #;None
+                    false)]))
+
+(def #export (exported-defs module state)
+  (-> Text (Lux (List Text)))
+  (case (get module (get@ #;modules state))
+    (#;Some =module)
+    (using List/Monad
+      (#;Right [state (M;join (:: M;_functor (F;map (: (-> (, Text (, Bool (DefData' Macro)))
+                                                           (List Text))
+                                                       (lambda [gdef]
+                                                         (let [[name [export? _]] gdef]
+                                                           (if export?
+                                                             (list name)
+                                                             (list)))))
+                                                    (get@ #;defs =module))))]))
+    
+    #;None
+    (#;Left ($ text:++ "Unknown module: " module))))
+
+(def (show-envs envs)
+  (-> (List (Env Text (, LuxVar Type))) Text)
+  (|> envs
+      (F;map (lambda [env]
+               (case env
+                 {#;name name #;inner-closures _ #;locals {#;counter _ #;mappings locals} #;closure _}
+                 ($ text:++ name ": " (|> locals
+                                          (F;map (: (All [a] (-> (, Text a) Text))
+                                                    (lambda [b] (let [[label _] b] label))))
+                                          (:: List/Functor)
+                                          (interpose " ")
+                                          (foldL text:++ ""))))))
+      (:: List/Functor)
+      (interpose "\n")
+      (foldL text:++ "")))
+
+(def (try-both f x1 x2)
+  (All [a b]
+    (-> (-> a (Maybe b)) a a (Maybe b)))
+  (case (f x1)
+    #;None     (f x2)
+    (#;Some y) (#;Some y)))
+
+(def (find-in-env name state)
+  (-> Ident Compiler (Maybe Type))
+  (let [vname' (ident->text name)]
+    (case state
+      {#;source source #;modules modules
+       #;envs   envs   #;types   types             #;host  host
+       #;seed   seed   #;eval? eval?}
+      (some (: (-> (Env Text (, LuxVar Type)) (Maybe Type))
+               (lambda [env]
+                 (case env
+                   {#;name _ #;inner-closures _ #;locals {#;counter _ #;mappings locals} #;closure {#;counter _ #;mappings closure}}
+                   (try-both (some (: (-> (, Text (, LuxVar Type)) (Maybe Type))
+                                      (lambda [binding]
+                                        (let [[bname [_ type]] binding]
+                                          (if (text:= vname' bname)
+                                            (#;Some type)
+                                            #;None)))))
+                             locals
+                             closure))))
+            envs))))
+
+(def (find-in-defs name state)
+  (-> Ident Compiler (Maybe Type))
+  (let [[v-prefix v-name] name
+        {#;source source #;modules modules
+         #;envs   envs   #;types   types   #;host           host
+         #;seed   seed   #;eval? eval?} state]
+    (case (get v-prefix modules)
+      #;None
+      #;None
+
+      (#;Some {#;defs defs #;module-aliases _ #;imports _})
+      (case (get v-name defs)
+        #;None
+        #;None
+
+        (#;Some [_ def-data])
+        (case def-data
+          #;TypeD          (#;Some Type)
+          (#;ValueD type)  (#;Some type)
+          (#;MacroD m)     (#;Some Macro)
+          (#;AliasD name') (find-in-defs name' state))))))
+
+(def #export (find-var-type name)
+  (-> Ident (Lux Type))
+  (do Lux/Monad
+    [name' (normalize name)]
+    (: (Lux Type)
+       (lambda [state]
+         (case (find-in-env name state)
+           (#;Some struct-type)
+           (#;Right [state struct-type])
+
+           _
+           (case (find-in-defs name' state)
+             (#;Some struct-type)
+             (#;Right [state struct-type])
+
+             _
+             (let [{#;source source #;modules      modules
+                    #;envs   envs   #;types        types        #;host  host
+                    #;seed   seed   #;eval? eval?} state]
+               (#;Left ($ text:++ "Unknown var: " (ident->text name) "\n\n" (show-envs envs))))))))
+    ))
diff --git a/source/lux/meta/macro.lux b/source/lux/meta/macro.lux
new file mode 100644
index 000000000..22aeaf874
--- /dev/null
+++ b/source/lux/meta/macro.lux
@@ -0,0 +1,54 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux)
+
+## [Utils]
+(def (_meta x)
+  (-> (Syntax' (Meta Cursor)) Syntax)
+  (#;Meta [["" -1 -1] x]))
+
+## [Syntax]
+(def #export (defmacro tokens state)
+  Macro
+  (case tokens
+    (#;Cons [(#;Meta [_ (#;FormS (#;Cons [name args]))]) (#;Cons [body #;Nil])])
+    (#;Right [state (#;Cons [(` ((~ (_meta (#;SymbolS ["lux" "def"]))) ((~ name) (~@ args))
+                                 (~ (_meta (#;SymbolS ["lux" "Macro"])))
+                                 (~ body)))
+                             (#;Cons [(` ((~ (_meta (#;SymbolS ["" "_lux_declare-macro"]))) (~ name)))
+                                      #;Nil])])])
+
+    (#;Cons [(#;Meta [_ (#;TagS ["" "export"])]) (#;Cons [(#;Meta [_ (#;FormS (#;Cons [name args]))]) (#;Cons [body #;Nil])])])
+    (#;Right [state (#;Cons [(` ((~ (_meta (#;SymbolS ["lux" "def"]))) (~ (_meta (#;TagS ["" "export"]))) ((~ name) (~@ args))
+                                 (~ (_meta (#;SymbolS ["lux" "Macro"])))
+                                 (~ body)))
+                             (#;Cons [(` ((~ (_meta (#;SymbolS ["" "_lux_declare-macro"]))) (~ name)))
+                                      #;Nil])])])
+
+    _
+    (#;Left "Wrong syntax for defmacro")))
+(_lux_declare-macro defmacro)
+
+## [Functions]
+(do-template [<name> <type> <tag>]
+  [(def #export (<name> x)
+     (-> <type> Syntax)
+     (#;Meta [["" -1 -1] (<tag> x)]))]
+  
+  [bool$   Bool                     #;BoolS]
+  [int$    Int                      #;IntS]
+  [real$   Real                     #;RealS]
+  [char$   Char                     #;CharS]
+  [text$   Text                     #;TextS]
+  [symbol$ Ident                    #;SymbolS]
+  [tag$    Ident                    #;TagS]
+  [form$   (List Syntax)            #;FormS]
+  [tuple$  (List Syntax)            #;TupleS]
+  [record$ (List (, Syntax Syntax)) #;RecordS]
+  )
diff --git a/source/lux/meta/syntax.lux b/source/lux/meta/syntax.lux
new file mode 100644
index 000000000..1fe85c32f
--- /dev/null
+++ b/source/lux/meta/syntax.lux
@@ -0,0 +1,262 @@
+##   Copyright (c) Eduardo Julian. All rights reserved.
+##   The use and distribution terms for this software are covered by the
+##   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+##   which can be found in the file epl-v10.html at the root of this distribution.
+##   By using this software in any fashion, you are agreeing to be bound by
+##   the terms of this license.
+##   You must not remove this notice, or any other, from this software.
+
+(;import lux
+         (.. (macro #as m #refer #all)
+             (lux #as l #refer (#only Lux/Monad gensym)))
+         (lux (control (functor #as F)
+                       (monad #as M #refer (#only do)))
+              (data (eq #as E)
+                    (bool #as b)
+                    (char #as c)
+                    (text #as t)
+                    list)))
+
+## [Utils]
+(def (first xy)
+  (All [a b] (-> (, a b) a))
+  (let [[x y] xy]
+    x))
+
+(def (join-pairs pairs)
+  (All [a] (-> (List (, a a)) (List a)))
+  (case pairs
+    #;Nil                   #;Nil
+    (#;Cons [[x y] pairs']) (list& x y (join-pairs pairs'))))
+
+## Types
+(deftype #export (Parser a)
+  (-> (List Syntax) (Maybe (, (List Syntax) a))))
+
+## Structures
+(defstruct #export Parser/Functor (F;Functor Parser)
+  (def (F;map f ma)
+    (lambda [tokens]
+      (case (ma tokens)
+        #;None
+        #;None
+
+        (#;Some [tokens' a])
+        (#;Some [tokens' (f a)])))))
+
+(defstruct #export Parser/Monad (M;Monad Parser)
+  (def M;_functor Parser/Functor)
+
+  (def (M;wrap x tokens)
+    (#;Some [tokens x]))
+
+  (def (M;join mma)
+    (lambda [tokens]
+      (case (mma tokens)
+        #;None
+        #;None
+
+        (#;Some [tokens' ma])
+        (ma tokens')))))
+
+## Parsers
+(def #export (id^ tokens)
+  (Parser Syntax)
+  (case tokens
+    #;Nil                #;None
+    (#;Cons [t tokens']) (#;Some [tokens' t])))
+
+(do-template [<name> <type> <tag>]
+  [(def #export (<name> tokens)
+     (Parser <type>)
+     (case tokens
+       (#;Cons [(#;Meta [_ (<tag> x)]) tokens'])
+       (#;Some [tokens' x])
+
+       _
+       #;None))]
+
+  [  bool^ Bool  #;BoolS]
+  [   int^ Int   #;IntS]
+  [  real^ Real  #;RealS]
+  [  char^ Char  #;CharS]
+  [  text^ Text  #;TextS]
+  [symbol^ Ident #;SymbolS]
+  [   tag^ Ident #;TagS]
+  )
+
+(do-template [<name> <tag>]
+  [(def #export (<name> tokens)
+     (Parser Text)
+     (case tokens
+       (#;Cons [(#;Meta [_ (<tag> ["" x])]) tokens'])
+       (#;Some [tokens' x])
+
+       _
+       #;None))]
+
+  [local-symbol^ #;SymbolS]
+  [   local-tag^ #;TagS]
+  )
+
+(def (ident:= x y)
+  (-> Ident Ident Bool)
+  (let [[x1 x2] x
+        [y1 y2] y]
+    (and (text:= x1 y1)
+         (text:= x2 y2))))
+
+(do-template [<name> <type> <tag> <eq>]
+  [(def #export (<name> v tokens)
+     (-> <type> (Parser (,)))
+     (case tokens
+       (#;Cons [(#;Meta [_ (<tag> x)]) tokens'])
+       (if (<eq> v x)
+         (#;Some [tokens' []])
+         #;None)
+
+       _
+       #;None))]
+
+  [  bool?^ Bool    #;BoolS  (:: b;Bool/Eq E;=)]
+  [   int?^ Int      #;IntS  i=]
+  [  real?^ Real    #;RealS  r=]
+  [  char?^ Char    #;CharS  (:: c;Char/Eq E;=)]
+  [  text?^ Text    #;TextS  (:: t;Text/Eq E;=)]
+  [symbol?^ Ident #;SymbolS ident:=]
+  [   tag?^ Ident    #;TagS ident:=]
+  )
+
+(do-template [<name> <tag>]
+  [(def #export (<name> p tokens)
+     (All [a]
+       (-> (Parser a) (Parser a)))
+     (case tokens
+       (#;Cons [(#;Meta [_ (<tag> form)]) tokens'])
+       (case (p form)
+         (#;Some [#;Nil x]) (#;Some [tokens' x])
+         _                  #;None)
+
+       _
+       #;None))]
+
+  [ form^  #;FormS]
+  [tuple^ #;TupleS]
+  )
+
+(def #export (?^ p tokens)
+  (All [a]
+    (-> (Parser a) (Parser (Maybe a))))
+  (case (p tokens)
+    #;None               (#;Some [tokens #;None])
+    (#;Some [tokens' x]) (#;Some [tokens' (#;Some x)])))
+
+(def (run-parser p tokens)
+  (All [a]
+    (-> (Parser a) (List Syntax) (Maybe (, (List Syntax) a))))
+  (p tokens))
+
+(def #export (*^ p tokens)
+  (All [a]
+    (-> (Parser a) (Parser (List a))))
+  (case (p tokens)
+    #;None               (#;Some [tokens (list)])
+    (#;Some [tokens' x]) (run-parser (do Parser/Monad
+                                       [xs (*^ p)]
+                                       (M;wrap (list& x xs)))
+                                     tokens')))
+
+(def #export (+^ p)
+  (All [a]
+    (-> (Parser a) (Parser (List a))))
+  (do Parser/Monad
+    [x p
+     xs (*^ p)]
+    (M;wrap (list& x xs))))
+
+(def #export (&^ p1 p2)
+  (All [a b]
+    (-> (Parser a) (Parser b) (Parser (, a b))))
+  (do Parser/Monad
+    [x1 p1
+     x2 p2]
+    (M;wrap [x1 x2])))
+
+(def #export (|^ p1 p2 tokens)
+  (All [a b]
+    (-> (Parser a) (Parser b) (Parser (Either b))))
+  (case (p1 tokens)
+    (#;Some [tokens' x1]) (#;Some [tokens' (#;Left x1)])
+    #;None                (run-parser (do Parser/Monad
+                                        [x2 p2]
+                                        (M;wrap (#;Right x2)))
+                                      tokens)))
+
+(def #export (||^ ps tokens)
+  (All [a]
+    (-> (List (Parser a)) (Parser (Maybe a))))
+  (case ps
+    #;Nil            #;None
+    (#;Cons [p ps']) (case (p tokens)
+                       #;None               (||^ ps' tokens)
+                       (#;Some [tokens' x]) (#;Some [tokens' (#;Some x)]))
+    ))
+
+(def #export (end^ tokens)
+  (Parser (,))
+  (case tokens
+    #;Nil      (#;Some [tokens []])
+    _          #;None))
+
+## Syntax
+(defmacro #export (defsyntax tokens)
+  (let [[exported? tokens] (: (, Bool (List Syntax))
+                              (case tokens
+                                (\ (list& (#;Meta [_ (#;TagS ["" "export"])]) tokens'))
+                                [true tokens']
+
+                                _
+                                [false tokens]))]
+    (case tokens
+      (\ (list (#;Meta [_ (#;FormS (list& (#;Meta [_ (#;SymbolS ["" name])]) args))])
+               body))
+      (do Lux/Monad
+        [names+parsers (M;map% Lux/Monad
+                               (: (-> Syntax (Lux (, Syntax Syntax)))
+                                  (lambda [arg]
+                                    (case arg
+                                      (\ (#;Meta [_ (#;TupleS (list (#;Meta [_ (#;SymbolS var-name)])
+                                                                    parser))]))
+                                      (M;wrap [(symbol$ var-name) parser])
+
+                                      (\ (#;Meta [_ (#;SymbolS var-name)]))
+                                      (M;wrap [(symbol$ var-name) (` id^)])
+
+                                      _
+                                      (l;fail "Syntax pattern expects 2-tuples or symbols."))))
+                               args)
+         g!tokens (gensym "tokens")
+         g!_ (gensym "_")
+         #let [names (:: List/Functor (F;map first names+parsers))
+               error-msg (text$ (text:++ "Wrong syntax for " name))
+               body' (foldL (: (-> Syntax (, Syntax Syntax) Syntax)
+                               (lambda [body name+parser]
+                                 (let [[name parser] name+parser]
+                                   (` (_lux_case ((~ parser) (~ g!tokens))
+                                        (#;Some [(~ g!tokens) (~ name)])
+                                        (~ body)
+
+                                        (~ g!_)
+                                        (l;fail (~ error-msg)))))))
+                            body
+                            (reverse names+parsers))
+               macro-def (: Syntax
+                            (` (m;defmacro ((~ (symbol$ ["" name])) (~ g!tokens))
+                                           (~ body'))))]]
+        (M;wrap (list& macro-def
+                       (if exported?
+                         (list (` (_lux_export (~ (symbol$ ["" name])))))
+                         (list)))))
+      
+      _
+      (l;fail "Wrong syntax for defsyntax"))))