Struct tor_hsservice::internal_prelude::iter::Peekable
1.0.0 · source · pub struct Peekable<I>where
I: Iterator,{
iter: I,
peeked: Option<Option<<I as Iterator>::Item>>,
}
Expand description
Fields§
§iter: I
§peeked: Option<Option<<I as Iterator>::Item>>
Implementations§
source§impl<I> Peekable<I>where
I: Iterator,
impl<I> Peekable<I>where
I: Iterator,
1.0.0 · sourcepub fn peek(&mut self) -> Option<&<I as Iterator>::Item>
pub fn peek(&mut self) -> Option<&<I as Iterator>::Item>
Returns a reference to the next() value without advancing the iterator.
Like next
, if there is a value, it is wrapped in a Some(T)
.
But if the iteration is over, None
is returned.
Because peek()
returns a reference, and many iterators iterate over
references, there can be a possibly confusing situation where the
return value is a double reference. You can see this effect in the
examples below.
§Examples
Basic usage:
let xs = [1, 2, 3];
let mut iter = xs.iter().peekable();
// peek() lets us see into the future
assert_eq!(iter.peek(), Some(&&1));
assert_eq!(iter.next(), Some(&1));
assert_eq!(iter.next(), Some(&2));
// The iterator does not advance even if we `peek` multiple times
assert_eq!(iter.peek(), Some(&&3));
assert_eq!(iter.peek(), Some(&&3));
assert_eq!(iter.next(), Some(&3));
// After the iterator is finished, so is `peek()`
assert_eq!(iter.peek(), None);
assert_eq!(iter.next(), None);
1.53.0 · sourcepub fn peek_mut(&mut self) -> Option<&mut <I as Iterator>::Item>
pub fn peek_mut(&mut self) -> Option<&mut <I as Iterator>::Item>
Returns a mutable reference to the next() value without advancing the iterator.
Like next
, if there is a value, it is wrapped in a Some(T)
.
But if the iteration is over, None
is returned.
Because peek_mut()
returns a reference, and many iterators iterate over
references, there can be a possibly confusing situation where the
return value is a double reference. You can see this effect in the examples
below.
§Examples
Basic usage:
let mut iter = [1, 2, 3].iter().peekable();
// Like with `peek()`, we can see into the future without advancing the iterator.
assert_eq!(iter.peek_mut(), Some(&mut &1));
assert_eq!(iter.peek_mut(), Some(&mut &1));
assert_eq!(iter.next(), Some(&1));
// Peek into the iterator and set the value behind the mutable reference.
if let Some(p) = iter.peek_mut() {
assert_eq!(*p, &2);
*p = &5;
}
// The value we put in reappears as the iterator continues.
assert_eq!(iter.collect::<Vec<_>>(), vec![&5, &3]);
1.51.0 · sourcepub fn next_if(
&mut self,
func: impl FnOnce(&<I as Iterator>::Item) -> bool
) -> Option<<I as Iterator>::Item>
pub fn next_if( &mut self, func: impl FnOnce(&<I as Iterator>::Item) -> bool ) -> Option<<I as Iterator>::Item>
Consume and return the next value of this iterator if a condition is true.
If func
returns true
for the next value of this iterator, consume and return it.
Otherwise, return None
.
§Examples
Consume a number if it’s equal to 0.
let mut iter = (0..5).peekable();
// The first item of the iterator is 0; consume it.
assert_eq!(iter.next_if(|&x| x == 0), Some(0));
// The next item returned is now 1, so `consume` will return `false`.
assert_eq!(iter.next_if(|&x| x == 0), None);
// `next_if` saves the value of the next item if it was not equal to `expected`.
assert_eq!(iter.next(), Some(1));
Consume any number less than 10.
let mut iter = (1..20).peekable();
// Consume all numbers less than 10
while iter.next_if(|&x| x < 10).is_some() {}
// The next value returned will be 10
assert_eq!(iter.next(), Some(10));
1.51.0 · sourcepub fn next_if_eq<T>(&mut self, expected: &T) -> Option<<I as Iterator>::Item>
pub fn next_if_eq<T>(&mut self, expected: &T) -> Option<<I as Iterator>::Item>
Consume and return the next item if it is equal to expected
.
§Example
Consume a number if it’s equal to 0.
let mut iter = (0..5).peekable();
// The first item of the iterator is 0; consume it.
assert_eq!(iter.next_if_eq(&0), Some(0));
// The next item returned is now 1, so `consume` will return `false`.
assert_eq!(iter.next_if_eq(&0), None);
// `next_if_eq` saves the value of the next item if it was not equal to `expected`.
assert_eq!(iter.next(), Some(1));
Trait Implementations§
1.38.0 · source§impl<I> DoubleEndedIterator for Peekable<I>where
I: DoubleEndedIterator,
impl<I> DoubleEndedIterator for Peekable<I>where
I: DoubleEndedIterator,
source§fn next_back(&mut self) -> Option<<Peekable<I> as Iterator>::Item>
fn next_back(&mut self) -> Option<<Peekable<I> as Iterator>::Item>
source§fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
Iterator::try_fold()
: it takes
elements starting from the back of the iterator. Read moresource§fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
source§fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
iter_advance_by
)n
elements. Read more1.0.0 · source§impl<I> ExactSizeIterator for Peekable<I>where
I: ExactSizeIterator,
impl<I> ExactSizeIterator for Peekable<I>where
I: ExactSizeIterator,
1.0.0 · source§impl<I> Iterator for Peekable<I>where
I: Iterator,
impl<I> Iterator for Peekable<I>where
I: Iterator,
source§fn next(&mut self) -> Option<<I as Iterator>::Item>
fn next(&mut self) -> Option<<I as Iterator>::Item>
source§fn count(self) -> usize
fn count(self) -> usize
source§fn nth(&mut self, n: usize) -> Option<<I as Iterator>::Item>
fn nth(&mut self, n: usize) -> Option<<I as Iterator>::Item>
n
th element of the iterator. Read moresource§fn last(self) -> Option<<I as Iterator>::Item>
fn last(self) -> Option<<I as Iterator>::Item>
source§fn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
source§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
source§fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
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 moresource§fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
iter_advance_by
)n
elements. 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> ⓘ
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> ⓘ
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> ⓘ
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> ⓘ
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> ⓘ
fn map<B, F>(self, f: F) -> Map<Self, F> ⓘ
1.0.0 · source§fn filter<P>(self, predicate: P) -> Filter<Self, P> ⓘ
fn filter<P>(self, predicate: P) -> Filter<Self, P> ⓘ
1.0.0 · source§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> ⓘ
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> ⓘ
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> ⓘ
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> ⓘ
1.0.0 · source§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> ⓘ
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> ⓘ
1.57.0 · source§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> ⓘ
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> ⓘ
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 flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> ⓘ
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> ⓘ
source§fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N> ⓘ
fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N> ⓘ
iter_map_windows
)f
for each contiguous window of size N
over
self
and returns an iterator over the outputs of f
. Like slice::windows()
,
the windows during mapping overlap as well. Read more1.0.0 · source§fn inspect<F>(self, f: F) -> Inspect<Self, F> ⓘ
fn inspect<F>(self, f: F) -> Inspect<Self, F> ⓘ
1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
source§fn collect_into<E>(self, collection: &mut E) -> &mut E
fn collect_into<E>(self, collection: &mut E) -> &mut E
iter_collect_into
)1.0.0 · source§fn partition<B, F>(self, f: F) -> (B, B)
fn partition<B, F>(self, f: F) -> (B, B)
source§fn is_partitioned<P>(self, predicate: P) -> bool
fn is_partitioned<P>(self, predicate: P) -> bool
iter_is_partitioned
)true
precede all those that return false
. Read more1.27.0 · source§fn try_for_each<F, R>(&mut self, f: F) -> R
fn try_for_each<F, R>(&mut self, f: F) -> R
1.51.0 · source§fn reduce<F>(self, f: F) -> Option<Self::Item>
fn reduce<F>(self, f: F) -> Option<Self::Item>
source§fn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
fn try_reduce<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
iterator_try_reduce
)1.0.0 · source§fn all<F>(&mut self, f: F) -> bool
fn all<F>(&mut self, f: F) -> bool
1.0.0 · source§fn any<F>(&mut self, f: F) -> bool
fn any<F>(&mut self, f: F) -> bool
1.0.0 · source§fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
1.30.0 · source§fn find_map<B, F>(&mut self, f: F) -> Option<B>
fn find_map<B, F>(&mut self, f: F) -> Option<B>
source§fn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
fn try_find<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
try_find
)1.0.0 · source§fn position<P>(&mut self, predicate: P) -> Option<usize>
fn position<P>(&mut self, predicate: P) -> Option<usize>
1.6.0 · source§fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn max_by<F>(self, compare: F) -> Option<Self::Item>
fn max_by<F>(self, compare: F) -> Option<Self::Item>
1.6.0 · source§fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn min_by<F>(self, compare: F) -> Option<Self::Item>
fn min_by<F>(self, compare: F) -> Option<Self::Item>
1.0.0 · source§fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
1.36.0 · source§fn copied<'a, T>(self) -> Copied<Self> ⓘ
fn copied<'a, T>(self) -> Copied<Self> ⓘ
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 product<P>(self) -> P
fn product<P>(self) -> P
source§fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
fn cmp_by<I, F>(self, other: I, cmp: F) -> 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>
fn partial_cmp<I>(self, other: I) -> Option<Ordering>
PartialOrd
elements of
this Iterator
with those of another. The comparison works like short-circuit
evaluation, returning a result without comparing the remaining elements.
As soon as an order can be determined, the evaluation stops and a result is returned. Read moresource§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 moresource§fn eq_by<I, F>(self, other: I, eq: F) -> bool
fn eq_by<I, F>(self, other: I, eq: F) -> bool
iter_order_by
)1.5.0 · source§fn lt<I>(self, other: I) -> bool
fn lt<I>(self, other: I) -> bool
Iterator
are lexicographically
less than those of another. Read more1.5.0 · source§fn le<I>(self, other: I) -> bool
fn le<I>(self, other: I) -> bool
Iterator
are lexicographically
less or equal to those of another. Read more1.5.0 · source§fn gt<I>(self, other: I) -> bool
fn gt<I>(self, other: I) -> bool
Iterator
are lexicographically
greater than those of another. Read more1.5.0 · source§fn ge<I>(self, other: I) -> bool
fn ge<I>(self, other: I) -> bool
Iterator
are lexicographically
greater than or equal to those of another. Read moresource§fn is_sorted_by<F>(self, compare: F) -> bool
fn is_sorted_by<F>(self, compare: F) -> bool
is_sorted
)source§fn is_sorted_by_key<F, K>(self, f: F) -> bool
fn is_sorted_by_key<F, K>(self, f: F) -> bool
is_sorted
)impl<I> FusedIterator for Peekable<I>where
I: FusedIterator,
impl<I> TrustedLen for Peekable<I>where
I: TrustedLen,
Auto Trait Implementations§
impl<I> Freeze for Peekable<I>
impl<I> RefUnwindSafe for Peekable<I>
impl<I> Send for Peekable<I>
impl<I> Sync for Peekable<I>
impl<I> Unpin for Peekable<I>
impl<I> UnwindSafe for Peekable<I>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<T> CheckedSum<usize> for Twhere
T: IntoIterator<Item = usize>,
impl<T> CheckedSum<usize> for Twhere
T: IntoIterator<Item = usize>,
§fn checked_sum(self) -> Result<usize, Error>
fn checked_sum(self) -> Result<usize, Error>
§impl<T> Conv for T
impl<T> Conv for T
§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
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
.§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.§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.§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.§impl<T> DowncastSync for T
impl<T> DowncastSync for T
§impl<T> FmtForward for T
impl<T> FmtForward for T
§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self
to use its Binary
implementation when Debug
-formatted.§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self
to use its Display
implementation when
Debug
-formatted.§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self
to use its LowerExp
implementation when
Debug
-formatted.§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self
to use its LowerHex
implementation when
Debug
-formatted.§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self
to use its Octal
implementation when Debug
-formatted.§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self
to use its Pointer
implementation when
Debug
-formatted.§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self
to use its UpperExp
implementation when
Debug
-formatted.§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self
to use its UpperHex
implementation when
Debug
-formatted.§fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> 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> ⓘ
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> ⓘ
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<I> IteratorExt for Iwhere
I: Iterator,
impl<I> IteratorExt for Iwhere
I: Iterator,
§fn batching_split_before_with_header<F>(
self,
batch_starting: F
) -> BatchesWithHeader<Self::Item, Self, F> ⓘ
fn batching_split_before_with_header<F>( self, batch_starting: F ) -> BatchesWithHeader<Self::Item, Self, F> ⓘ
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>
fn choose<R>(self, rng: &mut R) -> Option<Self::Item>
source§fn choose_stable<R>(self, rng: &mut R) -> Option<Self::Item>
fn choose_stable<R>(self, rng: &mut R) -> Option<Self::Item>
§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> ⓘ
§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> ⓘ
§fn intersperse(
self,
element: Self::Item
) -> IntersperseWith<Self, IntersperseElementSimple<Self::Item>> ⓘ
fn intersperse( self, element: Self::Item ) -> IntersperseWith<Self, IntersperseElementSimple<Self::Item>> ⓘ
§fn intersperse_with<F>(self, element: F) -> IntersperseWith<Self, F> ⓘ
fn intersperse_with<F>(self, element: F) -> IntersperseWith<Self, F> ⓘ
§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,
§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,
§fn batching<B, F>(self, f: F) -> Batching<Self, F> ⓘ
fn batching<B, F>(self, f: F) -> Batching<Self, F> ⓘ
§fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F>
fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F>
use_alloc
only.§fn chunks(self, size: usize) -> IntoChunks<Self>where
Self: Sized,
fn chunks(self, size: usize) -> IntoChunks<Self>where
Self: Sized,
use_alloc
only.§fn tuple_windows<T>(self) -> TupleWindows<Self, T> ⓘ
fn tuple_windows<T>(self) -> TupleWindows<Self, T> ⓘ
§fn circular_tuple_windows<T>(self) -> CircularTupleWindows<Self, T> ⓘ
fn circular_tuple_windows<T>(self) -> CircularTupleWindows<Self, T> ⓘ
§fn tuples<T>(self) -> Tuples<Self, T> ⓘ
fn tuples<T>(self) -> Tuples<Self, T> ⓘ
§fn tee(self) -> (Tee<Self>, Tee<Self>)
fn tee(self) -> (Tee<Self>, Tee<Self>)
use_alloc
only.§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 more§fn map_results<F, T, U, E>(
self,
f: F
) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>
fn map_results<F, T, U, E>( self, f: F ) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>
.map_ok()
.§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>>
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> ⓘ
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> ⓘ
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> ⓘ
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>
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> ⓘ
§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>> ⓘ
§fn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt> ⓘ
fn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt> ⓘ
use_alloc
only.§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,
use_alloc
only.§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> ⓘ
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,
use_alloc
only.self
. Read more§fn coalesce<F>(self, f: F) -> CoalesceBy<Self, F, NoCount>
fn coalesce<F>(self, f: F) -> CoalesceBy<Self, F, NoCount>
§fn dedup(self) -> CoalesceBy<Self, DedupPred2CoalescePred<DedupEq>, NoCount>
fn dedup(self) -> CoalesceBy<Self, DedupPred2CoalescePred<DedupEq>, NoCount>
§fn dedup_by<Cmp>(
self,
cmp: Cmp
) -> CoalesceBy<Self, DedupPred2CoalescePred<Cmp>, NoCount>
fn dedup_by<Cmp>( self, cmp: Cmp ) -> CoalesceBy<Self, DedupPred2CoalescePred<Cmp>, NoCount>
§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,
§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>
§fn duplicates(self) -> DuplicatesBy<Self, Self::Item, ById>
fn duplicates(self) -> DuplicatesBy<Self, Self::Item, ById>
use_std
only.§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>>
use_std
only.§fn unique(self) -> Unique<Self> ⓘ
fn unique(self) -> Unique<Self> ⓘ
use_std
only.§fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F> ⓘ
fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F> ⓘ
use_std
only.§fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F> ⓘ
fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F> ⓘ
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> ⓘ
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> ⓘ
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> ⓘ
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> ⓘ
§fn combinations(self, k: usize) -> Combinations<Self> ⓘ
fn combinations(self, k: usize) -> Combinations<Self> ⓘ
use_alloc
only.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> ⓘ
use_alloc
only.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> ⓘ
use_alloc
only.§fn powerset(self) -> Powerset<Self> ⓘ
fn powerset(self) -> Powerset<Self> ⓘ
use_alloc
only.§fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F> ⓘ
fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F> ⓘ
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,
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> ⓘ
§fn update<F>(self, updater: F) -> Update<Self, F> ⓘ
fn update<F>(self, updater: F) -> Update<Self, F> ⓘ
§fn next_tuple<T>(&mut self) -> Option<T>
fn next_tuple<T>(&mut self) -> Option<T>
§fn collect_tuple<T>(self) -> Option<T>
fn collect_tuple<T>(self) -> Option<T>
§fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)>
fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)>
§fn find_or_last<P>(self, predicate: P) -> Option<Self::Item>
fn find_or_last<P>(self, predicate: P) -> Option<Self::Item>
§fn find_or_first<P>(self, predicate: P) -> Option<Self::Item>
fn find_or_first<P>(self, predicate: P) -> Option<Self::Item>
§fn contains<Q>(&mut self, query: &Q) -> bool
fn contains<Q>(&mut self, query: &Q) -> bool
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)>>
§fn all_unique(&mut self) -> bool
fn all_unique(&mut self) -> bool
use_std
only.§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 more§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 more§fn foreach<F>(self, f: F)
fn foreach<F>(self, f: F)
f
eagerly on each element of the iterator. Read more§fn collect_vec(self) -> Vec<Self::Item>where
Self: Sized,
fn collect_vec(self) -> Vec<Self::Item>where
Self: Sized,
use_alloc
only..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
self
from the from
iterator,
stopping at the shortest of the two iterators. Read more§fn join(&mut self, sep: &str) -> String
fn join(&mut self, sep: &str) -> String
use_alloc
only.sep
. Read more§fn format(self, sep: &str) -> Format<'_, Self>where
Self: Sized,
fn format(self, sep: &str) -> Format<'_, Self>where
Self: Sized,
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>
sep
. Read more§fn fold_results<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>
fn fold_results<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>
.fold_ok()
.§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>
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>
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>
Iterator::reduce
instead§fn tree_fold1<F>(self, f: F) -> Option<Self::Item>
fn tree_fold1<F>(self, f: F) -> Option<Self::Item>
§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>
§fn product1<P>(self) -> Option<P>
fn product1<P>(self) -> Option<P>
§fn sorted_unstable(self) -> IntoIter<Self::Item> ⓘ
fn sorted_unstable(self) -> IntoIter<Self::Item> ⓘ
use_alloc
only.§fn sorted_unstable_by<F>(self, cmp: F) -> IntoIter<Self::Item> ⓘ
fn sorted_unstable_by<F>(self, cmp: F) -> IntoIter<Self::Item> ⓘ
use_alloc
only.§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> ⓘ
use_alloc
only.§fn sorted(self) -> IntoIter<Self::Item> ⓘ
fn sorted(self) -> IntoIter<Self::Item> ⓘ
use_alloc
only.§fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item> ⓘ
fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item> ⓘ
use_alloc
only.§fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item> ⓘ
fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item> ⓘ
use_alloc
only.§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> ⓘ
use_alloc
only.§fn k_smallest(self, k: usize) -> IntoIter<Self::Item> ⓘ
fn k_smallest(self, k: usize) -> IntoIter<Self::Item> ⓘ
use_alloc
only.§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)
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)
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>>
use_std
only.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>>
use_std
only.Iterator
on a HashMap
. Keys mapped to Vec
s of values. The key is specified
in the closure. Read more§fn into_grouping_map<K, V>(self) -> GroupingMap<Self>
fn into_grouping_map<K, V>(self) -> GroupingMap<Self>
use_std
only.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<MapForGrouping<Self, F>>
fn into_grouping_map_by<K, V, F>( self, key_mapper: F ) -> GroupingMap<MapForGrouping<Self, F>>
use_std
only.GroupingMap
to be used later with one of the efficient
group-and-fold operations it allows to perform. Read more§fn min_set(self) -> Vec<Self::Item>
fn min_set(self) -> Vec<Self::Item>
use_alloc
only.§fn min_set_by<F>(self, compare: F) -> Vec<Self::Item>
fn min_set_by<F>(self, compare: F) -> Vec<Self::Item>
use_alloc
only.§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>
use_alloc
only.§fn max_set(self) -> Vec<Self::Item>
fn max_set(self) -> Vec<Self::Item>
use_alloc
only.§fn max_set_by<F>(self, compare: F) -> Vec<Self::Item>
fn max_set_by<F>(self, compare: F) -> Vec<Self::Item>
use_alloc
only.§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>
use_alloc
only.§fn minmax(self) -> MinMaxResult<Self::Item>
fn minmax(self) -> MinMaxResult<Self::Item>
§fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item>
fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item>
§fn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item>
fn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item>
§fn position_max(self) -> Option<usize>
fn position_max(self) -> Option<usize>
§fn position_max_by_key<K, F>(self, key: F) -> Option<usize>
fn position_max_by_key<K, F>(self, key: F) -> Option<usize>
§fn position_max_by<F>(self, compare: F) -> Option<usize>
fn position_max_by<F>(self, compare: F) -> Option<usize>
§fn position_min(self) -> Option<usize>
fn position_min(self) -> Option<usize>
§fn position_min_by_key<K, F>(self, key: F) -> Option<usize>
fn position_min_by_key<K, F>(self, key: F) -> Option<usize>
§fn position_min_by<F>(self, compare: F) -> Option<usize>
fn position_min_by<F>(self, compare: F) -> Option<usize>
§fn position_minmax(self) -> MinMaxResult<usize>
fn position_minmax(self) -> MinMaxResult<usize>
§fn position_minmax_by_key<K, F>(self, key: F) -> MinMaxResult<usize>
fn position_minmax_by_key<K, F>(self, key: F) -> MinMaxResult<usize>
§fn position_minmax_by<F>(self, compare: F) -> MinMaxResult<usize>
fn position_minmax_by<F>(self, compare: F) -> MinMaxResult<usize>
§fn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>>where
Self: Sized,
fn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>>where
Self: Sized,
§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,
§fn multipeek(self) -> MultiPeek<Self> ⓘwhere
Self: Sized,
fn multipeek(self) -> MultiPeek<Self> ⓘwhere
Self: Sized,
use_alloc
only..next()
values without advancing the base iterator. Read more§fn counts(self) -> HashMap<Self::Item, usize>
fn counts(self) -> HashMap<Self::Item, usize>
use_std
only.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>
use_std
only.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>,
§impl<IT> MultiUnzip<()> for IT
impl<IT> MultiUnzip<()> for IT
§fn multiunzip(self)
fn multiunzip(self)
§impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
§fn multiunzip(self) -> (FromA,)
fn multiunzip(self) -> (FromA,)
§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)
§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)
§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)
§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)
§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)
§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)
§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)
§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)
§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)
§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)
§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)
§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self
, then passes self.as_ref()
into the pipe function.§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self
, then passes self.as_mut()
into the pipe
function.§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self
, then passes self.deref()
into the pipe function.§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B>
of a value. Read more§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B>
of a value. Read more§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R>
view of a value. Read more§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R>
view of a value. Read more§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target
of a value. Read more§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target
of a value. Read more§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap()
only in debug builds, and is erased in release builds.§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut()
only in debug builds, and is erased in release
builds.§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow()
only in debug builds, and is erased in release
builds.§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut()
only in debug builds, and is erased in release
builds.§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref()
only in debug builds, and is erased in release
builds.§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut()
only in debug builds, and is erased in release
builds.§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref()
only in debug builds, and is erased in release
builds.