1.0.0[−][src]Struct core::iter::Map
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> = vec![1, 2, 3].into_iter().map(|x| x + 1).rev().collect(); assert_eq!(v, [4, 3, 2]);Run
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 vec!['a', 'b', 'c'].into_iter() .map(|letter| { c += 1; (letter, c) }) { println!("{:?}", pair); }Run
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 vec!['a', 'b', 'c'].into_iter() .map(|letter| { c += 1; (letter, c) }) .rev() { println!("{:?}", pair); }Run
Trait Implementations
impl<I: Clone, F: Clone> Clone for Map<I, F>
[src]
ⓘImportant traits for Map<I, F>fn clone(&self) -> Map<I, F>
[src]
fn clone_from(&mut self, source: &Self)
[src]
impl<B, I: Iterator, F> Iterator for Map<I, F> where
F: FnMut(I::Item) -> B,
[src]
F: FnMut(I::Item) -> B,
type Item = B
The type of the elements being iterated over.
fn next(&mut self) -> Option<B>
[src]
fn size_hint(&self) -> (usize, Option<usize>)
[src]
fn try_fold<Acc, G, R>(&mut self, init: Acc, g: G) -> R where
Self: Sized,
G: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
[src]
Self: Sized,
G: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
fn fold<Acc, G>(self, init: Acc, g: G) -> Acc where
G: FnMut(Acc, Self::Item) -> Acc,
[src]
G: FnMut(Acc, Self::Item) -> Acc,
fn count(self) -> usize where
Self: Sized,
[src]
Self: Sized,
fn last(self) -> Option<Self::Item> where
Self: Sized,
[src]
Self: Sized,
fn nth(&mut self, n: usize) -> Option<Self::Item>
[src]
ⓘImportant traits for StepBy<I>fn step_by(self, step: usize) -> StepBy<Self> where
Self: Sized,
1.28.0[src]
Self: Sized,
ⓘImportant traits for Chain<A, B>fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter> where
Self: Sized,
U: IntoIterator<Item = Self::Item>,
[src]
Self: Sized,
U: IntoIterator<Item = Self::Item>,
ⓘImportant traits for Zip<A, B>fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter> where
Self: Sized,
U: IntoIterator,
[src]
Self: Sized,
U: IntoIterator,
ⓘImportant traits for Map<I, F>fn map<B, F>(self, f: F) -> Map<Self, F> where
Self: Sized,
F: FnMut(Self::Item) -> B,
[src]
Self: Sized,
F: FnMut(Self::Item) -> B,
fn for_each<F>(self, f: F) where
Self: Sized,
F: FnMut(Self::Item),
1.21.0[src]
Self: Sized,
F: FnMut(Self::Item),
ⓘImportant traits for Filter<I, P>fn filter<P>(self, predicate: P) -> Filter<Self, P> where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
ⓘImportant traits for FilterMap<I, F>fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
[src]
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
ⓘImportant traits for Enumerate<I>fn enumerate(self) -> Enumerate<Self> where
Self: Sized,
[src]
Self: Sized,
ⓘImportant traits for Peekable<I>fn peekable(self) -> Peekable<Self> where
Self: Sized,
[src]
Self: Sized,
ⓘImportant traits for SkipWhile<I, P>fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
ⓘImportant traits for TakeWhile<I, P>fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
ⓘImportant traits for Skip<I>fn skip(self, n: usize) -> Skip<Self> where
Self: Sized,
[src]
Self: Sized,
ⓘImportant traits for Take<I>fn take(self, n: usize) -> Take<Self> where
Self: Sized,
[src]
Self: Sized,
ⓘImportant traits for Scan<I, St, F>fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
[src]
Self: Sized,
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
Self: Sized,
U: IntoIterator,
F: FnMut(Self::Item) -> U,
[src]
Self: Sized,
U: IntoIterator,
F: FnMut(Self::Item) -> U,
ⓘImportant traits for Flatten<I>fn flatten(self) -> Flatten<Self> where
Self: Sized,
Self::Item: IntoIterator,
1.29.0[src]
Self: Sized,
Self::Item: IntoIterator,
ⓘImportant traits for Fuse<I>fn fuse(self) -> Fuse<Self> where
Self: Sized,
[src]
Self: Sized,
ⓘImportant traits for Inspect<I, F>fn inspect<F>(self, f: F) -> Inspect<Self, F> where
Self: Sized,
F: FnMut(&Self::Item),
[src]
Self: Sized,
F: FnMut(&Self::Item),
fn by_ref(&mut self) -> &mut Self where
Self: Sized,
[src]
Self: Sized,
#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]
fn collect<B: FromIterator<Self::Item>>(self) -> B where
Self: Sized,
[src]
Self: Sized,
fn partition<B, F>(self, f: F) -> (B, B) where
Self: Sized,
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
[src]
Self: Sized,
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
fn partition_in_place<'a, T: 'a, P>(self, predicate: P) -> usize where
Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
P: FnMut(&T) -> bool,
[src]
Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
P: FnMut(&T) -> bool,
fn is_partitioned<P>(self, predicate: P) -> bool where
Self: Sized,
P: FnMut(Self::Item) -> bool,
[src]
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn try_for_each<F, R>(&mut self, f: F) -> R where
Self: Sized,
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
1.27.0[src]
Self: Sized,
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
fn all<F>(&mut self, f: F) -> bool where
Self: Sized,
F: FnMut(Self::Item) -> bool,
[src]
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> bool where
Self: Sized,
F: FnMut(Self::Item) -> bool,
[src]
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
1.30.0[src]
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn position<P>(&mut self, predicate: P) -> Option<usize> where
Self: Sized,
P: FnMut(Self::Item) -> bool,
[src]
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: Sized + ExactSizeIterator + DoubleEndedIterator,
[src]
P: FnMut(Self::Item) -> bool,
Self: Sized + ExactSizeIterator + DoubleEndedIterator,
fn max(self) -> Option<Self::Item> where
Self: Sized,
Self::Item: Ord,
[src]
Self: Sized,
Self::Item: Ord,
fn min(self) -> Option<Self::Item> where
Self: Sized,
Self::Item: Ord,
[src]
Self: Sized,
Self::Item: Ord,
fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item> where
Self: Sized,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item> where
Self: Sized,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
ⓘImportant traits for Rev<I>fn rev(self) -> Rev<Self> where
Self: Sized + DoubleEndedIterator,
[src]
Self: Sized + DoubleEndedIterator,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Sized + Iterator<Item = (A, B)>,
[src]
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Sized + Iterator<Item = (A, B)>,
ⓘImportant traits for Copied<I>fn copied<'a, T: 'a>(self) -> Copied<Self> where
Self: Sized + Iterator<Item = &'a T>,
T: Copy,
1.36.0[src]
Self: Sized + Iterator<Item = &'a T>,
T: Copy,
ⓘImportant traits for Cloned<I>fn cloned<'a, T: 'a>(self) -> Cloned<Self> where
Self: Sized + Iterator<Item = &'a T>,
T: Clone,
[src]
Self: Sized + Iterator<Item = &'a T>,
T: Clone,
ⓘImportant traits for Cycle<I>fn cycle(self) -> Cycle<Self> where
Self: Sized + Clone,
[src]
Self: Sized + Clone,
fn sum<S>(self) -> S where
Self: Sized,
S: Sum<Self::Item>,
1.11.0[src]
Self: Sized,
S: Sum<Self::Item>,
fn product<P>(self) -> P where
Self: Sized,
P: Product<Self::Item>,
1.11.0[src]
Self: Sized,
P: Product<Self::Item>,
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
Self: Sized,
1.5.0[src]
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
Self: Sized,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, I::Item) -> Ordering,
[src]
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, I::Item) -> Ordering,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, I::Item) -> Option<Ordering>,
[src]
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, I::Item) -> Option<Ordering>,
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<I::Item>,
Self: Sized,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<I::Item>,
Self: Sized,
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, I::Item) -> bool,
[src]
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, I::Item) -> bool,
fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<I::Item>,
Self: Sized,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<I::Item>,
Self: Sized,
fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
fn is_sorted(self) -> bool where
Self: Sized,
Self::Item: PartialOrd,
[src]
Self: Sized,
Self::Item: PartialOrd,
fn is_sorted_by<F>(self, compare: F) -> bool where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
Self: Sized,
F: FnMut(Self::Item) -> K,
K: PartialOrd,
[src]
Self: Sized,
F: FnMut(Self::Item) -> K,
K: PartialOrd,
impl<B, I: DoubleEndedIterator, F> DoubleEndedIterator for Map<I, F> where
F: FnMut(I::Item) -> B,
[src]
F: FnMut(I::Item) -> B,
fn next_back(&mut self) -> Option<B>
[src]
fn try_rfold<Acc, G, R>(&mut self, init: Acc, g: G) -> R where
Self: Sized,
G: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
[src]
Self: Sized,
G: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
fn rfold<Acc, G>(self, init: Acc, g: G) -> Acc where
G: FnMut(Acc, Self::Item) -> Acc,
[src]
G: FnMut(Acc, Self::Item) -> Acc,
fn nth_back(&mut self, n: usize) -> Option<Self::Item>
1.37.0[src]
fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
1.27.0[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
impl<B, I: ExactSizeIterator, F> ExactSizeIterator for Map<I, F> where
F: FnMut(I::Item) -> B,
[src]
F: FnMut(I::Item) -> B,
impl<B, I: FusedIterator, F> FusedIterator for Map<I, F> where
F: FnMut(I::Item) -> B,
1.26.0[src]
F: FnMut(I::Item) -> B,
impl<B, I, F> TrustedLen for Map<I, F> where
I: TrustedLen,
F: FnMut(I::Item) -> B,
[src]
I: TrustedLen,
F: FnMut(I::Item) -> B,
impl<I: Debug, F> Debug for Map<I, F>
1.9.0[src]
Auto Trait Implementations
impl<I, F> Send for Map<I, F> where
F: Send,
I: Send,
F: Send,
I: Send,
impl<I, F> Sync for Map<I, F> where
F: Sync,
I: Sync,
F: Sync,
I: Sync,
impl<I, F> Unpin for Map<I, F> where
F: Unpin,
I: Unpin,
F: Unpin,
I: Unpin,
Blanket Implementations
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, 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(U) -> Result<T, <T as TryFrom<U>>::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,
fn borrow_mut(&mut Self) -> &mut T
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,