From c84c38544bc6e81f0b0482e4e82b6c95848c1a0c Mon Sep 17 00:00:00 2001 From: Akshay Date: Tue, 6 Apr 2021 14:54:54 +0530 Subject: apply clippy lints --- src/lisp/prelude.rs | 122 ++++++++++++++++++++++++++-------------------------- 1 file changed, 60 insertions(+), 62 deletions(-) (limited to 'src/lisp/prelude.rs') 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 { primitive!(env, Arity::Atleast(2), "+", |args, _| { let nums = args - .into_iter() + .iter() .map(|arg| arg.try_into()) .collect::, LispError>>()?; return Ok(LispExpr::Number( @@ -76,10 +76,10 @@ pub fn new_env() -> Result { primitive!(env, Arity::Atleast(2), "-", |args, _| { let nums = args - .into_iter() + .iter() .map(|arg| arg.try_into()) .collect::, 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 { primitive!(env, Arity::Atleast(2), "*", |args, _| { let nums = args - .into_iter() + .iter() .map(|arg| arg.try_into()) .collect::, LispError>>()?; return Ok(LispExpr::Number( @@ -98,10 +98,10 @@ pub fn new_env() -> Result { primitive!(env, Arity::Atleast(2), "/", |args, _| { let nums = args - .into_iter() + .iter() .map(|arg| arg.try_into()) .collect::, 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 { }); 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 { (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 { primitive!(env, Arity::Atleast(2), ">", |args, _| { let nums = args - .into_iter() + .iter() .map(|arg| arg.try_into()) .collect::, 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 { primitive!(env, Arity::Atleast(2), ">=", |args, _| { let nums = args - .into_iter() + .iter() .map(|arg| arg.try_into()) .collect::, 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 { primitive!(env, Arity::Atleast(2), "<", |args, _| { let nums = args - .into_iter() + .iter() .map(|arg| arg.try_into()) .collect::, 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 { primitive!(env, Arity::Atleast(2), "<=", |args, _| { let nums = args - .into_iter() + .iter() .map(|arg| arg.try_into()) .collect::, 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 { .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 { 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 { 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 { 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 { .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 { 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()), } }); -- cgit v1.2.3