1.0.0[−][src]Struct std::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<B, I, F> DoubleEndedIterator for Map<I, F> where
F: FnMut(<I as Iterator>::Item) -> B,
I: DoubleEndedIterator,
[src]
F: FnMut(<I as Iterator>::Item) -> B,
I: DoubleEndedIterator,
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]
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Map<I, F>: Sized,
fn rfold<Acc, G>(self, init: Acc, g: G) -> Acc where
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> Acc,
[src]
G: FnMut(Acc, <Map<I, F> as Iterator>::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
P: FnMut(&Self::Item) -> bool,
1.27.0[src]
P: FnMut(&Self::Item) -> bool,
impl<I, F> Debug for Map<I, F> where
I: Debug,
1.9.0[src]
I: Debug,
impl<B, I, F> FusedIterator for Map<I, F> where
F: FnMut(<I as Iterator>::Item) -> B,
I: FusedIterator,
1.26.0[src]
F: FnMut(<I as Iterator>::Item) -> B,
I: FusedIterator,
impl<I, F> Clone for Map<I, F> where
F: Clone,
I: Clone,
[src]
F: Clone,
I: Clone,
ⓘImportant traits for Map<I, F>fn clone(&self) -> Map<I, F>
[src]
fn clone_from(&mut self, source: &Self)
[src]
impl<B, I, F> ExactSizeIterator for Map<I, F> where
F: FnMut(<I as Iterator>::Item) -> B,
I: ExactSizeIterator,
[src]
F: FnMut(<I as Iterator>::Item) -> B,
I: ExactSizeIterator,
impl<B, I, F> Iterator for Map<I, F> where
F: FnMut(<I as Iterator>::Item) -> B,
I: Iterator,
[src]
F: FnMut(<I as Iterator>::Item) -> B,
I: Iterator,
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
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Map<I, F>: Sized,
[src]
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Map<I, F>: Sized,
fn fold<Acc, G>(self, init: Acc, g: G) -> Acc where
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> Acc,
[src]
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> Acc,
fn count(self) -> usize
[src]
fn last(self) -> Option<Self::Item>
[src]
fn nth(&mut self, n: usize) -> Option<Self::Item>
[src]
ⓘImportant traits for StepBy<I>fn step_by(self, step: usize) -> StepBy<Self>
1.28.0[src]
ⓘImportant traits for Chain<A, B>fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>,
[src]
U: IntoIterator<Item = Self::Item>,
ⓘImportant traits for Zip<A, B>fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator,
[src]
U: IntoIterator,
ⓘImportant traits for Map<I, F>fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,
[src]
F: FnMut(Self::Item) -> B,
fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
1.21.0[src]
F: FnMut(Self::Item),
ⓘImportant traits for Filter<I, P>fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
ⓘImportant traits for FilterMap<I, F>fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
[src]
F: FnMut(Self::Item) -> Option<B>,
ⓘImportant traits for Enumerate<I>fn enumerate(self) -> Enumerate<Self>
[src]
ⓘImportant traits for Peekable<I>fn peekable(self) -> Peekable<Self>
[src]
ⓘImportant traits for SkipWhile<I, P>fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
ⓘImportant traits for TakeWhile<I, P>fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
ⓘImportant traits for Skip<I>fn skip(self, n: usize) -> Skip<Self>
[src]
ⓘImportant traits for Take<I>fn take(self, n: usize) -> Take<Self>
[src]
ⓘImportant traits for Scan<I, St, F>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]
F: FnMut(&mut St, Self::Item) -> Option<B>,
ⓘImportant traits for FlatMap<I, U, F>fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
[src]
F: FnMut(Self::Item) -> U,
U: IntoIterator,
ⓘImportant traits for Flatten<I>fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator,
1.29.0[src]
Self::Item: IntoIterator,
ⓘImportant traits for Fuse<I>fn fuse(self) -> Fuse<Self>
[src]
ⓘImportant traits for Inspect<I, F>fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
[src]
F: FnMut(&Self::Item),
ⓘImportant traits for &'_ mut Ffn by_ref(&mut self) -> &mut Self
[src]
#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]
fn collect<B>(self) -> B where
B: FromIterator<Self::Item>,
[src]
B: FromIterator<Self::Item>,
fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
[src]
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
P: FnMut(&T) -> bool,
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
[src]
P: FnMut(&T) -> bool,
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]
P: FnMut(Self::Item) -> bool,
fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
1.27.0[src]
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
[src]
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
[src]
F: FnMut(Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,
1.30.0[src]
F: FnMut(Self::Item) -> Option<B>,
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
[src]
P: FnMut(Self::Item) -> bool,
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
[src]
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
B: Ord,
F: FnMut(&Self::Item) -> B,
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
B: Ord,
F: FnMut(&Self::Item) -> B,
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
ⓘImportant traits for Rev<I>fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator,
[src]
Self: DoubleEndedIterator,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
[src]
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
ⓘImportant traits for Copied<I>fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
1.36.0[src]
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
ⓘImportant traits for Cloned<I>fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
[src]
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
ⓘImportant traits for Cycle<I>fn cycle(self) -> Cycle<Self> where
Self: Clone,
[src]
Self: Clone,
fn sum<S>(self) -> S where
S: Sum<Self::Item>,
1.11.0[src]
S: Sum<Self::Item>,
fn product<P>(self) -> P where
P: Product<Self::Item>,
1.11.0[src]
P: Product<Self::Item>,
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
1.5.0[src]
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
[src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator,
[src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator,
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
[src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]
Self::Item: PartialOrd<Self::Item>,
fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
[src]
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
impl<B, I, F> TrustedLen for Map<I, F> where
F: FnMut(<I as Iterator>::Item) -> B,
I: TrustedLen,
[src]
F: FnMut(<I as Iterator>::Item) -> B,
I: TrustedLen,
Auto Trait Implementations
impl<I, F> UnwindSafe for Map<I, F> where
F: UnwindSafe,
I: UnwindSafe,
F: UnwindSafe,
I: UnwindSafe,
impl<I, F> RefUnwindSafe for Map<I, F> where
F: RefUnwindSafe,
I: RefUnwindSafe,
F: RefUnwindSafe,
I: RefUnwindSafe,
impl<I, F> Unpin for Map<I, F> where
F: Unpin,
I: Unpin,
F: Unpin,
I: Unpin,
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,
Blanket Implementations
impl<T> From<T> for T
[src]
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(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<I> IntoIterator for I where
I: Iterator,
[src]
I: Iterator,
type Item = <I as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = I
Which kind of iterator are we turning this into?
fn into_iter(self) -> I
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
ⓘImportant traits for &'_ mut Ffn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,