pub trait DoubleEndedIterator: Iterator {
fn next_back(&mut self) -> Option<Self::Item>;
fn nth_back(&mut self, n: usize) -> Option<Self::Item> { ... }
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where F: FnMut(B, Self::Item) -> R, R: Try<Ok = B>,
{ ... }
fn rfold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, Self::Item) -> B,
{ ... }
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.
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());
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.
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());
The elements yielded by DoubleEndedIterator's methods may differ from the ones yielded by Iterator's methods:
let vec = vec![(1, 'a'), (1, 'b'), (1, 'c'), (2, 'a'), (2, 'b')];
let uniq_by_fst_comp = || {
let mut seen = std::collections::HashSet::new();
vec.iter().copied().filter(move |x| seen.insert(x.0))
};
assert_eq!(uniq_by_fst_comp().last(), Some((2, 'a')));
assert_eq!(uniq_by_fst_comp().next_back(), Some((2, 'b')));
assert_eq!(
uniq_by_fst_comp().fold(vec![], |mut v, x| {v.push(x); v}),
vec![(1, 'a'), (2, 'a')]
);
assert_eq!(
uniq_by_fst_comp().rfold(vec![], |mut v, x| {v.push(x); v}),
vec![(2, 'b'), (1, 'c')]
);fn nth_back(&mut self, n: usize) -> Option<Self::Item>1.37.0
Returns the nth element from the end of the iterator.
This is essentially the reversed version of nth. Although like most indexing operations, the count starts from zero, so nth_back(0) returns the first value from the end, nth_back(1) the second, and so on.
Note that all elements between the end and the returned element will be consumed, including the returned element. This also means that calling nth_back(0) multiple times on the same iterator will return different elements.
nth_back() will return None if n is greater than or equal to the length of the iterator.
Basic usage:
let a = [1, 2, 3]; assert_eq!(a.iter().nth_back(2), Some(&1));
Calling nth_back() multiple times doesn't rewind the iterator:
let a = [1, 2, 3]; let mut iter = a.iter(); assert_eq!(iter.nth_back(1), Some(&2)); assert_eq!(iter.nth_back(1), None);
Returning None if there are less than n + 1 elements:
let a = [1, 2, 3]; assert_eq!(a.iter().nth_back(10), None);
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>, 1.27.0
This is the reverse version of try_fold(): it takes elements starting from the back of the iterator.
Basic usage:
let a = ["1", "2", "3"];
let sum = a.iter()
.map(|&s| s.parse::<i32>())
.try_rfold(0, |acc, x| x.and_then(|y| Ok(acc + y)));
assert_eq!(sum, Ok(6));Short-circuiting:
let a = ["1", "rust", "3"];
let mut it = a.iter();
let sum = it
.by_ref()
.map(|&s| s.parse::<i32>())
.try_rfold(0, |acc, x| x.and_then(|y| Ok(acc + y)));
assert!(sum.is_err());
// Because it short-circuited, the remaining elements are still
// available through the iterator.
assert_eq!(it.next_back(), Some(&"1"));fn rfold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B, 1.27.0
An iterator method that reduces the iterator's elements to a single, final value, starting from the back.
This is the reverse version of fold(): it takes elements starting from the back of the iterator.
rfold() takes two arguments: an initial value, and a closure with two arguments: an 'accumulator', and an element. The closure returns the value that the accumulator should have for the next iteration.
The initial value is the value the accumulator will have on the first call.
After applying this closure to every element of the iterator, rfold() returns the accumulator.
This operation is sometimes called 'reduce' or 'inject'.
Folding is useful whenever you have a collection of something, and want to produce a single value from it.
Basic usage:
let a = [1, 2, 3];
// the sum of all of the elements of a
let sum = a.iter()
.rfold(0, |acc, &x| acc + x);
assert_eq!(sum, 6);This example builds a string, starting with an initial value and continuing with each element from the back until the front:
let numbers = [1, 2, 3, 4, 5];
let zero = "0".to_string();
let result = numbers.iter().rfold(zero, |acc, &x| {
format!("({} + {})", x, acc)
});
assert_eq!(result, "(1 + (2 + (3 + (4 + (5 + 0)))))");fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool, 1.27.0
Searches for an element of an iterator from the back 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.
Basic usage:
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:
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));
impl<'a, T, P> DoubleEndedIterator for SplitInclusiveMut<'a, T, P> where
P: FnMut(&T) -> bool, [src]
fn next_back(&mut self) -> Option<&'a mut [T]>[src]
impl<'a, T, P> DoubleEndedIterator for SplitInclusive<'a, T, P> where
P: FnMut(&T) -> bool, [src]
fn next_back(&mut self) -> Option<&'a [T]>[src]
impl<'a, P> DoubleEndedIterator for SplitInclusive<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, [src]
fn next_back(&mut self) -> Option<&'a str>[src]
impl DoubleEndedIterator for EscapeDefault[src]
impl DoubleEndedIterator for Args[src]
impl DoubleEndedIterator for ArgsOs[src]
impl<'_> DoubleEndedIterator for Bytes<'_>[src]
fn next_back(&mut self) -> Option<u8>[src]
fn nth_back(&mut self, n: usize) -> Option<<Bytes<'_> as Iterator>::Item>[src]
fn rfind<P>(&mut self, predicate: P) -> Option<<Bytes<'_> as Iterator>::Item> where
P: FnMut(&<Bytes<'_> as Iterator>::Item) -> bool, [src]
impl<'_> DoubleEndedIterator for std::string::Drain<'_>[src]
impl<'_, I> DoubleEndedIterator for Splice<'_, I> where
I: Iterator, [src]
impl<'_, T> DoubleEndedIterator for std::collections::binary_heap::Drain<'_, T>[src]
impl<'_, T> DoubleEndedIterator for std::collections::vec_deque::Drain<'_, T>[src]
impl<'_, T> DoubleEndedIterator for std::vec::Drain<'_, T>[src]
impl<'a> DoubleEndedIterator for Components<'a>[src]
impl<'a> DoubleEndedIterator for std::path::Iter<'a>[src]
impl<'a> DoubleEndedIterator for CharIndices<'a>[src]
impl<'a> DoubleEndedIterator for Chars<'a>[src]
impl<'a> DoubleEndedIterator for Lines<'a>[src]
impl<'a> DoubleEndedIterator for LinesAny<'a>[src]
impl<'a> DoubleEndedIterator for SplitAsciiWhitespace<'a>[src]
impl<'a> DoubleEndedIterator for SplitWhitespace<'a>[src]
impl<'a, A> DoubleEndedIterator for std::option::Iter<'a, A>[src]
impl<'a, A> DoubleEndedIterator for std::option::IterMut<'a, A>[src]
impl<'a, I> DoubleEndedIterator for &'a mut I where
I: DoubleEndedIterator + ?Sized, [src]
fn next_back(&mut self) -> Option<<I as Iterator>::Item>[src]
fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item>[src]
impl<'a, I, T> DoubleEndedIterator for Cloned<I> where
I: DoubleEndedIterator<Item = &'a T>,
T: 'a + Clone, [src]
fn next_back(&mut self) -> Option<T>[src]
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, <Cloned<I> as Iterator>::Item) -> R,
R: Try<Ok = B>,
Cloned<I>: Sized, [src]
fn rfold<Acc, F>(self, init: Acc, f: F) -> Acc where
F: FnMut(Acc, <Cloned<I> as Iterator>::Item) -> Acc, [src]
impl<'a, I, T> DoubleEndedIterator for Copied<I> where
I: DoubleEndedIterator<Item = &'a T>,
T: 'a + Copy, [src]
fn next_back(&mut self) -> Option<T>[src]
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, <Copied<I> as Iterator>::Item) -> R,
R: Try<Ok = B>,
Copied<I>: Sized, [src]
fn rfold<Acc, F>(self, init: Acc, f: F) -> Acc where
F: FnMut(Acc, <Copied<I> as Iterator>::Item) -> Acc, [src]
impl<'a, K, V> DoubleEndedIterator for std::collections::btree_map::Iter<'a, K, V> where
K: 'a,
V: 'a, [src]
impl<'a, K, V> DoubleEndedIterator for std::collections::btree_map::IterMut<'a, K, V> where
K: 'a,
V: 'a, [src]
impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V>[src]
impl<'a, K, V> DoubleEndedIterator for std::collections::btree_map::Range<'a, K, V>[src]
impl<'a, K, V> DoubleEndedIterator for RangeMut<'a, K, V>[src]
impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V>[src]
impl<'a, K, V> DoubleEndedIterator for ValuesMut<'a, K, V>[src]
impl<'a, P> DoubleEndedIterator for MatchIndices<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>, [src]
impl<'a, P> DoubleEndedIterator for Matches<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>, [src]
impl<'a, P> DoubleEndedIterator for RMatchIndices<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>, [src]
impl<'a, P> DoubleEndedIterator for RMatches<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>, [src]
impl<'a, P> DoubleEndedIterator for std::str::RSplit<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>, [src]
impl<'a, P> DoubleEndedIterator for RSplitTerminator<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>, [src]
impl<'a, P> DoubleEndedIterator for std::str::Split<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>, [src]
impl<'a, P> DoubleEndedIterator for SplitTerminator<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>, [src]
impl<'a, T> DoubleEndedIterator for std::collections::binary_heap::Iter<'a, T>[src]
impl<'a, T> DoubleEndedIterator for std::collections::btree_set::Iter<'a, T>[src]
impl<'a, T> DoubleEndedIterator for std::collections::btree_set::Range<'a, T>[src]
impl<'a, T> DoubleEndedIterator for std::collections::linked_list::Iter<'a, T>[src]
impl<'a, T> DoubleEndedIterator for std::collections::linked_list::IterMut<'a, T>[src]
impl<'a, T> DoubleEndedIterator for std::collections::vec_deque::Iter<'a, T>[src]
fn next_back(&mut self) -> Option<&'a T>[src]
fn rfold<Acc, F>(self, accum: Acc, f: F) -> Acc where
F: FnMut(Acc, <Iter<'a, T> as Iterator>::Item) -> Acc, [src]
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, <Iter<'a, T> as Iterator>::Item) -> R,
R: Try<Ok = B>,
Iter<'a, T>: Sized, [src]
impl<'a, T> DoubleEndedIterator for std::collections::vec_deque::IterMut<'a, T>[src]
fn next_back(&mut self) -> Option<&'a mut T>[src]
fn rfold<Acc, F>(self, accum: Acc, f: F) -> Acc where
F: FnMut(Acc, <IterMut<'a, T> as Iterator>::Item) -> Acc, [src]
impl<'a, T> DoubleEndedIterator for std::result::Iter<'a, T>[src]
impl<'a, T> DoubleEndedIterator for std::result::IterMut<'a, T>[src]
impl<'a, T> DoubleEndedIterator for Chunks<'a, T>[src]
fn next_back(&mut self) -> Option<&'a [T]>[src]
fn nth_back(&mut self, n: usize) -> Option<<Chunks<'a, T> as Iterator>::Item>[src]
impl<'a, T> DoubleEndedIterator for ChunksExact<'a, T>[src]
fn next_back(&mut self) -> Option<&'a [T]>[src]
fn nth_back(
&mut self,
n: usize
) -> Option<<ChunksExact<'a, T> as Iterator>::Item>[src]
impl<'a, T> DoubleEndedIterator for ChunksExactMut<'a, T>[src]
fn next_back(&mut self) -> Option<&'a mut [T]>[src]
fn nth_back(
&mut self,
n: usize
) -> Option<<ChunksExactMut<'a, T> as Iterator>::Item>[src]
impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T>[src]
fn next_back(&mut self) -> Option<&'a mut [T]>[src]
fn nth_back(&mut self, n: usize) -> Option<<ChunksMut<'a, T> as Iterator>::Item>[src]
impl<'a, T> DoubleEndedIterator for std::slice::Iter<'a, T>[src]
fn next_back(&mut self) -> Option<&'a T>[src]
fn nth_back(&mut self, n: usize) -> Option<&'a T>[src]
impl<'a, T> DoubleEndedIterator for std::slice::IterMut<'a, T>[src]
fn next_back(&mut self) -> Option<&'a mut T>[src]
fn nth_back(&mut self, n: usize) -> Option<&'a mut T>[src]
impl<'a, T> DoubleEndedIterator for RChunks<'a, T>[src]
fn next_back(&mut self) -> Option<&'a [T]>[src]
fn nth_back(&mut self, n: usize) -> Option<<RChunks<'a, T> as Iterator>::Item>[src]
impl<'a, T> DoubleEndedIterator for RChunksExact<'a, T>[src]
fn next_back(&mut self) -> Option<&'a [T]>[src]
fn nth_back(
&mut self,
n: usize
) -> Option<<RChunksExact<'a, T> as Iterator>::Item>[src]
impl<'a, T> DoubleEndedIterator for RChunksExactMut<'a, T>[src]
fn next_back(&mut self) -> Option<&'a mut [T]>[src]
fn nth_back(
&mut self,
n: usize
) -> Option<<RChunksExactMut<'a, T> as Iterator>::Item>[src]
impl<'a, T> DoubleEndedIterator for RChunksMut<'a, T>[src]
fn next_back(&mut self) -> Option<&'a mut [T]>[src]
fn nth_back(
&mut self,
n: usize
) -> Option<<RChunksMut<'a, T> as Iterator>::Item>[src]
impl<'a, T> DoubleEndedIterator for Windows<'a, T>[src]
fn next_back(&mut self) -> Option<&'a [T]>[src]
fn nth_back(&mut self, n: usize) -> Option<<Windows<'a, T> as Iterator>::Item>[src]
impl<'a, T, P> DoubleEndedIterator for std::slice::RSplit<'a, T, P> where
P: FnMut(&T) -> bool, [src]
impl<'a, T, P> DoubleEndedIterator for RSplitMut<'a, T, P> where
P: FnMut(&T) -> bool, [src]
fn next_back(&mut self) -> Option<&'a mut [T]>[src]
impl<'a, T, P> DoubleEndedIterator for std::slice::Split<'a, T, P> where
P: FnMut(&T) -> bool, [src]
impl<'a, T, P> DoubleEndedIterator for SplitMut<'a, T, P> where
P: FnMut(&T) -> bool, [src]
fn next_back(&mut self) -> Option<&'a mut [T]>[src]
impl<'a, T, const N: usize> DoubleEndedIterator for ArrayChunks<'a, T, N>[src]
fn next_back(&mut self) -> Option<&'a [T; N]>[src]
fn nth_back(
&mut self,
n: usize
) -> Option<<ArrayChunks<'a, T, N> as Iterator>::Item>[src]
impl<A> DoubleEndedIterator for Repeat<A> where
A: Clone, [src]
impl<A> DoubleEndedIterator for std::ops::Range<A> where
A: Step, [src]
impl<A> DoubleEndedIterator for RangeInclusive<A> where
A: Step, [src]
fn next_back(&mut self) -> Option<A>[src]
fn nth_back(&mut self, n: usize) -> Option<A>[src]
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, <RangeInclusive<A> as Iterator>::Item) -> R,
R: Try<Ok = B>,
RangeInclusive<A>: Sized, [src]
fn rfold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, <RangeInclusive<A> as Iterator>::Item) -> B,
RangeInclusive<A>: Sized, [src]
impl<A> DoubleEndedIterator for std::option::IntoIter<A>[src]
impl<A, B> DoubleEndedIterator for Chain<A, B> where
A: DoubleEndedIterator,
B: DoubleEndedIterator<Item = <A as Iterator>::Item>, [src]
fn next_back(&mut self) -> Option<<A as Iterator>::Item>[src]
fn nth_back(&mut self, n: usize) -> Option<<A as Iterator>::Item>[src]
fn rfind<P>(&mut self, predicate: P) -> Option<<Chain<A, B> as Iterator>::Item> where
P: FnMut(&<Chain<A, B> as Iterator>::Item) -> bool, [src]
fn try_rfold<Acc, F, R>(&mut self, acc: Acc, f: F) -> R where
F: FnMut(Acc, <Chain<A, B> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Chain<A, B>: Sized, [src]
fn rfold<Acc, F>(self, acc: Acc, f: F) -> Acc where
F: FnMut(Acc, <Chain<A, B> as Iterator>::Item) -> Acc, [src]
impl<A, B> DoubleEndedIterator for Zip<A, B> where
A: DoubleEndedIterator + ExactSizeIterator,
B: DoubleEndedIterator + ExactSizeIterator, [src]
impl<A, F> DoubleEndedIterator for OnceWith<F> where
F: FnOnce() -> A, [src]
impl<B, I, F> DoubleEndedIterator for FilterMap<I, F> where
F: FnMut(<I as Iterator>::Item) -> Option<B>,
I: DoubleEndedIterator, [src]
fn next_back(&mut self) -> Option<B>[src]
fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
Fold: FnMut(Acc, <FilterMap<I, F> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
FilterMap<I, F>: Sized, [src]
fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
Fold: FnMut(Acc, <FilterMap<I, F> as Iterator>::Item) -> Acc, [src]
impl<B, I, F> DoubleEndedIterator for Map<I, F> where
F: FnMut(<I as Iterator>::Item) -> B,
I: DoubleEndedIterator, [src]
fn next_back(&mut self) -> Option<B>[src]
fn try_rfold<Acc, G, R>(&mut self, init: Acc, g: G) -> R where
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Map<I, F>: Sized, [src]
fn rfold<Acc, G>(self, init: Acc, g: G) -> Acc where
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> Acc, [src]
impl<I> DoubleEndedIterator for Box<I> where
I: DoubleEndedIterator + ?Sized, [src]
fn next_back(&mut self) -> Option<<I as Iterator>::Item>[src]
fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item>[src]
impl<I> DoubleEndedIterator for Enumerate<I> where
I: ExactSizeIterator + DoubleEndedIterator, [src]
fn next_back(&mut self) -> Option<(usize, <I as Iterator>::Item)>[src]
fn nth_back(&mut self, n: usize) -> Option<(usize, <I as Iterator>::Item)>[src]
fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
Fold: FnMut(Acc, <Enumerate<I> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Enumerate<I>: Sized, [src]
fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
Fold: FnMut(Acc, <Enumerate<I> as Iterator>::Item) -> Acc, [src]
impl<I> DoubleEndedIterator for Fuse<I> where
I: DoubleEndedIterator, [src]
fn next_back(&mut self) -> Option<<I as Iterator>::Item>[src]
fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item>[src]
fn try_rfold<Acc, Fold, R>(&mut self, acc: Acc, fold: Fold) -> R where
Fold: FnMut(Acc, <Fuse<I> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Fuse<I>: Sized, [src]
fn rfold<Acc, Fold>(self, acc: Acc, fold: Fold) -> Acc where
Fold: FnMut(Acc, <Fuse<I> as Iterator>::Item) -> Acc, [src]
fn rfind<P>(&mut self, predicate: P) -> Option<<Fuse<I> as Iterator>::Item> where
P: FnMut(&<Fuse<I> as Iterator>::Item) -> bool, [src]
impl<I> DoubleEndedIterator for Peekable<I> where
I: DoubleEndedIterator, [src]
fn next_back(&mut self) -> Option<<Peekable<I> as Iterator>::Item>[src]
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, <Peekable<I> as Iterator>::Item) -> R,
R: Try<Ok = B>,
Peekable<I>: Sized, [src]
fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
Fold: FnMut(Acc, <Peekable<I> as Iterator>::Item) -> Acc, [src]
impl<I> DoubleEndedIterator for Rev<I> where
I: DoubleEndedIterator, [src]
fn next_back(&mut self) -> Option<<I as Iterator>::Item>[src]
fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item>[src]
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, <Rev<I> as Iterator>::Item) -> R,
R: Try<Ok = B>,
Rev<I>: Sized, [src]
fn rfold<Acc, F>(self, init: Acc, f: F) -> Acc where
F: FnMut(Acc, <Rev<I> as Iterator>::Item) -> Acc, [src]
fn rfind<P>(&mut self, predicate: P) -> Option<<Rev<I> as Iterator>::Item> where
P: FnMut(&<Rev<I> as Iterator>::Item) -> bool, [src]
impl<I> DoubleEndedIterator for Skip<I> where
I: DoubleEndedIterator + ExactSizeIterator, [src]
fn next_back(&mut self) -> Option<<Skip<I> as Iterator>::Item>[src]
fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item>[src]
fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
Fold: FnMut(Acc, <Skip<I> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Skip<I>: Sized, [src]
fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
Fold: FnMut(Acc, <Skip<I> as Iterator>::Item) -> Acc, [src]
impl<I> DoubleEndedIterator for StepBy<I> where
I: DoubleEndedIterator + ExactSizeIterator, [src]
fn next_back(&mut self) -> Option<<StepBy<I> as Iterator>::Item>[src]
fn nth_back(&mut self, n: usize) -> Option<<StepBy<I> as Iterator>::Item>[src]
fn try_rfold<Acc, F, R>(&mut self, init: Acc, f: F) -> R where
F: FnMut(Acc, <StepBy<I> as Iterator>::Item) -> R,
R: Try<Ok = Acc>, [src]
fn rfold<Acc, F>(self, init: Acc, f: F) -> Acc where
F: FnMut(Acc, <StepBy<I> as Iterator>::Item) -> Acc,
StepBy<I>: Sized, [src]
impl<I> DoubleEndedIterator for Take<I> where
I: DoubleEndedIterator + ExactSizeIterator, [src]
fn next_back(&mut self) -> Option<<Take<I> as Iterator>::Item>[src]
fn nth_back(&mut self, n: usize) -> Option<<Take<I> as Iterator>::Item>[src]
fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
Fold: FnMut(Acc, <Take<I> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Take<I>: Sized, [src]
fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
Fold: FnMut(Acc, <Take<I> as Iterator>::Item) -> Acc,
Take<I>: Sized, [src]
impl<I, F> DoubleEndedIterator for Inspect<I, F> where
F: FnMut(&<I as Iterator>::Item),
I: DoubleEndedIterator, [src]
fn next_back(&mut self) -> Option<<I as Iterator>::Item>[src]
fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
Fold: FnMut(Acc, <Inspect<I, F> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Inspect<I, F>: Sized, [src]
fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
Fold: FnMut(Acc, <Inspect<I, F> as Iterator>::Item) -> Acc, [src]
impl<I, P> DoubleEndedIterator for Filter<I, P> where
I: DoubleEndedIterator,
P: FnMut(&<I as Iterator>::Item) -> bool, [src]
fn next_back(&mut self) -> Option<<I as Iterator>::Item>[src]
fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
Fold: FnMut(Acc, <Filter<I, P> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Filter<I, P>: Sized, [src]
fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
Fold: FnMut(Acc, <Filter<I, P> as Iterator>::Item) -> Acc, [src]
impl<I, U> DoubleEndedIterator for Flatten<I> where
I: DoubleEndedIterator,
U: DoubleEndedIterator,
<I as Iterator>::Item: IntoIterator,
<<I as Iterator>::Item as IntoIterator>::IntoIter == U,
<<I as Iterator>::Item as IntoIterator>::Item == <U as Iterator>::Item, [src]
fn next_back(&mut self) -> Option<<U as Iterator>::Item>[src]
fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
Fold: FnMut(Acc, <Flatten<I> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Flatten<I>: Sized, [src]
fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
Fold: FnMut(Acc, <Flatten<I> as Iterator>::Item) -> Acc, [src]
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, [src]
fn next_back(&mut self) -> Option<<U as IntoIterator>::Item>[src]
fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
Fold: FnMut(Acc, <FlatMap<I, U, F> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
FlatMap<I, U, F>: Sized, [src]
fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
Fold: FnMut(Acc, <FlatMap<I, U, F> as Iterator>::Item) -> Acc, [src]
impl<K, V> DoubleEndedIterator for std::collections::btree_map::IntoIter<K, V>[src]
impl<K, V> DoubleEndedIterator for IntoKeys<K, V>[src]
impl<K, V> DoubleEndedIterator for IntoValues<K, V>[src]
impl<T> DoubleEndedIterator for std::collections::binary_heap::IntoIter<T>[src]
impl<T> DoubleEndedIterator for std::collections::btree_set::IntoIter<T>[src]
impl<T> DoubleEndedIterator for std::collections::linked_list::IntoIter<T>[src]
impl<T> DoubleEndedIterator for std::collections::vec_deque::IntoIter<T>[src]
impl<T> DoubleEndedIterator for Empty<T>[src]
impl<T> DoubleEndedIterator for Once<T>[src]
impl<T> DoubleEndedIterator for std::result::IntoIter<T>[src]
impl<T> DoubleEndedIterator for std::vec::IntoIter<T>[src]
impl<T, const N: usize> DoubleEndedIterator for std::array::IntoIter<T, N>[src]
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/iter/trait.DoubleEndedIterator.html