1.0.0[−][src]Struct std::iter::Enumerate
An iterator that yields the current count and the element during iteration.
This struct is created by the enumerate method on Iterator. See its
documentation for more.
Trait Implementations
impl<I> FusedIterator for Enumerate<I> where
I: FusedIterator, 1.26.0[src]
I: FusedIterator,
impl<I> Iterator for Enumerate<I> where
I: Iterator, [src]
I: Iterator,
type Item = (usize, <I as Iterator>::Item)
The type of the elements being iterated over.
fn next(&mut self) -> Option<(usize, <I as Iterator>::Item)>[src]
Overflow Behavior
The method does no guarding against overflows, so enumerating more than
usize::MAX elements either produces the wrong result or panics. If
debug assertions are enabled, a panic is guaranteed.
Panics
Might panic if the index of the element overflows a usize.
fn size_hint(&self) -> (usize, Option<usize>)[src]
fn nth(&mut self, n: usize) -> Option<(usize, <I as Iterator>::Item)>[src]
fn count(self) -> usize[src]
fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
Fold: FnMut(Acc, <Enumerate<I> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Enumerate<I>: Sized, [src]
Fold: FnMut(Acc, <Enumerate<I> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Enumerate<I>: Sized,
fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
Fold: FnMut(Acc, <Enumerate<I> as Iterator>::Item) -> Acc, [src]
Fold: FnMut(Acc, <Enumerate<I> as Iterator>::Item) -> Acc,
fn last(self) -> Option<Self::Item>[src]
ⓘImportant traits for StepBy<I>fn step_by(self, step: usize) -> StepBy<Self>1.28.0[src]
ⓘImportant traits for StepBy<I>
ⓘImportant traits for Chain<A, B>fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>, [src]
ⓘImportant traits for Chain<A, B>
U: IntoIterator<Item = Self::Item>,
ⓘImportant traits for Zip<A, B>fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator, [src]
ⓘImportant traits for Zip<A, B>
U: IntoIterator,
ⓘImportant traits for Map<I, F>fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B, [src]
ⓘImportant traits for Map<I, F>
F: FnMut(Self::Item) -> B,
fn for_each<F>(self, f: F) where
F: FnMut(Self::Item), 1.21.0[src]
F: FnMut(Self::Item),
ⓘImportant traits for Filter<I, P>fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool, [src]
ⓘImportant traits for Filter<I, P>
P: FnMut(&Self::Item) -> bool,
ⓘImportant traits for FilterMap<I, F>fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>, [src]
ⓘImportant traits for FilterMap<I, F>
F: FnMut(Self::Item) -> Option<B>,
ⓘImportant traits for Enumerate<I>fn enumerate(self) -> Enumerate<Self>[src]
ⓘImportant traits for Enumerate<I>
ⓘImportant traits for Peekable<I>fn peekable(self) -> Peekable<Self>[src]
ⓘImportant traits for Peekable<I>
ⓘImportant traits for SkipWhile<I, P>fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool, [src]
ⓘImportant traits for SkipWhile<I, P>
P: FnMut(&Self::Item) -> bool,
ⓘImportant traits for TakeWhile<I, P>fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool, [src]
ⓘImportant traits for TakeWhile<I, P>
P: FnMut(&Self::Item) -> bool,
ⓘImportant traits for Skip<I>fn skip(self, n: usize) -> Skip<Self>[src]
ⓘImportant traits for Skip<I>
ⓘImportant traits for Take<I>fn take(self, n: usize) -> Take<Self>[src]
ⓘImportant traits for Take<I>
ⓘImportant traits for Scan<I, St, F>fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>, [src]
ⓘImportant traits for Scan<I, St, F>
F: FnMut(&mut St, Self::Item) -> Option<B>,
ⓘImportant traits for FlatMap<I, U, F>fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator, [src]
ⓘImportant traits for FlatMap<I, U, F>
F: FnMut(Self::Item) -> U,
U: IntoIterator,
ⓘImportant traits for Flatten<I>fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator, 1.29.0[src]
ⓘImportant traits for Flatten<I>
Self::Item: IntoIterator,
ⓘImportant traits for Fuse<I>fn fuse(self) -> Fuse<Self>[src]
ⓘImportant traits for Fuse<I>
ⓘImportant traits for Inspect<I, F>fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item), [src]
ⓘImportant traits for Inspect<I, F>
F: FnMut(&Self::Item),
ⓘImportant traits for &'_ mut Ifn by_ref(&mut self) -> &mut Self[src]
ⓘImportant traits for &'_ mut I
#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]
fn collect<B>(self) -> B where
B: FromIterator<Self::Item>, [src]
B: FromIterator<Self::Item>,
fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool, [src]
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
P: FnMut(&T) -> bool,
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a, [src]
P: FnMut(&T) -> bool,
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool, [src]
P: FnMut(Self::Item) -> bool,
fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>, 1.27.0[src]
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool, [src]
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool, [src]
F: FnMut(Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool, [src]
P: FnMut(&Self::Item) -> bool,
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>, 1.30.0[src]
F: FnMut(Self::Item) -> Option<B>,
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool, [src]
P: FnMut(Self::Item) -> bool,
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator, [src]
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord, [src]
Self::Item: Ord,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord, [src]
Self::Item: Ord,
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B, 1.6.0[src]
B: Ord,
F: FnMut(&Self::Item) -> B,
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering, 1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B, 1.6.0[src]
B: Ord,
F: FnMut(&Self::Item) -> B,
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering, 1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
ⓘImportant traits for Rev<I>fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator, [src]
ⓘImportant traits for Rev<I>
Self: DoubleEndedIterator,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>, [src]
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
ⓘImportant traits for Copied<I>fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy, 1.36.0[src]
ⓘImportant traits for Copied<I>
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
ⓘImportant traits for Cloned<I>fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Clone, [src]
ⓘImportant traits for Cloned<I>
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
ⓘImportant traits for Cycle<I>fn cycle(self) -> Cycle<Self> where
Self: Clone, [src]
ⓘImportant traits for Cycle<I>
Self: Clone,
fn sum<S>(self) -> S where
S: Sum<Self::Item>, 1.11.0[src]
S: Sum<Self::Item>,
fn product<P>(self) -> P where
P: Product<Self::Item>, 1.11.0[src]
P: Product<Self::Item>,
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord, 1.5.0[src]
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator, [src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator, [src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator,
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator, [src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>, [src]
Self::Item: PartialOrd<Self::Item>,
fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>, [src]
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>, [src]
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
impl<I> Clone for Enumerate<I> where
I: Clone, [src]
I: Clone,
ⓘImportant traits for Enumerate<I>fn clone(&self) -> Enumerate<I>[src]
ⓘImportant traits for Enumerate<I>
fn clone_from(&mut self, source: &Self)[src]
impl<I> TrustedLen for Enumerate<I> where
I: TrustedLen, [src]
I: TrustedLen,
impl<I> ExactSizeIterator for Enumerate<I> where
I: ExactSizeIterator, [src]
I: ExactSizeIterator,
impl<I> DoubleEndedIterator for Enumerate<I> where
I: ExactSizeIterator + DoubleEndedIterator, [src]
I: ExactSizeIterator + DoubleEndedIterator,
fn next_back(&mut self) -> Option<(usize, <I as Iterator>::Item)>[src]
fn nth_back(&mut self, n: usize) -> Option<(usize, <I as Iterator>::Item)>[src]
fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
Fold: FnMut(Acc, <Enumerate<I> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Enumerate<I>: Sized, [src]
Fold: FnMut(Acc, <Enumerate<I> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Enumerate<I>: Sized,
fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
Fold: FnMut(Acc, <Enumerate<I> as Iterator>::Item) -> Acc, [src]
Fold: FnMut(Acc, <Enumerate<I> as Iterator>::Item) -> Acc,
fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool, 1.27.0[src]
P: FnMut(&Self::Item) -> bool,
impl<I> Debug for Enumerate<I> where
I: Debug, [src]
I: Debug,
Auto Trait Implementations
impl<I> UnwindSafe for Enumerate<I> where
I: UnwindSafe,
I: UnwindSafe,
impl<I> RefUnwindSafe for Enumerate<I> where
I: RefUnwindSafe,
I: RefUnwindSafe,
impl<I> Unpin for Enumerate<I> where
I: Unpin,
I: Unpin,
impl<I> Send for Enumerate<I> where
I: Send,
I: Send,
impl<I> Sync for Enumerate<I> where
I: Sync,
I: Sync,
Blanket Implementations
impl<I> IntoIterator for I where
I: Iterator, [src]
I: Iterator,
type Item = <I as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = I
Which kind of iterator are we turning this into?
fn into_iter(self) -> I[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]
impl<T, U> Into<U> for T where
U: From<T>, [src]
U: From<T>,
impl<T> From<T> for T[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]
impl<T> Borrow<T> for T where
T: ?Sized, [src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized, [src]
T: ?Sized,
ⓘImportant traits for &'_ mut Ifn borrow_mut(&mut self) -> &mut T[src]
ⓘImportant traits for &'_ mut I
impl<T> Any for T where
T: 'static + ?Sized, [src]
T: 'static + ?Sized,
impl<T> ToOwned for T where
T: Clone, [src]
T: Clone,