Trait lens_rs::traits::TraversalRef

pub trait TraversalRef<T: ?Sized> {
    type To: ?Sized;
    fn traverse_ref<'a>(&self, source: &'a T) -> Vec<&'a Self::To>;
}

A trait representing the optics allows you to traverse over a structure and change out its contents. A Traversal can access the multiple substructures.

Example

let mut x = (1, vec![Some((2, 3)), None]);
optics!(_1.Mapped._Some._0)
    .traverse_mut(&mut x)
    .into_iter()
    .for_each(|i| *i += 1);
assert_eq!(optics!(_1._mapped.Some._0).traverse(x), vec![3]);

Associated Types

type To: ?Sized

Loading content...

Required methods

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

Loading content...

Implementors

impl<'t, T: ?Sized, Tr> TraversalRef<&'t T> for _ref<Tr> where
    Tr: TraversalRef<<&'t T as Deref>::Target>, 

type To = Tr::To

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

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

type To = Tr::To

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

impl<K, Q: ?Sized, V, Tr> TraversalRef<BTreeMap<K, V>> for _ix<&Q, Tr> where
    K: Borrow<Q> + Ord,
    Q: Ord,
    Tr: TraversalRef<V>, 

type To = Tr::To

fn traverse_ref<'a>(&self, source: &'a BTreeMap<K, V>) -> Vec<&'a Self::To>

impl<K, Q: ?Sized, V, Tr> TraversalRef<HashMap<K, V, RandomState>> for _ix<&Q, Tr> where
    K: Eq + Hash + Borrow<Q>,
    Q: Eq + Hash,
    Tr: TraversalRef<V>, 

type To = Tr::To

fn traverse_ref<'a>(&self, source: &'a HashMap<K, V>) -> Vec<&'a Self::To>

impl<T> TraversalRef<T> for __

type To = T

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

impl<T, Tr> TraversalRef<[T]> for _ix<usize, Tr> where
    Tr: TraversalRef<T>, 

type To = Tr::To

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

impl<T, Tr> TraversalRef<[T]> for _ix<Range<usize>, Tr> where
    Tr: TraversalRef<[T]>, 

type To = Tr::To

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

impl<T, Tr> TraversalRef<[T]> for _ix<RangeFrom<usize>, Tr> where
    Tr: TraversalRef<[T]>, 

type To = Tr::To

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

impl<T, Tr> TraversalRef<[T]> for _ix<RangeFull, Tr> where
    Tr: TraversalRef<[T]>, 

type To = Tr::To

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

impl<T, Tr> TraversalRef<[T]> for _ix<RangeTo<usize>, Tr> where
    Tr: TraversalRef<[T]>, 

type To = Tr::To

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

impl<T, Tr> TraversalRef<VecDeque<T>> for _ix<usize, Tr> where
    Tr: TraversalRef<T>, 

type To = Tr::To

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

impl<T, Tr> TraversalRef<Vec<T, Global>> for _ix<usize, Tr> where
    Tr: TraversalRef<T>, 

type To = Tr::To

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

impl<T, Tr> TraversalRef<Vec<T, Global>> for _ix<Range<usize>, Tr> where
    Tr: TraversalRef<[T]>, 

type To = Tr::To

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

impl<T, Tr> TraversalRef<Vec<T, Global>> for _ix<RangeFrom<usize>, Tr> where
    Tr: TraversalRef<[T]>, 

type To = Tr::To

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

impl<T, Tr> TraversalRef<Vec<T, Global>> for _ix<RangeFull, Tr> where
    Tr: TraversalRef<[T]>, 

type To = Tr::To

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

impl<T, Tr> TraversalRef<Vec<T, Global>> for _ix<RangeTo<usize>, Tr> where
    Tr: TraversalRef<[T]>, 

type To = Tr::To

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

impl<T, Tr, const N: usize> TraversalRef<[T; N]> for _ix<usize, Tr> where
    Tr: TraversalRef<T>, 

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

impl<T: ?Sized, Tr> TraversalRef<Rc<T>> for _arc<Tr> where
    Tr: TraversalRef<<Rc<T> as Deref>::Target>, 

type To = Tr::To

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

impl<T: ?Sized, Tr> TraversalRef<Rc<T>> for _rc<Tr> where
    Tr: TraversalRef<<Rc<T> as Deref>::Target>, 

type To = Tr::To

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

impl<Tr> TraversalRef<str> for _ix<Range<usize>, Tr> where
    Tr: TraversalRef<str>, 

type To = Tr::To

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

impl<Tr> TraversalRef<str> for _ix<RangeFrom<usize>, Tr> where
    Tr: TraversalRef<str>, 

type To = Tr::To

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

impl<Tr> TraversalRef<str> for _ix<RangeFull, Tr> where
    Tr: TraversalRef<str>, 

type To = Tr::To

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

impl<Tr> TraversalRef<str> for _ix<RangeTo<usize>, Tr> where
    Tr: TraversalRef<str>, 

type To = Tr::To

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

impl<Tr> TraversalRef<String> for _ix<Range<usize>, Tr> where
    Tr: TraversalRef<str>, 

type To = Tr::To

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

impl<Tr> TraversalRef<String> for _ix<RangeFrom<usize>, Tr> where
    Tr: TraversalRef<str>, 

type To = Tr::To

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

impl<Tr> TraversalRef<String> for _ix<RangeFull, Tr> where
    Tr: TraversalRef<str>, 

type To = Tr::To

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

impl<Tr> TraversalRef<String> for _ix<RangeTo<usize>, Tr> where
    Tr: TraversalRef<str>, 

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

impl<Tr, T> TraversalRef<LinkedList<T>> for _mapped<Tr> where
    Tr: TraversalRef<T>, 

type To = Tr::To

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

impl<Tr, T> TraversalRef<VecDeque<T>> for _mapped<Tr> where
    Tr: TraversalRef<T>, 

type To = Tr::To

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

impl<Tr, T> TraversalRef<Vec<T, Global>> for _mapped<Tr> where
    Tr: TraversalRef<T>, 

type To = Tr::To

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

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

type To = Tr::To

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

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

type To = Tr::To

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

Loading content...