WIP: adding back vectorization for the 12th time

Author: timfennis

ndc_lib/src/interpreter/evaluate/mod.rs

@@ -120,7 +120,7 @@ pub(crate) fn evaluate_expression(
                             );
                         };
                         // (&func, &mut arguments, environment, span)
-                        let result = match func.borrow().call_checked(&mut arguments, environment) {
+                        let result = match func.call_checked(&mut arguments, environment) {
                             Err(FunctionCarrier::FunctionTypeMismatch)
                                 if operations_to_try.peek().is_none() =>
                             {
@@ -190,7 +190,7 @@ pub(crate) fn evaluate_expression(
                             );
                         };
 
-                        let result = match func.borrow().call_checked(
+                        let result = match func.call_checked(
                             &mut [value_at_index.clone(), right_value.clone()],
                             environment,
                         ) {
@@ -328,20 +328,17 @@ pub(crate) fn evaluate_expression(
             arguments,
         } => {
             let mut evaluated_args = Vec::new();
-            let mut arg_types = Vec::new();
 
             for argument in arguments {
                 let arg = evaluate_expression(argument, environment)?;
-                arg_types.push(arg.static_type());
                 evaluated_args.push(arg);
             }
 
-            let function_as_value = evaluate_as_function(function, &arg_types, environment)?;
+            let function_as_value = resolve_and_call(function, &arg_types, environment)?;
 
             return if let Value::Function(function) = function_as_value {
                 // Here we should be able to call without checking types
                 function
-                    .borrow()
                     .call(&mut evaluated_args, environment)
                     .add_span(span)
             } else {
@@ -671,7 +668,7 @@ fn produce_default_value(
 ) -> EvaluationResult {
     match default {
         Value::Function(function) => {
-            match function.borrow().call_checked(&mut [], environment) {
+            match function.call_checked(&mut [], environment) {
                 Err(FunctionCarrier::FunctionTypeMismatch) => {
                     Err(FunctionCarrier::EvaluationError(EvaluationError::new(
                         "default function is not callable without arguments".to_string(),
@@ -981,26 +978,77 @@ fn execute_for_iterations(
     Ok(Value::unit())
 }
 
-fn evaluate_as_function(
+// fn evaluate_as_function(
+//     function_expression: &ExpressionLocation,
+//     arg_types: &[StaticType],
+//     environment: &Rc<RefCell<Environment>>,
+// ) -> EvaluationResult {
+//     let ExpressionLocation { expression, .. } = function_expression;
+//
+//     if let Expression::Identifier { resolved, .. } = expression {
+//         resolve_dynamic_binding(resolved, arg_types, environment).ok_or_else(|| {
+//             FunctionCarrier::EvaluationError(EvaluationError::new(
+//                 format!(
+//                     "Failed to find a function that can handle the arguments ({}) at runtime",
+//                     arg_types.iter().join(", ")
+//                 ),
+//                 function_expression.span,
+//             ))
+//         })
+//     } else {
+//         evaluate_expression(function_expression, environment)
+//     }
+// }
+
+fn resolve_and_call(
     function_expression: &ExpressionLocation,
-    arg_types: &[StaticType],
+    args: &mut [Value],
     environment: &Rc<RefCell<Environment>>,
 ) -> EvaluationResult {
+    ////////////////////////////
     let ExpressionLocation { expression, .. } = function_expression;
 
-    if let Expression::Identifier { resolved, .. } = expression {
-        resolve_dynamic_binding(resolved, arg_types, environment).ok_or_else(|| {
+    let function = if let Expression::Identifier { resolved, .. } = expression {
+        let arg_types = args.iter().map(|arg| arg.static_type()).collect::<Vec<_>>();
+
+        let opt = match resolved {
+            Binding::None => None,
+            Binding::Resolved(var) => Some(environment.borrow().get(*var)),
+            Binding::Dynamic(dynamic_binding) => dynamic_binding
+                .iter() // TODO: should we consider the binding order?
+                .find_map(|binding| {
+                    let value = environment.borrow().get(*binding);
+
+                    let Value::Function(fun) = &value else {
+                        panic!("dynamic binding resolved to non-function type at runtime");
+                    };
+
+                    // Find the first function that matches
+                    if fun.static_type().is_fn_and_matches(&arg_types) {
+                        return Some(value);
+                    }
+
+                    None
+                }),
+        };
+        opt.ok_or_else(|| {
             FunctionCarrier::EvaluationError(EvaluationError::new(
                 format!(
                     "Failed to find a function that can handle the arguments ({}) at runtime",
                     arg_types.iter().join(", ")
                 ),
                 function_expression.span,
             ))
-        })
+        })?
     } else {
-        evaluate_expression(function_expression, environment)
-    }
+        evaluate_expression(function_expression, environment)?
+    };
+
+    ////////////////////////////
+    ////////////////////////////
+    ////////////////////////////
+
+    todo!();
 }
 
 fn resolve_dynamic_binding(
@@ -1021,11 +1069,11 @@ fn resolve_dynamic_binding(
                 };
 
                 // Find the first function that matches
-                if fun.borrow().static_type().is_fn_and_matches(arg_types) {
-                    Some(value)
-                } else {
-                    None
+                if fun.static_type().is_fn_and_matches(arg_types) {
+                    return Some(value);
                 }
+
+                None
             }),
     }
 }

ndc_lib/src/interpreter/function.rs

@@ -18,13 +18,13 @@ use std::rc::Rc;
 /// Callable is a wrapper around a `OverloadedFunction` pointer and the environment to make it
 /// easy to have an executable function as a method signature in the standard library
 pub struct Callable<'a> {
-    pub function: Rc<RefCell<Function>>,
+    pub function: Rc<Function>,
     pub environment: &'a Rc<RefCell<Environment>>,
 }
 
 impl Callable<'_> {
     pub fn call(&self, args: &mut [Value]) -> EvaluationResult {
-        self.function.borrow().call(args, self.environment)
+        self.function.call(args, self.environment)
     }
 }
 

ndc_lib/src/interpreter/value.rs

@@ -25,12 +25,12 @@ pub enum Value {
     Number(Number),
     Bool(bool),
     Sequence(Sequence),
-    Function(Rc<RefCell<Function>>),
+    Function(Rc<Function>),
 }
 
 impl Value {
     pub(crate) fn function(function: Function) -> Self {
-        Self::Function(Rc::new(RefCell::new(function)))
+        Self::Function(Rc::new(function))
     }
     pub(crate) fn string<S: Into<String>>(string: S) -> Self {
         Self::Sequence(Sequence::String(Rc::new(RefCell::new(string.into()))))
@@ -158,7 +158,7 @@ impl Value {
             Self::Bool(_) => StaticType::Bool,
 
             Self::Sequence(s) => s.static_type(),
-            Self::Function(fun) => fun.borrow().static_type(),
+            Self::Function(fun) => fun.static_type(),
         }
     }
 

ndc_lib/src/stdlib/value.rs

@@ -16,8 +16,8 @@ mod inner {
     pub fn docs(func: &Callable<'_>) -> anyhow::Result<String> {
         let mut buf = String::new();
 
-        let sig = func.function.borrow().type_signature();
-        let fun = func.function.borrow();
+        let sig = func.function.type_signature();
+        let fun = &func.function;
 
         if fun.name().is_empty() {
             write!(buf, "fn({sig})")?;