Trait serde_closure::traits::FnMut

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

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

See the readme for examples.

Required methods

fn call_mut(&mut 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> FnMut<(A, B, C, D, E, F, G, H, I, J, K, L)> for T where
    T: FnMut(A, B, C, D, E, F, G, H, I, J, K, L) -> O, 

fn call_mut(
    &mut 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> FnMut<(B, C, D, E, F, G, H, I, J, K, L)> for T where
    T: FnMut(B, C, D, E, F, G, H, I, J, K, L) -> O, 

fn call_mut(
    &mut 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> FnMut<(C, D, E, F, G, H, I, J, K, L)> for T where
    T: FnMut(C, D, E, F, G, H, I, J, K, L) -> O, 

fn call_mut(
    &mut 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> FnMut<(D, E, F, G, H, I, J, K, L)> for T where
    T: FnMut(D, E, F, G, H, I, J, K, L) -> O, 

fn call_mut(
    &mut 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> FnMut<(E, F, G, H, I, J, K, L)> for T where
    T: FnMut(E, F, G, H, I, J, K, L) -> O, 

fn call_mut(
    &mut 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> FnMut<(F, G, H, I, J, K, L)> for T where
    T: FnMut(F, G, H, I, J, K, L) -> O, 

fn call_mut(
    &mut 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> FnMut<(G, H, I, J, K, L)> for T where
    T: FnMut(G, H, I, J, K, L) -> O, 

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

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

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

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

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

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

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

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

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

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

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

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

fn call_mut(&mut self, (): ()) -> Self::Output

Loading content...