Trait stdcli::prelude::itertools::__std_iter::DoubleEndedIterator

pub trait DoubleEndedIterator: Iterator {
    fn next_back(&mut self) -> Option<Self::Item>;

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
        P: FnMut(&Self::Item) -> bool,
    { ... }
}

An iterator able to yield elements from both ends.

Something that implements DoubleEndedIterator has one extra capability over something that implements Iterator: the ability to also take Items from the back, as well as the front.

It is important to note that both back and forth work on the same range, and do not cross: iteration is over when they meet in the middle.

In a similar fashion to the Iterator protocol, once a DoubleEndedIterator returns None from a next_back(), calling it again may or may not ever return Some again. next() and next_back() are interchangeable for this purpose.

Examples

Basic usage:

let numbers = vec![1, 2, 3, 4, 5, 6];

let mut iter = numbers.iter();

assert_eq!(Some(&1), iter.next());
assert_eq!(Some(&6), iter.next_back());
assert_eq!(Some(&5), iter.next_back());
assert_eq!(Some(&2), iter.next());
assert_eq!(Some(&3), iter.next());
assert_eq!(Some(&4), iter.next());
assert_eq!(None, iter.next());
assert_eq!(None, iter.next_back());

Required Methods

fn next_back(&mut self) -> Option<Self::Item>

Removes and returns an element from the end of the iterator.

Returns None when there are no more elements.

The trait-level docs contain more details.

Examples

Basic usage:

let numbers = vec![1, 2, 3, 4, 5, 6];

let mut iter = numbers.iter();

assert_eq!(Some(&1), iter.next());
assert_eq!(Some(&6), iter.next_back());
assert_eq!(Some(&5), iter.next_back());
assert_eq!(Some(&2), iter.next());
assert_eq!(Some(&3), iter.next());
assert_eq!(Some(&4), iter.next());
assert_eq!(None, iter.next());
assert_eq!(None, iter.next_back());

Provided Methods

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

Searches for an element of an iterator from the right that satisfies a predicate.

rfind() takes a closure that returns true or false. It applies this closure to each element of the iterator, starting at the end, and if any of them return true, then rfind() returns Some(element). If they all return false, it returns None.

rfind() is short-circuiting; in other words, it will stop processing as soon as the closure returns true.

Because rfind() takes a reference, and many iterators iterate over references, this leads to a possibly confusing situation where the argument is a double reference. You can see this effect in the examples below, with &&x.

Examples

Basic usage:

#![feature(iter_rfind)]

let a = [1, 2, 3];

assert_eq!(a.iter().rfind(|&&x| x == 2), Some(&2));

assert_eq!(a.iter().rfind(|&&x| x == 5), None);

Stopping at the first true:

#![feature(iter_rfind)]

let a = [1, 2, 3];

let mut iter = a.iter();

assert_eq!(iter.rfind(|&&x| x == 2), Some(&2));

// we can still use `iter`, as there are more elements.
assert_eq!(iter.next_back(), Some(&1));

Implementations on Foreign Types

impl<T> DoubleEndedIterator for IntoIter<T>

fn next_back(&mut self) -> Option<T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T>

fn next_back(&mut self) -> Option<&'a mut [T]>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, A> DoubleEndedIterator for Iter<'a, A>

fn next_back(&mut self) -> Option<&'a A>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T, P> DoubleEndedIterator for SplitMut<'a, T, P> where
    P: FnMut(&T) -> bool, 

fn next_back(&mut self) -> Option<&'a mut [T]>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<A> DoubleEndedIterator for IntoIter<A>

fn next_back(&mut self) -> Option<A>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for Iter<'a, T>

fn next_back(&mut self) -> Option<&'a T>

fn rfind<F>(&mut self, predicate: F) -> Option<<Iter<'a, T> as Iterator>::Item> where
    F: FnMut(&<Iter<'a, T> as Iterator>::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for Windows<'a, T>

fn next_back(&mut self) -> Option<&'a [T]>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, P> DoubleEndedIterator for SplitTerminator<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>, 

fn next_back(&mut self) -> Option<&'a str>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a> DoubleEndedIterator for Bytes<'a>

fn next_back(&mut self) -> Option<u8>

fn rfind<P>(&mut self, predicate: P) -> Option<<Bytes<'a> as Iterator>::Item> where
    P: FnMut(&<Bytes<'a> as Iterator>::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T, P> DoubleEndedIterator for RSplit<'a, T, P> where
    P: FnMut(&T) -> bool, 

fn next_back(&mut self) -> Option<&'a [T]>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, P> DoubleEndedIterator for RSplit<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>, 

fn next_back(&mut self) -> Option<&'a str>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T, P> DoubleEndedIterator for Split<'a, T, P> where
    P: FnMut(&T) -> bool, 

fn next_back(&mut self) -> Option<&'a [T]>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<A> DoubleEndedIterator for RangeInclusive<A> where
    A: Step, 

fn next_back(&mut self) -> Option<A>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, P> DoubleEndedIterator for MatchIndices<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>, 

fn next_back(&mut self) -> Option<(usize, &'a str)>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a> DoubleEndedIterator for LinesAny<'a>

fn next_back(&mut self) -> Option<&'a str>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a> DoubleEndedIterator for Chars<'a>

fn next_back(&mut self) -> Option<char>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a> DoubleEndedIterator for Lines<'a>

fn next_back(&mut self) -> Option<&'a str>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, P> DoubleEndedIterator for RMatchIndices<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>, 

fn next_back(&mut self) -> Option<(usize, &'a str)>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, I> DoubleEndedIterator for &'a mut I where
    I: DoubleEndedIterator + ?Sized, 

fn next_back(&mut self) -> Option<<I as Iterator>::Item>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for Iter<'a, T>

fn next_back(&mut self) -> Option<&'a T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, A> DoubleEndedIterator for IterMut<'a, A>

fn next_back(&mut self) -> Option<&'a mut A>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, P> DoubleEndedIterator for Split<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>, 

fn next_back(&mut self) -> Option<&'a str>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, P> DoubleEndedIterator for Matches<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>, 

fn next_back(&mut self) -> Option<&'a str>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, P> DoubleEndedIterator for RMatches<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>, 

fn next_back(&mut self) -> Option<&'a str>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<A> DoubleEndedIterator for Range<A> where
    A: Step, 

fn next_back(&mut self) -> Option<A>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T, P> DoubleEndedIterator for RSplitMut<'a, T, P> where
    P: FnMut(&T) -> bool, 

fn next_back(&mut self) -> Option<&'a mut [T]>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for Chunks<'a, T>

fn next_back(&mut self) -> Option<&'a [T]>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, P> DoubleEndedIterator for RSplitTerminator<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>, 

fn next_back(&mut self) -> Option<&'a str>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for IterMut<'a, T>

fn next_back(&mut self) -> Option<&'a mut T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for IterMut<'a, T>

fn next_back(&mut self) -> Option<&'a mut T>

fn rfind<F>(
    &mut self,
    predicate: F
) -> Option<<IterMut<'a, T> as Iterator>::Item> where
    F: FnMut(&<IterMut<'a, T> as Iterator>::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a> DoubleEndedIterator for CharIndices<'a>

fn next_back(&mut self) -> Option<(usize, char)>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a> DoubleEndedIterator for Values<'a>

fn next_back(&mut self) -> Option<&'a str>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a> DoubleEndedIterator for OsValues<'a>

fn next_back(&mut self) -> Option<&'a OsStr>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, K, V> DoubleEndedIterator for Entries<'a, K, V>

fn next_back(&mut self) -> Option<(&'a K, &'a V)>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V>

fn next_back(&mut self) -> Option<&'a V>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V>

fn next_back(&mut self) -> Option<&'a V>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for Iter<'a, T>

fn next_back(&mut self) -> Option<&'a T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V>

fn next_back(&mut self) -> Option<&'a K>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for Iter<'a, T>

fn next_back(&mut self) -> Option<&'a T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, K, V> DoubleEndedIterator for Entries<'a, K, V>

fn next_back(&mut self) -> Option<(&'a K, &'a V)>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V>

fn next_back(&mut self) -> Option<&'a K>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, K, V> DoubleEndedIterator for Iter<'a, K, V>

fn next_back(&mut self) -> Option<(&'a K, &'a V)>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, K, V> DoubleEndedIterator for IterMut<'a, K, V>

fn next_back(&mut self) -> Option<(&'a K, &'a mut V)>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V>

fn next_back(&mut self) -> Option<&'a K>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<K, V> DoubleEndedIterator for IntoIter<K, V>

fn next_back(&mut self) -> Option<(K, V)>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V>

fn next_back(&mut self) -> Option<&'a V>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for IterMut<'a, T>

fn next_back(&mut self) -> Option<&'a mut T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for Iter<'a, T>

fn next_back(&mut self) -> Option<&'a T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V>

fn next_back(&mut self) -> Option<&'a V>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for Drain<'a, T> where
    T: 'a, 

fn next_back(&mut self) -> Option<T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, K, V> DoubleEndedIterator for Iter<'a, K, V> where
    K: 'a,
    V: 'a, 

fn next_back(&mut self) -> Option<(&'a K, &'a V)>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, K, V> DoubleEndedIterator for RangeMut<'a, K, V>

fn next_back(&mut self) -> Option<(&'a K, &'a mut V)>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for Iter<'a, T>

fn next_back(&mut self) -> Option<&'a T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, K, V> DoubleEndedIterator for Range<'a, K, V>

fn next_back(&mut self) -> Option<(&'a K, &'a V)>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, K, V> DoubleEndedIterator for ValuesMut<'a, K, V>

fn next_back(&mut self) -> Option<&'a mut V>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for Drain<'a, T> where
    T: 'a, 

fn next_back(&mut self) -> Option<T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, K, V> DoubleEndedIterator for IterMut<'a, K, V> where
    K: 'a,
    V: 'a, 

fn next_back(&mut self) -> Option<(&'a K, &'a mut V)>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a> DoubleEndedIterator for Drain<'a>

fn next_back(&mut self) -> Option<char>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for Range<'a, T>

fn next_back(&mut self) -> Option<&'a T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<K, V> DoubleEndedIterator for IntoIter<K, V>

fn next_back(&mut self) -> Option<(K, V)>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<I> DoubleEndedIterator for Box<I> where
    I: DoubleEndedIterator + ?Sized, 

fn next_back(&mut self) -> Option<<I as Iterator>::Item>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for Drain<'a, T>

fn next_back(&mut self) -> Option<T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, I> DoubleEndedIterator for Splice<'a, I> where
    I: Iterator, 

fn next_back(&mut self) -> Option<<Splice<'a, I> as Iterator>::Item>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<T> DoubleEndedIterator for IntoIter<T>

fn next_back(&mut self) -> Option<T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<T> DoubleEndedIterator for IntoIter<T>

fn next_back(&mut self) -> Option<T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for IterMut<'a, T>

fn next_back(&mut self) -> Option<&'a mut T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V>

fn next_back(&mut self) -> Option<&'a K>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for Iter<'a, T>

fn next_back(&mut self) -> Option<&'a T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<T> DoubleEndedIterator for IntoIter<T>

fn next_back(&mut self) -> Option<T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for Iter<'a, T>

fn next_back(&mut self) -> Option<&'a T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<T> DoubleEndedIterator for IntoIter<T>

fn next_back(&mut self) -> Option<T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<T> DoubleEndedIterator for IntoIter<T>

fn next_back(&mut self) -> Option<T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<A> DoubleEndedIterator for Range<A> where
    A: Integer + Clone + ToPrimitive, 

Integer is required to ensure the range will be the same regardless of the direction it is consumed.

fn next_back(&mut self) -> Option<A>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<A> DoubleEndedIterator for RangeInclusive<A> where
    A: Sub<A, Output = A> + Integer + Clone + ToPrimitive, 

fn next_back(&mut self) -> Option<A>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl DoubleEndedIterator for ArgsOs

fn next_back(&mut self) -> Option<OsString>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl DoubleEndedIterator for Args

fn next_back(&mut self) -> Option<String>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a> DoubleEndedIterator for Components<'a>

fn next_back(&mut self) -> Option<Component<'a>>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a> DoubleEndedIterator for Iter<'a>

fn next_back(&mut self) -> Option<&'a OsStr>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl DoubleEndedIterator for EscapeDefault

fn next_back(&mut self) -> Option<u8>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, V> DoubleEndedIterator for Keys<'a, V>

fn next_back(&mut self) -> Option<usize>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, V> DoubleEndedIterator for IterMut<'a, V>

fn next_back(&mut self) -> Option<(usize, &'a mut V)>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, V> DoubleEndedIterator for Drain<'a, V>

fn next_back(&mut self) -> Option<(usize, V)>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, V> DoubleEndedIterator for Values<'a, V>

fn next_back(&mut self) -> Option<&'a V>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, V> DoubleEndedIterator for Iter<'a, V>

fn next_back(&mut self) -> Option<(usize, &'a V)>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<V> DoubleEndedIterator for IntoIter<V>

fn next_back(&mut self) -> Option<(usize, V)>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for Drain<'a, T> where
    T: 'a, 

fn next_back(&mut self) -> Option<T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<A> DoubleEndedIterator for IntoIter<A> where
    A: Array, 

fn next_back(&mut self) -> Option<<A as Array>::Item>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a, T> DoubleEndedIterator for Drain<'a, T> where
    T: 'a, 

fn next_back(&mut self) -> Option<T>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<A> DoubleEndedIterator for IntoIter<A> where
    A: Array, 

fn next_back(&mut self) -> Option<<A as Array>::Item>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a> DoubleEndedIterator for SplitWhitespace<'a>

fn next_back(&mut self) -> Option<&'a str>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

impl<'a> DoubleEndedIterator for Memchr<'a>

fn next_back(&mut self) -> Option<<Memchr<'a> as Iterator>::Item>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

🔬 This is a nightly-only experimental API. (iter_rfind)

Implementors

• impl<'a> DoubleEndedIterator for stdcli::prelude::serde_json::map::Values<'a>
• impl<'a> DoubleEndedIterator for stdcli::prelude::serde_json::map::IterMut<'a>
• impl DoubleEndedIterator for stdcli::prelude::serde_json::map::IntoIter
• impl<'a> DoubleEndedIterator for stdcli::prelude::serde_json::map::Keys<'a>
• impl<'a> DoubleEndedIterator for stdcli::prelude::serde_json::map::Iter<'a>
• impl<I> DoubleEndedIterator for Skip<I> where
    I: DoubleEndedIterator + ExactSizeIterator, 
• impl<'a, I, T> DoubleEndedIterator for Cloned<I> where
    I: DoubleEndedIterator<Item = &'a T>,
    T: 'a + Clone, 
• impl<I> DoubleEndedIterator for Enumerate<I> where
    I: ExactSizeIterator + DoubleEndedIterator, 
• impl<I> DoubleEndedIterator for Rev<I> where
    I: DoubleEndedIterator, 
• impl<I> DoubleEndedIterator for Fuse<I> where
    I: DoubleEndedIterator, 
• impl<T> DoubleEndedIterator for Empty<T>
• impl<B, I, F> DoubleEndedIterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: DoubleEndedIterator, 
• impl<I, U, F> DoubleEndedIterator for FlatMap<I, U, F> where
    F: FnMut(<I as Iterator>::Item) -> U,
    I: DoubleEndedIterator,
    U: IntoIterator,
    <U as IntoIterator>::IntoIter: DoubleEndedIterator, 
• impl<B, I, F> DoubleEndedIterator for FilterMap<I, F> where
    F: FnMut(<I as Iterator>::Item) -> Option<B>,
    I: DoubleEndedIterator, 
• impl<I, P> DoubleEndedIterator for Filter<I, P> where
    I: DoubleEndedIterator,
    P: FnMut(&<I as Iterator>::Item) -> bool, 
• impl<I> DoubleEndedIterator for Fuse<I> where
    I: DoubleEndedIterator + FusedIterator, 
• impl<I, F> DoubleEndedIterator for Inspect<I, F> where
    F: FnMut(&<I as Iterator>::Item) -> (),
    I: DoubleEndedIterator, 
• impl<A> DoubleEndedIterator for Repeat<A> where
    A: Clone, 
• impl<A, B> DoubleEndedIterator for Chain<A, B> where
    A: DoubleEndedIterator,
    B: DoubleEndedIterator<Item = <A as Iterator>::Item>, 
• impl<T> DoubleEndedIterator for Once<T>
• impl<A, B> DoubleEndedIterator for Zip<A, B> where
    A: DoubleEndedIterator + ExactSizeIterator,
    B: DoubleEndedIterator + ExactSizeIterator, 
• impl<X, Iter, B, C, D, E, F, G, H> DoubleEndedIterator for ConsTuples<Iter, ((B, C, D, E, F, G, H), X)> where
    Iter: DoubleEndedIterator<Item = ((B, C, D, E, F, G, H), X)>, 
• impl<I> DoubleEndedIterator for RcIter<I> where
    I: DoubleEndedIterator, 
• impl<I, F> DoubleEndedIterator for Update<I, F> where
    F: FnMut(&mut <I as Iterator>::Item) -> (),
    I: DoubleEndedIterator, 
• impl<I, F> DoubleEndedIterator for PadUsing<I, F> where
    F: FnMut(usize) -> <I as Iterator>::Item,
    I: DoubleEndedIterator + ExactSizeIterator, 
• impl<X, Iter, C, D, E, F, G, H> DoubleEndedIterator for ConsTuples<Iter, ((C, D, E, F, G, H), X)> where
    Iter: DoubleEndedIterator<Item = ((C, D, E, F, G, H), X)>, 
• impl<X, Iter, D, E, F, G, H> DoubleEndedIterator for ConsTuples<Iter, ((D, E, F, G, H), X)> where
    Iter: DoubleEndedIterator<Item = ((D, E, F, G, H), X)>, 
• impl<X, Iter, E, F, G, H> DoubleEndedIterator for ConsTuples<Iter, ((E, F, G, H), X)> where
    Iter: DoubleEndedIterator<Item = ((E, F, G, H), X)>, 
• impl<X, Iter, F, G, H> DoubleEndedIterator for ConsTuples<Iter, ((F, G, H), X)> where
    Iter: DoubleEndedIterator<Item = ((F, G, H), X)>, 
• impl<X, Iter, G, H> DoubleEndedIterator for ConsTuples<Iter, ((G, H), X)> where
    Iter: DoubleEndedIterator<Item = ((G, H), X)>, 
• impl<T, U> DoubleEndedIterator for ZipLongest<T, U> where
    T: DoubleEndedIterator + ExactSizeIterator,
    U: DoubleEndedIterator + ExactSizeIterator, 
• impl<I, F> DoubleEndedIterator for Positions<I, F> where
    F: FnMut(<I as Iterator>::Item) -> bool,
    I: DoubleEndedIterator + ExactSizeIterator, 
• impl<A> DoubleEndedIterator for RepeatN<A> where
    A: Clone, 
• impl DoubleEndedIterator for stdcli::prelude::regex::SetMatchesIntoIter
• impl DoubleEndedIterator for stdcli::prelude::regex::bytes::SetMatchesIntoIter
• impl<'a> DoubleEndedIterator for stdcli::prelude::regex::bytes::SetMatchesIter<'a>
• impl<'a> DoubleEndedIterator for stdcli::prelude::regex::SetMatchesIter<'a>
• impl<L, R> DoubleEndedIterator for Either<L, R> where
    L: DoubleEndedIterator,
    R: DoubleEndedIterator<Item = <L as Iterator>::Item>,