Trait lens_rs::traits::TraversalMut

pub trait TraversalMut<T: ?Sized>: TraversalRef<T> {
    fn traverse_mut<'a>(&self, source: &'a mut T) -> Vec<&'a mut Self::To>;
}

Required methods

fn traverse_mut<'a>(&self, source: &'a mut T) -> Vec<&'a mut Self::To>

Loading content...

Implementors

impl<'t, T: ?Sized, Tr> TraversalMut<&'t mut T> for _mut<Tr> where
    Tr: TraversalMut<<&'t mut T as Deref>::Target>, 

fn traverse_mut<'a>(&self, source: &'a mut &'t mut T) -> Vec<&'a mut Self::To>

impl<T> TraversalMut<T> for __

fn traverse_mut<'a>(&self, source: &'a mut T) -> Vec<&'a mut Self::To>

impl<T, Tr> TraversalMut<[T]> for _ix<usize, Tr> where
    Tr: TraversalMut<T>, 

fn traverse_mut<'a>(&self, source: &'a mut [T]) -> Vec<&'a mut Self::To>

impl<T, Tr> TraversalMut<[T]> for _ix<Range<usize>, Tr> where
    Tr: TraversalMut<[T]>, 

fn traverse_mut<'a>(&self, source: &'a mut [T]) -> Vec<&'a mut Self::To>

impl<T, Tr> TraversalMut<[T]> for _ix<RangeFrom<usize>, Tr> where
    Tr: TraversalMut<[T]>, 

fn traverse_mut<'a>(&self, source: &'a mut [T]) -> Vec<&'a mut Self::To>

impl<T, Tr> TraversalMut<[T]> for _ix<RangeFull, Tr> where
    Tr: TraversalMut<[T]>, 

fn traverse_mut<'a>(&self, source: &'a mut [T]) -> Vec<&'a mut Self::To>

impl<T, Tr> TraversalMut<[T]> for _ix<RangeTo<usize>, Tr> where
    Tr: TraversalMut<[T]>, 

fn traverse_mut<'a>(&self, source: &'a mut [T]) -> Vec<&'a mut Self::To>

impl<T, Tr> TraversalMut<VecDeque<T>> for _ix<usize, Tr> where
    Tr: TraversalMut<T>, 

fn traverse_mut<'a>(&self, source: &'a mut VecDeque<T>) -> Vec<&'a mut Self::To>

impl<T, Tr> TraversalMut<Vec<T, Global>> for _ix<usize, Tr> where
    Tr: TraversalMut<T>, 

fn traverse_mut<'a>(&self, source: &'a mut Vec<T>) -> Vec<&'a mut Self::To>

impl<T, Tr> TraversalMut<Vec<T, Global>> for _ix<Range<usize>, Tr> where
    Tr: TraversalMut<[T]>, 

fn traverse_mut<'a>(&self, source: &'a mut Vec<T>) -> Vec<&'a mut Self::To>

impl<T, Tr> TraversalMut<Vec<T, Global>> for _ix<RangeFrom<usize>, Tr> where
    Tr: TraversalMut<[T]>, 

fn traverse_mut<'a>(&self, source: &'a mut Vec<T>) -> Vec<&'a mut Self::To>

impl<T, Tr> TraversalMut<Vec<T, Global>> for _ix<RangeFull, Tr> where
    Tr: TraversalMut<[T]>, 

fn traverse_mut<'a>(&self, source: &'a mut Vec<T>) -> Vec<&'a mut Self::To>

impl<T, Tr> TraversalMut<Vec<T, Global>> for _ix<RangeTo<usize>, Tr> where
    Tr: TraversalMut<[T]>, 

fn traverse_mut<'a>(&self, source: &'a mut Vec<T>) -> Vec<&'a mut Self::To>

impl<T, Tr, const N: usize> TraversalMut<[T; N]> for _ix<usize, Tr> where
    Tr: TraversalMut<T>, 

fn traverse_mut<'a>(&self, source: &'a mut [T; N]) -> Vec<&'a mut Self::To>

impl<T, Tr, const N: usize> TraversalMut<[T; N]> for _ix<Range<usize>, Tr> where
    Tr: TraversalMut<[T]>, 

fn traverse_mut<'a>(&self, source: &'a mut [T; N]) -> Vec<&'a mut Self::To>

impl<T, Tr, const N: usize> TraversalMut<[T; N]> for _ix<RangeFrom<usize>, Tr> where
    Tr: TraversalMut<[T]>, 

fn traverse_mut<'a>(&self, source: &'a mut [T; N]) -> Vec<&'a mut Self::To>

impl<T, Tr, const N: usize> TraversalMut<[T; N]> for _ix<RangeFull, Tr> where
    Tr: TraversalMut<[T]>, 

fn traverse_mut<'a>(&self, source: &'a mut [T; N]) -> Vec<&'a mut Self::To>

impl<T, Tr, const N: usize> TraversalMut<[T; N]> for _ix<RangeTo<usize>, Tr> where
    Tr: TraversalMut<[T]>, 

fn traverse_mut<'a>(&self, source: &'a mut [T; N]) -> Vec<&'a mut Self::To>

impl<T: ?Sized, Tr> TraversalMut<Box<T, Global>> for _box<Tr> where
    Tr: TraversalMut<<Box<T> as Deref>::Target>, 

fn traverse_mut<'a>(&self, source: &'a mut Box<T>) -> Vec<&'a mut Self::To>

impl<Tr> TraversalMut<str> for _ix<Range<usize>, Tr> where
    Tr: TraversalMut<str>, 

fn traverse_mut<'a>(&self, source: &'a mut str) -> Vec<&'a mut Self::To>

impl<Tr> TraversalMut<str> for _ix<RangeFrom<usize>, Tr> where
    Tr: TraversalMut<str>, 

fn traverse_mut<'a>(&self, source: &'a mut str) -> Vec<&'a mut Self::To>

impl<Tr> TraversalMut<str> for _ix<RangeFull, Tr> where
    Tr: TraversalMut<str>, 

fn traverse_mut<'a>(&self, source: &'a mut str) -> Vec<&'a mut Self::To>

impl<Tr> TraversalMut<str> for _ix<RangeTo<usize>, Tr> where
    Tr: TraversalMut<str>, 

fn traverse_mut<'a>(&self, source: &'a mut str) -> Vec<&'a mut Self::To>

impl<Tr> TraversalMut<String> for _ix<Range<usize>, Tr> where
    Tr: TraversalMut<str>, 

fn traverse_mut<'a>(&self, source: &'a mut String) -> Vec<&'a mut Self::To>

impl<Tr> TraversalMut<String> for _ix<RangeFrom<usize>, Tr> where
    Tr: TraversalMut<str>, 

fn traverse_mut<'a>(&self, source: &'a mut String) -> Vec<&'a mut Self::To>

impl<Tr> TraversalMut<String> for _ix<RangeFull, Tr> where
    Tr: TraversalMut<str>, 

fn traverse_mut<'a>(&self, source: &'a mut String) -> Vec<&'a mut Self::To>

impl<Tr> TraversalMut<String> for _ix<RangeTo<usize>, Tr> where
    Tr: TraversalMut<str>, 

fn traverse_mut<'a>(&self, source: &'a mut String) -> Vec<&'a mut Self::To>

impl<Tr, A> TraversalMut<(A, A, A, A, A, A, A)> for _both<Tr> where
    Tr: TraversalMut<A>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, A, A, A, A, A, A)
) -> Vec<&'a mut Self::To>

impl<Tr, A> TraversalMut<(A, A, A, A, A, A)> for _both<Tr> where
    Tr: TraversalMut<A>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, A, A, A, A, A)
) -> Vec<&'a mut Self::To>

impl<Tr, A> TraversalMut<(A, A, A, A, A)> for _both<Tr> where
    Tr: TraversalMut<A>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, A, A, A, A)
) -> Vec<&'a mut Self::To>

impl<Tr, A> TraversalMut<(A, A, A, A)> for _both<Tr> where
    Tr: TraversalMut<A>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, A, A, A)
) -> Vec<&'a mut Self::To>

impl<Tr, A> TraversalMut<(A, A, A)> for _both<Tr> where
    Tr: TraversalMut<A>, 

fn traverse_mut<'a>(&self, source: &'a mut (A, A, A)) -> Vec<&'a mut Self::To>

impl<Tr, A> TraversalMut<(A, A)> for _both<Tr> where
    Tr: TraversalMut<A>, 

fn traverse_mut<'a>(&self, source: &'a mut (A, A)) -> Vec<&'a mut Self::To>

impl<Tr, A> TraversalMut<(A,)> for _0<Tr> where
    Tr: TraversalMut<A>, 

fn traverse_mut<'a>(&self, source: &'a mut (A,)) -> Vec<&'a mut Self::To>

impl<Tr, A> TraversalMut<(A,)> for _both<Tr> where
    Tr: TraversalMut<A>, 

fn traverse_mut<'a>(&self, source: &'a mut (A,)) -> Vec<&'a mut Self::To>

impl<Tr, A, B> TraversalMut<(A, B)> for _0<Tr> where
    Tr: TraversalMut<A>, 

fn traverse_mut<'a>(&self, source: &'a mut (A, B)) -> Vec<&'a mut Self::To>

impl<Tr, A, B> TraversalMut<(A, B)> for _1<Tr> where
    Tr: TraversalMut<B>, 

fn traverse_mut<'a>(&self, source: &'a mut (A, B)) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C> TraversalMut<(A, B, C)> for _0<Tr> where
    Tr: TraversalMut<A>, 

fn traverse_mut<'a>(&self, source: &'a mut (A, B, C)) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C> TraversalMut<(A, B, C)> for _1<Tr> where
    Tr: TraversalMut<B>, 

fn traverse_mut<'a>(&self, source: &'a mut (A, B, C)) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C> TraversalMut<(A, B, C)> for _2<Tr> where
    Tr: TraversalMut<C>, 

fn traverse_mut<'a>(&self, source: &'a mut (A, B, C)) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D> TraversalMut<(A, B, C, D)> for _0<Tr> where
    Tr: TraversalMut<A>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D> TraversalMut<(A, B, C, D)> for _1<Tr> where
    Tr: TraversalMut<B>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D> TraversalMut<(A, B, C, D)> for _2<Tr> where
    Tr: TraversalMut<C>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D> TraversalMut<(A, B, C, D)> for _3<Tr> where
    Tr: TraversalMut<D>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D, E> TraversalMut<(A, B, C, D, E)> for _0<Tr> where
    Tr: TraversalMut<A>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D, E)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D, E> TraversalMut<(A, B, C, D, E)> for _1<Tr> where
    Tr: TraversalMut<B>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D, E)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D, E> TraversalMut<(A, B, C, D, E)> for _2<Tr> where
    Tr: TraversalMut<C>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D, E)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D, E> TraversalMut<(A, B, C, D, E)> for _3<Tr> where
    Tr: TraversalMut<D>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D, E)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D, E> TraversalMut<(A, B, C, D, E)> for _4<Tr> where
    Tr: TraversalMut<E>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D, E)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D, E, F> TraversalMut<(A, B, C, D, E, F)> for _0<Tr> where
    Tr: TraversalMut<A>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D, E, F)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D, E, F> TraversalMut<(A, B, C, D, E, F)> for _1<Tr> where
    Tr: TraversalMut<B>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D, E, F)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D, E, F> TraversalMut<(A, B, C, D, E, F)> for _2<Tr> where
    Tr: TraversalMut<C>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D, E, F)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D, E, F> TraversalMut<(A, B, C, D, E, F)> for _3<Tr> where
    Tr: TraversalMut<D>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D, E, F)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D, E, F> TraversalMut<(A, B, C, D, E, F)> for _4<Tr> where
    Tr: TraversalMut<E>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D, E, F)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D, E, F> TraversalMut<(A, B, C, D, E, F)> for _5<Tr> where
    Tr: TraversalMut<F>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D, E, F)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D, E, F, G> TraversalMut<(A, B, C, D, E, F, G)> for _0<Tr> where
    Tr: TraversalMut<A>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D, E, F, G)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D, E, F, G> TraversalMut<(A, B, C, D, E, F, G)> for _1<Tr> where
    Tr: TraversalMut<B>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D, E, F, G)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D, E, F, G> TraversalMut<(A, B, C, D, E, F, G)> for _2<Tr> where
    Tr: TraversalMut<C>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D, E, F, G)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D, E, F, G> TraversalMut<(A, B, C, D, E, F, G)> for _3<Tr> where
    Tr: TraversalMut<D>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D, E, F, G)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D, E, F, G> TraversalMut<(A, B, C, D, E, F, G)> for _4<Tr> where
    Tr: TraversalMut<E>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D, E, F, G)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D, E, F, G> TraversalMut<(A, B, C, D, E, F, G)> for _5<Tr> where
    Tr: TraversalMut<F>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D, E, F, G)
) -> Vec<&'a mut Self::To>

impl<Tr, A, B, C, D, E, F, G> TraversalMut<(A, B, C, D, E, F, G)> for _6<Tr> where
    Tr: TraversalMut<G>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut (A, B, C, D, E, F, G)
) -> Vec<&'a mut Self::To>

impl<Tr, T> TraversalMut<Option<T>> for Some<Tr> where
    Tr: TraversalMut<T>, 

fn traverse_mut<'a>(&self, source: &'a mut Option<T>) -> Vec<&'a mut Self::To>

impl<Tr, T> TraversalMut<LinkedList<T>> for _mapped<Tr> where
    Tr: TraversalMut<T>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut LinkedList<T>
) -> Vec<&'a mut Self::To>

impl<Tr, T> TraversalMut<VecDeque<T>> for _mapped<Tr> where
    Tr: TraversalMut<T>, 

fn traverse_mut<'a>(&self, source: &'a mut VecDeque<T>) -> Vec<&'a mut Self::To>

impl<Tr, T> TraversalMut<Vec<T, Global>> for _mapped<Tr> where
    Tr: TraversalMut<T>, 

fn traverse_mut<'a>(&self, source: &'a mut Vec<T>) -> Vec<&'a mut Self::To>

impl<Tr, T, E> TraversalMut<Result<T, E>> for Err<Tr> where
    Tr: TraversalMut<E>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut Result<T, E>
) -> Vec<&'a mut Self::To>

impl<Tr, T, E> TraversalMut<Result<T, E>> for Ok<Tr> where
    Tr: TraversalMut<T>, 

fn traverse_mut<'a>(
    &self,
    source: &'a mut Result<T, E>
) -> Vec<&'a mut Self::To>

Loading content...