Struct SequenceIterator
pub struct SequenceIterator<'a, T, F, E = Error>where
F: ASN1Parser,{ /* private fields */ }
Expand description
An Iterator over binary data, parsing elements of type T
This helps parsing SEQUENCE OF
items of type T
. The type of parser
(BER/DER) is specified using the generic parameter F
of this struct.
Note: the iterator must start on the sequence contents, not the sequence itself.
§Examples
use asn1_rs::{DerParser, Integer, SequenceIterator};
let data = &[0x30, 0x6, 0x2, 0x1, 0x1, 0x2, 0x1, 0x2];
for (idx, item) in SequenceIterator::<Integer, DerParser>::new(&data[2..]).enumerate() {
let item = item.unwrap(); // parsing could have failed
let i = item.as_u32().unwrap(); // integer can be negative, or too large to fit into u32
assert_eq!(i as usize, idx + 1);
}
Implementations§
§impl<'a, T, F, E> SequenceIterator<'a, T, F, E>where
F: ASN1Parser,
impl<'a, T, F, E> SequenceIterator<'a, T, F, E>where
F: ASN1Parser,
pub fn new(data: &'a [u8]) -> SequenceIterator<'a, T, F, E>
Trait Implementations§
Auto Trait Implementations§
impl<'a, T, F, E> Freeze for SequenceIterator<'a, T, F, E>
impl<'a, T, F, E> RefUnwindSafe for SequenceIterator<'a, T, F, E>
impl<'a, T, F, E> Send for SequenceIterator<'a, T, F, E>
impl<'a, T, F, E> Sync for SequenceIterator<'a, T, F, E>
impl<'a, T, F, E> Unpin for SequenceIterator<'a, T, F, E>
impl<'a, T, F, E> UnwindSafe for SequenceIterator<'a, T, F, E>
Blanket Implementations§
§impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,
impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,
§impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,
impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,
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
§impl<'e, I, E> EmitAndCount for I
impl<'e, I, E> EmitAndCount for I
§impl<T> FutureExt for T
impl<T> FutureExt for T
§fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ
fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ
§fn with_current_context(self) -> WithContext<Self> ⓘ
fn with_current_context(self) -> WithContext<Self> ⓘ
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
§fn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
Converts
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
Converts
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moreSource§impl<I> IntoIterator for Iwhere
I: Iterator,
impl<I> IntoIterator for Iwhere
I: Iterator,
§impl<'a, I, M, Request> IteratorMatcherExt<'a, M, Request> for I
impl<'a, I, M, Request> IteratorMatcherExt<'a, M, Request> for I
§fn matches_and(
self,
ext: Option<&mut Extensions>,
ctx: &Context,
request: &Request,
) -> bool
fn matches_and( self, ext: Option<&mut Extensions>, ctx: &Context, request: &Request, ) -> bool
Matches in case all
Matcher
elements match for the given Request
within the specified crate::Context
.§fn matches_or(
self,
ext: Option<&mut Extensions>,
ctx: &Context,
request: &Request,
) -> bool
fn matches_or( self, ext: Option<&mut Extensions>, ctx: &Context, request: &Request, ) -> bool
Matches in case any of the
Matcher
elements match for the given Request
within the specified crate::Context
.Source§impl<I> IteratorRandom for Iwhere
I: Iterator,
impl<I> IteratorRandom for Iwhere
I: Iterator,
Source§fn choose_stable<R>(self, rng: &mut R) -> Option<Self::Item>
fn choose_stable<R>(self, rng: &mut R) -> Option<Self::Item>
Uniformly sample one element (stable) Read more
§impl<T> Itertools for T
impl<T> Itertools for T
§fn interleave<J>(
self,
other: J,
) -> Interleave<Self, <J as IntoIterator>::IntoIter> ⓘ
fn interleave<J>( self, other: J, ) -> Interleave<Self, <J as IntoIterator>::IntoIter> ⓘ
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> ⓘ
fn interleave_shortest<J>( self, other: J, ) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter> ⓘ
Alternate elements from two iterators until at least one of them has run
out. Read more
§fn intersperse(
self,
element: Self::Item,
) -> IntersperseWith<Self, IntersperseElementSimple<Self::Item>> ⓘ
fn intersperse( self, element: Self::Item, ) -> IntersperseWith<Self, IntersperseElementSimple<Self::Item>> ⓘ
An iterator adaptor to insert a particular value
between each element of the adapted iterator. Read more
§fn intersperse_with<F>(self, element: F) -> IntersperseWith<Self, F> ⓘ
fn intersperse_with<F>(self, element: F) -> IntersperseWith<Self, F> ⓘ
An iterator adaptor to insert a particular value created by a function
between each element of the adapted iterator. Read more
§fn get<R>(self, index: R) -> <R as IteratorIndex<Self>>::Outputwhere
Self: Sized,
R: IteratorIndex<Self>,
fn get<R>(self, index: R) -> <R as IteratorIndex<Self>>::Outputwhere
Self: Sized,
R: IteratorIndex<Self>,
Returns an iterator over a subsection of the iterator. Read more
§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
§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
§fn batching<B, F>(self, f: F) -> Batching<Self, F> ⓘ
fn batching<B, F>(self, f: F) -> Batching<Self, F> ⓘ
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 chunk_by<K, F>(self, key: F) -> ChunkBy<K, Self, F>
fn chunk_by<K, F>(self, key: F) -> ChunkBy<K, Self, F>
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 group_by<K, F>(self, key: F) -> ChunkBy<K, Self, F>
fn group_by<K, F>(self, key: F) -> ChunkBy<K, Self, F>
👎Deprecated since 0.13.0: Use .chunk_by() instead
See
.chunk_by()
.§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
§fn tuple_windows<T>(self) -> TupleWindows<Self, T> ⓘ
fn tuple_windows<T>(self) -> TupleWindows<Self, T> ⓘ
Return an iterator over all contiguous windows producing tuples of
a specific size (up to 12). Read more
§fn circular_tuple_windows<T>(self) -> CircularTupleWindows<Self, T> ⓘ
fn circular_tuple_windows<T>(self) -> CircularTupleWindows<Self, T> ⓘ
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
§fn tuples<T>(self) -> Tuples<Self, T> ⓘ
fn tuples<T>(self) -> Tuples<Self, T> ⓘ
Return an iterator that groups the items in tuples of a specific size
(up to 12). Read more
§fn tee(self) -> (Tee<Self>, Tee<Self>)
fn tee(self) -> (Tee<Self>, Tee<Self>)
Split into an iterator pair that both yield all elements from
the original iterator. Read more
§fn map_ok<F, T, U, E>(self, f: F) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>
fn map_ok<F, T, U, E>(self, f: F) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>
Return an iterator adaptor that applies the provided closure
to every
Result::Ok
value. Result::Err
values are
unchanged. Read more§fn filter_ok<F, T, E>(self, f: F) -> FilterOk<Self, F> ⓘ
fn filter_ok<F, T, E>(self, f: F) -> FilterOk<Self, F> ⓘ
Return an iterator adaptor that filters every
Result::Ok
value with the provided closure. Result::Err
values are
unchanged. Read more§fn filter_map_ok<F, T, U, E>(self, f: F) -> FilterMapOk<Self, F> ⓘ
fn filter_map_ok<F, T, U, E>(self, f: F) -> FilterMapOk<Self, F> ⓘ
Return an iterator adaptor that filters and transforms every
Result::Ok
value with the provided closure. Result::Err
values are unchanged. Read more§fn flatten_ok<T, E>(self) -> FlattenOk<Self, T, E> ⓘ
fn flatten_ok<T, E>(self) -> FlattenOk<Self, T, E> ⓘ
Return an iterator adaptor that flattens every
Result::Ok
value into
a series of Result::Ok
values. Result::Err
values are unchanged. Read more§fn process_results<F, T, E, R>(self, processor: F) -> Result<R, E>
fn process_results<F, T, E, R>(self, processor: F) -> Result<R, E>
“Lift” a function of the values of the current iterator so as to process
an iterator of
Result
values instead. Read more§fn merge<J>(
self,
other: J,
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte> ⓘ
fn merge<J>( self, other: J, ) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte> ⓘ
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> ⓘ
fn merge_by<J, F>( self, other: J, is_first: F, ) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F> ⓘ
§fn merge_join_by<J, F, T>(
self,
other: J,
cmp_fn: F,
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeFuncLR<F, <F as FuncLR<Self::Item, <<J as IntoIterator>::IntoIter as Iterator>::Item>>::T>> ⓘ
fn merge_join_by<J, F, T>( self, other: J, cmp_fn: F, ) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeFuncLR<F, <F as FuncLR<Self::Item, <<J as IntoIterator>::IntoIter as Iterator>::Item>>::T>> ⓘ
Create an iterator that merges items from both this and the specified
iterator in ascending order. Read more
§fn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt> ⓘ
fn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt> ⓘ
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
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
§fn cartesian_product<J>(
self,
other: J,
) -> Product<Self, <J as IntoIterator>::IntoIter> ⓘ
fn cartesian_product<J>( self, other: J, ) -> Product<Self, <J as IntoIterator>::IntoIter> ⓘ
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: 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 more§fn coalesce<F>(self, f: F) -> CoalesceBy<Self, F, NoCount>
fn coalesce<F>(self, f: F) -> CoalesceBy<Self, F, NoCount>
Return an iterator adaptor that uses the passed-in closure to
optionally merge together consecutive elements. Read more
§fn dedup(self) -> CoalesceBy<Self, DedupPred2CoalescePred<DedupEq>, NoCount>
fn dedup(self) -> CoalesceBy<Self, DedupPred2CoalescePred<DedupEq>, NoCount>
Remove duplicates from sections of consecutive identical elements.
If the iterator is sorted, all elements will be unique. Read more
§fn dedup_by<Cmp>(
self,
cmp: Cmp,
) -> CoalesceBy<Self, DedupPred2CoalescePred<Cmp>, NoCount>
fn dedup_by<Cmp>( self, cmp: Cmp, ) -> CoalesceBy<Self, DedupPred2CoalescePred<Cmp>, NoCount>
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
§fn dedup_with_count(
self,
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<DedupEq>, WithCount>where
Self: Sized,
fn dedup_with_count(
self,
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<DedupEq>, WithCount>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
§fn dedup_by_with_count<Cmp>(
self,
cmp: Cmp,
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<Cmp>, WithCount>
fn dedup_by_with_count<Cmp>( self, cmp: Cmp, ) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<Cmp>, WithCount>
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
§fn duplicates(self) -> DuplicatesBy<Self, Self::Item, ById>
fn duplicates(self) -> DuplicatesBy<Self, Self::Item, ById>
Return an iterator adaptor that produces elements that appear more than once during the
iteration. Duplicates are detected using hash and equality. Read more
§fn duplicates_by<V, F>(self, f: F) -> DuplicatesBy<Self, V, ByFn<F>>
fn duplicates_by<V, F>(self, f: F) -> DuplicatesBy<Self, V, ByFn<F>>
Return an iterator adaptor that produces elements that appear more than once during the
iteration. Duplicates are detected using hash and equality. Read more
§fn unique(self) -> Unique<Self> ⓘ
fn unique(self) -> Unique<Self> ⓘ
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> ⓘ
fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F> ⓘ
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> ⓘ
fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F> ⓘ
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> ⓘ
fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F> ⓘ
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 take_while_inclusive<F>(self, accept: F) -> TakeWhileInclusive<Self, F> ⓘ
fn take_while_inclusive<F>(self, accept: F) -> TakeWhileInclusive<Self, F> ⓘ
Returns an iterator adaptor that consumes elements while the given
predicate is
true
, including the element for which the predicate
first returned false
. Read more§fn while_some<A>(self) -> WhileSome<Self> ⓘ
fn while_some<A>(self) -> WhileSome<Self> ⓘ
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> ⓘ
fn tuple_combinations<T>(self) -> TupleCombinations<Self, T> ⓘ
Return an iterator adaptor that iterates over the combinations of the
elements from an iterator. Read more
§fn array_combinations<const K: usize>(
self,
) -> CombinationsGeneric<Self, [usize; K]>
fn array_combinations<const K: usize>( self, ) -> CombinationsGeneric<Self, [usize; K]>
Return an iterator adaptor that iterates over the combinations of the
elements from an iterator. Read more
§fn combinations(self, k: usize) -> CombinationsGeneric<Self, Vec<usize>>
fn combinations(self, k: usize) -> CombinationsGeneric<Self, Vec<usize>>
Return an iterator adaptor that iterates over the
k
-length combinations of
the elements from an iterator. Read more§fn combinations_with_replacement(
self,
k: usize,
) -> CombinationsWithReplacement<Self> ⓘ
fn combinations_with_replacement( self, k: usize, ) -> CombinationsWithReplacement<Self> ⓘ
Return an iterator that iterates over the
k
-length combinations of
the elements from an iterator, with replacement. Read more§fn permutations(self, k: usize) -> Permutations<Self> ⓘ
fn permutations(self, k: usize) -> Permutations<Self> ⓘ
Return an iterator adaptor that iterates over all k-permutations of the
elements from an iterator. Read more
§fn powerset(self) -> Powerset<Self> ⓘ
fn powerset(self) -> Powerset<Self> ⓘ
Return an iterator that iterates through the powerset of the elements from an
iterator. Read more
§fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F> ⓘ
fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F> ⓘ
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> ⓘ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 more§fn positions<P>(self, predicate: P) -> Positions<Self, P> ⓘ
fn positions<P>(self, predicate: P) -> Positions<Self, P> ⓘ
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> ⓘ
fn update<F>(self, updater: F) -> Update<Self, F> ⓘ
Return an iterator adaptor that applies a mutating function
to each element before yielding it. Read more
§fn next_array<const N: usize>(&mut self) -> Option<[Self::Item; N]>where
Self: Sized,
fn next_array<const N: usize>(&mut self) -> Option<[Self::Item; N]>where
Self: Sized,
Advances the iterator and returns the next items grouped in an array of
a specific size. Read more
§fn collect_array<const N: usize>(self) -> Option<[Self::Item; N]>where
Self: Sized,
fn collect_array<const N: usize>(self) -> Option<[Self::Item; N]>where
Self: Sized,
Collects all items from the iterator into an array of a specific size. Read more
§fn next_tuple<T>(&mut self) -> Option<T>
fn next_tuple<T>(&mut self) -> Option<T>
Advances the iterator and returns the next items grouped in a tuple of
a specific size (up to 12). Read more
§fn collect_tuple<T>(self) -> Option<T>
fn collect_tuple<T>(self) -> Option<T>
Collects all items from the iterator into a tuple of a specific size
(up to 12). Read more
§fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)>
fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)>
Find the position and value of the first element satisfying a predicate. Read more
§fn find_or_last<P>(self, predicate: P) -> Option<Self::Item>
fn find_or_last<P>(self, predicate: P) -> Option<Self::Item>
Find the value of the first element satisfying a predicate or return the last element, if any. Read more
§fn find_or_first<P>(self, predicate: P) -> Option<Self::Item>
fn find_or_first<P>(self, predicate: P) -> Option<Self::Item>
Find the value of the first element satisfying a predicate or return the first element, if any. Read more
§fn contains<Q>(&mut self, query: &Q) -> bool
fn contains<Q>(&mut self, query: &Q) -> bool
Returns
true
if the given item is present in this iterator. Read more§fn all_equal_value(
&mut self,
) -> Result<Self::Item, Option<(Self::Item, Self::Item)>>
fn all_equal_value( &mut self, ) -> Result<Self::Item, Option<(Self::Item, 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
§fn all_unique(&mut self) -> bool
fn all_unique(&mut self) -> bool
Check whether all elements are unique (non equal). Read more
§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 more§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 more§fn collect_vec(self) -> Vec<Self::Item>where
Self: Sized,
fn collect_vec(self) -> Vec<Self::Item>where
Self: Sized,
.collect_vec()
is simply a type specialization of Iterator::collect
,
for convenience.§fn try_collect<T, U, E>(self) -> Result<U, E>
fn try_collect<T, U, E>(self) -> Result<U, E>
§fn set_from<'a, A, J>(&mut self, from: J) -> usize
fn set_from<'a, A, J>(&mut self, from: J) -> usize
Assign to each reference in
self
from the from
iterator,
stopping at the shortest of the two iterators. Read more§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 more§fn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F>
fn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F>
Format all iterator elements, separated by
sep
. Read more§fn fold_ok<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>
fn fold_ok<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>
Fold
Result
values from an iterator. Read more§fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option<B>
fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option<B>
Fold
Option
values from an iterator. Read more§fn fold1<F>(self, f: F) -> Option<Self::Item>
fn fold1<F>(self, f: F) -> Option<Self::Item>
👎Deprecated since 0.10.2: Use
Iterator::reduce
insteadAccumulator of the elements in the iterator. Read more
§fn tree_reduce<F>(self, f: F) -> Option<Self::Item>
fn tree_reduce<F>(self, f: F) -> Option<Self::Item>
Accumulate the elements in the iterator in a tree-like manner. Read more
§fn tree_fold1<F>(self, f: F) -> Option<Self::Item>
fn tree_fold1<F>(self, f: F) -> Option<Self::Item>
👎Deprecated since 0.13.0: Use .tree_reduce() instead
See
.tree_reduce()
.§fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B>
fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B>
An iterator method that applies a function, producing a single, final value. Read more
§fn product1<P>(self) -> Option<P>
fn product1<P>(self) -> Option<P>
Iterate over the entire iterator and multiply all the elements. Read more
§fn sorted_unstable(self) -> IntoIter<Self::Item> ⓘ
fn sorted_unstable(self) -> IntoIter<Self::Item> ⓘ
Sort all iterator elements into a new iterator in ascending order. Read more
§fn sorted_unstable_by<F>(self, cmp: F) -> IntoIter<Self::Item> ⓘ
fn sorted_unstable_by<F>(self, cmp: F) -> IntoIter<Self::Item> ⓘ
Sort all iterator elements into a new iterator in ascending order. Read more
§fn sorted_unstable_by_key<K, F>(self, f: F) -> IntoIter<Self::Item> ⓘ
fn sorted_unstable_by_key<K, F>(self, f: F) -> IntoIter<Self::Item> ⓘ
Sort all iterator elements into a new iterator in ascending order. Read more
§fn sorted(self) -> IntoIter<Self::Item> ⓘ
fn sorted(self) -> IntoIter<Self::Item> ⓘ
Sort all iterator elements into a new iterator in ascending order. Read more
§fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item> ⓘ
fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item> ⓘ
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> ⓘ
fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item> ⓘ
Sort all iterator elements into a new iterator in ascending order. Read more
§fn sorted_by_cached_key<K, F>(self, f: F) -> IntoIter<Self::Item> ⓘ
fn sorted_by_cached_key<K, F>(self, f: F) -> IntoIter<Self::Item> ⓘ
Sort all iterator elements into a new iterator in ascending order. The key function is
called exactly once per key. Read more
§fn k_smallest(self, k: usize) -> IntoIter<Self::Item> ⓘ
fn k_smallest(self, k: usize) -> IntoIter<Self::Item> ⓘ
Sort the k smallest elements into a new iterator, in ascending order. Read more
§fn k_smallest_by<F>(self, k: usize, cmp: F) -> IntoIter<Self::Item> ⓘ
fn k_smallest_by<F>(self, k: usize, cmp: F) -> IntoIter<Self::Item> ⓘ
Sort the k smallest elements into a new iterator using the provided comparison. Read more
§fn k_smallest_by_key<F, K>(self, k: usize, key: F) -> IntoIter<Self::Item> ⓘ
fn k_smallest_by_key<F, K>(self, k: usize, key: F) -> IntoIter<Self::Item> ⓘ
Return the elements producing the k smallest outputs of the provided function. Read more
§fn k_smallest_relaxed(self, k: usize) -> IntoIter<Self::Item> ⓘ
fn k_smallest_relaxed(self, k: usize) -> IntoIter<Self::Item> ⓘ
Sort the k smallest elements into a new iterator, in ascending order, relaxing the amount of memory required. Read more
§fn k_smallest_relaxed_by<F>(self, k: usize, cmp: F) -> IntoIter<Self::Item> ⓘ
fn k_smallest_relaxed_by<F>(self, k: usize, cmp: F) -> IntoIter<Self::Item> ⓘ
Sort the k smallest elements into a new iterator using the provided comparison, relaxing the amount of memory required. Read more
§fn k_smallest_relaxed_by_key<F, K>(
self,
k: usize,
key: F,
) -> IntoIter<Self::Item> ⓘ
fn k_smallest_relaxed_by_key<F, K>( self, k: usize, key: F, ) -> IntoIter<Self::Item> ⓘ
Return the elements producing the k smallest outputs of the provided function, relaxing the amount of memory required. Read more
§fn k_largest(self, k: usize) -> IntoIter<Self::Item> ⓘ
fn k_largest(self, k: usize) -> IntoIter<Self::Item> ⓘ
Sort the k largest elements into a new iterator, in descending order. Read more
§fn k_largest_by<F>(self, k: usize, cmp: F) -> IntoIter<Self::Item> ⓘ
fn k_largest_by<F>(self, k: usize, cmp: F) -> IntoIter<Self::Item> ⓘ
Sort the k largest elements into a new iterator using the provided comparison. Read more
§fn k_largest_by_key<F, K>(self, k: usize, key: F) -> IntoIter<Self::Item> ⓘ
fn k_largest_by_key<F, K>(self, k: usize, key: F) -> IntoIter<Self::Item> ⓘ
Return the elements producing the k largest outputs of the provided function. Read more
§fn k_largest_relaxed(self, k: usize) -> IntoIter<Self::Item> ⓘ
fn k_largest_relaxed(self, k: usize) -> IntoIter<Self::Item> ⓘ
Sort the k largest elements into a new iterator, in descending order, relaxing the amount of memory required. Read more
§fn k_largest_relaxed_by<F>(self, k: usize, cmp: F) -> IntoIter<Self::Item> ⓘ
fn k_largest_relaxed_by<F>(self, k: usize, cmp: F) -> IntoIter<Self::Item> ⓘ
Sort the k largest elements into a new iterator using the provided comparison, relaxing the amount of memory required. Read more
§fn k_largest_relaxed_by_key<F, K>(
self,
k: usize,
key: F,
) -> IntoIter<Self::Item> ⓘ
fn k_largest_relaxed_by_key<F, K>( self, k: usize, key: F, ) -> IntoIter<Self::Item> ⓘ
Return the elements producing the k largest outputs of the provided function, relaxing the amount of memory required. Read more
§fn tail(self, n: usize) -> IntoIter<Self::Item> ⓘwhere
Self: Sized,
fn tail(self, n: usize) -> IntoIter<Self::Item> ⓘwhere
Self: Sized,
Consumes the iterator and return an iterator of the last
n
elements. Read more§fn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B)
fn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B)
Collect all iterator elements into one of two
partitions. Unlike
Iterator::partition
, each partition may
have a distinct type. Read more§fn partition_result<A, B, T, E>(self) -> (A, B)
fn partition_result<A, B, T, E>(self) -> (A, B)
Partition a sequence of
Result
s into one list of all the Ok
elements
and another list of all the Err
elements. Read more§fn into_group_map<K, V>(self) -> HashMap<K, Vec<V>>
fn into_group_map<K, V>(self) -> HashMap<K, Vec<V>>
Return a
HashMap
of keys mapped to Vec
s of values. Keys and values
are taken from (Key, Value)
tuple pairs yielded by the input iterator. Read more§fn into_group_map_by<K, V, F>(self, f: F) -> HashMap<K, Vec<V>>
fn into_group_map_by<K, V, F>(self, f: F) -> HashMap<K, Vec<V>>
Return a
HashMap
of keys mapped to Vec
s of values. The key is specified
in the closure. The values are taken from the input iterator. Read more§fn into_grouping_map<K, V>(self) -> GroupingMap<Self>
fn into_grouping_map<K, V>(self) -> GroupingMap<Self>
Constructs a
GroupingMap
to be used later with one of the efficient
group-and-fold operations it allows to perform. Read more§fn into_grouping_map_by<K, V, F>(
self,
key_mapper: F,
) -> GroupingMap<MapSpecialCase<Self, GroupingMapFn<F>>>
fn into_grouping_map_by<K, V, F>( self, key_mapper: F, ) -> GroupingMap<MapSpecialCase<Self, GroupingMapFn<F>>>
Constructs a
GroupingMap
to be used later with one of the efficient
group-and-fold operations it allows to perform. Read more§fn min_set_by<F>(self, compare: F) -> Vec<Self::Item>
fn min_set_by<F>(self, compare: F) -> Vec<Self::Item>
Return all minimum elements of an iterator, as determined by
the specified function. Read more
§fn min_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>
fn min_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>
Return all minimum elements of an iterator, as determined by
the specified function. Read more
§fn max_set_by<F>(self, compare: F) -> Vec<Self::Item>
fn max_set_by<F>(self, compare: F) -> Vec<Self::Item>
Return all maximum elements of an iterator, as determined by
the specified function. Read more
§fn max_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>
fn max_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>
Return all maximum elements of an iterator, as determined by
the specified function. Read more
§fn minmax(self) -> MinMaxResult<Self::Item>
fn minmax(self) -> MinMaxResult<Self::Item>
Return the minimum and maximum elements in the iterator. Read more
§fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item>
fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item>
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>
fn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item>
Return the minimum and maximum element of an iterator, as determined by
the specified comparison function. Read more
§fn position_max(self) -> Option<usize>
fn position_max(self) -> Option<usize>
Return the position of the maximum element in the iterator. Read more
§fn position_max_by_key<K, F>(self, key: F) -> Option<usize>
fn position_max_by_key<K, F>(self, key: F) -> Option<usize>
Return the position of the maximum element in the iterator, as
determined by the specified function. Read more
§fn position_max_by<F>(self, compare: F) -> Option<usize>
fn position_max_by<F>(self, compare: F) -> Option<usize>
Return the position of the maximum element in the iterator, as
determined by the specified comparison function. Read more
§fn position_min(self) -> Option<usize>
fn position_min(self) -> Option<usize>
Return the position of the minimum element in the iterator. Read more
§fn position_min_by_key<K, F>(self, key: F) -> Option<usize>
fn position_min_by_key<K, F>(self, key: F) -> Option<usize>
Return the position of the minimum element in the iterator, as
determined by the specified function. Read more
§fn position_min_by<F>(self, compare: F) -> Option<usize>
fn position_min_by<F>(self, compare: F) -> Option<usize>
Return the position of the minimum element in the iterator, as
determined by the specified comparison function. Read more
§fn position_minmax(self) -> MinMaxResult<usize>
fn position_minmax(self) -> MinMaxResult<usize>
Return the positions of the minimum and maximum elements in
the iterator. Read more
§fn position_minmax_by_key<K, F>(self, key: F) -> MinMaxResult<usize>
fn position_minmax_by_key<K, F>(self, key: F) -> MinMaxResult<usize>
Return the postions of the minimum and maximum elements of an
iterator, as determined by the specified function. Read more
§fn position_minmax_by<F>(self, compare: F) -> MinMaxResult<usize>
fn position_minmax_by<F>(self, compare: F) -> MinMaxResult<usize>
Return the postions of the minimum and maximum elements of an
iterator, as determined by the specified comparison function. Read more
§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
§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§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 more§fn counts(self) -> HashMap<Self::Item, usize>
fn counts(self) -> HashMap<Self::Item, usize>
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 more§fn counts_by<K, F>(self, f: F) -> HashMap<K, usize>
fn counts_by<K, F>(self, f: F) -> HashMap<K, usize>
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 more§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
§impl<IT> MultiUnzip<()> for IT
impl<IT> MultiUnzip<()> for IT
§fn multiunzip(self)
fn multiunzip(self)
Unzip this iterator into multiple collections.
§impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
§fn multiunzip(self) -> (FromA,)
fn multiunzip(self) -> (FromA,)
Unzip this iterator into multiple collections.
§impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IT
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IT
§fn multiunzip(self) -> (FromA, FromB)
fn multiunzip(self) -> (FromA, FromB)
Unzip this iterator into multiple collections.
§impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
§fn multiunzip(self) -> (FromA, FromB, FromC)
fn multiunzip(self) -> (FromA, FromB, FromC)
Unzip this iterator into multiple collections.
§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
§fn multiunzip(self) -> (FromA, FromB, FromC, FromD)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD)
Unzip this iterator into multiple collections.
§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
§fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)
Unzip this iterator into multiple collections.
§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
§fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)
Unzip this iterator into multiple collections.
§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
§fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)
Unzip this iterator into multiple collections.
§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
§fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)
Unzip this iterator into multiple collections.
§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
§fn multiunzip(
self,
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)
fn multiunzip( self, ) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)
Unzip this iterator into multiple collections.
§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
§fn multiunzip(
self,
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)
fn multiunzip( self, ) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)
Unzip this iterator into multiple collections.
§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
FromK: Default + Extend<K>,
§fn multiunzip(
self,
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)
fn multiunzip( self, ) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)
Unzip this iterator into multiple collections.
§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
FromK: Default + Extend<K>,
FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
FromK: Default + Extend<K>,
FromL: Default + Extend<L>,
§fn multiunzip(
self,
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)
fn multiunzip( self, ) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)
Unzip this iterator into multiple collections.
§impl<T> Pointable for T
impl<T> Pointable for T
§impl<T> PolicyExt for Twhere
T: ?Sized,
impl<T> PolicyExt for Twhere
T: ?Sized,
§fn and<P, B, E>(self, other: P) -> And<T, P>
fn and<P, B, E>(self, other: P) -> And<T, P>
Create a new
Policy
that returns Action::Follow
only if self
and other
return
Action::Follow
. Read more§impl<T, U> RamaTryInto<U> for Twhere
U: RamaTryFrom<T>,
impl<T, U> RamaTryInto<U> for Twhere
U: RamaTryFrom<T>,
type Error = <U as RamaTryFrom<T>>::Error
fn rama_try_into(self) -> Result<U, <U as RamaTryFrom<T>>::Error>
§impl<T, U> RamaTryInto<U> for Twhere
U: RamaTryFrom<T>,
impl<T, U> RamaTryInto<U> for Twhere
U: RamaTryFrom<T>,
type Error = <U as RamaTryFrom<T>>::Error
fn rama_try_into(self) -> Result<U, <U as RamaTryFrom<T>>::Error>
§impl<I> UnicodeNormalization<I> for I
impl<I> UnicodeNormalization<I> for I
§fn nfd(self) -> Decompositions<I> ⓘ
fn nfd(self) -> Decompositions<I> ⓘ
Returns an iterator over the string in Unicode Normalization Form D
(canonical decomposition).
§fn nfkd(self) -> Decompositions<I> ⓘ
fn nfkd(self) -> Decompositions<I> ⓘ
Returns an iterator over the string in Unicode Normalization Form KD
(compatibility decomposition).
§fn nfc(self) -> Recompositions<I> ⓘ
fn nfc(self) -> Recompositions<I> ⓘ
An Iterator over the string in Unicode Normalization Form C
(canonical decomposition followed by canonical composition).
§fn nfkc(self) -> Recompositions<I> ⓘ
fn nfkc(self) -> Recompositions<I> ⓘ
An Iterator over the string in Unicode Normalization Form KC
(compatibility decomposition followed by canonical composition).
§fn cjk_compat_variants(self) -> Replacements<I> ⓘ
fn cjk_compat_variants(self) -> Replacements<I> ⓘ
A transformation which replaces CJK Compatibility Ideograph codepoints
with normal forms using Standardized Variation Sequences. This is not
part of the canonical or compatibility decomposition algorithms, but
performing it before those algorithms produces normalized output which
better preserves the intent of the original text. Read more
§fn stream_safe(self) -> StreamSafe<I> ⓘ
fn stream_safe(self) -> StreamSafe<I> ⓘ
An Iterator over the string with Conjoining Grapheme Joiner characters
inserted according to the Stream-Safe Text Process (UAX15-D4)