Trait lens_rs::traits::PrismMut

pub trait PrismMut<T: ?Sized>: PrismRef<T> + TraversalMut<T> {
    fn pm_mut<'a>(&self, source: &'a mut T) -> Option<&'a mut Self::To>;
}

Required methods

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

Loading content...

Implementors

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

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

impl<Pm> PrismMut<str> for _ix<Range<usize>, Pm> where
    Pm: PrismMut<str>, 

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

impl<Pm> PrismMut<str> for _ix<RangeFrom<usize>, Pm> where
    Pm: PrismMut<str>, 

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

impl<Pm> PrismMut<str> for _ix<RangeFull, Pm> where
    Pm: PrismMut<str>, 

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

impl<Pm> PrismMut<str> for _ix<RangeTo<usize>, Pm> where
    Pm: PrismMut<str>, 

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

impl<Pm> PrismMut<String> for _ix<Range<usize>, Pm> where
    Pm: PrismMut<str>, 

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

impl<Pm> PrismMut<String> for _ix<RangeFrom<usize>, Pm> where
    Pm: PrismMut<str>, 

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

impl<Pm> PrismMut<String> for _ix<RangeFull, Pm> where
    Pm: PrismMut<str>, 

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

impl<Pm> PrismMut<String> for _ix<RangeTo<usize>, Pm> where
    Pm: PrismMut<str>, 

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

impl<Pm, A> PrismMut<(A,)> for _0<Pm> where
    Pm: PrismMut<A>, 

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

impl<Pm, A> PrismMut<(A,)> for _both<Pm> where
    Pm: PrismMut<A>, 

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

impl<Pm, A, B> PrismMut<(A, B)> for _0<Pm> where
    Pm: PrismMut<A>, 

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

impl<Pm, A, B> PrismMut<(A, B)> for _1<Pm> where
    Pm: PrismMut<B>, 

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

impl<Pm, A, B, C> PrismMut<(A, B, C)> for _0<Pm> where
    Pm: PrismMut<A>, 

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

impl<Pm, A, B, C> PrismMut<(A, B, C)> for _1<Pm> where
    Pm: PrismMut<B>, 

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

impl<Pm, A, B, C> PrismMut<(A, B, C)> for _2<Pm> where
    Pm: PrismMut<C>, 

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

impl<Pm, A, B, C, D> PrismMut<(A, B, C, D)> for _0<Pm> where
    Pm: PrismMut<A>, 

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

impl<Pm, A, B, C, D> PrismMut<(A, B, C, D)> for _1<Pm> where
    Pm: PrismMut<B>, 

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

impl<Pm, A, B, C, D> PrismMut<(A, B, C, D)> for _2<Pm> where
    Pm: PrismMut<C>, 

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

impl<Pm, A, B, C, D> PrismMut<(A, B, C, D)> for _3<Pm> where
    Pm: PrismMut<D>, 

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

impl<Pm, A, B, C, D, E> PrismMut<(A, B, C, D, E)> for _0<Pm> where
    Pm: PrismMut<A>, 

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

impl<Pm, A, B, C, D, E> PrismMut<(A, B, C, D, E)> for _1<Pm> where
    Pm: PrismMut<B>, 

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

impl<Pm, A, B, C, D, E> PrismMut<(A, B, C, D, E)> for _2<Pm> where
    Pm: PrismMut<C>, 

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

impl<Pm, A, B, C, D, E> PrismMut<(A, B, C, D, E)> for _3<Pm> where
    Pm: PrismMut<D>, 

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

impl<Pm, A, B, C, D, E> PrismMut<(A, B, C, D, E)> for _4<Pm> where
    Pm: PrismMut<E>, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<Pm, T> PrismMut<Option<T>> for Some<Pm> where
    Pm: PrismMut<T>, 

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

impl<Pm, T, E> PrismMut<Result<T, E>> for Err<Pm> where
    Pm: PrismMut<E>, 

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

impl<Pm, T, E> PrismMut<Result<T, E>> for Ok<Pm> where
    Pm: PrismMut<T>, 

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

impl<T> PrismMut<T> for __

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

impl<T, Pm> PrismMut<[T]> for _ix<usize, Pm> where
    Pm: PrismMut<T>, 

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

impl<T, Pm> PrismMut<[T]> for _ix<Range<usize>, Pm> where
    Pm: PrismMut<[T]>, 

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

impl<T, Pm> PrismMut<[T]> for _ix<RangeFrom<usize>, Pm> where
    Pm: PrismMut<[T]>, 

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

impl<T, Pm> PrismMut<[T]> for _ix<RangeFull, Pm> where
    Pm: PrismMut<[T]>, 

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

impl<T, Pm> PrismMut<[T]> for _ix<RangeTo<usize>, Pm> where
    Pm: PrismMut<[T]>, 

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

impl<T, Pm> PrismMut<VecDeque<T>> for _ix<usize, Pm> where
    Pm: PrismMut<T>, 

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

impl<T, Pm> PrismMut<Vec<T, Global>> for _ix<usize, Pm> where
    Pm: PrismMut<T>, 

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

impl<T, Pm> PrismMut<Vec<T, Global>> for _ix<Range<usize>, Pm> where
    Pm: PrismMut<[T]>, 

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

impl<T, Pm> PrismMut<Vec<T, Global>> for _ix<RangeFrom<usize>, Pm> where
    Pm: PrismMut<[T]>, 

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

impl<T, Pm> PrismMut<Vec<T, Global>> for _ix<RangeFull, Pm> where
    Pm: PrismMut<[T]>, 

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

impl<T, Pm> PrismMut<Vec<T, Global>> for _ix<RangeTo<usize>, Pm> where
    Pm: PrismMut<[T]>, 

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

impl<T, Pm, const N: usize> PrismMut<[T; N]> for _ix<usize, Pm> where
    Pm: PrismMut<T>, 

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

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

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

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

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

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

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

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

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

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

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

Loading content...