Refactor Eval

Author: albeva

README.md

@@ -35,18 +35,25 @@ expr-solver-bin = "1.0.2"
 ### Basic Example
 
 ```rust
-use expr_solver::{Eval};
+use expr_solver::Eval;
 
 fn main() {
-    let mut eval = Eval::new("2+3*4");
+    // Quick one-liner evaluation
+    match Eval::evaluate("2+3*4") {
+        Ok(result) => println!("Result: {}", result),
+        Err(e) => eprintln!("Error: {}", e),
+    }
+
+    // Or create an evaluator instance for more control
+    let mut eval = Eval::new("sqrt(16) + pi");
     match eval.run() {
         Ok(result) => println!("Result: {}", result),
         Err(e) => eprintln!("Error: {}", e),
     }
 }
 ```
 
-This will evaluate the hardcoded expression `2 + 3 * 4` and print the result.
+This will evaluate mathematical expressions and print the results.
 
 ## Testing
 

bin/src/main.rs

@@ -66,15 +66,13 @@ fn run() -> Result<(), String> {
 
     // load either from string input or a file
     let mut eval = if let Some(expr) = args.expression.as_ref().or(args.expr.as_ref()) {
-        Eval::new(expr)
+        Eval::with_table(expr, table)
     } else if let Some(input) = &args.input {
-        Eval::new_from_file(input.clone())
+        Eval::from_file_with_table(input.clone(), table)
     } else {
         return Err("no input".to_string());
     };
 
-    eval.with_table(table);
-
     if args.assembly {
         let program = eval.build_program()?;
         print!("{}", program.get_assembly());

lib/src/lib.rs

@@ -68,36 +68,55 @@ enum EvalSource<'str> {
 #[derive(Debug)]
 pub struct Eval<'str> {
     source: EvalSource<'str>,
-    table: Option<SymTable>,
+    table: SymTable,
 }
 
 impl<'str> Eval<'str> {
+    /// Quick evaluation of an expression with default standard library
+    pub fn evaluate(expression: &'str str) -> Result<Decimal, String> {
+        Self::new(expression).run()
+    }
+
+    /// Create a new evaluator with an expression string
     pub fn new(string: &'str str) -> Self {
+        Self::with_table(string, SymTable::stdlib())
+    }
+
+    /// Create a new evaluator with an expression string and custom symbol table
+    pub fn with_table(string: &'str str, table: SymTable) -> Self {
         let source = Source::new(string);
         Self {
             source: EvalSource::Source(Cow::Owned(source)),
-            table: None,
+            table,
         }
     }
 
+    /// Create a new evaluator from a Source reference
     pub fn new_from_source(source: &'str Source<'str>) -> Self {
+        Self::from_source_with_table(source, SymTable::stdlib())
+    }
+
+    /// Create a new evaluator from a Source reference with custom symbol table
+    pub fn from_source_with_table(source: &'str Source<'str>, table: SymTable) -> Self {
         Self {
             source: EvalSource::Source(Cow::Borrowed(source)),
-            table: None,
+            table,
         }
     }
 
+    /// Create a new evaluator from a compiled binary file
     pub fn new_from_file(path: PathBuf) -> Self {
+        Self::from_file_with_table(path, SymTable::stdlib())
+    }
+
+    /// Create a new evaluator from a compiled binary file with custom symbol table
+    pub fn from_file_with_table(path: PathBuf, table: SymTable) -> Self {
         Self {
             source: EvalSource::File(path),
-            table: None,
+            table,
         }
     }
 
-    pub fn with_table(&mut self, table: SymTable) {
-        self.table = Some(table);
-    }
-
     pub fn run(&mut self) -> Result<Decimal, String> {
         let program = self.build_program()?;
         Vm::default().run(&program).map_err(|err| err.to_string())
@@ -110,7 +129,7 @@ impl<'str> Eval<'str> {
     }
 
     pub fn build_program(&mut self) -> Result<Program<'_>, String> {
-        let table = self.table.get_or_insert_with(SymTable::stdlib);
+        let table = &self.table;
         match &self.source {
             EvalSource::Source(source) => {
                 let mut parser = Parser::new(source);

lib/tests/integration_tests.rs

@@ -19,8 +19,7 @@ fn eval_err(expr: &str) -> String {
 
 // Helper function to evaluate an expression with a custom symbol table and expect an Ok result.
 fn eval_with_custom_table_ok(expr: &str, table: SymTable) -> Decimal {
-    let mut eval = Eval::new(expr);
-    eval.with_table(table);
+    let mut eval = Eval::with_table(expr, table);
     eval.run().expect("Evaluation should be successful")
 }