1.0.0[−][src]Struct af_lib::iter::__std_iter::Map
An iterator that maps the values of iter
with f
.
This struct
is created by the map
method on Iterator
. See its
documentation for more.
Notes about side effects
The map
iterator implements DoubleEndedIterator
, meaning that
you can also map
backwards:
let v: Vec<i32> = vec![1, 2, 3].into_iter().map(|x| x + 1).rev().collect(); assert_eq!(v, [4, 3, 2]);
But if your closure has state, iterating backwards may act in a way you do not expect. Let's go through an example. First, in the forward direction:
let mut c = 0; for pair in vec!['a', 'b', 'c'].into_iter() .map(|letter| { c += 1; (letter, c) }) { println!("{:?}", pair); }
This will print "('a', 1), ('b', 2), ('c', 3)".
Now consider this twist where we add a call to rev
. This version will
print ('c', 1), ('b', 2), ('a', 3)
. Note that the letters are reversed,
but the values of the counter still go in order. This is because map()
is
still being called lazily on each item, but we are popping items off the
back of the vector now, instead of shifting them from the front.
let mut c = 0; for pair in vec!['a', 'b', 'c'].into_iter() .map(|letter| { c += 1; (letter, c) }) .rev() { println!("{:?}", pair); }
Trait Implementations
impl<I, F> Clone for Map<I, F> where
F: Clone,
I: Clone,
[src]
F: Clone,
I: Clone,
impl<I, F> Debug for Map<I, F> where
I: Debug,
1.9.0[src]
I: Debug,
impl<B, I, F> DoubleEndedIterator for Map<I, F> where
F: FnMut(<I as Iterator>::Item) -> B,
I: DoubleEndedIterator,
[src]
F: FnMut(<I as Iterator>::Item) -> B,
I: DoubleEndedIterator,
pub fn next_back(&mut self) -> Option<B>
[src]
pub fn try_rfold<Acc, G, R>(&mut self, init: Acc, g: G) -> R where
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Map<I, F>: Sized,
[src]
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Map<I, F>: Sized,
pub fn rfold<Acc, G>(self, init: Acc, g: G) -> Acc where
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> Acc,
[src]
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> Acc,
pub fn advance_back_by(&mut self, n: usize) -> Result<(), usize>
[src]
pub fn nth_back(&mut self, n: usize) -> Option<Self::Item>
1.37.0[src]
pub fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
1.27.0[src]
P: FnMut(&Self::Item) -> bool,
impl<B, I, F> ExactSizeIterator for Map<I, F> where
F: FnMut(<I as Iterator>::Item) -> B,
I: ExactSizeIterator,
[src]
F: FnMut(<I as Iterator>::Item) -> B,
I: ExactSizeIterator,
impl<B, I, F> FusedIterator for Map<I, F> where
F: FnMut(<I as Iterator>::Item) -> B,
I: FusedIterator,
1.26.0[src]
F: FnMut(<I as Iterator>::Item) -> B,
I: FusedIterator,
impl<B, I, F> InPlaceIterable for Map<I, F> where
F: FnMut(<I as Iterator>::Item) -> B,
I: InPlaceIterable,
[src]
F: FnMut(<I as Iterator>::Item) -> B,
I: InPlaceIterable,
impl<B, I, F> Iterator for Map<I, F> where
F: FnMut(<I as Iterator>::Item) -> B,
I: Iterator,
[src]
F: FnMut(<I as Iterator>::Item) -> B,
I: Iterator,
type Item = B
The type of the elements being iterated over.
pub fn next(&mut self) -> Option<B>
[src]
pub fn size_hint(&self) -> (usize, Option<usize>)
[src]
pub fn try_fold<Acc, G, R>(&mut self, init: Acc, g: G) -> R where
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Map<I, F>: Sized,
[src]
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> R,
R: Try<Ok = Acc>,
Map<I, F>: Sized,
pub fn fold<Acc, G>(self, init: Acc, g: G) -> Acc where
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> Acc,
[src]
G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> Acc,
pub unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> B where
Map<I, F>: TrustedRandomAccess,
[src]
Map<I, F>: TrustedRandomAccess,
pub fn count(self) -> usize
[src]
pub fn last(self) -> Option<Self::Item>
[src]
pub fn advance_by(&mut self, n: usize) -> Result<(), usize>
[src]
pub fn nth(&mut self, n: usize) -> Option<Self::Item>
[src]
pub fn step_by(self, step: usize) -> StepBy<Self>ⓘ
1.28.0[src]
pub fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>ⓘ where
U: IntoIterator<Item = Self::Item>,
[src]
U: IntoIterator<Item = Self::Item>,
pub fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>ⓘ where
U: IntoIterator,
[src]
U: IntoIterator,
pub fn intersperse(self, separator: Self::Item) -> Intersperse<Self>ⓘNotable traits for Intersperse<I>
impl<I> Iterator for Intersperse<I> where
I: Iterator,
<I as Iterator>::Item: Clone, type Item = <I as Iterator>::Item;
where
Self::Item: Clone,
[src]
Notable traits for Intersperse<I>
impl<I> Iterator for Intersperse<I> where
I: Iterator,
<I as Iterator>::Item: Clone, type Item = <I as Iterator>::Item;
Self::Item: Clone,
pub fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>ⓘNotable traits for IntersperseWith<I, G>
impl<I, G> Iterator for IntersperseWith<I, G> where
G: FnMut() -> <I as Iterator>::Item,
I: Iterator, type Item = <I as Iterator>::Item;
where
G: FnMut() -> Self::Item,
[src]
Notable traits for IntersperseWith<I, G>
impl<I, G> Iterator for IntersperseWith<I, G> where
G: FnMut() -> <I as Iterator>::Item,
I: Iterator, type Item = <I as Iterator>::Item;
G: FnMut() -> Self::Item,
pub fn map<B, F>(self, f: F) -> Map<Self, F>ⓘ where
F: FnMut(Self::Item) -> B,
[src]
F: FnMut(Self::Item) -> B,
pub fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
1.21.0[src]
F: FnMut(Self::Item),
pub fn filter<P>(self, predicate: P) -> Filter<Self, P>ⓘ where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
pub fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>ⓘ where
F: FnMut(Self::Item) -> Option<B>,
[src]
F: FnMut(Self::Item) -> Option<B>,
pub fn enumerate(self) -> Enumerate<Self>ⓘ
[src]
pub fn peekable(self) -> Peekable<Self>ⓘ
[src]
pub fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>ⓘ where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
pub fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>ⓘ where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
pub fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>ⓘ where
P: FnMut(Self::Item) -> Option<B>,
[src]
P: FnMut(Self::Item) -> Option<B>,
pub fn skip(self, n: usize) -> Skip<Self>ⓘ
[src]
pub fn take(self, n: usize) -> Take<Self>ⓘ
[src]
pub fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>ⓘ where
F: FnMut(&mut St, Self::Item) -> Option<B>,
[src]
F: FnMut(&mut St, Self::Item) -> Option<B>,
pub fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>ⓘ where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
[src]
F: FnMut(Self::Item) -> U,
U: IntoIterator,
pub fn flatten(self) -> Flatten<Self>ⓘ where
Self::Item: IntoIterator,
1.29.0[src]
Self::Item: IntoIterator,
pub fn fuse(self) -> Fuse<Self>ⓘ
[src]
pub fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘ where
F: FnMut(&Self::Item),
[src]
F: FnMut(&Self::Item),
pub fn by_ref(&mut self) -> &mut SelfⓘNotable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
[src]
Notable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
#[must_use =
"if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]pub fn collect<B>(self) -> B where
B: FromIterator<Self::Item>,
[src]
B: FromIterator<Self::Item>,
pub fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
[src]
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
pub fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
Self: DoubleEndedIterator<Item = &'a mut T>,
P: FnMut(&T) -> bool,
T: 'a,
[src]
Self: DoubleEndedIterator<Item = &'a mut T>,
P: FnMut(&T) -> bool,
T: 'a,
pub fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]
P: FnMut(Self::Item) -> bool,
pub fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
1.27.0[src]
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
pub fn fold_first<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
[src]
F: FnMut(Self::Item, Self::Item) -> Self::Item,
pub fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
[src]
F: FnMut(Self::Item) -> bool,
pub fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
[src]
F: FnMut(Self::Item) -> bool,
pub fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
pub fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,
1.30.0[src]
F: FnMut(Self::Item) -> Option<B>,
pub fn try_find<F, R>(
&mut self,
f: F
) -> Result<Option<Self::Item>, <R as Try>::Error> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>,
[src]
&mut self,
f: F
) -> Result<Option<Self::Item>, <R as Try>::Error> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>,
pub fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
[src]
P: FnMut(Self::Item) -> bool,
pub fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
Self: ExactSizeIterator + DoubleEndedIterator,
P: FnMut(Self::Item) -> bool,
[src]
Self: ExactSizeIterator + DoubleEndedIterator,
P: FnMut(Self::Item) -> bool,
pub fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
pub fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
pub fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
B: Ord,
F: FnMut(&Self::Item) -> B,
pub fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
pub fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
B: Ord,
F: FnMut(&Self::Item) -> B,
pub fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
pub fn rev(self) -> Rev<Self>ⓘ where
Self: DoubleEndedIterator,
[src]
Self: DoubleEndedIterator,
pub fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
Self: Iterator<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
[src]
Self: Iterator<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
pub fn copied<'a, T>(self) -> Copied<Self>ⓘ where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
1.36.0[src]
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
pub fn cloned<'a, T>(self) -> Cloned<Self>ⓘ where
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
[src]
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
pub fn cycle(self) -> Cycle<Self>ⓘ where
Self: Clone,
[src]
Self: Clone,
pub fn sum<S>(self) -> S where
S: Sum<Self::Item>,
1.11.0[src]
S: Sum<Self::Item>,
pub fn product<P>(self) -> P where
P: Product<Self::Item>,
1.11.0[src]
P: Product<Self::Item>,
pub fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
1.5.0[src]
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
pub fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
[src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
pub fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator,
[src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator,
pub fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
pub fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
[src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
pub fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
pub fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]
Self::Item: PartialOrd<Self::Item>,
pub fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
pub fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
[src]
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
impl<S, B, I, F> SourceIter for Map<I, F> where
F: FnMut(<I as Iterator>::Item) -> B,
S: Iterator,
I: Iterator + SourceIter<Source = S>,
[src]
F: FnMut(<I as Iterator>::Item) -> B,
S: Iterator,
I: Iterator + SourceIter<Source = S>,
type Source = S
inplace_iteration
)A source stage in an iterator pipeline.
pub unsafe fn as_inner(&mut self) -> &mut SⓘNotable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
[src]
Notable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
impl<B, I, F> TrustedLen for Map<I, F> where
F: FnMut(<I as Iterator>::Item) -> B,
I: TrustedLen,
[src]
F: FnMut(<I as Iterator>::Item) -> B,
I: TrustedLen,
Auto Trait Implementations
impl<I, F> RefUnwindSafe for Map<I, F> where
F: RefUnwindSafe,
I: RefUnwindSafe,
[src]
F: RefUnwindSafe,
I: RefUnwindSafe,
impl<I, F> Send for Map<I, F> where
F: Send,
I: Send,
[src]
F: Send,
I: Send,
impl<I, F> Sync for Map<I, F> where
F: Sync,
I: Sync,
[src]
F: Sync,
I: Sync,
impl<I, F> Unpin for Map<I, F> where
F: Unpin,
I: Unpin,
[src]
F: Unpin,
I: Unpin,
impl<I, F> UnwindSafe for Map<I, F> where
F: UnwindSafe,
I: UnwindSafe,
[src]
F: UnwindSafe,
I: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow(&self) -> &TⓘNotable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
[src]
Notable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
[src]
Notable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
impl<T> From<T> for T
[src]
impl<T> Instrument for T
[src]
pub fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]
Notable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
pub fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]
Notable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
impl<T> Instrument for T
[src]
pub fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]
Notable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
pub fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]
Notable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<I> IntoIterator for I where
I: Iterator,
[src]
I: Iterator,
type Item = <I as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = I
Which kind of iterator are we turning this into?
pub fn into_iter(self) -> I
[src]
impl<I> IteratorRandom for I where
I: Iterator,
[src]
I: Iterator,
pub fn choose<R>(self, rng: &mut R) -> Option<Self::Item> where
R: Rng + ?Sized,
[src]
R: Rng + ?Sized,
pub fn choose_stable<R>(self, rng: &mut R) -> Option<Self::Item> where
R: Rng + ?Sized,
[src]
R: Rng + ?Sized,
pub fn choose_multiple_fill<R>(
self,
rng: &mut R,
buf: &mut [Self::Item]
) -> usize where
R: Rng + ?Sized,
[src]
self,
rng: &mut R,
buf: &mut [Self::Item]
) -> usize where
R: Rng + ?Sized,
pub fn choose_multiple<R>(
self,
rng: &mut R,
amount: usize
) -> Vec<Self::Item, Global>ⓘ where
R: Rng + ?Sized,
[src]
self,
rng: &mut R,
amount: usize
) -> Vec<Self::Item, Global>ⓘ where
R: Rng + ?Sized,
impl<I> IteratorRandom for I where
I: Iterator,
[src]
I: Iterator,
pub fn choose<R>(self, rng: &mut R) -> Option<Self::Item> where
R: Rng + ?Sized,
[src]
R: Rng + ?Sized,
pub fn choose_multiple_fill<R>(
self,
rng: &mut R,
buf: &mut [Self::Item]
) -> usize where
R: Rng + ?Sized,
[src]
self,
rng: &mut R,
buf: &mut [Self::Item]
) -> usize where
R: Rng + ?Sized,
pub fn choose_multiple<R>(
self,
rng: &mut R,
amount: usize
) -> Vec<Self::Item, Global>ⓘ where
R: Rng + ?Sized,
[src]
self,
rng: &mut R,
amount: usize
) -> Vec<Self::Item, Global>ⓘ where
R: Rng + ?Sized,
impl<T> Itertools for T where
T: Iterator + ?Sized,
[src]
T: Iterator + ?Sized,
pub fn interleave<J>(
self,
other: J
) -> Interleave<Self, <J as IntoIterator>::IntoIter>ⓘNotable traits for Interleave<I, J>
impl<I, J> Iterator for Interleave<I, J> where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
J: IntoIterator<Item = Self::Item>,
[src]
self,
other: J
) -> Interleave<Self, <J as IntoIterator>::IntoIter>ⓘ
Notable traits for Interleave<I, J>
impl<I, J> Iterator for Interleave<I, J> where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>, type Item = <I as Iterator>::Item;
J: IntoIterator<Item = Self::Item>,
pub fn interleave_shortest<J>(
self,
other: J
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>ⓘNotable traits for InterleaveShortest<I, J>
impl<I, J> Iterator for InterleaveShortest<I, J> where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
J: IntoIterator<Item = Self::Item>,
[src]
self,
other: J
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>ⓘ
Notable traits for InterleaveShortest<I, J>
impl<I, J> Iterator for InterleaveShortest<I, J> where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>, type Item = <I as Iterator>::Item;
J: IntoIterator<Item = Self::Item>,
pub fn intersperse(
self,
element: Self::Item
) -> IntersperseWith<Self, IntersperseElementSimple<Self::Item>>ⓘNotable traits for IntersperseWith<I, ElemF>
impl<I, ElemF> Iterator for IntersperseWith<I, ElemF> where
I: Iterator,
ElemF: IntersperseElement<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
Self::Item: Clone,
[src]
self,
element: Self::Item
) -> IntersperseWith<Self, IntersperseElementSimple<Self::Item>>ⓘ
Notable traits for IntersperseWith<I, ElemF>
impl<I, ElemF> Iterator for IntersperseWith<I, ElemF> where
I: Iterator,
ElemF: IntersperseElement<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
Self::Item: Clone,
pub fn intersperse_with<F>(self, element: F) -> IntersperseWith<Self, F>ⓘNotable traits for IntersperseWith<I, ElemF>
impl<I, ElemF> Iterator for IntersperseWith<I, ElemF> where
I: Iterator,
ElemF: IntersperseElement<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
F: FnMut() -> Self::Item,
[src]
Notable traits for IntersperseWith<I, ElemF>
impl<I, ElemF> Iterator for IntersperseWith<I, ElemF> where
I: Iterator,
ElemF: IntersperseElement<<I as Iterator>::Item>, type Item = <I as Iterator>::Item;
F: FnMut() -> Self::Item,
pub fn zip_longest<J>(
self,
other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>ⓘNotable traits for ZipLongest<T, U>
impl<T, U> Iterator for ZipLongest<T, U> where
T: Iterator,
U: Iterator, type Item = EitherOrBoth<<T as Iterator>::Item, <U as Iterator>::Item>;
where
J: IntoIterator,
[src]
self,
other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>ⓘ
Notable traits for ZipLongest<T, U>
impl<T, U> Iterator for ZipLongest<T, U> where
T: Iterator,
U: Iterator, type Item = EitherOrBoth<<T as Iterator>::Item, <U as Iterator>::Item>;
J: IntoIterator,
pub fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>ⓘ where
J: IntoIterator,
[src]
J: IntoIterator,
pub fn batching<B, F>(self, f: F) -> Batching<Self, F>ⓘ where
F: FnMut(&mut Self) -> Option<B>,
[src]
F: FnMut(&mut Self) -> Option<B>,
pub fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F> where
F: FnMut(&Self::Item) -> K,
K: PartialEq<K>,
[src]
F: FnMut(&Self::Item) -> K,
K: PartialEq<K>,
pub fn chunks(self, size: usize) -> IntoChunks<Self>
[src]
pub fn tuple_windows<T>(self) -> TupleWindows<Self, T>ⓘNotable traits for TupleWindows<I, T>
impl<I, T> Iterator for TupleWindows<I, T> where
T: HomogeneousTuple + Clone,
I: Iterator<Item = <T as TupleCollect>::Item>,
<T as TupleCollect>::Item: Clone, type Item = T;
where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
<T as TupleCollect>::Item: Clone,
[src]
Notable traits for TupleWindows<I, T>
impl<I, T> Iterator for TupleWindows<I, T> where
T: HomogeneousTuple + Clone,
I: Iterator<Item = <T as TupleCollect>::Item>,
<T as TupleCollect>::Item: Clone, type Item = T;
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
<T as TupleCollect>::Item: Clone,
pub fn circular_tuple_windows<T>(self) -> CircularTupleWindows<Self, T>ⓘNotable traits for CircularTupleWindows<I, T>
impl<I, T> Iterator for CircularTupleWindows<I, T> where
T: TupleCollect + Clone,
I: Iterator<Item = <T as TupleCollect>::Item> + Clone,
<T as TupleCollect>::Item: Clone, type Item = T;
where
Self: Clone + Iterator<Item = <T as TupleCollect>::Item> + ExactSizeIterator,
T: TupleCollect + Clone,
<T as TupleCollect>::Item: Clone,
[src]
Notable traits for CircularTupleWindows<I, T>
impl<I, T> Iterator for CircularTupleWindows<I, T> where
T: TupleCollect + Clone,
I: Iterator<Item = <T as TupleCollect>::Item> + Clone,
<T as TupleCollect>::Item: Clone, type Item = T;
Self: Clone + Iterator<Item = <T as TupleCollect>::Item> + ExactSizeIterator,
T: TupleCollect + Clone,
<T as TupleCollect>::Item: Clone,
pub fn tuples<T>(self) -> Tuples<Self, T>ⓘ where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
[src]
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
pub fn tee(self) -> (Tee<Self>, Tee<Self>) where
Self::Item: Clone,
[src]
Self::Item: Clone,
pub fn step(self, n: usize) -> Step<Self>ⓘ
[src]
pub fn map_into<R>(self) -> MapSpecialCase<Self, MapSpecialCaseFnInto<R>> where
Self::Item: Into<R>,
[src]
Self::Item: Into<R>,
pub fn map_results<F, T, U, E>(
self,
f: F
) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>> where
Self: Iterator<Item = Result<T, E>>,
F: FnMut(T) -> U,
[src]
self,
f: F
) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>> where
Self: Iterator<Item = Result<T, E>>,
F: FnMut(T) -> U,
pub fn map_ok<F, T, U, E>(
self,
f: F
) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>> where
Self: Iterator<Item = Result<T, E>>,
F: FnMut(T) -> U,
[src]
self,
f: F
) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>> where
Self: Iterator<Item = Result<T, E>>,
F: FnMut(T) -> U,
pub fn filter_ok<F, T, E>(self, f: F) -> FilterOk<Self, F>ⓘ where
Self: Iterator<Item = Result<T, E>>,
F: FnMut(&T) -> bool,
[src]
Self: Iterator<Item = Result<T, E>>,
F: FnMut(&T) -> bool,
pub fn filter_map_ok<F, T, U, E>(self, f: F) -> FilterMapOk<Self, F>ⓘNotable traits for FilterMapOk<I, F>
impl<I, F, T, U, E> Iterator for FilterMapOk<I, F> where
F: FnMut(T) -> Option<U>,
I: Iterator<Item = Result<T, E>>, type Item = Result<U, E>;
where
Self: Iterator<Item = Result<T, E>>,
F: FnMut(T) -> Option<U>,
[src]
Notable traits for FilterMapOk<I, F>
impl<I, F, T, U, E> Iterator for FilterMapOk<I, F> where
F: FnMut(T) -> Option<U>,
I: Iterator<Item = Result<T, E>>, type Item = Result<U, E>;
Self: Iterator<Item = Result<T, E>>,
F: FnMut(T) -> Option<U>,
pub fn merge<J>(
self,
other: J
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>ⓘ where
J: IntoIterator<Item = Self::Item>,
Self::Item: PartialOrd<Self::Item>,
[src]
self,
other: J
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>ⓘ where
J: IntoIterator<Item = Self::Item>,
Self::Item: PartialOrd<Self::Item>,
pub fn merge_by<J, F>(
self,
other: J,
is_first: F
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>ⓘ where
F: FnMut(&Self::Item, &Self::Item) -> bool,
J: IntoIterator<Item = Self::Item>,
[src]
self,
other: J,
is_first: F
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>ⓘ where
F: FnMut(&Self::Item, &Self::Item) -> bool,
J: IntoIterator<Item = Self::Item>,
pub fn merge_join_by<J, F>(
self,
other: J,
cmp_fn: F
) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>ⓘ where
F: FnMut(&Self::Item, &<J as IntoIterator>::Item) -> Ordering,
J: IntoIterator,
[src]
self,
other: J,
cmp_fn: F
) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>ⓘ where
F: FnMut(&Self::Item, &<J as IntoIterator>::Item) -> Ordering,
J: IntoIterator,
pub fn kmerge(
self
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt>ⓘ where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: PartialOrd<<Self::Item as IntoIterator>::Item>,
[src]
self
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt>ⓘ where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: PartialOrd<<Self::Item as IntoIterator>::Item>,
pub fn kmerge_by<F>(
self,
first: F
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F>ⓘ where
F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,
Self::Item: IntoIterator,
[src]
self,
first: F
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F>ⓘ where
F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,
Self::Item: IntoIterator,
pub fn cartesian_product<J>(
self,
other: J
) -> Product<Self, <J as IntoIterator>::IntoIter>ⓘ where
J: IntoIterator,
Self::Item: Clone,
<J as IntoIterator>::IntoIter: Clone,
[src]
self,
other: J
) -> Product<Self, <J as IntoIterator>::IntoIter>ⓘ where
J: IntoIterator,
Self::Item: Clone,
<J as IntoIterator>::IntoIter: Clone,
pub fn multi_cartesian_product(
self
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>ⓘ where
Self: Iterator,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::IntoIter: Clone,
<Self::Item as IntoIterator>::Item: Clone,
[src]
self
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>ⓘ where
Self: Iterator,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::IntoIter: Clone,
<Self::Item as IntoIterator>::Item: Clone,
pub fn coalesce<F>(self, f: F) -> CoalesceBy<Self, F, Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,
[src]
F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,
pub fn dedup(
self
) -> CoalesceBy<Self, DedupPred2CoalescePred<DedupEq>, Self::Item> where
Self::Item: PartialEq<Self::Item>,
[src]
self
) -> CoalesceBy<Self, DedupPred2CoalescePred<DedupEq>, Self::Item> where
Self::Item: PartialEq<Self::Item>,
pub fn dedup_by<Cmp>(
self,
cmp: Cmp
) -> CoalesceBy<Self, DedupPred2CoalescePred<Cmp>, Self::Item> where
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
[src]
self,
cmp: Cmp
) -> CoalesceBy<Self, DedupPred2CoalescePred<Cmp>, Self::Item> where
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
pub fn dedup_with_count(
self
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<DedupEq>, (usize, Self::Item)>
[src]
self
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<DedupEq>, (usize, Self::Item)>
pub fn dedup_by_with_count<Cmp>(
self,
cmp: Cmp
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<Cmp>, (usize, Self::Item)> where
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
[src]
self,
cmp: Cmp
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<Cmp>, (usize, Self::Item)> where
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
pub fn unique(self) -> Unique<Self>ⓘ where
Self::Item: Clone,
Self::Item: Eq,
Self::Item: Hash,
[src]
Self::Item: Clone,
Self::Item: Eq,
Self::Item: Hash,
pub fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>ⓘ where
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
[src]
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
pub fn peeking_take_while<F>(
&mut self,
accept: F
) -> PeekingTakeWhile<'_, Self, F>ⓘNotable traits for PeekingTakeWhile<'a, I, F>
impl<'a, I, F> Iterator for PeekingTakeWhile<'a, I, F> where
F: FnMut(&<I as Iterator>::Item) -> bool,
I: PeekingNext, type Item = <I as Iterator>::Item;
where
Self: PeekingNext,
F: FnMut(&Self::Item) -> bool,
[src]
&mut self,
accept: F
) -> PeekingTakeWhile<'_, Self, F>ⓘ
Notable traits for PeekingTakeWhile<'a, I, F>
impl<'a, I, F> Iterator for PeekingTakeWhile<'a, I, F> where
F: FnMut(&<I as Iterator>::Item) -> bool,
I: PeekingNext, type Item = <I as Iterator>::Item;
Self: PeekingNext,
F: FnMut(&Self::Item) -> bool,
pub fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>ⓘ where
Self: Clone,
F: FnMut(&Self::Item) -> bool,
[src]
Self: Clone,
F: FnMut(&Self::Item) -> bool,
pub fn while_some<A>(self) -> WhileSome<Self>ⓘ where
Self: Iterator<Item = Option<A>>,
[src]
Self: Iterator<Item = Option<A>>,
pub fn tuple_combinations<T>(self) -> TupleCombinations<Self, T>ⓘNotable traits for TupleCombinations<I, T>
impl<I, T> Iterator for TupleCombinations<I, T> where
T: HasCombination<I>,
I: Iterator, type Item = T;
where
Self: Clone,
T: HasCombination<Self>,
Self::Item: Clone,
[src]
Notable traits for TupleCombinations<I, T>
impl<I, T> Iterator for TupleCombinations<I, T> where
T: HasCombination<I>,
I: Iterator, type Item = T;
Self: Clone,
T: HasCombination<Self>,
Self::Item: Clone,
pub fn combinations(self, k: usize) -> Combinations<Self>ⓘ where
Self::Item: Clone,
[src]
Self::Item: Clone,
pub fn combinations_with_replacement(
self,
k: usize
) -> CombinationsWithReplacement<Self>ⓘ where
Self::Item: Clone,
[src]
self,
k: usize
) -> CombinationsWithReplacement<Self>ⓘ where
Self::Item: Clone,
pub fn permutations(self, k: usize) -> Permutations<Self>ⓘ where
Self::Item: Clone,
[src]
Self::Item: Clone,
pub fn powerset(self) -> Powerset<Self>ⓘ where
Self::Item: Clone,
[src]
Self::Item: Clone,
pub fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>ⓘ where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
pub fn with_position(self) -> WithPosition<Self>ⓘNotable traits for WithPosition<I>
impl<I> Iterator for WithPosition<I> where
I: Iterator, type Item = Position<<I as Iterator>::Item>;
[src]
Notable traits for WithPosition<I>
impl<I> Iterator for WithPosition<I> where
I: Iterator, type Item = Position<<I as Iterator>::Item>;
pub fn positions<P>(self, predicate: P) -> Positions<Self, P>ⓘ where
P: FnMut(Self::Item) -> bool,
[src]
P: FnMut(Self::Item) -> bool,
pub fn update<F>(self, updater: F) -> Update<Self, F>ⓘ where
F: FnMut(&mut Self::Item),
[src]
F: FnMut(&mut Self::Item),
pub fn next_tuple<T>(&mut self) -> Option<T> where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
[src]
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
pub fn collect_tuple<T>(self) -> Option<T> where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
[src]
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
pub fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)> where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
pub fn all_equal(&mut self) -> bool where
Self::Item: PartialEq<Self::Item>,
[src]
Self::Item: PartialEq<Self::Item>,
pub fn dropping(self, n: usize) -> Self
[src]
pub fn dropping_back(self, n: usize) -> Self where
Self: DoubleEndedIterator,
[src]
Self: DoubleEndedIterator,
pub fn foreach<F>(self, f: F) where
F: FnMut(Self::Item),
[src]
F: FnMut(Self::Item),
pub fn concat(self) -> Self::Item where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
[src]
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
pub fn collect_vec(self) -> Vec<Self::Item, Global>ⓘ
[src]
pub fn try_collect<T, U, E>(self) -> Result<U, E> where
Self: Iterator<Item = Result<T, E>>,
Result<U, E>: FromIterator<Result<T, E>>,
[src]
Self: Iterator<Item = Result<T, E>>,
Result<U, E>: FromIterator<Result<T, E>>,
pub fn set_from<'a, A, J>(&mut self, from: J) -> usize where
Self: Iterator<Item = &'a mut A>,
A: 'a,
J: IntoIterator<Item = A>,
[src]
Self: Iterator<Item = &'a mut A>,
A: 'a,
J: IntoIterator<Item = A>,
pub fn join(&mut self, sep: &str) -> String where
Self::Item: Display,
[src]
Self::Item: Display,
pub fn format(self, sep: &str) -> Format<'_, Self>
[src]
pub fn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F> where
F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display)) -> Result<(), Error>,
[src]
F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display)) -> Result<(), Error>,
pub 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,
[src]
Self: Iterator<Item = Result<A, E>>,
F: FnMut(B, A) -> B,
pub 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,
[src]
Self: Iterator<Item = Result<A, E>>,
F: FnMut(B, A) -> B,
pub 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,
[src]
Self: Iterator<Item = Option<A>>,
F: FnMut(B, A) -> B,
pub fn fold1<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
[src]
F: FnMut(Self::Item, Self::Item) -> Self::Item,
pub fn tree_fold1<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
[src]
F: FnMut(Self::Item, Self::Item) -> Self::Item,
pub fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B> where
F: FnMut(B, Self::Item) -> FoldWhile<B>,
[src]
F: FnMut(B, Self::Item) -> FoldWhile<B>,
pub fn sum1<S>(self) -> Option<S> where
S: Sum<Self::Item>,
[src]
S: Sum<Self::Item>,
pub fn product1<P>(self) -> Option<P> where
P: Product<Self::Item>,
[src]
P: Product<Self::Item>,
pub fn sorted_unstable(self) -> IntoIter<Self::Item, Global>ⓘ where
Self::Item: Ord,
[src]
Self::Item: Ord,
pub fn sorted_unstable_by<F>(self, cmp: F) -> IntoIter<Self::Item, Global>ⓘ where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
pub fn sorted_unstable_by_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>ⓘ where
F: FnMut(&Self::Item) -> K,
K: Ord,
[src]
F: FnMut(&Self::Item) -> K,
K: Ord,
pub fn sorted(self) -> IntoIter<Self::Item, Global>ⓘ where
Self::Item: Ord,
[src]
Self::Item: Ord,
pub fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item, Global>ⓘ where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
pub fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>ⓘ where
F: FnMut(&Self::Item) -> K,
K: Ord,
[src]
F: FnMut(&Self::Item) -> K,
K: Ord,
pub fn k_smallest(self, k: usize) -> IntoIter<Self::Item, Global>ⓘ where
Self::Item: Ord,
[src]
Self::Item: Ord,
pub fn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B) where
B: Default + Extend<R>,
A: Default + Extend<L>,
F: FnMut(Self::Item) -> Either<L, R>,
[src]
B: Default + Extend<R>,
A: Default + Extend<L>,
F: FnMut(Self::Item) -> Either<L, R>,
pub fn into_group_map<K, V>(self) -> HashMap<K, Vec<V, Global>, RandomState> where
Self: Iterator<Item = (K, V)>,
K: Hash + Eq,
[src]
Self: Iterator<Item = (K, V)>,
K: Hash + Eq,
pub fn into_group_map_by<K, V, F>(
self,
f: F
) -> HashMap<K, Vec<V, Global>, RandomState> where
Self: Iterator<Item = V>,
F: Fn(&V) -> K,
K: Hash + Eq,
[src]
self,
f: F
) -> HashMap<K, Vec<V, Global>, RandomState> where
Self: Iterator<Item = V>,
F: Fn(&V) -> K,
K: Hash + Eq,
pub fn into_grouping_map<K, V>(self) -> GroupingMap<Self> where
Self: Iterator<Item = (K, V)>,
K: Hash + Eq,
[src]
Self: Iterator<Item = (K, V)>,
K: Hash + Eq,
pub fn into_grouping_map_by<K, V, F>(
self,
key_mapper: F
) -> GroupingMap<MapForGrouping<Self, F>> where
Self: Iterator<Item = V>,
F: FnMut(&V) -> K,
K: Hash + Eq,
[src]
self,
key_mapper: F
) -> GroupingMap<MapForGrouping<Self, F>> where
Self: Iterator<Item = V>,
F: FnMut(&V) -> K,
K: Hash + Eq,
pub fn minmax(self) -> MinMaxResult<Self::Item> where
Self::Item: PartialOrd<Self::Item>,
[src]
Self::Item: PartialOrd<Self::Item>,
pub fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item> where
F: FnMut(&Self::Item) -> K,
K: PartialOrd<K>,
[src]
F: FnMut(&Self::Item) -> K,
K: PartialOrd<K>,
pub fn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
pub fn position_max(self) -> Option<usize> where
Self::Item: Ord,
[src]
Self::Item: Ord,
pub fn position_max_by_key<K, F>(self, key: F) -> Option<usize> where
F: FnMut(&Self::Item) -> K,
K: Ord,
[src]
F: FnMut(&Self::Item) -> K,
K: Ord,
pub fn position_max_by<F>(self, compare: F) -> Option<usize> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
pub fn position_min(self) -> Option<usize> where
Self::Item: Ord,
[src]
Self::Item: Ord,
pub fn position_min_by_key<K, F>(self, key: F) -> Option<usize> where
F: FnMut(&Self::Item) -> K,
K: Ord,
[src]
F: FnMut(&Self::Item) -> K,
K: Ord,
pub fn position_min_by<F>(self, compare: F) -> Option<usize> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
pub fn position_minmax(self) -> MinMaxResult<usize> where
Self::Item: PartialOrd<Self::Item>,
[src]
Self::Item: PartialOrd<Self::Item>,
pub fn position_minmax_by_key<K, F>(self, key: F) -> MinMaxResult<usize> where
F: FnMut(&Self::Item) -> K,
K: PartialOrd<K>,
[src]
F: FnMut(&Self::Item) -> K,
K: PartialOrd<K>,
pub fn position_minmax_by<F>(self, compare: F) -> MinMaxResult<usize> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
pub fn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>>
[src]
pub fn multipeek(self) -> MultiPeek<Self>ⓘ
[src]
pub fn counts(self) -> HashMap<Self::Item, usize, RandomState> where
Self::Item: Eq,
Self::Item: Hash,
[src]
Self::Item: Eq,
Self::Item: Hash,
impl<S, T> ProgressIterator for T where
T: Iterator<Item = S>,
T: Iterator<Item = S>,
pub fn progress_with(self, progress: ProgressBar) -> ProgressBarIter<T>ⓘ
pub fn progress(self) -> ProgressBarIter<Self>ⓘ
pub fn progress_count(self, len: u64) -> ProgressBarIter<Self>ⓘ
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<I> UnicodeNormalization<I> for I where
I: Iterator<Item = char>,
I: Iterator<Item = char>,
pub fn nfd(self) -> Decompositions<I>ⓘ
pub fn nfkd(self) -> Decompositions<I>ⓘ
pub fn nfc(self) -> Recompositions<I>ⓘ
pub fn nfkc(self) -> Recompositions<I>ⓘ
pub fn stream_safe(self) -> StreamSafe<I>ⓘ
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,