Implement tuple vectorization for arithmetic operators

Element-wise operations now work on numeric tuples:
- (1,2) + (5,3) == (6,5)
- (1,1) * 2 == (2,2)
- 5 + (3,2) == (8,7)

The analyser's last-resort fallback now collects all same-named
bindings instead of just the last one, so operators like `-` with
both unary and binary overloads can be correctly resolved at runtime.
The evaluator's resolve_and_call attempts vectorization when no direct
function match is found and the argument types support it.

Author: timfennis

ndc_lib/src/interpreter/evaluate/mod.rs

@@ -334,7 +334,7 @@ pub(crate) fn evaluate_expression(
                 evaluated_args.push(arg);
             }
 
-            let function_as_value = resolve_and_call(function, evaluated_args, environment, span)?;
+            resolve_and_call(function, evaluated_args, environment, span)?
         }
         Expression::FunctionDeclaration {
             parameters: arguments,
@@ -991,36 +991,59 @@ fn resolve_and_call(
     environment: &Rc<RefCell<Environment>>,
     span: Span,
 ) -> EvaluationResult {
-    ////////////////////////////
     let ExpressionLocation { expression, .. } = function_expression;
 
-    let function_as_value = if let Expression::Identifier { resolved, .. } = expression {
+    let function_as_value = if let Expression::Identifier { name, 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?
+                .iter()
                 .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
                 }),
         };
+
+        if opt.is_none() {
+            if let Binding::Dynamic(dynamic_binding) = resolved {
+                if let [left_type, right_type] = arg_types.as_slice() {
+                    if left_type.supports_vectorization_with(right_type) {
+                        let elem_types = vectorized_element_types(left_type, right_type);
+                        let inner_fn = dynamic_binding.iter().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");
+                            };
+                            if fun.static_type().is_fn_and_matches(&elem_types) {
+                                Some(Rc::clone(&fun))
+                            } else {
+                                None
+                            }
+                        });
+                        if let Some(inner_fn) = inner_fn {
+                            return inner_fn.call_vectorized(&mut args, environment).add_span(span);
+                        }
+                    }
+                }
+            }
+        }
+
         opt.ok_or_else(|| {
             FunctionCarrier::EvaluationError(EvaluationError::new(
                 format!(
-                    "Failed to find a function that can handle the arguments ({}) at runtime",
+                    "no function called '{name}' found matches the arguments: ({})",
                     arg_types.iter().join(", ")
                 ),
                 function_expression.span,
@@ -1030,12 +1053,7 @@ fn resolve_and_call(
         evaluate_expression(function_expression, environment)?
     };
 
-    ////////////////////////////
-    ////////////////////////////
-    ////////////////////////////
-
     if let Value::Function(function) = function_as_value {
-        // Here we should be able to call without checking types
         function.call(&mut args, environment).add_span(span)
     } else {
         Err(FunctionCarrier::EvaluationError(EvaluationError::new(
@@ -1048,6 +1066,12 @@ fn resolve_and_call(
     }
 }
 
+fn vectorized_element_types(left: &StaticType, right: &StaticType) -> [StaticType; 2] {
+    let left_elem = left.sequence_element_type().unwrap_or_else(|| left.clone());
+    let right_elem = right.sequence_element_type().unwrap_or_else(|| right.clone());
+    [left_elem, right_elem]
+}
+
 fn resolve_dynamic_binding(
     binding: &Binding,
     arg_types: &[StaticType],

ndc_lib/src/interpreter/function.rs

@@ -122,49 +122,39 @@ impl Function {
         }
     }
 
-    fn call_vectorized(
+    pub fn call_vectorized(
         &self,
         args: &mut [Value],
         env: &Rc<RefCell<Environment>>,
     ) -> EvaluationResult {
         let [left, right] = args else {
-            // Vectorized application only works in cases where there are two tuple arguments
             panic!("incorrect argument count for vectorization should have been handled by caller");
         };
 
-        // TODO: let caller handle checks?
-        // if !left.supports_vectorization_with(right) {
-        //     return Err(FunctionCarrier::FunctionNotFound);
-        // }
-
-        let (left, right) = match (left, right) {
-            // Both are tuples
-            (Value::Sequence(Sequence::Tuple(left)), Value::Sequence(Sequence::Tuple(right))) => {
-                (left, right.as_slice())
+        let result = match (left, right) {
+            (Value::Sequence(Sequence::Tuple(left_rc)), Value::Sequence(Sequence::Tuple(right_rc))) => {
+                left_rc
+                    .iter()
+                    .zip(right_rc.iter())
+                    .map(|(l, r)| self.call(&mut [l.clone(), r.clone()], env))
+                    .collect::<Result<Vec<_>, _>>()?
             }
-            // Left is a number and right is a tuple
-            (left @ Value::Number(_), Value::Sequence(Sequence::Tuple(right))) => (
-                &mut Rc::new(vec![left.clone(); right.len()]),
-                right.as_slice(),
-            ),
-            // Left is a tuple and right is a number
-            (Value::Sequence(Sequence::Tuple(left)), right @ Value::Number(_)) => {
-                (left, std::slice::from_ref(right))
+            (left @ Value::Number(_), Value::Sequence(Sequence::Tuple(right_rc))) => {
+                right_rc
+                    .iter()
+                    .map(|r| self.call(&mut [left.clone(), r.clone()], env))
+                    .collect::<Result<Vec<_>, _>>()?
             }
-            _ => {
-                panic!("caller should handle all checks before vectorizing")
+            (Value::Sequence(Sequence::Tuple(left_rc)), right @ Value::Number(_)) => {
+                left_rc
+                    .iter()
+                    .map(|l| self.call(&mut [l.clone(), right.clone()], env))
+                    .collect::<Result<Vec<_>, _>>()?
             }
+            _ => panic!("caller should handle all checks before vectorizing"),
         };
 
-        let left_mut: &mut Vec<Value> = Rc::make_mut(left);
-
-        // Zip the mutable vector with the immutable right side and perform the operations on all elements
-        // TODO: maybe one day figure out how to get rid of all these clones
-        for (l, r) in left_mut.iter_mut().zip(right.iter().cycle()) {
-            *l = self.call(&mut [l.clone(), r.clone()], env)?;
-        }
-
-        Ok(Value::Sequence(Sequence::Tuple(left.clone())))
+        Ok(Value::Sequence(Sequence::Tuple(Rc::new(result))))
     }
 }
 

ndc_lib/src/interpreter/mod.rs

@@ -71,8 +71,8 @@ impl Interpreter {
             self.analyser.analyse(e)?;
         }
 
-        dbg!(&expressions);
-        dbg!(&self.analyser);
+        //dbg!(&expressions);
+        //dbg!(&self.analyser);
 
         let final_value = self.interpret(expressions.into_iter())?;
 

ndc_lib/src/interpreter/semantic/analyser.rs

@@ -637,15 +637,40 @@ impl ScopeTree {
 
                 Some(Binding::Dynamic(loose_bindings))
             })
-            // If we can't find any function in scope that could match, we just default to an identifier.
-            // TODO: no this fucks everything
+            // If we can't find any function in scope that could match, fall back to all same-named
+            // bindings so runtime dynamic dispatch (including vectorization) can pick the right one.
             .or_else(|| {
-                self.get_binding_any(ident)
-                    .map(|resolved| Binding::Dynamic(vec![resolved]))
+                let all_bindings = self.get_all_bindings_by_name(ident);
+                if all_bindings.is_empty() {
+                    return None;
+                }
+                Some(Binding::Dynamic(all_bindings))
             })
             .unwrap_or(Binding::None)
     }
 
+    fn get_all_bindings_by_name(&self, ident: &str) -> Vec<ResolvedVar> {
+        let mut results = Vec::new();
+        let mut depth = 0;
+        let mut scope_ptr = self.current_scope_idx;
+
+        loop {
+            let slots = self.scopes[scope_ptr].find_all_slots_by_name(ident);
+            results.extend(slots.into_iter().map(|slot| ResolvedVar::Captured { slot, depth }));
+
+            if let Some(parent_idx) = self.scopes[scope_ptr].parent_idx {
+                depth += 1;
+                scope_ptr = parent_idx;
+            } else {
+                let global_slots = self.global_scope.find_all_slots_by_name(ident);
+                results.extend(global_slots.into_iter().map(|slot| ResolvedVar::Global { slot }));
+                break;
+            }
+        }
+
+        results
+    }
+
     fn resolve_function(&mut self, ident: &str, arg_types: &[StaticType]) -> Option<ResolvedVar> {
         let mut depth = 0;
         let mut scope_ptr = self.current_scope_idx;
@@ -692,6 +717,16 @@ impl Scope {
             .rposition(|(ident, _)| ident == find_ident)
     }
 
+    fn find_all_slots_by_name(&self, find_ident: &str) -> Vec<usize> {
+        self.identifiers
+            .iter()
+            .enumerate()
+            .filter_map(|(slot, (ident, _))| {
+                if ident == find_ident { Some(slot) } else { None }
+            })
+            .collect()
+    }
+
     fn find_function_candidates(&self, find_ident: &str, find_types: &[StaticType]) -> Vec<usize> {
         self.identifiers.iter()
             .enumerate()

tests/programs/900_bugs/bug0003_invoke_invalid_value.ndct

@@ -1,4 +1,4 @@
 --PROGRAM--
 5();
 --EXPECT-ERROR--
-Failed to invoke expression as function
+Unable to invoke Int as a function.