Struct FnWrapper

pub struct FnWrapper<T, F> { /* private fields */ }

Wrapper of a function containing information about its arguments.

Using FnWrapper allows to define native functions with minimum boilerplate and with increased type safety. FnWrappers can be constructed explcitly or indirectly via Environment::insert_wrapped_fn(), Value::wrapped_fn(), or wrap().

Arguments of a wrapped function must implement TryFromValue trait for the applicable grammar, and the output type must implement IntoEvalResult. If arguments and/or output have non-'static lifetime, use the wrap_fn macro. If you need CallContext (e.g., to call functions provided as an argument), use the wrap_fn_with_context macro.

Examples

Basic function

use arithmetic_eval::{fns, Environment, Value, VariableMap};

let max = fns::wrap(|x: f32, y: f32| if x > y { x } else { y });

let program = "max(1, 3) == 3 && max(-1, -3) == -1";
let program = Untyped::<F32Grammar>::parse_statements(program)?;
let module = Environment::new()
    .insert_native_fn("max", max)
    .compile_module("test_max", &program)?;
assert_eq!(module.run()?, Value::Bool(true));

Fallible function with complex args

fn zip_arrays(xs: Vec<f32>, ys: Vec<f32>) -> Result<Vec<(f32, f32)>, String> {
    if xs.len() == ys.len() {
        Ok(xs.into_iter().zip(ys).map(|(x, y)| (x, y)).collect())
    } else {
        Err("Arrays must have the same size".to_owned())
    }
}

let program = "(1, 2, 3).zip((4, 5, 6)) == ((1, 4), (2, 5), (3, 6))";
let program = Untyped::<F32Grammar>::parse_statements(program)?;

let module = Environment::new()
    .insert_wrapped_fn("zip", zip_arrays)
    .compile_module("test_zip", &program)?;
assert_eq!(module.run()?, Value::Bool(true));

Implementations

impl<T, F> FnWrapper<T, F>

pub const fn new(function: F) -> Self

Creates a new wrapper.

Note that the created wrapper is not guaranteed to be usable as NativeFn. For this to be the case, function needs to be a function or an Fn closure, and the T type argument needs to be a tuple with the function return type and the argument types (in this order).

Trait Implementations

impl<T, F: Clone> Clone for FnWrapper<T, F>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, F> Debug for FnWrapper<T, F>

where F: Debug,

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Num, F, Ret> NativeFn<Num> for FnWrapper<(Ret,), F>

where F: Fn() -> Ret, Ret: for<'val> IntoEvalResult<'val, Num>,

fn evaluate<'a>( &self, args: Vec<SpannedValue<'a, Num>>, context: &mut CallContext<'_, 'a, Num>, ) -> EvalResult<'a, Num>

Executes the function on the specified arguments.

impl<Num, F, Ret, T> NativeFn<Num> for FnWrapper<(Ret, T), F>

where F: Fn(T) -> Ret, T: for<'val> TryFromValue<'val, Num>, Ret: for<'val> IntoEvalResult<'val, Num>,

fn evaluate<'a>( &self, args: Vec<SpannedValue<'a, Num>>, context: &mut CallContext<'_, 'a, Num>, ) -> EvalResult<'a, Num>

Executes the function on the specified arguments.

impl<Num, F, Ret, T, U> NativeFn<Num> for FnWrapper<(Ret, T, U), F>

where F: Fn(T, U) -> Ret, T: for<'val> TryFromValue<'val, Num>, U: for<'val> TryFromValue<'val, Num>, Ret: for<'val> IntoEvalResult<'val, Num>,

fn evaluate<'a>( &self, args: Vec<SpannedValue<'a, Num>>, context: &mut CallContext<'_, 'a, Num>, ) -> EvalResult<'a, Num>

Executes the function on the specified arguments.

impl<Num, F, Ret, T, U, V> NativeFn<Num> for FnWrapper<(Ret, T, U, V), F>

where F: Fn(T, U, V) -> Ret, T: for<'val> TryFromValue<'val, Num>, U: for<'val> TryFromValue<'val, Num>, V: for<'val> TryFromValue<'val, Num>, Ret: for<'val> IntoEvalResult<'val, Num>,

fn evaluate<'a>( &self, args: Vec<SpannedValue<'a, Num>>, context: &mut CallContext<'_, 'a, Num>, ) -> EvalResult<'a, Num>

Executes the function on the specified arguments.

impl<Num, F, Ret, T, U, V, W> NativeFn<Num> for FnWrapper<(Ret, T, U, V, W), F>

where F: Fn(T, U, V, W) -> Ret, T: for<'val> TryFromValue<'val, Num>, U: for<'val> TryFromValue<'val, Num>, V: for<'val> TryFromValue<'val, Num>, W: for<'val> TryFromValue<'val, Num>, Ret: for<'val> IntoEvalResult<'val, Num>,

fn evaluate<'a>( &self, args: Vec<SpannedValue<'a, Num>>, context: &mut CallContext<'_, 'a, Num>, ) -> EvalResult<'a, Num>

Executes the function on the specified arguments.

impl<Num, F, Ret, T, U, V, W, X> NativeFn<Num> for FnWrapper<(Ret, T, U, V, W, X), F>

where F: Fn(T, U, V, W, X) -> Ret, T: for<'val> TryFromValue<'val, Num>, U: for<'val> TryFromValue<'val, Num>, V: for<'val> TryFromValue<'val, Num>, W: for<'val> TryFromValue<'val, Num>, X: for<'val> TryFromValue<'val, Num>, Ret: for<'val> IntoEvalResult<'val, Num>,

fn evaluate<'a>( &self, args: Vec<SpannedValue<'a, Num>>, context: &mut CallContext<'_, 'a, Num>, ) -> EvalResult<'a, Num>

Executes the function on the specified arguments.

impl<Num, F, Ret, T, U, V, W, X, Y> NativeFn<Num> for FnWrapper<(Ret, T, U, V, W, X, Y), F>

where F: Fn(T, U, V, W, X, Y) -> Ret, T: for<'val> TryFromValue<'val, Num>, U: for<'val> TryFromValue<'val, Num>, V: for<'val> TryFromValue<'val, Num>, W: for<'val> TryFromValue<'val, Num>, X: for<'val> TryFromValue<'val, Num>, Y: for<'val> TryFromValue<'val, Num>, Ret: for<'val> IntoEvalResult<'val, Num>,

fn evaluate<'a>( &self, args: Vec<SpannedValue<'a, Num>>, context: &mut CallContext<'_, 'a, Num>, ) -> EvalResult<'a, Num>

Executes the function on the specified arguments.

impl<Num, F, Ret, T, U, V, W, X, Y, Z> NativeFn<Num> for FnWrapper<(Ret, T, U, V, W, X, Y, Z), F>

where F: Fn(T, U, V, W, X, Y, Z) -> Ret, T: for<'val> TryFromValue<'val, Num>, U: for<'val> TryFromValue<'val, Num>, V: for<'val> TryFromValue<'val, Num>, W: for<'val> TryFromValue<'val, Num>, X: for<'val> TryFromValue<'val, Num>, Y: for<'val> TryFromValue<'val, Num>, Z: for<'val> TryFromValue<'val, Num>, Ret: for<'val> IntoEvalResult<'val, Num>,

fn evaluate<'a>( &self, args: Vec<SpannedValue<'a, Num>>, context: &mut CallContext<'_, 'a, Num>, ) -> EvalResult<'a, Num>

Executes the function on the specified arguments.

impl<Num, F, Ret, T, U, V, W, X, Y, Z, A> NativeFn<Num> for FnWrapper<(Ret, T, U, V, W, X, Y, Z, A), F>

where F: Fn(T, U, V, W, X, Y, Z, A) -> Ret, T: for<'val> TryFromValue<'val, Num>, U: for<'val> TryFromValue<'val, Num>, V: for<'val> TryFromValue<'val, Num>, W: for<'val> TryFromValue<'val, Num>, X: for<'val> TryFromValue<'val, Num>, Y: for<'val> TryFromValue<'val, Num>, Z: for<'val> TryFromValue<'val, Num>, A: for<'val> TryFromValue<'val, Num>, Ret: for<'val> IntoEvalResult<'val, Num>,

fn evaluate<'a>( &self, args: Vec<SpannedValue<'a, Num>>, context: &mut CallContext<'_, 'a, Num>, ) -> EvalResult<'a, Num>

Executes the function on the specified arguments.

impl<Num, F, Ret, T, U, V, W, X, Y, Z, A, B> NativeFn<Num> for FnWrapper<(Ret, T, U, V, W, X, Y, Z, A, B), F>

where F: Fn(T, U, V, W, X, Y, Z, A, B) -> Ret, T: for<'val> TryFromValue<'val, Num>, U: for<'val> TryFromValue<'val, Num>, V: for<'val> TryFromValue<'val, Num>, W: for<'val> TryFromValue<'val, Num>, X: for<'val> TryFromValue<'val, Num>, Y: for<'val> TryFromValue<'val, Num>, Z: for<'val> TryFromValue<'val, Num>, A: for<'val> TryFromValue<'val, Num>, B: for<'val> TryFromValue<'val, Num>, Ret: for<'val> IntoEvalResult<'val, Num>,

fn evaluate<'a>( &self, args: Vec<SpannedValue<'a, Num>>, context: &mut CallContext<'_, 'a, Num>, ) -> EvalResult<'a, Num>

Executes the function on the specified arguments.

impl<Num, F, Ret, T, U, V, W, X, Y, Z, A, B, C> NativeFn<Num> for FnWrapper<(Ret, T, U, V, W, X, Y, Z, A, B, C), F>

where F: Fn(T, U, V, W, X, Y, Z, A, B, C) -> Ret, T: for<'val> TryFromValue<'val, Num>, U: for<'val> TryFromValue<'val, Num>, V: for<'val> TryFromValue<'val, Num>, W: for<'val> TryFromValue<'val, Num>, X: for<'val> TryFromValue<'val, Num>, Y: for<'val> TryFromValue<'val, Num>, Z: for<'val> TryFromValue<'val, Num>, A: for<'val> TryFromValue<'val, Num>, B: for<'val> TryFromValue<'val, Num>, C: for<'val> TryFromValue<'val, Num>, Ret: for<'val> IntoEvalResult<'val, Num>,

fn evaluate<'a>( &self, args: Vec<SpannedValue<'a, Num>>, context: &mut CallContext<'_, 'a, Num>, ) -> EvalResult<'a, Num>

Executes the function on the specified arguments.

impl<T, F: Copy> Copy for FnWrapper<T, F>