Trait tuple::Call

pub trait Call<T> {
    type Output;
    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"));

Associated Types

type Output

Loading content...

Required methods

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

Loading content...

Implementors

impl<Func, Out, A> Call<(A,)> for Func where
    Func: Fn(A) -> Out, 

type Output = Out

fn call(&self, (a): (A,)) -> Out

impl<Func, Out, A> Call<T1<A>> for Func where
    Func: Fn(A) -> Out, 

type Output = Out

fn call(&self, T1: T1<A>) -> Out

impl<Func, Out, A, B> Call<(A, B)> for Func where
    Func: Fn(A, B) -> Out, 

type Output = Out

fn call(&self, (a, b): (A, B)) -> Out

impl<Func, Out, A, B> Call<T2<A, B>> for Func where
    Func: Fn(A, B) -> Out, 

type Output = Out

fn call(&self, T2: T2<A, B>) -> Out

impl<Func, Out, A, B, C> Call<(A, B, C)> for Func where
    Func: Fn(A, B, C) -> Out, 

type Output = Out

fn call(&self, (a, b, c): (A, B, C)) -> Out

impl<Func, Out, A, B, C> Call<T3<A, B, C>> for Func where
    Func: Fn(A, B, C) -> Out, 

type Output = Out

fn call(&self, T3: T3<A, B, C>) -> 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

fn call(&self, (a, b, c, d): (A, B, C, D)) -> 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

fn call(&self, T4: T4<A, B, C, D>) -> 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

fn call(&self, (a, b, c, d, e): (A, B, C, D, E)) -> 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

fn call(&self, T5: T5<A, B, C, D, E>) -> 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

fn call(&self, (a, b, c, d, e, f): (A, B, C, D, E, F)) -> 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

fn call(&self, T6: T6<A, B, C, D, E, F>) -> 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

fn call(&self, (a, b, c, d, e, f, g): (A, B, C, D, E, F, G)) -> 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

fn call(&self, T7: T7<A, B, C, D, E, F, G>) -> 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

fn call(&self, (a, b, c, d, e, f, g, h): (A, B, C, D, E, F, G, H)) -> 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

fn call(&self, T8: T8<A, B, C, D, E, F, G, H>) -> 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

fn call(&self, (a, b, c, d, e, f, g, h, i): (A, B, C, D, E, F, G, H, I)) -> 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

fn call(&self, T9: T9<A, B, C, D, E, F, G, H, I>) -> 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

fn call(
    &self,
    (a, b, c, d, e, f, g, h, i, j): (A, B, C, D, E, F, G, H, I, J)
) -> 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

fn call(&self, T10: T10<A, B, C, D, E, F, G, H, I, J>) -> 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

fn call(
    &self,
    (a, b, c, d, e, f, g, h, i, j, k): (A, B, C, D, E, F, G, H, I, J, K)
) -> 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

fn call(&self, T11: T11<A, B, C, D, E, F, G, H, I, J, K>) -> 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

fn call(
    &self,
    (a, b, c, d, e, f, g, h, i, j, k, l): (A, B, C, D, E, F, G, H, I, J, K, L)
) -> 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

fn call(&self, T12: T12<A, B, C, D, E, F, G, H, I, J, K, L>) -> 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

fn call(
    &self,
    (a, b, c, d, e, f, g, h, i, j, k, l, m): (A, B, C, D, E, F, G, H, I, J, K, L, M)
) -> 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

fn call(&self, T13: T13<A, B, C, D, E, F, G, H, I, J, K, L, M>) -> 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

fn call(
    &self,
    (a, b, c, d, e, f, g, h, i, j, k, l, m, n): (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
) -> 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

fn call(&self, T14: T14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>) -> 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

fn call(
    &self,
    (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
) -> 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

fn call(&self, T15: T15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>) -> Out

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

fn call(
    &self,
    (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
) -> 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

fn call(&self, T16: T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>) -> Out

Loading content...