Clean up and fixes

Author: albeva

bin/src/main.rs

@@ -1,5 +1,5 @@
 use clap::{ArgAction, Parser};
-use expr_solver::{SymTable, Symbol, eval_file_with_table, load_with_table};
+use expr_solver::{Program, SymTable, Symbol};
 use rust_decimal::prelude::*;
 use std::path::PathBuf;
 
@@ -61,29 +61,31 @@ fn run() -> Result<(), String> {
         return Ok(());
     }
 
-    // load either from string input or a file
-    if let Some(expr) = args.expression.as_ref().or(args.expr.as_ref()) {
-        let program = load_with_table(expr, table)?;
-
-        if args.assembly {
-            print!("{}", program.get_assembly());
-            return Ok(());
-        }
-
-        // save to a file?
-        if let Some(output_path) = &args.output {
-            program
-                .save_bytecode_to_file(output_path)
-                .map_err(|e| e.to_string())?
-        } else {
-            let res = program.execute().map_err(|e| e.to_string())?;
-            println!("{res}");
-        }
-    } else if let Some(input) = &args.input {
-        let res = eval_file_with_table(input.to_string_lossy().as_ref(), table)?;
-        println!("{res}");
+    // Load input from either expression or file
+    let program = if let Some(expr) = args.expression.as_ref().or(args.expr.as_ref()) {
+        Program::new_from_source(expr)
+            .map_err(|err| err.to_string())?
+            .link(table)
+            .map_err(|err| err.to_string())?
+    } else if let Some(file) = &args.input {
+        Program::new_from_file(file.to_string_lossy().as_ref())
+            .map_err(|err| err.to_string())?
+            .link(table)
+            .map_err(|err| err.to_string())?
     } else {
         return Err("no input".to_string());
+    };
+
+    // Act on the loaded program
+    if args.assembly {
+        print!("{}", program.get_assembly());
+    } else if let Some(output_path) = &args.output {
+        program
+            .save_bytecode_to_file(output_path)
+            .map_err(|e| e.to_string())?;
+    } else {
+        let res = program.execute().map_err(|e| e.to_string())?;
+        println!("{res}");
     }
 
     Ok(())

lib/src/lib.rs

@@ -40,11 +40,11 @@
 //! The `Program` type uses the type-state pattern to enforce correct usage:
 //!
 //! ```
-//! use expr_solver::{load, SymTable};
+//! use expr_solver::{SymTable, Program};
 //! use rust_decimal_macros::dec;
 //!
 //! // Compile expression to bytecode
-//! let program = load("x + y").unwrap();
+//! let program = Program::new_from_source("x + y").unwrap();
 //!
 //! // Link with symbol table (validated at link time)
 //! let mut table = SymTable::new();
@@ -109,8 +109,7 @@ pub use vm::{Vm, VmError};
 /// assert_eq!(result.to_string(), "14");
 /// ```
 pub fn eval(expression: &str) -> Result<Decimal, String> {
-    let program = load_with_table(expression, SymTable::stdlib())?;
-    program.execute().map_err(|err| err.to_string())
+    eval_with_table(expression, SymTable::stdlib())
 }
 
 /// Evaluates an expression string with a custom symbol table.
@@ -128,8 +127,12 @@ pub fn eval(expression: &str) -> Result<Decimal, String> {
 /// assert_eq!(result, dec!(84));
 /// ```
 pub fn eval_with_table(expression: &str, table: SymTable) -> Result<Decimal, String> {
-    let program = load_with_table(expression, table)?;
-    program.execute().map_err(|err| err.to_string())
+    Program::new_from_source(expression)
+        .map_err(|err| err.to_string())?
+        .link(table)
+        .map_err(|err| err.to_string())?
+        .execute()
+        .map_err(|err| err.to_string())
 }
 
 /// Evaluates an expression from a binary file with the standard library.
@@ -159,34 +162,3 @@ pub fn eval_file_with_table(path: impl AsRef<str>, table: SymTable) -> Result<De
     let linked = program.link(table).map_err(|err| err.to_string())?;
     linked.execute().map_err(|err| err.to_string())
 }
-
-/// Loads and compiles an expression, returning a compiled program.
-///
-/// # Examples
-///
-/// ```
-/// use expr_solver::{load, SymTable};
-///
-/// let program = load("2 + 3 * 4").unwrap();
-/// let linked = program.link(SymTable::stdlib()).unwrap();
-/// let result = linked.execute().unwrap();
-/// assert_eq!(result.to_string(), "14");
-/// ```
-pub fn load(expression: &str) -> Result<Program<'_, Compiled>, String> {
-    Program::new_from_source(expression).map_err(|err| err.to_string())
-}
-
-/// Loads, compiles, and links an expression, returning a ready-to-execute program.
-///
-/// # Examples
-///
-/// ```
-/// use expr_solver::{load_with_table, SymTable};
-///
-/// let program = load_with_table("sin(pi/2)", SymTable::stdlib()).unwrap();
-/// let result = program.execute().unwrap();
-/// ```
-pub fn load_with_table(expression: &str, table: SymTable) -> Result<Program<'_, Linked>, String> {
-    let program = load(expression)?;
-    program.link(table).map_err(|err| err.to_string())
-}

lib/tests/integration_tests.rs

@@ -1,4 +1,4 @@
-use expr_solver::{SymTable, eval, eval_with_table, load, load_with_table};
+use expr_solver::{Compiled, Linked, Program, SymTable, eval, eval_with_table};
 use indoc::indoc;
 use rust_decimal::{Decimal, MathematicalOps};
 use rust_decimal_macros::dec;
@@ -250,6 +250,18 @@ fn test_if_function_semantic_errors() {
 // Program API Tests
 // ====================
 
+fn load_with_table(
+    expr: &'static str,
+    table: SymTable,
+) -> Result<Program<'static, Linked>, String> {
+    let program = Program::new_from_source(expr).map_err(|err| err.to_string())?;
+    program.link(table).map_err(|err| err.to_string())
+}
+
+fn load(expr: &'static str) -> Result<Program<'static, Compiled>, String> {
+    Program::new_from_source(expr).map_err(|err| err.to_string())
+}
+
 #[test]
 fn test_program_basic_arithmetic() {
     let program = load_with_table("2 + 3 * 4", SymTable::stdlib()).expect("link failed");