Trait rhai::RegisterNativeFunction[−][src]

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

    fn param_types() -> Box<[TypeId]>;

    fn param_names() -> Box<[&'static str]>;

    fn return_type() -> TypeId;

    fn return_type_name() -> &'static str;
}

Trait to register custom Rust functions.

Required methods

fn into_callable_function(self) -> CallableFunction[src]

Convert this function into a CallableFunction.

fn param_types() -> Box<[TypeId]>[src]

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

fn param_names() -> Box<[&'static str]>[src]

Get the type names of this function’s parameters. Exported under the metadata feature only.

fn return_type() -> TypeId[src]

Get the type ID of this function’s return value. Exported under the metadata feature only.

fn return_type_name() -> &'static str[src]

Get the type name of this function’s return value. Exported under the metadata feature only.

Loading content...

Implementors

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

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

impl<FN: 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>> + SendSync + 'static, A: Variant + Clone, B: Variant + Clone, C: 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, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> 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[src]

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

impl<FN: 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>> + SendSync + 'static, B: Variant + Clone, C: 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, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> 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[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<FN: 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>> + SendSync + 'static, A: Variant + Clone, B: Variant + Clone, C: 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, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> 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[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<FN: 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>> + SendSync + 'static, A: Variant + Clone, B: Variant + Clone, C: 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, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> 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[src]

impl<FN: 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 + 'static, A: Variant + Clone, B: Variant + Clone, C: 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, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> 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[src]

impl<FN: 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>> + SendSync + 'static, B: Variant + Clone, C: 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, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> 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[src]

impl<FN: 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 + 'static, B: Variant + Clone, C: 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, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> 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[src]

impl<FN: 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>> + SendSync + 'static, C: 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, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> 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[src]

impl<FN: 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 + 'static, C: 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, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> RegisterNativeFunction<(NativeCallContext<'static>, Mut<C>, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN[src]

impl<FN: 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>> + SendSync + 'static, 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, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> 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[src]

impl<FN: 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 + 'static, 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, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> RegisterNativeFunction<(NativeCallContext<'static>, Mut<D>, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), ()> for FN[src]

impl<FN: 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>> + SendSync + 'static, 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, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> 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[src]

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

impl<FN: 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>> + SendSync + 'static, F: Variant + Clone, G: Variant + Clone, H: Variant + Clone, J: Variant + Clone, K: Variant + Clone, L: Variant + Clone, M: Variant + Clone, N: Variant + Clone, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> 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[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<FN: 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>> + SendSync + 'static, A: Variant + Clone, B: Variant + Clone, C: 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, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> 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[src]

impl<FN: 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 + 'static, A: Variant + Clone, B: Variant + Clone, C: 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, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> 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[src]

impl<FN: 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>> + SendSync + 'static, B: Variant + Clone, C: 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, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> 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[src]

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

impl<FN: 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>> + SendSync + 'static, C: 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, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> 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[src]

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

impl<FN: 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>> + SendSync + 'static, 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, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> 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[src]

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

impl<FN: 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>> + SendSync + 'static, 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, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> 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[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Loading content...