diff --git a/Cargo.lock b/Cargo.lock
index 183c8e6..7806c6c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -266,6 +266,7 @@ checksum = "e4a24736216ec316047a1fc4252e27dabb04218aa4a3f37c6e7ddbf1f9782b54"
 name = "nomwut"
 version = "0.1.0"
 dependencies = [
+ "itertools",
  "lalrpop",
  "lalrpop-util",
  "regex",
diff --git a/Cargo.toml b/Cargo.toml
index dcf74cc..d938bfb 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,6 +11,7 @@ build = "build.rs"
 [dependencies]
 lalrpop-util = "0.19.5"
 regex = "1"
+itertools = "0.10"
 
 [build-dependencies]
 lalrpop = "0.19.5"
diff --git a/src/calc.lalrpop b/src/calc.lalrpop
index e67e552..48405fe 100644
--- a/src/calc.lalrpop
+++ b/src/calc.lalrpop
@@ -1,38 +1,42 @@
 use std::str::FromStr;
-use crate::lexer;
+//use crate::lexer;
 use crate::Expr;
+use crate::Sp;
 
 grammar;
 
-extern {
-    type Location = usize;
-    type Error = lexer::LexicalError;
-
-    enum lexer::Tok {
-        "(" => lexer::Tok::LPren,
-        ")" => lexer::Tok::RPren,
-        Space => lexer::Tok::Space,
-        Int => lexer::Tok::Int(<i32>),
-    }
-}
-
-
-Sep<T, S>: Vec<T> = {
-    <mut v:(<T> S)*> <e:T?> => match e {
-        None => v,
-        Some(e) => {
-            v.push(e);
-            v
-        }
-    }
-}
 
+Span<T>: Sp<T> = {
+    <@L> <T> <@R> => Sp(<>)
+};
 
 pub Expr: Expr = {
-    "(" <elems:Sep<Expr, Space>> ")" => Expr::List(elems),
-    <n:Int> => Expr::Number(n),
+    "(" <elems:(<Span<(<Expr>)>>)+> ")" => Expr::List(elems),
+
+    "{" <elems:(<Span<(<Expr>)>> <Span<(<Expr>)>>)*> "}" => Expr::Table(elems),
+
+    <x:Keyword> => x,
+    <x:Symbol> => x,
+    <x:StrLit> => Expr::Str(x),
+    <x:Num> => Expr::Number(x),
+    Comment => Expr::Comment,
 };
 
+Keyword: Expr = <r":[^\s]+"> => Expr::Keyword(<>.to_string());
+Symbol: Expr = <r"[a-zA-Z_!\?<>/.*-+][^\s{}\(\)]*"> => Expr::Symbol(<>.to_string());
+
+StrLit: String = {
+    r#""(?:[^"\\]|\\.)*""# => {
+      let val = <>;
+      val[1..val.len() - 1].to_owned()
+    },
+}
+
+Comment: () = r";[^\n\r]*";
+
+
+Num: i32 = <r"[0-9]+"> => i32::from_str(<>).unwrap();
+
 
 
 // vim:shiftwidth=4
diff --git a/src/calc.rs b/src/calc.rs
index 7822044..19225cc 100644
--- a/src/calc.rs
+++ b/src/calc.rs
@@ -1,7 +1,6 @@
 // auto-generated: "lalrpop 0.19.5"
-// sha3: f4883744b015673a40928edc8f19edfbcd87416d27a5af7681a47c80f6af451
+// sha3: 7f1eed9c7f5eae965f19f037e3f83cc3f8b8ac855ed1b7d5e579d3c668c23b2
 use std::str::FromStr;
-use crate::lexer;
 use crate::Expr;
 #[allow(unused_extern_crates)]
 extern crate lalrpop_util as __lalrpop_util;
@@ -15,7 +14,6 @@ mod __parse__Expr {
     #![allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports, unused_parens)]
 
     use std::str::FromStr;
-    use crate::lexer;
     use crate::Expr;
     #[allow(unused_extern_crates)]
     extern crate lalrpop_util as __lalrpop_util;
@@ -23,40 +21,38 @@ mod __parse__Expr {
     use self::__lalrpop_util::state_machine as __state_machine;
     extern crate core;
     extern crate alloc;
-    use super::__ToTriple;
+    use self::__lalrpop_util::lexer::Token;
     #[allow(dead_code)]
-    pub(crate) enum __Symbol<>
+    pub(crate) enum __Symbol<'input>
      {
-        Variant0(lexer::Tok),
-        Variant1(i32),
-        Variant2(Expr),
-        Variant3(alloc::vec::Vec<Expr>),
-        Variant4(core::option::Option<Expr>),
-        Variant5(Vec<Expr>),
+        Variant0(&'input str),
+        Variant1(Expr),
+        Variant2(alloc::vec::Vec<Expr>),
+        Variant3(i32),
     }
     const __ACTION: &[i8] = &[
         // State 0
-        2, 0, 5, 0,
+        2, 0, 7, 8,
         // State 1
-        2, -11, 5, 0,
+        2, 0, 7, 8,
         // State 2
-        2, -13, 5, 0,
+        2, 11, 7, 8,
         // State 3
         0, 0, 0, 0,
         // State 4
-        0, -7, 0, -7,
+        -5, -5, -5, -5,
         // State 5
-        0, -10, 0, 9,
+        -6, -6, -6, -6,
         // State 6
-        0, 10, 0, 0,
+        -7, -7, -7, -7,
         // State 7
-        0, -12, 0, 11,
+        -8, -8, -8, -8,
         // State 8
-        -4, -4, -4, 0,
+        -2, -2, -2, -2,
         // State 9
-        0, -6, 0, -6,
+        -3, -3, -3, -3,
         // State 10
-        -5, -5, -5, 0,
+        -4, -4, -4, -4,
     ];
     fn __action(state: i8, integer: usize) -> i8 {
         __ACTION[(state as usize) * 4 + integer]
@@ -69,31 +65,32 @@ mod __parse__Expr {
         // State 2
         0,
         // State 3
-        -14,
+        -9,
         // State 4
-        -7,
+        -5,
         // State 5
-        0,
+        -6,
         // State 6
-        0,
+        -7,
         // State 7
-        0,
+        -8,
         // State 8
         0,
         // State 9
-        -6,
-        // State 10
         0,
+        // State 10
+        -4,
     ];
     fn __goto(state: i8, nt: usize) -> i8 {
         match nt {
-            2 => 2,
-            3 => match state {
-                1 => 5,
-                2 => 7,
+            1 => 2,
+            2 => match state {
+                1 => 8,
+                2 => 9,
                 _ => 3,
             },
-            5 => 6,
+            3 => 4,
+            4 => 5,
             _ => 0,
         }
     }
@@ -101,8 +98,8 @@ mod __parse__Expr {
         const __TERMINAL: &[&str] = &[
             r###""(""###,
             r###"")""###,
-            r###"Int"###,
-            r###"Space"###,
+            r###"r#":[^\\s]+"#"###,
+            r###"r#"[0-9]+"#"###,
         ];
         __TERMINAL.iter().enumerate().filter_map(|(index, terminal)| {
             let next_state = __action(__state, index);
@@ -113,19 +110,20 @@ mod __parse__Expr {
             }
         }).collect()
     }
-    pub(crate) struct __StateMachine<>
+    pub(crate) struct __StateMachine<'input>
     where 
     {
-        __phantom: core::marker::PhantomData<()>,
+        input: &'input str,
+        __phantom: core::marker::PhantomData<(&'input ())>,
     }
-    impl<> __state_machine::ParserDefinition for __StateMachine<>
+    impl<'input> __state_machine::ParserDefinition for __StateMachine<'input>
     where 
     {
         type Location = usize;
-        type Error = lexer::LexicalError;
-        type Token = lexer::Tok;
+        type Error = &'static str;
+        type Token = Token<'input>;
         type TokenIndex = usize;
-        type Symbol = __Symbol<>;
+        type Symbol = __Symbol<'input>;
         type Success = Expr;
         type StateIndex = i8;
         type Action = i8;
@@ -144,7 +142,7 @@ mod __parse__Expr {
 
         #[inline]
         fn token_to_index(&self, token: &Self::Token) -> Option<usize> {
-            __token_to_integer(token, core::marker::PhantomData::<()>)
+            __token_to_integer(token, core::marker::PhantomData::<(&())>)
         }
 
         #[inline]
@@ -168,7 +166,7 @@ mod __parse__Expr {
         }
 
         fn token_to_symbol(&self, token_index: usize, token: Self::Token) -> Self::Symbol {
-            __token_to_symbol(token_index, token, core::marker::PhantomData::<()>)
+            __token_to_symbol(token_index, token, core::marker::PhantomData::<(&())>)
         }
 
         fn expected_tokens(&self, state: i8) -> alloc::vec::Vec<alloc::string::String> {
@@ -196,11 +194,12 @@ mod __parse__Expr {
             symbols: &mut alloc::vec::Vec<__state_machine::SymbolTriple<Self>>,
         ) -> Option<__state_machine::ParseResult<Self>> {
             __reduce(
+                self.input,
                 action,
                 start_location,
                 states,
                 symbols,
-                core::marker::PhantomData::<()>,
+                core::marker::PhantomData::<(&())>,
             )
         }
 
@@ -209,120 +208,110 @@ mod __parse__Expr {
         }
     }
     fn __token_to_integer<
+        'input,
     >(
-        __token: &lexer::Tok,
-        _: core::marker::PhantomData<()>,
+        __token: &Token<'input>,
+        _: core::marker::PhantomData<(&'input ())>,
     ) -> Option<usize>
     {
         match *__token {
-            lexer::Tok::LPren if true => Some(0),
-            lexer::Tok::RPren if true => Some(1),
-            lexer::Tok::Int(_) if true => Some(2),
-            lexer::Tok::Space if true => Some(3),
+            Token(2, _) if true => Some(0),
+            Token(3, _) if true => Some(1),
+            Token(0, _) if true => Some(2),
+            Token(1, _) if true => Some(3),
             _ => None,
         }
     }
     fn __token_to_symbol<
+        'input,
     >(
         __token_index: usize,
-        __token: lexer::Tok,
-        _: core::marker::PhantomData<()>,
-    ) -> __Symbol<>
+        __token: Token<'input>,
+        _: core::marker::PhantomData<(&'input ())>,
+    ) -> __Symbol<'input>
     {
         match __token_index {
-            0 | 1 | 3 => __Symbol::Variant0(__token),
-            2 => match __token {
-                lexer::Tok::Int(__tok0) if true => __Symbol::Variant1(__tok0),
+            0 | 1 | 2 | 3 => match __token {
+                Token(2, __tok0) | Token(3, __tok0) | Token(0, __tok0) | Token(1, __tok0) if true => __Symbol::Variant0(__tok0),
                 _ => unreachable!(),
             },
             _ => unreachable!(),
         }
     }
     pub struct ExprParser {
+        builder: __lalrpop_util::lexer::MatcherBuilder,
         _priv: (),
     }
 
     impl ExprParser {
         pub fn new() -> ExprParser {
+            let __builder = super::__intern_token::new_builder();
             ExprParser {
+                builder: __builder,
                 _priv: (),
             }
         }
 
         #[allow(dead_code)]
         pub fn parse<
-            __TOKEN: __ToTriple<>,
-            __TOKENS: IntoIterator<Item=__TOKEN>,
+            'input,
         >(
             &self,
-            __tokens0: __TOKENS,
-        ) -> Result<Expr, __lalrpop_util::ParseError<usize, lexer::Tok, lexer::LexicalError>>
+            input: &'input str,
+        ) -> Result<Expr, __lalrpop_util::ParseError<usize, Token<'input>, &'static str>>
         {
-            let __tokens = __tokens0.into_iter();
-            let mut __tokens = __tokens.map(|t| __ToTriple::to_triple(t));
+            let mut __tokens = self.builder.matcher(input);
             __state_machine::Parser::drive(
                 __StateMachine {
-                    __phantom: core::marker::PhantomData::<()>,
+                    input,
+                    __phantom: core::marker::PhantomData::<(&())>,
                 },
                 __tokens,
             )
         }
     }
     pub(crate) fn __reduce<
+        'input,
     >(
+        input: &'input str,
         __action: i8,
         __lookahead_start: Option<&usize>,
         __states: &mut alloc::vec::Vec<i8>,
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,
-        _: core::marker::PhantomData<()>,
-    ) -> Option<Result<Expr,__lalrpop_util::ParseError<usize, lexer::Tok, lexer::LexicalError>>>
+        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: core::marker::PhantomData<(&'input ())>,
+    ) -> Option<Result<Expr,__lalrpop_util::ParseError<usize, Token<'input>, &'static str>>>
     {
         let (__pop_states, __nonterminal) = match __action {
             0 => {
-                __reduce0(__lookahead_start, __symbols, core::marker::PhantomData::<()>)
+                __reduce0(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)
             }
             1 => {
-                __reduce1(__lookahead_start, __symbols, core::marker::PhantomData::<()>)
+                __reduce1(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)
             }
             2 => {
-                __reduce2(__lookahead_start, __symbols, core::marker::PhantomData::<()>)
+                __reduce2(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)
             }
             3 => {
-                __reduce3(__lookahead_start, __symbols, core::marker::PhantomData::<()>)
+                __reduce3(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)
             }
             4 => {
-                __reduce4(__lookahead_start, __symbols, core::marker::PhantomData::<()>)
+                __reduce4(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)
             }
             5 => {
-                __reduce5(__lookahead_start, __symbols, core::marker::PhantomData::<()>)
+                __reduce5(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)
             }
             6 => {
-                __reduce6(__lookahead_start, __symbols, core::marker::PhantomData::<()>)
+                __reduce6(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)
             }
             7 => {
-                __reduce7(__lookahead_start, __symbols, core::marker::PhantomData::<()>)
+                __reduce7(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)
             }
             8 => {
-                __reduce8(__lookahead_start, __symbols, core::marker::PhantomData::<()>)
-            }
-            9 => {
-                __reduce9(__lookahead_start, __symbols, core::marker::PhantomData::<()>)
-            }
-            10 => {
-                __reduce10(__lookahead_start, __symbols, core::marker::PhantomData::<()>)
-            }
-            11 => {
-                __reduce11(__lookahead_start, __symbols, core::marker::PhantomData::<()>)
-            }
-            12 => {
-                __reduce12(__lookahead_start, __symbols, core::marker::PhantomData::<()>)
-            }
-            13 => {
                 // __Expr = Expr => ActionFn(0);
-                let __sym0 = __pop_Variant2(__symbols);
+                let __sym0 = __pop_Variant1(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym0.2.clone();
-                let __nt = super::__action0::<>(__sym0);
+                let __nt = super::__action0::<>(input, __sym0);
                 return Some(Ok(__nt));
             }
             _ => panic!("invalid action code {}", __action)
@@ -338,60 +327,44 @@ mod __parse__Expr {
     fn __symbol_type_mismatch() -> ! {
         panic!("symbol type mismatch")
     }
-    fn __pop_Variant2<
-    >(
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>
-    ) -> (usize, Expr, usize)
-     {
-        match __symbols.pop() {
-            Some((__l, __Symbol::Variant2(__v), __r)) => (__l, __v, __r),
-            _ => __symbol_type_mismatch()
-        }
-    }
-    fn __pop_Variant5<
-    >(
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>
-    ) -> (usize, Vec<Expr>, usize)
-     {
-        match __symbols.pop() {
-            Some((__l, __Symbol::Variant5(__v), __r)) => (__l, __v, __r),
-            _ => __symbol_type_mismatch()
-        }
-    }
-    fn __pop_Variant3<
-    >(
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>
-    ) -> (usize, alloc::vec::Vec<Expr>, usize)
-     {
-        match __symbols.pop() {
-            Some((__l, __Symbol::Variant3(__v), __r)) => (__l, __v, __r),
-            _ => __symbol_type_mismatch()
-        }
-    }
-    fn __pop_Variant4<
-    >(
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>
-    ) -> (usize, core::option::Option<Expr>, usize)
-     {
-        match __symbols.pop() {
-            Some((__l, __Symbol::Variant4(__v), __r)) => (__l, __v, __r),
-            _ => __symbol_type_mismatch()
-        }
-    }
     fn __pop_Variant1<
+      'input,
     >(
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>
-    ) -> (usize, i32, usize)
+        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, Expr, usize)
      {
         match __symbols.pop() {
             Some((__l, __Symbol::Variant1(__v), __r)) => (__l, __v, __r),
             _ => __symbol_type_mismatch()
         }
     }
-    fn __pop_Variant0<
+    fn __pop_Variant2<
+      'input,
     >(
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>
-    ) -> (usize, lexer::Tok, usize)
+        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, alloc::vec::Vec<Expr>, usize)
+     {
+        match __symbols.pop() {
+            Some((__l, __Symbol::Variant2(__v), __r)) => (__l, __v, __r),
+            _ => __symbol_type_mismatch()
+        }
+    }
+    fn __pop_Variant3<
+      'input,
+    >(
+        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, i32, usize)
+     {
+        match __symbols.pop() {
+            Some((__l, __Symbol::Variant3(__v), __r)) => (__l, __v, __r),
+            _ => __symbol_type_mismatch()
+        }
+    }
+    fn __pop_Variant0<
+      'input,
+    >(
+        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, &'input str, usize)
      {
         match __symbols.pop() {
             Some((__l, __Symbol::Variant0(__v), __r)) => (__l, __v, __r),
@@ -399,306 +372,256 @@ mod __parse__Expr {
         }
     }
     pub(crate) fn __reduce0<
+        'input,
     >(
+        input: &'input str,
         __lookahead_start: Option<&usize>,
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,
-        _: core::marker::PhantomData<()>,
+        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: core::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // (<Expr> Space) = Expr, Space => ActionFn(8);
-        assert!(__symbols.len() >= 2);
-        let __sym1 = __pop_Variant0(__symbols);
-        let __sym0 = __pop_Variant2(__symbols);
-        let __start = __sym0.0.clone();
-        let __end = __sym1.2.clone();
-        let __nt = super::__action8::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
-        (2, 0)
-    }
-    pub(crate) fn __reduce1<
-    >(
-        __lookahead_start: Option<&usize>,
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,
-        _: core::marker::PhantomData<()>,
-    ) -> (usize, usize)
-    {
-        // (<Expr> Space)* =  => ActionFn(6);
-        let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default();
-        let __end = __start.clone();
-        let __nt = super::__action6::<>(&__start, &__end);
-        __symbols.push((__start, __Symbol::Variant3(__nt), __end));
-        (0, 1)
-    }
-    pub(crate) fn __reduce2<
-    >(
-        __lookahead_start: Option<&usize>,
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,
-        _: core::marker::PhantomData<()>,
-    ) -> (usize, usize)
-    {
-        // (<Expr> Space)* = (<Expr> Space)+ => ActionFn(7);
-        let __sym0 = __pop_Variant3(__symbols);
-        let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action7::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant3(__nt), __end));
-        (1, 1)
-    }
-    pub(crate) fn __reduce3<
-    >(
-        __lookahead_start: Option<&usize>,
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,
-        _: core::marker::PhantomData<()>,
-    ) -> (usize, usize)
-    {
-        // (<Expr> Space)+ = Expr, Space => ActionFn(11);
-        assert!(__symbols.len() >= 2);
-        let __sym1 = __pop_Variant0(__symbols);
-        let __sym0 = __pop_Variant2(__symbols);
-        let __start = __sym0.0.clone();
-        let __end = __sym1.2.clone();
-        let __nt = super::__action11::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant3(__nt), __end));
-        (2, 2)
-    }
-    pub(crate) fn __reduce4<
-    >(
-        __lookahead_start: Option<&usize>,
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,
-        _: core::marker::PhantomData<()>,
-    ) -> (usize, usize)
-    {
-        // (<Expr> Space)+ = (<Expr> Space)+, Expr, Space => ActionFn(12);
-        assert!(__symbols.len() >= 3);
-        let __sym2 = __pop_Variant0(__symbols);
-        let __sym1 = __pop_Variant2(__symbols);
-        let __sym0 = __pop_Variant3(__symbols);
-        let __start = __sym0.0.clone();
-        let __end = __sym2.2.clone();
-        let __nt = super::__action12::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant3(__nt), __end));
-        (3, 2)
-    }
-    pub(crate) fn __reduce5<
-    >(
-        __lookahead_start: Option<&usize>,
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,
-        _: core::marker::PhantomData<()>,
-    ) -> (usize, usize)
-    {
-        // Expr = "(", Sep<Expr, Space>, ")" => ActionFn(1);
-        assert!(__symbols.len() >= 3);
-        let __sym2 = __pop_Variant0(__symbols);
-        let __sym1 = __pop_Variant5(__symbols);
-        let __sym0 = __pop_Variant0(__symbols);
-        let __start = __sym0.0.clone();
-        let __end = __sym2.2.clone();
-        let __nt = super::__action1::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
-        (3, 3)
-    }
-    pub(crate) fn __reduce6<
-    >(
-        __lookahead_start: Option<&usize>,
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,
-        _: core::marker::PhantomData<()>,
-    ) -> (usize, usize)
-    {
-        // Expr = Int => ActionFn(2);
+        // (<Expr>) = Expr => ActionFn(8);
         let __sym0 = __pop_Variant1(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action2::<>(__sym0);
+        let __nt = super::__action8::<>(input, __sym0);
+        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
+        (1, 0)
+    }
+    pub(crate) fn __reduce1<
+        'input,
+    >(
+        input: &'input str,
+        __lookahead_start: Option<&usize>,
+        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: core::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // (<Expr>)+ = Expr => ActionFn(9);
+        let __sym0 = __pop_Variant1(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action9::<>(input, __sym0);
         __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 1)
+    }
+    pub(crate) fn __reduce2<
+        'input,
+    >(
+        input: &'input str,
+        __lookahead_start: Option<&usize>,
+        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: core::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // (<Expr>)+ = (<Expr>)+, Expr => ActionFn(10);
+        assert!(__symbols.len() >= 2);
+        let __sym1 = __pop_Variant1(__symbols);
+        let __sym0 = __pop_Variant2(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym1.2.clone();
+        let __nt = super::__action10::<>(input, __sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (2, 1)
+    }
+    pub(crate) fn __reduce3<
+        'input,
+    >(
+        input: &'input str,
+        __lookahead_start: Option<&usize>,
+        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: core::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // Expr = "(", (<Expr>)+, ")" => ActionFn(1);
+        assert!(__symbols.len() >= 3);
+        let __sym2 = __pop_Variant0(__symbols);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym2.2.clone();
+        let __nt = super::__action1::<>(input, __sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
+        (3, 2)
+    }
+    pub(crate) fn __reduce4<
+        'input,
+    >(
+        input: &'input str,
+        __lookahead_start: Option<&usize>,
+        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: core::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // Expr = Keyword => ActionFn(2);
+        let __sym0 = __pop_Variant1(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action2::<>(input, __sym0);
+        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
+        (1, 2)
+    }
+    pub(crate) fn __reduce5<
+        'input,
+    >(
+        input: &'input str,
+        __lookahead_start: Option<&usize>,
+        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: core::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // Expr = Num => ActionFn(3);
+        let __sym0 = __pop_Variant3(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action3::<>(input, __sym0);
+        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
+        (1, 2)
+    }
+    pub(crate) fn __reduce6<
+        'input,
+    >(
+        input: &'input str,
+        __lookahead_start: Option<&usize>,
+        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: core::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // Keyword = r#":[^\\s]+"# => ActionFn(4);
+        let __sym0 = __pop_Variant0(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action4::<>(input, __sym0);
+        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
         (1, 3)
     }
     pub(crate) fn __reduce7<
+        'input,
     >(
+        input: &'input str,
         __lookahead_start: Option<&usize>,
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,
-        _: core::marker::PhantomData<()>,
+        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: core::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Expr? = Expr => ActionFn(4);
-        let __sym0 = __pop_Variant2(__symbols);
+        // Num = r#"[0-9]+"# => ActionFn(5);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action4::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant4(__nt), __end));
+        let __nt = super::__action5::<>(input, __sym0);
+        __symbols.push((__start, __Symbol::Variant3(__nt), __end));
         (1, 4)
     }
-    pub(crate) fn __reduce8<
-    >(
-        __lookahead_start: Option<&usize>,
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,
-        _: core::marker::PhantomData<()>,
-    ) -> (usize, usize)
-    {
-        // Expr? =  => ActionFn(5);
-        let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default();
-        let __end = __start.clone();
-        let __nt = super::__action5::<>(&__start, &__end);
-        __symbols.push((__start, __Symbol::Variant4(__nt), __end));
-        (0, 4)
-    }
-    pub(crate) fn __reduce9<
-    >(
-        __lookahead_start: Option<&usize>,
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,
-        _: core::marker::PhantomData<()>,
-    ) -> (usize, usize)
-    {
-        // Sep<Expr, Space> = Expr => ActionFn(15);
-        let __sym0 = __pop_Variant2(__symbols);
-        let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action15::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant5(__nt), __end));
-        (1, 5)
-    }
-    pub(crate) fn __reduce10<
-    >(
-        __lookahead_start: Option<&usize>,
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,
-        _: core::marker::PhantomData<()>,
-    ) -> (usize, usize)
-    {
-        // Sep<Expr, Space> =  => ActionFn(16);
-        let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default();
-        let __end = __start.clone();
-        let __nt = super::__action16::<>(&__start, &__end);
-        __symbols.push((__start, __Symbol::Variant5(__nt), __end));
-        (0, 5)
-    }
-    pub(crate) fn __reduce11<
-    >(
-        __lookahead_start: Option<&usize>,
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,
-        _: core::marker::PhantomData<()>,
-    ) -> (usize, usize)
-    {
-        // Sep<Expr, Space> = (<Expr> Space)+, Expr => ActionFn(17);
-        assert!(__symbols.len() >= 2);
-        let __sym1 = __pop_Variant2(__symbols);
-        let __sym0 = __pop_Variant3(__symbols);
-        let __start = __sym0.0.clone();
-        let __end = __sym1.2.clone();
-        let __nt = super::__action17::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant5(__nt), __end));
-        (2, 5)
-    }
-    pub(crate) fn __reduce12<
-    >(
-        __lookahead_start: Option<&usize>,
-        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,
-        _: core::marker::PhantomData<()>,
-    ) -> (usize, usize)
-    {
-        // Sep<Expr, Space> = (<Expr> Space)+ => ActionFn(18);
-        let __sym0 = __pop_Variant3(__symbols);
-        let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action18::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant5(__nt), __end));
-        (1, 5)
-    }
 }
 pub use self::__parse__Expr::ExprParser;
+#[cfg_attr(rustfmt, rustfmt_skip)]
+mod __intern_token {
+    #![allow(unused_imports)]
+    use std::str::FromStr;
+    use crate::Expr;
+    #[allow(unused_extern_crates)]
+    extern crate lalrpop_util as __lalrpop_util;
+    #[allow(unused_imports)]
+    use self::__lalrpop_util::state_machine as __state_machine;
+    extern crate core;
+    extern crate alloc;
+    pub fn new_builder() -> __lalrpop_util::lexer::MatcherBuilder {
+        let __strs: &[(&str, bool)] = &[
+            ("^(:[\u{0}-\u{8}\u{e}-\u{1f}!-\u{84}\u{86}-\u{9f}¡-ᙿᚁ-\u{1fff}\u{200b}-‧\u{202a}-\u{202e}‰-⁞\u{2060}-\u{2fff}、-\u{10ffff}]+)", false),
+            ("^([0-9]+)", false),
+            ("^(\\()", false),
+            ("^(\\))", false),
+            (r"^(\s*)", true),
+        ];
+        __lalrpop_util::lexer::MatcherBuilder::new(__strs.iter().copied()).unwrap()
+    }
+}
+pub(crate) use self::__lalrpop_util::lexer::Token;
 
+#[allow(unused_variables)]
 fn __action0<
+    'input,
 >(
+    input: &'input str,
     (_, __0, _): (usize, Expr, usize),
 ) -> Expr
 {
     __0
 }
 
+#[allow(unused_variables)]
 fn __action1<
+    'input,
 >(
-    (_, _, _): (usize, lexer::Tok, usize),
-    (_, elems, _): (usize, Vec<Expr>, usize),
-    (_, _, _): (usize, lexer::Tok, usize),
+    input: &'input str,
+    (_, _, _): (usize, &'input str, usize),
+    (_, elems, _): (usize, alloc::vec::Vec<Expr>, usize),
+    (_, _, _): (usize, &'input str, usize),
 ) -> Expr
 {
     Expr::List(elems)
 }
 
+#[allow(unused_variables)]
 fn __action2<
+    'input,
 >(
-    (_, n, _): (usize, i32, usize),
+    input: &'input str,
+    (_, x, _): (usize, Expr, usize),
 ) -> Expr
 {
-    Expr::Number(n)
+    x
 }
 
+#[allow(unused_variables)]
 fn __action3<
+    'input,
 >(
-    (_, mut v, _): (usize, alloc::vec::Vec<Expr>, usize),
-    (_, e, _): (usize, core::option::Option<Expr>, usize),
-) -> Vec<Expr>
-{
-    match e {
-        None => v,
-        Some(e) => {
-            v.push(e);
-            v
-        }
-    }
-}
-
-fn __action4<
->(
-    (_, __0, _): (usize, Expr, usize),
-) -> core::option::Option<Expr>
-{
-    Some(__0)
-}
-
-fn __action5<
->(
-    __lookbehind: &usize,
-    __lookahead: &usize,
-) -> core::option::Option<Expr>
-{
-    None
-}
-
-fn __action6<
->(
-    __lookbehind: &usize,
-    __lookahead: &usize,
-) -> alloc::vec::Vec<Expr>
-{
-    alloc::vec![]
-}
-
-fn __action7<
->(
-    (_, v, _): (usize, alloc::vec::Vec<Expr>, usize),
-) -> alloc::vec::Vec<Expr>
-{
-    v
-}
-
-fn __action8<
->(
-    (_, __0, _): (usize, Expr, usize),
-    (_, _, _): (usize, lexer::Tok, usize),
+    input: &'input str,
+    (_, x, _): (usize, i32, usize),
 ) -> Expr
 {
-    __0
+    Expr::Number(x)
 }
 
-fn __action9<
+#[allow(unused_variables)]
+fn __action4<
+    'input,
 >(
+    input: &'input str,
+    (_, __0, _): (usize, &'input str, usize),
+) -> Expr
+{
+    Expr::Keyword(__0.to_string())
+}
+
+#[allow(unused_variables)]
+fn __action5<
+    'input,
+>(
+    input: &'input str,
+    (_, __0, _): (usize, &'input str, usize),
+) -> i32
+{
+    i32::from_str(__0).unwrap()
+}
+
+#[allow(unused_variables)]
+fn __action6<
+    'input,
+>(
+    input: &'input str,
     (_, __0, _): (usize, Expr, usize),
 ) -> alloc::vec::Vec<Expr>
 {
     alloc::vec![__0]
 }
 
-fn __action10<
+#[allow(unused_variables)]
+fn __action7<
+    'input,
 >(
+    input: &'input str,
     (_, v, _): (usize, alloc::vec::Vec<Expr>, usize),
     (_, e, _): (usize, Expr, usize),
 ) -> alloc::vec::Vec<Expr>
@@ -706,161 +629,72 @@ fn __action10<
     { let mut v = v; v.push(e); v }
 }
 
-fn __action11<
+#[allow(unused_variables)]
+fn __action8<
+    'input,
 >(
+    input: &'input str,
+    (_, __0, _): (usize, Expr, usize),
+) -> Expr
+{
+    __0
+}
+
+#[allow(unused_variables)]
+fn __action9<
+    'input,
+>(
+    input: &'input str,
     __0: (usize, Expr, usize),
-    __1: (usize, lexer::Tok, usize),
 ) -> alloc::vec::Vec<Expr>
 {
     let __start0 = __0.0.clone();
-    let __end0 = __1.2.clone();
+    let __end0 = __0.2.clone();
     let __temp0 = __action8(
+        input,
         __0,
-        __1,
     );
     let __temp0 = (__start0, __temp0, __end0);
-    __action9(
+    __action6(
+        input,
         __temp0,
     )
 }
 
-fn __action12<
+#[allow(unused_variables)]
+fn __action10<
+    'input,
 >(
+    input: &'input str,
     __0: (usize, alloc::vec::Vec<Expr>, usize),
     __1: (usize, Expr, usize),
-    __2: (usize, lexer::Tok, usize),
 ) -> alloc::vec::Vec<Expr>
-{
-    let __start0 = __1.0.clone();
-    let __end0 = __2.2.clone();
-    let __temp0 = __action8(
-        __1,
-        __2,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action10(
-        __0,
-        __temp0,
-    )
-}
-
-fn __action13<
->(
-    __0: (usize, core::option::Option<Expr>, usize),
-) -> Vec<Expr>
-{
-    let __start0 = __0.0.clone();
-    let __end0 = __0.0.clone();
-    let __temp0 = __action6(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action3(
-        __temp0,
-        __0,
-    )
-}
-
-fn __action14<
->(
-    __0: (usize, alloc::vec::Vec<Expr>, usize),
-    __1: (usize, core::option::Option<Expr>, usize),
-) -> Vec<Expr>
-{
-    let __start0 = __0.0.clone();
-    let __end0 = __0.2.clone();
-    let __temp0 = __action7(
-        __0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action3(
-        __temp0,
-        __1,
-    )
-}
-
-fn __action15<
->(
-    __0: (usize, Expr, usize),
-) -> Vec<Expr>
-{
-    let __start0 = __0.0.clone();
-    let __end0 = __0.2.clone();
-    let __temp0 = __action4(
-        __0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action13(
-        __temp0,
-    )
-}
-
-fn __action16<
->(
-    __lookbehind: &usize,
-    __lookahead: &usize,
-) -> Vec<Expr>
-{
-    let __start0 = __lookbehind.clone();
-    let __end0 = __lookahead.clone();
-    let __temp0 = __action5(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action13(
-        __temp0,
-    )
-}
-
-fn __action17<
->(
-    __0: (usize, alloc::vec::Vec<Expr>, usize),
-    __1: (usize, Expr, usize),
-) -> Vec<Expr>
 {
     let __start0 = __1.0.clone();
     let __end0 = __1.2.clone();
-    let __temp0 = __action4(
+    let __temp0 = __action8(
+        input,
         __1,
     );
     let __temp0 = (__start0, __temp0, __end0);
-    __action14(
+    __action7(
+        input,
         __0,
         __temp0,
     )
 }
 
-fn __action18<
->(
-    __0: (usize, alloc::vec::Vec<Expr>, usize),
-) -> Vec<Expr>
-{
-    let __start0 = __0.2.clone();
-    let __end0 = __0.2.clone();
-    let __temp0 = __action5(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action14(
-        __0,
-        __temp0,
-    )
+pub trait __ToTriple<'input, > {
+    fn to_triple(value: Self) -> Result<(usize,Token<'input>,usize), __lalrpop_util::ParseError<usize, Token<'input>, &'static str>>;
 }
 
-pub trait __ToTriple<> {
-    fn to_triple(value: Self) -> Result<(usize,lexer::Tok,usize), __lalrpop_util::ParseError<usize, lexer::Tok, lexer::LexicalError>>;
-}
-
-impl<> __ToTriple<> for (usize, lexer::Tok, usize) {
-    fn to_triple(value: Self) -> Result<(usize,lexer::Tok,usize), __lalrpop_util::ParseError<usize, lexer::Tok, lexer::LexicalError>> {
+impl<'input, > __ToTriple<'input, > for (usize, Token<'input>, usize) {
+    fn to_triple(value: Self) -> Result<(usize,Token<'input>,usize), __lalrpop_util::ParseError<usize, Token<'input>, &'static str>> {
         Ok(value)
     }
 }
-impl<> __ToTriple<> for Result<(usize, lexer::Tok, usize), lexer::LexicalError> {
-    fn to_triple(value: Self) -> Result<(usize,lexer::Tok,usize), __lalrpop_util::ParseError<usize, lexer::Tok, lexer::LexicalError>> {
+impl<'input, > __ToTriple<'input, > for Result<(usize, Token<'input>, usize), &'static str> {
+    fn to_triple(value: Self) -> Result<(usize,Token<'input>,usize), __lalrpop_util::ParseError<usize, Token<'input>, &'static str>> {
         match value {
             Ok(v) => Ok(v),
             Err(error) => Err(__lalrpop_util::ParseError::User { error }),
diff --git a/src/main.rs b/src/main.rs
index 7c14565..99bbd5d 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,16 +1,50 @@
 #![allow(unused_imports)]
 
+use itertools::Itertools;
+
 use lalrpop_util::lalrpop_mod;
 
-mod lexer;
+//mod lexer;
 
 lalrpop_mod!(pub calc);
 
+#[derive(Debug, Eq, PartialEq, Clone, Copy)]
+pub struct Sp<T>(pub usize, pub T, pub usize);
+
+impl<T: std::fmt::Display> std::fmt::Display for Sp<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "<{}- {} -{}>", self.0, self.1, self.2)
+    }
+}
+
 #[derive(Debug)]
 pub enum Expr {
-    List(Vec<Expr>),
+    List(Vec<Sp<Expr>>),
+    Table(Vec<(Sp<Expr>, Sp<Expr>)>),
+    Keyword(String),
     Symbol(String),
+    Str(String),
     Number(i32),
+    Comment,
+}
+
+impl std::fmt::Display for Expr {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use Expr::*;
+        match self {
+            Number(x) => write!(f, "{}", x),
+            List(x) => write!(f, "({})", x.iter().map(|e| format!("{}", e)).join(" ")),
+            Table(x) => write!(
+                f,
+                "{{{}}}",
+                x.iter().map(|(k, v)| format!("{} {}", k, v)).join(" ")
+            ),
+            Keyword(x) => write!(f, "{}", x),
+            Symbol(x) => write!(f, "{}", x),
+            Str(x) => write!(f, "{}", x),
+            Comment => write!(f, ""),
+        }
+    }
 }
 
 fn main() {}
@@ -19,22 +53,38 @@ fn main() {}
 macro_rules! test_p {
     ($e:expr) => {
         let e = $e;
-        let lex = crate::lexer::Lexer::new(e);
         let p = calc::ExprParser::new();
-        match p.parse(lex) {
-            Ok(res) => println!("{:?}", res),
-            Err(e) => eprintln!("{:?}", e),
+        match p.parse(e) {
+            Ok(res) => println!("{}\n=> {}\n", e, res),
+            Err(e) => eprintln!("{}", e),
         }
     };
 }
 
 #[test]
 fn calc() {
-    //assert!(calc::ExprParser::new().parse("(1 2 3)").is_ok());
-
     test_p!("1");
     test_p!("(12)");
     test_p!("(1 2)");
+    test_p!("(1 :foo 1)");
+    test_p!("(:foo 1)");
+    test_p!("(:foo->: 1)");
+    test_p!("(foo 1)");
+    test_p!("(lol😄 1)");
+
+    test_p!(r#"(test "hi")"#);
+    test_p!(r#"(test "h\"i")"#);
+    test_p!(r#"(test " hi ")"#);
+
+    test_p!("(+ (1 2 (* 2 5)))");
+
+    test_p!(r#"{:key value 12 "hi" (test) (1 2 3)}"#);
+
+    test_p!(r#"; test"#);
+    test_p!(
+        r#"(f arg ; test
+              arg2)"#
+    );
 
     println!("\n\n\n\n\n\n");