pub struct Preorder<'a, 'tcx> {
body: &'a Body<'tcx>,
visited: BitSet<BasicBlock>,
worklist: Vec<BasicBlock, Global>,
root_is_start_block: bool,
}Expand description
Preorder traversal of a graph.
Preorder traversal is when each node is visited after at least one of its predecessors. If you are familiar with some basic graph theory, then this performs a depth first search and returns nodes in order of discovery time.
A
/ \
/ \
B C
\ /
\ /
D
A preorder traversal of this graph is either A B D C or A C D B
Fields§
§body: &'a Body<'tcx>§visited: BitSet<BasicBlock>§worklist: Vec<BasicBlock, Global>§root_is_start_block: boolAuto Trait Implementations§
impl<'a, 'tcx> !RefUnwindSafe for Preorder<'a, 'tcx>
impl<'a, 'tcx> !Send for Preorder<'a, 'tcx>
impl<'a, 'tcx> !Sync for Preorder<'a, 'tcx>
impl<'a, 'tcx> Unpin for Preorder<'a, 'tcx>
impl<'a, 'tcx> !UnwindSafe for Preorder<'a, 'tcx>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<I> IntoIterator for Iwhere
I: Iterator,
impl<I> IntoIterator for Iwhere I: Iterator,
source§impl<T> Itertools for Twhere
T: Iterator + ?Sized,
impl<T> Itertools for Twhere T: Iterator + ?Sized,
source§fn interleave<J>(
self,
other: J
) -> Interleave<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator<Item = Self::Item>,
Self: Sized,
fn interleave<J>( self, other: J ) -> Interleave<Self, <J as IntoIterator>::IntoIter>where J: IntoIterator<Item = Self::Item>, Self: Sized,
Alternate elements from two iterators until both have run out. Read more
source§fn interleave_shortest<J>(
self,
other: J
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator<Item = Self::Item>,
Self: Sized,
fn interleave_shortest<J>( self, other: J ) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>where J: IntoIterator<Item = Self::Item>, Self: Sized,
Alternate elements from two iterators until at least one of them has run
out. Read more
source§fn intersperse(
self,
element: Self::Item
) -> IntersperseWith<Self, IntersperseElementSimple<Self::Item>>where
Self: Sized,
Self::Item: Clone,
fn intersperse( self, element: Self::Item ) -> IntersperseWith<Self, IntersperseElementSimple<Self::Item>>where Self: Sized, Self::Item: Clone,
An iterator adaptor to insert a particular value
between each element of the adapted iterator. Read more
source§fn intersperse_with<F>(self, element: F) -> IntersperseWith<Self, F>where
Self: Sized,
F: FnMut() -> Self::Item,
fn intersperse_with<F>(self, element: F) -> IntersperseWith<Self, F>where Self: Sized, F: FnMut() -> Self::Item,
An iterator adaptor to insert a particular value created by a function
between each element of the adapted iterator. Read more
source§fn zip_longest<J>(
self,
other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
Self: Sized,
fn zip_longest<J>( self, other: J ) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>where J: IntoIterator, Self: Sized,
Create an iterator which iterates over both this and the specified
iterator simultaneously, yielding pairs of two optional elements. Read more
source§fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
Self: Sized,
fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>where J: IntoIterator, Self: Sized,
Create an iterator which iterates over both this and the specified
iterator simultaneously, yielding pairs of elements. Read more
source§fn batching<B, F>(self, f: F) -> Batching<Self, F>where
F: FnMut(&mut Self) -> Option<B>,
Self: Sized,
fn batching<B, F>(self, f: F) -> Batching<Self, F>where F: FnMut(&mut Self) -> Option<B>, Self: Sized,
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
source§fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F>where
Self: Sized,
F: FnMut(&Self::Item) -> K,
K: PartialEq<K>,
fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F>where Self: Sized, F: FnMut(&Self::Item) -> K, K: PartialEq<K>,
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
source§fn chunks(self, size: usize) -> IntoChunks<Self>where
Self: Sized,
fn chunks(self, size: usize) -> IntoChunks<Self>where Self: Sized,
Return an iterable that can chunk the iterator. Read more
source§fn tuple_windows<T>(self) -> TupleWindows<Self, T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
<T as TupleCollect>::Item: Clone,
fn tuple_windows<T>(self) -> TupleWindows<Self, T>where Self: Sized + Iterator<Item = <T as TupleCollect>::Item>, T: HomogeneousTuple, <T as TupleCollect>::Item: Clone,
Return an iterator over all contiguous windows producing tuples of
a specific size (up to 12). Read more
source§fn circular_tuple_windows<T>(self) -> CircularTupleWindows<Self, T>where
Self: Sized + Clone + Iterator<Item = <T as TupleCollect>::Item> + ExactSizeIterator,
T: TupleCollect + Clone,
<T as TupleCollect>::Item: Clone,
fn circular_tuple_windows<T>(self) -> CircularTupleWindows<Self, T>where Self: Sized + Clone + Iterator<Item = <T as TupleCollect>::Item> + ExactSizeIterator, T: TupleCollect + Clone, <T as TupleCollect>::Item: Clone,
Return an iterator over all windows, wrapping back to the first
elements when the window would otherwise exceed the length of the
iterator, producing tuples of a specific size (up to 12). Read more
source§fn tuples<T>(self) -> Tuples<Self, T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn tuples<T>(self) -> Tuples<Self, T>where Self: Sized + Iterator<Item = <T as TupleCollect>::Item>, T: HomogeneousTuple,
Return an iterator that groups the items in tuples of a specific size
(up to 12). Read more
source§fn tee(self) -> (Tee<Self>, Tee<Self>)where
Self: Sized,
Self::Item: Clone,
fn tee(self) -> (Tee<Self>, Tee<Self>)where Self: Sized, Self::Item: Clone,
Split into an iterator pair that both yield all elements from
the original iterator. Read more
source§fn step(self, n: usize) -> Step<Self>where
Self: Sized,
fn step(self, n: usize) -> Step<Self>where Self: Sized,
👎Deprecated since 0.8.0: Use std .step_by() instead
Return an iterator adaptor that steps
n elements in the base iterator
for each iteration. Read moresource§fn map_into<R>(self) -> MapSpecialCase<Self, MapSpecialCaseFnInto<R>>where
Self: Sized,
Self::Item: Into<R>,
fn map_into<R>(self) -> MapSpecialCase<Self, MapSpecialCaseFnInto<R>>where Self: Sized, Self::Item: Into<R>,
source§fn map_results<F, T, U, E>(
self,
f: F
) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> U,
fn map_results<F, T, U, E>( self, f: F ) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>where Self: Iterator<Item = Result<T, E>> + Sized, F: FnMut(T) -> U,
👎Deprecated since 0.10.0: Use .map_ok() instead
See
.map_ok().source§fn map_ok<F, T, U, E>(self, f: F) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> U,
fn map_ok<F, T, U, E>(self, f: F) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>where Self: Iterator<Item = Result<T, E>> + Sized, F: FnMut(T) -> U,
Return an iterator adaptor that applies the provided closure
to every
Result::Ok value. Result::Err values are
unchanged. Read moresource§fn filter_ok<F, T, E>(self, f: F) -> FilterOk<Self, F>where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(&T) -> bool,
fn filter_ok<F, T, E>(self, f: F) -> FilterOk<Self, F>where Self: Iterator<Item = Result<T, E>> + Sized, F: FnMut(&T) -> bool,
Return an iterator adaptor that filters every
Result::Ok
value with the provided closure. Result::Err values are
unchanged. Read moresource§fn filter_map_ok<F, T, U, E>(self, f: F) -> FilterMapOk<Self, F>where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> Option<U>,
fn filter_map_ok<F, T, U, E>(self, f: F) -> FilterMapOk<Self, F>where Self: Iterator<Item = Result<T, E>> + Sized, F: FnMut(T) -> Option<U>,
Return an iterator adaptor that filters and transforms every
Result::Ok value with the provided closure. Result::Err
values are unchanged. Read moresource§fn flatten_ok<T, E>(self) -> FlattenOk<Self, T, E>where
Self: Iterator<Item = Result<T, E>> + Sized,
T: IntoIterator,
fn flatten_ok<T, E>(self) -> FlattenOk<Self, T, E>where Self: Iterator<Item = Result<T, E>> + Sized, T: IntoIterator,
Return an iterator adaptor that flattens every
Result::Ok value into
a series of Result::Ok values. Result::Err values are unchanged. Read moresource§fn process_results<F, T, E, R>(self, processor: F) -> Result<R, E>where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnOnce(ProcessResults<'_, Self, E>) -> R,
fn process_results<F, T, E, R>(self, processor: F) -> Result<R, E>where Self: Iterator<Item = Result<T, E>> + Sized, F: FnOnce(ProcessResults<'_, Self, E>) -> R,
“Lift” a function of the values of the current iterator so as to process
an iterator of
Result values instead. Read moresource§fn merge<J>(
self,
other: J
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>where
Self: Sized,
Self::Item: PartialOrd<Self::Item>,
J: IntoIterator<Item = Self::Item>,
fn merge<J>( self, other: J ) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>where Self: Sized, Self::Item: PartialOrd<Self::Item>, J: IntoIterator<Item = Self::Item>,
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
source§fn merge_by<J, F>(
self,
other: J,
is_first: F
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>where
Self: Sized,
J: IntoIterator<Item = Self::Item>,
F: FnMut(&Self::Item, &Self::Item) -> bool,
fn merge_by<J, F>( self, other: J, is_first: F ) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>where Self: Sized, J: IntoIterator<Item = Self::Item>, F: FnMut(&Self::Item, &Self::Item) -> bool,
source§fn merge_join_by<J, F, T>(
self,
other: J,
cmp_fn: F
) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>where
J: IntoIterator,
F: FnMut(&Self::Item, &<J as IntoIterator>::Item) -> T,
T: OrderingOrBool<Self::Item, <J as IntoIterator>::Item>,
Self: Sized,
fn merge_join_by<J, F, T>( self, other: J, cmp_fn: F ) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>where J: IntoIterator, F: FnMut(&Self::Item, &<J as IntoIterator>::Item) -> T, T: OrderingOrBool<Self::Item, <J as IntoIterator>::Item>, Self: Sized,
Create an iterator that merges items from both this and the specified
iterator in ascending order. Read more
source§fn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt>where
Self: Sized,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: PartialOrd<<Self::Item as IntoIterator>::Item>,
fn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt>where Self: Sized, Self::Item: IntoIterator, <Self::Item as IntoIterator>::Item: PartialOrd<<Self::Item as IntoIterator>::Item>,
Return an iterator adaptor that flattens an iterator of iterators by
merging them in ascending order. Read more
source§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,
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,
Return an iterator adaptor that flattens an iterator of iterators by
merging them according to the given closure. Read more
source§fn cartesian_product<J>(
self,
other: J
) -> Product<Self, <J as IntoIterator>::IntoIter>where
Self: Sized,
Self::Item: Clone,
J: IntoIterator,
<J as IntoIterator>::IntoIter: Clone,
fn cartesian_product<J>( self, other: J ) -> Product<Self, <J as IntoIterator>::IntoIter>where Self: Sized, Self::Item: Clone, J: IntoIterator, <J as IntoIterator>::IntoIter: Clone,
Return an iterator adaptor that iterates over the cartesian product of
the element sets of two iterators
self and J. Read moresource§fn multi_cartesian_product(
self
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>where
Self: Sized,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::IntoIter: Clone,
<Self::Item as IntoIterator>::Item: Clone,
fn multi_cartesian_product( self ) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>where Self: Sized, Self::Item: IntoIterator, <Self::Item as IntoIterator>::IntoIter: Clone, <Self::Item as IntoIterator>::Item: Clone,
Return an iterator adaptor that iterates over the cartesian product of
all subiterators returned by meta-iterator
self. Read moresource§fn coalesce<F>(self, f: F) -> CoalesceBy<Self, F, Self::Item>where
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,
fn coalesce<F>(self, f: F) -> CoalesceBy<Self, F, Self::Item>where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,
Return an iterator adaptor that uses the passed-in closure to
optionally merge together consecutive elements. Read more
source§fn dedup(self) -> CoalesceBy<Self, DedupPred2CoalescePred<DedupEq>, Self::Item>where
Self: Sized,
Self::Item: PartialEq<Self::Item>,
fn dedup(self) -> CoalesceBy<Self, DedupPred2CoalescePred<DedupEq>, Self::Item>where Self: Sized, Self::Item: PartialEq<Self::Item>,
Remove duplicates from sections of consecutive identical elements.
If the iterator is sorted, all elements will be unique. Read more
source§fn dedup_by<Cmp>(
self,
cmp: Cmp
) -> CoalesceBy<Self, DedupPred2CoalescePred<Cmp>, Self::Item>where
Self: Sized,
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
fn dedup_by<Cmp>( self, cmp: Cmp ) -> CoalesceBy<Self, DedupPred2CoalescePred<Cmp>, Self::Item>where Self: Sized, Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
Remove duplicates from sections of consecutive identical elements,
determining equality using a comparison function.
If the iterator is sorted, all elements will be unique. Read more
source§fn dedup_with_count(
self
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<DedupEq>, (usize, Self::Item)>where
Self: Sized,
fn dedup_with_count( self ) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<DedupEq>, (usize, Self::Item)>where Self: Sized,
Remove duplicates from sections of consecutive identical elements, while keeping a count of
how many repeated elements were present.
If the iterator is sorted, all elements will be unique. Read more
source§fn dedup_by_with_count<Cmp>(
self,
cmp: Cmp
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<Cmp>, (usize, Self::Item)>where
Self: Sized,
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
fn dedup_by_with_count<Cmp>( self, cmp: Cmp ) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<Cmp>, (usize, Self::Item)>where Self: Sized, Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
Remove duplicates from sections of consecutive identical elements, while keeping a count of
how many repeated elements were present.
This will determine equality using a comparison function.
If the iterator is sorted, all elements will be unique. Read more
source§fn duplicates(self) -> DuplicatesBy<Self, Self::Item, ById>where
Self: Sized,
Self::Item: Eq + Hash,
fn duplicates(self) -> DuplicatesBy<Self, Self::Item, ById>where Self: Sized, Self::Item: Eq + Hash,
Return an iterator adaptor that produces elements that appear more than once during the
iteration. Duplicates are detected using hash and equality. Read more
source§fn duplicates_by<V, F>(self, f: F) -> DuplicatesBy<Self, V, ByFn<F>>where
Self: Sized,
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
fn duplicates_by<V, F>(self, f: F) -> DuplicatesBy<Self, V, ByFn<F>>where Self: Sized, V: Eq + Hash, F: FnMut(&Self::Item) -> V,
Return an iterator adaptor that produces elements that appear more than once during the
iteration. Duplicates are detected using hash and equality. Read more
source§fn unique(self) -> Unique<Self>where
Self: Sized,
Self::Item: Clone + Eq + Hash,
fn unique(self) -> Unique<Self>where Self: Sized, Self::Item: Clone + Eq + Hash,
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
source§fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>where
Self: Sized,
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>where Self: Sized, V: Eq + Hash, F: FnMut(&Self::Item) -> V,
Return an iterator adaptor that filters out elements that have
already been produced once during the iteration. Read more
source§fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F>where
Self: Sized + PeekingNext,
F: FnMut(&Self::Item) -> bool,
fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F>where Self: Sized + PeekingNext, F: FnMut(&Self::Item) -> bool,
Return an iterator adaptor that borrows from this iterator and
takes items while the closure
accept returns true. Read moresource§fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>where
Self: Clone,
F: FnMut(&Self::Item) -> bool,
fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>where Self: Clone, F: FnMut(&Self::Item) -> bool,
Return an iterator adaptor that borrows from a
Clone-able iterator
to only pick off elements while the predicate accept returns true. Read moresource§fn take_while_inclusive<F>(
&mut self,
accept: F
) -> TakeWhileInclusive<'_, Self, F>where
Self: Sized,
F: FnMut(&Self::Item) -> bool,
fn take_while_inclusive<F>( &mut self, accept: F ) -> TakeWhileInclusive<'_, Self, F>where Self: Sized, F: FnMut(&Self::Item) -> bool,
Returns an iterator adaptor that consumes elements while the given
predicate is
true, including the element for which the predicate
first returned false. Read moresource§fn while_some<A>(self) -> WhileSome<Self>where
Self: Sized + Iterator<Item = Option<A>>,
fn while_some<A>(self) -> WhileSome<Self>where Self: Sized + Iterator<Item = Option<A>>,
Return an iterator adaptor that filters
Option<A> iterator elements
and produces A. Stops on the first None encountered. Read moresource§fn tuple_combinations<T>(self) -> TupleCombinations<Self, T>where
Self: Sized + Clone,
Self::Item: Clone,
T: HasCombination<Self>,
fn tuple_combinations<T>(self) -> TupleCombinations<Self, T>where Self: Sized + Clone, Self::Item: Clone, T: HasCombination<Self>,
Return an iterator adaptor that iterates over the combinations of the
elements from an iterator. Read more
source§fn combinations(self, k: usize) -> Combinations<Self>where
Self: Sized,
Self::Item: Clone,
fn combinations(self, k: usize) -> Combinations<Self>where Self: Sized, Self::Item: Clone,
Return an iterator adaptor that iterates over the
k-length combinations of
the elements from an iterator. Read moresource§fn combinations_with_replacement(
self,
k: usize
) -> CombinationsWithReplacement<Self>where
Self: Sized,
Self::Item: Clone,
fn combinations_with_replacement( self, k: usize ) -> CombinationsWithReplacement<Self>where Self: Sized, Self::Item: Clone,
Return an iterator that iterates over the
k-length combinations of
the elements from an iterator, with replacement. Read moresource§fn permutations(self, k: usize) -> Permutations<Self>where
Self: Sized,
Self::Item: Clone,
fn permutations(self, k: usize) -> Permutations<Self>where Self: Sized, Self::Item: Clone,
Return an iterator adaptor that iterates over all k-permutations of the
elements from an iterator. Read more
source§fn powerset(self) -> Powerset<Self>where
Self: Sized,
Self::Item: Clone,
fn powerset(self) -> Powerset<Self>where Self: Sized, Self::Item: Clone,
Return an iterator that iterates through the powerset of the elements from an
iterator. Read more
source§fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>where
Self: Sized,
F: FnMut(usize) -> Self::Item,
fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>where Self: Sized, F: FnMut(usize) -> Self::Item,
Return an iterator adaptor that pads the sequence to a minimum length of
min by filling missing elements using a closure f. Read moresource§fn with_position(self) -> WithPosition<Self>where
Self: Sized,
fn with_position(self) -> WithPosition<Self>where Self: Sized,
Return an iterator adaptor that combines each element with a
Position to
ease special-case handling of the first or last elements. Read moresource§fn positions<P>(self, predicate: P) -> Positions<Self, P>where
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn positions<P>(self, predicate: P) -> Positions<Self, P>where Self: Sized, P: FnMut(Self::Item) -> bool,
Return an iterator adaptor that yields the indices of all elements
satisfying a predicate, counted from the start of the iterator. Read more
source§fn update<F>(self, updater: F) -> Update<Self, F>where
Self: Sized,
F: FnMut(&mut Self::Item),
fn update<F>(self, updater: F) -> Update<Self, F>where Self: Sized, F: FnMut(&mut Self::Item),
Return an iterator adaptor that applies a mutating function
to each element before yielding it. Read more
source§fn next_tuple<T>(&mut self) -> Option<T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn next_tuple<T>(&mut self) -> Option<T>where Self: Sized + Iterator<Item = <T as TupleCollect>::Item>, T: HomogeneousTuple,
Advances the iterator and returns the next items grouped in a tuple of
a specific size (up to 12). Read more
source§fn collect_tuple<T>(self) -> Option<T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn collect_tuple<T>(self) -> Option<T>where Self: Sized + Iterator<Item = <T as TupleCollect>::Item>, T: HomogeneousTuple,
Collects all items from the iterator into a tuple of a specific size
(up to 12). Read more
source§fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)>where
P: FnMut(&Self::Item) -> bool,
fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)>where P: FnMut(&Self::Item) -> bool,
Find the position and value of the first element satisfying a predicate. Read more
source§fn find_or_last<P>(self, predicate: P) -> Option<Self::Item>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn find_or_last<P>(self, predicate: P) -> Option<Self::Item>where Self: Sized, P: FnMut(&Self::Item) -> bool,
Find the value of the first element satisfying a predicate or return the last element, if any. Read more
source§fn find_or_first<P>(self, predicate: P) -> Option<Self::Item>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn find_or_first<P>(self, predicate: P) -> Option<Self::Item>where Self: Sized, P: FnMut(&Self::Item) -> bool,
Find the value of the first element satisfying a predicate or return the first element, if any. Read more
source§fn contains<Q>(&mut self, query: &Q) -> boolwhere
Self: Sized,
Self::Item: Borrow<Q>,
Q: PartialEq<Q>,
fn contains<Q>(&mut self, query: &Q) -> boolwhere Self: Sized, Self::Item: Borrow<Q>, Q: PartialEq<Q>,
Returns
true if the given item is present in this iterator. Read moresource§fn all_equal(&mut self) -> boolwhere
Self: Sized,
Self::Item: PartialEq<Self::Item>,
fn all_equal(&mut self) -> boolwhere Self: Sized, Self::Item: PartialEq<Self::Item>,
Check whether all elements compare equal. Read more
source§fn all_equal_value(
&mut self
) -> Result<Self::Item, Option<(Self::Item, Self::Item)>>where
Self: Sized,
Self::Item: PartialEq<Self::Item>,
fn all_equal_value( &mut self ) -> Result<Self::Item, Option<(Self::Item, Self::Item)>>where Self: Sized, Self::Item: PartialEq<Self::Item>,
If there are elements and they are all equal, return a single copy of that element.
If there are no elements, return an Error containing None.
If there are elements and they are not all equal, return a tuple containing the first
two non-equal elements found. Read more
source§fn all_unique(&mut self) -> boolwhere
Self: Sized,
Self::Item: Eq + Hash,
fn all_unique(&mut self) -> boolwhere Self: Sized, Self::Item: Eq + Hash,
Check whether all elements are unique (non equal). Read more
source§fn dropping(self, n: usize) -> Selfwhere
Self: Sized,
fn dropping(self, n: usize) -> Selfwhere Self: Sized,
Consume the first
n elements from the iterator eagerly,
and return the same iterator again. Read moresource§fn dropping_back(self, n: usize) -> Selfwhere
Self: Sized + DoubleEndedIterator,
fn dropping_back(self, n: usize) -> Selfwhere Self: Sized + DoubleEndedIterator,
Consume the last
n elements from the iterator eagerly,
and return the same iterator again. Read moresource§fn foreach<F>(self, f: F)where
F: FnMut(Self::Item),
Self: Sized,
fn foreach<F>(self, f: F)where F: FnMut(Self::Item), Self: Sized,
👎Deprecated since 0.8.0: Use .for_each() instead
Run the closure
f eagerly on each element of the iterator. Read moresource§fn concat(self) -> Self::Itemwhere
Self: Sized,
Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,
fn concat(self) -> Self::Itemwhere Self: Sized, Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,
source§fn collect_vec(self) -> Vec<Self::Item, Global>where
Self: Sized,
fn collect_vec(self) -> Vec<Self::Item, Global>where Self: Sized,
.collect_vec() is simply a type specialization of Iterator::collect,
for convenience.source§fn try_collect<T, U, E>(self) -> Result<U, E>where
Self: Sized + Iterator<Item = Result<T, E>>,
Result<U, E>: FromIterator<Result<T, E>>,
fn try_collect<T, U, E>(self) -> Result<U, E>where Self: Sized + Iterator<Item = Result<T, E>>, Result<U, E>: FromIterator<Result<T, E>>,
source§fn set_from<'a, A, J>(&mut self, from: J) -> usizewhere
A: 'a,
Self: Iterator<Item = &'a mut A>,
J: IntoIterator<Item = A>,
fn set_from<'a, A, J>(&mut self, from: J) -> usizewhere A: 'a, Self: Iterator<Item = &'a mut A>, J: IntoIterator<Item = A>,
Assign to each reference in
self from the from iterator,
stopping at the shortest of the two iterators. Read moresource§fn join(&mut self, sep: &str) -> Stringwhere
Self::Item: Display,
fn join(&mut self, sep: &str) -> Stringwhere Self::Item: Display,
Combine all iterator elements into one String, separated by
sep. Read moresource§fn format(self, sep: &str) -> Format<'_, Self>where
Self: Sized,
fn format(self, sep: &str) -> Format<'_, Self>where Self: Sized,
Format all iterator elements, separated by
sep. Read moresource§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<(), Error>) -> Result<(), Error>,
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<(), Error>) -> Result<(), Error>,
Format all iterator elements, separated by
sep. Read moresource§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,
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,
👎Deprecated since 0.10.0: Use .fold_ok() instead
See
.fold_ok().source§fn fold_ok<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,
fn fold_ok<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,
Fold
Result values from an iterator. Read moresource§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,
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,
Fold
Option values from an iterator. Read moresource§fn fold1<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
Self: Sized,
fn fold1<F>(self, f: F) -> Option<Self::Item>where F: FnMut(Self::Item, Self::Item) -> Self::Item, Self: Sized,
👎Deprecated since 0.10.2: Use
Iterator::reduce insteadAccumulator of the elements in the iterator. Read more
source§fn tree_fold1<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
Self: Sized,
fn tree_fold1<F>(self, f: F) -> Option<Self::Item>where F: FnMut(Self::Item, Self::Item) -> Self::Item, Self: Sized,
Accumulate the elements in the iterator in a tree-like manner. Read more
source§fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B>where
Self: Sized,
F: FnMut(B, Self::Item) -> FoldWhile<B>,
fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B>where Self: Sized, F: FnMut(B, Self::Item) -> FoldWhile<B>,
An iterator method that applies a function, producing a single, final value. Read more
source§fn sum1<S>(self) -> Option<S>where
Self: Sized,
S: Sum<Self::Item>,
fn sum1<S>(self) -> Option<S>where Self: Sized, S: Sum<Self::Item>,
Iterate over the entire iterator and add all the elements. Read more
source§fn product1<P>(self) -> Option<P>where
Self: Sized,
P: Product<Self::Item>,
fn product1<P>(self) -> Option<P>where Self: Sized, P: Product<Self::Item>,
Iterate over the entire iterator and multiply all the elements. Read more
source§fn sorted_unstable(self) -> IntoIter<Self::Item, Global>where
Self: Sized,
Self::Item: Ord,
fn sorted_unstable(self) -> IntoIter<Self::Item, Global>where Self: Sized, Self::Item: Ord,
Sort all iterator elements into a new iterator in ascending order. Read more
source§fn sorted_unstable_by<F>(self, cmp: F) -> IntoIter<Self::Item, Global>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn sorted_unstable_by<F>(self, cmp: F) -> IntoIter<Self::Item, Global>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
Sort all iterator elements into a new iterator in ascending order. Read more
source§fn sorted_unstable_by_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn sorted_unstable_by_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>where Self: Sized, K: Ord, F: FnMut(&Self::Item) -> K,
Sort all iterator elements into a new iterator in ascending order. Read more
source§fn sorted(self) -> IntoIter<Self::Item, Global>where
Self: Sized,
Self::Item: Ord,
fn sorted(self) -> IntoIter<Self::Item, Global>where Self: Sized, Self::Item: Ord,
Sort all iterator elements into a new iterator in ascending order. Read more
source§fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item, Global>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item, Global>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
Sort all iterator elements into a new iterator in ascending order. Read more
source§fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>where Self: Sized, K: Ord, F: FnMut(&Self::Item) -> K,
Sort all iterator elements into a new iterator in ascending order. Read more
source§fn sorted_by_cached_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn sorted_by_cached_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>where Self: Sized, K: Ord, F: FnMut(&Self::Item) -> K,
Sort all iterator elements into a new iterator in ascending order. The key function is
called exactly once per key. Read more
source§fn k_smallest(self, k: usize) -> IntoIter<Self::Item, Global>where
Self: Sized,
Self::Item: Ord,
fn k_smallest(self, k: usize) -> IntoIter<Self::Item, Global>where Self: Sized, Self::Item: Ord,
Sort the k smallest elements into a new iterator, in ascending order. Read more
source§fn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B)where
Self: Sized,
F: FnMut(Self::Item) -> Either<L, R>,
A: Default + Extend<L>,
B: Default + Extend<R>,
fn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B)where Self: Sized, F: FnMut(Self::Item) -> Either<L, R>, A: Default + Extend<L>, B: Default + Extend<R>,
Collect all iterator elements into one of two
partitions. Unlike
Iterator::partition, each partition may
have a distinct type. Read moresource§fn partition_result<A, B, T, E>(self) -> (A, B)where
Self: Iterator<Item = Result<T, E>> + Sized,
A: Default + Extend<T>,
B: Default + Extend<E>,
fn partition_result<A, B, T, E>(self) -> (A, B)where Self: Iterator<Item = Result<T, E>> + Sized, A: Default + Extend<T>, B: Default + Extend<E>,
Partition a sequence of
Results into one list of all the Ok elements
and another list of all the Err elements. Read moresource§fn into_group_map<K, V>(self) -> HashMap<K, Vec<V, Global>, RandomState>where
Self: Iterator<Item = (K, V)> + Sized,
K: Hash + Eq,
fn into_group_map<K, V>(self) -> HashMap<K, Vec<V, Global>, RandomState>where Self: Iterator<Item = (K, V)> + Sized, K: Hash + Eq,
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 moresource§fn into_group_map_by<K, V, F>(
self,
f: F
) -> HashMap<K, Vec<V, Global>, RandomState>where
Self: Iterator<Item = V> + Sized,
K: Hash + Eq,
F: Fn(&V) -> K,
fn into_group_map_by<K, V, F>( self, f: F ) -> HashMap<K, Vec<V, Global>, RandomState>where Self: Iterator<Item = V> + Sized, K: Hash + Eq, F: Fn(&V) -> K,
Return an
Iterator on a HashMap. Keys mapped to Vecs of values. The key is specified
in the closure. Read moresource§fn into_grouping_map<K, V>(self) -> GroupingMap<Self>where
Self: Iterator<Item = (K, V)> + Sized,
K: Hash + Eq,
fn into_grouping_map<K, V>(self) -> GroupingMap<Self>where Self: Iterator<Item = (K, V)> + Sized, K: Hash + Eq,
Constructs a
GroupingMap to be used later with one of the efficient
group-and-fold operations it allows to perform. Read moresource§fn into_grouping_map_by<K, V, F>(
self,
key_mapper: F
) -> GroupingMap<MapForGrouping<Self, F>>where
Self: Iterator<Item = V> + Sized,
K: Hash + Eq,
F: FnMut(&V) -> K,
fn into_grouping_map_by<K, V, F>( self, key_mapper: F ) -> GroupingMap<MapForGrouping<Self, F>>where Self: Iterator<Item = V> + Sized, K: Hash + Eq, F: FnMut(&V) -> K,
Constructs a
GroupingMap to be used later with one of the efficient
group-and-fold operations it allows to perform. Read moresource§fn min_set(self) -> Vec<Self::Item, Global>where
Self: Sized,
Self::Item: Ord,
fn min_set(self) -> Vec<Self::Item, Global>where Self: Sized, Self::Item: Ord,
Return all minimum elements of an iterator. Read more
source§fn min_set_by<F>(self, compare: F) -> Vec<Self::Item, Global>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_set_by<F>(self, compare: F) -> Vec<Self::Item, Global>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
Return all minimum elements of an iterator, as determined by
the specified function. Read more
source§fn min_set_by_key<K, F>(self, key: F) -> Vec<Self::Item, Global>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn min_set_by_key<K, F>(self, key: F) -> Vec<Self::Item, Global>where Self: Sized, K: Ord, F: FnMut(&Self::Item) -> K,
Return all minimum elements of an iterator, as determined by
the specified function. Read more
source§fn max_set(self) -> Vec<Self::Item, Global>where
Self: Sized,
Self::Item: Ord,
fn max_set(self) -> Vec<Self::Item, Global>where Self: Sized, Self::Item: Ord,
Return all maximum elements of an iterator. Read more
source§fn max_set_by<F>(self, compare: F) -> Vec<Self::Item, Global>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn max_set_by<F>(self, compare: F) -> Vec<Self::Item, Global>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
Return all maximum elements of an iterator, as determined by
the specified function. Read more
source§fn max_set_by_key<K, F>(self, key: F) -> Vec<Self::Item, Global>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn max_set_by_key<K, F>(self, key: F) -> Vec<Self::Item, Global>where Self: Sized, K: Ord, F: FnMut(&Self::Item) -> K,
Return all maximum elements of an iterator, as determined by
the specified function. Read more
source§fn minmax(self) -> MinMaxResult<Self::Item>where
Self: Sized,
Self::Item: PartialOrd<Self::Item>,
fn minmax(self) -> MinMaxResult<Self::Item>where Self: Sized, Self::Item: PartialOrd<Self::Item>,
Return the minimum and maximum elements in the iterator. Read more
source§fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item>where
Self: Sized,
K: PartialOrd<K>,
F: FnMut(&Self::Item) -> K,
fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item>where Self: Sized, K: PartialOrd<K>, F: FnMut(&Self::Item) -> K,
Return the minimum and maximum element of an iterator, as determined by
the specified function. Read more
source§fn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
Return the minimum and maximum element of an iterator, as determined by
the specified comparison function. Read more
source§fn position_max(self) -> Option<usize>where
Self: Sized,
Self::Item: Ord,
fn position_max(self) -> Option<usize>where Self: Sized, Self::Item: Ord,
Return the position of the maximum element in the iterator. Read more
source§fn position_max_by_key<K, F>(self, key: F) -> Option<usize>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn position_max_by_key<K, F>(self, key: F) -> Option<usize>where Self: Sized, K: Ord, F: FnMut(&Self::Item) -> K,
Return the position of the maximum element in the iterator, as
determined by the specified function. Read more
source§fn position_max_by<F>(self, compare: F) -> Option<usize>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn position_max_by<F>(self, compare: F) -> Option<usize>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
Return the position of the maximum element in the iterator, as
determined by the specified comparison function. Read more
source§fn position_min(self) -> Option<usize>where
Self: Sized,
Self::Item: Ord,
fn position_min(self) -> Option<usize>where Self: Sized, Self::Item: Ord,
Return the position of the minimum element in the iterator. Read more
source§fn position_min_by_key<K, F>(self, key: F) -> Option<usize>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn position_min_by_key<K, F>(self, key: F) -> Option<usize>where Self: Sized, K: Ord, F: FnMut(&Self::Item) -> K,
Return the position of the minimum element in the iterator, as
determined by the specified function. Read more
source§fn position_min_by<F>(self, compare: F) -> Option<usize>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn position_min_by<F>(self, compare: F) -> Option<usize>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
Return the position of the minimum element in the iterator, as
determined by the specified comparison function. Read more
source§fn position_minmax(self) -> MinMaxResult<usize>where
Self: Sized,
Self::Item: PartialOrd<Self::Item>,
fn position_minmax(self) -> MinMaxResult<usize>where Self: Sized, Self::Item: PartialOrd<Self::Item>,
Return the positions of the minimum and maximum elements in
the iterator. Read more
source§fn position_minmax_by_key<K, F>(self, key: F) -> MinMaxResult<usize>where
Self: Sized,
K: PartialOrd<K>,
F: FnMut(&Self::Item) -> K,
fn position_minmax_by_key<K, F>(self, key: F) -> MinMaxResult<usize>where Self: Sized, K: PartialOrd<K>, F: FnMut(&Self::Item) -> K,
Return the postions of the minimum and maximum elements of an
iterator, as determined by the specified function. Read more
source§fn position_minmax_by<F>(self, compare: F) -> MinMaxResult<usize>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn position_minmax_by<F>(self, compare: F) -> MinMaxResult<usize>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
Return the postions of the minimum and maximum elements of an
iterator, as determined by the specified comparison function. Read more
source§fn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>>where
Self: Sized,
fn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>>where Self: Sized,
If the iterator yields exactly one element, that element will be returned, otherwise
an error will be returned containing an iterator that has the same output as the input
iterator. Read more
source§fn at_most_one(self) -> Result<Option<Self::Item>, ExactlyOneError<Self>>where
Self: Sized,
fn at_most_one(self) -> Result<Option<Self::Item>, ExactlyOneError<Self>>where Self: Sized,
If the iterator yields no elements, Ok(None) will be returned. If the iterator yields
exactly one element, that element will be returned, otherwise an error will be returned
containing an iterator that has the same output as the input iterator. Read more
source§fn multipeek(self) -> MultiPeek<Self>where
Self: Sized,
fn multipeek(self) -> MultiPeek<Self>where Self: Sized,
An iterator adaptor that allows the user to peek at multiple
.next()
values without advancing the base iterator. Read moresource§fn counts(self) -> HashMap<Self::Item, usize, RandomState>where
Self: Sized,
Self::Item: Eq + Hash,
fn counts(self) -> HashMap<Self::Item, usize, RandomState>where Self: Sized, Self::Item: Eq + Hash,
Collect the items in this iterator and return a
HashMap which
contains each item that appears in the iterator and the number
of times it appears. Read moresource§fn counts_by<K, F>(self, f: F) -> HashMap<K, usize, RandomState>where
Self: Sized,
K: Eq + Hash,
F: FnMut(Self::Item) -> K,
fn counts_by<K, F>(self, f: F) -> HashMap<K, usize, RandomState>where Self: Sized, K: Eq + Hash, F: FnMut(Self::Item) -> K,
Collect the items in this iterator and return a
HashMap which
contains each item that appears in the iterator and the number
of times it appears,
determining identity using a keying function. Read moresource§fn multiunzip<FromI>(self) -> FromIwhere
Self: Sized + MultiUnzip<FromI>,
fn multiunzip<FromI>(self) -> FromIwhere Self: Sized + MultiUnzip<FromI>,
Converts an iterator of tuples into a tuple of containers. Read more
source§impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for ITwhere
IT: Iterator<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for ITwhere IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>,
source§fn multiunzip(self) -> (FromA, FromB)
fn multiunzip(self) -> (FromA, FromB)
Unzip this iterator into multiple collections.