Struct DynamicFunction 

pub struct DynamicFunction { /* private fields */ }

A dynamic function that can be called at runtime.

DynamicFunction provides a concrete implementation of the Function trait that wraps a closure. This allows for runtime creation of functions with dynamic behavior.

Fields

• name - The function name
• inputs - List of input arguments
• output - Optional output argument
• ptr - The function implementation as a boxed closure

Example

use plux_rs::function::{DynamicFunction, Arg, FunctionOutput};
use plux_rs::variable::VariableType;

let multiply = DynamicFunction::new(
    "multiply",
    vec![
        Arg::new("x", VariableType::F64),
        Arg::new("y", VariableType::F64),
    ],
    Some(Arg::new("result", VariableType::F64)),
    |args| -> FunctionOutput {
        let x = args[0].parse_ref::<f64>();
        let y = args[1].parse_ref::<f64>();
        Ok(Some((x * y).into()))
    }
);

Implementations

impl DynamicFunction

pub fn new<S, F>(name: S, inputs: Vec<Arg>, output: Option<Arg>, ptr: F) -> Self

where S: Into<String>, F: Fn(&[Variable]) -> FunctionOutput + Send + Sync + 'static,

Creates a new dynamic function.

Parameters

• name - The function name (will be converted to String)
• inputs - Vector of input arguments
• output - Optional output argument (None for void functions)
• ptr - The function implementation as a closure

Returns

Returns a new DynamicFunction instance.

Type Parameters

• S - Type that can be converted into String (for the name)
• F - Function type that takes &Variable and returns FunctionOutput

Example

use plux_rs::function::{DynamicFunction, Arg, FunctionOutput};
use plux_rs::variable::VariableType;

let greet = DynamicFunction::new(
    "greet",
    vec![Arg::new("name", VariableType::String)],
    Some(Arg::new("message", VariableType::String)),
    |args| -> FunctionOutput {
        let name = args[0].parse_ref::<String>();
        Ok(Some(format!("Hello, {}!", name).into()))
    }
);

Trait Implementations

impl Function for DynamicFunction

type Output = Result<Option<Variable>, Box<dyn Error + Sync + Send>>

The output type of the function

fn name(&self) -> String

Returns the name of the function.

fn inputs(&self) -> Vec<Arg>

Returns the input arguments of the function.

fn output(&self) -> Option<Arg>

Returns the output argument of the function.

fn call(&self, args: &[Variable]) -> Self::Output

Calls the function with the given arguments.