1 files changed, 25 insertions, 30 deletions
diff --git a/src/lisp/eval.rs b/src/lisp/eval.rs
index 9276ef5..329b6ab 100644
--- a/src/lisp/eval.rs
+++ b/src/lisp/eval.rs
@@ -76,7 +76,7 @@ where
                                self.eval(&LispExpr::List(f.body.clone()))
                            };
                            self.app.lisp_env.pop();
-                            return result;
+                            result
                        }
                    }
                    LispExpr::List(_) => {
@@ -108,7 +108,7 @@ where
                    error!("Unable to create global definition");
                    return Err(EvalError::BadForm.into());
                }
-                return Ok(LispExpr::Unit);
+                Ok(LispExpr::Unit)
            }
            [LispExpr::List(shorthand), LispExpr::List(body)] => {
                // (define (func arg) <body>) shorthand
@@ -130,12 +130,12 @@ where
                let local_env = &mut self.app.lisp_env.last_mut();
                if let Some(env) = local_env {
-                    env.insert(id.into(), value);
+                    env.insert(id, value);
                } else {
                    error!("Unable to create global definition");
                    return Err(EvalError::BadForm.into());
                }
-                return Ok(LispExpr::Unit);
+                Ok(LispExpr::Unit)
            }
            _ => {
                error!("Invalid usage of `define`");
@@ -154,17 +154,16 @@ where
                let value = self.eval(&expr)?;
                let local_env = self.app.lisp_env.last_mut();
                if let Some(env) = local_env {
-                    return env
+                    env.insert(id.into(), value)
-                        .insert(id.into(), value)
+                        .ok_or_else(|| EvalError::UnboundVariable(id.into()).into())
-                        .ok_or(EvalError::UnboundVariable(id.into()).into());
                } else {
                    error!("Unable to set in global env!");
-                    return Err(EvalError::BadForm.into());
+                    Err(EvalError::BadForm.into())
                }
            }
            _ => {
                error!("Invalid usage of `set!`");
-                return Err(EvalError::BadForm.into());
+                Err(EvalError::BadForm.into())
            }
        }
    }
@@ -172,15 +171,15 @@ where
    pub fn eval_if(&mut self, args: &[LispExpr]) -> Result<LispExpr, LispError> {
        let arity = Arity::Exact(3);
        if !arity.check(args) {
-            return Err(arity.to_error());
+            Err(arity.to_error())
        } else {
            match args {
                [predicate, then, else_] => {
                    let predicate = self.eval(&predicate)?;
                    if matches!(predicate, LispExpr::BoolLit(false)) {
-                        return self.eval(&else_);
+                        self.eval(&else_)
                    } else {
-                        return self.eval(&then);
+                        self.eval(&then)
                    }
                }
                _ => {
@@ -194,7 +193,7 @@ where
        let arity = Arity::Atleast(1);
        let valid_cond_stmt = |expr: &LispExpr| matches!(expr, LispExpr::List(v) if v.len() == 2);
        if !arity.check(args) {
-            return Err(arity.to_error());
+            Err(arity.to_error())
        } else {
            for cond_stmt in args {
                if valid_cond_stmt(cond_stmt) {
@@ -211,7 +210,7 @@ where
                    return Err(EvalError::BadForm.into());
                }
            }
-            return Ok(LispExpr::Unit);
+            Ok(LispExpr::Unit)
        }
    }
@@ -220,7 +219,7 @@ where
        let valid_binding_stmt =
            |expr: &LispExpr| matches!(expr, LispExpr::List(v) if v.len() == 2);
        if !arity.check(args) {
-            return Err(arity.to_error());
+            Err(arity.to_error())
        } else {
            let nested_env = Environment::new();
            self.app.lisp_env.push(nested_env);
@@ -247,11 +246,11 @@ where
                    }
                    let result = self.eval(&body);
                    self.app.lisp_env.pop();
-                    return result;
+                    result
                }
                _ => {
                    error!("bad `let` form");
-                    return Err(EvalError::BadForm.into());
+                    Err(EvalError::BadForm.into())
                }
            }
        }
@@ -277,32 +276,28 @@ pub fn create_lambda(cdr: &[LispExpr]) -> Result<LispExpr, LispError> {
        return Err(arity.to_error());
    }
    match cdr {
-        [LispExpr::List(params), LispExpr::List(body)] if type_match!(params, (..) => LispExpr::Ident(_)) =>
+        [LispExpr::List(params), LispExpr::List(body)] if type_match!(params, (..) => LispExpr::Ident(_)) => {
-        {
+            Ok(LispExpr::Function(LispFunction {
-            return Ok(LispExpr::Function(LispFunction {
+                params: params.iter().map(|p| p.unwrap_ident()).collect::<Vec<_>>(),
-                params: params
-                    .into_iter()
-                    .map(|p| p.unwrap_ident())
-                    .collect::<Vec<_>>(),
                body: body.clone(),
-            }));
+            }))
        }
        _ => {
            error!("Invalid usage of `lambda`");
-            return Err(EvalError::BadForm.into());
+            Err(EvalError::BadForm.into())
        }
    }
 }
 pub fn lookup(env_list: &[Environment], key: &str) -> Result<LispExpr, LispError> {
    if env_list.is_empty() {
-        return Err(EvalError::UnboundVariable(key.into()).into());
+        Err(EvalError::UnboundVariable(key.into()).into())
    } else {
        let local_env = env_list.last().unwrap();
        if let Some(val) = local_env.get(key) {
-            return Ok(val.clone());
+            Ok(val.clone())
        } else {
-            return lookup(&env_list[..env_list.len() - 1], key);
+            lookup(&env_list[..env_list.len() - 1], key)
        }
    }
 }
@@ -314,7 +309,7 @@ mod tests {
    use crate::lisp::{expr::LispExpr, lex::Lexer, number::LispNumber, parse::Parser};
    fn run(code: &str, app: &mut AppState) -> LispExpr {
-        let mut parser = Parser::new(Lexer::new(code, 0));
+        let mut parser = Parser::new(Lexer::new(code));
        let mut evaluator = Evaluator {
            app,
            context: Vec::new(),