1 files changed, 91 insertions, 13 deletions

diff --git a/src/lisp/prelude.rs b/src/lisp/prelude.rs
index d8a930b..dffd9f4 100644
--- a/src/lisp/prelude.rs
+++ b/src/lisp/prelude.rs
@@ -3,11 +3,12 @@ use crate::{
     lisp::{
         error::{EvalError, LispError},
         eval::eval,
-        expr::{is_ident, Arity, LispExpr},
+        expr::{Arity, LispExpr},
         number::LispNumber,
         Environment,
     },
     primitive,
+    utils::load_script,
 };
 
 use std::{convert::TryInto, fs::File, io::Write};
@@ -27,7 +28,7 @@ macro_rules! primitive {
 
 #[macro_export]
 macro_rules! type_match {
-    ($args:expr, $($range:expr => $kind:pat),+) => {
+    ($args:expr, $($range:literal => $kind:pat),+) => {
         {
             let mut temp_vec = vec![];
             $(
@@ -35,10 +36,21 @@ macro_rules! type_match {
             )+
             temp_vec.iter().all(|&t| t)
         }
+    };
+    ($args:expr, $($range:expr => $kind:pat),+) => {
+        {
+            let mut temp_vec = vec![];
+            $(
+                for arg in &$args[$range] {
+                    temp_vec.push(matches!(arg, $kind));
+                }
+            )+
+            temp_vec.iter().all(|&t| t)
+        }
     }
 }
 
-pub fn new_env() -> Environment {
+pub fn new_env() -> Result<Environment, LispError> {
     let mut env = Environment::new();
 
     primitive!(env, Arity::Atleast(2), "+", |args, _| {
@@ -113,7 +125,7 @@ pub fn new_env() -> Environment {
     });
 
     primitive!(env, Arity::Exact(1), "not", |args, _| {
-        if matches!(&args[0], LispExpr::BoolLit(false)) {
+        if type_match!(args, 0 => LispExpr::BoolLit(false)) {
             Ok(LispExpr::BoolLit(true))
         } else {
             Ok(LispExpr::BoolLit(false))
@@ -121,11 +133,7 @@ pub fn new_env() -> Environment {
     });
 
     primitive!(env, Arity::Atleast(1), "begin", |args, _| {
-        if args.is_empty() {
-            Err(EvalError::ArgumentCount(Arity::Atleast(1)).into())
-        } else {
-            Ok(args.into_iter().last().unwrap().clone())
-        }
+        Ok(args.into_iter().last().unwrap().clone())
     });
 
     primitive!(env, Arity::Exact(0), "quit", |_, app| {
@@ -136,7 +144,7 @@ pub fn new_env() -> Environment {
     primitive!(env, Arity::Exact(2), "eq?", |args, app| {
         let s = &args[0];
         let o = &args[1];
-        info!("comparing {} {}", s, o);
+        info!("comparing s: {} and o: {}", s, o);
         let result = s.compare(o, &app.lisp_env);
         result.map(LispExpr::BoolLit)
     });
@@ -188,7 +196,7 @@ pub fn new_env() -> Environment {
     primitive!(env, Arity::Exact(1), "string-len", |args, _| {
         if type_match!(args, 0 => LispExpr::StringLit(_)) {
             Ok(LispExpr::Number(LispNumber::Integer(
-                args[0].as_ref().len() as i64,
+                args[0].unwrap_stringlit().len() as i64,
             )))
         } else {
             Err(EvalError::TypeMismatch.into())
@@ -218,7 +226,7 @@ pub fn new_env() -> Environment {
             0
         };
         if let [LispExpr::Quote(kind, _)] = args {
-            if is_ident(kind) {
+            if matches!(kind.as_ref(), LispExpr::Ident(_)) {
                 match (&**kind).as_ref() {
                     "fill" => app.brush = Brush::Fill,
                     "circle" => app.brush = Brush::new(old_size),
@@ -250,9 +258,79 @@ pub fn new_env() -> Environment {
         }
     });
 
+    primitive!(env, Arity::Exact(2), "filter", |args, app| {
+        let mut apply_filter =
+            |func: &LispExpr, ls: &Vec<LispExpr>| -> Result<Vec<LispExpr>, LispError> {
+                let mut result = vec![];
+                for arg in ls.into_iter() {
+                    if eval(&LispExpr::List(vec![func.clone(), arg.clone()]), app)?.cast_bool() {
+                        result.push(arg.clone())
+                    }
+                }
+                Ok(result)
+            };
+        if matches!(&args[0], LispExpr::Function(_) | LispExpr::PrimitiveFunc(_)) {
+            match &args[1] {
+                LispExpr::List(ls) => return Ok(LispExpr::List(apply_filter(&args[0], ls)?)),
+                _ => return Err(EvalError::TypeMismatch.into()),
+            }
+        } else {
+            return Err(EvalError::TypeMismatch.into());
+        }
+    });
+
+    primitive!(env, Arity::Exact(1), "car", |args, _| {
+        if type_match!(args, 0 => LispExpr::List(_)) {
+            return Ok(args[0].unwrap_list().swap_remove(0));
+        } else if type_match!(args, 0 => LispExpr::Unit) {
+            return Err(EvalError::AccessEmptyList.into());
+        } else {
+            return Err(EvalError::TypeMismatch.into());
+        }
+    });
+
+    primitive!(env, Arity::Exact(1), "cdr", |args, _| {
+        if type_match!(args, 0 => LispExpr::List(_)) {
+            let mut ls = args[0].unwrap_list();
+            if ls.len() == 0 {
+                return Err(EvalError::AccessEmptyList.into());
+            } else if ls.len() == 1 {
+                return Ok(LispExpr::Unit);
+            } else {
+                ls.remove(0);
+                return Ok(LispExpr::List(ls));
+            }
+        } else if type_match!(args, 0 => LispExpr::Unit) {
+            return Err(EvalError::AccessEmptyList.into());
+        } else {
+            return Err(EvalError::TypeMismatch.into());
+        }
+    });
+
     primitive!(env, Arity::Atleast(1), "list", |args, _| {
         return Ok(LispExpr::List(args.to_vec()));
     });
 
-    env
+    primitive!(env, Arity::Exact(1), "load-script", |args, app| {
+        if type_match!(args, 0 => LispExpr::StringLit(_)) {
+            let path = args[0].unwrap_stringlit();
+            load_script(&path, app).map(|_| LispExpr::Unit)
+        } else {
+            return Err(EvalError::TypeMismatch.into());
+        }
+    });
+
+    primitive!(env, Arity::Atleast(1), "error", |args, _| {
+        if type_match!(args, 0 => LispExpr::StringLit(_)) {
+            let mut s = String::from(args[0].unwrap_stringlit());
+            for arg in args.into_iter().skip(1) {
+                s.push_str(&format!(" {}", arg));
+            }
+            return Err(EvalError::Custom(s).into());
+        } else {
+            return Err(EvalError::TypeMismatch.into());
+        }
+    });
+
+    Ok(env)
 }