std::iter::MapWhile - Rust

Struct std::iter::MapWhile

#[must_use = "iterators are lazy and do nothing unless consumed"]pub struct MapWhile<I, P> { /* fields omitted */ }

🔬 This is a nightly-only experimental API. (iter_map_while #68537)recently added

An iterator that only accepts elements while predicate returns Some(_).

This struct is created by the map_while method on Iterator. See its documentation for more.

Trait Implementations

`impl<I, P> Clone for MapWhile<I, P> where I: Clone, P: Clone,` [src]

fn clone(&self) -> MapWhile<I, P>ⓘNotable traits for MapWhile<I, P>
impl<B, I, P> Iterator for MapWhile<I, P> where
    I: Iterator,
    P: FnMut(<I as Iterator>::Item) -> Option<B>, 
    type Item = B;

[src]

`fn clone_from(&mut self, source: &Self)`[src]1.0.0

`impl<I, P> Debug for MapWhile<I, P> where I: Debug,` [src]

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<B, I, P> Iterator for MapWhile<I, P> where I: Iterator, P: FnMut(::Item) -> Option,` [src]

`type Item = B`

The type of the elements being iterated over.

`fn next(&mut self) -> Option`[src]

`fn size_hint(&self) -> (usize, Option<usize>)`[src]

`fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where Fold: FnMut(Acc, <MapWhile<I, P> as Iterator>::Item) -> R, R: Try<Ok = Acc>, MapWhile<I, P>: Sized,` [src]

`fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where Fold: FnMut(Acc, <MapWhile<I, P> as Iterator>::Item) -> Acc, MapWhile<I, P>: Sized,` [src]

`fn count(self) -> usize`[src]1.0.0

`fn last(self) -> Option<Self::Item>`[src]1.0.0

`fn nth(&mut self, n: usize) -> Option<Self::Item>`[src]1.0.0

fn step_by(self, step: usize) -> StepBy<Self>ⓘNotable traits for StepBy<I>
impl<I> Iterator for StepBy<I> where
    I: Iterator, 
    type Item = <I as Iterator>::Item;

[src]1.28.0

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Chain<A, B>
impl<A, B> Iterator for Chain<A, B> where
    A: Iterator,
    B: Iterator<Item = <A as Iterator>::Item>, 
    type Item = <A as Iterator>::Item;
 where
    U: IntoIterator<Item = Self::Item>,

[src]1.0.0

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Zip<A, B>
impl<A, B> Iterator for Zip<A, B> where
    A: Iterator,
    B: Iterator, 
    type Item = (<A as Iterator>::Item, <B as Iterator>::Item);
 where
    U: IntoIterator,

[src]1.0.0

fn map<B, F>(self, f: F) -> Map<Self, F>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator, 
    type Item = B;
 where
    F: FnMut(Self::Item) -> B,

[src]1.0.0

`fn for_each<F>(self, f: F) where F: FnMut(Self::Item),` [src]1.21.0

fn filter<P>(self, predicate: P) -> Filter<Self, P>ⓘNotable traits for Filter<I, P>
impl<I, P> Iterator for Filter<I, P> where
    I: Iterator,
    P: FnMut(&<I as Iterator>::Item) -> bool, 
    type Item = <I as Iterator>::Item;
 where
    P: FnMut(&Self::Item) -> bool,

[src]1.0.0

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>ⓘNotable traits for FilterMap<I, F>
impl<B, I, F> Iterator for FilterMap<I, F> where
    F: FnMut(<I as Iterator>::Item) -> Option<B>,
    I: Iterator, 
    type Item = B;
 where
    F: FnMut(Self::Item) -> Option<B>,

[src]1.0.0

fn enumerate(self) -> Enumerate<Self>ⓘNotable traits for Enumerate<I>
impl<I> Iterator for Enumerate<I> where
    I: Iterator, 
    type Item = (usize, <I as Iterator>::Item);

[src]1.0.0

fn peekable(self) -> Peekable<Self>ⓘNotable traits for Peekable<I>
impl<I> Iterator for Peekable<I> where
    I: Iterator, 
    type Item = <I as Iterator>::Item;

[src]1.0.0

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>ⓘNotable traits for SkipWhile<I, P>
impl<I, P> Iterator for SkipWhile<I, P> where
    I: Iterator,
    P: FnMut(&<I as Iterator>::Item) -> bool, 
    type Item = <I as Iterator>::Item;
 where
    P: FnMut(&Self::Item) -> bool,

[src]1.0.0

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>ⓘNotable traits for TakeWhile<I, P>
impl<I, P> Iterator for TakeWhile<I, P> where
    I: Iterator,
    P: FnMut(&<I as Iterator>::Item) -> bool, 
    type Item = <I as Iterator>::Item;
 where
    P: FnMut(&Self::Item) -> bool,

[src]1.0.0

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>ⓘNotable traits for MapWhile<I, P>
impl<B, I, P> Iterator for MapWhile<I, P> where
    I: Iterator,
    P: FnMut(<I as Iterator>::Item) -> Option<B>, 
    type Item = B;
 where
    P: FnMut(Self::Item) -> Option<B>,

[src]

fn skip(self, n: usize) -> Skip<Self>ⓘNotable traits for Skip<I>
impl<I> Iterator for Skip<I> where
    I: Iterator, 
    type Item = <I as Iterator>::Item;

[src]1.0.0

fn take(self, n: usize) -> Take<Self>ⓘNotable traits for Take<I>
impl<I> Iterator for Take<I> where
    I: Iterator, 
    type Item = <I as Iterator>::Item;

[src]1.0.0

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>ⓘNotable traits for Scan<I, St, F>
impl<B, I, St, F> Iterator for Scan<I, St, F> where
    F: FnMut(&mut St, <I as Iterator>::Item) -> Option<B>,
    I: Iterator, 
    type Item = B;
 where
    F: FnMut(&mut St, Self::Item) -> Option<B>,

[src]1.0.0

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>ⓘNotable traits for FlatMap<I, U, F>
impl<I, U, F> Iterator for FlatMap<I, U, F> where
    F: FnMut(<I as Iterator>::Item) -> U,
    I: Iterator,
    U: IntoIterator, 
    type Item = <U as IntoIterator>::Item;
 where
    F: FnMut(Self::Item) -> U,
    U: IntoIterator,

[src]1.0.0

fn flatten(self) -> Flatten<Self>ⓘNotable traits for Flatten<I>
impl<I, U> Iterator for Flatten<I> where
    I: Iterator,
    U: Iterator,
    <I as Iterator>::Item: IntoIterator,
    <<I as Iterator>::Item as IntoIterator>::IntoIter == U,
    <<I as Iterator>::Item as IntoIterator>::Item == <U as Iterator>::Item, 
    type Item = <U as Iterator>::Item;
 where
    Self::Item: IntoIterator,

[src]1.29.0

fn fuse(self) -> Fuse<Self>ⓘNotable traits for Fuse<I>
impl<I> Iterator for Fuse<I> where
    I: Iterator, 
    type Item = <I as Iterator>::Item;

[src]1.0.0

fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘNotable traits for Inspect<I, F>
impl<I, F> Iterator for Inspect<I, F> where
    F: FnMut(&<I as Iterator>::Item),
    I: Iterator, 
    type Item = <I as Iterator>::Item;
 where
    F: FnMut(&Self::Item),

[src]1.0.0

fn by_ref(&mut self) -> &mut SelfⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized, 
    type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized, 
    type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W

[src]1.0.0

#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]fn collect(self) -> B where B: FromIterator<Self::Item>, [src]1.0.0

`fn partition<B, F>(self, f: F) -> (B, B) where B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,` [src]1.0.0

`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]

`fn is_partitioned(self, predicate: P) -> bool where P: FnMut(Self::Item) -> bool,` [src]

`fn try_for_each<F, R>(&mut self, f: F) -> R where F: FnMut(Self::Item) -> R, R: Try<Ok = ()>,` [src]1.27.0

`fn fold_first<F>(self, f: F) -> Option<Self::Item> where F: FnMut(Self::Item, Self::Item) -> Self::Item,` [src]

`fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool,` [src]1.0.0

`fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool,` [src]1.0.0

`fn find(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool,` [src]1.0.0

`fn find_map<B, F>(&mut self, f: F) -> Option where F: FnMut(Self::Item) -> Option,` [src]1.30.0

`fn try_find<F, R>( &mut self, f: F ) -> Result<Option<Self::Item>, <R as Try>::Error> where F: FnMut(&Self::Item) -> R, R: Try<Ok = bool>,` [src]

`fn position(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool,` [src]1.0.0

`fn rposition(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool, Self: ExactSizeIterator + DoubleEndedIterator,` [src]1.0.0

`fn max(self) -> Option<Self::Item> where Self::Item: Ord,` [src]1.0.0

`fn min(self) -> Option<Self::Item> where Self::Item: Ord,` [src]1.0.0

`fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B,` [src]1.6.0

`fn max_by<F>(self, compare: F) -> Option<Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering,` [src]1.15.0

`fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B,` [src]1.6.0

`fn min_by<F>(self, compare: F) -> Option<Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering,` [src]1.15.0

fn rev(self) -> Rev<Self>ⓘNotable traits for Rev<I>
impl<I> Iterator for Rev<I> where
    I: DoubleEndedIterator, 
    type Item = <I as Iterator>::Item;
 where
    Self: DoubleEndedIterator,

[src]1.0.0

`fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where FromA: Default + Extend<A>, FromB: Default + Extend, Self: Iterator<Item = (A, B)>,` [src]1.0.0

fn copied<'a, T>(self) -> Copied<Self>ⓘNotable traits for Copied<I>
impl<'a, I, T> Iterator for Copied<I> where
    I: Iterator<Item = &'a T>,
    T: 'a + Copy, 
    type Item = T;
 where
    Self: Iterator<Item = &'a T>,
    T: 'a + Copy,

[src]1.36.0

fn cloned<'a, T>(self) -> Cloned<Self>ⓘNotable traits for Cloned<I>
impl<'a, I, T> Iterator for Cloned<I> where
    I: Iterator<Item = &'a T>,
    T: 'a + Clone, 
    type Item = T;
 where
    Self: Iterator<Item = &'a T>,
    T: 'a + Clone,

[src]1.0.0

fn cycle(self) -> Cycle<Self>ⓘNotable traits for Cycle<I>
impl<I> Iterator for Cycle<I> where
    I: Clone + Iterator, 
    type Item = <I as Iterator>::Item;
 where
    Self: Clone,

[src]1.0.0

`fn sum<S>(self) -> S where S: Sum<Self::Item>,` [src]1.11.0

`fn product(self) -> P where P: Product<Self::Item>,` [src]1.11.0

`fn cmp(self, other: I) -> Ordering where I: IntoIterator<Item = Self::Item>, Self::Item: Ord,` [src]1.5.0

`fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where F: FnMut(Self::Item, ::Item) -> Ordering, I: IntoIterator,` [src]

`fn partial_cmp(self, other: I) -> Option<Ordering> where I: IntoIterator, Self::Item: PartialOrd<::Item>,` [src]1.5.0

`fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where F: FnMut(Self::Item, ::Item) -> Option<Ordering>, I: IntoIterator,` [src]

`fn eq(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<::Item>,` [src]1.5.0

`fn eq_by<I, F>(self, other: I, eq: F) -> bool where F: FnMut(Self::Item, ::Item) -> bool, I: IntoIterator,` [src]

`fn ne(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<::Item>,` [src]1.5.0

`fn lt(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<::Item>,` [src]1.5.0

`fn le(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<::Item>,` [src]1.5.0

`fn gt(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<::Item>,` [src]1.5.0

`fn ge(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<::Item>,` [src]1.5.0

`fn is_sorted(self) -> bool where Self::Item: PartialOrd<Self::Item>,` [src]

`fn is_sorted_by<F>(self, compare: F) -> bool where F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,` [src]

`fn is_sorted_by_key<F, K>(self, f: F) -> bool where F: FnMut(Self::Item) -> K, K: PartialOrd<K>,` [src]

Auto Trait Implementations

`impl<I, P> RefUnwindSafe for MapWhile<I, P> where I: RefUnwindSafe, P: RefUnwindSafe,`

`impl<I, P> Send for MapWhile<I, P> where I: Send, P: Send,`

`impl<I, P> Sync for MapWhile<I, P> where I: Sync, P: Sync,`

`impl<I, P> Unpin for MapWhile<I, P> where I: Unpin, P: Unpin,`

`impl<I, P> UnwindSafe for MapWhile<I, P> where I: UnwindSafe, P: UnwindSafe,`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

fn borrow(&self) -> &TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized, 
    type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized, 
    type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W

[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

fn borrow_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized, 
    type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized, 
    type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W

[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl IntoIterator for I where I: Iterator,` [src]

`type Item = ::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> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`[src]

`fn clone_into(&self, target: &mut T)`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src]

© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/iter/struct.MapWhile.html

Struct std::iter::MapWhile

Trait Implementations

impl<I, P> Clone for MapWhile<I, P> where I: Clone, P: Clone, [src]

fn clone(&self) -> MapWhile<I, P>ⓘNotable traits for MapWhile<I, P> impl<B, I, P> Iterator for MapWhile<I, P> where I: Iterator, P: FnMut(<I as Iterator>::Item) -> Option<B>, type Item = B; [src]

Notable traits for MapWhile<I, P>

fn clone_from(&mut self, source: &Self)[src]1.0.0

impl<I, P> Debug for MapWhile<I, P> where I: Debug, [src]

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>[src]

impl<B, I, P> Iterator for MapWhile<I, P> where I: Iterator, P: FnMut(<I as Iterator>::Item) -> Option<B>, [src]

type Item = B

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

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

fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where Fold: FnMut(Acc, <MapWhile<I, P> as Iterator>::Item) -> R, R: Try<Ok = Acc>, MapWhile<I, P>: Sized, [src]

fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where Fold: FnMut(Acc, <MapWhile<I, P> as Iterator>::Item) -> Acc, MapWhile<I, P>: Sized, [src]

fn count(self) -> usize[src]1.0.0

fn last(self) -> Option<Self::Item>[src]1.0.0

fn nth(&mut self, n: usize) -> Option<Self::Item>[src]1.0.0

fn step_by(self, step: usize) -> StepBy<Self>ⓘNotable traits for StepBy<I> impl<I> Iterator for StepBy<I> where I: Iterator, type Item = <I as Iterator>::Item; [src]1.28.0

Notable traits for StepBy<I>

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Chain<A, B> impl<A, B> Iterator for Chain<A, B> where A: Iterator, B: Iterator<Item = <A as Iterator>::Item>, type Item = <A as Iterator>::Item; where U: IntoIterator<Item = Self::Item>, [src]1.0.0

Notable traits for Chain<A, B>

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Zip<A, B> impl<A, B> Iterator for Zip<A, B> where A: Iterator, B: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item); where U: IntoIterator, [src]1.0.0

Notable traits for Zip<A, B>

fn map<B, F>(self, f: F) -> Map<Self, F>ⓘNotable traits for Map<I, F> impl<B, I, F> Iterator for Map<I, F> where F: FnMut(<I as Iterator>::Item) -> B, I: Iterator, type Item = B; where F: FnMut(Self::Item) -> B, [src]1.0.0

Notable traits for Map<I, F>

fn for_each<F>(self, f: F) where F: FnMut(Self::Item), [src]1.21.0

fn filter<P>(self, predicate: P) -> Filter<Self, P>ⓘNotable traits for Filter<I, P> impl<I, P> Iterator for Filter<I, P> where I: Iterator, P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item; where P: FnMut(&Self::Item) -> bool, [src]1.0.0

Notable traits for Filter<I, P>

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>ⓘNotable traits for FilterMap<I, F> impl<B, I, F> Iterator for FilterMap<I, F> where F: FnMut(<I as Iterator>::Item) -> Option<B>, I: Iterator, type Item = B; where F: FnMut(Self::Item) -> Option<B>, [src]1.0.0

Notable traits for FilterMap<I, F>

fn enumerate(self) -> Enumerate<Self>ⓘNotable traits for Enumerate<I> impl<I> Iterator for Enumerate<I> where I: Iterator, type Item = (usize, <I as Iterator>::Item); [src]1.0.0

Notable traits for Enumerate<I>

fn peekable(self) -> Peekable<Self>ⓘNotable traits for Peekable<I> impl<I> Iterator for Peekable<I> where I: Iterator, type Item = <I as Iterator>::Item; [src]1.0.0

Notable traits for Peekable<I>

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>ⓘNotable traits for SkipWhile<I, P> impl<I, P> Iterator for SkipWhile<I, P> where I: Iterator, P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item; where P: FnMut(&Self::Item) -> bool, [src]1.0.0

Notable traits for SkipWhile<I, P>

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>ⓘNotable traits for TakeWhile<I, P> impl<I, P> Iterator for TakeWhile<I, P> where I: Iterator, P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item; where P: FnMut(&Self::Item) -> bool, [src]1.0.0

Notable traits for TakeWhile<I, P>

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>ⓘNotable traits for MapWhile<I, P> impl<B, I, P> Iterator for MapWhile<I, P> where I: Iterator, P: FnMut(<I as Iterator>::Item) -> Option<B>, type Item = B; where P: FnMut(Self::Item) -> Option<B>, [src]

Notable traits for MapWhile<I, P>

fn skip(self, n: usize) -> Skip<Self>ⓘNotable traits for Skip<I> impl<I> Iterator for Skip<I> where I: Iterator, type Item = <I as Iterator>::Item; [src]1.0.0

Notable traits for Skip<I>

fn take(self, n: usize) -> Take<Self>ⓘNotable traits for Take<I> impl<I> Iterator for Take<I> where I: Iterator, type Item = <I as Iterator>::Item; [src]1.0.0

Notable traits for Take<I>

Notable traits for Scan<I, St, F>

Notable traits for FlatMap<I, U, F>

Notable traits for Flatten<I>

fn fuse(self) -> Fuse<Self>ⓘNotable traits for Fuse<I> impl<I> Iterator for Fuse<I> where I: Iterator, type Item = <I as Iterator>::Item; [src]1.0.0

Notable traits for Fuse<I>

fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘNotable traits for Inspect<I, F> impl<I, F> Iterator for Inspect<I, F> where F: FnMut(&<I as Iterator>::Item), I: Iterator, type Item = <I as Iterator>::Item; where F: FnMut(&Self::Item), [src]1.0.0

Notable traits for Inspect<I, F>

Notable traits for &'_ mut F

#[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]1.0.0

fn partition<B, F>(self, f: F) -> (B, B) where B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool, [src]1.0.0

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]

fn is_partitioned<P>(self, predicate: P) -> bool where P: FnMut(Self::Item) -> bool, [src]

fn try_for_each<F, R>(&mut self, f: F) -> R where F: FnMut(Self::Item) -> R, R: Try<Ok = ()>, [src]1.27.0

fn fold_first<F>(self, f: F) -> Option<Self::Item> where F: FnMut(Self::Item, Self::Item) -> Self::Item, [src]

fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool, [src]1.0.0

fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool, [src]1.0.0

fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool, [src]1.0.0

fn find_map<B, F>(&mut self, f: F) -> Option<B> where F: FnMut(Self::Item) -> Option<B>, [src]1.30.0

fn try_find<F, R>( &mut self, f: F) -> Result<Option<Self::Item>, <R as Try>::Error> where F: FnMut(&Self::Item) -> R, R: Try<Ok = bool>, [src]

fn position<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool, [src]1.0.0

fn rposition<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool, Self: ExactSizeIterator + DoubleEndedIterator, [src]1.0.0

fn max(self) -> Option<Self::Item> where Self::Item: Ord, [src]1.0.0

fn min(self) -> Option<Self::Item> where Self::Item: Ord, [src]1.0.0

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B, [src]1.6.0

fn max_by<F>(self, compare: F) -> Option<Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering, [src]1.15.0

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B, [src]1.6.0

fn min_by<F>(self, compare: F) -> Option<Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering, [src]1.15.0

fn rev(self) -> Rev<Self>ⓘNotable traits for Rev<I> impl<I> Iterator for Rev<I> where I: DoubleEndedIterator, type Item = <I as Iterator>::Item; where Self: DoubleEndedIterator, [src]1.0.0

Notable traits for Rev<I>

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Iterator<Item = (A, B)>, [src]1.0.0

fn copied<'a, T>(self) -> Copied<Self>ⓘNotable traits for Copied<I> impl<'a, I, T> Iterator for Copied<I> where I: Iterator<Item = &'a T>, T: 'a + Copy, type Item = T; where Self: Iterator<Item = &'a T>, T: 'a + Copy, [src]1.36.0

Notable traits for Copied<I>

fn cloned<'a, T>(self) -> Cloned<Self>ⓘNotable traits for Cloned<I> impl<'a, I, T> Iterator for Cloned<I> where I: Iterator<Item = &'a T>, T: 'a + Clone, type Item = T; where Self: Iterator<Item = &'a T>, T: 'a + Clone, [src]1.0.0

Notable traits for Cloned<I>

fn cycle(self) -> Cycle<Self>ⓘNotable traits for Cycle<I> impl<I> Iterator for Cycle<I> where I: Clone + Iterator, type Item = <I as Iterator>::Item; where Self: Clone, [src]1.0.0

Notable traits for Cycle<I>

`impl<I, P> Clone for MapWhile<I, P> where I: Clone, P: Clone,` [src]

`fn clone(&self) -> MapWhile<I, P>ⓘNotable traits for MapWhile<I, P> impl<B, I, P> Iterator for MapWhile<I, P> where I: Iterator, P: FnMut(<I as Iterator>::Item) -> Option<B>, type Item = B;`[src]

`fn clone_from(&mut self, source: &Self)`[src]1.0.0

`impl<I, P> Debug for MapWhile<I, P> where I: Debug,` [src]

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<B, I, P> Iterator for MapWhile<I, P> where I: Iterator, P: FnMut(<I as Iterator>::Item) -> Option<B>,` [src]

`type Item = B`

`fn next(&mut self) -> Option<B>`[src]

`fn size_hint(&self) -> (usize, Option<usize>)`[src]

`fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where Fold: FnMut(Acc, <MapWhile<I, P> as Iterator>::Item) -> R, R: Try<Ok = Acc>, MapWhile<I, P>: Sized,` [src]

`fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where Fold: FnMut(Acc, <MapWhile<I, P> as Iterator>::Item) -> Acc, MapWhile<I, P>: Sized,` [src]

`fn count(self) -> usize`[src]1.0.0

`fn last(self) -> Option<Self::Item>`[src]1.0.0

`fn nth(&mut self, n: usize) -> Option<Self::Item>`[src]1.0.0

`fn step_by(self, step: usize) -> StepBy<Self>ⓘNotable traits for StepBy<I> impl<I> Iterator for StepBy<I> where I: Iterator, type Item = <I as Iterator>::Item;`[src]1.28.0

`fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Chain<A, B> impl<A, B> Iterator for Chain<A, B> where A: Iterator, B: Iterator<Item = <A as Iterator>::Item>, type Item = <A as Iterator>::Item; where U: IntoIterator<Item = Self::Item>,` [src]1.0.0

`fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Zip<A, B> impl<A, B> Iterator for Zip<A, B> where A: Iterator, B: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item); where U: IntoIterator,` [src]1.0.0

`fn map<B, F>(self, f: F) -> Map<Self, F>ⓘNotable traits for Map<I, F> impl<B, I, F> Iterator for Map<I, F> where F: FnMut(<I as Iterator>::Item) -> B, I: Iterator, type Item = B; where F: FnMut(Self::Item) -> B,` [src]1.0.0

`fn for_each<F>(self, f: F) where F: FnMut(Self::Item),` [src]1.21.0

`fn filter<P>(self, predicate: P) -> Filter<Self, P>ⓘNotable traits for Filter<I, P> impl<I, P> Iterator for Filter<I, P> where I: Iterator, P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item; where P: FnMut(&Self::Item) -> bool,` [src]1.0.0

`fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>ⓘNotable traits for FilterMap<I, F> impl<B, I, F> Iterator for FilterMap<I, F> where F: FnMut(<I as Iterator>::Item) -> Option<B>, I: Iterator, type Item = B; where F: FnMut(Self::Item) -> Option<B>,` [src]1.0.0

`fn enumerate(self) -> Enumerate<Self>ⓘNotable traits for Enumerate<I> impl<I> Iterator for Enumerate<I> where I: Iterator, type Item = (usize, <I as Iterator>::Item);`[src]1.0.0

`fn peekable(self) -> Peekable<Self>ⓘNotable traits for Peekable<I> impl<I> Iterator for Peekable<I> where I: Iterator, type Item = <I as Iterator>::Item;`[src]1.0.0

`fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>ⓘNotable traits for SkipWhile<I, P> impl<I, P> Iterator for SkipWhile<I, P> where I: Iterator, P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item; where P: FnMut(&Self::Item) -> bool,` [src]1.0.0

`fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>ⓘNotable traits for TakeWhile<I, P> impl<I, P> Iterator for TakeWhile<I, P> where I: Iterator, P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item; where P: FnMut(&Self::Item) -> bool,` [src]1.0.0

`fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>ⓘNotable traits for MapWhile<I, P> impl<B, I, P> Iterator for MapWhile<I, P> where I: Iterator, P: FnMut(<I as Iterator>::Item) -> Option<B>, type Item = B; where P: FnMut(Self::Item) -> Option<B>,` [src]

`fn skip(self, n: usize) -> Skip<Self>ⓘNotable traits for Skip<I> impl<I> Iterator for Skip<I> where I: Iterator, type Item = <I as Iterator>::Item;`[src]1.0.0

`fn take(self, n: usize) -> Take<Self>ⓘNotable traits for Take<I> impl<I> Iterator for Take<I> where I: Iterator, type Item = <I as Iterator>::Item;`[src]1.0.0

`fn fuse(self) -> Fuse<Self>ⓘNotable traits for Fuse<I> impl<I> Iterator for Fuse<I> where I: Iterator, type Item = <I as Iterator>::Item;`[src]1.0.0

`fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘNotable traits for Inspect<I, F> impl<I, F> Iterator for Inspect<I, F> where F: FnMut(&<I as Iterator>::Item), I: Iterator, type Item = <I as Iterator>::Item; where F: FnMut(&Self::Item),` [src]1.0.0

`fn partition<B, F>(self, f: F) -> (B, B) where B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,` [src]1.0.0

`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]

`fn is_partitioned<P>(self, predicate: P) -> bool where P: FnMut(Self::Item) -> bool,` [src]

`fn try_for_each<F, R>(&mut self, f: F) -> R where F: FnMut(Self::Item) -> R, R: Try<Ok = ()>,` [src]1.27.0

`fn fold_first<F>(self, f: F) -> Option<Self::Item> where F: FnMut(Self::Item, Self::Item) -> Self::Item,` [src]

`fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool,` [src]1.0.0

`fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool,` [src]1.0.0

`fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool,` [src]1.0.0

`fn find_map<B, F>(&mut self, f: F) -> Option<B> where F: FnMut(Self::Item) -> Option<B>,` [src]1.30.0

`fn try_find<F, R>( &mut self, f: F ) -> Result<Option<Self::Item>, <R as Try>::Error> where F: FnMut(&Self::Item) -> R, R: Try<Ok = bool>,` [src]

`fn position<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool,` [src]1.0.0

`fn rposition<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool, Self: ExactSizeIterator + DoubleEndedIterator,` [src]1.0.0

`fn max(self) -> Option<Self::Item> where Self::Item: Ord,` [src]1.0.0

`fn min(self) -> Option<Self::Item> where Self::Item: Ord,` [src]1.0.0

`fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B,` [src]1.6.0

`fn max_by<F>(self, compare: F) -> Option<Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering,` [src]1.15.0

`fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B,` [src]1.6.0

`fn min_by<F>(self, compare: F) -> Option<Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering,` [src]1.15.0

`fn rev(self) -> Rev<Self>ⓘNotable traits for Rev<I> impl<I> Iterator for Rev<I> where I: DoubleEndedIterator, type Item = <I as Iterator>::Item; where Self: DoubleEndedIterator,` [src]1.0.0

`fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Iterator<Item = (A, B)>,` [src]1.0.0

`fn copied<'a, T>(self) -> Copied<Self>ⓘNotable traits for Copied<I> impl<'a, I, T> Iterator for Copied<I> where I: Iterator<Item = &'a T>, T: 'a + Copy, type Item = T; where Self: Iterator<Item = &'a T>, T: 'a + Copy,` [src]1.36.0

`fn cloned<'a, T>(self) -> Cloned<Self>ⓘNotable traits for Cloned<I> impl<'a, I, T> Iterator for Cloned<I> where I: Iterator<Item = &'a T>, T: 'a + Clone, type Item = T; where Self: Iterator<Item = &'a T>, T: 'a + Clone,` [src]1.0.0

`fn cycle(self) -> Cycle<Self>ⓘNotable traits for Cycle<I> impl<I> Iterator for Cycle<I> where I: Clone + Iterator, type Item = <I as Iterator>::Item; where Self: Clone,` [src]1.0.0

`fn sum<S>(self) -> S where S: Sum<Self::Item>,` [src]1.11.0

`fn product<P>(self) -> P where P: Product<Self::Item>,` [src]1.11.0

`fn cmp<I>(self, other: I) -> Ordering where I: IntoIterator<Item = Self::Item>, Self::Item: Ord,` [src]1.5.0

`fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering, I: IntoIterator,` [src]

`fn partial_cmp<I>(self, other: I) -> Option<Ordering> where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>,` [src]1.5.0

`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]

`fn eq<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>,` [src]1.5.0

`fn eq_by<I, F>(self, other: I, eq: F) -> bool where F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool, I: IntoIterator,` [src]

`fn ne<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>,` [src]1.5.0

`fn lt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>,` [src]1.5.0

`fn le<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>,` [src]1.5.0

`fn gt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>,` [src]1.5.0

`fn ge<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>,` [src]1.5.0

`fn is_sorted(self) -> bool where Self::Item: PartialOrd<Self::Item>,` [src]

`fn is_sorted_by<F>(self, compare: F) -> bool where F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,` [src]

`fn is_sorted_by_key<F, K>(self, f: F) -> bool where F: FnMut(Self::Item) -> K, K: PartialOrd<K>,` [src]

`impl<I, P> RefUnwindSafe for MapWhile<I, P> where I: RefUnwindSafe, P: RefUnwindSafe,`

`impl<I, P> Send for MapWhile<I, P> where I: Send, P: Send,`

`impl<I, P> Sync for MapWhile<I, P> where I: Sync, P: Sync,`

`impl<I, P> Unpin for MapWhile<I, P> where I: Unpin, P: Unpin,`

`impl<I, P> UnwindSafe for MapWhile<I, P> where I: UnwindSafe, P: UnwindSafe,`

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]