Trait arithmetic_eval::NativeFn[−][src]

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

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

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

Executes the function on the specified arguments.

Trait Implementations

impl<T> Debug for dyn NativeFn<T>[src]

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

Formats the value using the given formatter. Read more

Implementors

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

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

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>, [src]

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

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>, [src]

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

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>, [src]

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

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>, [src]

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

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>, [src]

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

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>, [src]

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

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>, [src]

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

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>, [src]

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

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>, [src]

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

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>, [src]

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

impl<T> NativeFn<T> for Compare[src]

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

impl<T> NativeFn<T> for Array where
    T: Clone + Zero + One, [src]

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

impl<T> NativeFn<T> for Assert[src]

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

impl<T> NativeFn<T> for If[src]

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

impl<T> NativeFn<T> for Push[src]

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

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

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

impl<T: Clone> NativeFn<T> for Filter[src]

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

impl<T: Clone> NativeFn<T> for Fold[src]

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

impl<T: Clone> NativeFn<T> for Loop[src]

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

impl<T: Clone> NativeFn<T> for Map[src]

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

impl<T: Clone> NativeFn<T> for Merge[src]

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

impl<T: Clone> NativeFn<T> for While[src]

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

impl<T: Display> NativeFn<T> for AssertEq[src]

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

impl<T: Display> NativeFn<T> for Dbg[src]

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

impl<T: FromPrimitive> NativeFn<T> for Len[src]

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