1 files changed, 28 insertions, 9 deletions

diff --git a/src/lisp/eval.rs b/src/lisp/eval.rs
index cb8ce68..d11ad30 100644
--- a/src/lisp/eval.rs
+++ b/src/lisp/eval.rs
@@ -31,7 +31,7 @@ where
             LispExpr::Number(_) => Ok(expr.clone()),
             LispExpr::BoolLit(_) => Ok(expr.clone()),
             LispExpr::Ident(ref id) => lookup(&self.app.lisp_env, id),
-            LispExpr::Quote(_, _) => Ok(expr.clone()),
+            LispExpr::Quote(item, _) => Ok(apply_quote(&item.as_ref())),
             LispExpr::List(li) => {
                 let func_expr = &li[0];
                 match func_expr {
@@ -41,7 +41,7 @@ where
                         "lambda" => create_lambda(&li[1..]),
                         "if" => self.eval_if(&li[1..]),
                         "cond" => self.eval_cond(&li[1..]),
-                        "quote" => quote_var(&li[1..]),
+                        "quote" => Ok(apply_quote(&li[1])),
                         _ => {
                             let mut new_ls = vec![self.eval(&func_expr)?];
                             new_ls.extend(li[1..].to_vec());
@@ -215,12 +215,15 @@ where
     }
 }
 
-pub fn quote_var(args: &[LispExpr]) -> Result<LispExpr, LispError> {
-    let arity = Arity::Exact(1);
-    if !arity.check(args) {
-        return Err(arity.to_error());
-    } else {
-        return Ok(args[0].clone().quote(1));
+pub fn apply_quote(arg: &LispExpr) -> LispExpr {
+    match arg {
+        i @ LispExpr::Unit
+        | i @ LispExpr::StringLit(_)
+        | i @ LispExpr::Char(_)
+        | i @ LispExpr::Number(_)
+        | i @ LispExpr::BoolLit(_) => i.clone(),
+        LispExpr::List(ls) => LispExpr::List(ls.iter().map(|a| apply_quote(a)).collect::<Vec<_>>()),
+        _ => arg.clone(),
     }
 }
 
@@ -313,12 +316,28 @@ mod tests {
         assert!(run("(eq? '(1 2 3) '(1 2 3))", app).cast_bool());
         assert!(run("(eq? '(1 '(1 2 3)) '(1 '(1 2 3)))", app).cast_bool(),);
         assert!(run("(eq? '#t '#t)", app).cast_bool());
+
+        assert!(run("(eq? 1 '1)", app).cast_bool());
+        assert_eq!(
+            run("'(1 2 3)", app),
+            LispExpr::List(
+                vec![1, 2, 3]
+                    .into_iter()
+                    .map(LispNumber::Integer)
+                    .map(LispExpr::Number)
+                    .collect()
+            ),
+        );
+        assert_eq!(
+            run("(caar (cdr '(1 (4 5))))", app),
+            LispExpr::Number(LispNumber::Integer(4))
+        );
     }
 
     fn eval_logical(app: &mut AppState) {
         assert!(run("(and #t #t)", app).cast_bool());
         assert!(run("(or #f #t)", app).cast_bool());
-        assert!(run("(not #t)", app).cast_bool());
+        assert!(!run("(not #t)", app).cast_bool());
         assert_eq!(run("(not #f)", app), run("(not (not #t))", app));
     }
 }