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]
fn clone(&self) -> Map<I, F>[src]
fn clone_from(&mut self, source: &Self)[src]
impl<I: Debug, F> Debug for Map<I, F>1.9.0[src]
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: 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]
fn step_by(self, step: usize) -> StepBy<Self> where
    Self: Sized, 1.28.0[src]
Self: Sized,
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>,
fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter> where
    Self: Sized,
    U: IntoIterator, [src]
Self: Sized,
U: IntoIterator,
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),
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,
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>,
fn enumerate(self) -> Enumerate<Self> where
    Self: Sized, [src]
Self: Sized,
fn peekable(self) -> Peekable<Self> where
    Self: Sized, [src]
Self: Sized,
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,
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,
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
    Self: Sized,
    P: FnMut(Self::Item) -> Option<B>, [src]
Self: Sized,
P: FnMut(Self::Item) -> Option<B>,
fn skip(self, n: usize) -> Skip<Self> where
    Self: Sized, [src]
Self: Sized,
fn take(self, n: usize) -> Take<Self> where
    Self: Sized, [src]
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>, [src]
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
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,
fn flatten(self) -> Flatten<Self> where
    Self: Sized,
    Self::Item: IntoIterator, 1.29.0[src]
Self: Sized,
Self::Item: IntoIterator,
fn fuse(self) -> Fuse<Self> where
    Self: Sized, [src]
Self: Sized,
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 try_find<F, E, R>(&mut self, f: F) -> Result<Option<Self::Item>, E> where
    Self: Sized,
    F: FnMut(&Self::Item) -> R,
    R: Try<Ok = bool, Error = E>, [src]
Self: Sized,
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool, Error = E>,
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,
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)>,
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,
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,
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, F> TrustedLen for Map<I, F> where
    I: TrustedLen,
    F: FnMut(I::Item) -> B, [src]
I: TrustedLen,
F: FnMut(I::Item) -> B,
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> Any for T where
    T: 'static + ?Sized, [src]
T: 'static + ?Sized,
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> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
U: From<T>,
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, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
U: TryFrom<T>,