Struct internal_iterator::Filter

pub struct Filter<I, F> { /* fields omitted */ }

An iterator that filters the elements of iter with predicate.

Trait Implementations

impl<I, F> InternalIterator for Filter<I, F> where
    I: InternalIterator,
    F: FnMut(&I::Item) -> bool, 

type Item = I::Item

Type of items yielded by the iterator.

fn find_map<R, C>(self, consumer: C) -> Option<R> where
    C: 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: 'a>(self) -> Cloned<Self> where
    Self: InternalIterator<Item = &'a T>,
    T: Clone, 

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: 'a>(self) -> Copied<Self> where
    Self: InternalIterator<Item = &'a T>,
    T: Copy, 

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 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(self) -> Option<Self::Item> where
    Self::Item: Ord, 

Returns the maximum element of an 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(self) -> Option<Self::Item> where
    Self::Item: Ord, 

Returns the minimum element of an iterator.

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 maximum 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.