Trait tooples::CanApplyMut

pub trait CanApplyMut<F>: CanApplyOnce<F> {
    fn apply_to_mut(self, f: &mut F) -> Self::Output;
}

Required Methods

fn apply_to_mut(self, f: &mut F) -> Self::Output

Implementations on Foreign Types

impl<Fun, Z> CanApplyMut<Fun> for () where     Fun: FnMut() -> Z,

fn apply_to_mut(self, f: &mut Fun) -> Self::Output

impl<Fun, Z, A> CanApplyMut<Fun> for (A,) where     Fun: FnMut(A) -> Z,

fn apply_to_mut(self, f: &mut Fun) -> Self::Output

impl<Fun, Z, A, B> CanApplyMut<Fun> for (A, B) where     Fun: FnMut(A, B) -> Z,

fn apply_to_mut(self, f: &mut Fun) -> Self::Output

impl<Fun, Z, A, B, C> CanApplyMut<Fun> for (A, B, C) where     Fun: FnMut(A, B, C) -> Z,

fn apply_to_mut(self, f: &mut Fun) -> Self::Output

impl<Fun, Z, A, B, C, D> CanApplyMut<Fun> for (A, B, C, D) where     Fun: FnMut(A, B, C, D) -> Z,

fn apply_to_mut(self, f: &mut Fun) -> Self::Output

impl<Fun, Z, A, B, C, D, E> CanApplyMut<Fun> for (A, B, C, D, E) where     Fun: FnMut(A, B, C, D, E) -> Z,

fn apply_to_mut(self, f: &mut Fun) -> Self::Output

impl<Fun, Z, A, B, C, D, E, F> CanApplyMut<Fun> for (A, B, C, D, E, F) where     Fun: FnMut(A, B, C, D, E, F) -> Z,

fn apply_to_mut(self, f: &mut Fun) -> Self::Output

impl<Fun, Z, A, B, C, D, E, F, G> CanApplyMut<Fun> for (A, B, C, D, E, F, G) where     Fun: FnMut(A, B, C, D, E, F, G) -> Z,

fn apply_to_mut(self, f: &mut Fun) -> Self::Output

impl<Fun, Z, A, B, C, D, E, F, G, H> CanApplyMut<Fun> for (A, B, C, D, E, F, G, H) where     Fun: FnMut(A, B, C, D, E, F, G, H) -> Z,

fn apply_to_mut(self, f: &mut Fun) -> Self::Output

impl<Fun, Z, A, B, C, D, E, F, G, H, I> CanApplyMut<Fun> for (A, B, C, D, E, F, G, H, I) where     Fun: FnMut(A, B, C, D, E, F, G, H, I) -> Z,

fn apply_to_mut(self, f: &mut Fun) -> Self::Output

impl<Fun, Z, A, B, C, D, E, F, G, H, I, J> CanApplyMut<Fun> for (A, B, C, D, E, F, G, H, I, J) where     Fun: FnMut(A, B, C, D, E, F, G, H, I, J) -> Z,

fn apply_to_mut(self, f: &mut Fun) -> Self::Output

impl<Fun, Z, A, B, C, D, E, F, G, H, I, J, K> CanApplyMut<Fun> for (A, B, C, D, E, F, G, H, I, J, K) where     Fun: FnMut(A, B, C, D, E, F, G, H, I, J, K) -> Z,

fn apply_to_mut(self, f: &mut Fun) -> Self::Output

impl<Fun, Z, A, B, C, D, E, F, G, H, I, J, K, L> CanApplyMut<Fun> for (A, B, C, D, E, F, G, H, I, J, K, L) where     Fun: FnMut(A, B, C, D, E, F, G, H, I, J, K, L) -> Z,

fn apply_to_mut(self, f: &mut Fun) -> Self::Output

Implementors