Struct pallet_housing_fund::storage::PrefixIterator  
pub struct PrefixIterator<T, OnRemoval = ()> { /* private fields */ }Expand description
Iterate or drain over a prefix and decode raw_key and raw_value into T.
If any decoding fails it skips it and continues to the next key.
If draining, then the hook OnRemoval::on_removal is called after each removal.
Implementations§
§impl<T, OnRemoval1> PrefixIterator<T, OnRemoval1>
 
impl<T, OnRemoval1> PrefixIterator<T, OnRemoval1>
pub fn convert_on_removal<OnRemoval2>(self) -> PrefixIterator<T, OnRemoval2> ⓘ
pub fn convert_on_removal<OnRemoval2>(self) -> PrefixIterator<T, OnRemoval2> ⓘ
Converts to the same iterator but with the different ‘OnRemoval’ type
§impl<T, OnRemoval> PrefixIterator<T, OnRemoval>
 
impl<T, OnRemoval> PrefixIterator<T, OnRemoval>
pub fn new(
    prefix: Vec<u8, Global>,
    previous_key: Vec<u8, Global>,
    decode_fn: fn(_: &[u8], _: &[u8]) -> Result<T, Error>
) -> PrefixIterator<T, OnRemoval> ⓘ
pub fn new(
    prefix: Vec<u8, Global>,
    previous_key: Vec<u8, Global>,
    decode_fn: fn(_: &[u8], _: &[u8]) -> Result<T, Error>
) -> PrefixIterator<T, OnRemoval> ⓘ
Creates a new PrefixIterator, iterating after previous_key and filtering out keys that
are not prefixed with prefix.
A decode_fn function must also be supplied, and it takes in two &[u8] parameters,
returning a Result containing the decoded type T if successful, and a codec::Error on
failure. The first &[u8] argument represents the raw, undecoded key without the prefix of
the current item, while the second &[u8] argument denotes the corresponding raw,
undecoded value.
pub fn last_raw_key(&self) -> &[u8] ⓘ
pub fn last_raw_key(&self) -> &[u8] ⓘ
Get the last key that has been iterated upon and return it.
pub fn prefix(&self) -> &[u8] ⓘ
pub fn prefix(&self) -> &[u8] ⓘ
Get the prefix that is being iterated upon for this iterator and return it.
pub fn set_last_raw_key(&mut self, previous_key: Vec<u8, Global>)
pub fn set_last_raw_key(&mut self, previous_key: Vec<u8, Global>)
Set the key that the iterator should start iterating after.
pub fn drain(self) -> PrefixIterator<T, OnRemoval> ⓘ
pub fn drain(self) -> PrefixIterator<T, OnRemoval> ⓘ
Mutate this iterator into a draining iterator; items iterated are removed from storage.
Trait Implementations§
§impl<T, OnRemoval> Iterator for PrefixIterator<T, OnRemoval>where
    OnRemoval: PrefixIteratorOnRemoval,
 
impl<T, OnRemoval> Iterator for PrefixIterator<T, OnRemoval>where
    OnRemoval: PrefixIteratorOnRemoval,
§fn next(&mut self) -> Option<<PrefixIterator<T, OnRemoval> as Iterator>::Item>
 
fn next(&mut self) -> Option<<PrefixIterator<T, OnRemoval> as Iterator>::Item>
source§fn next_chunk<const N: usize>(
    &mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
    Self: Sized,
 
fn next_chunk<const N: usize>(
    &mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
    Self: Sized,
iter_next_chunk)N values. Read more1.0.0 · source§fn size_hint(&self) -> (usize, Option<usize>)
 
fn size_hint(&self) -> (usize, Option<usize>)
1.0.0 · source§fn count(self) -> usizewhere
    Self: Sized,
 
fn count(self) -> usizewhere
    Self: Sized,
1.0.0 · source§fn last(self) -> Option<Self::Item>where
    Self: Sized,
 
fn last(self) -> Option<Self::Item>where
    Self: Sized,
source§fn advance_by(&mut self, n: usize) -> Result<(), usize>
 
fn advance_by(&mut self, n: usize) -> Result<(), usize>
iter_advance_by)n elements. Read more1.0.0 · source§fn nth(&mut self, n: usize) -> Option<Self::Item>
 
fn nth(&mut self, n: usize) -> Option<Self::Item>
nth element of the iterator. Read more1.28.0 · source§fn step_by(self, step: usize) -> StepBy<Self>where
    Self: Sized,
 
fn step_by(self, step: usize) -> StepBy<Self>where
    Self: Sized,
1.0.0 · source§fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where
    Self: Sized,
    U: IntoIterator<Item = Self::Item>,
 
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where
    Self: Sized,
    U: IntoIterator<Item = Self::Item>,
1.0.0 · source§fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
    Self: Sized,
    U: IntoIterator,
 
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
    Self: Sized,
    U: IntoIterator,
source§fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where
    Self: Sized,
    G: FnMut() -> Self::Item,
 
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where
    Self: Sized,
    G: FnMut() -> Self::Item,
iter_intersperse)separator
between adjacent items of the original iterator. Read more1.0.0 · source§fn map<B, F>(self, f: F) -> Map<Self, F>where
    Self: Sized,
    F: FnMut(Self::Item) -> B,
 
fn map<B, F>(self, f: F) -> Map<Self, F>where
    Self: Sized,
    F: FnMut(Self::Item) -> B,
1.21.0 · source§fn for_each<F>(self, f: F)where
    Self: Sized,
    F: FnMut(Self::Item),
 
fn for_each<F>(self, f: F)where
    Self: Sized,
    F: FnMut(Self::Item),
1.0.0 · source§fn filter<P>(self, predicate: P) -> Filter<Self, P>where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool,
 
fn filter<P>(self, predicate: P) -> Filter<Self, P>where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool,
1.0.0 · source§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where
    Self: Sized,
    F: FnMut(Self::Item) -> Option<B>,
 
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where
    Self: Sized,
    F: FnMut(Self::Item) -> Option<B>,
1.0.0 · source§fn enumerate(self) -> Enumerate<Self>where
    Self: Sized,
 
fn enumerate(self) -> Enumerate<Self>where
    Self: Sized,
1.0.0 · source§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool,
 
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool,
1.0.0 · source§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool,
 
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool,
1.57.0 · source§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where
    Self: Sized,
    P: FnMut(Self::Item) -> Option<B>,
 
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where
    Self: Sized,
    P: FnMut(Self::Item) -> Option<B>,
1.0.0 · source§fn skip(self, n: usize) -> Skip<Self>where
    Self: Sized,
 
fn skip(self, n: usize) -> Skip<Self>where
    Self: Sized,
n elements. Read more1.0.0 · source§fn take(self, n: usize) -> Take<Self>where
    Self: Sized,
 
fn take(self, n: usize) -> Take<Self>where
    Self: Sized,
n elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0 · source§fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where
    Self: Sized,
    F: FnMut(&mut St, Self::Item) -> Option<B>,
 
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where
    Self: Sized,
    F: FnMut(&mut St, Self::Item) -> Option<B>,
1.0.0 · source§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
    Self: Sized,
    U: IntoIterator,
    F: FnMut(Self::Item) -> U,
 
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
    Self: Sized,
    U: IntoIterator,
    F: FnMut(Self::Item) -> U,
1.0.0 · source§fn inspect<F>(self, f: F) -> Inspect<Self, F>where
    Self: Sized,
    F: FnMut(&Self::Item),
 
fn inspect<F>(self, f: F) -> Inspect<Self, F>where
    Self: Sized,
    F: FnMut(&Self::Item),
1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
    Self: Sized,
 
fn by_ref(&mut self) -> &mut Selfwhere
    Self: Sized,
1.0.0 · source§fn collect<B>(self) -> Bwhere
    B: FromIterator<Self::Item>,
    Self: Sized,
 
fn collect<B>(self) -> Bwhere
    B: FromIterator<Self::Item>,
    Self: Sized,
source§fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere
    E: Extend<Self::Item>,
    Self: Sized,
 
fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere
    E: Extend<Self::Item>,
    Self: Sized,
iter_collect_into)1.0.0 · source§fn partition<B, F>(self, f: F) -> (B, B)where
    Self: Sized,
    B: Default + Extend<Self::Item>,
    F: FnMut(&Self::Item) -> bool,
 
fn partition<B, F>(self, f: F) -> (B, B)where
    Self: Sized,
    B: Default + Extend<Self::Item>,
    F: FnMut(&Self::Item) -> bool,
source§fn is_partitioned<P>(self, predicate: P) -> boolwhere
    Self: Sized,
    P: FnMut(Self::Item) -> bool,
 
fn is_partitioned<P>(self, predicate: P) -> boolwhere
    Self: Sized,
    P: FnMut(Self::Item) -> bool,
iter_is_partitioned)true precede all those that return false. Read more1.27.0 · source§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
    Self: Sized,
    F: FnMut(B, Self::Item) -> R,
    R: Try<Output = B>,
 
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
    Self: Sized,
    F: FnMut(B, Self::Item) -> R,
    R: Try<Output = B>,
1.27.0 · source§fn try_for_each<F, R>(&mut self, f: F) -> Rwhere
    Self: Sized,
    F: FnMut(Self::Item) -> R,
    R: Try<Output = ()>,
 
fn try_for_each<F, R>(&mut self, f: F) -> Rwhere
    Self: Sized,
    F: FnMut(Self::Item) -> R,
    R: Try<Output = ()>,
1.0.0 · source§fn fold<B, F>(self, init: B, f: F) -> Bwhere
    Self: Sized,
    F: FnMut(B, Self::Item) -> B,
 
fn fold<B, F>(self, init: B, f: F) -> Bwhere
    Self: Sized,
    F: FnMut(B, Self::Item) -> B,
1.51.0 · source§fn reduce<F>(self, f: F) -> Option<Self::Item>where
    Self: Sized,
    F: FnMut(Self::Item, Self::Item) -> Self::Item,
 
fn reduce<F>(self, f: F) -> Option<Self::Item>where
    Self: Sized,
    F: FnMut(Self::Item, Self::Item) -> Self::Item,
source§fn try_reduce<F, R>(
    &mut self,
    f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere
    Self: Sized,
    F: FnMut(Self::Item, Self::Item) -> R,
    R: Try<Output = Self::Item>,
    <R as Try>::Residual: Residual<Option<Self::Item>>,
 
fn try_reduce<F, R>(
    &mut self,
    f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere
    Self: Sized,
    F: FnMut(Self::Item, Self::Item) -> R,
    R: Try<Output = Self::Item>,
    <R as Try>::Residual: Residual<Option<Self::Item>>,
iterator_try_reduce)1.0.0 · source§fn all<F>(&mut self, f: F) -> boolwhere
    Self: Sized,
    F: FnMut(Self::Item) -> bool,
 
fn all<F>(&mut self, f: F) -> boolwhere
    Self: Sized,
    F: FnMut(Self::Item) -> bool,
1.0.0 · source§fn any<F>(&mut self, f: F) -> boolwhere
    Self: Sized,
    F: FnMut(Self::Item) -> bool,
 
fn any<F>(&mut self, f: F) -> boolwhere
    Self: Sized,
    F: FnMut(Self::Item) -> bool,
1.0.0 · source§fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool,
 
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool,
1.30.0 · source§fn find_map<B, F>(&mut self, f: F) -> Option<B>where
    Self: Sized,
    F: FnMut(Self::Item) -> Option<B>,
 
fn find_map<B, F>(&mut self, f: F) -> Option<B>where
    Self: Sized,
    F: FnMut(Self::Item) -> Option<B>,
source§fn try_find<F, R>(
    &mut self,
    f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere
    Self: Sized,
    F: FnMut(&Self::Item) -> R,
    R: Try<Output = bool>,
    <R as Try>::Residual: Residual<Option<Self::Item>>,
 
fn try_find<F, R>(
    &mut self,
    f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere
    Self: Sized,
    F: FnMut(&Self::Item) -> R,
    R: Try<Output = bool>,
    <R as Try>::Residual: Residual<Option<Self::Item>>,
try_find)1.0.0 · source§fn position<P>(&mut self, predicate: P) -> Option<usize>where
    Self: Sized,
    P: FnMut(Self::Item) -> bool,
 
fn position<P>(&mut self, predicate: P) -> Option<usize>where
    Self: Sized,
    P: FnMut(Self::Item) -> bool,
1.6.0 · source§fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where
    B: Ord,
    Self: Sized,
    F: FnMut(&Self::Item) -> B,
 
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where
    B: Ord,
    Self: Sized,
    F: FnMut(&Self::Item) -> B,
1.15.0 · source§fn max_by<F>(self, compare: F) -> Option<Self::Item>where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
 
fn max_by<F>(self, compare: F) -> Option<Self::Item>where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.6.0 · source§fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where
    B: Ord,
    Self: Sized,
    F: FnMut(&Self::Item) -> B,
 
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where
    B: Ord,
    Self: Sized,
    F: FnMut(&Self::Item) -> B,
1.15.0 · source§fn min_by<F>(self, compare: F) -> Option<Self::Item>where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
 
fn min_by<F>(self, compare: F) -> Option<Self::Item>where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.0.0 · source§fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    Self: Sized + Iterator<Item = (A, B)>,
 
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    Self: Sized + Iterator<Item = (A, B)>,
1.36.0 · source§fn copied<'a, T>(self) -> Copied<Self>where
    T: 'a + Copy,
    Self: Sized + Iterator<Item = &'a T>,
 
fn copied<'a, T>(self) -> Copied<Self>where
    T: 'a + Copy,
    Self: Sized + Iterator<Item = &'a T>,
1.0.0 · source§fn cloned<'a, T>(self) -> Cloned<Self>where
    T: 'a + Clone,
    Self: Sized + Iterator<Item = &'a T>,
 
fn cloned<'a, T>(self) -> Cloned<Self>where
    T: 'a + Clone,
    Self: Sized + Iterator<Item = &'a T>,
source§fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
    Self: Sized,
 
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
    Self: Sized,
iter_array_chunks)N elements of the iterator at a time. Read more1.11.0 · source§fn sum<S>(self) -> Swhere
    Self: Sized,
    S: Sum<Self::Item>,
 
fn sum<S>(self) -> Swhere
    Self: Sized,
    S: Sum<Self::Item>,
1.11.0 · source§fn product<P>(self) -> Pwhere
    Self: Sized,
    P: Product<Self::Item>,
 
fn product<P>(self) -> Pwhere
    Self: Sized,
    P: Product<Self::Item>,
source§fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
 
fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
iter_order_by)Iterator with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
    Self: Sized,
 
fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
    Self: Sized,
source§fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
 
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
iter_order_by)Iterator with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn eq<I>(self, other: I) -> boolwhere
    I: IntoIterator,
    Self::Item: PartialEq<<I as IntoIterator>::Item>,
    Self: Sized,
 
fn eq<I>(self, other: I) -> boolwhere
    I: IntoIterator,
    Self::Item: PartialEq<<I as IntoIterator>::Item>,
    Self: Sized,
source§fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
 
fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
iter_order_by)1.5.0 · source§fn ne<I>(self, other: I) -> boolwhere
    I: IntoIterator,
    Self::Item: PartialEq<<I as IntoIterator>::Item>,
    Self: Sized,
 
fn ne<I>(self, other: I) -> boolwhere
    I: IntoIterator,
    Self::Item: PartialEq<<I as IntoIterator>::Item>,
    Self: Sized,
1.5.0 · source§fn lt<I>(self, other: I) -> boolwhere
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
    Self: Sized,
 
fn lt<I>(self, other: I) -> boolwhere
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
    Self: Sized,
Iterator are lexicographically
less than those of another. Read more1.5.0 · source§fn le<I>(self, other: I) -> boolwhere
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
    Self: Sized,
 
fn le<I>(self, other: I) -> boolwhere
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
    Self: Sized,
Iterator are lexicographically
less or equal to those of another. Read more1.5.0 · source§fn gt<I>(self, other: I) -> boolwhere
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
    Self: Sized,
 
fn gt<I>(self, other: I) -> boolwhere
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
    Self: Sized,
Iterator are lexicographically
greater than those of another. Read more1.5.0 · source§fn ge<I>(self, other: I) -> boolwhere
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
    Self: Sized,
 
fn ge<I>(self, other: I) -> boolwhere
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
    Self: Sized,
Iterator are lexicographically
greater than or equal to those of another. Read moresource§fn is_sorted_by<F>(self, compare: F) -> boolwhere
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
 
fn is_sorted_by<F>(self, compare: F) -> boolwhere
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
is_sorted)source§fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
    Self: Sized,
    F: FnMut(Self::Item) -> K,
    K: PartialOrd<K>,
 
fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
    Self: Sized,
    F: FnMut(Self::Item) -> K,
    K: PartialOrd<K>,
is_sorted)Auto Trait Implementations§
impl<T, OnRemoval> RefUnwindSafe for PrefixIterator<T, OnRemoval>where
    OnRemoval: RefUnwindSafe,
impl<T, OnRemoval> Send for PrefixIterator<T, OnRemoval>where
    OnRemoval: Send,
impl<T, OnRemoval> Sync for PrefixIterator<T, OnRemoval>where
    OnRemoval: Sync,
impl<T, OnRemoval> Unpin for PrefixIterator<T, OnRemoval>where
    OnRemoval: Unpin,
impl<T, OnRemoval> UnwindSafe for PrefixIterator<T, OnRemoval>where
    OnRemoval: UnwindSafe,
Blanket Implementations§
§impl<T> CheckedConversion for T
 
impl<T> CheckedConversion for T
§fn checked_from<T>(t: T) -> Option<Self>where
    Self: TryFrom<T>,
 
fn checked_from<T>(t: T) -> Option<Self>where
    Self: TryFrom<T>,
§fn checked_into<T>(self) -> Option<T>where
    Self: TryInto<T>,
 
fn checked_into<T>(self) -> Option<T>where
    Self: TryInto<T>,
§impl<T> Downcast for Twhere
    T: Any,
 
impl<T> Downcast for Twhere
    T: Any,
§fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
 
fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
then be further downcast into Box<ConcreteType> where ConcreteType implements Trait. Read more§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
 
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
further downcast into Rc<ConcreteType> where ConcreteType implements Trait. Read more§fn as_any(&self) -> &(dyn Any + 'static)
 
fn as_any(&self) -> &(dyn Any + 'static)
&Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &Any’s vtable from &Trait’s. Read more§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
 
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &mut Any’s vtable from &mut Trait’s. Read moresource§impl<T> Instrument for T
 
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self>
 
fn instrument(self, span: Span) -> Instrumented<Self>
source§fn in_current_span(self) -> Instrumented<Self>
 
fn in_current_span(self) -> Instrumented<Self>
source§impl<I> IntoIterator for Iwhere
    I: Iterator,
 
impl<I> IntoIterator for Iwhere
    I: Iterator,
source§impl<I> IteratorRandom for Iwhere
    I: Iterator,
 
impl<I> IteratorRandom for Iwhere
    I: Iterator,
source§fn choose<R>(self, rng: &mut R) -> Option<Self::Item>where
    R: Rng + ?Sized,
 
fn choose<R>(self, rng: &mut R) -> Option<Self::Item>where
    R: Rng + ?Sized,
source§fn choose_stable<R>(self, rng: &mut R) -> Option<Self::Item>where
    R: Rng + ?Sized,
 
fn choose_stable<R>(self, rng: &mut R) -> Option<Self::Item>where
    R: Rng + ?Sized,
source§impl<I> IteratorRandom for Iwhere
    I: Iterator,
 
impl<I> IteratorRandom for Iwhere
    I: Iterator,
source§fn choose<R>(self, rng: &mut R) -> Option<Self::Item>where
    R: Rng + ?Sized,
 
fn choose<R>(self, rng: &mut R) -> Option<Self::Item>where
    R: Rng + ?Sized,
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,
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,
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,
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,
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,
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,
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,
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>,
source§fn chunks(self, size: usize) -> IntoChunks<Self>where
    Self: Sized,
 
fn chunks(self, size: usize) -> IntoChunks<Self>where
    Self: Sized,
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,
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,
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,
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,
source§fn step(self, n: usize) -> Step<Self>where
    Self: Sized,
 
fn step(self, n: usize) -> Step<Self>where
    Self: Sized,
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,
.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,
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,
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>,
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,
Result::Ok value into
a series of Result::Ok values. Result::Err values are unchanged. 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>,
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>(
    self,
    other: J,
    cmp_fn: F
) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>where
    J: IntoIterator,
    F: FnMut(&Self::Item, &<J as IntoIterator>::Item) -> Ordering,
    Self: Sized,
 
fn merge_join_by<J, F>(
    self,
    other: J,
    cmp_fn: F
) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>where
    J: IntoIterator,
    F: FnMut(&Self::Item, &<J as IntoIterator>::Item) -> Ordering,
    Self: Sized,
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>,
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,
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,
self and J. Read moresource§fn multi_cartesian_product(
    self
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>where
    Self: Iterator + Sized,
    Self::Item: IntoIterator,
    <Self::Item as IntoIterator>::IntoIter: Clone,
    <Self::Item as IntoIterator>::Item: Clone,
 
fn multi_cartesian_product(
    self
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>where
    Self: Iterator + Sized,
    Self::Item: IntoIterator,
    <Self::Item as IntoIterator>::IntoIter: Clone,
    <Self::Item as IntoIterator>::Item: Clone,
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)>,
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>,
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,
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,
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,
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,
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,
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,
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,
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,
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,
Clone-able iterator
to only pick off elements while the predicate accept returns true. 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>>,
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>,
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,
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,
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,
source§fn powerset(self) -> Powerset<Self>where
    Self: Sized,
    Self::Item: Clone,
 
fn powerset(self) -> Powerset<Self>where
    Self: Sized,
    Self::Item: Clone,
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,
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,
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,
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),
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,
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,
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,
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,
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,
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>,
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>,
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,
source§fn dropping(self, n: usize) -> Selfwhere
    Self: Sized,
 
fn dropping(self, n: usize) -> Selfwhere
    Self: Sized,
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,
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,
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 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>,
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,
sep. Read moresource§fn format(self, sep: &str) -> Format<'_, Self>where
    Self: Sized,
 
fn format(self, sep: &str) -> Format<'_, Self>where
    Self: Sized,
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>,
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,
.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,
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,
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,
Iterator::reduce insteadsource§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,
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>,
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>,
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>,
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,
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,
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,
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,
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,
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,
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,
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,
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>,
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>,
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,
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,
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,
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,
GroupingMap to be used later with one of the efficient 
group-and-fold operations it allows to perform. Read moresource§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>,
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,
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,
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,
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,
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,
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,
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,
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,
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>,
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,
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,
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,
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,
source§fn multipeek(self) -> MultiPeek<Self>where
    Self: Sized,
 
fn multipeek(self) -> MultiPeek<Self>where
    Self: Sized,
.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,
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,
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>,
source§impl<IT> MultiUnzip<()> for ITwhere
    IT: Iterator<Item = ()>,
 
impl<IT> MultiUnzip<()> for ITwhere
    IT: Iterator<Item = ()>,
source§fn multiunzip(self)
 
fn multiunzip(self)
source§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>,
source§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)
source§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>,
source§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)
source§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>,
source§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)
source§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>,
source§fn multiunzip(
    self
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)
 
fn multiunzip(
    self
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)
source§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 ITwhere
    IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,
    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>,
 
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 ITwhere
    IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,
    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>,
source§fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)
 
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)
source§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 ITwhere
    IT: Iterator<Item = (A, B, C, D, E, F, G)>,
    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>,
 
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 ITwhere
    IT: Iterator<Item = (A, B, C, D, E, F, G)>,
    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>,
source§fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)
 
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for ITwhere
    IT: Iterator<Item = (A, B, C, D, E, F)>,
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    FromC: Default + Extend<C>,
    FromD: Default + Extend<D>,
    FromE: Default + Extend<E>,
    FromF: Default + Extend<F>,
 
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for ITwhere
    IT: Iterator<Item = (A, B, C, D, E, F)>,
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    FromC: Default + Extend<C>,
    FromD: Default + Extend<D>,
    FromE: Default + Extend<E>,
    FromF: Default + Extend<F>,
source§fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)
 
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for ITwhere
    IT: Iterator<Item = (A, B, C, D, E)>,
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    FromC: Default + Extend<C>,
    FromD: Default + Extend<D>,
    FromE: Default + Extend<E>,
 
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for ITwhere
    IT: Iterator<Item = (A, B, C, D, E)>,
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    FromC: Default + Extend<C>,
    FromD: Default + Extend<D>,
    FromE: Default + Extend<E>,
source§fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)
 
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for ITwhere
    IT: Iterator<Item = (A, B, C, D)>,
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    FromC: Default + Extend<C>,
    FromD: Default + Extend<D>,
 
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for ITwhere
    IT: Iterator<Item = (A, B, C, D)>,
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    FromC: Default + Extend<C>,
    FromD: Default + Extend<D>,
source§fn multiunzip(self) -> (FromA, FromB, FromC, FromD)
 
fn multiunzip(self) -> (FromA, FromB, FromC, FromD)
source§impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for ITwhere
    IT: Iterator<Item = (A, B, C)>,
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    FromC: Default + Extend<C>,
 
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for ITwhere
    IT: Iterator<Item = (A, B, C)>,
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    FromC: Default + Extend<C>,
source§fn multiunzip(self) -> (FromA, FromB, FromC)
 
fn multiunzip(self) -> (FromA, FromB, FromC)
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)
source§impl<IT, A, FromA> MultiUnzip<(FromA,)> for ITwhere
    IT: Iterator<Item = (A,)>,
    FromA: Default + Extend<A>,
 
impl<IT, A, FromA> MultiUnzip<(FromA,)> for ITwhere
    IT: Iterator<Item = (A,)>,
    FromA: Default + Extend<A>,
source§fn multiunzip(self) -> (FromA,)
 
fn multiunzip(self) -> (FromA,)
§impl<T> Pointable for T
 
impl<T> Pointable for T
§impl<T> SaturatedConversion for T
 
impl<T> SaturatedConversion for T
§fn saturated_from<T>(t: T) -> Selfwhere
    Self: UniqueSaturatedFrom<T>,
 
fn saturated_from<T>(t: T) -> Selfwhere
    Self: UniqueSaturatedFrom<T>,
§fn saturated_into<T>(self) -> Twhere
    Self: UniqueSaturatedInto<T>,
 
fn saturated_into<T>(self) -> Twhere
    Self: UniqueSaturatedInto<T>,
T. Read more§impl<SS, SP> SupersetOf<SS> for SPwhere
    SS: SubsetOf<SP>,
 
impl<SS, SP> SupersetOf<SS> for SPwhere
    SS: SubsetOf<SP>,
§fn to_subset(&self) -> Option<SS>
 
fn to_subset(&self) -> Option<SS>
self from the equivalent element of its
superset. Read more§fn is_in_subset(&self) -> bool
 
fn is_in_subset(&self) -> bool
self is actually part of its subset T (and can be converted to it).§fn to_subset_unchecked(&self) -> SS
 
fn to_subset_unchecked(&self) -> SS
self.to_subset but without any property checks. Always succeeds.§fn from_subset(element: &SS) -> SP
 
fn from_subset(element: &SS) -> SP
self to the equivalent element of its superset.§impl<S, T> UncheckedInto<T> for Swhere
    T: UncheckedFrom<S>,
 
impl<S, T> UncheckedInto<T> for Swhere
    T: UncheckedFrom<S>,
§fn unchecked_into(self) -> T
 
fn unchecked_into(self) -> T
unchecked_from.§impl<I> UnicodeNormalization<I> for Iwhere
    I: Iterator<Item = char>,
 
impl<I> UnicodeNormalization<I> for Iwhere
    I: Iterator<Item = char>,
§fn nfd(self) -> Decompositions<I>
 
fn nfd(self) -> Decompositions<I>
§fn nfkd(self) -> Decompositions<I>
 
fn nfkd(self) -> Decompositions<I>
§fn nfc(self) -> Recompositions<I>
 
fn nfc(self) -> Recompositions<I>
§fn nfkc(self) -> Recompositions<I>
 
fn nfkc(self) -> Recompositions<I>
§fn cjk_compat_variants(self) -> Replacements<I>
 
fn cjk_compat_variants(self) -> Replacements<I>
§fn stream_safe(self) -> StreamSafe<I>
 
fn stream_safe(self) -> StreamSafe<I>
§impl<T, S> UniqueSaturatedInto<T> for Swhere
    T: Bounded,
    S: TryInto<T>,
 
impl<T, S> UniqueSaturatedInto<T> for Swhere
    T: Bounded,
    S: TryInto<T>,
§fn unique_saturated_into(self) -> T
 
fn unique_saturated_into(self) -> T
T.