Trait lens_rs::traits::prism::PrismMut

pub trait PrismMut<Optics, Image: ?Sized>: PrismRef<Optics, Image> + TraversalMut<Optics, Image> {
    fn preview_mut(&mut self, optics: Optics) -> Option<&mut Image>;
}

the mutable version of Prism

Required methods

fn preview_mut(&mut self, optics: Optics) -> Option<&mut Image>

Loading content...

Implementations on Foreign Types

impl<__Image, __Pm, A> PrismMut<_0<__Pm>, __Image> for (A,) where
    __Image: ?Sized,
    A: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _0<__Pm>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<Ok<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Ok<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<Err<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Err<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<Some<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Some<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<None<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: None<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<_1<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _1<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<_2<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _2<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<_3<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _3<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<_4<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _4<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<_5<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _5<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<_6<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _6<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<_7<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _7<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<_8<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _8<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<_9<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _9<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<_10<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _10<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<_11<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _11<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<_12<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _12<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<_13<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _13<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<_14<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _14<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<_15<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _15<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A> PrismMut<_16<__Opt>, __Image> for (A,) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _16<__Opt>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B> PrismMut<_0<__Pm>, __Image> for (A, B) where
    __Image: ?Sized,
    A: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _0<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B> PrismMut<_1<__Pm>, __Image> for (A, B) where
    __Image: ?Sized,
    B: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _1<__Pm>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B> PrismMut<Ok<__Opt>, __Image> for (A, B) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Ok<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B> PrismMut<Err<__Opt>, __Image> for (A, B) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Err<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B> PrismMut<Some<__Opt>, __Image> for (A, B) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Some<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B> PrismMut<None<__Opt>, __Image> for (A, B) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: None<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B> PrismMut<_2<__Opt>, __Image> for (A, B) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _2<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B> PrismMut<_3<__Opt>, __Image> for (A, B) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _3<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B> PrismMut<_4<__Opt>, __Image> for (A, B) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _4<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B> PrismMut<_5<__Opt>, __Image> for (A, B) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _5<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B> PrismMut<_6<__Opt>, __Image> for (A, B) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _6<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B> PrismMut<_7<__Opt>, __Image> for (A, B) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _7<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B> PrismMut<_8<__Opt>, __Image> for (A, B) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _8<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B> PrismMut<_9<__Opt>, __Image> for (A, B) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _9<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B> PrismMut<_10<__Opt>, __Image> for (A, B) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _10<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B> PrismMut<_11<__Opt>, __Image> for (A, B) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _11<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B> PrismMut<_12<__Opt>, __Image> for (A, B) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _12<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B> PrismMut<_13<__Opt>, __Image> for (A, B) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _13<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B> PrismMut<_14<__Opt>, __Image> for (A, B) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _14<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B> PrismMut<_15<__Opt>, __Image> for (A, B) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _15<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B> PrismMut<_16<__Opt>, __Image> for (A, B) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _16<__Opt>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C> PrismMut<_0<__Pm>, __Image> for (A, B, C) where
    __Image: ?Sized,
    A: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _0<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C> PrismMut<_1<__Pm>, __Image> for (A, B, C) where
    __Image: ?Sized,
    B: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _1<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C> PrismMut<_2<__Pm>, __Image> for (A, B, C) where
    __Image: ?Sized,
    C: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _2<__Pm>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C> PrismMut<Ok<__Opt>, __Image> for (A, B, C) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Ok<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C> PrismMut<Err<__Opt>, __Image> for (A, B, C) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Err<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C> PrismMut<Some<__Opt>, __Image> for (A, B, C) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Some<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C> PrismMut<None<__Opt>, __Image> for (A, B, C) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: None<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C> PrismMut<_3<__Opt>, __Image> for (A, B, C) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _3<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C> PrismMut<_4<__Opt>, __Image> for (A, B, C) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _4<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C> PrismMut<_5<__Opt>, __Image> for (A, B, C) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _5<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C> PrismMut<_6<__Opt>, __Image> for (A, B, C) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _6<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C> PrismMut<_7<__Opt>, __Image> for (A, B, C) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _7<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C> PrismMut<_8<__Opt>, __Image> for (A, B, C) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _8<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C> PrismMut<_9<__Opt>, __Image> for (A, B, C) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _9<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C> PrismMut<_10<__Opt>, __Image> for (A, B, C) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _10<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C> PrismMut<_11<__Opt>, __Image> for (A, B, C) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _11<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C> PrismMut<_12<__Opt>, __Image> for (A, B, C) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _12<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C> PrismMut<_13<__Opt>, __Image> for (A, B, C) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _13<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C> PrismMut<_14<__Opt>, __Image> for (A, B, C) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _14<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C> PrismMut<_15<__Opt>, __Image> for (A, B, C) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _15<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C> PrismMut<_16<__Opt>, __Image> for (A, B, C) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _16<__Opt>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D> PrismMut<_0<__Pm>, __Image> for (A, B, C, D) where
    __Image: ?Sized,
    A: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _0<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D> PrismMut<_1<__Pm>, __Image> for (A, B, C, D) where
    __Image: ?Sized,
    B: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _1<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D> PrismMut<_2<__Pm>, __Image> for (A, B, C, D) where
    __Image: ?Sized,
    C: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _2<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D> PrismMut<_3<__Pm>, __Image> for (A, B, C, D) where
    __Image: ?Sized,
    D: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _3<__Pm>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D> PrismMut<Ok<__Opt>, __Image> for (A, B, C, D) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Ok<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D> PrismMut<Err<__Opt>, __Image> for (A, B, C, D) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Err<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D> PrismMut<Some<__Opt>, __Image> for (A, B, C, D) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Some<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D> PrismMut<None<__Opt>, __Image> for (A, B, C, D) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: None<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D> PrismMut<_4<__Opt>, __Image> for (A, B, C, D) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _4<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D> PrismMut<_5<__Opt>, __Image> for (A, B, C, D) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _5<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D> PrismMut<_6<__Opt>, __Image> for (A, B, C, D) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _6<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D> PrismMut<_7<__Opt>, __Image> for (A, B, C, D) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _7<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D> PrismMut<_8<__Opt>, __Image> for (A, B, C, D) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _8<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D> PrismMut<_9<__Opt>, __Image> for (A, B, C, D) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _9<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D> PrismMut<_10<__Opt>, __Image> for (A, B, C, D) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _10<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D> PrismMut<_11<__Opt>, __Image> for (A, B, C, D) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _11<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D> PrismMut<_12<__Opt>, __Image> for (A, B, C, D) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _12<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D> PrismMut<_13<__Opt>, __Image> for (A, B, C, D) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _13<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D> PrismMut<_14<__Opt>, __Image> for (A, B, C, D) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _14<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D> PrismMut<_15<__Opt>, __Image> for (A, B, C, D) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _15<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D> PrismMut<_16<__Opt>, __Image> for (A, B, C, D) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _16<__Opt>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E> PrismMut<_0<__Pm>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized,
    A: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _0<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E> PrismMut<_1<__Pm>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized,
    B: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _1<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E> PrismMut<_2<__Pm>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized,
    C: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _2<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E> PrismMut<_3<__Pm>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized,
    D: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _3<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E> PrismMut<_4<__Pm>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized,
    E: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _4<__Pm>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E> PrismMut<Ok<__Opt>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Ok<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E> PrismMut<Err<__Opt>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Err<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E> PrismMut<Some<__Opt>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Some<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E> PrismMut<None<__Opt>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: None<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E> PrismMut<_5<__Opt>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _5<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E> PrismMut<_6<__Opt>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _6<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E> PrismMut<_7<__Opt>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _7<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E> PrismMut<_8<__Opt>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _8<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E> PrismMut<_9<__Opt>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _9<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E> PrismMut<_10<__Opt>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _10<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E> PrismMut<_11<__Opt>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _11<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E> PrismMut<_12<__Opt>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _12<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E> PrismMut<_13<__Opt>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _13<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E> PrismMut<_14<__Opt>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _14<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E> PrismMut<_15<__Opt>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _15<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E> PrismMut<_16<__Opt>, __Image> for (A, B, C, D, E) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _16<__Opt>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F> PrismMut<_0<__Pm>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized,
    A: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _0<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F> PrismMut<_1<__Pm>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized,
    B: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _1<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F> PrismMut<_2<__Pm>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized,
    C: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _2<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F> PrismMut<_3<__Pm>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized,
    D: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _3<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F> PrismMut<_4<__Pm>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized,
    E: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _4<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F> PrismMut<_5<__Pm>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized,
    F: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _5<__Pm>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F> PrismMut<Ok<__Opt>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Ok<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F> PrismMut<Err<__Opt>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Err<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F> PrismMut<Some<__Opt>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Some<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F> PrismMut<None<__Opt>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: None<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F> PrismMut<_6<__Opt>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _6<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F> PrismMut<_7<__Opt>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _7<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F> PrismMut<_8<__Opt>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _8<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F> PrismMut<_9<__Opt>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _9<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F> PrismMut<_10<__Opt>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _10<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F> PrismMut<_11<__Opt>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _11<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F> PrismMut<_12<__Opt>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _12<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F> PrismMut<_13<__Opt>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _13<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F> PrismMut<_14<__Opt>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _14<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F> PrismMut<_15<__Opt>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _15<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F> PrismMut<_16<__Opt>, __Image> for (A, B, C, D, E, F) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _16<__Opt>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G> PrismMut<_0<__Pm>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized,
    A: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _0<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G> PrismMut<_1<__Pm>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized,
    B: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _1<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G> PrismMut<_2<__Pm>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized,
    C: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _2<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G> PrismMut<_3<__Pm>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized,
    D: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _3<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G> PrismMut<_4<__Pm>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized,
    E: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _4<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G> PrismMut<_5<__Pm>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized,
    F: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _5<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G> PrismMut<_6<__Pm>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized,
    G: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _6<__Pm>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G> PrismMut<Ok<__Opt>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Ok<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G> PrismMut<Err<__Opt>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Err<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G> PrismMut<Some<__Opt>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Some<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G> PrismMut<None<__Opt>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: None<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G> PrismMut<_7<__Opt>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _7<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G> PrismMut<_8<__Opt>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _8<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G> PrismMut<_9<__Opt>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _9<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G> PrismMut<_10<__Opt>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _10<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G> PrismMut<_11<__Opt>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _11<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G> PrismMut<_12<__Opt>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _12<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G> PrismMut<_13<__Opt>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _13<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G> PrismMut<_14<__Opt>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _14<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G> PrismMut<_15<__Opt>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _15<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G> PrismMut<_16<__Opt>, __Image> for (A, B, C, D, E, F, G) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _16<__Opt>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H> PrismMut<_0<__Pm>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized,
    A: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _0<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H> PrismMut<_1<__Pm>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized,
    B: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _1<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H> PrismMut<_2<__Pm>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized,
    C: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _2<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H> PrismMut<_3<__Pm>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized,
    D: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _3<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H> PrismMut<_4<__Pm>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized,
    E: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _4<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H> PrismMut<_5<__Pm>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized,
    F: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _5<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H> PrismMut<_6<__Pm>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized,
    G: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _6<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H> PrismMut<_7<__Pm>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized,
    H: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _7<__Pm>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H> PrismMut<Ok<__Opt>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Ok<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H> PrismMut<Err<__Opt>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Err<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H> PrismMut<Some<__Opt>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Some<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H> PrismMut<None<__Opt>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: None<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H> PrismMut<_8<__Opt>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _8<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H> PrismMut<_9<__Opt>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _9<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H> PrismMut<_10<__Opt>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _10<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H> PrismMut<_11<__Opt>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _11<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H> PrismMut<_12<__Opt>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _12<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H> PrismMut<_13<__Opt>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _13<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H> PrismMut<_14<__Opt>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _14<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H> PrismMut<_15<__Opt>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _15<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H> PrismMut<_16<__Opt>, __Image> for (A, B, C, D, E, F, G, H) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _16<__Opt>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I> PrismMut<_0<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized,
    A: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _0<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I> PrismMut<_1<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized,
    B: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _1<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I> PrismMut<_2<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized,
    C: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _2<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I> PrismMut<_3<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized,
    D: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _3<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I> PrismMut<_4<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized,
    E: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _4<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I> PrismMut<_5<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized,
    F: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _5<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I> PrismMut<_6<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized,
    G: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _6<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I> PrismMut<_7<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized,
    H: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _7<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I> PrismMut<_8<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized,
    I: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _8<__Pm>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> PrismMut<Ok<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Ok<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> PrismMut<Err<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Err<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> PrismMut<Some<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Some<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> PrismMut<None<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: None<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> PrismMut<_9<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _9<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> PrismMut<_10<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _10<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> PrismMut<_11<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _11<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> PrismMut<_12<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _12<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> PrismMut<_13<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _13<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> PrismMut<_14<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _14<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> PrismMut<_15<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _15<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> PrismMut<_16<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _16<__Opt>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J> PrismMut<_0<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized,
    A: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _0<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J> PrismMut<_1<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized,
    B: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _1<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J> PrismMut<_2<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized,
    C: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _2<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J> PrismMut<_3<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized,
    D: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _3<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J> PrismMut<_4<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized,
    E: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _4<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J> PrismMut<_5<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized,
    F: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _5<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J> PrismMut<_6<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized,
    G: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _6<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J> PrismMut<_7<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized,
    H: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _7<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J> PrismMut<_8<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized,
    I: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _8<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J> PrismMut<_9<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized,
    J: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _9<__Pm>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> PrismMut<Ok<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Ok<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> PrismMut<Err<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Err<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> PrismMut<Some<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Some<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> PrismMut<None<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: None<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> PrismMut<_10<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _10<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> PrismMut<_11<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _11<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> PrismMut<_12<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _12<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> PrismMut<_13<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _13<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> PrismMut<_14<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _14<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> PrismMut<_15<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _15<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> PrismMut<_16<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _16<__Opt>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K> PrismMut<_0<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized,
    A: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _0<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K> PrismMut<_1<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized,
    B: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _1<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K> PrismMut<_2<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized,
    C: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _2<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K> PrismMut<_3<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized,
    D: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _3<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K> PrismMut<_4<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized,
    E: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _4<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K> PrismMut<_5<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized,
    F: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _5<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K> PrismMut<_6<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized,
    G: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _6<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K> PrismMut<_7<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized,
    H: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _7<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K> PrismMut<_8<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized,
    I: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _8<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K> PrismMut<_9<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized,
    J: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _9<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K> PrismMut<_10<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized,
    K: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _10<__Pm>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> PrismMut<Ok<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Ok<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> PrismMut<Err<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Err<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> PrismMut<Some<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Some<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> PrismMut<None<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: None<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> PrismMut<_11<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _11<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> PrismMut<_12<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _12<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> PrismMut<_13<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _13<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> PrismMut<_14<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _14<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> PrismMut<_15<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _15<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> PrismMut<_16<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _16<__Opt>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<_0<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized,
    A: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _0<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<_1<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized,
    B: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _1<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<_2<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized,
    C: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _2<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<_3<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized,
    D: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _3<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<_4<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized,
    E: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _4<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<_5<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized,
    F: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _5<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<_6<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized,
    G: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _6<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<_7<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized,
    H: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _7<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<_8<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized,
    I: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _8<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<_9<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized,
    J: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _9<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<_10<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized,
    K: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _10<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<_11<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized,
    L: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _11<__Pm>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<Ok<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Ok<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<Err<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Err<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<Some<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Some<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<None<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: None<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<_12<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _12<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<_13<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _13<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<_14<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _14<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<_15<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _15<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L> PrismMut<_16<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _16<__Opt>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<_0<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized,
    A: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _0<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<_1<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized,
    B: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _1<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<_2<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized,
    C: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _2<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<_3<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized,
    D: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _3<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<_4<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized,
    E: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _4<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<_5<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized,
    F: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _5<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<_6<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized,
    G: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _6<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<_7<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized,
    H: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _7<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<_8<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized,
    I: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _8<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<_9<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized,
    J: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _9<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<_10<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized,
    K: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _10<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<_11<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized,
    L: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _11<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<_12<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized,
    M: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _12<__Pm>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<Ok<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Ok<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<Err<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Err<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<Some<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Some<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<None<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: None<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<_13<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _13<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<_14<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _14<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<_15<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _15<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M> PrismMut<_16<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _16<__Opt>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<_0<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized,
    A: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _0<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<_1<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized,
    B: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _1<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<_2<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized,
    C: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _2<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<_3<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized,
    D: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _3<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<_4<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized,
    E: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _4<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<_5<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized,
    F: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _5<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<_6<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized,
    G: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _6<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<_7<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized,
    H: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _7<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<_8<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized,
    I: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _8<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<_9<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized,
    J: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _9<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<_10<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized,
    K: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _10<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<_11<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized,
    L: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _11<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<_12<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized,
    M: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _12<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<_13<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized,
    N: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _13<__Pm>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<Ok<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Ok<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<Err<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Err<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<Some<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Some<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<None<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: None<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<_14<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _14<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<_15<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _15<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N> PrismMut<_16<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _16<__Opt>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<_0<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized,
    A: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _0<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<_1<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized,
    B: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _1<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<_2<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized,
    C: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _2<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<_3<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized,
    D: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _3<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<_4<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized,
    E: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _4<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<_5<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized,
    F: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _5<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<_6<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized,
    G: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _6<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<_7<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized,
    H: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _7<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<_8<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized,
    I: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _8<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<_9<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized,
    J: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _9<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<_10<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized,
    K: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _10<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<_11<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized,
    L: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _11<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<_12<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized,
    M: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _12<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<_13<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized,
    N: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _13<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<_14<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized,
    O: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _14<__Pm>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<Ok<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Ok<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<Err<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Err<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<Some<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Some<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<None<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: None<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<_15<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _15<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PrismMut<_16<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _16<__Opt>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<_0<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized,
    A: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _0<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<_1<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized,
    B: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _1<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<_2<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized,
    C: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _2<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<_3<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized,
    D: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _3<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<_4<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized,
    E: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _4<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<_5<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized,
    F: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _5<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<_6<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized,
    G: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _6<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<_7<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized,
    H: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _7<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<_8<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized,
    I: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _8<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<_9<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized,
    J: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _9<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<_10<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized,
    K: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _10<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<_11<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized,
    L: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _11<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<_12<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized,
    M: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _12<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<_13<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized,
    N: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _13<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<_14<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized,
    O: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _14<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<_15<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized,
    P: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _15<__Pm>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<Ok<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Ok<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<Err<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Err<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<Some<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Some<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<None<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: None<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PrismMut<_16<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _16<__Opt>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<_0<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized,
    A: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _0<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<_1<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized,
    B: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _1<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<_2<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized,
    C: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _2<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<_3<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized,
    D: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _3<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<_4<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized,
    E: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _4<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<_5<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized,
    F: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _5<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<_6<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized,
    G: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _6<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<_7<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized,
    H: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _7<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<_8<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized,
    I: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _8<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<_9<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized,
    J: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _9<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<_10<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized,
    K: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _10<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<_11<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized,
    L: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _11<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<_12<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized,
    M: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _12<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<_13<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized,
    N: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _13<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<_14<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized,
    O: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _14<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<_15<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized,
    P: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _15<__Pm>) -> Option<&mut __Image>

impl<__Image, __Pm, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<_16<__Pm>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized,
    Q: PrismMut<__Pm, __Image>, 

fn preview_mut(&mut self, optics: _16<__Pm>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<Ok<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Ok<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<Err<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Err<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<Some<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Some<__Opt>) -> Option<&mut __Image>

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PrismMut<None<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: None<__Opt>) -> Option<&mut __Image>

impl<Pm: Clone, Image: ?Sized, A> PrismMut<_both<Pm>, Image> for (A,) where
    A: PrismMut<Pm, Image>, 

fn preview_mut(&mut self, optics: _both<Pm>) -> Option<&mut Image>

impl<T: ?Sized, Image: ?Sized, Pm> PrismMut<_box<Pm>, Image> for Box<T> where
    T: PrismMut<Pm, Image>, 

fn preview_mut(&mut self, optics: _box<Pm>) -> Option<&mut Image>

impl<T: ?Sized, Image: ?Sized, Pm> PrismMut<_mut<Pm>, Image> for Box<T> where
    T: PrismMut<Pm, Image>, 

fn preview_mut(&mut self, optics: _mut<Pm>) -> Option<&mut Image>

impl<T: ?Sized, Image: ?Sized, Pm> PrismMut<_mut<Pm>, Image> for &mut T where
    T: PrismMut<Pm, Image>, 

fn preview_mut(&mut self, optics: _mut<Pm>) -> Option<&mut Image>

impl<T, Image: ?Sized, Pm> PrismMut<_ix<usize, Pm>, Image> for Vec<T> where
    T: PrismMut<Pm, Image>, 

fn preview_mut(&mut self, optics: _ix<usize, Pm>) -> Option<&mut Image>

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

fn preview_mut(&mut self, optics: _ix<Range<usize>, Pm>) -> Option<&mut Image>

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

fn preview_mut(&mut self, optics: _ix<RangeTo<usize>, Pm>) -> Option<&mut Image>

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

fn preview_mut(
    &mut self,
    optics: _ix<RangeFrom<usize>, Pm>
) -> Option<&mut Image>

impl<T, Image: ?Sized, Pm> PrismMut<_ix<RangeFull, Pm>, Image> for Vec<T> where
    [T]: PrismMut<Pm, Image>, 

fn preview_mut(&mut self, optics: _ix<RangeFull, Pm>) -> Option<&mut Image>

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

fn preview_mut(&mut self, optics: _ix<usize, Pm>) -> Option<&mut Image>

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

fn preview_mut(&mut self, optics: _ix<usize, Pm>) -> Option<&mut Image>

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

fn preview_mut(&mut self, optics: _ix<Range<usize>, Pm>) -> Option<&mut Image>

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

fn preview_mut(&mut self, optics: _ix<RangeTo<usize>, Pm>) -> Option<&mut Image>

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

fn preview_mut(
    &mut self,
    optics: _ix<RangeFrom<usize>, Pm>
) -> Option<&mut Image>

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

fn preview_mut(&mut self, optics: _ix<RangeFull, Pm>) -> Option<&mut Image>

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

fn preview_mut(&mut self, optics: _ix<usize, Pm>) -> Option<&mut Image>

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

fn preview_mut(&mut self, optics: _ix<Range<usize>, Pm>) -> Option<&mut Image>

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

fn preview_mut(&mut self, optics: _ix<RangeTo<usize>, Pm>) -> Option<&mut Image>

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

fn preview_mut(
    &mut self,
    optics: _ix<RangeFrom<usize>, Pm>
) -> Option<&mut Image>

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

fn preview_mut(&mut self, optics: _ix<RangeFull, Pm>) -> Option<&mut Image>

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

fn preview_mut(&mut self, optics: _ix<Range<usize>, Pm>) -> Option<&mut Image>

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

fn preview_mut(&mut self, optics: _ix<RangeTo<usize>, Pm>) -> Option<&mut Image>

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

fn preview_mut(
    &mut self,
    optics: _ix<RangeFrom<usize>, Pm>
) -> Option<&mut Image>

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

fn preview_mut(&mut self, optics: _ix<RangeFull, Pm>) -> Option<&mut Image>

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

fn preview_mut(&mut self, optics: _ix<Range<usize>, Pm>) -> Option<&mut Image>

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

fn preview_mut(&mut self, optics: _ix<RangeTo<usize>, Pm>) -> Option<&mut Image>

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

fn preview_mut(
    &mut self,
    optics: _ix<RangeFrom<usize>, Pm>
) -> Option<&mut Image>

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

fn preview_mut(&mut self, optics: _ix<RangeFull, Pm>) -> Option<&mut Image>

impl<__Pm, __Image, T> PrismMut<Some<__Pm>, __Image> for Option<T> where
    T: PrismMut<__Pm, __Image>,
    __Image: ?Sized, 

fn preview_mut(&mut self, optics: Some<__Pm>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<None<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: None<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<Ok<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Ok<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<Err<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Err<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<_0<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _0<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<_1<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _1<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<_2<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _2<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<_3<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _3<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<_4<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _4<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<_5<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _5<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<_6<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _6<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<_7<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _7<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<_8<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _8<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<_9<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _9<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<_10<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _10<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<_11<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _11<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<_12<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _12<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<_13<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _13<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<_14<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _14<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<_15<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _15<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T> PrismMut<_16<__Opt>, __Image> for Option<T> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _16<__Opt>) -> Option<&mut __Image>

impl<__Pm, __Image, T, E> PrismMut<Ok<__Pm>, __Image> for Result<T, E> where
    T: PrismMut<__Pm, __Image>,
    __Image: ?Sized, 

fn preview_mut(&mut self, optics: Ok<__Pm>) -> Option<&mut __Image>

impl<__Pm, __Image, T, E> PrismMut<Err<__Pm>, __Image> for Result<T, E> where
    E: PrismMut<__Pm, __Image>,
    __Image: ?Sized, 

fn preview_mut(&mut self, optics: Err<__Pm>) -> Option<&mut __Image>

impl<__Opt, __Image, T, E> PrismMut<Some<__Opt>, __Image> for Result<T, E> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: Some<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T, E> PrismMut<None<__Opt>, __Image> for Result<T, E> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: None<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T, E> PrismMut<_0<__Opt>, __Image> for Result<T, E> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _0<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T, E> PrismMut<_1<__Opt>, __Image> for Result<T, E> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _1<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T, E> PrismMut<_2<__Opt>, __Image> for Result<T, E> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _2<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T, E> PrismMut<_3<__Opt>, __Image> for Result<T, E> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _3<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T, E> PrismMut<_4<__Opt>, __Image> for Result<T, E> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _4<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T, E> PrismMut<_5<__Opt>, __Image> for Result<T, E> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _5<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T, E> PrismMut<_6<__Opt>, __Image> for Result<T, E> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _6<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T, E> PrismMut<_7<__Opt>, __Image> for Result<T, E> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _7<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T, E> PrismMut<_8<__Opt>, __Image> for Result<T, E> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _8<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T, E> PrismMut<_9<__Opt>, __Image> for Result<T, E> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _9<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T, E> PrismMut<_10<__Opt>, __Image> for Result<T, E> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _10<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T, E> PrismMut<_11<__Opt>, __Image> for Result<T, E> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _11<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T, E> PrismMut<_12<__Opt>, __Image> for Result<T, E> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _12<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T, E> PrismMut<_13<__Opt>, __Image> for Result<T, E> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _13<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T, E> PrismMut<_14<__Opt>, __Image> for Result<T, E> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _14<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T, E> PrismMut<_15<__Opt>, __Image> for Result<T, E> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _15<__Opt>) -> Option<&mut __Image>

impl<__Opt, __Image, T, E> PrismMut<_16<__Opt>, __Image> for Result<T, E> where
    __Image: ?Sized, 

fn preview_mut(&mut self, _optics: _16<__Opt>) -> Option<&mut __Image>

Loading content...

Implementors

impl<T: ?Sized> PrismMut<__, T> for T

fn preview_mut(&mut self, _optics: __) -> Option<&mut T>

Loading content...