Trait lens_rs::traits::Traversal

pub trait Traversal<T>: TraversalMut<T> {
    fn traverse(&self, source: T) -> Vec<Self::To>;
}

Required methods

fn traverse(&self, source: T) -> Vec<Self::To>

Loading content...

Implementors

impl<T> Traversal<T> for __

fn traverse(&self, source: T) -> Vec<Self::To>

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

fn traverse(&self, source: (A, A, A, A, A, A, A)) -> Vec<Self::To>

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

fn traverse(&self, source: (A, A, A, A, A, A)) -> Vec<Self::To>

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

fn traverse(&self, source: (A, A, A, A, A)) -> Vec<Self::To>

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

fn traverse(&self, source: (A, A, A, A)) -> Vec<Self::To>

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

fn traverse(&self, source: (A, A, A)) -> Vec<Self::To>

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

fn traverse(&self, source: (A, A)) -> Vec<Self::To>

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

fn traverse(&self, source: (A,)) -> Vec<Self::To>

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

fn traverse(&self, source: (A,)) -> Vec<Self::To>

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

fn traverse(&self, source: (A, B)) -> Vec<Self::To>

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

fn traverse(&self, source: (A, B)) -> Vec<Self::To>

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

fn traverse(&self, source: (A, B, C)) -> Vec<Self::To>

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

fn traverse(&self, source: (A, B, C)) -> Vec<Self::To>

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

fn traverse(&self, source: (A, B, C)) -> Vec<Self::To>

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

fn traverse(&self, source: (A, B, C, D)) -> Vec<Self::To>

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

fn traverse(&self, source: (A, B, C, D)) -> Vec<Self::To>

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

fn traverse(&self, source: (A, B, C, D)) -> Vec<Self::To>

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

fn traverse(&self, source: (A, B, C, D)) -> Vec<Self::To>

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

fn traverse(&self, source: (A, B, C, D, E)) -> Vec<Self::To>

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

fn traverse(&self, source: (A, B, C, D, E)) -> Vec<Self::To>

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

fn traverse(&self, source: (A, B, C, D, E)) -> Vec<Self::To>

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

fn traverse(&self, source: (A, B, C, D, E)) -> Vec<Self::To>

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

fn traverse(&self, source: (A, B, C, D, E)) -> Vec<Self::To>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn traverse(&self, source: Option<T>) -> Vec<Self::To>

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

fn traverse(&self, source: Box<T>) -> Vec<Self::To>

impl<Tr, T> Traversal<LinkedList<T>> for _mapped<Tr> where
    Tr: Traversal<<LinkedList<T> as IntoIterator>::Item>, 

fn traverse(&self, source: LinkedList<T>) -> Vec<Self::To>

impl<Tr, T> Traversal<VecDeque<T>> for _mapped<Tr> where
    Tr: Traversal<<VecDeque<T> as IntoIterator>::Item>, 

fn traverse(&self, source: VecDeque<T>) -> Vec<Self::To>

impl<Tr, T> Traversal<Vec<T, Global>> for _mapped<Tr> where
    Tr: Traversal<<Vec<T> as IntoIterator>::Item>, 

fn traverse(&self, source: Vec<T>) -> Vec<Self::To>

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

fn traverse(&self, source: Result<T, E>) -> Vec<Self::To>

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

fn traverse(&self, source: Result<T, E>) -> Vec<Self::To>

Loading content...