Tweaks

Author: albeva

bin/src/main.rs

@@ -7,11 +7,11 @@ use std::path::PathBuf;
 #[derive(Parser)]
 #[command(version, about, long_about = None, arg_required_else_help = true)]
 struct Args {
-    /// Expression to evaluate
-    #[arg(short, long, conflicts_with_all = ["input", "expr", "symbol_table"])]
+    /// Expression to evaluate (can be provided as positional argument or with -e/--expression)
+    #[arg(short, long, conflicts_with = "input")]
     expression: Option<String>,
 
-    /// Expression to evaluate (positional)
+    /// Expression to evaluate (positional, alternative to -e/--expression)
     #[arg(conflicts_with_all = ["expression", "input", "symbol_table"])]
     expr: Option<String>,
 

lib/src/lib.rs

@@ -25,7 +25,7 @@ mod symbol;
 mod token;
 mod vm;
 
-use std::{borrow::Cow, fs, path::PathBuf};
+use std::{borrow::Cow, fmt, fs, path::PathBuf};
 
 // Public API
 pub use ir::IrBuilder;
@@ -40,6 +40,25 @@ pub use source::Source;
 pub use symbol::{SymTable, Symbol, SymbolError};
 pub use vm::{Vm, VmError};
 
+/// A wrapper that formats errors with source code highlighting
+struct FormattedError {
+    message: String,
+}
+
+impl fmt::Display for FormattedError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.message)
+    }
+}
+
+impl<T: SpanError> From<(&T, &Source<'_>)> for FormattedError {
+    fn from((error, source): (&T, &Source<'_>)) -> Self {
+        Self {
+            message: format!("{}\n{}", error, source.highlight(&error.span())),
+        }
+    }
+}
+
 #[derive(Debug)]
 enum EvalSource<'str> {
     Source(Cow<'str, Source<'str>>),
@@ -97,14 +116,14 @@ impl<'str> Eval<'str> {
                 let mut parser = Parser::new(source);
                 let mut ast: Expr = match parser
                     .parse()
-                    .map_err(|err| Self::error_with_source(&err, source))?
+                    .map_err(|err| FormattedError::from((&err, source.as_ref())).to_string())?
                 {
                     Some(ast) => ast,
                     None => return Ok(Program::default()),
                 };
                 Sema::new(table)
                     .visit(&mut ast)
-                    .map_err(|err| Self::error_with_source(&err, source))?;
+                    .map_err(|err| FormattedError::from((&err, source.as_ref())).to_string())?;
                 IrBuilder::new().build(&ast).map_err(|err| err.to_string())
             }
             EvalSource::File(path) => {
@@ -113,8 +132,4 @@ impl<'str> Eval<'str> {
             }
         }
     }
-
-    fn error_with_source<T: SpanError>(error: &T, source: &Source) -> String {
-        format!("{}\n{}", error, source.highlight(&error.span()))
-    }
 }

lib/src/program.rs

@@ -7,6 +7,9 @@ use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
+/// Current version of the program format
+const PROGRAM_VERSION: &str = env!("CARGO_PKG_VERSION");
+
 /// Expression parsing and evaluation errors.
 #[derive(Error, Debug)]
 pub enum ProgramError {
@@ -87,7 +90,7 @@ enum BinaryInstr {
 impl<'sym> Program<'sym> {
     pub fn new() -> Self {
         Self {
-            version: env!("CARGO_PKG_VERSION").to_string(),
+            version: PROGRAM_VERSION.to_string(),
             code: Vec::new(),
         }
     }
@@ -169,10 +172,9 @@ impl<'sym> Program<'sym> {
     }
 
     fn validate_version(version: &String) -> Result<(), ProgramError> {
-        let current_version = env!("CARGO_PKG_VERSION");
-        if version != current_version {
+        if version != PROGRAM_VERSION {
             return Err(ProgramError::IncompatibleVersions(
-                current_version.to_string(),
+                PROGRAM_VERSION.to_string(),
                 version.clone(),
             ));
         }

lib/src/token.rs

@@ -46,17 +46,11 @@ impl<'src> Token<'src> {
     }
 
     pub fn is_right_associative(&self) -> bool {
-        match self {
-            Token::Caret => true,
-            _ => false,
-        }
+        matches!(self, Token::Caret)
     }
 
     pub fn is_postfix_unary(&self) -> bool {
-        match self {
-            Token::Bang => true,
-            _ => false,
-        }
+        matches!(self, Token::Bang)
     }
 
     pub fn lexeme(&self) -> Cow<'src, str> {

lib/src/vm.rs

@@ -197,17 +197,14 @@ impl Vm {
             return Err(VmError::InvalidFactorial { value: n });
         }
 
-        // Calculate factorial using safe multiplication
+        // Calculate factorial using safe multiplication with iterator
         let n_u64 = n.to_u64().unwrap();
-        let mut result = Decimal::ONE;
-        for i in 1..=n_u64 {
-            result =
-                result
-                    .checked_mul(Decimal::from(i))
-                    .ok_or_else(|| VmError::ArithmeticError {
-                        message: format!("Factorial calculation overflow at {}!", i),
-                    })?;
-        }
+        let result = (1..=n_u64).try_fold(Decimal::ONE, |acc, i| {
+            acc.checked_mul(Decimal::from(i))
+                .ok_or_else(|| VmError::ArithmeticError {
+                    message: format!("Factorial calculation overflow at {}!", i),
+                })
+        })?;
 
         stack.push(result);
         Ok(())