Struct 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> = <I1 as Iterator>::Item<'a> where Self: '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) -> bool

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

Tests if every element of the iterator matches a predicate

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

where 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) -> usize

where 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) -> T

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