Struct gat_std::iter::Chain

pub struct Chain<I1, I2> { /* private fields */ }

See Iterator::chain

Trait Implementations

impl<'b, I1, I2> Iterator for Chain<I1, I2>where
    I1: Iterator + 'b,
    I2: Iterator<Item<'b> = I1::Item<'b>> + 'b,

type Item<'a>
where
    Self: 'a = <I1 as Iterator>::Item<'a>

The value yielded by each call to next on this iterator

fn next(&mut self) -> Option<Self::Item<'_>>

Get the next value of this iterator, or return None

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

Get a hint as to the size of this iterator - the first value is a lower bound, second is an optional upper bound.

fn advance_by(&mut self, n: usize) -> Result<(), usize>

Advance the iterator by n elements

fn nth(&mut self, n: usize) -> Option<Self::Item<'_>>

Return the nth element of the iterator

fn map<O, F>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Item<'_>) -> O,

Take a closure which will take each value from the iterator, and yield a new value computed from it.

fn touch<F>(self, f: F) -> Touch<Self, F>where
    Self: Sized,
    F: FnMut(&mut Self::Item<'_>),

Gain mutable access to each value in this iterator, then yield it to the next step. This allows altering each item without consuming it, preserving the lending nature or the iterator

fn filter<F>(self, f: F) -> Filter<Self, F>where
    Self: Sized,
    F: FnMut(&Self::Item<'_>) -> bool,

Execute a closure on each item in the iterator, returning true if it should be included, or false to skip it

fn step_by(self, step: usize) -> StepBy<Self>where
    Self: Sized,

Creates an iterator starting at the same point, but stepping by the given amount at each iteration

fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter>where
    Self: Sized,
    U: IntoIterator,
    U::IntoIter: for<'a> Iterator<Item<'a> = Self::Item<'a>>,

Takes two iterators and creates a new iterator over both in sequence

fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter>where
    Self: Sized,
    U: IntoIterator,

‘Zips up’ two iterators into a single iterator of pairs

fn enumerate(self) -> Enumerate<Self>where
    Self: Sized,

Creates an iterator which gives the current iteration count as well as the next value

fn skip_while<F>(self, f: F) -> SkipWhile<Self, F>where
    Self: Sized,
    F: FnMut(&Self::Item<'_>) -> bool,

Creates an iterator that skips elements based on a predicate

fn take_while<F>(self, f: F) -> TakeWhile<Self, F>where
    Self: Sized,
    F: FnMut(&Self::Item<'_>) -> bool,

Creates an iterator that yields elements based on a predicate

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

Creates an iterator that skips the first n elements

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

Creates an iterator that yields the first n elements, or fewer if the underlying iterator ends sooner

fn all<F>(&mut self, f: F) -> boolwhere
    F: FnMut(Self::Item<'_>) -> bool,

Tests if every element of the iterator matches a predicate

fn any<F>(&mut self, f: F) -> boolwhere
    F: FnMut(Self::Item<'_>) -> bool,

Tests if any element of the iterator matches a predicate

fn find<F>(&mut self, f: F) -> Option<Self::Item<'_>>where
    F: FnMut(&Self::Item<'_>) -> bool,

Searches for an element of an iterator that satisfies a predicate

fn count(self) -> usizewhere
    Self: Sized,

Consume the iterator, counting the number of items and returning it

fn for_each<F>(self, f: F)where
    Self: Sized,
    F: FnMut(Self::Item<'_>),

Execute a closure on each value of this iterator

fn fold<T, F>(self, acc: T, f: F) -> Twhere
    Self: Sized,
    F: FnMut(T, Self::Item<'_>) -> T,

Execute a closure on each value of this iterator, with an additional ‘accumulator’ value passed to each call. The closure is expected to return the new value of the accumulator.

fn scan<T, B, F>(self, acc: T, f: F) -> Scan<Self, T, F> where
    Self: Sized,
    F: FnMut(&mut T, Self::Item<'_>) -> Option<B>,

Execute a closure on each value of this iterator, with an additional state value passed via mutable reference to each call. The closure is expected to return the new value for each step of the iterator, if the returned value is None the iterator stops early.