Trait arithmetic_eval::NativeFn

pub trait NativeFn<T> {
    pub fn evaluate<'a>(
        &self, 
        args: Vec<SpannedValue<'a, T>>, 
        context: &mut CallContext<'_, 'a, T>
    ) -> EvalResult<'a, T>;
}

Function on zero or more Values.

Native functions are defined in the Rust code and then can be used from the interpreted code. See fns module docs for different ways to define native functions.

Required methods

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

Executes the function on the specified arguments.

Loading content...

Trait Implementations

impl<T> Debug for dyn NativeFn<T>

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

Formats the value using the given formatter.

Implementors

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

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

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>, 

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

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>, 

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

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>, 

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

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>, 

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

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>, 

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

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>, 

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

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>, 

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

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>, 

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

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>, 

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

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>, 

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

impl<T> NativeFn<T> for Compare

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

impl<T> NativeFn<T> for Assert

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

impl<T> NativeFn<T> for If

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

impl<T> NativeFn<T> for Push

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

impl<T, F: 'static> NativeFn<T> for F where
    F: for<'a> Fn(Vec<SpannedValue<'a, T>>, &mut CallContext<'_, 'a, T>) -> EvalResult<'a, T>, 

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

impl<T: Clone> NativeFn<T> for Filter

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

impl<T: Clone> NativeFn<T> for Fold

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

impl<T: Clone> NativeFn<T> for Loop

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

impl<T: Clone> NativeFn<T> for Map

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

impl<T: Clone> NativeFn<T> for Merge

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

impl<T: Clone> NativeFn<T> for While

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

impl<T: Display> NativeFn<T> for AssertEq

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

impl<T: Display> NativeFn<T> for Dbg

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

Loading content...