Struct std::iter::Map

#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct Map<I, F> { /* fields omitted */ }

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]);

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);
}

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);
}

Trait Implementations

impl<I, F> Clone for Map<I, F> where
    F: Clone,
    I: Clone,  [src]

fn clone(&self) -> Map<I, F> [src]

fn clone_from(&mut self, source: &Self) [src]

impl<B, I, F> DoubleEndedIterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: DoubleEndedIterator,  [src]

fn next_back(&mut self) -> Option<B> [src]

fn try_rfold<Acc, G, R>(&mut self, init: Acc, g: G) -> R where
    G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> R,
    R: Try<Ok = Acc>,
    Map<I, F>: Sized,  [src]

fn rfold<Acc, G>(self, init: Acc, g: G) -> Acc where
    G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> Acc,  [src]

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool,  [src]

impl<B, I, F> FusedIterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: FusedIterator,  [src]

impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,  [src]

type Item = B

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
    G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> R,
    R: Try<Ok = Acc>,
    Map<I, F>: Sized,  [src]

fn fold<Acc, G>(self, init: Acc, g: G) -> Acc where
    G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> Acc,  [src]

fn count(self) -> usize [src]

fn last(self) -> Option<Self::Item> [src]

fn nth(&mut self, n: usize) -> Option<Self::Item> [src]

fn step_by(self, step: usize) -> StepBy<Self> [src]

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
    U: IntoIterator<Item = Self::Item>,  [src]

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
    U: IntoIterator,  [src]

fn map<B, F>(self, f: F) -> Map<Self, F> where
    F: FnMut(Self::Item) -> B,  [src]

fn for_each<F>(self, f: F) where
    F: FnMut(Self::Item) -> (), 

1.21.0

[src]

fn filter<P>(self, predicate: P) -> Filter<Self, P> where
    P: FnMut(&Self::Item) -> bool,  [src]

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
    F: FnMut(Self::Item) -> Option<B>,  [src]

fn enumerate(self) -> Enumerate<Self> [src]

fn peekable(self) -> Peekable<Self> [src]

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
    P: FnMut(&Self::Item) -> bool,  [src]

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
    P: FnMut(&Self::Item) -> bool,  [src]

fn skip(self, n: usize) -> Skip<Self> [src]

fn take(self, n: usize) -> Take<Self> [src]

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]

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
    F: FnMut(Self::Item) -> U,
    U: IntoIterator,  [src]

fn fuse(self) -> Fuse<Self> [src]

fn inspect<F>(self, f: F) -> Inspect<Self, F> where
    F: FnMut(&Self::Item) -> (),  [src]

fn by_ref(&mut self) -> &mut Self [src]

fn collect<B>(self) -> B where
    B: FromIterator<Self::Item>,  [src]

fn partition<B, F>(self, f: F) -> (B, B) where
    B: Default + Extend<Self::Item>,
    F: FnMut(&Self::Item) -> bool,  [src]

fn all<F>(&mut self, f: F) -> bool where
    F: FnMut(Self::Item) -> bool,  [src]

fn any<F>(&mut self, f: F) -> bool where
    F: FnMut(Self::Item) -> bool,  [src]

fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool,  [src]

fn position<P>(&mut self, predicate: P) -> Option<usize> where
    P: FnMut(Self::Item) -> bool,  [src]

fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
    P: FnMut(Self::Item) -> bool,
    Self: ExactSizeIterator + DoubleEndedIterator,  [src]

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord,  [src]

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord,  [src]

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
    B: Ord,
    F: FnMut(&Self::Item) -> B, 

1.6.0

[src]

fn max_by<F>(self, compare: F) -> Option<Self::Item> where
    F: FnMut(&Self::Item, &Self::Item) -> Ordering, 

1.15.0

[src]

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
    B: Ord,
    F: FnMut(&Self::Item) -> B, 

1.6.0

[src]

fn min_by<F>(self, compare: F) -> Option<Self::Item> where
    F: FnMut(&Self::Item, &Self::Item) -> Ordering, 

1.15.0

[src]

fn rev(self) -> Rev<Self> where
    Self: DoubleEndedIterator,  [src]

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    Self: Iterator<Item = (A, B)>,  [src]

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: Iterator<Item = &'a T>,
    T: 'a + Clone,  [src]

fn cycle(self) -> Cycle<Self> where
    Self: Clone,  [src]

fn sum<S>(self) -> S where
    S: Sum<Self::Item>, 

1.11.0

[src]

fn product<P>(self) -> P where
    P: Product<Self::Item>, 

1.11.0

[src]

fn cmp<I>(self, other: I) -> Ordering where
    I: IntoIterator<Item = Self::Item>,
    Self::Item: Ord, 

1.5.0

[src]

fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

1.5.0

[src]

fn eq<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialEq<<I as IntoIterator>::Item>, 

1.5.0

[src]

fn ne<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialEq<<I as IntoIterator>::Item>, 

1.5.0

[src]

fn lt<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

1.5.0

[src]

fn le<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

1.5.0

[src]

fn gt<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

1.5.0

[src]

fn ge<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

1.5.0

[src]

impl<B, I, F> ExactSizeIterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: ExactSizeIterator,  [src]

fn len(&self) -> usize [src]

fn is_empty(&self) -> bool [src]

impl<B, I, F> TrustedLen for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: TrustedLen,  [src]

impl<I, F> Debug for Map<I, F> where
    I: Debug, 

1.9.0

[src]

fn fmt(&self, f: &mut Formatter) -> Result<(), Error> [src]