functions are first class

1 files changed, 40 insertions, 34 deletions

diff --git a/src/lisp/eval.rs b/src/lisp/eval.rs
index f49efb9..3a3a61e 100644
--- a/src/lisp/eval.rs
+++ b/src/lisp/eval.rs
@@ -30,42 +30,47 @@ pub fn eval(expr: &LispExpr, app: &mut AppState) -> Result<LispExpr, LispError>
                     "lambda" => create_lambda(&li[1..]),
                     "if" => eval_if(&li[1..], app),
                     _ => {
-                        let func_expr = eval(&func_expr, app)?;
-                        match func_expr {
-                            LispExpr::PrimitiveFunc(f) => {
-                                let mut args = Vec::new();
-                                for item in li[1..].iter() {
-                                    args.push(eval(item, app)?);
-                                }
-                                f.call(&args, app)
-                            }
-                            LispExpr::Function(f) => {
-                                let mut args = Vec::new();
-                                for item in li[1..].iter() {
-                                    let i = eval(item, app)?;
-                                    args.push(i);
-                                }
-                                if f.params.len() != args.len() {
-                                    info!("too many or too little number of args");
-                                    Err(EvalError::ArgumentCount(Arity::Exact(f.params.len()))
-                                        .into())
-                                } else {
-                                    let nested_env: Environment =
-                                        f.params.into_iter().zip(args).collect();
-                                    app.lisp_env.push(nested_env);
-                                    let result = if f.body.is_empty() {
-                                        Ok(LispExpr::Unit)
-                                    } else {
-                                        eval(&LispExpr::List(f.body), app)
-                                    };
-                                    app.lisp_env.pop();
-                                    return result;
-                                }
-                            }
-                            _ => Err(EvalError::BadForm.into()),
-                        }
+                        let mut new_ls = vec![eval(&func_expr, app)?];
+                        new_ls.extend(li[1..].to_vec());
+                        eval(&(LispExpr::List(new_ls)), app)
                     }
                 },
+                LispExpr::PrimitiveFunc(f) => {
+                    let mut args = Vec::new();
+                    for item in li[1..].iter() {
+                        args.push(eval(item, app)?);
+                    }
+                    f.call(&args, app)
+                }
+                LispExpr::Function(f) => {
+                    let mut args = Vec::new();
+                    for item in li[1..].iter() {
+                        let i = eval(item, app)?;
+                        args.push(i);
+                    }
+                    if f.params.len() != args.len() {
+                        info!("too many or too little number of args");
+                        Err(EvalError::ArgumentCount(Arity::Exact(f.params.len())).into())
+                    } else {
+                        let nested_env: Environment =
+                            f.params.clone().into_iter().zip(args).collect();
+                        app.lisp_env.push(nested_env);
+                        let result = if f.body.is_empty() {
+                            Ok(LispExpr::Unit)
+                        } else {
+                            eval(&LispExpr::List(f.body.clone()), app)
+                        };
+                        app.lisp_env.pop();
+                        return result;
+                    }
+                }
+                LispExpr::List(_) => {
+                    info!("list as funciton");
+                    let func_expr = eval(&func_expr, app)?;
+                    let mut new_ls = vec![func_expr];
+                    new_ls.extend(li[1..].to_vec());
+                    eval(&(LispExpr::List(new_ls)), app)
+                }
                 _ => Err(EvalError::BadForm.into()),
             }
         }
@@ -74,6 +79,7 @@ pub fn eval(expr: &LispExpr, app: &mut AppState) -> Result<LispExpr, LispError>
 }
 
 pub fn define_var(args: &[LispExpr], app: &mut AppState) -> Result<LispExpr, LispError> {
+    info!("defining");
     let arity = Arity::Exact(2);
     if !arity.is_valid(args) {
         return Err(arity.to_error());