Trait serde_closure::traits::Fn

pub trait Fn<Args>: FnMut<Args> {
    fn call(&self, args: Args) -> Self::Output;
}

Supertrait of std::ops::Fn that is usable on stable Rust. It is implemented by closures created by the Fn macro.

See the readme for examples.

Required methods

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

Performs the call operation.

Loading content...

Implementors

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, O> Fn<(A, B, C, D, E, F, G, H, I, J, K, L)> for T where
    T: Fn(A, B, C, D, E, F, G, H, I, J, K, L) -> O, 

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)
) -> Self::Output

impl<T, B, C, D, E, F, G, H, I, J, K, L, O> Fn<(B, C, D, E, F, G, H, I, J, K, L)> for T where
    T: Fn(B, C, D, E, F, G, H, I, J, K, L) -> O, 

fn call(
    &self,
    (B, C, D, E, F, G, H, I, J, K, L): (B, C, D, E, F, G, H, I, J, K, L)
) -> Self::Output

impl<T, C, D, E, F, G, H, I, J, K, L, O> Fn<(C, D, E, F, G, H, I, J, K, L)> for T where
    T: Fn(C, D, E, F, G, H, I, J, K, L) -> O, 

fn call(
    &self,
    (C, D, E, F, G, H, I, J, K, L): (C, D, E, F, G, H, I, J, K, L)
) -> Self::Output

impl<T, D, E, F, G, H, I, J, K, L, O> Fn<(D, E, F, G, H, I, J, K, L)> for T where
    T: Fn(D, E, F, G, H, I, J, K, L) -> O, 

fn call(
    &self,
    (D, E, F, G, H, I, J, K, L): (D, E, F, G, H, I, J, K, L)
) -> Self::Output

impl<T, E, F, G, H, I, J, K, L, O> Fn<(E, F, G, H, I, J, K, L)> for T where
    T: Fn(E, F, G, H, I, J, K, L) -> O, 

fn call(
    &self,
    (E, F, G, H, I, J, K, L): (E, F, G, H, I, J, K, L)
) -> Self::Output

impl<T, F, G, H, I, J, K, L, O> Fn<(F, G, H, I, J, K, L)> for T where
    T: Fn(F, G, H, I, J, K, L) -> O, 

fn call(&self, (F, G, H, I, J, K, L): (F, G, H, I, J, K, L)) -> Self::Output

impl<T, G, H, I, J, K, L, O> Fn<(G, H, I, J, K, L)> for T where
    T: Fn(G, H, I, J, K, L) -> O, 

fn call(&self, (G, H, I, J, K, L): (G, H, I, J, K, L)) -> Self::Output

impl<T, H, I, J, K, L, O> Fn<(H, I, J, K, L)> for T where
    T: Fn(H, I, J, K, L) -> O, 

fn call(&self, (H, I, J, K, L): (H, I, J, K, L)) -> Self::Output

impl<T, I, J, K, L, O> Fn<(I, J, K, L)> for T where
    T: Fn(I, J, K, L) -> O, 

fn call(&self, (I, J, K, L): (I, J, K, L)) -> Self::Output

impl<T, J, K, L, O> Fn<(J, K, L)> for T where
    T: Fn(J, K, L) -> O, 

fn call(&self, (J, K, L): (J, K, L)) -> Self::Output

impl<T, K, L, O> Fn<(K, L)> for T where
    T: Fn(K, L) -> O, 

fn call(&self, (K, L): (K, L)) -> Self::Output

impl<T, L, O> Fn<(L,)> for T where
    T: Fn(L) -> O, 

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

impl<T, O> Fn<()> for T where
    T: Fn() -> O, 

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

Loading content...