Struct lens_rs::optics::_ix

pub struct _ix<I, Optic>(pub Optic, pub I);

Trait Implementations

impl<I: Clone, Optic: Clone> Clone for _ix<I, Optic>

fn clone(&self) -> _ix<I, Optic>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<I: Copy, Optic: Copy> Copy for _ix<I, Optic>

impl<I: Debug, Optic: Debug> Debug for _ix<I, Optic>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<I: Eq, Optic: Eq> Eq for _ix<I, Optic>

impl<T, Ls, const N: usize> LensMut<[T; N]> for _ix<usize, Ls> where
    Ls: LensMut<T>, 

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

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

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

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

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

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

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

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

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

impl<T, Ls> LensMut<[T]> for _ix<usize, Ls> where
    Ls: LensMut<T>, 

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

impl<T, Ls> LensMut<[T]> for _ix<Range<usize>, Ls> where
    Ls: LensMut<[T]>, 

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

impl<T, Ls> LensMut<[T]> for _ix<RangeTo<usize>, Ls> where
    Ls: LensMut<[T]>, 

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

impl<T, Ls> LensMut<[T]> for _ix<RangeFrom<usize>, Ls> where
    Ls: LensMut<[T]>, 

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

impl<T, Ls> LensMut<[T]> for _ix<RangeFull, Ls> where
    Ls: LensMut<[T]>, 

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

impl<Ls> LensMut<String> for _ix<Range<usize>, Ls> where
    Ls: LensMut<str>, 

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

impl<Ls> LensMut<String> for _ix<RangeTo<usize>, Ls> where
    Ls: LensMut<str>, 

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

impl<Ls> LensMut<String> for _ix<RangeFrom<usize>, Ls> where
    Ls: LensMut<str>, 

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

impl<Ls> LensMut<String> for _ix<RangeFull, Ls> where
    Ls: LensMut<str>, 

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

impl<T, Ls> LensMut<Vec<T, Global>> for _ix<usize, Ls> where
    Ls: LensMut<T>, 

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

impl<T, Ls> LensMut<Vec<T, Global>> for _ix<Range<usize>, Ls> where
    Ls: LensMut<[T]>, 

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

impl<T, Ls> LensMut<Vec<T, Global>> for _ix<RangeTo<usize>, Ls> where
    Ls: LensMut<[T]>, 

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

impl<T, Ls> LensMut<Vec<T, Global>> for _ix<RangeFrom<usize>, Ls> where
    Ls: LensMut<[T]>, 

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

impl<T, Ls> LensMut<Vec<T, Global>> for _ix<RangeFull, Ls> where
    Ls: LensMut<[T]>, 

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

impl<T, Ls> LensMut<VecDeque<T>> for _ix<usize, Ls> where
    Ls: LensMut<T>, 

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

impl<Ls> LensMut<str> for _ix<Range<usize>, Ls> where
    Ls: LensMut<str>, 

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

impl<Ls> LensMut<str> for _ix<RangeTo<usize>, Ls> where
    Ls: LensMut<str>, 

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

impl<Ls> LensMut<str> for _ix<RangeFrom<usize>, Ls> where
    Ls: LensMut<str>, 

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

impl<Ls> LensMut<str> for _ix<RangeFull, Ls> where
    Ls: LensMut<str>, 

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

impl<T, Ls, const N: usize> LensRef<[T; N]> for _ix<usize, Ls> where
    Ls: LensRef<T>, 

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

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

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

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

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

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

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

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

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

impl<T, Ls> LensRef<[T]> for _ix<usize, Ls> where
    Ls: LensRef<T>, 

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

impl<T, Ls> LensRef<[T]> for _ix<Range<usize>, Ls> where
    Ls: LensRef<[T]>, 

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

impl<T, Ls> LensRef<[T]> for _ix<RangeTo<usize>, Ls> where
    Ls: LensRef<[T]>, 

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

impl<T, Ls> LensRef<[T]> for _ix<RangeFrom<usize>, Ls> where
    Ls: LensRef<[T]>, 

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

impl<T, Ls> LensRef<[T]> for _ix<RangeFull, Ls> where
    Ls: LensRef<[T]>, 

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

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

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

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

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

impl<Ls> LensRef<String> for _ix<Range<usize>, Ls> where
    Ls: LensRef<str>, 

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

impl<Ls> LensRef<String> for _ix<RangeTo<usize>, Ls> where
    Ls: LensRef<str>, 

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

impl<Ls> LensRef<String> for _ix<RangeFrom<usize>, Ls> where
    Ls: LensRef<str>, 

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

impl<Ls> LensRef<String> for _ix<RangeFull, Ls> where
    Ls: LensRef<str>, 

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

impl<T, Ls> LensRef<Vec<T, Global>> for _ix<usize, Ls> where
    Ls: LensRef<T>, 

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

impl<T, Ls> LensRef<Vec<T, Global>> for _ix<Range<usize>, Ls> where
    Ls: LensRef<[T]>, 

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

impl<T, Ls> LensRef<Vec<T, Global>> for _ix<RangeTo<usize>, Ls> where
    Ls: LensRef<[T]>, 

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

impl<T, Ls> LensRef<Vec<T, Global>> for _ix<RangeFrom<usize>, Ls> where
    Ls: LensRef<[T]>, 

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

impl<T, Ls> LensRef<Vec<T, Global>> for _ix<RangeFull, Ls> where
    Ls: LensRef<[T]>, 

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

impl<T, Ls> LensRef<VecDeque<T>> for _ix<usize, Ls> where
    Ls: LensRef<T>, 

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

impl<Ls> LensRef<str> for _ix<Range<usize>, Ls> where
    Ls: LensRef<str>, 

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

impl<Ls> LensRef<str> for _ix<RangeTo<usize>, Ls> where
    Ls: LensRef<str>, 

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

impl<Ls> LensRef<str> for _ix<RangeFrom<usize>, Ls> where
    Ls: LensRef<str>, 

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

impl<Ls> LensRef<str> for _ix<RangeFull, Ls> where
    Ls: LensRef<str>, 

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

impl<I: PartialEq, Optic: PartialEq> PartialEq<_ix<I, Optic>> for _ix<I, Optic>

fn eq(&self, other: &_ix<I, Optic>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &_ix<I, Optic>) -> bool

This method tests for !=.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<I, Optic> StructuralEq for _ix<I, Optic>

impl<I, Optic> StructuralPartialEq for _ix<I, Optic>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn traverse_mut<'a>(&self, source: &'a mut str) -> Vec<&'a mut 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<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, 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> 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<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<[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<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<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<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> 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<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<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> 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<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<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<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<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>