add Debug & PartialEq impls for LispExpr; add eval tests

1 files changed, 42 insertions, 12 deletions

diff --git a/src/lisp/expr.rs b/src/lisp/expr.rs
index 8fd794e..059113b 100644
--- a/src/lisp/expr.rs
+++ b/src/lisp/expr.rs
@@ -1,4 +1,4 @@
-use std::{convert::TryFrom, fmt};
+use std::{cmp::PartialEq, convert::TryFrom, fmt};
 
 use crate::app::AppState;
 use crate::lisp::{
@@ -177,6 +177,47 @@ impl fmt::Display for LispExpr {
     }
 }
 
+impl fmt::Debug for LispExpr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            LispExpr::Unit => f.debug_tuple("Unit").finish(),
+            LispExpr::Number(n) => write!(f, "Number({:?})", n),
+            LispExpr::List(l) => f.debug_list().entries(l.iter()).finish(),
+            LispExpr::StringLit(s) => write!(f, "String({:?})", s),
+            LispExpr::Char(c) => write!(f, "Char({:?})", c),
+            LispExpr::BoolLit(b) => write!(f, "Bool({:?})", b),
+            LispExpr::Ident(s) => write!(f, "Ident({})", s),
+            LispExpr::PrimitiveFunc(_) => write!(f, "Primitive"),
+            LispExpr::Function(func) => write!(f, "<#lambda> {}", func.params.join(" ")),
+            LispExpr::Quasiquote(val, depth) => write!(f, "{}{}", "`".repeat(*depth as usize), val),
+            LispExpr::Comma(val, depth) => write!(f, "{}{}", ",".repeat(*depth as usize), val),
+            LispExpr::CommaAt(val, depth) => write!(f, "{}@{}", ",".repeat(*depth as usize), val),
+            LispExpr::Quote(val, depth) => write!(f, "{}{}", "'".repeat(*depth as usize), val),
+        }
+    }
+}
+
+impl PartialEq for LispExpr {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (LispExpr::Unit, LispExpr::Unit) => true,
+            (LispExpr::Number(s), LispExpr::Number(o)) => s == o,
+            (LispExpr::List(s), LispExpr::List(o)) => s.iter().zip(o).all(|(a, b)| a == b),
+            (LispExpr::StringLit(s), LispExpr::StringLit(o)) => s == o,
+            (LispExpr::Char(s), LispExpr::Char(o)) => s == o,
+            (LispExpr::BoolLit(s), LispExpr::BoolLit(o)) => s == o,
+            (LispExpr::Ident(s), LispExpr::Ident(o)) => s == o,
+            (LispExpr::PrimitiveFunc(_), LispExpr::PrimitiveFunc(_)) => false,
+            (LispExpr::Function(_), LispExpr::Function(_)) => false,
+            (LispExpr::Quasiquote(s, sd), LispExpr::Quasiquote(o, od)) => (s, sd) == (o, od),
+            (LispExpr::Comma(s, sd), LispExpr::Comma(o, od)) => (s, sd) == (o, od),
+            (LispExpr::CommaAt(s, sd), LispExpr::CommaAt(o, od)) => (s, sd) == (o, od),
+            (LispExpr::Quote(s, sd), LispExpr::Quote(o, od)) => (s, sd) == (o, od),
+            _ => false,
+        }
+    }
+}
+
 impl TryFrom<LispExpr> for LispNumber {
     type Error = LispError;
     fn try_from(value: LispExpr) -> Result<Self, Self::Error> {
@@ -197,17 +238,6 @@ impl<'a> TryFrom<&'a LispExpr> for &'a LispNumber {
     }
 }
 
-//impl TryFrom<LispExpr> for Ident {
-//    type Error = LispError;
-//    fn try_from(value: LispExpr) -> Result<Self, Self::Error> {
-//        match value {
-//            LispExpr::Ident(i) => Ok(i),
-//            _ => Err(LispError::Eval(EvalError::TypeMismatch)),
-//        }
-//    }
-//}
-//
-//
 impl TryFrom<LispExpr> for String {
     type Error = LispError;
     fn try_from(value: LispExpr) -> Result<Self, Self::Error> {