#[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
impl<I: Debug, F> Debug for Map<I, F>1.9.0
impl<B, I: Iterator, F> Iterator for Map<I, F> where F: FnMut(I::Item) -> B
type Item = B
fn next(&mut self) -> Option<B>
fn count(self) -> usize where Self: Sized
fn nth(&mut self, n: usize) -> Option<Self::Item> where Self: Sized
fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter> where Self: Sized, U: IntoIterator<Item=Self::Item>
fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter> where Self: Sized, U: IntoIterator
fn map<B, F>(self, f: F) -> Map<Self, F> where Self: Sized, F: FnMut(Self::Item) -> B
fn filter<P>(self, predicate: P) -> Filter<Self, P> where Self: Sized, P: FnMut(&Self::Item) -> bool
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where Self: Sized, P: FnMut(&Self::Item) -> bool
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where Self: Sized, P: FnMut(&Self::Item) -> bool
fn skip(self, n: usize) -> Skip<Self> where Self: Sized
fn take(self, n: usize) -> Take<Self> where Self: Sized
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>
fn fuse(self) -> Fuse<Self> where Self: Sized
fn inspect<F>(self, f: F) -> Inspect<Self, F> where Self: Sized, F: FnMut(&Self::Item)
fn by_ref(&mut self) -> &mut Self where Self: Sized
fn partition<B, F>(self, f: F) -> (B, B) where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool
fn fold<B, F>(self, init: B, f: F) -> B where Self: Sized, F: FnMut(B, Self::Item) -> B
fn all<F>(&mut self, f: F) -> bool where Self: Sized, F: FnMut(Self::Item) -> bool
fn any<F>(&mut self, f: F) -> bool where 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
fn position<P>(&mut self, predicate: P) -> Option<usize> where Self: Sized, P: FnMut(Self::Item) -> bool
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Iterator<Item=(A, B)>
fn cloned<'a, T: 'a>(self) -> Cloned<Self> where Self: Sized + Iterator<Item=&'a T>, T: Clone
fn sum<S>(self) -> S where S: Add<Self::Item, Output=S> + Zero, Self: Sized
fn product<P>(self) -> P where P: Mul<Self::Item, Output=P> + One, Self: Sized
fn eq<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>, Self: Sized1.5.0
fn ne<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>, Self: Sized1.5.0
fn lt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>, Self: Sized1.5.0
fn le<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>, Self: Sized1.5.0
fn gt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>, Self: Sized1.5.0
fn ge<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>, Self: Sized1.5.0
Derived Implementations