#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct Map<I, F> {
// some fields omitted
}1.0.0An iterator that maps the values of iter with f.
This struct is created by the map() method on Iterator. See its
documentation for more.
The map() iterator implements DoubleEndedIterator, meaning that
you can also map() backwards:
fn main() {
let v: Vec<i32> = vec![1, 2, 3].into_iter().rev().map(|x| x + 1).collect();
assert_eq!(v, [4, 3, 2]);
}
let v: Vec<i32> = vec![1, 2, 3].into_iter().rev().map(|x| x + 1).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:
fn main() {
let mut c = 0;
for pair in vec!['a', 'b', 'c'].into_iter()
.map(|letter| { c += 1; (letter, c) }) {
println!("{:?}", pair);
}
}
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 lazilly on each item, but we are popping items off the
back of the vector now, instead of shifting them from the front.
fn main() {
let mut c = 0;
for pair in vec!['a', 'b', 'c'].into_iter()
.map(|letter| { c += 1; (letter, c) })
.rev() {
println!("{:?}", pair);
}
}
let mut c = 0;
for pair in vec!['a', 'b', 'c'].into_iter()
.map(|letter| { c += 1; (letter, c) })
.rev() {
println!("{:?}", pair);
}
Trait Implementations
type Item = B
fn next(&mut self) -> Option<B>
fn map<B, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> B
fn filter<P>(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where F: FnMut(&mut St, Self::Item) -> Option<B>
fn fuse(self) -> Fuse<Self>
fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item) -> ()
fn by_ref(&mut self) -> &mut Self
fn fold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, Self::Item) -> B
fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool
fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B1.6.0
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B1.6.0
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where Self: Iterator<Item=(A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>
fn cloned<'a, T>(self) -> Cloned<Self> where Self: Iterator<Item=&'a T>, T: 'a + Clone
fn cycle(self) -> Cycle<Self> where Self: Clone
fn sum<S>(self) -> S where S: Add<Self::Item, Output=S> + Zero
fn product<P>(self) -> P where P: Mul<Self::Item, Output=P> + One
impl<I, F> Debug for Map<I, F> where I: Debug1.9.0
Derived Implementations
impl<I, F> Clone for Map<I, F> where F: Clone, I: Clone