Trait Call 

pub trait Call<T> {
    type Output;

    // Required method
    fn call(&self, args: T) -> Self::Output;
}

Call a Fn and unpack the arguments.

    fn foo(a: u32, b: &str) { }
    foo.call((1, "hi"));
    foo.call(T2(1, "hi"));

Required Associated Types

type Output

Required Methods

fn call(&self, args: T) -> Self::Output

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<Func, Out, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Call<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)> for Func

where Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Call<T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>> for Func

where Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Call<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)> for Func

where Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Call<T15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>> for Func

where Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F, G, H, I, J, K, L, M, N> Call<(A, B, C, D, E, F, G, H, I, J, K, L, M, N)> for Func

where Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F, G, H, I, J, K, L, M, N> Call<T14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>> for Func

where Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F, G, H, I, J, K, L, M> Call<(A, B, C, D, E, F, G, H, I, J, K, L, M)> for Func

where Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F, G, H, I, J, K, L, M> Call<T13<A, B, C, D, E, F, G, H, I, J, K, L, M>> for Func

where Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F, G, H, I, J, K, L> Call<(A, B, C, D, E, F, G, H, I, J, K, L)> for Func

where Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F, G, H, I, J, K, L> Call<T12<A, B, C, D, E, F, G, H, I, J, K, L>> for Func

where Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F, G, H, I, J, K> Call<(A, B, C, D, E, F, G, H, I, J, K)> for Func

where Func: Fn(A, B, C, D, E, F, G, H, I, J, K) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F, G, H, I, J, K> Call<T11<A, B, C, D, E, F, G, H, I, J, K>> for Func

where Func: Fn(A, B, C, D, E, F, G, H, I, J, K) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F, G, H, I, J> Call<(A, B, C, D, E, F, G, H, I, J)> for Func

where Func: Fn(A, B, C, D, E, F, G, H, I, J) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F, G, H, I, J> Call<T10<A, B, C, D, E, F, G, H, I, J>> for Func

where Func: Fn(A, B, C, D, E, F, G, H, I, J) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F, G, H, I> Call<(A, B, C, D, E, F, G, H, I)> for Func

where Func: Fn(A, B, C, D, E, F, G, H, I) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F, G, H, I> Call<T9<A, B, C, D, E, F, G, H, I>> for Func

where Func: Fn(A, B, C, D, E, F, G, H, I) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F, G, H> Call<(A, B, C, D, E, F, G, H)> for Func

where Func: Fn(A, B, C, D, E, F, G, H) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F, G, H> Call<T8<A, B, C, D, E, F, G, H>> for Func

where Func: Fn(A, B, C, D, E, F, G, H) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F, G> Call<(A, B, C, D, E, F, G)> for Func

where Func: Fn(A, B, C, D, E, F, G) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F, G> Call<T7<A, B, C, D, E, F, G>> for Func

where Func: Fn(A, B, C, D, E, F, G) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F> Call<(A, B, C, D, E, F)> for Func

where Func: Fn(A, B, C, D, E, F) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E, F> Call<T6<A, B, C, D, E, F>> for Func

where Func: Fn(A, B, C, D, E, F) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E> Call<(A, B, C, D, E)> for Func

where Func: Fn(A, B, C, D, E) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D, E> Call<T5<A, B, C, D, E>> for Func

where Func: Fn(A, B, C, D, E) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D> Call<(A, B, C, D)> for Func

where Func: Fn(A, B, C, D) -> Out,

type Output = Out

impl<Func, Out, A, B, C, D> Call<T4<A, B, C, D>> for Func

where Func: Fn(A, B, C, D) -> Out,

type Output = Out

impl<Func, Out, A, B, C> Call<(A, B, C)> for Func

where Func: Fn(A, B, C) -> Out,

type Output = Out

impl<Func, Out, A, B, C> Call<T3<A, B, C>> for Func

where Func: Fn(A, B, C) -> Out,

type Output = Out

impl<Func, Out, A, B> Call<(A, B)> for Func

where Func: Fn(A, B) -> Out,

type Output = Out

impl<Func, Out, A, B> Call<T2<A, B>> for Func

where Func: Fn(A, B) -> Out,

type Output = Out

impl<Func, Out, A> Call<(A,)> for Func

where Func: Fn(A) -> Out,

type Output = Out

impl<Func, Out, A> Call<T1<A>> for Func

where Func: Fn(A) -> Out,

type Output = Out