Trait tor_hsservice::internal_prelude::iter::DoubleEndedIterator
1.0.0 · source · pub trait DoubleEndedIterator: Iterator {
// Required method
fn next_back(&mut self) -> Option<Self::Item>;
// Provided methods
fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> { ... }
fn nth_back(&mut self, n: usize) -> Option<Self::Item> { ... }
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
where Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B> { ... }
fn rfold<B, F>(self, init: B, f: F) -> B
where Self: Sized,
F: FnMut(B, Self::Item) -> B { ... }
fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
where Self: Sized,
P: FnMut(&Self::Item) -> bool { ... }
}
Expand description
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
Item
s 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§
1.0.0 · sourcefn next_back(&mut self) -> Option<Self::Item>
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());
§Remarks
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')]
);
Provided Methods§
sourcefn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
🔬This is a nightly-only experimental API. (iter_advance_by
)
fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
iter_advance_by
)Advances the iterator from the back by n
elements.
advance_back_by
is the reverse version of advance_by
. This method will
eagerly skip n
elements starting from the back by calling next_back
up
to n
times until None
is encountered.
advance_back_by(n)
will return Ok(())
if the iterator successfully advances by
n
elements, or a Err(NonZero<usize>)
with value k
if None
is encountered, where k
is remaining number of steps that could not be advanced because the iterator ran out.
If self
is empty and n
is non-zero, then this returns Err(n)
.
Otherwise, k
is always less than n
.
Calling advance_back_by(0)
can do meaningful work, for example Flatten
can advance its
outer iterator until it finds an inner iterator that is not empty, which then often
allows it to return a more accurate size_hint()
than in its initial state.
§Examples
Basic usage:
#![feature(iter_advance_by)]
use std::num::NonZero;
let a = [3, 4, 5, 6];
let mut iter = a.iter();
assert_eq!(iter.advance_back_by(2), Ok(()));
assert_eq!(iter.next_back(), Some(&4));
assert_eq!(iter.advance_back_by(0), Ok(()));
assert_eq!(iter.advance_back_by(100), Err(NonZero::new(99).unwrap())); // only `&3` was skipped
1.37.0 · sourcefn nth_back(&mut self, n: usize) -> Option<Self::Item>
fn nth_back(&mut self, n: usize) -> Option<Self::Item>
Returns the n
th element from the end of the iterator.
This is essentially the reversed version of Iterator::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.
§Examples
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);
1.27.0 · sourcefn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
This is the reverse version of Iterator::try_fold()
: it takes
elements starting from the back of the iterator.
§Examples
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"));
1.27.0 · sourcefn rfold<B, F>(self, init: B, f: F) -> B
fn rfold<B, F>(self, init: B, f: F) -> B
An iterator method that reduces the iterator’s elements to a single, final value, starting from the back.
This is the reverse version of Iterator::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.
Note: rfold()
combines elements in a right-associative fashion. For associative
operators like +
, the order the elements are combined in is not important, but for non-associative
operators like -
the order will affect the final result.
For a left-associative version of rfold()
, see Iterator::fold()
.
§Examples
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 demonstrates the right-associative nature of rfold()
:
it 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)))))");
1.27.0 · sourcefn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
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
.
§Examples
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));
Implementors§
impl DoubleEndedIterator for RelayIdTypeIter
impl DoubleEndedIterator for DirEventIter
impl DoubleEndedIterator for alloc::string::Drain<'_>
impl DoubleEndedIterator for EscapeDefault
impl DoubleEndedIterator for ToLowercase
impl DoubleEndedIterator for ToUppercase
impl DoubleEndedIterator for Bytes<'_>
impl DoubleEndedIterator for Args
impl DoubleEndedIterator for ArgsOs
impl DoubleEndedIterator for U32Digits<'_>
u64_digit
only.impl DoubleEndedIterator for U64Digits<'_>
u64_digit
only.impl DoubleEndedIterator for serde_json::map::IntoIter
impl DoubleEndedIterator for IntoIter
impl DoubleEndedIterator for SetMatchesIntoIter
impl DoubleEndedIterator for SetMatchesIntoIter
impl DoubleEndedIterator for Utf16CharIter<'_>
impl<'a> DoubleEndedIterator for EscapeAscii<'a>
impl<'a> DoubleEndedIterator for CharIndices<'a>
impl<'a> DoubleEndedIterator for core::str::iter::Chars<'a>
impl<'a> DoubleEndedIterator for Lines<'a>
impl<'a> DoubleEndedIterator for LinesAny<'a>
impl<'a> DoubleEndedIterator for SplitAsciiWhitespace<'a>
impl<'a> DoubleEndedIterator for SplitWhitespace<'a>
impl<'a> DoubleEndedIterator for std::path::Components<'a>
impl<'a> DoubleEndedIterator for std::path::Iter<'a>
impl<'a> DoubleEndedIterator for serde_json::map::Iter<'a>
impl<'a> DoubleEndedIterator for serde_json::map::IterMut<'a>
impl<'a> DoubleEndedIterator for serde_json::map::Keys<'a>
impl<'a> DoubleEndedIterator for serde_json::map::Values<'a>
impl<'a> DoubleEndedIterator for serde_json::map::ValuesMut<'a>
impl<'a> DoubleEndedIterator for Chars<'a>
impl<'a> DoubleEndedIterator for CharsMut<'a>
impl<'a> DoubleEndedIterator for CharsRef<'a>
impl<'a> DoubleEndedIterator for Components<'a>
impl<'a> DoubleEndedIterator for HexIterator<'a>
impl<'a> DoubleEndedIterator for Iter<'a>
impl<'a> DoubleEndedIterator for Iter<'a>
impl<'a> DoubleEndedIterator for IterMut<'a>
impl<'a> DoubleEndedIterator for Keys<'a>
impl<'a> DoubleEndedIterator for PatternSetIter<'a>
alloc
only.impl<'a> DoubleEndedIterator for SetMatchesIter<'a>
impl<'a> DoubleEndedIterator for SetMatchesIter<'a>
impl<'a> DoubleEndedIterator for Values<'a>
impl<'a, 'h> DoubleEndedIterator for OneIter<'a, 'h>
impl<'a, 'h> DoubleEndedIterator for OneIter<'a, 'h>
impl<'a, 'h> DoubleEndedIterator for OneIter<'a, 'h>
impl<'a, 'h> DoubleEndedIterator for ThreeIter<'a, 'h>
impl<'a, 'h> DoubleEndedIterator for ThreeIter<'a, 'h>
impl<'a, 'h> DoubleEndedIterator for ThreeIter<'a, 'h>
impl<'a, 'h> DoubleEndedIterator for TwoIter<'a, 'h>
impl<'a, 'h> DoubleEndedIterator for TwoIter<'a, 'h>
impl<'a, 'h> DoubleEndedIterator for TwoIter<'a, 'h>
impl<'a, A> DoubleEndedIterator for core::option::Iter<'a, A>
impl<'a, A> DoubleEndedIterator for core::option::IterMut<'a, A>
impl<'a, I> DoubleEndedIterator for &'a mut Iwhere
I: DoubleEndedIterator + ?Sized,
impl<'a, I, T> DoubleEndedIterator for Cloned<I>
impl<'a, I, T> DoubleEndedIterator for Copied<I>
impl<'a, K> DoubleEndedIterator for Iter<'a, K>where
K: 'a,
impl<'a, K> DoubleEndedIterator for Iter<'a, K>where
K: 'a,
impl<'a, K, V> DoubleEndedIterator for alloc::collections::btree::map::Iter<'a, K, V>where
K: 'a,
V: 'a,
impl<'a, K, V> DoubleEndedIterator for alloc::collections::btree::map::IterMut<'a, K, V>
impl<'a, K, V> DoubleEndedIterator for alloc::collections::btree::map::Keys<'a, K, V>
impl<'a, K, V> DoubleEndedIterator for alloc::collections::btree::map::Range<'a, K, V>
impl<'a, K, V> DoubleEndedIterator for RangeMut<'a, K, V>
impl<'a, K, V> DoubleEndedIterator for alloc::collections::btree::map::Values<'a, K, V>
impl<'a, K, V> DoubleEndedIterator for alloc::collections::btree::map::ValuesMut<'a, K, V>
impl<'a, K, V> DoubleEndedIterator for phf::map::Entries<'a, K, V>
impl<'a, K, V> DoubleEndedIterator for phf::map::Keys<'a, K, V>
impl<'a, K, V> DoubleEndedIterator for phf::map::Values<'a, K, V>
impl<'a, K, V> DoubleEndedIterator for phf::ordered_map::Entries<'a, K, V>
impl<'a, K, V> DoubleEndedIterator for phf::ordered_map::Keys<'a, K, V>
impl<'a, K, V> DoubleEndedIterator for phf::ordered_map::Values<'a, K, V>
impl<'a, K, V> DoubleEndedIterator for Iter<'a, K, V>where
K: 'a,
V: 'a,
impl<'a, K, V> DoubleEndedIterator for Iter<'a, K, V>where
K: 'a,
V: 'a,
impl<'a, K, V, R> DoubleEndedIterator for Overlapping<'a, K, V, R>
impl<'a, K, V, R> DoubleEndedIterator for Overlapping<'a, K, V, R>
impl<'a, P> DoubleEndedIterator for MatchIndices<'a, P>
impl<'a, P> DoubleEndedIterator for Matches<'a, P>
impl<'a, P> DoubleEndedIterator for RMatchIndices<'a, P>
impl<'a, P> DoubleEndedIterator for RMatches<'a, P>
impl<'a, P> DoubleEndedIterator for core::str::iter::RSplit<'a, P>
impl<'a, P> DoubleEndedIterator for RSplitTerminator<'a, P>
impl<'a, P> DoubleEndedIterator for core::str::iter::Split<'a, P>
impl<'a, P> DoubleEndedIterator for core::str::iter::SplitInclusive<'a, P>
impl<'a, P> DoubleEndedIterator for SplitTerminator<'a, P>
impl<'a, T> DoubleEndedIterator for alloc::collections::binary_heap::Iter<'a, T>
impl<'a, T> DoubleEndedIterator for alloc::collections::btree::set::Iter<'a, T>
impl<'a, T> DoubleEndedIterator for alloc::collections::btree::set::Range<'a, T>
impl<'a, T> DoubleEndedIterator for alloc::collections::linked_list::Iter<'a, T>
impl<'a, T> DoubleEndedIterator for alloc::collections::linked_list::IterMut<'a, T>
impl<'a, T> DoubleEndedIterator for alloc::collections::vec_deque::iter::Iter<'a, T>
impl<'a, T> DoubleEndedIterator for alloc::collections::vec_deque::iter_mut::IterMut<'a, T>
impl<'a, T> DoubleEndedIterator for core::result::Iter<'a, T>
impl<'a, T> DoubleEndedIterator for core::result::IterMut<'a, T>
impl<'a, T> DoubleEndedIterator for core::slice::iter::Chunks<'a, T>
impl<'a, T> DoubleEndedIterator for core::slice::iter::ChunksExact<'a, T>
impl<'a, T> DoubleEndedIterator for core::slice::iter::ChunksExactMut<'a, T>
impl<'a, T> DoubleEndedIterator for core::slice::iter::ChunksMut<'a, T>
impl<'a, T> DoubleEndedIterator for core::slice::iter::Iter<'a, T>
impl<'a, T> DoubleEndedIterator for core::slice::iter::IterMut<'a, T>
impl<'a, T> DoubleEndedIterator for core::slice::iter::RChunks<'a, T>
impl<'a, T> DoubleEndedIterator for core::slice::iter::RChunksExact<'a, T>
impl<'a, T> DoubleEndedIterator for core::slice::iter::RChunksExactMut<'a, T>
impl<'a, T> DoubleEndedIterator for core::slice::iter::RChunksMut<'a, T>
impl<'a, T> DoubleEndedIterator for core::slice::iter::Windows<'a, T>
impl<'a, T> DoubleEndedIterator for openssl::stack::Iter<'a, T>where
T: Stackable,
impl<'a, T> DoubleEndedIterator for openssl::stack::IterMut<'a, T>where
T: Stackable,
impl<'a, T> DoubleEndedIterator for phf::ordered_set::Iter<'a, T>
impl<'a, T> DoubleEndedIterator for phf::set::Iter<'a, T>
impl<'a, T> DoubleEndedIterator for ArrayVecDrain<'a, T>where
T: 'a + Default,
impl<'a, T> DoubleEndedIterator for Drain<'a, T>where
T: 'a + Array,
impl<'a, T> DoubleEndedIterator for Drain<'a, T>where
T: 'a,
impl<'a, T> DoubleEndedIterator for Iter<'a, T>
impl<'a, T> DoubleEndedIterator for IterMut<'a, T>where
T: 'a,
impl<'a, T> DoubleEndedIterator for ValueIter<'a, T>where
T: 'a,
impl<'a, T> DoubleEndedIterator for ValueIterMut<'a, T>where
T: 'a,
impl<'a, T, O> DoubleEndedIterator for ChunksExactMutNoAlias<'a, T, O>where
T: 'a + BitStore,
O: BitOrder,
ChunksExactMut<'a, T, O>: DoubleEndedIterator<Item = &'a mut BitSlice<<T as BitStore>::Alias, O>>,
impl<'a, T, O> DoubleEndedIterator for ChunksMutNoAlias<'a, T, O>where
T: 'a + BitStore,
O: BitOrder,
ChunksMut<'a, T, O>: DoubleEndedIterator<Item = &'a mut BitSlice<<T as BitStore>::Alias, O>>,
impl<'a, T, O> DoubleEndedIterator for Iter<'a, T, O>where
T: 'a + BitStore,
O: BitOrder,
impl<'a, T, O> DoubleEndedIterator for IterMut<'a, T, O>where
T: 'a + BitStore,
O: BitOrder,
impl<'a, T, O> DoubleEndedIterator for IterMutNoAlias<'a, T, O>where
T: 'a + BitStore,
O: BitOrder,
IterMut<'a, T, O>: DoubleEndedIterator<Item = <usize as BitSliceIndex<'a, <T as BitStore>::Alias, O>>::Mut>,
impl<'a, T, O> DoubleEndedIterator for RChunksExactMutNoAlias<'a, T, O>where
T: 'a + BitStore,
O: BitOrder,
RChunksExactMut<'a, T, O>: DoubleEndedIterator<Item = &'a mut BitSlice<<T as BitStore>::Alias, O>>,
impl<'a, T, O> DoubleEndedIterator for RChunksMutNoAlias<'a, T, O>where
T: 'a + BitStore,
O: BitOrder,
RChunksMut<'a, T, O>: DoubleEndedIterator<Item = &'a mut BitSlice<<T as BitStore>::Alias, O>>,
impl<'a, T, O, P> DoubleEndedIterator for RSplit<'a, T, O, P>
impl<'a, T, O, P> DoubleEndedIterator for RSplitMut<'a, T, O, P>
impl<'a, T, O, P> DoubleEndedIterator for RSplitMutNoAlias<'a, T, O, P>where
T: 'a + BitStore,
O: BitOrder,
P: FnMut(usize, &bool) -> bool,
RSplitMut<'a, T, O, P>: DoubleEndedIterator<Item = &'a mut BitSlice<<T as BitStore>::Alias, O>>,
impl<'a, T, O, P> DoubleEndedIterator for RSplitNMutNoAlias<'a, T, O, P>where
T: 'a + BitStore,
O: BitOrder,
P: FnMut(usize, &bool) -> bool,
RSplitNMut<'a, T, O, P>: DoubleEndedIterator<Item = &'a mut BitSlice<<T as BitStore>::Alias, O>>,
impl<'a, T, O, P> DoubleEndedIterator for Split<'a, T, O, P>
impl<'a, T, O, P> DoubleEndedIterator for SplitInclusive<'a, T, O, P>
impl<'a, T, O, P> DoubleEndedIterator for SplitInclusiveMut<'a, T, O, P>
impl<'a, T, O, P> DoubleEndedIterator for SplitInclusiveMutNoAlias<'a, T, O, P>where
T: 'a + BitStore,
O: BitOrder,
P: FnMut(usize, &bool) -> bool,
SplitInclusiveMut<'a, T, O, P>: DoubleEndedIterator<Item = &'a mut BitSlice<<T as BitStore>::Alias, O>>,
impl<'a, T, O, P> DoubleEndedIterator for SplitMut<'a, T, O, P>
impl<'a, T, O, P> DoubleEndedIterator for SplitMutNoAlias<'a, T, O, P>where
T: 'a + BitStore,
O: BitOrder,
P: FnMut(usize, &bool) -> bool,
SplitMut<'a, T, O, P>: DoubleEndedIterator<Item = &'a mut BitSlice<<T as BitStore>::Alias, O>>,
impl<'a, T, O, P> DoubleEndedIterator for SplitNMutNoAlias<'a, T, O, P>where
T: 'a + BitStore,
O: BitOrder,
P: FnMut(usize, &bool) -> bool,
SplitNMut<'a, T, O, P>: DoubleEndedIterator<Item = &'a mut BitSlice<<T as BitStore>::Alias, O>>,
impl<'a, T, P> DoubleEndedIterator for ChunkBy<'a, T, P>
impl<'a, T, P> DoubleEndedIterator for ChunkByMut<'a, T, P>
impl<'a, T, P> DoubleEndedIterator for core::slice::iter::RSplit<'a, T, P>
impl<'a, T, P> DoubleEndedIterator for core::slice::iter::RSplitMut<'a, T, P>
impl<'a, T, P> DoubleEndedIterator for core::slice::iter::Split<'a, T, P>
impl<'a, T, P> DoubleEndedIterator for core::slice::iter::SplitInclusive<'a, T, P>
impl<'a, T, P> DoubleEndedIterator for core::slice::iter::SplitInclusiveMut<'a, T, P>
impl<'a, T, P> DoubleEndedIterator for core::slice::iter::SplitMut<'a, T, P>
impl<'a, T, R> DoubleEndedIterator for Overlapping<'a, T, R>
impl<'a, T, R> DoubleEndedIterator for Overlapping<'a, T, R>
impl<'a, T, const CAP: usize> DoubleEndedIterator for arrayvec::arrayvec::Drain<'a, T, CAP>where
T: 'a,
impl<'a, T, const N: usize> DoubleEndedIterator for core::slice::iter::ArrayChunks<'a, T, N>
impl<'a, T, const N: usize> DoubleEndedIterator for ArrayChunksMut<'a, T, N>
impl<'a, T, const N: usize> DoubleEndedIterator for ArrayWindows<'a, T, N>
impl<'h> DoubleEndedIterator for Memchr2<'h>
impl<'h> DoubleEndedIterator for Memchr3<'h>
impl<'h> DoubleEndedIterator for Memchr<'h>
impl<'p, A> DoubleEndedIterator for TinyVecDrain<'p, A>where
A: Array,
impl<'p, A, I> DoubleEndedIterator for ArrayVecSplice<'p, A, I>where
A: Array,
I: Iterator<Item = <A as Array>::Item> + DoubleEndedIterator,
impl<'p, A, I> DoubleEndedIterator for TinyVecSplice<'p, A, I>where
A: Array,
I: Iterator<Item = <A as Array>::Item> + DoubleEndedIterator,
impl<A> DoubleEndedIterator for core::ops::range::Range<A>where
A: Step,
impl<A> DoubleEndedIterator for core::ops::range::RangeInclusive<A>where
A: Step,
impl<A> DoubleEndedIterator for core::option::IntoIter<A>
impl<A> DoubleEndedIterator for num_iter::Range<A>
Integer
is required to ensure the range will be the same regardless of
the direction it is consumed.
impl<A> DoubleEndedIterator for num_iter::RangeInclusive<A>
impl<A> DoubleEndedIterator for Repeat<A>where
A: Clone,
impl<A> DoubleEndedIterator for tor_hsservice::internal_prelude::iter::RepeatN<A>where
A: Clone,
impl<A> DoubleEndedIterator for ArrayVecIterator<A>where
A: Array,
impl<A> DoubleEndedIterator for IntoIter<A>where
A: Array,
impl<A> DoubleEndedIterator for RepeatN<A>where
A: Clone,
impl<A> DoubleEndedIterator for TinyVecIterator<A>where
A: Array,
impl<A> DoubleEndedIterator for Zip<(A,)>where
A: DoubleEndedIterator + ExactSizeIterator,
impl<A, B> DoubleEndedIterator for Chain<A, B>
impl<A, B> DoubleEndedIterator for tor_hsservice::internal_prelude::iter::Zip<A, B>
impl<A, B> DoubleEndedIterator for Zip<(A, B)>
impl<A, B, C> DoubleEndedIterator for Zip<(A, B, C)>where
A: DoubleEndedIterator + ExactSizeIterator,
B: DoubleEndedIterator + ExactSizeIterator,
C: DoubleEndedIterator + ExactSizeIterator,
impl<A, B, C, D> DoubleEndedIterator for Zip<(A, B, C, D)>where
A: DoubleEndedIterator + ExactSizeIterator,
B: DoubleEndedIterator + ExactSizeIterator,
C: DoubleEndedIterator + ExactSizeIterator,
D: DoubleEndedIterator + ExactSizeIterator,
impl<A, B, C, D, E> DoubleEndedIterator for Zip<(A, B, C, D, E)>where
A: DoubleEndedIterator + ExactSizeIterator,
B: DoubleEndedIterator + ExactSizeIterator,
C: DoubleEndedIterator + ExactSizeIterator,
D: DoubleEndedIterator + ExactSizeIterator,
E: DoubleEndedIterator + ExactSizeIterator,
impl<A, B, C, D, E, F> DoubleEndedIterator for Zip<(A, B, C, D, E, F)>
impl<A, B, C, D, E, F, G> DoubleEndedIterator for Zip<(A, B, C, D, E, F, G)>where
A: DoubleEndedIterator + ExactSizeIterator,
B: DoubleEndedIterator + ExactSizeIterator,
C: DoubleEndedIterator + ExactSizeIterator,
D: DoubleEndedIterator + ExactSizeIterator,
E: DoubleEndedIterator + ExactSizeIterator,
F: DoubleEndedIterator + ExactSizeIterator,
G: DoubleEndedIterator + ExactSizeIterator,
impl<A, B, C, D, E, F, G, H> DoubleEndedIterator for Zip<(A, B, C, D, E, F, G, H)>where
A: DoubleEndedIterator + ExactSizeIterator,
B: DoubleEndedIterator + ExactSizeIterator,
C: DoubleEndedIterator + ExactSizeIterator,
D: DoubleEndedIterator + ExactSizeIterator,
E: DoubleEndedIterator + ExactSizeIterator,
F: DoubleEndedIterator + ExactSizeIterator,
G: DoubleEndedIterator + ExactSizeIterator,
H: DoubleEndedIterator + ExactSizeIterator,
impl<A, B, C, D, E, F, G, H, I> DoubleEndedIterator for Zip<(A, B, C, D, E, F, G, H, I)>where
A: DoubleEndedIterator + ExactSizeIterator,
B: DoubleEndedIterator + ExactSizeIterator,
C: DoubleEndedIterator + ExactSizeIterator,
D: DoubleEndedIterator + ExactSizeIterator,
E: DoubleEndedIterator + ExactSizeIterator,
F: DoubleEndedIterator + ExactSizeIterator,
G: DoubleEndedIterator + ExactSizeIterator,
H: DoubleEndedIterator + ExactSizeIterator,
I: DoubleEndedIterator + ExactSizeIterator,
impl<A, B, C, D, E, F, G, H, I, J> DoubleEndedIterator for Zip<(A, B, C, D, E, F, G, H, I, J)>where
A: DoubleEndedIterator + ExactSizeIterator,
B: DoubleEndedIterator + ExactSizeIterator,
C: DoubleEndedIterator + ExactSizeIterator,
D: DoubleEndedIterator + ExactSizeIterator,
E: DoubleEndedIterator + ExactSizeIterator,
F: DoubleEndedIterator + ExactSizeIterator,
G: DoubleEndedIterator + ExactSizeIterator,
H: DoubleEndedIterator + ExactSizeIterator,
I: DoubleEndedIterator + ExactSizeIterator,
J: DoubleEndedIterator + ExactSizeIterator,
impl<A, B, C, D, E, F, G, H, I, J, K> DoubleEndedIterator for Zip<(A, B, C, D, E, F, G, H, I, J, K)>where
A: DoubleEndedIterator + ExactSizeIterator,
B: DoubleEndedIterator + ExactSizeIterator,
C: DoubleEndedIterator + ExactSizeIterator,
D: DoubleEndedIterator + ExactSizeIterator,
E: DoubleEndedIterator + ExactSizeIterator,
F: DoubleEndedIterator + ExactSizeIterator,
G: DoubleEndedIterator + ExactSizeIterator,
H: DoubleEndedIterator + ExactSizeIterator,
I: DoubleEndedIterator + ExactSizeIterator,
J: DoubleEndedIterator + ExactSizeIterator,
K: DoubleEndedIterator + ExactSizeIterator,
impl<A, B, C, D, E, F, G, H, I, J, K, L> DoubleEndedIterator for Zip<(A, B, C, D, E, F, G, H, I, J, K, L)>where
A: DoubleEndedIterator + ExactSizeIterator,
B: DoubleEndedIterator + ExactSizeIterator,
C: DoubleEndedIterator + ExactSizeIterator,
D: DoubleEndedIterator + ExactSizeIterator,
E: DoubleEndedIterator + ExactSizeIterator,
F: DoubleEndedIterator + ExactSizeIterator,
G: DoubleEndedIterator + ExactSizeIterator,
H: DoubleEndedIterator + ExactSizeIterator,
I: DoubleEndedIterator + ExactSizeIterator,
J: DoubleEndedIterator + ExactSizeIterator,
K: DoubleEndedIterator + ExactSizeIterator,
L: DoubleEndedIterator + ExactSizeIterator,
impl<A, F> DoubleEndedIterator for OnceWith<F>where
F: FnOnce() -> A,
impl<A, O> DoubleEndedIterator for IntoIter<A, O>where
A: BitViewSized,
O: BitOrder,
impl<B, I, F> DoubleEndedIterator for FilterMap<I, F>
impl<B, I, F> DoubleEndedIterator for Map<I, F>
impl<I> DoubleEndedIterator for ByRefSized<'_, I>where
I: DoubleEndedIterator,
impl<I> DoubleEndedIterator for Enumerate<I>where
I: ExactSizeIterator + DoubleEndedIterator,
impl<I> DoubleEndedIterator for Fuse<I>where
I: DoubleEndedIterator,
impl<I> DoubleEndedIterator for Peekable<I>where
I: DoubleEndedIterator,
impl<I> DoubleEndedIterator for Rev<I>where
I: DoubleEndedIterator,
impl<I> DoubleEndedIterator for Skip<I>where
I: DoubleEndedIterator + ExactSizeIterator,
impl<I> DoubleEndedIterator for StepBy<I>where
I: DoubleEndedIterator + ExactSizeIterator,
impl<I> DoubleEndedIterator for Take<I>where
I: DoubleEndedIterator + ExactSizeIterator,
impl<I> DoubleEndedIterator for Bidi<I>where
I: DoubleEndedIterator,
impl<I> DoubleEndedIterator for RcIter<I>where
I: DoubleEndedIterator,
impl<I> DoubleEndedIterator for Unique<I>
impl<I, A> DoubleEndedIterator for alloc::boxed::Box<I, A>
impl<I, A> DoubleEndedIterator for alloc::vec::splice::Splice<'_, I, A>
impl<I, A> DoubleEndedIterator for Box<I, A>where
I: DoubleEndedIterator + ?Sized,
A: Allocator,
impl<I, A> DoubleEndedIterator for Splice<'_, I, A>where
I: Iterator,
A: Allocator,
impl<I, F> DoubleEndedIterator for Inspect<I, F>
impl<I, F> DoubleEndedIterator for PadUsing<I, F>
impl<I, F> DoubleEndedIterator for Positions<I, F>
impl<I, F> DoubleEndedIterator for Update<I, F>
impl<I, K, V, S> DoubleEndedIterator for Splice<'_, I, K, V, S>
impl<I, P> DoubleEndedIterator for Filter<I, P>
impl<I, T, E> DoubleEndedIterator for FlattenOk<I, T, E>where
I: DoubleEndedIterator<Item = Result<T, E>>,
T: IntoIterator,
<T as IntoIterator>::IntoIter: DoubleEndedIterator,
impl<I, T, S> DoubleEndedIterator for Splice<'_, I, T, S>
impl<I, U> DoubleEndedIterator for Flatten<I>where
I: DoubleEndedIterator,
<I as Iterator>::Item: IntoIterator<IntoIter = U, Item = <U as Iterator>::Item>,
U: DoubleEndedIterator,
impl<I, U, F> DoubleEndedIterator for FlatMap<I, U, F>where
I: DoubleEndedIterator,
F: FnMut(<I as Iterator>::Item) -> U,
U: IntoIterator,
<U as IntoIterator>::IntoIter: DoubleEndedIterator,
impl<I, V, F> DoubleEndedIterator for UniqueBy<I, V, F>
impl<I, const N: usize> DoubleEndedIterator for tor_hsservice::internal_prelude::iter::ArrayChunks<I, N>where
I: DoubleEndedIterator + ExactSizeIterator,
impl<K> DoubleEndedIterator for IntoIter<K>
impl<K> DoubleEndedIterator for IntoIter<K>
impl<K, V> DoubleEndedIterator for Drain<'_, K, V>
impl<K, V> DoubleEndedIterator for IntoIter<K, V>
impl<K, V> DoubleEndedIterator for IntoIter<K, V>
impl<K, V> DoubleEndedIterator for IntoIter<K, V>
impl<K, V> DoubleEndedIterator for IntoKeys<K, V>
impl<K, V> DoubleEndedIterator for IntoValues<K, V>
impl<K, V> DoubleEndedIterator for Iter<'_, K, V>
impl<K, V> DoubleEndedIterator for IterMut<'_, K, V>
impl<K, V> DoubleEndedIterator for Keys<'_, K, V>
impl<K, V> DoubleEndedIterator for Values<'_, K, V>
impl<K, V> DoubleEndedIterator for ValuesMut<'_, K, V>
impl<K, V, A> DoubleEndedIterator for alloc::collections::btree::map::IntoIter<K, V, A>
impl<K, V, A> DoubleEndedIterator for alloc::collections::btree::map::IntoKeys<K, V, A>
impl<K, V, A> DoubleEndedIterator for alloc::collections::btree::map::IntoValues<K, V, A>
impl<L, R> DoubleEndedIterator for Either<L, R>
impl<L, R> DoubleEndedIterator for IterEither<L, R>where
L: DoubleEndedIterator,
R: DoubleEndedIterator,
impl<M, T, O> DoubleEndedIterator for BitPtrRange<M, T, O>where
M: Mutability,
T: BitStore,
O: BitOrder,
impl<T> DoubleEndedIterator for core::result::IntoIter<T>
impl<T> DoubleEndedIterator for openssl::stack::IntoIter<T>where
T: Stackable,
impl<T> DoubleEndedIterator for Empty<T>
impl<T> DoubleEndedIterator for Once<T>
impl<T> DoubleEndedIterator for AncillaryIter<'_, T>
impl<T> DoubleEndedIterator for Drain<'_, T>
impl<T> DoubleEndedIterator for Drain<'_, T>
impl<T> DoubleEndedIterator for IntoIter<T>
impl<T> DoubleEndedIterator for IntoIter<T>
impl<T> DoubleEndedIterator for IntoIter<T>
impl<T> DoubleEndedIterator for Iter<'_, T>
impl<T> DoubleEndedIterator for Iter<'_, T>
impl<T> DoubleEndedIterator for IterMut<'_, T>
impl<T, A> DoubleEndedIterator for alloc::collections::binary_heap::Drain<'_, T, A>where
A: Allocator,
impl<T, A> DoubleEndedIterator for alloc::collections::binary_heap::IntoIter<T, A>where
A: Allocator,
impl<T, A> DoubleEndedIterator for alloc::collections::btree::set::IntoIter<T, A>
impl<T, A> DoubleEndedIterator for alloc::collections::linked_list::IntoIter<T, A>where
A: Allocator,
impl<T, A> DoubleEndedIterator for alloc::collections::vec_deque::drain::Drain<'_, T, A>where
A: Allocator,
impl<T, A> DoubleEndedIterator for alloc::collections::vec_deque::into_iter::IntoIter<T, A>where
A: Allocator,
impl<T, A> DoubleEndedIterator for alloc::vec::drain::Drain<'_, T, A>where
A: Allocator,
impl<T, A> DoubleEndedIterator for alloc::vec::into_iter::IntoIter<T, A>where
A: Allocator,
impl<T, A> DoubleEndedIterator for Drain<'_, T, A>where
A: Allocator,
impl<T, A> DoubleEndedIterator for IntoIter<T, A>where
A: Allocator,
impl<T, N> DoubleEndedIterator for GenericArrayIter<T, N>where
N: ArrayLength<T>,
impl<T, O> DoubleEndedIterator for BitValIter<'_, T, O>where
T: BitStore,
O: BitOrder,
impl<T, O> DoubleEndedIterator for Chunks<'_, T, O>where
T: BitStore,
O: BitOrder,
impl<T, O> DoubleEndedIterator for ChunksExact<'_, T, O>where
T: BitStore,
O: BitOrder,
impl<T, O> DoubleEndedIterator for ChunksExactMut<'_, T, O>where
T: BitStore,
O: BitOrder,
impl<T, O> DoubleEndedIterator for ChunksMut<'_, T, O>where
T: BitStore,
O: BitOrder,
impl<T, O> DoubleEndedIterator for Domain<'_, Const, T, O>where
T: BitStore,
O: BitOrder,
impl<T, O> DoubleEndedIterator for Drain<'_, T, O>where
T: BitStore,
O: BitOrder,
tarpaulin_include
only.impl<T, O> DoubleEndedIterator for IntoIter<T, O>where
T: BitStore,
O: BitOrder,
impl<T, O> DoubleEndedIterator for IterOnes<'_, T, O>where
T: BitStore,
O: BitOrder,
impl<T, O> DoubleEndedIterator for IterZeros<'_, T, O>where
T: BitStore,
O: BitOrder,
impl<T, O> DoubleEndedIterator for RChunks<'_, T, O>where
T: BitStore,
O: BitOrder,
impl<T, O> DoubleEndedIterator for RChunksExact<'_, T, O>where
T: BitStore,
O: BitOrder,
impl<T, O> DoubleEndedIterator for RChunksExactMut<'_, T, O>where
T: BitStore,
O: BitOrder,
impl<T, O> DoubleEndedIterator for RChunksMut<'_, T, O>where
T: BitStore,
O: BitOrder,
impl<T, O> DoubleEndedIterator for Windows<'_, T, O>where
T: BitStore,
O: BitOrder,
impl<T, O, I> DoubleEndedIterator for Splice<'_, T, O, I>
tarpaulin_include
only.