Applying clippy suggestions

src/debruijn.rs

@@ -52,7 +52,7 @@ impl Display for DeBruijnNode {
         match self {
             FreeVariable(name) => write!(f, "{}", name),
             BoundVariable(i) => write!(f, "{}", i),
-            Abstraction(term) => write!(f, "{} {}", '\\', term.to_string()),
+            Abstraction(term) => write!(f, "\\ {}", term),
             Application(term1, term2) => {
                 let s1 = if let DeBruijnNode::FreeVariable(name) = &**term1 {
                     name.to_string()
@@ -61,14 +61,14 @@ impl Display for DeBruijnNode {
                 } else if let DeBruijnNode::Application(_, _) = &**term1 {
                     term1.to_string()
                 } else {
-                    format!("({})", term1.to_string())
+                    format!("({})", term1)
                 };
                 let s2 = if let DeBruijnNode::FreeVariable(name) = &**term2 {
                     name.to_string()
                 } else if let DeBruijnNode::BoundVariable(i) = &**term2 {
                     format!("{}", i)
                 } else {
-                    format!("({})", term2.to_string())
+                    format!("({})", term2)
                 };
                 write!(f, "{} {}", s1, s2)
             },

src/environment.rs

@@ -10,6 +10,7 @@ pub trait Environment: {
     type Instant;
 
     fn stdout(&mut self) -> &mut impl Write;
+    #[allow(dead_code)]
     fn stderr(&mut self) -> &mut impl Write;
     fn load(&self, file: &str) -> LashResult<String>;
     fn now(&self) -> Self::Instant;
@@ -29,6 +30,12 @@ struct StdStdout {}
 struct StdStderr {}
 
 #[cfg(feature = "std")]
+impl Default for StdEnvironment {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl StdEnvironment {
     pub fn new() -> Self {
         StdEnvironment {
@@ -51,7 +58,7 @@ impl Environment for StdEnvironment {
     }
 
     fn load(&self, file: &str) -> LashResult<String> {
-        std::fs::read_to_string(&file)
+        std::fs::read_to_string(file)
             .map_err(|e| LashError::new_file_error(file.into(), Some(e)))
     }
 

src/interpreter.rs

@@ -6,6 +6,7 @@ use alloc::string::String;
 use core::fmt;
 use core::fmt::Write;
 use core::str;
+use core::str::FromStr;
 
 use crate::error::*;
 use crate::environment::*;

src/macro.rs

@@ -103,7 +103,7 @@ impl Macro {
                 term
             },
             DeBruijn => {
-                println!("{}", DeBruijnNode::from(terms[0].clone()).to_string());
+                println!("{}", DeBruijnNode::from(terms[0].clone()));
                 terms[0].clone()
             },
             Debug | Dbg => {
@@ -180,7 +180,27 @@ impl Macro {
 
 impl Display for Macro {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        writeln!(f, "!{}", self)
+        use Macro::*;
+        let name = match self {
+            AlphaEq => "alphaeq",
+            CN => "cn",
+            CNormalize => "cnormalize",
+            Dbg => "dbg",
+            DeBruijn => "debruijn",
+            Debug => "debug",
+            Macros => "macros",
+            N => "n",
+            Normalize => "normalize",
+            R => "r",
+            Reduce => "reduce",
+            Resolve => "resolve",
+            Time => "time",
+            VN => "vn",
+            VNormalize => "vnormalize",
+            VR => "vr",
+            VReduce => "vreduce",
+        };
+        write!(f, "!{}", name)
     }
 }
 

src/parsing.rs

@@ -243,10 +243,7 @@ fn match_macro(s: Span) -> IResult<LambdaTree> {
     };
 
     let (rest, args) = opt(match_macro_args)(rest)?;
-    let lambdas = match args {
-        Some(lambdas) => lambdas,
-        None => Vec::new(),
-    };
+    let lambdas = args.unwrap_or_default();
 
     Ok((rest, LambdaTree::new_macro(m, lambdas)))
 }

src/strategy.rs

@@ -4,6 +4,7 @@ use alloc::borrow::ToOwned;
 use alloc::format;
 use alloc::string::String;
 use core::fmt::Write;
+use core::str::FromStr;
 
 #[cfg(feature = "std")]
 use colored::Colorize;
@@ -21,15 +22,6 @@ pub enum Strategy {
 }
 
 impl Strategy {
-    pub fn from_str(s: &str) -> Result<Self, ()> {
-        match s {
-            "applicative" => Ok(Self::Applicative),
-            "normal" => Ok(Self::Normal),
-            "callbyname" => Ok(Self::CallByName),
-            _ => Err(()),
-        }
-    }
-
     pub fn normalize(&self, term: LambdaTree, verbose: bool, out: &mut impl Write) -> (LambdaTree, usize) {
         let mut current = term;
         let mut nreductions = 0;
@@ -262,3 +254,16 @@ impl Default for Strategy {
         Self::Applicative
     }
 }
+
+impl FromStr for Strategy {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "applicative" => Ok(Self::Applicative),
+            "normal" => Ok(Self::Normal),
+            "callbyname" => Ok(Self::CallByName),
+            _ => Err(()),
+        }
+    }
+}