Struct snarkvm_wasm::iter::Map
1.0.0 · source · pub struct Map<I, F> { /* private fields */ }
Expand description
An iterator that maps the values of iter
with f
.
This struct
is created by the map
method on Iterator
. See its
documentation for more.
Notes about side effects
The map
iterator implements DoubleEndedIterator
, meaning that
you can also map
backwards:
let v: Vec<i32> = [1, 2, 3].into_iter().map(|x| x + 1).rev().collect();
assert_eq!(v, [4, 3, 2]);
But if your closure has state, iterating backwards may act in a way you do not expect. Let’s go through an example. First, in the forward direction:
let mut c = 0;
for pair in ['a', 'b', 'c'].into_iter()
.map(|letter| { c += 1; (letter, c) }) {
println!("{pair:?}");
}
This will print ('a', 1), ('b', 2), ('c', 3)
.
Now consider this twist where we add a call to rev
. This version will
print ('c', 1), ('b', 2), ('a', 3)
. Note that the letters are reversed,
but the values of the counter still go in order. This is because map()
is
still being called lazily on each item, but we are popping items off the
back of the vector now, instead of shifting them from the front.
let mut c = 0;
for pair in ['a', 'b', 'c'].into_iter()
.map(|letter| { c += 1; (letter, c) })
.rev() {
println!("{pair:?}");
}
Trait Implementations
sourceimpl<I, F> Clone for Map<I, F>where
I: Clone,
F: Clone,
impl<I, F> Clone for Map<I, F>where
I: Clone,
F: Clone,
sourcefn clone(&self) -> Map<I, F>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F>where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
fn clone(&self) -> Map<I, F>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F>where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresourceimpl<B, I, F> DoubleEndedIterator for Map<I, F>where
I: DoubleEndedIterator,
F: FnMut(<I as Iterator>::Item) -> B,
impl<B, I, F> DoubleEndedIterator for Map<I, F>where
I: DoubleEndedIterator,
F: FnMut(<I as Iterator>::Item) -> B,
sourcefn next_back(&mut self) -> Option<B>
fn next_back(&mut self) -> Option<B>
sourcefn try_rfold<Acc, G, R>(&mut self, init: Acc, g: G) -> Rwhere
Map<I, F>: Sized,
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> R,
R: Try<Output = Acc>,
fn try_rfold<Acc, G, R>(&mut self, init: Acc, g: G) -> Rwhere
Map<I, F>: Sized,
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> R,
R: Try<Output = Acc>,
Iterator::try_fold()
: it takes
elements starting from the back of the iterator. Read moresourcefn rfold<Acc, G>(self, init: Acc, g: G) -> Accwhere
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> Acc,
fn rfold<Acc, G>(self, init: Acc, g: G) -> Accwhere
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> Acc,
sourcefn advance_back_by(&mut self, n: usize) -> Result<(), usize>
fn advance_back_by(&mut self, n: usize) -> Result<(), usize>
iter_advance_by
)n
elements. Read moresourceimpl<B, I, F> ExactSizeIterator for Map<I, F>where
I: ExactSizeIterator,
F: FnMut(<I as Iterator>::Item) -> B,
impl<B, I, F> ExactSizeIterator for Map<I, F>where
I: ExactSizeIterator,
F: FnMut(<I as Iterator>::Item) -> B,
sourceimpl<B, I, F> Iterator for Map<I, F>where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B,
impl<B, I, F> Iterator for Map<I, F>where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B,
type Item = B
type Item = B
sourcefn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
sourcefn try_fold<Acc, G, R>(&mut self, init: Acc, g: G) -> Rwhere
Map<I, F>: Sized,
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> R,
R: Try<Output = Acc>,
fn try_fold<Acc, G, R>(&mut self, init: Acc, g: G) -> Rwhere
Map<I, F>: Sized,
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> R,
R: Try<Output = Acc>,
sourcefn fold<Acc, G>(self, init: Acc, g: G) -> Accwhere
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> Acc,
fn fold<Acc, G>(self, init: Acc, g: G) -> Accwhere
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> Acc,
sourcefn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
iter_next_chunk
)N
values. Read moresourcefn count(self) -> usizewhere
Self: Sized,
fn count(self) -> usizewhere
Self: Sized,
sourcefn last(self) -> Option<Self::Item>where
Self: Sized,
fn last(self) -> Option<Self::Item>where
Self: Sized,
sourcefn advance_by(&mut self, n: usize) -> Result<(), usize>
fn advance_by(&mut self, n: usize) -> Result<(), usize>
iter_advance_by
)n
elements. Read moresourcefn nth(&mut self, n: usize) -> Option<Self::Item>
fn nth(&mut self, n: usize) -> Option<Self::Item>
n
th element of the iterator. Read more1.28.0 · sourcefn step_by(self, step: usize) -> StepBy<Self>ⓘNotable traits for StepBy<I>impl<I> Iterator for StepBy<I>where
I: Iterator, type Item = <I as Iterator>::Item;
where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>ⓘNotable traits for StepBy<I>impl<I> Iterator for StepBy<I>where
I: Iterator, type Item = <I as Iterator>::Item;
where
Self: Sized,
I: Iterator, type Item = <I as Iterator>::Item;
sourcefn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Chain<A, B>impl<A, B> Iterator for Chain<A, B>where
A: Iterator,
B: Iterator<Item = <A as Iterator>::Item>, type Item = <A as Iterator>::Item;
where
Self: Sized,
U: IntoIterator<Item = Self::Item>,
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Chain<A, B>impl<A, B> Iterator for Chain<A, B>where
A: Iterator,
B: Iterator<Item = <A as Iterator>::Item>, type Item = <A as Iterator>::Item;
where
Self: Sized,
U: IntoIterator<Item = Self::Item>,
A: Iterator,
B: Iterator<Item = <A as Iterator>::Item>, type Item = <A as Iterator>::Item;
sourcefn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Zip<A, B>impl<A, B> Iterator for Zip<A, B>where
A: Iterator,
B: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item);
where
Self: Sized,
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Zip<A, B>impl<A, B> Iterator for Zip<A, B>where
A: Iterator,
B: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item);
where
Self: Sized,
U: IntoIterator,
A: Iterator,
B: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item);
sourcefn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>ⓘNotable traits for IntersperseWith<I, G>impl<I, G> Iterator for IntersperseWith<I, G>where
I: Iterator,
G: FnMut() -> <I as Iterator>::Item, type Item = <I as Iterator>::Item;
where
Self: Sized,
G: FnMut() -> Self::Item,
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>ⓘNotable traits for IntersperseWith<I, G>impl<I, G> Iterator for IntersperseWith<I, G>where
I: Iterator,
G: FnMut() -> <I as Iterator>::Item, type Item = <I as Iterator>::Item;
where
Self: Sized,
G: FnMut() -> Self::Item,
I: Iterator,
G: FnMut() -> <I as Iterator>::Item, type Item = <I as Iterator>::Item;
iter_intersperse
)separator
between adjacent items of the original iterator. Read moresourcefn map<B, F>(self, f: F) -> Map<Self, F>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F>where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
Self: Sized,
F: FnMut(Self::Item) -> B,
fn map<B, F>(self, f: F) -> Map<Self, F>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F>where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
Self: Sized,
F: FnMut(Self::Item) -> B,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
1.21.0 · sourcefn for_each<F>(self, f: F)where
Self: Sized,
F: FnMut(Self::Item),
fn for_each<F>(self, f: F)where
Self: Sized,
F: FnMut(Self::Item),
sourcefn filter<P>(self, predicate: P) -> Filter<Self, P>ⓘNotable traits for Filter<I, P>impl<I, P> Iterator for Filter<I, P>where
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;
where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn filter<P>(self, predicate: P) -> Filter<Self, P>ⓘNotable traits for Filter<I, P>impl<I, P> Iterator for Filter<I, P>where
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;
where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;
sourcefn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>ⓘNotable traits for FilterMap<I, F>impl<B, I, F> Iterator for FilterMap<I, F>where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> Option<B>, type Item = B;
where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>ⓘNotable traits for FilterMap<I, F>impl<B, I, F> Iterator for FilterMap<I, F>where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> Option<B>, type Item = B;
where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> Option<B>, type Item = B;
sourcefn enumerate(self) -> Enumerate<Self>ⓘNotable traits for Enumerate<I>impl<I> Iterator for Enumerate<I>where
I: Iterator, type Item = (usize, <I as Iterator>::Item);
where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>ⓘNotable traits for Enumerate<I>impl<I> Iterator for Enumerate<I>where
I: Iterator, type Item = (usize, <I as Iterator>::Item);
where
Self: Sized,
I: Iterator, type Item = (usize, <I as Iterator>::Item);
sourcefn peekable(self) -> Peekable<Self>ⓘNotable traits for Peekable<I>impl<I> Iterator for Peekable<I>where
I: Iterator, type Item = <I as Iterator>::Item;
where
Self: Sized,
fn peekable(self) -> Peekable<Self>ⓘNotable traits for Peekable<I>impl<I> Iterator for Peekable<I>where
I: Iterator, type Item = <I as Iterator>::Item;
where
Self: Sized,
I: Iterator, type Item = <I as Iterator>::Item;
sourcefn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>ⓘNotable traits for SkipWhile<I, P>impl<I, P> Iterator for SkipWhile<I, P>where
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;
where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>ⓘNotable traits for SkipWhile<I, P>impl<I, P> Iterator for SkipWhile<I, P>where
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;
where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;
sourcefn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>ⓘNotable traits for TakeWhile<I, P>impl<I, P> Iterator for TakeWhile<I, P>where
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;
where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>ⓘNotable traits for TakeWhile<I, P>impl<I, P> Iterator for TakeWhile<I, P>where
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;
where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;
1.57.0 · sourcefn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>ⓘNotable traits for MapWhile<I, P>impl<B, I, P> Iterator for MapWhile<I, P>where
I: Iterator,
P: FnMut(<I as Iterator>::Item) -> Option<B>, type Item = B;
where
Self: Sized,
P: FnMut(Self::Item) -> Option<B>,
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>ⓘNotable traits for MapWhile<I, P>impl<B, I, P> Iterator for MapWhile<I, P>where
I: Iterator,
P: FnMut(<I as Iterator>::Item) -> Option<B>, type Item = B;
where
Self: Sized,
P: FnMut(Self::Item) -> Option<B>,
I: Iterator,
P: FnMut(<I as Iterator>::Item) -> Option<B>, type Item = B;
sourcefn skip(self, n: usize) -> Skip<Self>ⓘNotable traits for Skip<I>impl<I> Iterator for Skip<I>where
I: Iterator, type Item = <I as Iterator>::Item;
where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>ⓘNotable traits for Skip<I>impl<I> Iterator for Skip<I>where
I: Iterator, type Item = <I as Iterator>::Item;
where
Self: Sized,
I: Iterator, type Item = <I as Iterator>::Item;
n
elements. Read moresourcefn take(self, n: usize) -> Take<Self>ⓘNotable traits for Take<I>impl<I> Iterator for Take<I>where
I: Iterator, type Item = <I as Iterator>::Item;
where
Self: Sized,
fn take(self, n: usize) -> Take<Self>ⓘNotable traits for Take<I>impl<I> Iterator for Take<I>where
I: Iterator, type Item = <I as Iterator>::Item;
where
Self: Sized,
I: Iterator, type Item = <I as Iterator>::Item;
n
elements, or fewer
if the underlying iterator ends sooner. Read moresourcefn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>ⓘNotable traits for Scan<I, St, F>impl<B, I, St, F> Iterator for Scan<I, St, F>where
I: Iterator,
F: FnMut(&mut St, <I as Iterator>::Item) -> Option<B>, type Item = B;
where
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>ⓘNotable traits for Scan<I, St, F>impl<B, I, St, F> Iterator for Scan<I, St, F>where
I: Iterator,
F: FnMut(&mut St, <I as Iterator>::Item) -> Option<B>, type Item = B;
where
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
I: Iterator,
F: FnMut(&mut St, <I as Iterator>::Item) -> Option<B>, type Item = B;
sourcefn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>ⓘNotable traits for FlatMap<I, U, F>impl<I, U, F> Iterator for FlatMap<I, U, F>where
I: Iterator,
U: IntoIterator,
F: FnMut(<I as Iterator>::Item) -> U, type Item = <U as IntoIterator>::Item;
where
Self: Sized,
U: IntoIterator,
F: FnMut(Self::Item) -> U,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>ⓘNotable traits for FlatMap<I, U, F>impl<I, U, F> Iterator for FlatMap<I, U, F>where
I: Iterator,
U: IntoIterator,
F: FnMut(<I as Iterator>::Item) -> U, type Item = <U as IntoIterator>::Item;
where
Self: Sized,
U: IntoIterator,
F: FnMut(Self::Item) -> U,
I: Iterator,
U: IntoIterator,
F: FnMut(<I as Iterator>::Item) -> U, type Item = <U as IntoIterator>::Item;
sourcefn fuse(self) -> Fuse<Self>ⓘNotable traits for Fuse<I>impl<I> Iterator for Fuse<I>where
I: Iterator, type Item = <I as Iterator>::Item;
where
Self: Sized,
fn fuse(self) -> Fuse<Self>ⓘNotable traits for Fuse<I>impl<I> Iterator for Fuse<I>where
I: Iterator, type Item = <I as Iterator>::Item;
where
Self: Sized,
I: Iterator, type Item = <I as Iterator>::Item;
sourcefn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘNotable traits for Inspect<I, F>impl<I, F> Iterator for Inspect<I, F>where
I: Iterator,
F: FnMut(&<I as Iterator>::Item), type Item = <I as Iterator>::Item;
where
Self: Sized,
F: FnMut(&Self::Item),
fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘNotable traits for Inspect<I, F>impl<I, F> Iterator for Inspect<I, F>where
I: Iterator,
F: FnMut(&<I as Iterator>::Item), type Item = <I as Iterator>::Item;
where
Self: Sized,
F: FnMut(&Self::Item),
I: Iterator,
F: FnMut(&<I as Iterator>::Item), type Item = <I as Iterator>::Item;
sourcefn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
sourcefn collect<B>(self) -> Bwhere
B: FromIterator<Self::Item>,
Self: Sized,
fn collect<B>(self) -> Bwhere
B: FromIterator<Self::Item>,
Self: Sized,
sourcefn collect_into<E>(self, collection: &mut E) -> &mut Ewhere
E: Extend<Self::Item>,
Self: Sized,
fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere
E: Extend<Self::Item>,
Self: Sized,
iter_collect_into
)sourcefn partition<B, F>(self, f: F) -> (B, B)where
Self: Sized,
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
fn partition<B, F>(self, f: F) -> (B, B)where
Self: Sized,
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
sourcefn is_partitioned<P>(self, predicate: P) -> boolwhere
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn is_partitioned<P>(self, predicate: P) -> boolwhere
Self: Sized,
P: FnMut(Self::Item) -> bool,
iter_is_partitioned
)true
precede all those that return false
. Read more1.27.0 · sourcefn try_for_each<F, R>(&mut self, f: F) -> Rwhere
Self: Sized,
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
fn try_for_each<F, R>(&mut self, f: F) -> Rwhere
Self: Sized,
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
1.51.0 · sourcefn reduce<F>(self, f: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn reduce<F>(self, f: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Self::Item,
sourcefn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> R,
R: Try<Output = Self::Item>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
fn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> R,
R: Try<Output = Self::Item>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
iterator_try_reduce
)sourcefn all<F>(&mut self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn all<F>(&mut self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> bool,
sourcefn any<F>(&mut self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> bool,
sourcefn find<P>(&mut self, predicate: P) -> Option<Self::Item>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
1.30.0 · sourcefn find_map<B, F>(&mut self, f: F) -> Option<B>where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn find_map<B, F>(&mut self, f: F) -> Option<B>where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
sourcefn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere
Self: Sized,
F: FnMut(&Self::Item) -> R,
R: Try<Output = bool>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
fn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere
Self: Sized,
F: FnMut(&Self::Item) -> R,
R: Try<Output = bool>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
try_find
)sourcefn position<P>(&mut self, predicate: P) -> Option<usize>where
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn position<P>(&mut self, predicate: P) -> Option<usize>where
Self: Sized,
P: FnMut(Self::Item) -> bool,
1.6.0 · sourcefn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
Self: Sized,
F: FnMut(&Self::Item) -> B,
1.15.0 · sourcefn max_by<F>(self, compare: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn max_by<F>(self, compare: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.6.0 · sourcefn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
Self: Sized,
F: FnMut(&Self::Item) -> B,
1.15.0 · sourcefn min_by<F>(self, compare: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by<F>(self, compare: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
sourcefn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Sized + Iterator<Item = (A, B)>,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Sized + Iterator<Item = (A, B)>,
1.36.0 · sourcefn copied<'a, T>(self) -> Copied<Self>ⓘNotable traits for Copied<I>impl<'a, I, T> Iterator for Copied<I>where
T: 'a + Copy,
I: Iterator<Item = &'a T>, type Item = T;
where
T: 'a + Copy,
Self: Sized + Iterator<Item = &'a T>,
fn copied<'a, T>(self) -> Copied<Self>ⓘNotable traits for Copied<I>impl<'a, I, T> Iterator for Copied<I>where
T: 'a + Copy,
I: Iterator<Item = &'a T>, type Item = T;
where
T: 'a + Copy,
Self: Sized + Iterator<Item = &'a T>,
T: 'a + Copy,
I: Iterator<Item = &'a T>, type Item = T;
sourcefn cloned<'a, T>(self) -> Cloned<Self>ⓘNotable traits for Cloned<I>impl<'a, I, T> Iterator for Cloned<I>where
T: 'a + Clone,
I: Iterator<Item = &'a T>, type Item = T;
where
T: 'a + Clone,
Self: Sized + Iterator<Item = &'a T>,
fn cloned<'a, T>(self) -> Cloned<Self>ⓘNotable traits for Cloned<I>impl<'a, I, T> Iterator for Cloned<I>where
T: 'a + Clone,
I: Iterator<Item = &'a T>, type Item = T;
where
T: 'a + Clone,
Self: Sized + Iterator<Item = &'a T>,
T: 'a + Clone,
I: Iterator<Item = &'a T>, type Item = T;
sourcefn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>ⓘNotable traits for ArrayChunks<I, N>impl<I, const N: usize> Iterator for ArrayChunks<I, N>where
I: Iterator, type Item = [<I as Iterator>::Item; N];
where
Self: Sized,
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>ⓘNotable traits for ArrayChunks<I, N>impl<I, const N: usize> Iterator for ArrayChunks<I, N>where
I: Iterator, type Item = [<I as Iterator>::Item; N];
where
Self: Sized,
I: Iterator, type Item = [<I as Iterator>::Item; N];
iter_array_chunks
)N
elements of the iterator at a time. Read more1.11.0 · sourcefn sum<S>(self) -> Swhere
Self: Sized,
S: Sum<Self::Item>,
fn sum<S>(self) -> Swhere
Self: Sized,
S: Sum<Self::Item>,
1.11.0 · sourcefn product<P>(self) -> Pwhere
Self: Sized,
P: Product<Self::Item>,
fn product<P>(self) -> Pwhere
Self: Sized,
P: Product<Self::Item>,
sourcefn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read more1.5.0 · sourcefn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
sourcefn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read more1.5.0 · sourcefn eq<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Self: Sized,
fn eq<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Self: Sized,
sourcefn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
iter_order_by
)1.5.0 · sourcefn ne<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Self: Sized,
fn ne<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Self: Sized,
1.5.0 · sourcefn lt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn lt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
Iterator
are lexicographically
less than those of another. Read more1.5.0 · sourcefn le<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn le<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
Iterator
are lexicographically
less or equal to those of another. Read more1.5.0 · sourcefn gt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn gt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
Iterator
are lexicographically
greater than those of another. Read more1.5.0 · sourcefn ge<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn ge<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
Iterator
are lexicographically
greater than or equal to those of another. Read moresourcefn is_sorted_by<F>(self, compare: F) -> boolwhere
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by<F>(self, compare: F) -> boolwhere
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
is_sorted
)sourcefn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
is_sorted
)impl<B, I, F> FusedIterator for Map<I, F>where
I: FusedIterator,
F: FnMut(<I as Iterator>::Item) -> B,
impl<B, I, F> TrustedLen for Map<I, F>where
I: TrustedLen,
F: FnMut(<I as Iterator>::Item) -> B,
Auto Trait Implementations
impl<I, F> RefUnwindSafe for Map<I, F>where
F: RefUnwindSafe,
I: RefUnwindSafe,
impl<I, F> Send for Map<I, F>where
F: Send,
I: Send,
impl<I, F> Sync for Map<I, F>where
F: Sync,
I: Sync,
impl<I, F> Unpin for Map<I, F>where
F: Unpin,
I: Unpin,
impl<I, F> UnwindSafe for Map<I, F>where
F: UnwindSafe,
I: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T>where
T: Future, type Output = <T as Future>::Output;
fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T>where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
sourcefn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T>where
T: Future, type Output = <T as Future>::Output;
fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T>where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
sourceimpl<I> IntoIterator for Iwhere
I: Iterator,
impl<I> IntoIterator for Iwhere
I: Iterator,
sourceimpl<I> IteratorRandom for Iwhere
I: Iterator,
impl<I> IteratorRandom for Iwhere
I: Iterator,
sourcefn choose<R>(self, rng: &mut R) -> Option<Self::Item>where
R: Rng + ?Sized,
fn choose<R>(self, rng: &mut R) -> Option<Self::Item>where
R: Rng + ?Sized,
sourcefn choose_stable<R>(self, rng: &mut R) -> Option<Self::Item>where
R: Rng + ?Sized,
fn choose_stable<R>(self, rng: &mut R) -> Option<Self::Item>where
R: Rng + ?Sized,
sourceimpl<T> Itertools for Twhere
T: Iterator + ?Sized,
impl<T> Itertools for Twhere
T: Iterator + ?Sized,
sourcefn interleave<J>(
self,
other: J
) -> Interleave<Self, <J as IntoIterator>::IntoIter>ⓘNotable traits for Interleave<I, J>impl<I, J> Iterator for Interleave<I, J>where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
J: IntoIterator<Item = Self::Item>,
Self: Sized,
fn interleave<J>(
self,
other: J
) -> Interleave<Self, <J as IntoIterator>::IntoIter>ⓘNotable traits for Interleave<I, J>impl<I, J> Iterator for Interleave<I, J>where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
J: IntoIterator<Item = Self::Item>,
Self: Sized,
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>, type Item = <I as Iterator>::Item;
sourcefn interleave_shortest<J>(
self,
other: J
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>ⓘNotable traits for InterleaveShortest<I, J>impl<I, J> Iterator for InterleaveShortest<I, J>where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
J: IntoIterator<Item = Self::Item>,
Self: Sized,
fn interleave_shortest<J>(
self,
other: J
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>ⓘNotable traits for InterleaveShortest<I, J>impl<I, J> Iterator for InterleaveShortest<I, J>where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
J: IntoIterator<Item = Self::Item>,
Self: Sized,
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>, type Item = <I as Iterator>::Item;
sourcefn intersperse(
self,
element: Self::Item
) -> IntersperseWith<Self, IntersperseElementSimple<Self::Item>>ⓘNotable traits for IntersperseWith<I, ElemF>impl<I, ElemF> Iterator for IntersperseWith<I, ElemF>where
I: Iterator,
ElemF: IntersperseElement<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
Self: Sized,
Self::Item: Clone,
fn intersperse(
self,
element: Self::Item
) -> IntersperseWith<Self, IntersperseElementSimple<Self::Item>>ⓘNotable traits for IntersperseWith<I, ElemF>impl<I, ElemF> Iterator for IntersperseWith<I, ElemF>where
I: Iterator,
ElemF: IntersperseElement<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
Self: Sized,
Self::Item: Clone,
I: Iterator,
ElemF: IntersperseElement<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
sourcefn intersperse_with<F>(self, element: F) -> IntersperseWith<Self, F>ⓘNotable traits for IntersperseWith<I, ElemF>impl<I, ElemF> Iterator for IntersperseWith<I, ElemF>where
I: Iterator,
ElemF: IntersperseElement<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
Self: Sized,
F: FnMut() -> Self::Item,
fn intersperse_with<F>(self, element: F) -> IntersperseWith<Self, F>ⓘNotable traits for IntersperseWith<I, ElemF>impl<I, ElemF> Iterator for IntersperseWith<I, ElemF>where
I: Iterator,
ElemF: IntersperseElement<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
Self: Sized,
F: FnMut() -> Self::Item,
I: Iterator,
ElemF: IntersperseElement<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
sourcefn zip_longest<J>(
self,
other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>ⓘNotable traits for ZipLongest<T, U>impl<T, U> Iterator for ZipLongest<T, U>where
T: Iterator,
U: Iterator, type Item = EitherOrBoth<<T as Iterator>::Item, <U as Iterator>::Item>;
where
J: IntoIterator,
Self: Sized,
fn zip_longest<J>(
self,
other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>ⓘNotable traits for ZipLongest<T, U>impl<T, U> Iterator for ZipLongest<T, U>where
T: Iterator,
U: Iterator, type Item = EitherOrBoth<<T as Iterator>::Item, <U as Iterator>::Item>;
where
J: IntoIterator,
Self: Sized,
T: Iterator,
U: Iterator, type Item = EitherOrBoth<<T as Iterator>::Item, <U as Iterator>::Item>;
sourcefn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>ⓘNotable traits for ZipEq<I, J>impl<I, J> Iterator for ZipEq<I, J>where
I: Iterator,
J: Iterator, type Item = (<I as Iterator>::Item, <J as Iterator>::Item);
where
J: IntoIterator,
Self: Sized,
fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>ⓘNotable traits for ZipEq<I, J>impl<I, J> Iterator for ZipEq<I, J>where
I: Iterator,
J: Iterator, type Item = (<I as Iterator>::Item, <J as Iterator>::Item);
where
J: IntoIterator,
Self: Sized,
I: Iterator,
J: Iterator, type Item = (<I as Iterator>::Item, <J as Iterator>::Item);
sourcefn batching<B, F>(self, f: F) -> Batching<Self, F>ⓘNotable traits for Batching<I, F>impl<B, F, I> Iterator for Batching<I, F>where
I: Iterator,
F: FnMut(&mut I) -> Option<B>, type Item = B;
where
F: FnMut(&mut Self) -> Option<B>,
Self: Sized,
fn batching<B, F>(self, f: F) -> Batching<Self, F>ⓘNotable traits for Batching<I, F>impl<B, F, I> Iterator for Batching<I, F>where
I: Iterator,
F: FnMut(&mut I) -> Option<B>, type Item = B;
where
F: FnMut(&mut Self) -> Option<B>,
Self: Sized,
I: Iterator,
F: FnMut(&mut I) -> Option<B>, type Item = B;
sourcefn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F>where
Self: Sized,
F: FnMut(&Self::Item) -> K,
K: PartialEq<K>,
fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F>where
Self: Sized,
F: FnMut(&Self::Item) -> K,
K: PartialEq<K>,
sourcefn chunks(self, size: usize) -> IntoChunks<Self>where
Self: Sized,
fn chunks(self, size: usize) -> IntoChunks<Self>where
Self: Sized,
sourcefn tuple_windows<T>(self) -> TupleWindows<Self, T>ⓘNotable traits for TupleWindows<I, T>impl<I, T> Iterator for TupleWindows<I, T>where
I: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple + Clone,
<T as TupleCollect>::Item: Clone, type Item = T;
where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
<T as TupleCollect>::Item: Clone,
fn tuple_windows<T>(self) -> TupleWindows<Self, T>ⓘNotable traits for TupleWindows<I, T>impl<I, T> Iterator for TupleWindows<I, T>where
I: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple + Clone,
<T as TupleCollect>::Item: Clone, type Item = T;
where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
<T as TupleCollect>::Item: Clone,
I: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple + Clone,
<T as TupleCollect>::Item: Clone, type Item = T;
sourcefn circular_tuple_windows<T>(self) -> CircularTupleWindows<Self, T>ⓘNotable traits for CircularTupleWindows<I, T>impl<I, T> Iterator for CircularTupleWindows<I, T>where
I: Iterator<Item = <T as TupleCollect>::Item> + Clone,
T: TupleCollect + Clone,
<T as TupleCollect>::Item: Clone, type Item = T;
where
Self: Sized + Clone + Iterator<Item = <T as TupleCollect>::Item> + ExactSizeIterator,
T: TupleCollect + Clone,
<T as TupleCollect>::Item: Clone,
fn circular_tuple_windows<T>(self) -> CircularTupleWindows<Self, T>ⓘNotable traits for CircularTupleWindows<I, T>impl<I, T> Iterator for CircularTupleWindows<I, T>where
I: Iterator<Item = <T as TupleCollect>::Item> + Clone,
T: TupleCollect + Clone,
<T as TupleCollect>::Item: Clone, type Item = T;
where
Self: Sized + Clone + Iterator<Item = <T as TupleCollect>::Item> + ExactSizeIterator,
T: TupleCollect + Clone,
<T as TupleCollect>::Item: Clone,
I: Iterator<Item = <T as TupleCollect>::Item> + Clone,
T: TupleCollect + Clone,
<T as TupleCollect>::Item: Clone, type Item = T;
sourcefn tuples<T>(self) -> Tuples<Self, T>ⓘNotable traits for Tuples<I, T>impl<I, T> Iterator for Tuples<I, T>where
I: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple, type Item = T;
where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn tuples<T>(self) -> Tuples<Self, T>ⓘNotable traits for Tuples<I, T>impl<I, T> Iterator for Tuples<I, T>where
I: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple, type Item = T;
where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
I: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple, type Item = T;
sourcefn tee(self) -> (Tee<Self>, Tee<Self>)where
Self: Sized,
Self::Item: Clone,
fn tee(self) -> (Tee<Self>, Tee<Self>)where
Self: Sized,
Self::Item: Clone,
sourcefn step(self, n: usize) -> Step<Self>ⓘNotable traits for Step<I>impl<I> Iterator for Step<I>where
I: Iterator, type Item = <I as Iterator>::Item;
where
Self: Sized,
fn step(self, n: usize) -> Step<Self>ⓘNotable traits for Step<I>impl<I> Iterator for Step<I>where
I: Iterator, type Item = <I as Iterator>::Item;
where
Self: Sized,
I: Iterator, type Item = <I as Iterator>::Item;
n
elements in the base iterator
for each iteration. Read moresourcefn map_into<R>(self) -> MapSpecialCase<Self, MapSpecialCaseFnInto<R>>where
Self: Sized,
Self::Item: Into<R>,
fn map_into<R>(self) -> MapSpecialCase<Self, MapSpecialCaseFnInto<R>>where
Self: Sized,
Self::Item: Into<R>,
sourcefn map_results<F, T, U, E>(
self,
f: F
) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> U,
fn map_results<F, T, U, E>(
self,
f: F
) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> U,
.map_ok()
.sourcefn map_ok<F, T, U, E>(self, f: F) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> U,
fn map_ok<F, T, U, E>(self, f: F) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> U,
Result::Ok
value. Result::Err
values are
unchanged. Read moresourcefn filter_ok<F, T, E>(self, f: F) -> FilterOk<Self, F>ⓘNotable traits for FilterOk<I, F>impl<I, F, T, E> Iterator for FilterOk<I, F>where
I: Iterator<Item = Result<T, E>>,
F: FnMut(&T) -> bool, type Item = Result<T, E>;
where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(&T) -> bool,
fn filter_ok<F, T, E>(self, f: F) -> FilterOk<Self, F>ⓘNotable traits for FilterOk<I, F>impl<I, F, T, E> Iterator for FilterOk<I, F>where
I: Iterator<Item = Result<T, E>>,
F: FnMut(&T) -> bool, type Item = Result<T, E>;
where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(&T) -> bool,
I: Iterator<Item = Result<T, E>>,
F: FnMut(&T) -> bool, type Item = Result<T, E>;
Result::Ok
value with the provided closure. Result::Err
values are
unchanged. Read moresourcefn filter_map_ok<F, T, U, E>(self, f: F) -> FilterMapOk<Self, F>ⓘNotable traits for FilterMapOk<I, F>impl<I, F, T, U, E> Iterator for FilterMapOk<I, F>where
I: Iterator<Item = Result<T, E>>,
F: FnMut(T) -> Option<U>, type Item = Result<U, E>;
where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> Option<U>,
fn filter_map_ok<F, T, U, E>(self, f: F) -> FilterMapOk<Self, F>ⓘNotable traits for FilterMapOk<I, F>impl<I, F, T, U, E> Iterator for FilterMapOk<I, F>where
I: Iterator<Item = Result<T, E>>,
F: FnMut(T) -> Option<U>, type Item = Result<U, E>;
where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> Option<U>,
I: Iterator<Item = Result<T, E>>,
F: FnMut(T) -> Option<U>, type Item = Result<U, E>;
Result::Ok
value with the provided closure. Result::Err
values are unchanged. Read moresourcefn flatten_ok<T, E>(self) -> FlattenOk<Self, T, E>ⓘNotable traits for FlattenOk<I, T, E>impl<I, T, E> Iterator for FlattenOk<I, T, E>where
I: Iterator<Item = Result<T, E>>,
T: IntoIterator, type Item = Result<<T as IntoIterator>::Item, E>;
where
Self: Iterator<Item = Result<T, E>> + Sized,
T: IntoIterator,
fn flatten_ok<T, E>(self) -> FlattenOk<Self, T, E>ⓘNotable traits for FlattenOk<I, T, E>impl<I, T, E> Iterator for FlattenOk<I, T, E>where
I: Iterator<Item = Result<T, E>>,
T: IntoIterator, type Item = Result<<T as IntoIterator>::Item, E>;
where
Self: Iterator<Item = Result<T, E>> + Sized,
T: IntoIterator,
I: Iterator<Item = Result<T, E>>,
T: IntoIterator, type Item = Result<<T as IntoIterator>::Item, E>;
Result::Ok
value into
a series of Result::Ok
values. Result::Err
values are unchanged. Read moresourcefn merge<J>(
self,
other: J
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>ⓘNotable traits for MergeBy<I, J, F>impl<I, J, F> Iterator for MergeBy<I, J, F>where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>,
F: MergePredicate<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
Self: Sized,
Self::Item: PartialOrd<Self::Item>,
J: IntoIterator<Item = Self::Item>,
fn merge<J>(
self,
other: J
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>ⓘNotable traits for MergeBy<I, J, F>impl<I, J, F> Iterator for MergeBy<I, J, F>where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>,
F: MergePredicate<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
Self: Sized,
Self::Item: PartialOrd<Self::Item>,
J: IntoIterator<Item = Self::Item>,
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>,
F: MergePredicate<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
sourcefn merge_by<J, F>(
self,
other: J,
is_first: F
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>ⓘNotable traits for MergeBy<I, J, F>impl<I, J, F> Iterator for MergeBy<I, J, F>where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>,
F: MergePredicate<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
Self: Sized,
J: IntoIterator<Item = Self::Item>,
F: FnMut(&Self::Item, &Self::Item) -> bool,
fn merge_by<J, F>(
self,
other: J,
is_first: F
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>ⓘNotable traits for MergeBy<I, J, F>impl<I, J, F> Iterator for MergeBy<I, J, F>where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>,
F: MergePredicate<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
Self: Sized,
J: IntoIterator<Item = Self::Item>,
F: FnMut(&Self::Item, &Self::Item) -> bool,
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>,
F: MergePredicate<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
sourcefn merge_join_by<J, F>(
self,
other: J,
cmp_fn: F
) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>ⓘNotable traits for MergeJoinBy<I, J, F>impl<I, J, F> Iterator for MergeJoinBy<I, J, F>where
I: Iterator,
J: Iterator,
F: FnMut(&<I as Iterator>::Item, &<J as Iterator>::Item) -> Ordering, type Item = EitherOrBoth<<I as Iterator>::Item, <J as Iterator>::Item>;
where
J: IntoIterator,
F: FnMut(&Self::Item, &<J as IntoIterator>::Item) -> Ordering,
Self: Sized,
fn merge_join_by<J, F>(
self,
other: J,
cmp_fn: F
) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>ⓘNotable traits for MergeJoinBy<I, J, F>impl<I, J, F> Iterator for MergeJoinBy<I, J, F>where
I: Iterator,
J: Iterator,
F: FnMut(&<I as Iterator>::Item, &<J as Iterator>::Item) -> Ordering, type Item = EitherOrBoth<<I as Iterator>::Item, <J as Iterator>::Item>;
where
J: IntoIterator,
F: FnMut(&Self::Item, &<J as IntoIterator>::Item) -> Ordering,
Self: Sized,
I: Iterator,
J: Iterator,
F: FnMut(&<I as Iterator>::Item, &<J as Iterator>::Item) -> Ordering, type Item = EitherOrBoth<<I as Iterator>::Item, <J as Iterator>::Item>;
sourcefn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt>ⓘNotable traits for KMergeBy<I, F>impl<I, F> Iterator for KMergeBy<I, F>where
I: Iterator,
F: KMergePredicate<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
Self: Sized,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: PartialOrd<<Self::Item as IntoIterator>::Item>,
fn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt>ⓘNotable traits for KMergeBy<I, F>impl<I, F> Iterator for KMergeBy<I, F>where
I: Iterator,
F: KMergePredicate<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
Self: Sized,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: PartialOrd<<Self::Item as IntoIterator>::Item>,
I: Iterator,
F: KMergePredicate<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
sourcefn kmerge_by<F>(
self,
first: F
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F>ⓘNotable traits for KMergeBy<I, F>impl<I, F> Iterator for KMergeBy<I, F>where
I: Iterator,
F: KMergePredicate<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
Self: Sized,
Self::Item: IntoIterator,
F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,
fn kmerge_by<F>(
self,
first: F
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F>ⓘNotable traits for KMergeBy<I, F>impl<I, F> Iterator for KMergeBy<I, F>where
I: Iterator,
F: KMergePredicate<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
Self: Sized,
Self::Item: IntoIterator,
F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,
I: Iterator,
F: KMergePredicate<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
sourcefn cartesian_product<J>(
self,
other: J
) -> Product<Self, <J as IntoIterator>::IntoIter>ⓘNotable traits for Product<I, J>impl<I, J> Iterator for Product<I, J>where
I: Iterator,
J: Clone + Iterator,
<I as Iterator>::Item: Clone, type Item = (<I as Iterator>::Item, <J as Iterator>::Item);
where
Self: Sized,
Self::Item: Clone,
J: IntoIterator,
<J as IntoIterator>::IntoIter: Clone,
fn cartesian_product<J>(
self,
other: J
) -> Product<Self, <J as IntoIterator>::IntoIter>ⓘNotable traits for Product<I, J>impl<I, J> Iterator for Product<I, J>where
I: Iterator,
J: Clone + Iterator,
<I as Iterator>::Item: Clone, type Item = (<I as Iterator>::Item, <J as Iterator>::Item);
where
Self: Sized,
Self::Item: Clone,
J: IntoIterator,
<J as IntoIterator>::IntoIter: Clone,
I: Iterator,
J: Clone + Iterator,
<I as Iterator>::Item: Clone, type Item = (<I as Iterator>::Item, <J as Iterator>::Item);
self
and J
. Read moresourcefn multi_cartesian_product(
self
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>ⓘNotable traits for MultiProduct<I>impl<I> Iterator for MultiProduct<I>where
I: Iterator + Clone,
<I as Iterator>::Item: Clone, type Item = Vec<<I as Iterator>::Item, Global>;
where
Self: Sized,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::IntoIter: Clone,
<Self::Item as IntoIterator>::Item: Clone,
fn multi_cartesian_product(
self
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>ⓘNotable traits for MultiProduct<I>impl<I> Iterator for MultiProduct<I>where
I: Iterator + Clone,
<I as Iterator>::Item: Clone, type Item = Vec<<I as Iterator>::Item, Global>;
where
Self: Sized,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::IntoIter: Clone,
<Self::Item as IntoIterator>::Item: Clone,
I: Iterator + Clone,
<I as Iterator>::Item: Clone, type Item = Vec<<I as Iterator>::Item, Global>;
self
. Read moresourcefn coalesce<F>(self, f: F) -> CoalesceBy<Self, F, Self::Item>where
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,
fn coalesce<F>(self, f: F) -> CoalesceBy<Self, F, Self::Item>where
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,
sourcefn dedup(self) -> CoalesceBy<Self, DedupPred2CoalescePred<DedupEq>, Self::Item>where
Self: Sized,
Self::Item: PartialEq<Self::Item>,
fn dedup(self) -> CoalesceBy<Self, DedupPred2CoalescePred<DedupEq>, Self::Item>where
Self: Sized,
Self::Item: PartialEq<Self::Item>,
sourcefn dedup_by<Cmp>(
self,
cmp: Cmp
) -> CoalesceBy<Self, DedupPred2CoalescePred<Cmp>, Self::Item>where
Self: Sized,
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
fn dedup_by<Cmp>(
self,
cmp: Cmp
) -> CoalesceBy<Self, DedupPred2CoalescePred<Cmp>, Self::Item>where
Self: Sized,
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
sourcefn dedup_with_count(
self
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<DedupEq>, (usize, Self::Item)>where
Self: Sized,
fn dedup_with_count(
self
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<DedupEq>, (usize, Self::Item)>where
Self: Sized,
sourcefn dedup_by_with_count<Cmp>(
self,
cmp: Cmp
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<Cmp>, (usize, Self::Item)>where
Self: Sized,
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
fn dedup_by_with_count<Cmp>(
self,
cmp: Cmp
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<Cmp>, (usize, Self::Item)>where
Self: Sized,
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
sourcefn duplicates(self) -> DuplicatesBy<Self, Self::Item, ById>where
Self: Sized,
Self::Item: Eq + Hash,
fn duplicates(self) -> DuplicatesBy<Self, Self::Item, ById>where
Self: Sized,
Self::Item: Eq + Hash,
sourcefn duplicates_by<V, F>(self, f: F) -> DuplicatesBy<Self, V, ByFn<F>>where
Self: Sized,
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
fn duplicates_by<V, F>(self, f: F) -> DuplicatesBy<Self, V, ByFn<F>>where
Self: Sized,
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
sourcefn unique(self) -> Unique<Self>ⓘNotable traits for Unique<I>impl<I> Iterator for Unique<I>where
I: Iterator,
<I as Iterator>::Item: Eq + Hash + Clone, type Item = <I as Iterator>::Item;
where
Self: Sized,
Self::Item: Clone + Eq + Hash,
fn unique(self) -> Unique<Self>ⓘNotable traits for Unique<I>impl<I> Iterator for Unique<I>where
I: Iterator,
<I as Iterator>::Item: Eq + Hash + Clone, type Item = <I as Iterator>::Item;
where
Self: Sized,
Self::Item: Clone + Eq + Hash,
I: Iterator,
<I as Iterator>::Item: Eq + Hash + Clone, type Item = <I as Iterator>::Item;
sourcefn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>ⓘNotable traits for UniqueBy<I, V, F>impl<I, V, F> Iterator for UniqueBy<I, V, F>where
I: Iterator,
V: Eq + Hash,
F: FnMut(&<I as Iterator>::Item) -> V, type Item = <I as Iterator>::Item;
where
Self: Sized,
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>ⓘNotable traits for UniqueBy<I, V, F>impl<I, V, F> Iterator for UniqueBy<I, V, F>where
I: Iterator,
V: Eq + Hash,
F: FnMut(&<I as Iterator>::Item) -> V, type Item = <I as Iterator>::Item;
where
Self: Sized,
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
I: Iterator,
V: Eq + Hash,
F: FnMut(&<I as Iterator>::Item) -> V, type Item = <I as Iterator>::Item;
sourcefn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F>ⓘNotable traits for PeekingTakeWhile<'a, I, F>impl<'a, I, F> Iterator for PeekingTakeWhile<'a, I, F>where
I: PeekingNext,
F: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;
where
Self: Sized + PeekingNext,
F: FnMut(&Self::Item) -> bool,
fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F>ⓘNotable traits for PeekingTakeWhile<'a, I, F>impl<'a, I, F> Iterator for PeekingTakeWhile<'a, I, F>where
I: PeekingNext,
F: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;
where
Self: Sized + PeekingNext,
F: FnMut(&Self::Item) -> bool,
I: PeekingNext,
F: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;
accept
returns true
. Read moresourcefn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>ⓘNotable traits for TakeWhileRef<'a, I, F>impl<'a, I, F> Iterator for TakeWhileRef<'a, I, F>where
I: Iterator + Clone,
F: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;
where
Self: Clone,
F: FnMut(&Self::Item) -> bool,
fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>ⓘNotable traits for TakeWhileRef<'a, I, F>impl<'a, I, F> Iterator for TakeWhileRef<'a, I, F>where
I: Iterator + Clone,
F: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;
where
Self: Clone,
F: FnMut(&Self::Item) -> bool,
I: Iterator + Clone,
F: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;
Clone
-able iterator
to only pick off elements while the predicate accept
returns true
. Read moresourcefn while_some<A>(self) -> WhileSome<Self>ⓘNotable traits for WhileSome<I>impl<I, A> Iterator for WhileSome<I>where
I: Iterator<Item = Option<A>>, type Item = A;
where
Self: Sized + Iterator<Item = Option<A>>,
fn while_some<A>(self) -> WhileSome<Self>ⓘNotable traits for WhileSome<I>impl<I, A> Iterator for WhileSome<I>where
I: Iterator<Item = Option<A>>, type Item = A;
where
Self: Sized + Iterator<Item = Option<A>>,
I: Iterator<Item = Option<A>>, type Item = A;
Option<A>
iterator elements
and produces A
. Stops on the first None
encountered. Read moresourcefn tuple_combinations<T>(self) -> TupleCombinations<Self, T>ⓘNotable traits for TupleCombinations<I, T>impl<I, T> Iterator for TupleCombinations<I, T>where
I: Iterator,
T: HasCombination<I>, type Item = T;
where
Self: Sized + Clone,
Self::Item: Clone,
T: HasCombination<Self>,
fn tuple_combinations<T>(self) -> TupleCombinations<Self, T>ⓘNotable traits for TupleCombinations<I, T>impl<I, T> Iterator for TupleCombinations<I, T>where
I: Iterator,
T: HasCombination<I>, type Item = T;
where
Self: Sized + Clone,
Self::Item: Clone,
T: HasCombination<Self>,
I: Iterator,
T: HasCombination<I>, type Item = T;
sourcefn combinations(self, k: usize) -> Combinations<Self>ⓘNotable traits for Combinations<I>impl<I> Iterator for Combinations<I>where
I: Iterator,
<I as Iterator>::Item: Clone, type Item = Vec<<I as Iterator>::Item, Global>;
where
Self: Sized,
Self::Item: Clone,
fn combinations(self, k: usize) -> Combinations<Self>ⓘNotable traits for Combinations<I>impl<I> Iterator for Combinations<I>where
I: Iterator,
<I as Iterator>::Item: Clone, type Item = Vec<<I as Iterator>::Item, Global>;
where
Self: Sized,
Self::Item: Clone,
I: Iterator,
<I as Iterator>::Item: Clone, type Item = Vec<<I as Iterator>::Item, Global>;
k
-length combinations of
the elements from an iterator. Read moresourcefn combinations_with_replacement(
self,
k: usize
) -> CombinationsWithReplacement<Self>ⓘNotable traits for CombinationsWithReplacement<I>impl<I> Iterator for CombinationsWithReplacement<I>where
I: Iterator,
<I as Iterator>::Item: Clone, type Item = Vec<<I as Iterator>::Item, Global>;
where
Self: Sized,
Self::Item: Clone,
fn combinations_with_replacement(
self,
k: usize
) -> CombinationsWithReplacement<Self>ⓘNotable traits for CombinationsWithReplacement<I>impl<I> Iterator for CombinationsWithReplacement<I>where
I: Iterator,
<I as Iterator>::Item: Clone, type Item = Vec<<I as Iterator>::Item, Global>;
where
Self: Sized,
Self::Item: Clone,
I: Iterator,
<I as Iterator>::Item: Clone, type Item = Vec<<I as Iterator>::Item, Global>;
k
-length combinations of
the elements from an iterator, with replacement. Read moresourcefn permutations(self, k: usize) -> Permutations<Self>ⓘNotable traits for Permutations<I>impl<I> Iterator for Permutations<I>where
I: Iterator,
<I as Iterator>::Item: Clone, type Item = Vec<<I as Iterator>::Item, Global>;
where
Self: Sized,
Self::Item: Clone,
fn permutations(self, k: usize) -> Permutations<Self>ⓘNotable traits for Permutations<I>impl<I> Iterator for Permutations<I>where
I: Iterator,
<I as Iterator>::Item: Clone, type Item = Vec<<I as Iterator>::Item, Global>;
where
Self: Sized,
Self::Item: Clone,
I: Iterator,
<I as Iterator>::Item: Clone, type Item = Vec<<I as Iterator>::Item, Global>;
sourcefn powerset(self) -> Powerset<Self>ⓘNotable traits for Powerset<I>impl<I> Iterator for Powerset<I>where
I: Iterator,
<I as Iterator>::Item: Clone, type Item = Vec<<I as Iterator>::Item, Global>;
where
Self: Sized,
Self::Item: Clone,
fn powerset(self) -> Powerset<Self>ⓘNotable traits for Powerset<I>impl<I> Iterator for Powerset<I>where
I: Iterator,
<I as Iterator>::Item: Clone, type Item = Vec<<I as Iterator>::Item, Global>;
where
Self: Sized,
Self::Item: Clone,
I: Iterator,
<I as Iterator>::Item: Clone, type Item = Vec<<I as Iterator>::Item, Global>;
sourcefn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>ⓘNotable traits for PadUsing<I, F>impl<I, F> Iterator for PadUsing<I, F>where
I: Iterator,
F: FnMut(usize) -> <I as Iterator>::Item, type Item = <I as Iterator>::Item;
where
Self: Sized,
F: FnMut(usize) -> Self::Item,
fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>ⓘNotable traits for PadUsing<I, F>impl<I, F> Iterator for PadUsing<I, F>where
I: Iterator,
F: FnMut(usize) -> <I as Iterator>::Item, type Item = <I as Iterator>::Item;
where
Self: Sized,
F: FnMut(usize) -> Self::Item,
I: Iterator,
F: FnMut(usize) -> <I as Iterator>::Item, type Item = <I as Iterator>::Item;
min
by filling missing elements using a closure f
. Read moresourcefn with_position(self) -> WithPosition<Self>ⓘNotable traits for WithPosition<I>impl<I> Iterator for WithPosition<I>where
I: Iterator, type Item = Position<<I as Iterator>::Item>;
where
Self: Sized,
fn with_position(self) -> WithPosition<Self>ⓘNotable traits for WithPosition<I>impl<I> Iterator for WithPosition<I>where
I: Iterator, type Item = Position<<I as Iterator>::Item>;
where
Self: Sized,
I: Iterator, type Item = Position<<I as Iterator>::Item>;
Position
to
ease special-case handling of the first or last elements. Read moresourcefn positions<P>(self, predicate: P) -> Positions<Self, P>ⓘNotable traits for Positions<I, F>impl<I, F> Iterator for Positions<I, F>where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> bool, type Item = usize;
where
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn positions<P>(self, predicate: P) -> Positions<Self, P>ⓘNotable traits for Positions<I, F>impl<I, F> Iterator for Positions<I, F>where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> bool, type Item = usize;
where
Self: Sized,
P: FnMut(Self::Item) -> bool,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> bool, type Item = usize;
sourcefn update<F>(self, updater: F) -> Update<Self, F>ⓘNotable traits for Update<I, F>impl<I, F> Iterator for Update<I, F>where
I: Iterator,
F: FnMut(&mut <I as Iterator>::Item), type Item = <I as Iterator>::Item;
where
Self: Sized,
F: FnMut(&mut Self::Item),
fn update<F>(self, updater: F) -> Update<Self, F>ⓘNotable traits for Update<I, F>impl<I, F> Iterator for Update<I, F>where
I: Iterator,
F: FnMut(&mut <I as Iterator>::Item), type Item = <I as Iterator>::Item;
where
Self: Sized,
F: FnMut(&mut Self::Item),
I: Iterator,
F: FnMut(&mut <I as Iterator>::Item), type Item = <I as Iterator>::Item;
sourcefn next_tuple<T>(&mut self) -> Option<T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn next_tuple<T>(&mut self) -> Option<T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
sourcefn collect_tuple<T>(self) -> Option<T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn collect_tuple<T>(self) -> Option<T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
sourcefn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)>where
P: FnMut(&Self::Item) -> bool,
fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)>where
P: FnMut(&Self::Item) -> bool,
sourcefn find_or_last<P>(self, predicate: P) -> Option<Self::Item>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn find_or_last<P>(self, predicate: P) -> Option<Self::Item>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
sourcefn find_or_first<P>(self, predicate: P) -> Option<Self::Item>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn find_or_first<P>(self, predicate: P) -> Option<Self::Item>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
sourcefn contains<Q>(&mut self, query: &Q) -> boolwhere
Self: Sized,
Self::Item: Borrow<Q>,
Q: PartialEq<Q>,
fn contains<Q>(&mut self, query: &Q) -> boolwhere
Self: Sized,
Self::Item: Borrow<Q>,
Q: PartialEq<Q>,
true
if the given item is present in this iterator. Read moresourcefn all_equal(&mut self) -> boolwhere
Self: Sized,
Self::Item: PartialEq<Self::Item>,
fn all_equal(&mut self) -> boolwhere
Self: Sized,
Self::Item: PartialEq<Self::Item>,
sourcefn all_unique(&mut self) -> boolwhere
Self: Sized,
Self::Item: Eq + Hash,
fn all_unique(&mut self) -> boolwhere
Self: Sized,
Self::Item: Eq + Hash,
sourcefn dropping(self, n: usize) -> Selfwhere
Self: Sized,
fn dropping(self, n: usize) -> Selfwhere
Self: Sized,
n
elements from the iterator eagerly,
and return the same iterator again. Read moresourcefn dropping_back(self, n: usize) -> Selfwhere
Self: Sized + DoubleEndedIterator,
fn dropping_back(self, n: usize) -> Selfwhere
Self: Sized + DoubleEndedIterator,
n
elements from the iterator eagerly,
and return the same iterator again. Read moresourcefn foreach<F>(self, f: F)where
F: FnMut(Self::Item),
Self: Sized,
fn foreach<F>(self, f: F)where
F: FnMut(Self::Item),
Self: Sized,
f
eagerly on each element of the iterator. Read moresourcefn concat(self) -> Self::Itemwhere
Self: Sized,
Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,
fn concat(self) -> Self::Itemwhere
Self: Sized,
Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,
sourcefn collect_vec(self) -> Vec<Self::Item, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
A: Allocator,
where
Self: Sized,
fn collect_vec(self) -> Vec<Self::Item, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
A: Allocator,
where
Self: Sized,
A: Allocator,
sourcefn try_collect<T, U, E>(self) -> Result<U, E>where
Self: Sized + Iterator<Item = Result<T, E>>,
Result<U, E>: FromIterator<Result<T, E>>,
fn try_collect<T, U, E>(self) -> Result<U, E>where
Self: Sized + Iterator<Item = Result<T, E>>,
Result<U, E>: FromIterator<Result<T, E>>,
sourcefn set_from<'a, A, J>(&mut self, from: J) -> usizewhere
A: 'a,
Self: Iterator<Item = &'a mut A>,
J: IntoIterator<Item = A>,
fn set_from<'a, A, J>(&mut self, from: J) -> usizewhere
A: 'a,
Self: Iterator<Item = &'a mut A>,
J: IntoIterator<Item = A>,
self
from the from
iterator,
stopping at the shortest of the two iterators. Read moresourcefn join(&mut self, sep: &str) -> Stringwhere
Self::Item: Display,
fn join(&mut self, sep: &str) -> Stringwhere
Self::Item: Display,
sep
. Read moresourcefn format(self, sep: &str) -> Format<'_, Self>where
Self: Sized,
fn format(self, sep: &str) -> Format<'_, Self>where
Self: Sized,
sep
. Read moresourcefn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F>where
Self: Sized,
F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display) -> Result<(), Error>) -> Result<(), Error>,
fn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F>where
Self: Sized,
F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display) -> Result<(), Error>) -> Result<(), Error>,
sep
. Read moresourcefn fold_results<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>where
Self: Iterator<Item = Result<A, E>>,
F: FnMut(B, A) -> B,
fn fold_results<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>where
Self: Iterator<Item = Result<A, E>>,
F: FnMut(B, A) -> B,
.fold_ok()
.sourcefn fold_ok<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>where
Self: Iterator<Item = Result<A, E>>,
F: FnMut(B, A) -> B,
fn fold_ok<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>where
Self: Iterator<Item = Result<A, E>>,
F: FnMut(B, A) -> B,
Result
values from an iterator. Read moresourcefn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option<B>where
Self: Iterator<Item = Option<A>>,
F: FnMut(B, A) -> B,
fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option<B>where
Self: Iterator<Item = Option<A>>,
F: FnMut(B, A) -> B,
Option
values from an iterator. Read moresourcefn fold1<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
Self: Sized,
fn fold1<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
Self: Sized,
Iterator::reduce
insteadsourcefn tree_fold1<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
Self: Sized,
fn tree_fold1<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
Self: Sized,
sourcefn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B>where
Self: Sized,
F: FnMut(B, Self::Item) -> FoldWhile<B>,
fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B>where
Self: Sized,
F: FnMut(B, Self::Item) -> FoldWhile<B>,
sourcefn sum1<S>(self) -> Option<S>where
Self: Sized,
S: Sum<Self::Item>,
fn sum1<S>(self) -> Option<S>where
Self: Sized,
S: Sum<Self::Item>,
sourcefn product1<P>(self) -> Option<P>where
Self: Sized,
P: Product<Self::Item>,
fn product1<P>(self) -> Option<P>where
Self: Sized,
P: Product<Self::Item>,
sourcefn sorted_unstable(self) -> IntoIter<Self::Item, Global>ⓘNotable traits for IntoIter<T, A>impl<T, A> Iterator for IntoIter<T, A>where
A: Allocator, type Item = T;
where
Self: Sized,
Self::Item: Ord,
fn sorted_unstable(self) -> IntoIter<Self::Item, Global>ⓘNotable traits for IntoIter<T, A>impl<T, A> Iterator for IntoIter<T, A>where
A: Allocator, type Item = T;
where
Self: Sized,
Self::Item: Ord,
A: Allocator, type Item = T;
sourcefn sorted_unstable_by<F>(self, cmp: F) -> IntoIter<Self::Item, Global>ⓘNotable traits for IntoIter<T, A>impl<T, A> Iterator for IntoIter<T, A>where
A: Allocator, type Item = T;
where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn sorted_unstable_by<F>(self, cmp: F) -> IntoIter<Self::Item, Global>ⓘNotable traits for IntoIter<T, A>impl<T, A> Iterator for IntoIter<T, A>where
A: Allocator, type Item = T;
where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
A: Allocator, type Item = T;
sourcefn sorted_unstable_by_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>ⓘNotable traits for IntoIter<T, A>impl<T, A> Iterator for IntoIter<T, A>where
A: Allocator, type Item = T;
where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn sorted_unstable_by_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>ⓘNotable traits for IntoIter<T, A>impl<T, A> Iterator for IntoIter<T, A>where
A: Allocator, type Item = T;
where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
A: Allocator, type Item = T;
sourcefn sorted(self) -> IntoIter<Self::Item, Global>ⓘNotable traits for IntoIter<T, A>impl<T, A> Iterator for IntoIter<T, A>where
A: Allocator, type Item = T;
where
Self: Sized,
Self::Item: Ord,
fn sorted(self) -> IntoIter<Self::Item, Global>ⓘNotable traits for IntoIter<T, A>impl<T, A> Iterator for IntoIter<T, A>where
A: Allocator, type Item = T;
where
Self: Sized,
Self::Item: Ord,
A: Allocator, type Item = T;
sourcefn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item, Global>ⓘNotable traits for IntoIter<T, A>impl<T, A> Iterator for IntoIter<T, A>where
A: Allocator, type Item = T;
where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item, Global>ⓘNotable traits for IntoIter<T, A>impl<T, A> Iterator for IntoIter<T, A>where
A: Allocator, type Item = T;
where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
A: Allocator, type Item = T;
sourcefn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>ⓘNotable traits for IntoIter<T, A>impl<T, A> Iterator for IntoIter<T, A>where
A: Allocator, type Item = T;
where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>ⓘNotable traits for IntoIter<T, A>impl<T, A> Iterator for IntoIter<T, A>where
A: Allocator, type Item = T;
where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
A: Allocator, type Item = T;
sourcefn sorted_by_cached_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>ⓘNotable traits for IntoIter<T, A>impl<T, A> Iterator for IntoIter<T, A>where
A: Allocator, type Item = T;
where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn sorted_by_cached_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>ⓘNotable traits for IntoIter<T, A>impl<T, A> Iterator for IntoIter<T, A>where
A: Allocator, type Item = T;
where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
A: Allocator, type Item = T;
sourcefn k_smallest(self, k: usize) -> IntoIter<Self::Item, Global>ⓘNotable traits for IntoIter<T, A>impl<T, A> Iterator for IntoIter<T, A>where
A: Allocator, type Item = T;
where
Self: Sized,
Self::Item: Ord,
fn k_smallest(self, k: usize) -> IntoIter<Self::Item, Global>ⓘNotable traits for IntoIter<T, A>impl<T, A> Iterator for IntoIter<T, A>where
A: Allocator, type Item = T;
where
Self: Sized,
Self::Item: Ord,
A: Allocator, type Item = T;
sourcefn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B)where
Self: Sized,
F: FnMut(Self::Item) -> Either<L, R>,
A: Default + Extend<L>,
B: Default + Extend<R>,
fn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B)where
Self: Sized,
F: FnMut(Self::Item) -> Either<L, R>,
A: Default + Extend<L>,
B: Default + Extend<R>,
Iterator::partition
, each partition may
have a distinct type. Read moresourcefn partition_result<A, B, T, E>(self) -> (A, B)where
Self: Iterator<Item = Result<T, E>> + Sized,
A: Default + Extend<T>,
B: Default + Extend<E>,
fn partition_result<A, B, T, E>(self) -> (A, B)where
Self: Iterator<Item = Result<T, E>> + Sized,
A: Default + Extend<T>,
B: Default + Extend<E>,
Result
s into one list of all the Ok
elements
and another list of all the Err
elements. Read moresourcefn into_group_map<K, V>(self) -> HashMap<K, Vec<V, Global>, RandomState>where
Self: Iterator<Item = (K, V)> + Sized,
K: Hash + Eq,
fn into_group_map<K, V>(self) -> HashMap<K, Vec<V, Global>, RandomState>where
Self: Iterator<Item = (K, V)> + Sized,
K: Hash + Eq,
HashMap
of keys mapped to Vec
s of values. Keys and values
are taken from (Key, Value)
tuple pairs yielded by the input iterator. Read moresourcefn into_group_map_by<K, V, F>(
self,
f: F
) -> HashMap<K, Vec<V, Global>, RandomState>where
Self: Iterator<Item = V> + Sized,
K: Hash + Eq,
F: Fn(&V) -> K,
fn into_group_map_by<K, V, F>(
self,
f: F
) -> HashMap<K, Vec<V, Global>, RandomState>where
Self: Iterator<Item = V> + Sized,
K: Hash + Eq,
F: Fn(&V) -> K,
Iterator
on a HashMap
. Keys mapped to Vec
s of values. The key is specified
in the closure. Read moresourcefn into_grouping_map<K, V>(self) -> GroupingMap<Self>where
Self: Iterator<Item = (K, V)> + Sized,
K: Hash + Eq,
fn into_grouping_map<K, V>(self) -> GroupingMap<Self>where
Self: Iterator<Item = (K, V)> + Sized,
K: Hash + Eq,
GroupingMap
to be used later with one of the efficient
group-and-fold operations it allows to perform. Read moresourcefn into_grouping_map_by<K, V, F>(
self,
key_mapper: F
) -> GroupingMap<MapForGrouping<Self, F>>where
Self: Iterator<Item = V> + Sized,
K: Hash + Eq,
F: FnMut(&V) -> K,
fn into_grouping_map_by<K, V, F>(
self,
key_mapper: F
) -> GroupingMap<MapForGrouping<Self, F>>where
Self: Iterator<Item = V> + Sized,
K: Hash + Eq,
F: FnMut(&V) -> K,
GroupingMap
to be used later with one of the efficient
group-and-fold operations it allows to perform. Read moresourcefn min_set(self) -> Vec<Self::Item, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
A: Allocator,
where
Self: Sized,
Self::Item: Ord,
fn min_set(self) -> Vec<Self::Item, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
A: Allocator,
where
Self: Sized,
Self::Item: Ord,
A: Allocator,
sourcefn min_set_by<F>(self, compare: F) -> Vec<Self::Item, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
A: Allocator,
where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_set_by<F>(self, compare: F) -> Vec<Self::Item, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
A: Allocator,
where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
A: Allocator,
sourcefn min_set_by_key<K, F>(self, key: F) -> Vec<Self::Item, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
A: Allocator,
where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn min_set_by_key<K, F>(self, key: F) -> Vec<Self::Item, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
A: Allocator,
where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
A: Allocator,
sourcefn max_set(self) -> Vec<Self::Item, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
A: Allocator,
where
Self: Sized,
Self::Item: Ord,
fn max_set(self) -> Vec<Self::Item, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
A: Allocator,
where
Self: Sized,
Self::Item: Ord,
A: Allocator,
sourcefn max_set_by<F>(self, compare: F) -> Vec<Self::Item, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
A: Allocator,
where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn max_set_by<F>(self, compare: F) -> Vec<Self::Item, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
A: Allocator,
where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
A: Allocator,
sourcefn max_set_by_key<K, F>(self, key: F) -> Vec<Self::Item, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
A: Allocator,
where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn max_set_by_key<K, F>(self, key: F) -> Vec<Self::Item, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
A: Allocator,
where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
A: Allocator,
sourcefn minmax(self) -> MinMaxResult<Self::Item>where
Self: Sized,
Self::Item: PartialOrd<Self::Item>,
fn minmax(self) -> MinMaxResult<Self::Item>where
Self: Sized,
Self::Item: PartialOrd<Self::Item>,
sourcefn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item>where
Self: Sized,
K: PartialOrd<K>,
F: FnMut(&Self::Item) -> K,
fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item>where
Self: Sized,
K: PartialOrd<K>,
F: FnMut(&Self::Item) -> K,
sourcefn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
sourcefn position_max(self) -> Option<usize>where
Self: Sized,
Self::Item: Ord,
fn position_max(self) -> Option<usize>where
Self: Sized,
Self::Item: Ord,
sourcefn position_max_by_key<K, F>(self, key: F) -> Option<usize>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn position_max_by_key<K, F>(self, key: F) -> Option<usize>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
sourcefn position_max_by<F>(self, compare: F) -> Option<usize>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn position_max_by<F>(self, compare: F) -> Option<usize>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
sourcefn position_min(self) -> Option<usize>where
Self: Sized,
Self::Item: Ord,
fn position_min(self) -> Option<usize>where
Self: Sized,
Self::Item: Ord,
sourcefn position_min_by_key<K, F>(self, key: F) -> Option<usize>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn position_min_by_key<K, F>(self, key: F) -> Option<usize>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
sourcefn position_min_by<F>(self, compare: F) -> Option<usize>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn position_min_by<F>(self, compare: F) -> Option<usize>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
sourcefn position_minmax(self) -> MinMaxResult<usize>where
Self: Sized,
Self::Item: PartialOrd<Self::Item>,
fn position_minmax(self) -> MinMaxResult<usize>where
Self: Sized,
Self::Item: PartialOrd<Self::Item>,
sourcefn position_minmax_by_key<K, F>(self, key: F) -> MinMaxResult<usize>where
Self: Sized,
K: PartialOrd<K>,
F: FnMut(&Self::Item) -> K,
fn position_minmax_by_key<K, F>(self, key: F) -> MinMaxResult<usize>where
Self: Sized,
K: PartialOrd<K>,
F: FnMut(&Self::Item) -> K,
sourcefn position_minmax_by<F>(self, compare: F) -> MinMaxResult<usize>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn position_minmax_by<F>(self, compare: F) -> MinMaxResult<usize>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
sourcefn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>>where
Self: Sized,
fn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>>where
Self: Sized,
sourcefn at_most_one(self) -> Result<Option<Self::Item>, ExactlyOneError<Self>>where
Self: Sized,
fn at_most_one(self) -> Result<Option<Self::Item>, ExactlyOneError<Self>>where
Self: Sized,
sourcefn multipeek(self) -> MultiPeek<Self>ⓘNotable traits for MultiPeek<I>impl<I> Iterator for MultiPeek<I>where
I: Iterator, type Item = <I as Iterator>::Item;
where
Self: Sized,
fn multipeek(self) -> MultiPeek<Self>ⓘNotable traits for MultiPeek<I>impl<I> Iterator for MultiPeek<I>where
I: Iterator, type Item = <I as Iterator>::Item;
where
Self: Sized,
I: Iterator, type Item = <I as Iterator>::Item;
.next()
values without advancing the base iterator. Read moresourcefn counts(self) -> HashMap<Self::Item, usize, RandomState>where
Self: Sized,
Self::Item: Eq + Hash,
fn counts(self) -> HashMap<Self::Item, usize, RandomState>where
Self: Sized,
Self::Item: Eq + Hash,
HashMap
which
contains each item that appears in the iterator and the number
of times it appears. Read moresourcefn counts_by<K, F>(self, f: F) -> HashMap<K, usize, RandomState>where
Self: Sized,
K: Eq + Hash,
F: FnMut(Self::Item) -> K,
fn counts_by<K, F>(self, f: F) -> HashMap<K, usize, RandomState>where
Self: Sized,
K: Eq + Hash,
F: FnMut(Self::Item) -> K,
HashMap
which
contains each item that appears in the iterator and the number
of times it appears,
determining identity using a keying function. Read moresourcefn multiunzip<FromI>(self) -> FromIwhere
Self: Sized + MultiUnzip<FromI>,
fn multiunzip<FromI>(self) -> FromIwhere
Self: Sized + MultiUnzip<FromI>,
sourceimpl<IT> MultiUnzip<()> for ITwhere
IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for ITwhere
IT: Iterator<Item = ()>,
sourcefn multiunzip(self)
fn multiunzip(self)
sourceimpl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
FromK: Default + Extend<K>,
FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
FromK: Default + Extend<K>,
FromL: Default + Extend<L>,
sourcefn multiunzip(
self
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)
fn multiunzip(
self
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)
sourceimpl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
FromK: Default + Extend<K>,
sourcefn multiunzip(
self
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)
fn multiunzip(
self
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)
sourceimpl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
sourcefn multiunzip(
self
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)
fn multiunzip(
self
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)
sourceimpl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
sourcefn multiunzip(
self
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)
fn multiunzip(
self
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)
sourceimpl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
sourcefn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)
sourceimpl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
sourcefn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)
sourceimpl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
sourcefn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)
sourceimpl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
sourcefn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)
sourceimpl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for ITwhere
IT: Iterator<Item = (A, B, C, D)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for ITwhere
IT: Iterator<Item = (A, B, C, D)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
sourcefn multiunzip(self) -> (FromA, FromB, FromC, FromD)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD)
sourceimpl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for ITwhere
IT: Iterator<Item = (A, B, C)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for ITwhere
IT: Iterator<Item = (A, B, C)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
sourcefn multiunzip(self) -> (FromA, FromB, FromC)
fn multiunzip(self) -> (FromA, FromB, FromC)
sourceimpl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for ITwhere
IT: Iterator<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for ITwhere
IT: Iterator<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
sourcefn multiunzip(self) -> (FromA, FromB)
fn multiunzip(self) -> (FromA, FromB)
sourceimpl<IT, A, FromA> MultiUnzip<(FromA,)> for ITwhere
IT: Iterator<Item = (A,)>,
FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for ITwhere
IT: Iterator<Item = (A,)>,
FromA: Default + Extend<A>,
sourcefn multiunzip(self) -> (FromA,)
fn multiunzip(self) -> (FromA,)
impl<T> Pointable for T
impl<T> Pointable for T
impl<I> UnicodeNormalization<I> for Iwhere
I: Iterator<Item = char>,
impl<I> UnicodeNormalization<I> for Iwhere
I: Iterator<Item = char>,
fn nfd(self) -> Decompositions<I>ⓘNotable traits for Decompositions<I>impl<I> Iterator for Decompositions<I>where
I: Iterator<Item = char>, type Item = char;
fn nfd(self) -> Decompositions<I>ⓘNotable traits for Decompositions<I>impl<I> Iterator for Decompositions<I>where
I: Iterator<Item = char>, type Item = char;
I: Iterator<Item = char>, type Item = char;
fn nfkd(self) -> Decompositions<I>ⓘNotable traits for Decompositions<I>impl<I> Iterator for Decompositions<I>where
I: Iterator<Item = char>, type Item = char;
fn nfkd(self) -> Decompositions<I>ⓘNotable traits for Decompositions<I>impl<I> Iterator for Decompositions<I>where
I: Iterator<Item = char>, type Item = char;
I: Iterator<Item = char>, type Item = char;
fn nfc(self) -> Recompositions<I>ⓘNotable traits for Recompositions<I>impl<I> Iterator for Recompositions<I>where
I: Iterator<Item = char>, type Item = char;
fn nfc(self) -> Recompositions<I>ⓘNotable traits for Recompositions<I>impl<I> Iterator for Recompositions<I>where
I: Iterator<Item = char>, type Item = char;
I: Iterator<Item = char>, type Item = char;
fn nfkc(self) -> Recompositions<I>ⓘNotable traits for Recompositions<I>impl<I> Iterator for Recompositions<I>where
I: Iterator<Item = char>, type Item = char;
fn nfkc(self) -> Recompositions<I>ⓘNotable traits for Recompositions<I>impl<I> Iterator for Recompositions<I>where
I: Iterator<Item = char>, type Item = char;
I: Iterator<Item = char>, type Item = char;
fn cjk_compat_variants(self) -> Replacements<I>ⓘNotable traits for Replacements<I>impl<I> Iterator for Replacements<I>where
I: Iterator<Item = char>, type Item = char;
fn cjk_compat_variants(self) -> Replacements<I>ⓘNotable traits for Replacements<I>impl<I> Iterator for Replacements<I>where
I: Iterator<Item = char>, type Item = char;
I: Iterator<Item = char>, type Item = char;
impl<V, T> VZip<V> for Twhere
V: MultiLane<T>,
impl<V, T> VZip<V> for Twhere
V: MultiLane<T>,
fn vzip(self) -> V
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T>where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T>where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
T: Future, type Output = <T as Future>::Output;
sourcefn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T>where
T: Future, type Output = <T as Future>::Output;
fn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T>where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;