Trait lens_rs::traits::LensMut

pub trait LensMut<T: ?Sized>: LensRef<T> + PrismMut<T> {
    fn view_mut<'a>(&self, source: &'a mut T) -> &'a mut Self::To;
}

Required methods

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

Loading content...

Implementors

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

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

impl<Ls> LensMut<str> for _ix<Range<usize>, Ls> where
    Ls: LensMut<str>, 

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

impl<Ls> LensMut<str> for _ix<RangeFrom<usize>, Ls> where
    Ls: LensMut<str>, 

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

impl<Ls> LensMut<str> for _ix<RangeFull, Ls> where
    Ls: LensMut<str>, 

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

impl<Ls> LensMut<str> for _ix<RangeTo<usize>, Ls> where
    Ls: LensMut<str>, 

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

impl<Ls> LensMut<String> for _ix<Range<usize>, Ls> where
    Ls: LensMut<str>, 

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

impl<Ls> LensMut<String> for _ix<RangeFrom<usize>, Ls> where
    Ls: LensMut<str>, 

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

impl<Ls> LensMut<String> for _ix<RangeFull, Ls> where
    Ls: LensMut<str>, 

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

impl<Ls> LensMut<String> for _ix<RangeTo<usize>, Ls> where
    Ls: LensMut<str>, 

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

impl<Ls, A> LensMut<(A,)> for _0<Ls> where
    Ls: LensMut<A>, 

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

impl<Ls, A> LensMut<(A,)> for _both<Ls> where
    Ls: LensMut<A>, 

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

impl<Ls, A, B> LensMut<(A, B)> for _0<Ls> where
    Ls: LensMut<A>, 

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

impl<Ls, A, B> LensMut<(A, B)> for _1<Ls> where
    Ls: LensMut<B>, 

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

impl<Ls, A, B, C> LensMut<(A, B, C)> for _0<Ls> where
    Ls: LensMut<A>, 

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

impl<Ls, A, B, C> LensMut<(A, B, C)> for _1<Ls> where
    Ls: LensMut<B>, 

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

impl<Ls, A, B, C> LensMut<(A, B, C)> for _2<Ls> where
    Ls: LensMut<C>, 

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

impl<Ls, A, B, C, D> LensMut<(A, B, C, D)> for _0<Ls> where
    Ls: LensMut<A>, 

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

impl<Ls, A, B, C, D> LensMut<(A, B, C, D)> for _1<Ls> where
    Ls: LensMut<B>, 

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

impl<Ls, A, B, C, D> LensMut<(A, B, C, D)> for _2<Ls> where
    Ls: LensMut<C>, 

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

impl<Ls, A, B, C, D> LensMut<(A, B, C, D)> for _3<Ls> where
    Ls: LensMut<D>, 

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

impl<Ls, A, B, C, D, E> LensMut<(A, B, C, D, E)> for _0<Ls> where
    Ls: LensMut<A>, 

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

impl<Ls, A, B, C, D, E> LensMut<(A, B, C, D, E)> for _1<Ls> where
    Ls: LensMut<B>, 

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

impl<Ls, A, B, C, D, E> LensMut<(A, B, C, D, E)> for _2<Ls> where
    Ls: LensMut<C>, 

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

impl<Ls, A, B, C, D, E> LensMut<(A, B, C, D, E)> for _3<Ls> where
    Ls: LensMut<D>, 

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

impl<Ls, A, B, C, D, E> LensMut<(A, B, C, D, E)> for _4<Ls> where
    Ls: LensMut<E>, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<T> LensMut<T> for __

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

impl<T, Ls> LensMut<[T]> for _ix<usize, Ls> where
    Ls: LensMut<T>, 

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

impl<T, Ls> LensMut<[T]> for _ix<Range<usize>, Ls> where
    Ls: LensMut<[T]>, 

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

impl<T, Ls> LensMut<[T]> for _ix<RangeFrom<usize>, Ls> where
    Ls: LensMut<[T]>, 

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

impl<T, Ls> LensMut<[T]> for _ix<RangeFull, Ls> where
    Ls: LensMut<[T]>, 

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

impl<T, Ls> LensMut<[T]> for _ix<RangeTo<usize>, Ls> where
    Ls: LensMut<[T]>, 

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

impl<T, Ls> LensMut<VecDeque<T>> for _ix<usize, Ls> where
    Ls: LensMut<T>, 

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

impl<T, Ls> LensMut<Vec<T, Global>> for _ix<usize, Ls> where
    Ls: LensMut<T>, 

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

impl<T, Ls> LensMut<Vec<T, Global>> for _ix<Range<usize>, Ls> where
    Ls: LensMut<[T]>, 

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

impl<T, Ls> LensMut<Vec<T, Global>> for _ix<RangeFrom<usize>, Ls> where
    Ls: LensMut<[T]>, 

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

impl<T, Ls> LensMut<Vec<T, Global>> for _ix<RangeFull, Ls> where
    Ls: LensMut<[T]>, 

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

impl<T, Ls> LensMut<Vec<T, Global>> for _ix<RangeTo<usize>, Ls> where
    Ls: LensMut<[T]>, 

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

impl<T, Ls, const N: usize> LensMut<[T; N]> for _ix<usize, Ls> where
    Ls: LensMut<T>, 

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

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

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

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

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

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

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

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

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

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

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

Loading content...