Trait lens_rs::traits::traversal::Traversal

pub trait Traversal<Optics, Image>: TraversalMut<Optics, Image> {
    fn traverse(self, optics: Optics) -> Vec<Image>
    where
        Self: Sized;
}

the movable version of Traversal

Required methods

fn traverse(self, optics: Optics) -> Vec<Image> where
    Self: Sized, 

Loading content...

Implementations on Foreign Types

impl<__Image, __Tr, A> Traversal<_0<__Tr>, __Image> for (A,) where
    A: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _0<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<Ok<__Opt>, __Image> for (A,)

fn traverse(self, _optics: Ok<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<Err<__Opt>, __Image> for (A,)

fn traverse(self, _optics: Err<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<Some<__Opt>, __Image> for (A,)

fn traverse(self, _optics: Some<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<None<__Opt>, __Image> for (A,)

fn traverse(self, _optics: None<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<_1<__Opt>, __Image> for (A,)

fn traverse(self, _optics: _1<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<_2<__Opt>, __Image> for (A,)

fn traverse(self, _optics: _2<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<_3<__Opt>, __Image> for (A,)

fn traverse(self, _optics: _3<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<_4<__Opt>, __Image> for (A,)

fn traverse(self, _optics: _4<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<_5<__Opt>, __Image> for (A,)

fn traverse(self, _optics: _5<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<_6<__Opt>, __Image> for (A,)

fn traverse(self, _optics: _6<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<_7<__Opt>, __Image> for (A,)

fn traverse(self, _optics: _7<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<_8<__Opt>, __Image> for (A,)

fn traverse(self, _optics: _8<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<_9<__Opt>, __Image> for (A,)

fn traverse(self, _optics: _9<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<_10<__Opt>, __Image> for (A,)

fn traverse(self, _optics: _10<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<_11<__Opt>, __Image> for (A,)

fn traverse(self, _optics: _11<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<_12<__Opt>, __Image> for (A,)

fn traverse(self, _optics: _12<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<_13<__Opt>, __Image> for (A,)

fn traverse(self, _optics: _13<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<_14<__Opt>, __Image> for (A,)

fn traverse(self, _optics: _14<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<_15<__Opt>, __Image> for (A,)

fn traverse(self, _optics: _15<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A> Traversal<_16<__Opt>, __Image> for (A,)

fn traverse(self, _optics: _16<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B> Traversal<_0<__Tr>, __Image> for (A, B) where
    A: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _0<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B> Traversal<_1<__Tr>, __Image> for (A, B) where
    B: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _1<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B> Traversal<Ok<__Opt>, __Image> for (A, B)

fn traverse(self, _optics: Ok<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B> Traversal<Err<__Opt>, __Image> for (A, B)

fn traverse(self, _optics: Err<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B> Traversal<Some<__Opt>, __Image> for (A, B)

fn traverse(self, _optics: Some<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B> Traversal<None<__Opt>, __Image> for (A, B)

fn traverse(self, _optics: None<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B> Traversal<_2<__Opt>, __Image> for (A, B)

fn traverse(self, _optics: _2<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B> Traversal<_3<__Opt>, __Image> for (A, B)

fn traverse(self, _optics: _3<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B> Traversal<_4<__Opt>, __Image> for (A, B)

fn traverse(self, _optics: _4<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B> Traversal<_5<__Opt>, __Image> for (A, B)

fn traverse(self, _optics: _5<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B> Traversal<_6<__Opt>, __Image> for (A, B)

fn traverse(self, _optics: _6<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B> Traversal<_7<__Opt>, __Image> for (A, B)

fn traverse(self, _optics: _7<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B> Traversal<_8<__Opt>, __Image> for (A, B)

fn traverse(self, _optics: _8<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B> Traversal<_9<__Opt>, __Image> for (A, B)

fn traverse(self, _optics: _9<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B> Traversal<_10<__Opt>, __Image> for (A, B)

fn traverse(self, _optics: _10<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B> Traversal<_11<__Opt>, __Image> for (A, B)

fn traverse(self, _optics: _11<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B> Traversal<_12<__Opt>, __Image> for (A, B)

fn traverse(self, _optics: _12<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B> Traversal<_13<__Opt>, __Image> for (A, B)

fn traverse(self, _optics: _13<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B> Traversal<_14<__Opt>, __Image> for (A, B)

fn traverse(self, _optics: _14<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B> Traversal<_15<__Opt>, __Image> for (A, B)

fn traverse(self, _optics: _15<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B> Traversal<_16<__Opt>, __Image> for (A, B)

fn traverse(self, _optics: _16<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C> Traversal<_0<__Tr>, __Image> for (A, B, C) where
    A: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _0<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C> Traversal<_1<__Tr>, __Image> for (A, B, C) where
    B: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _1<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C> Traversal<_2<__Tr>, __Image> for (A, B, C) where
    C: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _2<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C> Traversal<Ok<__Opt>, __Image> for (A, B, C)

fn traverse(self, _optics: Ok<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C> Traversal<Err<__Opt>, __Image> for (A, B, C)

fn traverse(self, _optics: Err<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C> Traversal<Some<__Opt>, __Image> for (A, B, C)

fn traverse(self, _optics: Some<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C> Traversal<None<__Opt>, __Image> for (A, B, C)

fn traverse(self, _optics: None<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C> Traversal<_3<__Opt>, __Image> for (A, B, C)

fn traverse(self, _optics: _3<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C> Traversal<_4<__Opt>, __Image> for (A, B, C)

fn traverse(self, _optics: _4<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C> Traversal<_5<__Opt>, __Image> for (A, B, C)

fn traverse(self, _optics: _5<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C> Traversal<_6<__Opt>, __Image> for (A, B, C)

fn traverse(self, _optics: _6<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C> Traversal<_7<__Opt>, __Image> for (A, B, C)

fn traverse(self, _optics: _7<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C> Traversal<_8<__Opt>, __Image> for (A, B, C)

fn traverse(self, _optics: _8<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C> Traversal<_9<__Opt>, __Image> for (A, B, C)

fn traverse(self, _optics: _9<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C> Traversal<_10<__Opt>, __Image> for (A, B, C)

fn traverse(self, _optics: _10<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C> Traversal<_11<__Opt>, __Image> for (A, B, C)

fn traverse(self, _optics: _11<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C> Traversal<_12<__Opt>, __Image> for (A, B, C)

fn traverse(self, _optics: _12<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C> Traversal<_13<__Opt>, __Image> for (A, B, C)

fn traverse(self, _optics: _13<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C> Traversal<_14<__Opt>, __Image> for (A, B, C)

fn traverse(self, _optics: _14<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C> Traversal<_15<__Opt>, __Image> for (A, B, C)

fn traverse(self, _optics: _15<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C> Traversal<_16<__Opt>, __Image> for (A, B, C)

fn traverse(self, _optics: _16<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D> Traversal<_0<__Tr>, __Image> for (A, B, C, D) where
    A: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _0<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D> Traversal<_1<__Tr>, __Image> for (A, B, C, D) where
    B: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _1<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D> Traversal<_2<__Tr>, __Image> for (A, B, C, D) where
    C: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _2<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D> Traversal<_3<__Tr>, __Image> for (A, B, C, D) where
    D: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _3<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D> Traversal<Ok<__Opt>, __Image> for (A, B, C, D)

fn traverse(self, _optics: Ok<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D> Traversal<Err<__Opt>, __Image> for (A, B, C, D)

fn traverse(self, _optics: Err<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D> Traversal<Some<__Opt>, __Image> for (A, B, C, D)

fn traverse(self, _optics: Some<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D> Traversal<None<__Opt>, __Image> for (A, B, C, D)

fn traverse(self, _optics: None<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D> Traversal<_4<__Opt>, __Image> for (A, B, C, D)

fn traverse(self, _optics: _4<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D> Traversal<_5<__Opt>, __Image> for (A, B, C, D)

fn traverse(self, _optics: _5<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D> Traversal<_6<__Opt>, __Image> for (A, B, C, D)

fn traverse(self, _optics: _6<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D> Traversal<_7<__Opt>, __Image> for (A, B, C, D)

fn traverse(self, _optics: _7<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D> Traversal<_8<__Opt>, __Image> for (A, B, C, D)

fn traverse(self, _optics: _8<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D> Traversal<_9<__Opt>, __Image> for (A, B, C, D)

fn traverse(self, _optics: _9<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D> Traversal<_10<__Opt>, __Image> for (A, B, C, D)

fn traverse(self, _optics: _10<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D> Traversal<_11<__Opt>, __Image> for (A, B, C, D)

fn traverse(self, _optics: _11<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D> Traversal<_12<__Opt>, __Image> for (A, B, C, D)

fn traverse(self, _optics: _12<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D> Traversal<_13<__Opt>, __Image> for (A, B, C, D)

fn traverse(self, _optics: _13<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D> Traversal<_14<__Opt>, __Image> for (A, B, C, D)

fn traverse(self, _optics: _14<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D> Traversal<_15<__Opt>, __Image> for (A, B, C, D)

fn traverse(self, _optics: _15<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D> Traversal<_16<__Opt>, __Image> for (A, B, C, D)

fn traverse(self, _optics: _16<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E> Traversal<_0<__Tr>, __Image> for (A, B, C, D, E) where
    A: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _0<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E> Traversal<_1<__Tr>, __Image> for (A, B, C, D, E) where
    B: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _1<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E> Traversal<_2<__Tr>, __Image> for (A, B, C, D, E) where
    C: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _2<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E> Traversal<_3<__Tr>, __Image> for (A, B, C, D, E) where
    D: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _3<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E> Traversal<_4<__Tr>, __Image> for (A, B, C, D, E) where
    E: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _4<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E> Traversal<Ok<__Opt>, __Image> for (A, B, C, D, E)

fn traverse(self, _optics: Ok<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E> Traversal<Err<__Opt>, __Image> for (A, B, C, D, E)

fn traverse(self, _optics: Err<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E> Traversal<Some<__Opt>, __Image> for (A, B, C, D, E)

fn traverse(self, _optics: Some<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E> Traversal<None<__Opt>, __Image> for (A, B, C, D, E)

fn traverse(self, _optics: None<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E> Traversal<_5<__Opt>, __Image> for (A, B, C, D, E)

fn traverse(self, _optics: _5<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E> Traversal<_6<__Opt>, __Image> for (A, B, C, D, E)

fn traverse(self, _optics: _6<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E> Traversal<_7<__Opt>, __Image> for (A, B, C, D, E)

fn traverse(self, _optics: _7<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E> Traversal<_8<__Opt>, __Image> for (A, B, C, D, E)

fn traverse(self, _optics: _8<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E> Traversal<_9<__Opt>, __Image> for (A, B, C, D, E)

fn traverse(self, _optics: _9<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E> Traversal<_10<__Opt>, __Image> for (A, B, C, D, E)

fn traverse(self, _optics: _10<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E> Traversal<_11<__Opt>, __Image> for (A, B, C, D, E)

fn traverse(self, _optics: _11<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E> Traversal<_12<__Opt>, __Image> for (A, B, C, D, E)

fn traverse(self, _optics: _12<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E> Traversal<_13<__Opt>, __Image> for (A, B, C, D, E)

fn traverse(self, _optics: _13<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E> Traversal<_14<__Opt>, __Image> for (A, B, C, D, E)

fn traverse(self, _optics: _14<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E> Traversal<_15<__Opt>, __Image> for (A, B, C, D, E)

fn traverse(self, _optics: _15<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E> Traversal<_16<__Opt>, __Image> for (A, B, C, D, E)

fn traverse(self, _optics: _16<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F> Traversal<_0<__Tr>, __Image> for (A, B, C, D, E, F) where
    A: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _0<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F> Traversal<_1<__Tr>, __Image> for (A, B, C, D, E, F) where
    B: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _1<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F> Traversal<_2<__Tr>, __Image> for (A, B, C, D, E, F) where
    C: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _2<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F> Traversal<_3<__Tr>, __Image> for (A, B, C, D, E, F) where
    D: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _3<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F> Traversal<_4<__Tr>, __Image> for (A, B, C, D, E, F) where
    E: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _4<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F> Traversal<_5<__Tr>, __Image> for (A, B, C, D, E, F) where
    F: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _5<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F> Traversal<Ok<__Opt>, __Image> for (A, B, C, D, E, F)

fn traverse(self, _optics: Ok<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F> Traversal<Err<__Opt>, __Image> for (A, B, C, D, E, F)

fn traverse(self, _optics: Err<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F> Traversal<Some<__Opt>, __Image> for (A, B, C, D, E, F)

fn traverse(self, _optics: Some<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F> Traversal<None<__Opt>, __Image> for (A, B, C, D, E, F)

fn traverse(self, _optics: None<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F> Traversal<_6<__Opt>, __Image> for (A, B, C, D, E, F)

fn traverse(self, _optics: _6<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F> Traversal<_7<__Opt>, __Image> for (A, B, C, D, E, F)

fn traverse(self, _optics: _7<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F> Traversal<_8<__Opt>, __Image> for (A, B, C, D, E, F)

fn traverse(self, _optics: _8<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F> Traversal<_9<__Opt>, __Image> for (A, B, C, D, E, F)

fn traverse(self, _optics: _9<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F> Traversal<_10<__Opt>, __Image> for (A, B, C, D, E, F)

fn traverse(self, _optics: _10<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F> Traversal<_11<__Opt>, __Image> for (A, B, C, D, E, F)

fn traverse(self, _optics: _11<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F> Traversal<_12<__Opt>, __Image> for (A, B, C, D, E, F)

fn traverse(self, _optics: _12<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F> Traversal<_13<__Opt>, __Image> for (A, B, C, D, E, F)

fn traverse(self, _optics: _13<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F> Traversal<_14<__Opt>, __Image> for (A, B, C, D, E, F)

fn traverse(self, _optics: _14<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F> Traversal<_15<__Opt>, __Image> for (A, B, C, D, E, F)

fn traverse(self, _optics: _15<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F> Traversal<_16<__Opt>, __Image> for (A, B, C, D, E, F)

fn traverse(self, _optics: _16<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G> Traversal<_0<__Tr>, __Image> for (A, B, C, D, E, F, G) where
    A: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _0<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G> Traversal<_1<__Tr>, __Image> for (A, B, C, D, E, F, G) where
    B: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _1<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G> Traversal<_2<__Tr>, __Image> for (A, B, C, D, E, F, G) where
    C: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _2<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G> Traversal<_3<__Tr>, __Image> for (A, B, C, D, E, F, G) where
    D: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _3<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G> Traversal<_4<__Tr>, __Image> for (A, B, C, D, E, F, G) where
    E: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _4<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G> Traversal<_5<__Tr>, __Image> for (A, B, C, D, E, F, G) where
    F: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _5<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G> Traversal<_6<__Tr>, __Image> for (A, B, C, D, E, F, G) where
    G: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _6<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G> Traversal<Ok<__Opt>, __Image> for (A, B, C, D, E, F, G)

fn traverse(self, _optics: Ok<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G> Traversal<Err<__Opt>, __Image> for (A, B, C, D, E, F, G)

fn traverse(self, _optics: Err<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G> Traversal<Some<__Opt>, __Image> for (A, B, C, D, E, F, G)

fn traverse(self, _optics: Some<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G> Traversal<None<__Opt>, __Image> for (A, B, C, D, E, F, G)

fn traverse(self, _optics: None<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G> Traversal<_7<__Opt>, __Image> for (A, B, C, D, E, F, G)

fn traverse(self, _optics: _7<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G> Traversal<_8<__Opt>, __Image> for (A, B, C, D, E, F, G)

fn traverse(self, _optics: _8<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G> Traversal<_9<__Opt>, __Image> for (A, B, C, D, E, F, G)

fn traverse(self, _optics: _9<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G> Traversal<_10<__Opt>, __Image> for (A, B, C, D, E, F, G)

fn traverse(self, _optics: _10<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G> Traversal<_11<__Opt>, __Image> for (A, B, C, D, E, F, G)

fn traverse(self, _optics: _11<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G> Traversal<_12<__Opt>, __Image> for (A, B, C, D, E, F, G)

fn traverse(self, _optics: _12<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G> Traversal<_13<__Opt>, __Image> for (A, B, C, D, E, F, G)

fn traverse(self, _optics: _13<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G> Traversal<_14<__Opt>, __Image> for (A, B, C, D, E, F, G)

fn traverse(self, _optics: _14<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G> Traversal<_15<__Opt>, __Image> for (A, B, C, D, E, F, G)

fn traverse(self, _optics: _15<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G> Traversal<_16<__Opt>, __Image> for (A, B, C, D, E, F, G)

fn traverse(self, _optics: _16<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H> Traversal<_0<__Tr>, __Image> for (A, B, C, D, E, F, G, H) where
    A: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _0<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H> Traversal<_1<__Tr>, __Image> for (A, B, C, D, E, F, G, H) where
    B: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _1<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H> Traversal<_2<__Tr>, __Image> for (A, B, C, D, E, F, G, H) where
    C: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _2<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H> Traversal<_3<__Tr>, __Image> for (A, B, C, D, E, F, G, H) where
    D: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _3<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H> Traversal<_4<__Tr>, __Image> for (A, B, C, D, E, F, G, H) where
    E: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _4<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H> Traversal<_5<__Tr>, __Image> for (A, B, C, D, E, F, G, H) where
    F: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _5<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H> Traversal<_6<__Tr>, __Image> for (A, B, C, D, E, F, G, H) where
    G: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _6<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H> Traversal<_7<__Tr>, __Image> for (A, B, C, D, E, F, G, H) where
    H: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _7<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H> Traversal<Ok<__Opt>, __Image> for (A, B, C, D, E, F, G, H)

fn traverse(self, _optics: Ok<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H> Traversal<Err<__Opt>, __Image> for (A, B, C, D, E, F, G, H)

fn traverse(self, _optics: Err<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H> Traversal<Some<__Opt>, __Image> for (A, B, C, D, E, F, G, H)

fn traverse(self, _optics: Some<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H> Traversal<None<__Opt>, __Image> for (A, B, C, D, E, F, G, H)

fn traverse(self, _optics: None<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H> Traversal<_8<__Opt>, __Image> for (A, B, C, D, E, F, G, H)

fn traverse(self, _optics: _8<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H> Traversal<_9<__Opt>, __Image> for (A, B, C, D, E, F, G, H)

fn traverse(self, _optics: _9<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H> Traversal<_10<__Opt>, __Image> for (A, B, C, D, E, F, G, H)

fn traverse(self, _optics: _10<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H> Traversal<_11<__Opt>, __Image> for (A, B, C, D, E, F, G, H)

fn traverse(self, _optics: _11<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H> Traversal<_12<__Opt>, __Image> for (A, B, C, D, E, F, G, H)

fn traverse(self, _optics: _12<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H> Traversal<_13<__Opt>, __Image> for (A, B, C, D, E, F, G, H)

fn traverse(self, _optics: _13<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H> Traversal<_14<__Opt>, __Image> for (A, B, C, D, E, F, G, H)

fn traverse(self, _optics: _14<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H> Traversal<_15<__Opt>, __Image> for (A, B, C, D, E, F, G, H)

fn traverse(self, _optics: _15<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H> Traversal<_16<__Opt>, __Image> for (A, B, C, D, E, F, G, H)

fn traverse(self, _optics: _16<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I> Traversal<_0<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I) where
    A: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _0<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I> Traversal<_1<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I) where
    B: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _1<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I> Traversal<_2<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I) where
    C: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _2<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I> Traversal<_3<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I) where
    D: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _3<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I> Traversal<_4<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I) where
    E: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _4<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I> Traversal<_5<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I) where
    F: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _5<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I> Traversal<_6<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I) where
    G: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _6<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I> Traversal<_7<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I) where
    H: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _7<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I> Traversal<_8<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I) where
    I: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _8<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> Traversal<Ok<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I)

fn traverse(self, _optics: Ok<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> Traversal<Err<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I)

fn traverse(self, _optics: Err<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> Traversal<Some<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I)

fn traverse(self, _optics: Some<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> Traversal<None<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I)

fn traverse(self, _optics: None<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> Traversal<_9<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I)

fn traverse(self, _optics: _9<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> Traversal<_10<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I)

fn traverse(self, _optics: _10<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> Traversal<_11<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I)

fn traverse(self, _optics: _11<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> Traversal<_12<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I)

fn traverse(self, _optics: _12<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> Traversal<_13<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I)

fn traverse(self, _optics: _13<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> Traversal<_14<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I)

fn traverse(self, _optics: _14<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> Traversal<_15<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I)

fn traverse(self, _optics: _15<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I> Traversal<_16<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I)

fn traverse(self, _optics: _16<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J> Traversal<_0<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    A: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _0<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J> Traversal<_1<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    B: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _1<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J> Traversal<_2<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    C: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _2<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J> Traversal<_3<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    D: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _3<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J> Traversal<_4<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    E: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _4<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J> Traversal<_5<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    F: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _5<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J> Traversal<_6<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    G: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _6<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J> Traversal<_7<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    H: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _7<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J> Traversal<_8<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    I: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _8<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J> Traversal<_9<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J) where
    J: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _9<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> Traversal<Ok<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J)

fn traverse(self, _optics: Ok<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> Traversal<Err<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J)

fn traverse(self, _optics: Err<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> Traversal<Some<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J)

fn traverse(self, _optics: Some<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> Traversal<None<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J)

fn traverse(self, _optics: None<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> Traversal<_10<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J)

fn traverse(self, _optics: _10<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> Traversal<_11<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J)

fn traverse(self, _optics: _11<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> Traversal<_12<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J)

fn traverse(self, _optics: _12<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> Traversal<_13<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J)

fn traverse(self, _optics: _13<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> Traversal<_14<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J)

fn traverse(self, _optics: _14<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> Traversal<_15<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J)

fn traverse(self, _optics: _15<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J> Traversal<_16<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J)

fn traverse(self, _optics: _16<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K> Traversal<_0<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    A: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _0<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K> Traversal<_1<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    B: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _1<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K> Traversal<_2<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    C: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _2<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K> Traversal<_3<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    D: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _3<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K> Traversal<_4<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    E: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _4<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K> Traversal<_5<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    F: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _5<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K> Traversal<_6<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    G: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _6<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K> Traversal<_7<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    H: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _7<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K> Traversal<_8<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    I: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _8<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K> Traversal<_9<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    J: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _9<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K> Traversal<_10<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K) where
    K: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _10<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> Traversal<Ok<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K)

fn traverse(self, _optics: Ok<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> Traversal<Err<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K)

fn traverse(self, _optics: Err<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> Traversal<Some<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K)

fn traverse(self, _optics: Some<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> Traversal<None<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K)

fn traverse(self, _optics: None<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> Traversal<_11<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K)

fn traverse(self, _optics: _11<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> Traversal<_12<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K)

fn traverse(self, _optics: _12<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> Traversal<_13<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K)

fn traverse(self, _optics: _13<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> Traversal<_14<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K)

fn traverse(self, _optics: _14<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> Traversal<_15<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K)

fn traverse(self, _optics: _15<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K> Traversal<_16<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K)

fn traverse(self, _optics: _16<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<_0<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    A: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _0<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<_1<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    B: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _1<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<_2<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    C: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _2<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<_3<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    D: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _3<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<_4<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    E: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _4<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<_5<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    F: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _5<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<_6<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    G: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _6<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<_7<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    H: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _7<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<_8<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    I: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _8<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<_9<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    J: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _9<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<_10<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    K: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _10<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Tr, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<_11<__Tr>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    L: Traversal<__Tr, __Image>, 

fn traverse(self, optics: _11<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<Ok<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L)

fn traverse(self, _optics: Ok<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<Err<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L)

fn traverse(self, _optics: Err<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<Some<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L)

fn traverse(self, _optics: Some<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<None<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L)

fn traverse(self, _optics: None<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<_12<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L)

fn traverse(self, _optics: _12<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<_13<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L)

fn traverse(self, _optics: _13<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<_14<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L)

fn traverse(self, _optics: _14<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<_15<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L)

fn traverse(self, _optics: _15<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L> Traversal<_16<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L)

fn traverse(self, _optics: _16<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _0<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _1<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _2<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _3<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _4<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _5<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _6<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _7<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _8<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _9<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _10<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _11<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _12<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M> Traversal<Ok<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M)

fn traverse(self, _optics: Ok<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M> Traversal<Err<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M)

fn traverse(self, _optics: Err<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M> Traversal<Some<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M)

fn traverse(self, _optics: Some<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M> Traversal<None<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M)

fn traverse(self, _optics: None<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M> Traversal<_13<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M)

fn traverse(self, _optics: _13<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M> Traversal<_14<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M)

fn traverse(self, _optics: _14<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M> Traversal<_15<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M)

fn traverse(self, _optics: _15<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Image, __Opt, A, B, C, D, E, F, G, H, I, J, K, L, M> Traversal<_16<__Opt>, __Image> for (A, B, C, D, E, F, G, H, I, J, K, L, M)

fn traverse(self, _optics: _16<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _0<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _1<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _2<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _3<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _4<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _5<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _6<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _7<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _8<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _9<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _10<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _11<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _12<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _13<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: Ok<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: Err<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: Some<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: None<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: _14<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: _15<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: _16<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _0<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _1<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _2<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _3<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _4<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _5<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _6<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _7<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _8<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _9<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _10<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _11<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _12<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _13<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _14<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: Ok<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: Err<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: Some<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: None<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: _15<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: _16<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _0<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _1<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _2<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _3<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _4<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _5<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _6<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _7<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _8<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _9<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _10<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _11<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _12<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _13<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _14<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _15<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: Ok<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: Err<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: Some<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: None<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: _16<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _0<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _1<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _2<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _3<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _4<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _5<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _6<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _7<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _8<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _9<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _10<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _11<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _12<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _13<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _14<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _15<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, optics: _16<__Tr>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: Ok<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: Err<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: Some<__Opt>) -> Vec<__Image> where
    Self: Sized, 

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

fn traverse(self, _optics: None<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<Tr, Image, A> Traversal<_both<Tr>, Image> for (A,) where
    Tr: Clone,
    A: Traversal<Tr, Image>, 

fn traverse(self, optics: _both<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr, Image, A> Traversal<_both<Tr>, Image> for (A, A) where
    Tr: Clone,
    A: Traversal<Tr, Image>, 

fn traverse(self, optics: _both<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr, Image, A> Traversal<_both<Tr>, Image> for (A, A, A) where
    Tr: Clone,
    A: Traversal<Tr, Image>, 

fn traverse(self, optics: _both<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr, Image, A> Traversal<_both<Tr>, Image> for (A, A, A, A) where
    Tr: Clone,
    A: Traversal<Tr, Image>, 

fn traverse(self, optics: _both<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr, Image, A> Traversal<_both<Tr>, Image> for (A, A, A, A, A) where
    Tr: Clone,
    A: Traversal<Tr, Image>, 

fn traverse(self, optics: _both<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr, Image, A> Traversal<_both<Tr>, Image> for (A, A, A, A, A, A) where
    Tr: Clone,
    A: Traversal<Tr, Image>, 

fn traverse(self, optics: _both<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr, Image, A> Traversal<_both<Tr>, Image> for (A, A, A, A, A, A, A) where
    Tr: Clone,
    A: Traversal<Tr, Image>, 

fn traverse(self, optics: _both<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr, Image, A> Traversal<_both<Tr>, Image> for (A, A, A, A, A, A, A, A) where
    Tr: Clone,
    A: Traversal<Tr, Image>, 

fn traverse(self, optics: _both<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr, Image, A> Traversal<_both<Tr>, Image> for (A, A, A, A, A, A, A, A, A) where
    Tr: Clone,
    A: Traversal<Tr, Image>, 

fn traverse(self, optics: _both<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr, Image, A> Traversal<_both<Tr>, Image> for (A, A, A, A, A, A, A, A, A, A) where
    Tr: Clone,
    A: Traversal<Tr, Image>, 

fn traverse(self, optics: _both<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr, Image, A> Traversal<_both<Tr>, Image> for (A, A, A, A, A, A, A, A, A, A, A) where
    Tr: Clone,
    A: Traversal<Tr, Image>, 

fn traverse(self, optics: _both<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr, Image, A> Traversal<_both<Tr>, Image> for (A, A, A, A, A, A, A, A, A, A, A, A) where
    Tr: Clone,
    A: Traversal<Tr, Image>, 

fn traverse(self, optics: _both<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr, Image, A> Traversal<_both<Tr>, Image> for (A, A, A, A, A, A, A, A, A, A, A, A, A) where
    Tr: Clone,
    A: Traversal<Tr, Image>, 

fn traverse(self, optics: _both<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr, Image, A> Traversal<_both<Tr>, Image> for (A, A, A, A, A, A, A, A, A, A, A, A, A, A) where
    Tr: Clone,
    A: Traversal<Tr, Image>, 

fn traverse(self, optics: _both<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr, Image, A> Traversal<_both<Tr>, Image> for (A, A, A, A, A, A, A, A, A, A, A, A, A, A, A) where
    Tr: Clone,
    A: Traversal<Tr, Image>, 

fn traverse(self, optics: _both<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr, Image, A> Traversal<_both<Tr>, Image> for (A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A) where
    Tr: Clone,
    A: Traversal<Tr, Image>, 

fn traverse(self, optics: _both<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr, Image, A> Traversal<_both<Tr>, Image> for (A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A) where
    Tr: Clone,
    A: Traversal<Tr, Image>, 

fn traverse(self, optics: _both<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr: Clone, Image, T> Traversal<_mapped<Tr>, Image> for Vec<T> where
    T: Traversal<Tr, Image>, 

fn traverse(self, optics: _mapped<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr: Clone, Image, T> Traversal<_mapped<Tr>, Image> for VecDeque<T> where
    T: Traversal<Tr, Image>, 

fn traverse(self, optics: _mapped<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr: Clone, Image, T> Traversal<_mapped<Tr>, Image> for LinkedList<T> where
    T: Traversal<Tr, Image>, 

fn traverse(self, optics: _mapped<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<Tr, Image, T> Traversal<_box<Tr>, Image> for Box<T> where
    T: Traversal<Tr, Image>, 

fn traverse(self, optics: _box<Tr>) -> Vec<Image> where
    Self: Sized, 

impl<__Tr, __Image, T> Traversal<Some<__Tr>, __Image> for Option<T> where
    T: Traversal<__Tr, __Image>, 

fn traverse(self, optics: Some<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<None<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: None<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<Ok<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: Ok<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<Err<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: Err<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<_0<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: _0<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<_1<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: _1<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<_2<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: _2<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<_3<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: _3<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<_4<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: _4<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<_5<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: _5<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<_6<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: _6<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<_7<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: _7<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<_8<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: _8<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<_9<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: _9<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<_10<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: _10<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<_11<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: _11<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<_12<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: _12<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<_13<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: _13<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<_14<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: _14<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<_15<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: _15<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T> Traversal<_16<__Opt>, __Image> for Option<T>

fn traverse(self, _optics: _16<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Tr, __Image, T, E> Traversal<Ok<__Tr>, __Image> for Result<T, E> where
    T: Traversal<__Tr, __Image>, 

fn traverse(self, optics: Ok<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Tr, __Image, T, E> Traversal<Err<__Tr>, __Image> for Result<T, E> where
    E: Traversal<__Tr, __Image>, 

fn traverse(self, optics: Err<__Tr>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T, E> Traversal<Some<__Opt>, __Image> for Result<T, E>

fn traverse(self, _optics: Some<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T, E> Traversal<None<__Opt>, __Image> for Result<T, E>

fn traverse(self, _optics: None<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T, E> Traversal<_0<__Opt>, __Image> for Result<T, E>

fn traverse(self, _optics: _0<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T, E> Traversal<_1<__Opt>, __Image> for Result<T, E>

fn traverse(self, _optics: _1<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T, E> Traversal<_2<__Opt>, __Image> for Result<T, E>

fn traverse(self, _optics: _2<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T, E> Traversal<_3<__Opt>, __Image> for Result<T, E>

fn traverse(self, _optics: _3<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T, E> Traversal<_4<__Opt>, __Image> for Result<T, E>

fn traverse(self, _optics: _4<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T, E> Traversal<_5<__Opt>, __Image> for Result<T, E>

fn traverse(self, _optics: _5<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T, E> Traversal<_6<__Opt>, __Image> for Result<T, E>

fn traverse(self, _optics: _6<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T, E> Traversal<_7<__Opt>, __Image> for Result<T, E>

fn traverse(self, _optics: _7<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T, E> Traversal<_8<__Opt>, __Image> for Result<T, E>

fn traverse(self, _optics: _8<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T, E> Traversal<_9<__Opt>, __Image> for Result<T, E>

fn traverse(self, _optics: _9<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T, E> Traversal<_10<__Opt>, __Image> for Result<T, E>

fn traverse(self, _optics: _10<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T, E> Traversal<_11<__Opt>, __Image> for Result<T, E>

fn traverse(self, _optics: _11<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T, E> Traversal<_12<__Opt>, __Image> for Result<T, E>

fn traverse(self, _optics: _12<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T, E> Traversal<_13<__Opt>, __Image> for Result<T, E>

fn traverse(self, _optics: _13<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T, E> Traversal<_14<__Opt>, __Image> for Result<T, E>

fn traverse(self, _optics: _14<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T, E> Traversal<_15<__Opt>, __Image> for Result<T, E>

fn traverse(self, _optics: _15<__Opt>) -> Vec<__Image> where
    Self: Sized, 

impl<__Opt, __Image, T, E> Traversal<_16<__Opt>, __Image> for Result<T, E>

fn traverse(self, _optics: _16<__Opt>) -> Vec<__Image> where
    Self: Sized, 

Loading content...

Implementors

impl<T> Traversal<__, T> for T

fn traverse(self, _optics: __) -> Vec<T> where
    Self: Sized, 

Loading content...