1 files changed, 52 insertions, 8 deletions

diff --git a/src/lisp/expr.rs b/src/lisp/expr.rs
index 934bb4a..9f2dc8d 100644
--- a/src/lisp/expr.rs
+++ b/src/lisp/expr.rs
@@ -117,6 +117,8 @@ impl LispExpr {
                 .iter()
                 .zip(o)
                 .all(|(a, b)| matches!(a.compare(b, envs), Ok(true)))),
+            (LispExpr::List(s), LispExpr::Unit) => Ok(s.len() == 0),
+            (LispExpr::Unit, LispExpr::List(s)) => Ok(s.len() == 0),
             (LispExpr::StringLit(s), LispExpr::StringLit(o)) => Ok(s == o),
             (LispExpr::Char(s), LispExpr::Char(o)) => Ok(s == o),
             (LispExpr::BoolLit(s), LispExpr::BoolLit(o)) => Ok(s == o),
@@ -142,6 +144,56 @@ impl LispExpr {
             _ => Err(EvalError::TypeMismatch.into()),
         }
     }
+
+    // have these be code gen'd somehow
+    pub fn unwrap_number(&self) -> LispNumber {
+        match &self {
+            LispExpr::Number(p) => p.clone(),
+            _ => panic!("attempt to call `unwrap_number` on invalid type"),
+        }
+    }
+
+    pub fn unwrap_list(&self) -> Vec<LispExpr> {
+        match &self {
+            LispExpr::List(p) => p.clone(),
+            _ => panic!("attempt to call `unwrap_number` on invalid type"),
+        }
+    }
+
+    pub fn unwrap_stringlit(&self) -> String {
+        match &self {
+            LispExpr::StringLit(p) => p.clone(),
+            _ => panic!("attempt to call `unwrap_stringlit` on invalid type"),
+        }
+    }
+
+    pub fn unwrap_ident(&self) -> String {
+        match &self {
+            LispExpr::Ident(p) => p.clone(),
+            _ => panic!("attempt to call `unwrap_ident` on invalid type"),
+        }
+    }
+
+    pub fn unwrap_primitive_func(&self) -> PrimitiveFunc {
+        match &self {
+            LispExpr::PrimitiveFunc(p) => p.clone(),
+            _ => panic!("attempt to call `unwrap_primitive_func` on invalid type"),
+        }
+    }
+
+    pub fn unwrap_function(&self) -> LispFunction {
+        match &self {
+            LispExpr::Function(p) => p.clone(),
+            _ => panic!("attempt to call `unwrap_function` on invalid type"),
+        }
+    }
+
+    pub fn cast_bool(&self) -> bool {
+        match &self {
+            LispExpr::BoolLit(false) => false,
+            _ => true,
+        }
+    }
 }
 
 impl fmt::Display for LispExpr {
@@ -270,11 +322,3 @@ impl TryFrom<LispExpr> for BoolLit {
         }
     }
 }
-
-pub fn is_ident<E: AsRef<LispExpr>>(expr: E) -> bool {
-    matches!(expr.as_ref(), LispExpr::Ident(_))
-}
-
-pub fn is_number<E: AsRef<LispExpr>>(expr: E) -> bool {
-    matches!(expr.as_ref(), LispExpr::Number(_))
-}