Struct internal_iterator::FilterMap

pub struct FilterMap<I, F> { /* private fields */ }

An iterator that uses f to both filter and map elements from iter.

Trait Implementations

impl<I: Clone, F: Clone> Clone for FilterMap<I, F>

fn clone(&self) -> FilterMap<I, F>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<I, F, T> InternalIterator for FilterMap<I, F>

where I: InternalIterator, F: FnMut(I::Item) -> Option<T>,

type Item = T

Type of items yielded by the iterator.

fn try_for_each<R, C>(self, consumer: C) -> ControlFlow<R>

where C: FnMut(Self::Item) -> ControlFlow<R>,

Applies function each elements of the iterator. Stops early if the function returns ControlFlow::Break.

fn find_map<R, F>(self, f: F) -> Option<R>

where F: FnMut(Self::Item) -> Option<R>,

Applies function to the elements of iterator and returns the first non-none result.

fn all<F>(self, f: F) -> bool

where F: FnMut(Self::Item) -> bool,

Tests if every element of the iterator matches the predicate.

fn any<F>(self, f: F) -> bool

where F: FnMut(Self::Item) -> bool,

Tests if any element of the iterator matches the predicate.

fn chain<U>( self, other: U ) -> Chain<Self, <U as IntoInternalIterator>::IntoIter>

where U: IntoInternalIterator<Item = Self::Item>,

Takes two iterators and returns an iterator that first iterates over the elements of the first iterator, and then over the second one.

fn cloned<'a, T>(self) -> Cloned<Self>

where Self: InternalIterator<Item = &'a T>, T: Clone + 'a,

Creates an iterator yields cloned elements of the original iterator.

fn collect<B>(self) -> B

where B: FromInternalIterator<Self::Item>,

Transforms the iterator into a collection.

fn copied<'a, T>(self) -> Copied<Self>

where Self: InternalIterator<Item = &'a T>, T: Copy + 'a,

Creates an iterator yields copied elements of the original iterator.

fn count(self) -> usize

Returns the number of elements yielded by the iterator.

fn enumerate(self) -> Enumerate<Self>

Creates an iterator that adds the index to every value of the original iterator.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where P: FnMut(&Self::Item) -> bool,

Creates an iterator which only yields elements matching the predicate.

fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F>

where F: FnMut(Self::Item) -> Option<T>,

A combination of InternalIterator::filter and InternalIterator::map.

fn find<F>(self, f: F) -> Option<Self::Item>

where F: FnMut(&Self::Item) -> bool,

Returns the first element of the iterator that matches the predicate.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, F>

where F: FnMut(Self::Item) -> U, U: IntoInternalIterator,

Creates and iterator which maps over the elements and flattens the resulting structure.

fn fold<B, F>(self, init: B, f: F) -> B

where F: FnMut(B, Self::Item) -> B,

Folds every element into an accumulator by applying an operation, returning the final result.

fn for_each<F>(self, f: F)

where F: FnMut(Self::Item),

Run the closure on each element.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where F: FnMut(&Self::Item),

Run the closure on each element, while passing that element on.

fn last(self) -> Option<Self::Item>

Returns the last element.

fn map<F, T>(self, f: F) -> Map<Self, F>

where F: FnMut(Self::Item) -> T,

Transform each element in the iterator.

fn max_by<F>(self, compare: F) -> Option<Self::Item>

where F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the maximum element of an iterator using a custom comparer function.

fn max_by_key<B: Ord>( self, key: impl FnMut(&Self::Item) -> B ) -> Option<Self::Item>

Returns the element that gives the maximum value from the specified function.

fn min_by<F>(self, compare: F) -> Option<Self::Item>

where F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the minimum element of an iterator using a custom comparer function.

fn min_by_key<B: Ord>( self, key: impl FnMut(&Self::Item) -> B ) -> Option<Self::Item>

Returns the element that gives the minimum value from the specified function.

fn next(self) -> Option<Self::Item>

Returns the first element of the iterator.

fn nth(self, n: usize) -> Option<Self::Item>

Returns the nth element of the iterator.

fn position<F>(self, f: F) -> Option<usize>

where F: FnMut(Self::Item) -> bool,

Returns the index of the first element matching the predicate.

fn skip(self, n: usize) -> Skip<Self>

Skip first n elements of the iterator.

fn take(self, n: usize) -> Take<Self>

Take first n elements of the iterator, disregarding the rest.