feat: used new macro to match input arguments

Author: raphael-goetz

taurus/src/context/argument.rs

@@ -1,3 +1,9 @@
+use std::convert::Infallible;
+use tucana::shared::{ListValue, Struct, Value};
+use tucana::shared::value::Kind;
+use crate::context::signal::Signal;
+use crate::error::RuntimeError;
+
 #[derive(Clone, Debug)]
 pub enum Argument {
     // Eval => Evaluated Value
@@ -12,4 +18,75 @@ pub enum Argument {
 pub enum ParameterNode {
     Eager,
     Lazy
+}
+
+pub trait TryFromArgument: Sized {
+    fn try_from_argument(a: &Argument) -> Result<Self, Signal>;
+}
+
+fn type_err(msg: &str) -> Signal {
+    Signal::Failure(RuntimeError::simple("InvalidArgumentRuntimeError", msg.to_string()))
+}
+
+impl TryFromArgument for Value {
+    fn try_from_argument(a: &Argument) -> Result<Self, Signal> {
+        match a {
+            Argument::Eval(v) => Ok(v.clone()),
+            _ => Err(type_err("Expected evaluated value but got lazy thunk")),
+        }
+    }
+}
+
+impl TryFromArgument for f64 {
+    fn try_from_argument(a: &Argument) -> Result<Self, Signal> {
+        match a {
+            Argument::Eval(Value { kind: Some(Kind::NumberValue(n)) }) => Ok(*n),
+            _ => Err(type_err("Expected number")),
+        }
+    }
+}
+
+impl TryFromArgument for bool {
+    fn try_from_argument(a: &Argument) -> Result<Self, Signal> {
+        match a {
+            Argument::Eval(Value { kind: Some(Kind::BoolValue(b)) }) => Ok(*b),
+            _ => Err(type_err("Expected boolean")),
+        }
+    }
+}
+
+impl TryFromArgument for String {
+    fn try_from_argument(a: &Argument) -> Result<Self, Signal> {
+        match a {
+            Argument::Eval(Value { kind: Some(Kind::StringValue(s)) }) => Ok(s.clone()),
+            _ => Err(type_err("Expected string")),
+        }
+    }
+}
+
+impl TryFromArgument for Struct {
+    fn try_from_argument(a: &Argument) -> Result<Self, Signal> {
+        match a {
+            Argument::Eval(Value { kind: Some(Kind::StructValue(s)) }) => Ok(s.clone()),
+            _ => Err(type_err("Expected struct")),
+        }
+    }
+}
+
+impl TryFromArgument for ListValue {
+    fn try_from_argument(a: &Argument) -> Result<Self, Signal> {
+        match a {
+            Argument::Eval(Value { kind: Some(Kind::ListValue(list)) }) => Ok(list.clone()),
+            _ => Err(Signal::Failure(RuntimeError::simple_str(
+                "InvalidArgumentRuntimeError",
+                "Expected array (ListValue)",
+            ))),
+        }
+    }
+}
+
+impl From<Infallible> for RuntimeError {
+    fn from(never: Infallible) -> Self {
+        match never {}
+    }
 }

taurus/src/context/mod.rs

@@ -3,6 +3,7 @@ pub mod signal;
 pub mod argument;
 pub mod executor;
 pub mod registry;
+pub mod macros;
 
 use crate::error::RuntimeError;
 use std::{

taurus/src/context/registry.rs

@@ -7,11 +7,8 @@ use std::collections::HashMap;
 /// - 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 type HandlerFn =
+    fn(args: &[Argument], ctx: &mut Context, run: &mut dyn FnMut(i64) -> Signal) -> Signal;
 
 pub struct HandlerFunctionEntry {
     pub handler: HandlerFn,
@@ -29,6 +26,47 @@ impl Default for FunctionStore {
     }
 }
 
+pub trait IntoFunctionEntry {
+    fn into_function_entry(self, param: Vec<ParameterNode>) -> HandlerFunctionEntry;
+    fn eager(self, param_amount: i8) -> HandlerFunctionEntry;
+    fn lazy(self, param_amount: i8) -> HandlerFunctionEntry;
+}
+
+impl IntoFunctionEntry for HandlerFn {
+    fn into_function_entry(self, param: Vec<ParameterNode>) -> HandlerFunctionEntry {
+        HandlerFunctionEntry {
+            handler: self,
+            param_modes: param,
+        }
+    }
+
+    fn eager(self, param_amount: i8) -> HandlerFunctionEntry {
+        let mut params = vec![];
+
+        for _ in 0..param_amount {
+            params.push(ParameterNode::Eager)
+        }
+
+        HandlerFunctionEntry {
+            handler: self,
+            param_modes: params,
+        }
+    }
+
+    fn lazy(self, param_amount: i8) -> HandlerFunctionEntry {
+        let mut params = vec![];
+
+        for _ in 0..param_amount {
+            params.push(ParameterNode::Lazy)
+        }
+
+        HandlerFunctionEntry {
+            handler: self,
+            param_modes: params,
+        }
+    }
+}
+
 impl FunctionStore {
     /// Create a new, empty store.
     pub fn new() -> Self {
@@ -48,4 +86,4 @@ impl FunctionStore {
             self.functions.insert(id.to_string(), func);
         }
     }
-}
+}