Struct Map 

pub struct Map<I, F> { /* private fields */ }

Available on crate feature ferrocene_certified only.

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

impl<I: Clone, F: Clone> Clone for Map<I, F>

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

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

where Self:,

Performs copy-assignment from source.

impl<B, I: Iterator, F> Iterator for Map<I, F>

where F: FnMut(I::Item) -> B,

type Item = B

The type of the elements being iterated over.

fn next(&mut self) -> Option<B>

Advances the iterator and returns the next value.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Takes a closure and creates an iterator which calls that closure on each element.

fn cloned<'a, T>(self) -> Cloned<Self>

where T: Clone + 'a, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which clones all of its elements.

impl<B, I, F> TrustedLen for Map<I, F>

where I: TrustedLen, F: FnMut(I::Item) -> B,