[][src]Struct itertools::structs::ZipLongest

#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct ZipLongest<T, U> { /* fields omitted */ }

An iterator which iterates two other iterators simultaneously

This iterator is fused.

See .zip_longest() for more information.

Trait Implementations

impl<T, U> Iterator for ZipLongest<T, U> where
    T: Iterator,
    U: Iterator
[src]

type Item = EitherOrBoth<T::Item, U::Item>

The type of the elements being iterated over.

fn count(self) -> usize1.0.0[src]

Consumes the iterator, counting the number of iterations and returning it. Read more

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

Consumes the iterator, returning the last element. Read more

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

Returns the nth element of the iterator. Read more

fn step_by(self, step: usize) -> StepBy<Self>1.28.0[src]

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

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
    U: IntoIterator<Item = Self::Item>, 
1.0.0[src]

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

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
    U: IntoIterator
1.0.0[src]

'Zips up' two iterators into a single iterator of pairs. Read more

fn map<B, F>(self, f: F) -> Map<Self, F> where
    F: FnMut(Self::Item) -> B, 
1.0.0[src]

Takes a closure and creates an iterator which calls that closure on each element. Read more

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

Calls a closure on each element of an iterator. Read more

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

Creates an iterator which uses a closure to determine if an element should be yielded. Read more

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
    F: FnMut(Self::Item) -> Option<B>, 
1.0.0[src]

Creates an iterator that both filters and maps. Read more

fn enumerate(self) -> Enumerate<Self>1.0.0[src]

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

fn peekable(self) -> Peekable<Self>1.0.0[src]

Creates an iterator which can use peek to look at the next element of the iterator without consuming it. Read more

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

Creates an iterator that [skip]s elements based on a predicate. Read more

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

Creates an iterator that yields elements based on a predicate. Read more

fn skip(self, n: usize) -> Skip<Self>1.0.0[src]

Creates an iterator that skips the first n elements. Read more

fn take(self, n: usize) -> Take<Self>1.0.0[src]

Creates an iterator that yields its first n elements. Read more

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
    F: FnMut(&mut St, Self::Item) -> Option<B>, 
1.0.0[src]

An iterator adaptor similar to [fold] that holds internal state and produces a new iterator. Read more

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
    F: FnMut(Self::Item) -> U,
    U: IntoIterator
1.0.0[src]

Creates an iterator that works like map, but flattens nested structure. Read more

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoIterator
1.29.0[src]

Creates an iterator that flattens nested structure. Read more

fn fuse(self) -> Fuse<Self>1.0.0[src]

Creates an iterator which ends after the first [None]. Read more

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

Do something with each element of an iterator, passing the value on. Read more

fn by_ref(&mut self) -> &mut Self1.0.0[src]

Borrows an iterator, rather than consuming it. Read more

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

Transforms an iterator into a collection. Read more

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

Consumes an iterator, creating two collections from it. Read more

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

An iterator method that applies a function as long as it returns successfully, producing a single, final value. Read more

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

An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error. Read more

fn fold<B, F>(self, init: B, f: F) -> B where
    F: FnMut(B, Self::Item) -> B, 
1.0.0[src]

An iterator method that applies a function, producing a single, final value. Read more

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

Tests if every element of the iterator matches a predicate. Read more

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

Tests if any element of the iterator matches a predicate. Read more

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

Searches for an element of an iterator that satisfies a predicate. Read more

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

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

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

Searches for an element in an iterator, returning its index. Read more

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

Searches for an element in an iterator from the right, returning its index. Read more

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

Returns the maximum element of an iterator. Read more

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

Returns the minimum element of an iterator. Read more

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

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

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

Returns the element that gives the maximum value with respect to the specified comparison function. Read more

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

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

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

Returns the element that gives the minimum value with respect to the specified comparison function. Read more

fn rev(self) -> Rev<Self> where
    Self: DoubleEndedIterator
1.0.0[src]

Reverses an iterator's direction. Read more

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

Converts an iterator of pairs into a pair of containers. Read more

fn copied<'a, T>(self) -> Copied<Self> where
    Self: Iterator<Item = &'a T>,
    T: 'a + Copy
1.36.0[src]

Creates an iterator which copies all of its elements. Read more

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: Iterator<Item = &'a T>,
    T: 'a + Clone
1.0.0[src]

Creates an iterator which [clone]s all of its elements. Read more

fn cycle(self) -> Cycle<Self> where
    Self: Clone
1.0.0[src]

Repeats an iterator endlessly. Read more

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

Sums the elements of an iterator. Read more

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

Iterates over the entire iterator, multiplying all the elements Read more

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

Lexicographically compares the elements of this Iterator with those of another. Read more

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

Lexicographically compares the elements of this Iterator with those of another. Read more

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

Determines if the elements of this Iterator are equal to those of another. Read more

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

Determines if the elements of this Iterator are unequal to those of another. Read more

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

Determines if the elements of this Iterator are lexicographically less than those of another. Read more

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

Determines if the elements of this Iterator are lexicographically less or equal to those of another. Read more

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

Determines if the elements of this Iterator are lexicographically greater than those of another. Read more

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

Determines if the elements of this Iterator are lexicographically greater than or equal to those of another. Read more

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

🔬 This is a nightly-only experimental API. (is_sorted)

new API

Checks if the elements of this iterator are sorted. Read more

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

🔬 This is a nightly-only experimental API. (is_sorted)

new API

Checks if the elements of this iterator are sorted using the given comparator function. Read more

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

🔬 This is a nightly-only experimental API. (is_sorted)

new API

Checks if the elements of this iterator are sorted using the given key extraction function. Read more

impl<T: Clone, U: Clone> Clone for ZipLongest<T, U>[src]

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

Performs copy-assignment from source. Read more

impl<T, U> ExactSizeIterator for ZipLongest<T, U> where
    T: ExactSizeIterator,
    U: ExactSizeIterator
[src]

fn len(&self) -> usize1.0.0[src]

Returns the exact number of times the iterator will iterate. Read more

fn is_empty(&self) -> bool[src]

🔬 This is a nightly-only experimental API. (exact_size_is_empty)

Returns true if the iterator is empty. Read more

impl<T, U> DoubleEndedIterator for ZipLongest<T, U> where
    T: DoubleEndedIterator + ExactSizeIterator,
    U: DoubleEndedIterator + ExactSizeIterator
[src]

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

🔬 This is a nightly-only experimental API. (iter_nth_back)

Returns the nth element from the end of the iterator. Read more

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

This is the reverse version of [try_fold()]: it takes elements starting from the back of the iterator. Read more

fn rfold<B, F>(self, accum: B, f: F) -> B where
    F: FnMut(B, Self::Item) -> B, 
1.27.0[src]

An iterator method that reduces the iterator's elements to a single, final value, starting from the back. Read more

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

Searches for an element of an iterator from the back that satisfies a predicate. Read more

impl<T: Debug, U: Debug> Debug for ZipLongest<T, U>[src]

Auto Trait Implementations

impl<T, U> Send for ZipLongest<T, U> where
    T: Send,
    U: Send

impl<T, U> Sync for ZipLongest<T, U> where
    T: Sync,
    U: Sync

Blanket Implementations

impl<T> Itertools for T where
    T: Iterator + ?Sized
[src]

Important traits for Interleave<I, J>
fn interleave<J>(self, other: J) -> Interleave<Self, J::IntoIter> where
    J: IntoIterator<Item = Self::Item>,
    Self: Sized
[src]

Alternate elements from two iterators until both have run out. Read more

Important traits for InterleaveShortest<I, J>
fn interleave_shortest<J>(
    self,
    other: J
) -> InterleaveShortest<Self, J::IntoIter> where
    J: IntoIterator<Item = Self::Item>,
    Self: Sized
[src]

Alternate elements from two iterators until at least one of them has run out. Read more

Important traits for Intersperse<I>
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self: Sized,
    Self::Item: Clone
[src]

An iterator adaptor to insert a particular value between each element of the adapted iterator. Read more

Important traits for ZipLongest<T, U>
fn zip_longest<J>(self, other: J) -> ZipLongest<Self, J::IntoIter> where
    J: IntoIterator,
    Self: Sized
[src]

Create an iterator which iterates over both this and the specified iterator simultaneously, yielding pairs of two optional elements. Read more

Important traits for ZipEq<I, J>
fn zip_eq<J>(self, other: J) -> ZipEq<Self, J::IntoIter> where
    J: IntoIterator,
    Self: Sized
[src]

Create an iterator which iterates over both this and the specified iterator simultaneously, yielding pairs of elements. Read more

Important traits for Batching<I, F>
fn batching<B, F>(self, f: F) -> Batching<Self, F> where
    F: FnMut(&mut Self) -> Option<B>,
    Self: Sized
[src]

A “meta iterator adaptor”. Its closure receives a reference to the iterator and may pick off as many elements as it likes, to produce the next iterator element. Read more

fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F> where
    Self: Sized,
    F: FnMut(&Self::Item) -> K,
    K: PartialEq
[src]

Return an iterable that can group iterator elements. Consecutive elements that map to the same key (“runs”), are assigned to the same group. Read more

fn chunks(self, size: usize) -> IntoChunks<Self> where
    Self: Sized
[src]

Return an iterable that can chunk the iterator. Read more

Important traits for TupleWindows<I, T>
fn tuple_windows<T>(self) -> TupleWindows<Self, T> where
    Self: Sized + Iterator<Item = T::Item>,
    T: TupleCollect,
    T::Item: Clone
[src]

Return an iterator over all contiguous windows producing tuples of a specific size (up to 4). Read more

Important traits for Tuples<I, T>
fn tuples<T>(self) -> Tuples<Self, T> where
    Self: Sized + Iterator<Item = T::Item>,
    T: TupleCollect, 
[src]

Return an iterator that groups the items in tuples of a specific size (up to 4). Read more

fn tee(self) -> (Tee<Self>, Tee<Self>) where
    Self: Sized,
    Self::Item: Clone
[src]

Split into an iterator pair that both yield all elements from the original iterator. Read more

Important traits for Step<I>
fn step(self, n: usize) -> Step<Self> where
    Self: Sized
[src]

Deprecated since 0.8:

Use std .step_by() instead

Return an iterator adaptor that steps n elements in the base iterator for each iteration. Read more

Important traits for MapInto<I, R>
fn map_into<R>(self) -> MapInto<Self, R> where
    Self: Sized,
    Self::Item: Into<R>, 
[src]

Convert each item of the iterator using the Into trait. Read more

Important traits for MapResults<I, F>
fn map_results<F, T, U, E>(self, f: F) -> MapResults<Self, F> where
    Self: Iterator<Item = Result<T, E>> + Sized,
    F: FnMut(T) -> U, 
[src]

Return an iterator adaptor that applies the provided closure to every Result::Ok value. Result::Err values are unchanged. Read more

Important traits for Merge<I, J>
fn merge<J>(self, other: J) -> Merge<Self, J::IntoIter> where
    Self: Sized,
    Self::Item: PartialOrd,
    J: IntoIterator<Item = Self::Item>, 
[src]

Return an iterator adaptor that merges the two base iterators in ascending order. If both base iterators are sorted (ascending), the result is sorted. Read more

Important traits for MergeBy<I, J, F>
fn merge_by<J, F>(self, other: J, is_first: F) -> MergeBy<Self, J::IntoIter, F> where
    Self: Sized,
    J: IntoIterator<Item = Self::Item>,
    F: FnMut(&Self::Item, &Self::Item) -> bool
[src]

Return an iterator adaptor that merges the two base iterators in order. This is much like .merge() but allows for a custom ordering. Read more

Important traits for MergeJoinBy<I, J, F>
fn merge_join_by<J, F>(
    self,
    other: J,
    cmp_fn: F
) -> MergeJoinBy<Self, J::IntoIter, F> where
    J: IntoIterator,
    F: FnMut(&Self::Item, &J::Item) -> Ordering,
    Self: Sized
[src]

Create an iterator that merges items from both this and the specified iterator in ascending order. Read more

Important traits for KMerge<I>
fn kmerge(self) -> KMerge<<Self::Item as IntoIterator>::IntoIter> where
    Self: Sized,
    Self::Item: IntoIterator,
    <Self::Item as IntoIterator>::Item: PartialOrd
[src]

Return an iterator adaptor that flattens an iterator of iterators by merging them in ascending order. Read more

Important traits for KMergeBy<I, F>
fn kmerge_by<F>(
    self,
    first: F
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F> where
    Self: Sized,
    Self::Item: IntoIterator,
    F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool
[src]

Return an iterator adaptor that flattens an iterator of iterators by merging them according to the given closure. Read more

Important traits for Product<I, J>
fn cartesian_product<J>(self, other: J) -> Product<Self, J::IntoIter> where
    Self: Sized,
    Self::Item: Clone,
    J: IntoIterator,
    J::IntoIter: Clone
[src]

Return an iterator adaptor that iterates over the cartesian product of the element sets of two iterators self and J. Read more

Important traits for MultiProduct<I>
fn multi_cartesian_product(
    self
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter> where
    Self: Iterator + Sized,
    Self::Item: IntoIterator,
    <Self::Item as IntoIterator>::IntoIter: Clone,
    <Self::Item as IntoIterator>::Item: Clone
[src]

Return an iterator adaptor that iterates over the cartesian product of all subiterators returned by meta-iterator self. Read more

Important traits for Coalesce<I, F>
fn coalesce<F>(self, f: F) -> Coalesce<Self, F> where
    Self: Sized,
    F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>, 
[src]

Return an iterator adaptor that uses the passed-in closure to optionally merge together consecutive elements. Read more

Important traits for Dedup<I>
fn dedup(self) -> Dedup<Self> where
    Self: Sized,
    Self::Item: PartialEq
[src]

Remove duplicates from sections of consecutive identical elements. If the iterator is sorted, all elements will be unique. Read more

Important traits for Unique<I>
fn unique(self) -> Unique<Self> where
    Self: Sized,
    Self::Item: Clone + Eq + Hash
[src]

Return an iterator adaptor that filters out elements that have already been produced once during the iteration. Duplicates are detected using hash and equality. Read more

Important traits for UniqueBy<I, V, F>
fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F> where
    Self: Sized,
    V: Eq + Hash,
    F: FnMut(&Self::Item) -> V, 
[src]

Return an iterator adaptor that filters out elements that have already been produced once during the iteration. Read more

Important traits for PeekingTakeWhile<'a, I, F>
fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<Self, F> where
    Self: Sized + PeekingNext,
    F: FnMut(&Self::Item) -> bool
[src]

Return an iterator adaptor that borrows from this iterator and takes items while the closure accept returns true. Read more

Important traits for TakeWhileRef<'a, I, F>
fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<Self, F> where
    Self: Clone,
    F: FnMut(&Self::Item) -> bool
[src]

Return an iterator adaptor that borrows from a Clone-able iterator to only pick off elements while the predicate accept returns true. Read more

Important traits for WhileSome<I>
fn while_some<A>(self) -> WhileSome<Self> where
    Self: Sized + Iterator<Item = Option<A>>, 
[src]

Return an iterator adaptor that filters Option<A> iterator elements and produces A. Stops on the first None encountered. Read more

Important traits for TupleCombinations<I, T>
fn tuple_combinations<T>(self) -> TupleCombinations<Self, T> where
    Self: Sized + Clone,
    Self::Item: Clone,
    T: HasCombination<Self>, 
[src]

Return an iterator adaptor that iterates over the combinations of the elements from an iterator. Read more

Important traits for Combinations<I>
fn combinations(self, n: usize) -> Combinations<Self> where
    Self: Sized,
    Self::Item: Clone
[src]

Return an iterator adaptor that iterates over the n-length combinations of the elements from an iterator. Read more

Important traits for PadUsing<I, F>
fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F> where
    Self: Sized,
    F: FnMut(usize) -> Self::Item
[src]

Return an iterator adaptor that pads the sequence to a minimum length of min by filling missing elements using a closure f. Read more

Important traits for WithPosition<I>
fn with_position(self) -> WithPosition<Self> where
    Self: Sized
[src]

Return an iterator adaptor that wraps each element in a Position to ease special-case handling of the first or last elements. Read more

Important traits for Positions<I, F>
fn positions<P>(self, predicate: P) -> Positions<Self, P> where
    Self: Sized,
    P: FnMut(Self::Item) -> bool
[src]

Return an iterator adaptor that yields the indices of all elements satisfying a predicate, counted from the start of the iterator. Read more

Important traits for Update<I, F>
fn update<F>(self, updater: F) -> Update<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Item), 
[src]

Return an iterator adaptor that applies a mutating function to each element before yielding it. Read more

fn next_tuple<T>(&mut self) -> Option<T> where
    Self: Sized + Iterator<Item = T::Item>,
    T: TupleCollect, 
[src]

Advances the iterator and returns the next items grouped in a tuple of a specific size (up to 4). Read more

fn collect_tuple<T>(self) -> Option<T> where
    Self: Sized + Iterator<Item = T::Item>,
    T: TupleCollect, 
[src]

Collects all items from the iterator into a tuple of a specific size (up to 4). Read more

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

Find the position and value of the first element satisfying a predicate. Read more

fn all_equal(&mut self) -> bool where
    Self::Item: PartialEq
[src]

Check whether all elements compare equal. Read more

fn dropping(self, n: usize) -> Self where
    Self: Sized
[src]

Consume the first n elements from the iterator eagerly, and return the same iterator again. Read more

fn dropping_back(self, n: usize) -> Self where
    Self: Sized,
    Self: DoubleEndedIterator
[src]

Consume the last n elements from the iterator eagerly, and return the same iterator again. Read more

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

Deprecated since 0.8:

Use .for_each() instead

Run the closure f eagerly on each element of the iterator. Read more

fn concat(self) -> Self::Item where
    Self: Sized,
    Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default
[src]

Combine all an iterator's elements into one element by using Extend. Read more

fn collect_vec(self) -> Vec<Self::Item> where
    Self: Sized
[src]

.collect_vec() is simply a type specialization of .collect(), for convenience. Read more

fn set_from<'a, A: 'a, J>(&mut self, from: J) -> usize where
    Self: Iterator<Item = &'a mut A>,
    J: IntoIterator<Item = A>, 
[src]

Assign to each reference in self from the from iterator, stopping at the shortest of the two iterators. Read more

fn join(&mut self, sep: &str) -> String where
    Self::Item: Display
[src]

Combine all iterator elements into one String, seperated by sep. Read more

fn format(self, sep: &str) -> Format<Self> where
    Self: Sized
[src]

Format all iterator elements, separated by sep. Read more

fn format_with<F>(self, sep: &str, format: F) -> FormatWith<Self, F> where
    Self: Sized,
    F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display) -> Result) -> Result
[src]

Format all iterator elements, separated by sep. Read more

fn fold_results<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E> where
    Self: Iterator<Item = Result<A, E>>,
    F: FnMut(B, A) -> B, 
[src]

Fold Result values from an iterator. Read more

fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option<B> where
    Self: Iterator<Item = Option<A>>,
    F: FnMut(B, A) -> B, 
[src]

Fold Option values from an iterator. Read more

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

Accumulator of the elements in the iterator. Read more

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

Accumulate the elements in the iterator in a tree-like manner. Read more

fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B> where
    Self: Sized,
    F: FnMut(B, Self::Item) -> FoldWhile<B>, 
[src]

Deprecated since 0.8:

Use .try_fold() instead

An iterator method that applies a function, producing a single, final value. Read more

fn sorted(self) -> IntoIter<Self::Item> where
    Self: Sized,
    Self::Item: Ord
[src]

Sort all iterator elements into a new iterator in ascending order. Read more

fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item> where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering
[src]

Sort all iterator elements into a new iterator in ascending order. Read more

fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item> where
    Self: Sized,
    K: Ord,
    F: FnMut(&Self::Item) -> K, 
[src]

Sort all iterator elements into a new iterator in ascending order. Read more

fn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B) where
    Self: Sized,
    F: Fn(Self::Item) -> Either<L, R>,
    A: Default + Extend<L>,
    B: Default + Extend<R>, 
[src]

Collect all iterator elements into one of two partitions. Unlike Iterator::partition, each partition may have a distinct type. Read more

fn into_group_map<K, V>(self) -> HashMap<K, Vec<V>> where
    Self: Iterator<Item = (K, V)> + Sized,
    K: Hash + Eq
[src]

Return a HashMap of keys mapped to Vecs of values. Keys and values are taken from (Key, Value) tuple pairs yielded by the input iterator. Read more

fn minmax(self) -> MinMaxResult<Self::Item> where
    Self: Sized,
    Self::Item: PartialOrd
[src]

Return the minimum and maximum elements in the iterator. Read more

fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item> where
    Self: Sized,
    K: PartialOrd,
    F: FnMut(&Self::Item) -> K, 
[src]

Return the minimum and maximum element of an iterator, as determined by the specified function. Read more

fn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item> where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering
[src]

Return the minimum and maximum element of an iterator, as determined by the specified comparison function. Read more

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

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

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

impl<I> IntoIterator for I where
    I: Iterator
[src]

type Item = <I as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = I

Which kind of iterator are we turning this into?

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

type Error = Infallible

The type returned in the event of a conversion error.

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

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

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

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

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