feat: wip added Lazy and Eager functions to ìmplement if-else logic

Author: raphael-goetz

src/context/argument.rs

@@ -0,0 +1,15 @@
+#[derive(Clone, Debug)]
+pub enum Argument {
+    // Eval => Evaluated Value
+    // - can be consumed directly by a function
+    Eval(tucana::shared::Value),
+    // Thunk of NodeFunction identifier
+    // - used for lazy execution of nodes
+    Thunk(i64)
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum ParameterNode {
+    Eager,
+    Lazy
+}

src/context/executor.rs

@@ -0,0 +1,113 @@
+use crate::context::Context;
+use crate::context::signal::Signal;
+use crate::error::RuntimeError;
+use std::collections::HashMap;
+use tucana::shared::{NodeFunction, NodeParameter};
+use crate::context::argument::{Argument, ParameterNode};
+use crate::context::registry::FunctionStore;
+
+pub struct Executor<'a> {
+    functions: &'a FunctionStore,
+    nodes: HashMap<i64, NodeFunction>,
+    context: Context,
+}
+
+type HandleNodeParameterFn = fn(&mut Executor, node_parameter: &NodeParameter) -> Signal;
+
+impl<'a> Executor<'a> {
+    pub fn new(
+        functions: &'a FunctionStore,
+        nodes: HashMap<i64, NodeFunction>,
+        context: Context,
+    ) -> Self {
+        Executor {
+            functions,
+            nodes,
+            context,
+        }
+    }
+
+    pub fn execute(&mut self, starting_node_id: i64) -> Signal {
+        let mut current_node_id = starting_node_id;
+
+        loop {
+            let node = match self.nodes.get(&current_node_id) {
+                None => {
+                    return Signal::Failure(RuntimeError::simple_str(
+                        "NodeNotFound",
+                        "The node with the id was not found",
+                    ));
+                }
+                Some(n) => n.clone(),
+            };
+
+
+            let entry = match self.functions.get(node.runtime_function_id.as_str()) {
+                None => {
+                    return Signal::Failure(RuntimeError::simple_str("FunctionNotFound","The function was not found"))
+                },
+                Some(f) => f,
+            };
+
+            let mut args: Vec<Argument> = Vec::with_capacity(node.parameters.len());
+            for parameter in &node.parameters {
+                let node_value = match &parameter.value {
+                    Some(v) => v,
+                    None => return Signal::Failure(RuntimeError::simple_str("NodeValueNotFound","Missing parameter value")),
+                };
+                let value = match &node_value.value {
+                    Some(v) => v,
+                    None => return Signal::Failure(RuntimeError::simple_str("NodeValueNotFound","Missing inner value")),
+                };
+
+                match value {
+                    tucana::shared::node_value::Value::LiteralValue(val) => {
+                        args.push(Argument::Eval(val.clone()))
+                    }
+                    tucana::shared::node_value::Value::ReferenceValue(_r) => {
+                        unimplemented!("ReferenceValue")
+                    }
+                    tucana::shared::node_value::Value::NodeFunctionId(id) => {
+                        args.push(Argument::Thunk(*id))
+                    }
+                }
+            }
+
+
+            // Eagerly evaluate args that the function *declares* as Eager
+            for (i, a) in args.iter_mut().enumerate() {
+                let mode = entry.param_modes.get(i).copied().unwrap_or(ParameterNode::Eager);
+                if matches!(mode, ParameterNode::Eager) {
+                    if let Argument::Thunk(id) = *a {
+                        match self.execute(id) {
+                            Signal::Success(v) => *a = Argument::Eval(v),
+                            // propagate control flow immediately
+                            s @ (Signal::Failure(_) | Signal::Return(_) | Signal::Respond(_) | Signal::Stop) => return s,
+                        }
+                    }
+                }
+            }
+
+            // Provide a runner for Lazy params
+            let mut run = |node_id: i64| self.execute(node_id);
+
+            // Call the handler (no special cases anywhere)
+            let result = (entry.handler)(&args, &mut self.context, &mut run);
+
+            match result {
+                Signal::Success(value) => {
+                    if let Some(next_node_id) = node.next_node_id {
+                        current_node_id = next_node_id;
+                        continue;
+                    } else {
+                        return Signal::Success(value);
+                    }
+                }
+                Signal::Failure(e) => return Signal::Failure(e),
+                Signal::Return(v) => return Signal::Return(v),
+                Signal::Respond(v) => return Signal::Respond(v),
+                Signal::Stop => return Signal::Stop,
+            }
+        }
+    }
+}

src/context/mod.rs

@@ -1,5 +1,8 @@
 pub mod context;
 pub mod signal;
+pub mod argument;
+pub mod executor;
+mod registry;
 
 use crate::error::RuntimeError;
 use std::{

src/registry/mod.rs src/context/registry.rssrc/registry/mod.rs renamed to src/context/registry.rs

@@ -1,13 +1,26 @@
 use crate::context::Context;
+use crate::context::argument::{Argument, ParameterNode};
 use crate::context::signal::Signal;
 use std::collections::HashMap;
-use tucana::shared::Value;
 
-pub type HandlerFn = fn(&[Value], &mut Context) -> Signal;
+/// HandlerFm
+/// - For eager params, the executor will already convert them to Argument::Eval(Value).
+/// - For lazy params, the executor will pass Argument::Thunk(node_id).
+/// - If a handler wants to execute a lazy arg, it calls run(node_id).
+pub type HandlerFn = fn(
+    args: &[Argument],
+    ctx: &mut Context,
+    run: &mut dyn FnMut(i64) -> Signal,
+) -> Signal;
+
+pub struct HandlerFunctionEntry {
+    pub handler: HandlerFn,
+    pub param_modes: Vec<ParameterNode>,
+}
 
 /// Holds all registered handlers.
 pub struct FunctionStore {
-    functions: HashMap<String, HandlerFn>,
+    functions: HashMap<String, HandlerFunctionEntry>,
 }
 
 impl Default for FunctionStore {
@@ -25,12 +38,12 @@ impl FunctionStore {
     }
 
     /// Look up a handler by its ID.
-    pub fn get(&self, id: &str) -> Option<&HandlerFn> {
+    pub fn get(&self, id: &str) -> Option<&HandlerFunctionEntry> {
         self.functions.get(id)
     }
 
     /// Execute all the registration closures to populate the map.
-    pub fn populate(&mut self, regs: Vec<(&'static str, HandlerFn)>) {
+    pub fn populate(&mut self, regs: Vec<(&'static str, HandlerFunctionEntry)>) {
         for (id, func) in regs {
             self.functions.insert(id.to_string(), func);
         }

src/executor/mod.rs

@@ -31,7 +31,7 @@ fn r#if(values: &[Value], _ctx: &mut Context) -> Signal {
     let [
         Value {
             kind: Some(Kind::StringValue(text)),
-        },
+        }
     ] = values
     else {
         return Signal::Failure(RuntimeError::simple(
@@ -51,17 +51,19 @@ fn r#if(values: &[Value], _ctx: &mut Context) -> Signal {
     };
 
     if bool {
-        unimplemented!()
+    //    Signal::Skip(vec![0])
     } else {
-        unimplemented!()
+   //     Signal::Return(Value {
+   //         kind: Some(Kind::NullValue(0)),
+   //     })
     }
 }
 
 fn if_else(values: &[Value], _ctx: &mut Context) -> Signal {
     let [
         Value {
             kind: Some(Kind::StringValue(text)),
-        },
+        }
     ] = values
     else {
         return Signal::Failure(RuntimeError::simple(
@@ -81,8 +83,8 @@ fn if_else(values: &[Value], _ctx: &mut Context) -> Signal {
     };
 
     if bool {
-        unimplemented!()
+    //    Signal::Skip(vec![1])
     } else {
-        unimplemented!()
+   //     Signal::Skip(vec![0])
     }
-}
+}

src/implementation/control.rs

@@ -3,9 +3,9 @@ use std::f64;
 use tucana::shared::{Value, value::Kind};
 
 use crate::context::signal::Signal;
-use crate::{context::Context, error::RuntimeError, registry::HandlerFn};
+use crate::{context::Context, error::RuntimeError};
 
-pub fn collect_number_functions() -> Vec<(&'static str, HandlerFn)> {
+pub fn collect_number_functions() -> Vec<(&'static str, )> {
     vec![
         ("std::number::add", add),
         ("std::number::multiply", multiply),