struct PeekIter<'a> {
stored: VecDeque<(TokenKind, &'a str)>,
peek_pos: usize,
iter: TokenIter<'a>,
}
Expand description
This iterator comes from the same idea than “Peekable” except that it allows to “peek” more than
just the next item by using peek_next
. The peek
method always returns the next item after
the current one whereas peek_next
will return the next item after the last one peeked.
You can use both peek
and peek_next
at the same time without problem.
Fields
stored: VecDeque<(TokenKind, &'a str)>
peek_pos: usize
This position is reinitialized when using next
. It is used in peek_next
.
iter: TokenIter<'a>
Implementations
Trait Implementations
sourceimpl<'a> Iterator for PeekIter<'a>
impl<'a> Iterator for PeekIter<'a>
sourcefn next(&mut self) -> Option<Self::Item>
fn next(&mut self) -> Option<Self::Item>
sourcefn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
iter_next_chunk
)N
values. Read more1.0.0 · sourcefn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
1.0.0 · sourcefn count(self) -> usize
fn count(self) -> usize
1.0.0 · sourcefn last(self) -> Option<Self::Item>
fn last(self) -> Option<Self::Item>
sourcefn advance_by(&mut self, n: usize) -> Result<(), usize>
fn advance_by(&mut self, n: usize) -> Result<(), usize>
iter_advance_by
)n
elements. Read more1.0.0 · sourcefn 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>
fn step_by(self, step: usize) -> StepBy<Self>
1.0.0 · sourcefn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where
U: IntoIterator<Item = Self::Item>,
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where
U: IntoIterator<Item = Self::Item>,
1.0.0 · sourcefn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
U: IntoIterator,
sourcefn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where
G: FnMut() -> Self::Item,
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where
G: FnMut() -> Self::Item,
iter_intersperse
)separator
between adjacent items of the original iterator. Read more1.0.0 · sourcefn map<B, F>(self, f: F) -> Map<Self, F>where
F: FnMut(Self::Item) -> B,
fn map<B, F>(self, f: F) -> Map<Self, F>where
F: FnMut(Self::Item) -> B,
1.21.0 · sourcefn for_each<F>(self, f: F)where
F: FnMut(Self::Item),
fn for_each<F>(self, f: F)where
F: FnMut(Self::Item),
1.0.0 · sourcefn filter<P>(self, predicate: P) -> Filter<Self, P>where
P: FnMut(&Self::Item) -> bool,
fn filter<P>(self, predicate: P) -> Filter<Self, P>where
P: FnMut(&Self::Item) -> bool,
1.0.0 · sourcefn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where
F: FnMut(Self::Item) -> Option<B>,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where
F: FnMut(Self::Item) -> Option<B>,
1.0.0 · sourcefn enumerate(self) -> Enumerate<Self>
fn enumerate(self) -> Enumerate<Self>
1.0.0 · sourcefn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
P: FnMut(&Self::Item) -> bool,
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
P: FnMut(&Self::Item) -> bool,
1.0.0 · sourcefn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
P: FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
P: FnMut(&Self::Item) -> bool,
1.57.0 · sourcefn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where
P: FnMut(Self::Item) -> Option<B>,
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where
P: FnMut(Self::Item) -> Option<B>,
1.0.0 · sourcefn skip(self, n: usize) -> Skip<Self>
fn skip(self, n: usize) -> Skip<Self>
n
elements. Read more1.0.0 · sourcefn take(self, n: usize) -> Take<Self>
fn take(self, n: usize) -> Take<Self>
n
elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0 · sourcefn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where
F: FnMut(&mut St, Self::Item) -> Option<B>,
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where
F: FnMut(&mut St, Self::Item) -> Option<B>,
1.0.0 · sourcefn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
U: IntoIterator,
F: FnMut(Self::Item) -> U,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
U: IntoIterator,
F: FnMut(Self::Item) -> U,
1.0.0 · sourcefn inspect<F>(self, f: F) -> Inspect<Self, F>where
F: FnMut(&Self::Item),
fn inspect<F>(self, f: F) -> Inspect<Self, F>where
F: FnMut(&Self::Item),
1.0.0 · sourcefn by_ref(&mut self) -> &mut Self
fn by_ref(&mut self) -> &mut Self
1.0.0 · sourcefn collect<B>(self) -> Bwhere
B: FromIterator<Self::Item>,
fn collect<B>(self) -> Bwhere
B: FromIterator<Self::Item>,
sourcefn collect_into<E>(self, collection: &mut E) -> &mut Ewhere
E: Extend<Self::Item>,
fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere
E: Extend<Self::Item>,
iter_collect_into
)1.0.0 · sourcefn partition<B, F>(self, f: F) -> (B, B)where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
fn partition<B, F>(self, f: F) -> (B, B)where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
sourcefn is_partitioned<P>(self, predicate: P) -> boolwhere
P: FnMut(Self::Item) -> bool,
fn is_partitioned<P>(self, predicate: P) -> boolwhere
P: FnMut(Self::Item) -> bool,
iter_is_partitioned
)true
precede all those that return false
. Read more1.27.0 · sourcefn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
1.27.0 · sourcefn try_for_each<F, R>(&mut self, f: F) -> Rwhere
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
fn try_for_each<F, R>(&mut self, f: F) -> Rwhere
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
1.0.0 · sourcefn fold<B, F>(self, init: B, f: F) -> Bwhere
F: FnMut(B, Self::Item) -> B,
fn fold<B, F>(self, init: B, f: F) -> Bwhere
F: FnMut(B, Self::Item) -> B,
1.51.0 · sourcefn reduce<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn reduce<F>(self, f: F) -> Option<Self::Item>where
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
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
F: FnMut(Self::Item, Self::Item) -> R,
R: Try<Output = Self::Item>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
iterator_try_reduce
)1.0.0 · sourcefn all<F>(&mut self, f: F) -> boolwhere
F: FnMut(Self::Item) -> bool,
fn all<F>(&mut self, f: F) -> boolwhere
F: FnMut(Self::Item) -> bool,
1.0.0 · sourcefn any<F>(&mut self, f: F) -> boolwhere
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> boolwhere
F: FnMut(Self::Item) -> bool,
1.0.0 · sourcefn find<P>(&mut self, predicate: P) -> Option<Self::Item>where
P: FnMut(&Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where
P: FnMut(&Self::Item) -> bool,
1.30.0 · sourcefn find_map<B, F>(&mut self, f: F) -> Option<B>where
F: FnMut(Self::Item) -> Option<B>,
fn find_map<B, F>(&mut self, f: F) -> Option<B>where
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
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
F: FnMut(&Self::Item) -> R,
R: Try<Output = bool>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
try_find
)1.0.0 · sourcefn position<P>(&mut self, predicate: P) -> Option<usize>where
P: FnMut(Self::Item) -> bool,
fn position<P>(&mut self, predicate: P) -> Option<usize>where
P: FnMut(Self::Item) -> bool,
1.6.0 · sourcefn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
F: FnMut(&Self::Item) -> B,
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.15.0 · sourcefn max_by<F>(self, compare: F) -> Option<Self::Item>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn max_by<F>(self, compare: F) -> Option<Self::Item>where
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,
F: FnMut(&Self::Item) -> B,
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.15.0 · sourcefn min_by<F>(self, compare: F) -> Option<Self::Item>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by<F>(self, compare: F) -> Option<Self::Item>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.0.0 · sourcefn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
1.36.0 · sourcefn copied<'a, T>(self) -> Copied<Self>where
T: 'a + Copy,
Self: Iterator<Item = &'a T>,
fn copied<'a, T>(self) -> Copied<Self>where
T: 'a + Copy,
Self: Iterator<Item = &'a T>,
1.0.0 · sourcefn cloned<'a, T>(self) -> Cloned<Self>where
T: 'a + Clone,
Self: Iterator<Item = &'a T>,
fn cloned<'a, T>(self) -> Cloned<Self>where
T: 'a + Clone,
Self: Iterator<Item = &'a T>,
sourcefn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
iter_array_chunks
)N
elements of the iterator at a time. Read more1.11.0 · sourcefn sum<S>(self) -> Swhere
S: Sum<Self::Item>,
fn sum<S>(self) -> Swhere
S: Sum<Self::Item>,
1.11.0 · sourcefn product<P>(self) -> Pwhere
P: Product<Self::Item>,
fn product<P>(self) -> Pwhere
P: Product<Self::Item>,
sourcefn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
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>,
fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
sourcefn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
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
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>,
fn eq<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
sourcefn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
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>,
fn ne<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0 · sourcefn lt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn lt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
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>,
fn le<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
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>,
fn gt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
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>,
fn ge<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Iterator
are lexicographically
greater than or equal to those of another. Read moresourcefn is_sorted_by<F>(self, compare: F) -> boolwhere
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by<F>(self, compare: F) -> boolwhere
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
is_sorted
)sourcefn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
is_sorted
)Auto Trait Implementations
impl<'a> RefUnwindSafe for PeekIter<'a>
impl<'a> Send for PeekIter<'a>
impl<'a> Sync for PeekIter<'a>
impl<'a> Unpin for PeekIter<'a>
impl<'a> UnwindSafe for PeekIter<'a>
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>
fn instrument(self, span: Span) -> Instrumented<Self>
sourcefn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
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>where
J: IntoIterator<Item = Self::Item>,
fn interleave<J>(
self,
other: J
) -> Interleave<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator<Item = Self::Item>,
sourcefn interleave_shortest<J>(
self,
other: J
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator<Item = Self::Item>,
fn interleave_shortest<J>(
self,
other: J
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator<Item = Self::Item>,
sourcefn intersperse(
self,
element: Self::Item
) -> IntersperseWith<Self, IntersperseElementSimple<Self::Item>>where
Self::Item: Clone,
fn intersperse(
self,
element: Self::Item
) -> IntersperseWith<Self, IntersperseElementSimple<Self::Item>>where
Self::Item: Clone,
sourcefn intersperse_with<F>(self, element: F) -> IntersperseWith<Self, F>where
F: FnMut() -> Self::Item,
fn intersperse_with<F>(self, element: F) -> IntersperseWith<Self, F>where
F: FnMut() -> Self::Item,
sourcefn zip_longest<J>(
self,
other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
fn zip_longest<J>(
self,
other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
sourcefn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
sourcefn batching<B, F>(self, f: F) -> Batching<Self, F>where
F: FnMut(&mut Self) -> Option<B>,
fn batching<B, F>(self, f: F) -> Batching<Self, F>where
F: FnMut(&mut Self) -> Option<B>,
sourcefn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F>where
F: FnMut(&Self::Item) -> K,
K: PartialEq<K>,
fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F>where
F: FnMut(&Self::Item) -> K,
K: PartialEq<K>,
sourcefn chunks(self, size: usize) -> IntoChunks<Self>
fn chunks(self, size: usize) -> IntoChunks<Self>
sourcefn tuple_windows<T>(self) -> TupleWindows<Self, T>where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
<T as TupleCollect>::Item: Clone,
fn tuple_windows<T>(self) -> TupleWindows<Self, T>where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
<T as TupleCollect>::Item: Clone,
sourcefn circular_tuple_windows<T>(self) -> CircularTupleWindows<Self, T>where
Self: 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>where
Self: Clone + Iterator<Item = <T as TupleCollect>::Item> + ExactSizeIterator,
T: TupleCollect + Clone,
<T as TupleCollect>::Item: Clone,
sourcefn tuples<T>(self) -> Tuples<Self, T>where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn tuples<T>(self) -> Tuples<Self, T>where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
sourcefn tee(self) -> (Tee<Self>, Tee<Self>)where
Self::Item: Clone,
fn tee(self) -> (Tee<Self>, Tee<Self>)where
Self::Item: Clone,
sourcefn step(self, n: usize) -> Step<Self>
fn step(self, n: usize) -> Step<Self>
Use std .step_by() instead
n
elements in the base iterator
for each iteration. Read moresourcefn map_into<R>(self) -> MapSpecialCase<Self, MapSpecialCaseFnInto<R>>where
Self::Item: Into<R>,
fn map_into<R>(self) -> MapSpecialCase<Self, MapSpecialCaseFnInto<R>>where
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>>,
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>>,
F: FnMut(T) -> U,
Use .map_ok() instead
.map_ok()
.sourcefn map_ok<F, T, U, E>(self, f: F) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>where
Self: Iterator<Item = Result<T, E>>,
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>>,
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>where
Self: Iterator<Item = Result<T, E>>,
F: FnMut(&T) -> bool,
fn filter_ok<F, T, E>(self, f: F) -> FilterOk<Self, F>where
Self: Iterator<Item = Result<T, E>>,
F: FnMut(&T) -> bool,
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>where
Self: Iterator<Item = Result<T, E>>,
F: FnMut(T) -> Option<U>,
fn filter_map_ok<F, T, U, E>(self, f: F) -> FilterMapOk<Self, F>where
Self: Iterator<Item = Result<T, E>>,
F: FnMut(T) -> Option<U>,
Result::Ok
value with the provided closure. Result::Err
values are unchanged. Read moresourcefn flatten_ok<T, E>(self) -> FlattenOk<Self, T, E>where
Self: Iterator<Item = Result<T, E>>,
T: IntoIterator,
fn flatten_ok<T, E>(self) -> FlattenOk<Self, T, E>where
Self: Iterator<Item = Result<T, E>>,
T: IntoIterator,
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>where
J: IntoIterator<Item = Self::Item>,
Self::Item: PartialOrd<Self::Item>,
fn merge<J>(
self,
other: J
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>where
J: IntoIterator<Item = Self::Item>,
Self::Item: PartialOrd<Self::Item>,
sourcefn merge_by<J, F>(
self,
other: J,
is_first: F
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>where
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>where
J: IntoIterator<Item = Self::Item>,
F: FnMut(&Self::Item, &Self::Item) -> bool,
sourcefn merge_join_by<J, F>(
self,
other: J,
cmp_fn: F
) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>where
J: IntoIterator,
F: FnMut(&Self::Item, &<J as IntoIterator>::Item) -> Ordering,
fn merge_join_by<J, F>(
self,
other: J,
cmp_fn: F
) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>where
J: IntoIterator,
F: FnMut(&Self::Item, &<J as IntoIterator>::Item) -> Ordering,
sourcefn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt>where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: PartialOrd<<Self::Item as IntoIterator>::Item>,
fn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt>where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: PartialOrd<<Self::Item as IntoIterator>::Item>,
sourcefn kmerge_by<F>(
self,
first: F
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F>where
F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,
Self::Item: IntoIterator,
fn kmerge_by<F>(
self,
first: F
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F>where
F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,
Self::Item: IntoIterator,
sourcefn cartesian_product<J>(
self,
other: J
) -> Product<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
Self::Item: Clone,
<J as IntoIterator>::IntoIter: Clone,
fn cartesian_product<J>(
self,
other: J
) -> Product<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
Self::Item: Clone,
<J as IntoIterator>::IntoIter: Clone,
self
and J
. Read moresourcefn multi_cartesian_product(
self
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>where
Self: Iterator,
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>where
Self: Iterator,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::IntoIter: Clone,
<Self::Item as IntoIterator>::Item: Clone,
self
. Read moresourcefn coalesce<F>(self, f: F) -> CoalesceBy<Self, F, Self::Item>where
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
F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,
sourcefn dedup(self) -> CoalesceBy<Self, DedupPred2CoalescePred<DedupEq>, Self::Item>where
Self::Item: PartialEq<Self::Item>,
fn dedup(self) -> CoalesceBy<Self, DedupPred2CoalescePred<DedupEq>, Self::Item>where
Self::Item: PartialEq<Self::Item>,
sourcefn dedup_by<Cmp>(
self,
cmp: Cmp
) -> CoalesceBy<Self, DedupPred2CoalescePred<Cmp>, Self::Item>where
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
fn dedup_by<Cmp>(
self,
cmp: Cmp
) -> CoalesceBy<Self, DedupPred2CoalescePred<Cmp>, Self::Item>where
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
sourcefn dedup_with_count(
self
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<DedupEq>, (usize, Self::Item)>
fn dedup_with_count(
self
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<DedupEq>, (usize, Self::Item)>
sourcefn dedup_by_with_count<Cmp>(
self,
cmp: Cmp
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<Cmp>, (usize, Self::Item)>where
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
fn dedup_by_with_count<Cmp>(
self,
cmp: Cmp
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<Cmp>, (usize, Self::Item)>where
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
sourcefn duplicates(self) -> DuplicatesBy<Self, Self::Item, ById>where
Self::Item: Eq,
Self::Item: Hash,
fn duplicates(self) -> DuplicatesBy<Self, Self::Item, ById>where
Self::Item: Eq,
Self::Item: Hash,
sourcefn duplicates_by<V, F>(self, f: F) -> DuplicatesBy<Self, V, ByFn<F>>where
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
fn duplicates_by<V, F>(self, f: F) -> DuplicatesBy<Self, V, ByFn<F>>where
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
sourcefn unique(self) -> Unique<Self>where
Self::Item: Clone,
Self::Item: Eq,
Self::Item: Hash,
fn unique(self) -> Unique<Self>where
Self::Item: Clone,
Self::Item: Eq,
Self::Item: Hash,
sourcefn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>where
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>where
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
sourcefn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F>where
Self: PeekingNext,
F: FnMut(&Self::Item) -> bool,
fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F>where
Self: PeekingNext,
F: FnMut(&Self::Item) -> bool,
accept
returns true
. Read moresourcefn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>where
Self: Clone,
F: FnMut(&Self::Item) -> bool,
fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>where
Self: Clone,
F: FnMut(&Self::Item) -> bool,
Clone
-able iterator
to only pick off elements while the predicate accept
returns true
. Read moresourcefn while_some<A>(self) -> WhileSome<Self>where
Self: Iterator<Item = Option<A>>,
fn while_some<A>(self) -> WhileSome<Self>where
Self: Iterator<Item = Option<A>>,
Option<A>
iterator elements
and produces A
. Stops on the first None
encountered. Read moresourcefn tuple_combinations<T>(self) -> TupleCombinations<Self, T>where
Self: Clone,
T: HasCombination<Self>,
Self::Item: Clone,
fn tuple_combinations<T>(self) -> TupleCombinations<Self, T>where
Self: Clone,
T: HasCombination<Self>,
Self::Item: Clone,
sourcefn combinations(self, k: usize) -> Combinations<Self>where
Self::Item: Clone,
fn combinations(self, k: usize) -> Combinations<Self>where
Self::Item: Clone,
k
-length combinations of
the elements from an iterator. Read moresourcefn combinations_with_replacement(
self,
k: usize
) -> CombinationsWithReplacement<Self>where
Self::Item: Clone,
fn combinations_with_replacement(
self,
k: usize
) -> CombinationsWithReplacement<Self>where
Self::Item: Clone,
k
-length combinations of
the elements from an iterator, with replacement. Read moresourcefn permutations(self, k: usize) -> Permutations<Self>where
Self::Item: Clone,
fn permutations(self, k: usize) -> Permutations<Self>where
Self::Item: Clone,
sourcefn powerset(self) -> Powerset<Self>where
Self::Item: Clone,
fn powerset(self) -> Powerset<Self>where
Self::Item: Clone,
sourcefn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>where
F: FnMut(usize) -> Self::Item,
fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>where
F: FnMut(usize) -> Self::Item,
min
by filling missing elements using a closure f
. Read moresourcefn with_position(self) -> WithPosition<Self>
fn with_position(self) -> WithPosition<Self>
Position
to
ease special-case handling of the first or last elements. Read moresourcefn positions<P>(self, predicate: P) -> Positions<Self, P>where
P: FnMut(Self::Item) -> bool,
fn positions<P>(self, predicate: P) -> Positions<Self, P>where
P: FnMut(Self::Item) -> bool,
sourcefn update<F>(self, updater: F) -> Update<Self, F>where
F: FnMut(&mut Self::Item),
fn update<F>(self, updater: F) -> Update<Self, F>where
F: FnMut(&mut Self::Item),
sourcefn next_tuple<T>(&mut self) -> Option<T>where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn next_tuple<T>(&mut self) -> Option<T>where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
sourcefn collect_tuple<T>(self) -> Option<T>where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn collect_tuple<T>(self) -> Option<T>where
Self: 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
P: FnMut(&Self::Item) -> bool,
fn find_or_last<P>(self, predicate: P) -> Option<Self::Item>where
P: FnMut(&Self::Item) -> bool,
sourcefn find_or_first<P>(self, predicate: P) -> Option<Self::Item>where
P: FnMut(&Self::Item) -> bool,
fn find_or_first<P>(self, predicate: P) -> Option<Self::Item>where
P: FnMut(&Self::Item) -> bool,
sourcefn contains<Q>(&mut self, query: &Q) -> boolwhere
Q: PartialEq<Q>,
Self::Item: Borrow<Q>,
fn contains<Q>(&mut self, query: &Q) -> boolwhere
Q: PartialEq<Q>,
Self::Item: Borrow<Q>,
true
if the given item is present in this iterator. Read moresourcefn all_equal(&mut self) -> boolwhere
Self::Item: PartialEq<Self::Item>,
fn all_equal(&mut self) -> boolwhere
Self::Item: PartialEq<Self::Item>,
sourcefn all_unique(&mut self) -> boolwhere
Self::Item: Eq,
Self::Item: Hash,
fn all_unique(&mut self) -> boolwhere
Self::Item: Eq,
Self::Item: Hash,
sourcefn dropping(self, n: usize) -> Self
fn dropping(self, n: usize) -> Self
n
elements from the iterator eagerly,
and return the same iterator again. Read moresourcefn dropping_back(self, n: usize) -> Selfwhere
Self: DoubleEndedIterator,
fn dropping_back(self, n: usize) -> Selfwhere
Self: 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),
fn foreach<F>(self, f: F)where
F: FnMut(Self::Item),
Use .for_each() instead
f
eagerly on each element of the iterator. Read moresourcefn concat(self) -> Self::Itemwhere
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
fn concat(self) -> Self::Itemwhere
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: 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,
fn collect_vec(self) -> Vec<Self::Item, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
A: Allocator,
A: Allocator,
sourcefn try_collect<T, U, E>(self) -> Result<U, E>where
Self: Iterator<Item = Result<T, E>>,
Result<U, E>: FromIterator<Result<T, E>>,
fn try_collect<T, U, E>(self) -> Result<U, E>where
Self: 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>
fn format(self, sep: &str) -> Format<'_, Self>
sep
. Read moresourcefn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F>where
F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display)) -> Result<(), Error>,
fn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F>where
F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display)) -> 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,
Use .fold_ok() instead
.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,
fn fold1<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
sourcefn tree_fold1<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn tree_fold1<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
sourcefn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B>where
F: FnMut(B, Self::Item) -> FoldWhile<B>,
fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B>where
F: FnMut(B, Self::Item) -> FoldWhile<B>,
sourcefn sum1<S>(self) -> Option<S>where
S: Sum<Self::Item>,
fn sum1<S>(self) -> Option<S>where
S: Sum<Self::Item>,
sourcefn product1<P>(self) -> Option<P>where
P: Product<Self::Item>,
fn product1<P>(self) -> Option<P>where
P: Product<Self::Item>,
sourcefn sorted_unstable(self) -> IntoIter<Self::Item, Global>where
Self::Item: Ord,
fn sorted_unstable(self) -> IntoIter<Self::Item, Global>where
Self::Item: Ord,
sourcefn sorted_unstable_by<F>(self, cmp: F) -> IntoIter<Self::Item, Global>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn sorted_unstable_by<F>(self, cmp: F) -> IntoIter<Self::Item, Global>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
sourcefn sorted_unstable_by_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>where
K: Ord,
F: FnMut(&Self::Item) -> K,
fn sorted_unstable_by_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>where
K: Ord,
F: FnMut(&Self::Item) -> K,
sourcefn sorted(self) -> IntoIter<Self::Item, Global>where
Self::Item: Ord,
fn sorted(self) -> IntoIter<Self::Item, Global>where
Self::Item: Ord,
sourcefn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item, Global>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item, Global>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
sourcefn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>where
K: Ord,
F: FnMut(&Self::Item) -> K,
fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>where
K: Ord,
F: FnMut(&Self::Item) -> K,
sourcefn k_smallest(self, k: usize) -> IntoIter<Self::Item, Global>where
Self::Item: Ord,
fn k_smallest(self, k: usize) -> IntoIter<Self::Item, Global>where
Self::Item: Ord,
sourcefn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B)where
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
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>>,
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>>,
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)>,
K: Hash + Eq,
fn into_group_map<K, V>(self) -> HashMap<K, Vec<V, Global>, RandomState>where
Self: Iterator<Item = (K, V)>,
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>,
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>,
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.
Different to into_group_map_by
because the key is still present. It is also more general.
You can also fold the group_map
. Read moresourcefn into_grouping_map<K, V>(self) -> GroupingMap<Self>where
Self: Iterator<Item = (K, V)>,
K: Hash + Eq,
fn into_grouping_map<K, V>(self) -> GroupingMap<Self>where
Self: Iterator<Item = (K, V)>,
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>,
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>,
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 minmax(self) -> MinMaxResult<Self::Item>where
Self::Item: PartialOrd<Self::Item>,
fn minmax(self) -> MinMaxResult<Self::Item>where
Self::Item: PartialOrd<Self::Item>,
sourcefn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item>where
K: PartialOrd<K>,
F: FnMut(&Self::Item) -> K,
fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item>where
K: PartialOrd<K>,
F: FnMut(&Self::Item) -> K,
sourcefn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
sourcefn position_max(self) -> Option<usize>where
Self::Item: Ord,
fn position_max(self) -> Option<usize>where
Self::Item: Ord,
sourcefn position_max_by_key<K, F>(self, key: F) -> Option<usize>where
K: Ord,
F: FnMut(&Self::Item) -> K,
fn position_max_by_key<K, F>(self, key: F) -> Option<usize>where
K: Ord,
F: FnMut(&Self::Item) -> K,
sourcefn position_max_by<F>(self, compare: F) -> Option<usize>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn position_max_by<F>(self, compare: F) -> Option<usize>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
sourcefn position_min(self) -> Option<usize>where
Self::Item: Ord,
fn position_min(self) -> Option<usize>where
Self::Item: Ord,
sourcefn position_min_by_key<K, F>(self, key: F) -> Option<usize>where
K: Ord,
F: FnMut(&Self::Item) -> K,
fn position_min_by_key<K, F>(self, key: F) -> Option<usize>where
K: Ord,
F: FnMut(&Self::Item) -> K,
sourcefn position_min_by<F>(self, compare: F) -> Option<usize>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn position_min_by<F>(self, compare: F) -> Option<usize>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
sourcefn position_minmax(self) -> MinMaxResult<usize>where
Self::Item: PartialOrd<Self::Item>,
fn position_minmax(self) -> MinMaxResult<usize>where
Self::Item: PartialOrd<Self::Item>,
sourcefn position_minmax_by_key<K, F>(self, key: F) -> MinMaxResult<usize>where
K: PartialOrd<K>,
F: FnMut(&Self::Item) -> K,
fn position_minmax_by_key<K, F>(self, key: F) -> MinMaxResult<usize>where
K: PartialOrd<K>,
F: FnMut(&Self::Item) -> K,
sourcefn position_minmax_by<F>(self, compare: F) -> MinMaxResult<usize>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn position_minmax_by<F>(self, compare: F) -> MinMaxResult<usize>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
sourcefn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>>
fn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>>
sourcefn at_most_one(self) -> Result<Option<Self::Item>, ExactlyOneError<Self>>
fn at_most_one(self) -> Result<Option<Self::Item>, ExactlyOneError<Self>>
sourcefn multipeek(self) -> MultiPeek<Self>
fn multipeek(self) -> MultiPeek<Self>
.next()
values without advancing the base iterator. Read moresourcefn counts(self) -> HashMap<Self::Item, usize, RandomState>where
Self::Item: Eq,
Self::Item: Hash,
fn counts(self) -> HashMap<Self::Item, usize, RandomState>where
Self::Item: Eq,
Self::Item: 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
K: Eq + Hash,
F: FnMut(Self::Item) -> K,
fn counts_by<K, F>(self, f: F) -> HashMap<K, usize, RandomState>where
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 moreimpl<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>where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
S: Into<Dispatch>,
sourcefn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
impl<'a, T> Captures<'a> for Twhere
T: ?Sized,
Layout
Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...)
attributes. Please see the Rust Reference’s “Type Layout” chapter for details on type layout guarantees.
Size: 56 bytes