1 files changed, 60 insertions, 62 deletions

diff --git a/src/lisp/prelude.rs b/src/lisp/prelude.rs
index aebff98..fee787e 100644
--- a/src/lisp/prelude.rs
+++ b/src/lisp/prelude.rs
@@ -66,7 +66,7 @@ pub fn new_env() -> Result<Environment, LispError> {
 
     primitive!(env, Arity::Atleast(2), "+", |args, _| {
         let nums = args
-            .into_iter()
+            .iter()
             .map(|arg| arg.try_into())
             .collect::<Result<Vec<&LispNumber>, LispError>>()?;
         return Ok(LispExpr::Number(
@@ -76,10 +76,10 @@ pub fn new_env() -> Result<Environment, LispError> {
 
     primitive!(env, Arity::Atleast(2), "-", |args, _| {
         let nums = args
-            .into_iter()
+            .iter()
             .map(|arg| arg.try_into())
             .collect::<Result<Vec<&LispNumber>, LispError>>()?;
-        let mut acc = nums[0].clone();
+        let mut acc = *nums[0];
         for arg in nums.into_iter().skip(1) {
             acc = acc - *arg;
         }
@@ -88,7 +88,7 @@ pub fn new_env() -> Result<Environment, LispError> {
 
     primitive!(env, Arity::Atleast(2), "*", |args, _| {
         let nums = args
-            .into_iter()
+            .iter()
             .map(|arg| arg.try_into())
             .collect::<Result<Vec<&LispNumber>, LispError>>()?;
         return Ok(LispExpr::Number(
@@ -98,10 +98,10 @@ pub fn new_env() -> Result<Environment, LispError> {
 
     primitive!(env, Arity::Atleast(2), "/", |args, _| {
         let nums = args
-            .into_iter()
+            .iter()
             .map(|arg| arg.try_into())
             .collect::<Result<Vec<&LispNumber>, LispError>>()?;
-        let mut acc = nums[0].clone();
+        let mut acc = *nums[0];
         for arg in nums.into_iter().skip(1) {
             acc = acc.div(*arg)?;
         }
@@ -139,7 +139,7 @@ pub fn new_env() -> Result<Environment, LispError> {
     });
 
     primitive!(env, Arity::Atleast(1), "begin", |args, _| {
-        Ok(args.into_iter().last().unwrap().clone())
+        Ok(args.iter().last().unwrap().clone())
     });
 
     primitive!(env, Arity::Exact(0), "quit", |_, app| {
@@ -157,8 +157,8 @@ pub fn new_env() -> Result<Environment, LispError> {
             (LispExpr::DottedList(s), LispExpr::DottedList(o)) => {
                 Ok(s.iter().zip(o).all(|(a, b)| a == b))
             }
-            (LispExpr::List(s), LispExpr::Unit) => Ok(s.len() == 0),
-            (LispExpr::Unit, LispExpr::List(s)) => Ok(s.len() == 0),
+            (LispExpr::List(s), LispExpr::Unit) => Ok(s.is_empty()),
+            (LispExpr::Unit, LispExpr::List(s)) => Ok(s.is_empty()),
             (LispExpr::DottedList(_), LispExpr::Unit) => Ok(false),
             (LispExpr::Unit, LispExpr::DottedList(_)) => Ok(false),
             (LispExpr::StringLit(s), LispExpr::StringLit(o)) => Ok(s == o),
@@ -176,10 +176,10 @@ pub fn new_env() -> Result<Environment, LispError> {
 
     primitive!(env, Arity::Atleast(2), ">", |args, _| {
         let nums = args
-            .into_iter()
+            .iter()
             .map(|arg| arg.try_into())
             .collect::<Result<Vec<&LispNumber>, LispError>>()?;
-        let acc = nums[0].clone();
+        let acc = *nums[0];
         Ok(LispExpr::BoolLit(
             nums.into_iter().skip(1).all(|&arg| acc > arg),
         ))
@@ -187,10 +187,10 @@ pub fn new_env() -> Result<Environment, LispError> {
 
     primitive!(env, Arity::Atleast(2), ">=", |args, _| {
         let nums = args
-            .into_iter()
+            .iter()
             .map(|arg| arg.try_into())
             .collect::<Result<Vec<&LispNumber>, LispError>>()?;
-        let acc = nums[0].clone();
+        let acc = *nums[0];
         Ok(LispExpr::BoolLit(
             nums.into_iter().skip(1).all(|&arg| acc >= arg),
         ))
@@ -198,10 +198,10 @@ pub fn new_env() -> Result<Environment, LispError> {
 
     primitive!(env, Arity::Atleast(2), "<", |args, _| {
         let nums = args
-            .into_iter()
+            .iter()
             .map(|arg| arg.try_into())
             .collect::<Result<Vec<&LispNumber>, LispError>>()?;
-        let acc = nums[0].clone();
+        let acc = *nums[0];
         Ok(LispExpr::BoolLit(
             nums.into_iter().skip(1).all(|&arg| acc < arg),
         ))
@@ -209,10 +209,10 @@ pub fn new_env() -> Result<Environment, LispError> {
 
     primitive!(env, Arity::Atleast(2), "<=", |args, _| {
         let nums = args
-            .into_iter()
+            .iter()
             .map(|arg| arg.try_into())
             .collect::<Result<Vec<&LispNumber>, LispError>>()?;
-        let acc = nums[0].clone();
+        let acc = *nums[0];
         Ok(LispExpr::BoolLit(
             nums.into_iter().skip(1).all(|&arg| acc <= arg),
         ))
@@ -235,18 +235,16 @@ pub fn new_env() -> Result<Environment, LispError> {
                 .map_err(|e| LispError::Stringified(e.to_string()))
                 .map(|_| LispExpr::Unit);
         }
-        return Err(EvalError::NoFileName.into());
+        Err(EvalError::NoFileName.into())
     });
 
     primitive!(env, Arity::Exact(1), "save-as", |args, app| {
         match &args[0] {
-            LispExpr::StringLit(s) => {
-                return app
-                    .save_as(&s)
-                    .map_err(|e| LispError::Stringified(e.to_string()))
-                    .map(|_| LispExpr::Unit);
-            }
-            _ => return Err(EvalError::TypeMismatch.into()),
+            LispExpr::StringLit(s) => app
+                .save_as(&s)
+                .map_err(|e| LispError::Stringified(e.to_string()))
+                .map(|_| LispExpr::Unit),
+            _ => Err(EvalError::TypeMismatch.into()),
         }
     });
 
@@ -261,52 +259,52 @@ pub fn new_env() -> Result<Environment, LispError> {
 
     primitive!(env, Arity::Exact(0), "brush-fill", |_, app| {
         app.brush = Brush::Fill;
-        return Ok(LispExpr::Unit);
+        Ok(LispExpr::Unit)
     });
 
     primitive!(env, Arity::Exact(0), "brush-circle", |_, app| {
         app.brush = Brush::new(0);
-        return Ok(LispExpr::Unit);
+        Ok(LispExpr::Unit)
     });
 
     primitive!(env, Arity::Exact(0), "brush-line", |_, app| {
         app.brush = Brush::line(0, false);
-        return Ok(LispExpr::Unit);
+        Ok(LispExpr::Unit)
     });
 
     primitive!(env, Arity::Exact(0), "brush-line-extend", |_, app| {
         app.brush = Brush::line(0, true);
-        return Ok(LispExpr::Unit);
+        Ok(LispExpr::Unit)
     });
 
     primitive!(env, Arity::Exact(2), "cons", |args, _| {
         if type_match!(args, 1 => LispExpr::Unit) {
-            return Ok(LispExpr::List(vec![args[0].clone()]));
+            Ok(LispExpr::List(vec![args[0].clone()]))
         } else if type_match!(args, 1 => LispExpr::DottedList(_)) {
             // cons of anything to an improper list is an improper list
             let mut rest = args[1].unwrap_dotted_list();
             rest.insert(0, args[0].clone());
-            return Ok(LispExpr::DottedList(rest));
+            Ok(LispExpr::DottedList(rest))
         } else if type_match!(args, 1 => LispExpr::List(_)) {
             // cons of anything to a proper list is a proper list
             let mut rest = args[1].unwrap_list();
             rest.insert(0, args[0].clone());
-            return Ok(LispExpr::List(rest));
+            Ok(LispExpr::List(rest))
         } else {
             // attempt to cons non-lists
-            return Ok(LispExpr::DottedList(vec![args[0].clone(), args[1].clone()]));
+            Ok(LispExpr::DottedList(vec![args[0].clone(), args[1].clone()]))
         }
     });
 
     primitive!(env, Arity::Exact(1), "car", |args, _| {
         if type_match!(args, 0 => LispExpr::List(_)) {
-            return Ok(args[0].unwrap_list().swap_remove(0));
+            Ok(args[0].unwrap_list().swap_remove(0))
         } else if type_match!(args, 0 => LispExpr::DottedList(_)) {
-            return Ok(args[0].unwrap_dotted_list().swap_remove(0));
+            Ok(args[0].unwrap_dotted_list().swap_remove(0))
         } else if type_match!(args, 0 => LispExpr::Unit) {
-            return Err(EvalError::AccessEmptyList.into());
+            Err(EvalError::AccessEmptyList.into())
         } else {
-            return Err(EvalError::TypeMismatch.into());
+            Err(EvalError::TypeMismatch.into())
         }
     });
 
@@ -314,32 +312,32 @@ pub fn new_env() -> Result<Environment, LispError> {
         if type_match!(args, 0 => LispExpr::List(_)) {
             // cdr of a proper list is a proper list
             let mut ls = args[0].unwrap_list();
-            if ls.len() == 0 {
-                return Err(EvalError::AccessEmptyList.into());
+            if ls.is_empty() {
+                Err(EvalError::AccessEmptyList.into())
             } else if ls.len() == 1 {
-                return Ok(LispExpr::Unit);
+                Ok(LispExpr::Unit)
             } else {
                 ls.remove(0);
-                return Ok(LispExpr::List(ls));
+                Ok(LispExpr::List(ls))
             }
         } else if type_match!(args, 0 => LispExpr::DottedList(_)) {
             // cdr of an improper list is an improper list or an atom
             let ls = args[0].unwrap_dotted_list();
             if ls.len() == 2 {
-                return Ok(ls.into_iter().last().unwrap());
+                Ok(ls.into_iter().last().unwrap())
             } else {
                 // should be unreachable
-                return Err(EvalError::AccessEmptyList.into());
+                Err(EvalError::AccessEmptyList.into())
             }
         } else if type_match!(args, 0 => LispExpr::Unit) {
-            return Err(EvalError::AccessEmptyList.into());
+            Err(EvalError::AccessEmptyList.into())
         } else {
-            return Err(EvalError::TypeMismatch.into());
+            Err(EvalError::TypeMismatch.into())
         }
     });
 
     primitive!(env, Arity::Atleast(1), "list", |args, _| {
-        return Ok(LispExpr::List(args.to_vec()));
+        Ok(LispExpr::List(args.to_vec()))
     });
 
     primitive!(env, Arity::Exact(1), "load-script", |args, app| {
@@ -347,40 +345,40 @@ pub fn new_env() -> Result<Environment, LispError> {
             let path = args[0].unwrap_stringlit();
             load_script(&path, app).map(|_| LispExpr::Unit)
         } else {
-            return Err(EvalError::TypeMismatch.into());
+            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) {
+            let mut s = args[0].unwrap_stringlit();
+            for arg in args.iter().skip(1) {
                 s.push_str(&format!(" {}", arg));
             }
-            return Err(EvalError::Custom(s).into());
+            Err(EvalError::Custom(s).into())
         } else {
-            return Err(EvalError::TypeMismatch.into());
+            Err(EvalError::TypeMismatch.into())
         }
     });
 
     primitive!(env, Arity::Exact(2), "assert-eq", |args, app| {
         if args[0].compare(&args[1], &app.lisp_env)? {
-            return Ok(LispExpr::Unit);
+            Ok(LispExpr::Unit)
         } else {
-            return Err(EvalError::AssertionError {
+            Err(EvalError::AssertionError {
                 expected: args[0].clone(),
                 got: args[1].clone(),
             }
-            .into());
+            .into())
         }
     });
 
     primitive!(env, Arity::Exact(0), "canvas-width", |_, app| {
-        return Ok(LispExpr::Number(LispNumber::Integer(app.width() as i64)));
+        Ok(LispExpr::Number(LispNumber::Integer(app.width() as i64)))
     });
 
     primitive!(env, Arity::Exact(0), "canvas-height", |_, app| {
-        return Ok(LispExpr::Number(LispNumber::Integer(app.height() as i64)));
+        Ok(LispExpr::Number(LispNumber::Integer(app.height() as i64)))
     });
 
     primitive!(env, Arity::Exact(3), "set-pixel!", |args, app| {
@@ -397,21 +395,21 @@ pub fn new_env() -> Result<Environment, LispError> {
                 .try_into()
                 .map_err(|_| -> LispError { EvalError::InvalidCoordinates((x, y)).into() })?;
             if !app.pixmap.contains(set_loc) {
-                return Err(EvalError::InvalidCoordinates((x, y)).into());
+                Err(EvalError::InvalidCoordinates((x, y)).into())
             } else {
                 let old_val = app.pixmap.set(set_loc, val);
                 app.current_operation
                     .push(PaintRecord::new(set_loc, old_val, val));
-                return Ok(LispExpr::Unit);
+                Ok(LispExpr::Unit)
             }
         } else {
-            return Err(EvalError::TypeMismatch.into());
+            Err(EvalError::TypeMismatch.into())
         }
     });
 
     primitive!(env, Arity::Exact(0), "commit", |_, app| {
         app.commit_operation();
-        return Ok(LispExpr::Unit);
+        Ok(LispExpr::Unit)
     });
 
     primitive!(env, Arity::Exact(2), "add-guide!", |args, app| {
@@ -422,9 +420,9 @@ pub fn new_env() -> Result<Environment, LispError> {
                     offset: *offset as u32,
                 };
                 app.guides.insert(guide, true);
-                return Ok(LispExpr::Unit);
+                Ok(LispExpr::Unit)
             }
-            _ => return Err(EvalError::TypeMismatch.into()),
+            _ => Err(EvalError::TypeMismatch.into()),
         }
     });