[][src]Struct debruijn::graph::NodeIter

pub struct NodeIter<'a, K: Kmer + 'a, D: Debug + 'a> { /* fields omitted */ }

Iterator over nodes in a DeBruijnGraph

Trait Implementations

impl<'a, K: Kmer + 'a, D: Debug + 'a> Iterator for NodeIter<'a, K, D>[src]

type Item = Node<'a, K, D>

The type of the elements being iterated over.

fn size_hint(&self) -> (usize, Option<usize>)
1.0.0
[src]

Returns the bounds on the remaining length of the iterator. Read more

fn count(self) -> usize
1.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 Self
1.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
[src]

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

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

Auto Trait Implementations

impl<'a, K, D> Send for NodeIter<'a, K, D> where
    D: Sync,
    K: Sync

impl<'a, K, D> Sync for NodeIter<'a, K, D> where
    D: Sync,
    K: Sync

Blanket Implementations

impl<T> From 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> Into for T where
    U: From<T>, 
[src]

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

type Error = Infallible

The type returned in the event of a conversion error.

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

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

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

impl<T, U> TryInto 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> ParallelBridge for T where
    T: Send + Iterator,
    <T as Iterator>::Item: Send
[src]

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

fn interleave<J>(
    self,
    other: J
) -> Interleave<Self, <J as IntoIterator>::IntoIter> where
    J: IntoIterator<Item = Self::Item>, 
[src]

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

fn interleave_shortest<J>(
    self,
    other: J
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter> where
    J: IntoIterator<Item = Self::Item>, 
[src]

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

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
    Self::Item: Clone
[src]

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

fn zip_longest<J>(
    self,
    other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter> where
    J: IntoIterator
[src]

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

fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter> where
    J: IntoIterator
[src]

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

fn batching<B, F>(self, f: F) -> Batching<Self, F> where
    F: FnMut(&mut Self) -> Option<B>, 
[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
    F: FnMut(&Self::Item) -> K,
    K: PartialEq<K>, 
[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>[src]

Return an iterable that can chunk the iterator. Read more

fn tuple_windows<T>(self) -> TupleWindows<Self, T> where
    Self: Iterator<Item = <T as TupleCollect>::Item>,
    T: TupleCollect,
    <T as TupleCollect>::Item: Clone
[src]

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

fn tuples<T>(self) -> Tuples<Self, T> where
    Self: Iterator<Item = <T as TupleCollect>::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::Item: Clone
[src]

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

fn step(self, n: usize) -> Step<Self>[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

fn map_into<R>(self) -> MapInto<Self, R> where
    Self::Item: Into<R>, 
[src]

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

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

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

fn merge<J>(self, other: J) -> Merge<Self, <J as IntoIterator>::IntoIter> where
    J: IntoIterator<Item = Self::Item>,
    Self::Item: PartialOrd<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

fn merge_by<J, F>(
    self,
    other: J,
    is_first: F
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F> where
    F: FnMut(&Self::Item, &Self::Item) -> bool,
    J: IntoIterator<Item = Self::Item>, 
[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

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

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

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

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

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

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

fn cartesian_product<J>(
    self,
    other: J
) -> Product<Self, <J as IntoIterator>::IntoIter> where
    J: IntoIterator,
    Self::Item: Clone,
    <J as IntoIterator>::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

fn multi_cartesian_product(
    self
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter> where
    Self: Iterator,
    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

fn coalesce<F>(self, f: F) -> Coalesce<Self, F> where
    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

fn dedup(self) -> Dedup<Self> where
    Self::Item: PartialEq<Self::Item>, 
[src]

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

fn unique(self) -> Unique<Self> where
    Self::Item: Clone,
    Self::Item: Eq,
    Self::Item: 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

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

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

fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<Self, F> where
    F: FnMut(&Self::Item) -> bool,
    Self: PeekingNext
[src]

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

fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<Self, F> where
    F: FnMut(&Self::Item) -> bool,
    Self: Clone
[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

fn while_some<A>(self) -> WhileSome<Self> where
    Self: 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

fn tuple_combinations<T>(self) -> TupleCombinations<Self, T> where
    Self: Clone,
    T: HasCombination<Self>,
    Self::Item: Clone
[src]

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

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

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

fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F> where
    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

fn with_position(self) -> WithPosition<Self>[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

fn positions<P>(self, predicate: P) -> Positions<Self, P> where
    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

fn update<F>(self, updater: F) -> Update<Self, F> where
    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: Iterator<Item = <T as TupleCollect>::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: Iterator<Item = <T as TupleCollect>::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<Self::Item>, 
[src]

Check whether all elements compare equal. Read more

fn dropping(self, n: usize) -> Self[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: 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), 
[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::Item: Extend<<Self::Item as IntoIterator>::Item>,
    Self::Item: IntoIterator,
    Self::Item: Default
[src]

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

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

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

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

Format all iterator elements, separated by sep. Read more

fn format_with<F>(self, sep: &str, format: F) -> FormatWith<Self, F> where
    F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display)) -> Result<(), Error>, 
[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
    F: FnMut(B, A) -> B,
    Self: Iterator<Item = Result<A, E>>, 
[src]

Fold Result values from an iterator. Read more

fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option<B> where
    F: FnMut(B, A) -> B,
    Self: Iterator<Item = Option<A>>, 
[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
[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
[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
    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::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
    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
    F: FnMut(&Self::Item) -> K,
    K: Ord
[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
    A: Default + Extend<L>,
    B: Default + Extend<R>,
    F: Fn(Self::Item) -> Either<L, 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>, RandomState> where
    K: Hash + Eq,
    Self: Iterator<Item = (K, V)>, 
[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::Item: PartialOrd<Self::Item>, 
[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
    F: FnMut(&Self::Item) -> K,
    K: PartialOrd<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
    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