Trait casbin::rhai::RegisterNativeFunction[−][src]

pub trait RegisterNativeFunction<Args, Result> {
    pub fn into_callable_function(self) -> CallableFunction;

    pub fn param_types() -> Box<[TypeId], Global>ⓘ
Notable traits for Box<R, Global>
impl<R> Read for Box<R, Global> where
    R: Read + ?Sized, impl<W> Write for Box<W, Global> where
    W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
    A: Allocator + 'static,
    F: Future + Unpin + ?Sized,     type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
    A: Allocator,
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;
;
}

Trait to register custom Rust functions.

Required methods

pub fn into_callable_function(self) -> CallableFunction[src]

Convert this function into a CallableFunction.

pub fn param_types() -> Box<[TypeId], Global>ⓘ

Notable traits for Box<R, Global>

impl<R> Read for Box<R, Global> where
    R: Read + ?Sized, impl<W> Write for Box<W, Global> where
    W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
    A: Allocator + 'static,
    F: Future + Unpin + ?Sized,  type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
    A: Allocator,
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;
[src]

Get the type ID’s of this function’s parameters.

Loading content...

Implementors

impl<FN, A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    A: Variant + Clone,
    B: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    A: Variant + Clone,
    B: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<A>, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    A: Variant + Clone,
    B: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<A>, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    A: Variant + Clone,
    B: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    A: Variant + Clone,
    B: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    A: Variant + Clone,
    B: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<A>, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    A: Variant + Clone,
    B: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<A>, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    A: Variant + Clone,
    B: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    B: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    B: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<B>, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    B: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<B>, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    B: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    B: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    B: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<B>, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    B: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<B>, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    B: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<C>, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<C>, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<C>, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<C>, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    C: Variant + Clone,
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<D>, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<D>, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<D>, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<D>, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    D: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<E>, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<E>, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<E>, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<E>, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    E: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<F>, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<F>, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<F>, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<F>, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    F: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<G>, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<G>, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(G, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<G>, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, G, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<G>, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    G: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<H>, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<H>, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(H, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<H>, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, H, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<H>, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    H: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<J>, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<J>, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(J, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<J>, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, J, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<J>, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    J: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<K>, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<K>, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(K, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(K, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<K>, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, K, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<K>, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    K: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<L>, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<L>, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(L, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(L, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<L>, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, L, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<L>, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    L: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<M>, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<M>, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(M, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(M, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<M>, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, M, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<M>, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    M: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut M, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<N>, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<N>, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<N>, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<N>, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(N, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, N, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(N, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    N: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(N, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<P>, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<P>, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<P>, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<P>, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(P, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, P, Q, R, S, T, U, V, RET> RegisterNativeFunction<(P, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    P: Variant + Clone,
    S: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(P, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<Q>, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<Q>, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, Q, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<Q>, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<Q>, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Q, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, Q, R, S, T, U, V, RET> RegisterNativeFunction<(Q, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    Q: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(Q, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<R>, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<R>, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, R, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<R>, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, R, S, T, U, V, RET> RegisterNativeFunction<(Mut<R>, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, R, S, T, U, V, RET> RegisterNativeFunction<(R, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(R, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, R, S, T, U, V, RET> RegisterNativeFunction<(R, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    R: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(R, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, RET> RegisterNativeFunction<(NativeCallContext<'static>,), Result<RET, Box<EvalAltResult, Global>>> for FN where
    FN: 'static + for<'a> Fn(NativeCallContext<'a>) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, RET> RegisterNativeFunction<(NativeCallContext<'static>,), ()> for FN where
    FN: 'static + for<'a> Fn(NativeCallContext<'a>) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, RET> RegisterNativeFunction<(), Result<RET, Box<EvalAltResult, Global>>> for FN where
    FN: 'static + Fn() -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, RET> RegisterNativeFunction<(), ()> for FN where
    FN: 'static + Fn() -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<S>, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<S>, T, U, V), ()> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, S, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, S, T, U, V), ()> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, S, T, U, V, RET> RegisterNativeFunction<(Mut<S>, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, S, T, U, V, RET> RegisterNativeFunction<(Mut<S>, T, U, V), ()> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, S, T, U, V, RET> RegisterNativeFunction<(S, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(S, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, S, T, U, V, RET> RegisterNativeFunction<(S, T, U, V), ()> for FN where
    T: Variant + Clone,
    S: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(S, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<T>, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<T>, U, V), ()> for FN where
    T: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, T, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, T, U, V), ()> for FN where
    T: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, T, U, V, RET> RegisterNativeFunction<(Mut<T>, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, T, U, V, RET> RegisterNativeFunction<(Mut<T>, U, V), ()> for FN where
    T: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, T, U, V, RET> RegisterNativeFunction<(T, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    T: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(T, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, T, U, V, RET> RegisterNativeFunction<(T, U, V), ()> for FN where
    T: Variant + Clone,
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(T, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<U>, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<U>, V), ()> for FN where
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, U, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, U, V), ()> for FN where
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, U, V, RET> RegisterNativeFunction<(Mut<U>, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, U, V, RET> RegisterNativeFunction<(Mut<U>, V), ()> for FN where
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(&mut U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, U, V, RET> RegisterNativeFunction<(U, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(U, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, U, V, RET> RegisterNativeFunction<(U, V), ()> for FN where
    U: Variant + Clone,
    V: Variant + Clone,
    FN: 'static + Fn(U, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<V>), Result<RET, Box<EvalAltResult, Global>>> for FN where
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, Mut<V>), ()> for FN where
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, &mut V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, V), Result<RET, Box<EvalAltResult, Global>>> for FN where
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, V, RET> RegisterNativeFunction<(NativeCallContext<'static>, V), ()> for FN where
    V: Variant + Clone,
    FN: 'static + for<'a> Fn(NativeCallContext<'a>, V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, V, RET> RegisterNativeFunction<(Mut<V>,), Result<RET, Box<EvalAltResult, Global>>> for FN where
    V: Variant + Clone,
    FN: 'static + Fn(&mut V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, V, RET> RegisterNativeFunction<(Mut<V>,), ()> for FN where
    V: Variant + Clone,
    FN: 'static + Fn(&mut V) -> RET + SendSync,
    RET: Variant + Clone, [src]

impl<FN, V, RET> RegisterNativeFunction<(V,), Result<RET, Box<EvalAltResult, Global>>> for FN where
    V: Variant + Clone,
    FN: 'static + Fn(V) -> Result<RET, Box<EvalAltResult, Global>> + SendSync,
    RET: Variant + Clone, [src]

impl<FN, V, RET> RegisterNativeFunction<(V,), ()> for FN where
    V: Variant + Clone,
    FN: 'static + Fn(V) -> RET + SendSync,
    RET: Variant + Clone, [src]

Loading content...