[refactoring] Rename and reorganize expression evaluation functions

- Rename all eval function calls to use consistent 'eval_' prefix:
  * add → eval_add, sub → eval_sub, mul → eval_mul, div → eval_div
  * and → eval_and, or → eval_or, not → eval_not
  * eq → eval_eq, neq → eval_neq, gt → eval_gt, lt → eval_lt
  * gte → eval_gte, lte → eval_lte
  * lookup → eval_lookup, call → eval_call
- Reorganize function definitions to match eval() function call order
- Move helper functions (eval_binary_arith_op, eval_binary_boolean_op,
  eval_binary_rel_op) before their usage
- Group functions by operation type: arithmetic, boolean, relational
- Maintain all existing functionality and test coverage
- Improve code organization and naming consistency

Author: rbonifacio

src/interpreter/expression_eval.rs

@@ -5,92 +5,35 @@ type ErrorMessage = (String, Option<Expression>);
 
 pub fn eval(exp: Expression, env: &Environment<Expression>) -> Result<Expression, ErrorMessage> {
     match exp {
-        Expression::Add(lhs, rhs) => add(*lhs, *rhs, env),
-        Expression::Sub(lhs, rhs) => sub(*lhs, *rhs, env),
-        Expression::Mul(lhs, rhs) => mul(*lhs, *rhs, env),
-        Expression::Div(lhs, rhs) => div(*lhs, *rhs, env),
-        Expression::And(lhs, rhs) => and(*lhs, *rhs, env),
-        Expression::Or(lhs, rhs) => or(*lhs, *rhs, env),
-        Expression::Not(lhs) => not(*lhs, env),
-        Expression::EQ(lhs, rhs) => eq(*lhs, *rhs, env),
-        Expression::NEQ(lhs, rhs) => neq(*lhs, *rhs, env),
-        Expression::GT(lhs, rhs) => gt(*lhs, *rhs, env),
-        Expression::LT(lhs, rhs) => lt(*lhs, *rhs, env),
-        Expression::GTE(lhs, rhs) => gte(*lhs, *rhs, env),
-        Expression::LTE(lhs, rhs) => lte(*lhs, *rhs, env),
-        Expression::Var(name) => lookup(name, env),
+        Expression::Add(lhs, rhs) => eval_add(*lhs, *rhs, env),
+        Expression::Sub(lhs, rhs) => eval_sub(*lhs, *rhs, env),
+        Expression::Mul(lhs, rhs) => eval_mul(*lhs, *rhs, env),
+        Expression::Div(lhs, rhs) => eval_div(*lhs, *rhs, env),
+        Expression::And(lhs, rhs) => eval_and(*lhs, *rhs, env),
+        Expression::Or(lhs, rhs) => eval_or(*lhs, *rhs, env),
+        Expression::Not(lhs) => eval_not(*lhs, env),
+        Expression::EQ(lhs, rhs) => eval_eq(*lhs, *rhs, env),
+        Expression::NEQ(lhs, rhs) => eval_neq(*lhs, *rhs, env),
+        Expression::GT(lhs, rhs) => eval_gt(*lhs, *rhs, env),
+        Expression::LT(lhs, rhs) => eval_lt(*lhs, *rhs, env),
+        Expression::GTE(lhs, rhs) => eval_gte(*lhs, *rhs, env),
+        Expression::LTE(lhs, rhs) => eval_lte(*lhs, *rhs, env),
+        Expression::Var(name) => eval_lookup(name, env),
         Expression::COk(e) => eval_ok(*e, env),
         Expression::CErr(e) => eval_err(*e, env),
         Expression::CJust(e) => eval_just(*e, env),
         Expression::Unwrap(e) => eval_unwrap_expression(*e, env),
         Expression::Propagate(e) => eval_propagate_expression(*e, env),
         Expression::IsError(e) => eval_iserror_expression(*e, env),
         Expression::IsNothing(e) => eval_isnothing_expression(*e, env),
-        Expression::FuncCall(name, args) => call(name, args, env),
+        Expression::FuncCall(name, args) => eval_call(name, args, env),
         Expression::ListValue(values) => eval_list_value(values, env),
         _ if is_constant(exp.clone()) => Ok(exp),
         _ => Err((String::from("Not implemented yet."), None)),
     }
 }
 
-pub fn lookup(name: String, env: &Environment<Expression>) -> Result<Expression, ErrorMessage> {
-    match env.lookup(&name) {
-        Some((_, value)) => Ok(value.clone()),
-        None => Err((format!("Variable '{}' not found", name), None)),
-    }
-}
-
-pub fn call(
-    name: Name,
-    args: Vec<Expression>,
-    env: &Environment<Expression>,
-) -> Result<Expression, ErrorMessage> {
-    match env.lookup_function(&name) {
-        Some(func) => {
-            let mut new_env = Environment::new();
-
-            // Copy global functions
-            for (name, (_, value)) in env.get_all_variables() {
-                if let Expression::FuncCall(_, _) = value {
-                    new_env.map_variable(name.clone(), false, value.clone());
-                }
-            }
-
-            // Bind arguments
-            for (i, formal_arg) in func.params.iter().enumerate() {
-                if i >= args.len() {
-                    return Err((
-                        format!(
-                            "[Runtime Error on '{}()'] missing argument '{}'.",
-                            name, formal_arg.argument_name
-                        ),
-                        None,
-                    ));
-                }
-                let arg_value = eval(args[i].clone(), env)?;
-                new_env.map_variable(formal_arg.argument_name.clone(), false, arg_value);
-            }
-
-            if args.len() > func.params.len() {
-                return Err((
-                    format!("[Runtime Error on '{}()'] too many arguments.", name),
-                    None,
-                ));
-            }
-
-            // Execute function
-            match super::statement_execute::execute(*func.body.as_ref().unwrap().clone(), &new_env)
-            {
-                Ok(_) => Err(("Function did not return a value".to_string(), None)),
-                Err((_, Some(value))) => Ok(value),
-                Err(e) => Err(e),
-            }
-        }
-        _ => Err((format!("Function {} not found", name), None)),
-    }
-}
-
-// Arithmetic Operations
+// Helper function for arithmetic operations
 fn eval_binary_arith_op<F>(
     lhs: Expression,
     rhs: Expression,
@@ -115,7 +58,54 @@ where
     }
 }
 
-fn add(
+// Helper function for boolean operations
+fn eval_binary_boolean_op<F>(
+    lhs: Expression,
+    rhs: Expression,
+    env: &Environment<Expression>,
+    op: F,
+    error_msg: &str,
+) -> Result<Expression, ErrorMessage>
+where
+    F: Fn(bool, bool) -> Expression,
+{
+    let v1 = eval(lhs, env)?;
+    let v2 = eval(rhs, env)?;
+
+    match (v1, v2) {
+        (Expression::CTrue, Expression::CTrue) => Ok(op(true, true)),
+        (Expression::CTrue, Expression::CFalse) => Ok(op(true, false)),
+        (Expression::CFalse, Expression::CTrue) => Ok(op(false, true)),
+        (Expression::CFalse, Expression::CFalse) => Ok(op(false, false)),
+        _ => Err((error_msg.to_string(), None)),
+    }
+}
+
+// Helper function for relational operations
+fn eval_binary_rel_op<F>(
+    lhs: Expression,
+    rhs: Expression,
+    env: &Environment<Expression>,
+    op: F,
+    error_msg: &str,
+) -> Result<Expression, ErrorMessage>
+where
+    F: Fn(f64, f64) -> Expression,
+{
+    let v1 = eval(lhs, env)?;
+    let v2 = eval(rhs, env)?;
+
+    match (v1, v2) {
+        (Expression::CInt(v1), Expression::CInt(v2)) => Ok(op(v1 as f64, v2 as f64)),
+        (Expression::CInt(v1), Expression::CReal(v2)) => Ok(op(v1 as f64, v2)),
+        (Expression::CReal(v1), Expression::CInt(v2)) => Ok(op(v1, v2 as f64)),
+        (Expression::CReal(v1), Expression::CReal(v2)) => Ok(op(v1, v2)),
+        _ => Err((error_msg.to_string(), None)),
+    }
+}
+
+// Arithmetic Operations
+fn eval_add(
     lhs: Expression,
     rhs: Expression,
     env: &Environment<Expression>,
@@ -128,7 +118,8 @@ fn add(
         "addition '(+)' is only defined for numbers (integers and real).",
     )
 }
-fn sub(
+
+fn eval_sub(
     lhs: Expression,
     rhs: Expression,
     env: &Environment<Expression>,
@@ -141,7 +132,8 @@ fn sub(
         "subtraction '(-)' is only defined for numbers (integers and real).",
     )
 }
-fn mul(
+
+fn eval_mul(
     lhs: Expression,
     rhs: Expression,
     env: &Environment<Expression>,
@@ -154,7 +146,8 @@ fn mul(
         "multiplication '(*)' is only defined for numbers (integers and real).",
     )
 }
-fn div(
+
+fn eval_div(
     lhs: Expression,
     rhs: Expression,
     env: &Environment<Expression>,
@@ -169,28 +162,7 @@ fn div(
 }
 
 // Boolean Operations
-fn eval_binary_boolean_op<F>(
-    lhs: Expression,
-    rhs: Expression,
-    env: &Environment<Expression>,
-    op: F,
-    error_msg: &str,
-) -> Result<Expression, ErrorMessage>
-where
-    F: Fn(bool, bool) -> Expression,
-{
-    let v1 = eval(lhs, env)?;
-    let v2 = eval(rhs, env)?;
-
-    match (v1, v2) {
-        (Expression::CTrue, Expression::CTrue) => Ok(op(true, true)),
-        (Expression::CTrue, Expression::CFalse) => Ok(op(true, false)),
-        (Expression::CFalse, Expression::CTrue) => Ok(op(false, true)),
-        (Expression::CFalse, Expression::CFalse) => Ok(op(false, false)),
-        _ => Err((error_msg.to_string(), None)),
-    }
-}
-fn and(
+fn eval_and(
     lhs: Expression,
     rhs: Expression,
     env: &Environment<Expression>,
@@ -209,7 +181,8 @@ fn and(
         "'and' is only defined for booleans.",
     )
 }
-fn or(
+
+fn eval_or(
     lhs: Expression,
     rhs: Expression,
     env: &Environment<Expression>,
@@ -228,7 +201,8 @@ fn or(
         "'or' is only defined for booleans.",
     )
 }
-fn not(lhs: Expression, env: &Environment<Expression>) -> Result<Expression, ErrorMessage> {
+
+fn eval_not(lhs: Expression, env: &Environment<Expression>) -> Result<Expression, ErrorMessage> {
     let v = eval(lhs, env)?;
     match v {
         Expression::CTrue => Ok(Expression::CFalse),
@@ -238,28 +212,7 @@ fn not(lhs: Expression, env: &Environment<Expression>) -> Result<Expression, Err
 }
 
 // Relational Operations
-fn eval_binary_rel_op<F>(
-    lhs: Expression,
-    rhs: Expression,
-    env: &Environment<Expression>,
-    op: F,
-    error_msg: &str,
-) -> Result<Expression, ErrorMessage>
-where
-    F: Fn(f64, f64) -> Expression,
-{
-    let v1 = eval(lhs, env)?;
-    let v2 = eval(rhs, env)?;
-
-    match (v1, v2) {
-        (Expression::CInt(v1), Expression::CInt(v2)) => Ok(op(v1 as f64, v2 as f64)),
-        (Expression::CInt(v1), Expression::CReal(v2)) => Ok(op(v1 as f64, v2)),
-        (Expression::CReal(v1), Expression::CInt(v2)) => Ok(op(v1, v2 as f64)),
-        (Expression::CReal(v1), Expression::CReal(v2)) => Ok(op(v1, v2)),
-        _ => Err((error_msg.to_string(), None)),
-    }
-}
-fn eq(
+fn eval_eq(
     lhs: Expression,
     rhs: Expression,
     env: &Environment<Expression>,
@@ -278,7 +231,8 @@ fn eq(
         "(==) is only defined for numbers (integers and real).",
     )
 }
-fn neq(
+
+fn eval_neq(
     lhs: Expression,
     rhs: Expression,
     env: &Environment<Expression>,
@@ -297,7 +251,8 @@ fn neq(
         "(!=) is only defined for numbers (integers and real).",
     )
 }
-fn gt(
+
+fn eval_gt(
     lhs: Expression,
     rhs: Expression,
     env: &Environment<Expression>,
@@ -316,7 +271,8 @@ fn gt(
         "(>) is only defined for numbers (integers and real).",
     )
 }
-fn lt(
+
+fn eval_lt(
     lhs: Expression,
     rhs: Expression,
     env: &Environment<Expression>,
@@ -335,7 +291,8 @@ fn lt(
         "(<) is only defined for numbers (integers and real).",
     )
 }
-fn gte(
+
+fn eval_gte(
     lhs: Expression,
     rhs: Expression,
     env: &Environment<Expression>,
@@ -354,7 +311,8 @@ fn gte(
         "(>=) is only defined for numbers (integers and real).",
     )
 }
-fn lte(
+
+fn eval_lte(
     lhs: Expression,
     rhs: Expression,
     env: &Environment<Expression>,
@@ -374,6 +332,65 @@ fn lte(
     )
 }
 
+// Variable lookup
+pub fn eval_lookup(name: String, env: &Environment<Expression>) -> Result<Expression, ErrorMessage> {
+    match env.lookup(&name) {
+        Some((_, value)) => Ok(value.clone()),
+        None => Err((format!("Variable '{}' not found", name), None)),
+    }
+}
+
+// Function call
+pub fn eval_call(
+    name: Name,
+    args: Vec<Expression>,
+    env: &Environment<Expression>,
+) -> Result<Expression, ErrorMessage> {
+    match env.lookup_function(&name) {
+        Some(func) => {
+            let mut new_env = Environment::new();
+
+            // Copy global functions
+            for (name, (_, value)) in env.get_all_variables() {
+                if let Expression::FuncCall(_, _) = value {
+                    new_env.map_variable(name.clone(), false, value.clone());
+                }
+            }
+
+            // Bind arguments
+            for (i, formal_arg) in func.params.iter().enumerate() {
+                if i >= args.len() {
+                    return Err((
+                        format!(
+                            "[Runtime Error on '{}()'] missing argument '{}'.",
+                            name, formal_arg.argument_name
+                        ),
+                        None,
+                    ));
+                }
+                let arg_value = eval(args[i].clone(), env)?;
+                new_env.map_variable(formal_arg.argument_name.clone(), false, arg_value);
+            }
+
+            if args.len() > func.params.len() {
+                return Err((
+                    format!("[Runtime Error on '{}()'] too many arguments.", name),
+                    None,
+                ));
+            }
+
+            // Execute function
+            match super::statement_execute::execute(*func.body.as_ref().unwrap().clone(), &new_env)
+            {
+                Ok(_) => Err(("Function did not return a value".to_string(), None)),
+                Err((_, Some(value))) => Ok(value),
+                Err(e) => Err(e),
+            }
+        }
+        _ => Err((format!("Function {} not found", name), None)),
+    }
+}
+
 // Other helpers
 fn eval_unwrap_expression(
     exp: Expression,