1.0.0[−][src]Struct tract_hir::prelude::tract_itertools::__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,
fn next_back(&mut self) -> Option<B>
[src]
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,
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,
fn nth_back(&mut self, n: usize) -> Option<Self::Item>
1.37.0[src]
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> 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.
fn next(&mut self) -> Option<B>
[src]
fn size_hint(&self) -> (usize, Option<usize>)
[src]
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,
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,
unsafe fn get_unchecked(&mut self, idx: usize) -> B where
Map<I, F>: TrustedRandomAccess,
[src]
Map<I, F>: TrustedRandomAccess,
fn count(self) -> usize
[src]
fn last(self) -> Option<Self::Item>
[src]
fn nth(&mut self, n: usize) -> Option<Self::Item>
[src]
fn step_by(self, step: usize) -> StepBy<Self>ⓘ
1.28.0[src]
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>ⓘ where
U: IntoIterator<Item = Self::Item>,
[src]
U: IntoIterator<Item = Self::Item>,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>ⓘ where
U: IntoIterator,
[src]
U: IntoIterator,
fn map<B, F>(self, f: F) -> Map<Self, F>ⓘ where
F: FnMut(Self::Item) -> B,
[src]
F: FnMut(Self::Item) -> B,
fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
1.21.0[src]
F: FnMut(Self::Item),
fn filter<P>(self, predicate: P) -> Filter<Self, P>ⓘ where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
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>,
fn enumerate(self) -> Enumerate<Self>ⓘ
[src]
fn peekable(self) -> Peekable<Self>ⓘ
[src]
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>ⓘ where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>ⓘ where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
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>,
fn skip(self, n: usize) -> Skip<Self>ⓘ
[src]
fn take(self, n: usize) -> Take<Self>ⓘ
[src]
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>,
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,
fn flatten(self) -> Flatten<Self>ⓘ where
Self::Item: IntoIterator,
1.29.0[src]
Self::Item: IntoIterator,
fn fuse(self) -> Fuse<Self>ⓘ
[src]
fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘ where
F: FnMut(&Self::Item),
[src]
F: FnMut(&Self::Item),
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"]fn collect<B>(self) -> B where
B: FromIterator<Self::Item>,
[src]
B: FromIterator<Self::Item>,
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,
fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
P: FnMut(&T) -> bool,
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
[src]
P: FnMut(&T) -> bool,
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]
P: FnMut(Self::Item) -> bool,
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 = ()>,
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,
fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
[src]
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
[src]
F: FnMut(Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
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>,
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>,
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
[src]
P: FnMut(Self::Item) -> bool,
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
[src]
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
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,
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,
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,
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,
fn rev(self) -> Rev<Self>ⓘ where
Self: DoubleEndedIterator,
[src]
Self: DoubleEndedIterator,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
[src]
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
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,
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,
fn cycle(self) -> Cycle<Self>ⓘ where
Self: Clone,
[src]
Self: Clone,
fn sum<S>(self) -> S where
S: Sum<Self::Item>,
1.11.0[src]
S: Sum<Self::Item>,
fn product<P>(self) -> P where
P: Product<Self::Item>,
1.11.0[src]
P: Product<Self::Item>,
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,
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,
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>,
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,
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>,
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,
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>,
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>,
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>,
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>,
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>,
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]
Self::Item: PartialOrd<Self::Item>,
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>,
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>,
Auto Trait Implementations
impl<I, F> RefUnwindSafe for Map<I, F> where
F: RefUnwindSafe,
I: RefUnwindSafe,
F: RefUnwindSafe,
I: RefUnwindSafe,
impl<I, F> Send for Map<I, F> where
F: Send,
I: Send,
F: Send,
I: Send,
impl<I, F> Sync for Map<I, F> where
F: Sync,
I: Sync,
F: Sync,
I: Sync,
impl<I, F> Unpin for Map<I, F> where
F: Unpin,
I: Unpin,
F: Unpin,
I: Unpin,
impl<I, F> UnwindSafe for Map<I, F> where
F: UnwindSafe,
I: UnwindSafe,
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,
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,
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> Downcast for T where
T: Any,
T: Any,
fn into_any(self: Box<T>) -> Box<dyn Any + 'static>ⓘNotable traits for Box<R>
impl<R> Read for Box<R> where
R: Read + ?Sized, impl<W> Write for Box<W> where
W: Write + ?Sized, impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
Notable traits for Box<R>
impl<R> Read for Box<R> where
R: Read + ?Sized, impl<W> Write for Box<W> where
W: Write + ?Sized, impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
fn as_any(&self) -> &(dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
impl<T> DowncastSync for T where
T: Send + Sync + Any,
T: Send + Sync + Any,
impl<T> DynClone for T where
T: Clone,
[src]
T: Clone,
impl<T> From<T> for T
[src]
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?
fn into_iter(self) -> I
[src]
impl<T> Itertools for T where
T: Iterator + ?Sized,
[src]
T: Iterator + ?Sized,
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>,
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>,
fn intersperse(self, element: 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,
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,
fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>ⓘ where
J: IntoIterator,
[src]
J: IntoIterator,
fn batching<B, F>(self, f: F) -> Batching<Self, F>ⓘ where
F: FnMut(&mut Self) -> Option<B>,
[src]
F: FnMut(&mut Self) -> Option<B>,
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>,
fn chunks(self, size: usize) -> IntoChunks<Self>
[src]
fn tuple_windows<T>(self) -> TupleWindows<Self, T>ⓘNotable traits for TupleWindows<I, T>
impl<I, T> Iterator for TupleWindows<I, T> where
I: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple + Clone,
<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
I: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple + Clone,
<T as TupleCollect>::Item: Clone, type Item = T;
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
<T as TupleCollect>::Item: Clone,
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,
fn tee(self) -> (Tee<Self>, Tee<Self>) where
Self::Item: Clone,
[src]
Self::Item: Clone,
fn step(self, n: usize) -> Step<Self>ⓘ
[src]
fn map_into<R>(self) -> MapInto<Self, R>ⓘ where
Self::Item: Into<R>,
[src]
Self::Item: Into<R>,
fn map_results<F, T, U, E>(self, f: F) -> MapResults<Self, F>ⓘNotable traits for MapResults<I, F>
impl<I, F, T, U, E> Iterator for MapResults<I, F> where
F: FnMut(T) -> U,
I: Iterator<Item = Result<T, E>>, type Item = Result<U, E>;
where
F: FnMut(T) -> U,
Self: Iterator<Item = Result<T, E>>,
[src]
Notable traits for MapResults<I, F>
impl<I, F, T, U, E> Iterator for MapResults<I, F> where
F: FnMut(T) -> U,
I: Iterator<Item = Result<T, E>>, type Item = Result<U, E>;
F: FnMut(T) -> U,
Self: Iterator<Item = Result<T, E>>,
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>,
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>,
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,
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::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: PartialOrd<<Self::Item as IntoIterator>::Item>,
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,
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,
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,
fn coalesce<F>(self, f: F) -> Coalesce<Self, F>ⓘ 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)>,
fn dedup(self) -> DedupBy<Self, DedupEq>ⓘ where
Self::Item: PartialEq<Self::Item>,
[src]
Self::Item: PartialEq<Self::Item>,
fn dedup_by<Cmp>(self, cmp: Cmp) -> DedupBy<Self, Cmp>ⓘ where
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
[src]
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
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,
fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>ⓘ where
F: FnMut(&Self::Item) -> V,
V: Eq + Hash,
[src]
F: FnMut(&Self::Item) -> V,
V: Eq + Hash,
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
F: FnMut(&Self::Item) -> bool,
Self: PeekingNext,
[src]
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;
F: FnMut(&Self::Item) -> bool,
Self: PeekingNext,
fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>ⓘ where
F: FnMut(&Self::Item) -> bool,
Self: Clone,
[src]
F: FnMut(&Self::Item) -> bool,
Self: Clone,
fn while_some<A>(self) -> WhileSome<Self>ⓘ where
Self: Iterator<Item = Option<A>>,
[src]
Self: Iterator<Item = Option<A>>,
fn tuple_combinations<T>(self) -> TupleCombinations<Self, T>ⓘNotable traits for TupleCombinations<I, T>
impl<I, T> Iterator for TupleCombinations<I, T> where
I: Iterator,
T: HasCombination<I>, 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
I: Iterator,
T: HasCombination<I>, type Item = T;
Self: Clone,
T: HasCombination<Self>,
Self::Item: Clone,
fn combinations(self, k: usize) -> Combinations<Self>ⓘ where
Self::Item: Clone,
[src]
Self::Item: Clone,
fn combinations_with_replacement(
self,
k: usize
) -> CombinationsWithReplacement<Self>ⓘ where
Self::Item: Clone,
[src]
self,
k: usize
) -> CombinationsWithReplacement<Self>ⓘ where
Self::Item: Clone,
fn permutations(self, k: usize) -> Permutations<Self>ⓘ where
Self::Item: Clone,
[src]
Self::Item: Clone,
fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>ⓘ where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
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>;
fn positions<P>(self, predicate: P) -> Positions<Self, P>ⓘ where
P: FnMut(Self::Item) -> bool,
[src]
P: FnMut(Self::Item) -> bool,
fn update<F>(self, updater: F) -> Update<Self, F>ⓘ where
F: FnMut(&mut Self::Item),
[src]
F: FnMut(&mut Self::Item),
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,
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,
fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)> where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
fn all_equal(&mut self) -> bool where
Self::Item: PartialEq<Self::Item>,
[src]
Self::Item: PartialEq<Self::Item>,
fn dropping(self, n: usize) -> Self
[src]
fn dropping_back(self, n: usize) -> Self where
Self: DoubleEndedIterator,
[src]
Self: DoubleEndedIterator,
fn foreach<F>(self, f: F) where
F: FnMut(Self::Item),
[src]
F: FnMut(Self::Item),
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,
fn collect_vec(self) -> Vec<Self::Item>ⓘ
[src]
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>>,
fn set_from<'a, A, J>(&mut self, from: J) -> usize where
A: 'a,
J: IntoIterator<Item = A>,
Self: Iterator<Item = &'a mut A>,
[src]
A: 'a,
J: IntoIterator<Item = A>,
Self: Iterator<Item = &'a mut A>,
fn join(&mut self, sep: &str) -> String where
Self::Item: Display,
[src]
Self::Item: Display,
fn format(self, sep: &str) -> Format<'_, Self>
[src]
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>,
fn fold_results<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E> where
F: FnMut(B, A) -> B,
Self: Iterator<Item = Result<A, E>>,
[src]
F: FnMut(B, A) -> B,
Self: Iterator<Item = Result<A, E>>,
fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option<B> where
F: FnMut(B, A) -> B,
Self: Iterator<Item = Option<A>>,
[src]
F: FnMut(B, A) -> B,
Self: Iterator<Item = Option<A>>,
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,
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,
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>,
fn sum1<S>(self) -> Option<S> where
S: Sum<Self::Item>,
[src]
S: Sum<Self::Item>,
fn product1<P>(self) -> Option<P> where
P: Product<Self::Item>,
[src]
P: Product<Self::Item>,
fn sorted(self) -> IntoIter<Self::Item>ⓘ where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item>ⓘ where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item>ⓘ where
F: FnMut(&Self::Item) -> K,
K: Ord,
[src]
F: FnMut(&Self::Item) -> K,
K: Ord,
fn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B) where
A: Default + Extend<L>,
B: Default + Extend<R>,
F: FnMut(Self::Item) -> Either<L, R>,
[src]
A: Default + Extend<L>,
B: Default + Extend<R>,
F: FnMut(Self::Item) -> Either<L, R>,
fn into_group_map<K, V>(self) -> HashMap<K, Vec<V>, RandomState> where
K: Hash + Eq,
Self: Iterator<Item = (K, V)>,
[src]
K: Hash + Eq,
Self: Iterator<Item = (K, V)>,
fn minmax(self) -> MinMaxResult<Self::Item> where
Self::Item: PartialOrd<Self::Item>,
[src]
Self::Item: PartialOrd<Self::Item>,
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>,
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,
fn position_max(self) -> Option<usize> where
Self::Item: Ord,
[src]
Self::Item: Ord,
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,
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,
fn position_min(self) -> Option<usize> where
Self::Item: Ord,
[src]
Self::Item: Ord,
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,
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,
fn position_minmax(self) -> MinMaxResult<usize> where
Self::Item: PartialOrd<Self::Item>,
[src]
Self::Item: PartialOrd<Self::Item>,
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>,
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,
fn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>>
[src]
impl<T> Itertools for T where
T: Iterator + ?Sized,
[src]
T: Iterator + ?Sized,
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>,
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>,
fn intersperse(self, element: 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,
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,
fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>ⓘ where
J: IntoIterator,
[src]
J: IntoIterator,
fn batching<B, F>(self, f: F) -> Batching<Self, F>ⓘ where
F: FnMut(&mut Self) -> Option<B>,
[src]
F: FnMut(&mut Self) -> Option<B>,
fn tuple_windows<T>(self) -> TupleWindows<Self, T>ⓘNotable traits for TupleWindows<I, T>
impl<I, T> Iterator for TupleWindows<I, T> where
I: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect + Clone,
<T as TupleCollect>::Item: Clone, type Item = T;
where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
<T as TupleCollect>::Item: Clone,
[src]
Notable traits for TupleWindows<I, T>
impl<I, T> Iterator for TupleWindows<I, T> where
I: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect + Clone,
<T as TupleCollect>::Item: Clone, type Item = T;
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
<T as TupleCollect>::Item: Clone,
fn tuples<T>(self) -> Tuples<Self, T>ⓘ where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
[src]
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
fn step(self, n: usize) -> Step<Self>ⓘ
[src]
fn map_into<R>(self) -> MapInto<Self, R>ⓘ where
Self::Item: Into<R>,
[src]
Self::Item: Into<R>,
fn map_results<F, T, U, E>(self, f: F) -> MapResults<Self, F>ⓘNotable traits for MapResults<I, F>
impl<I, F, T, U, E> Iterator for MapResults<I, F> where
F: FnMut(T) -> U,
I: Iterator<Item = Result<T, E>>, type Item = Result<U, E>;
where
F: FnMut(T) -> U,
Self: Iterator<Item = Result<T, E>>,
[src]
Notable traits for MapResults<I, F>
impl<I, F, T, U, E> Iterator for MapResults<I, F> where
F: FnMut(T) -> U,
I: Iterator<Item = Result<T, E>>, type Item = Result<U, E>;
F: FnMut(T) -> U,
Self: Iterator<Item = Result<T, E>>,
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>,
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>,
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,
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,
fn coalesce<F>(self, f: F) -> Coalesce<Self, F>ⓘ 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)>,
fn dedup(self) -> DedupBy<Self, DedupEq>ⓘ where
Self::Item: PartialEq<Self::Item>,
[src]
Self::Item: PartialEq<Self::Item>,
fn dedup_by<Cmp>(self, cmp: Cmp) -> DedupBy<Self, Cmp>ⓘ where
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
[src]
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
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
F: FnMut(&Self::Item) -> bool,
Self: PeekingNext,
[src]
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;
F: FnMut(&Self::Item) -> bool,
Self: PeekingNext,
fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>ⓘ where
F: FnMut(&Self::Item) -> bool,
Self: Clone,
[src]
F: FnMut(&Self::Item) -> bool,
Self: Clone,
fn while_some<A>(self) -> WhileSome<Self>ⓘ where
Self: Iterator<Item = Option<A>>,
[src]
Self: Iterator<Item = Option<A>>,
fn tuple_combinations<T>(self) -> TupleCombinations<Self, T>ⓘNotable traits for TupleCombinations<I, T>
impl<I, T> Iterator for TupleCombinations<I, T> where
I: Iterator,
T: HasCombination<I>, 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
I: Iterator,
T: HasCombination<I>, type Item = T;
Self: Clone,
T: HasCombination<Self>,
Self::Item: Clone,
fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>ⓘ where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
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>;
fn positions<P>(self, predicate: P) -> Positions<Self, P>ⓘ where
P: FnMut(Self::Item) -> bool,
[src]
P: FnMut(Self::Item) -> bool,
fn update<F>(self, updater: F) -> Update<Self, F>ⓘ where
F: FnMut(&mut Self::Item),
[src]
F: FnMut(&mut Self::Item),
fn next_tuple<T>(&mut self) -> Option<T> where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
[src]
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
fn collect_tuple<T>(self) -> Option<T> where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
[src]
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)> where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
fn all_equal(&mut self) -> bool where
Self::Item: PartialEq<Self::Item>,
[src]
Self::Item: PartialEq<Self::Item>,
fn dropping(self, n: usize) -> Self
[src]
fn dropping_back(self, n: usize) -> Self where
Self: DoubleEndedIterator,
[src]
Self: DoubleEndedIterator,
fn foreach<F>(self, f: F) where
F: FnMut(Self::Item),
[src]
F: FnMut(Self::Item),
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,
fn set_from<'a, A, J>(&mut self, from: J) -> usize where
A: 'a,
J: IntoIterator<Item = A>,
Self: Iterator<Item = &'a mut A>,
[src]
A: 'a,
J: IntoIterator<Item = A>,
Self: Iterator<Item = &'a mut A>,
fn format(self, sep: &str) -> Format<'_, Self>
[src]
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>,
fn fold_results<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E> where
F: FnMut(B, A) -> B,
Self: Iterator<Item = Result<A, E>>,
[src]
F: FnMut(B, A) -> B,
Self: Iterator<Item = Result<A, E>>,
fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option<B> where
F: FnMut(B, A) -> B,
Self: Iterator<Item = Option<A>>,
[src]
F: FnMut(B, A) -> B,
Self: Iterator<Item = Option<A>>,
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,
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,
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>,
fn sum1<S>(self) -> Option<S> where
S: Sum<Self::Item>,
[src]
S: Sum<Self::Item>,
fn product1<P>(self) -> Option<P> where
P: Product<Self::Item>,
[src]
P: Product<Self::Item>,
fn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B) where
A: Default + Extend<L>,
B: Default + Extend<R>,
F: FnMut(Self::Item) -> Either<L, R>,
[src]
A: Default + Extend<L>,
B: Default + Extend<R>,
F: FnMut(Self::Item) -> Either<L, R>,
fn minmax(self) -> MinMaxResult<Self::Item> where
Self::Item: PartialOrd<Self::Item>,
[src]
Self::Item: PartialOrd<Self::Item>,
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>,
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,
fn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>>
[src]
impl<D, A, I> MaybeProduct<D> for I where
A: Borrow<D>,
D: DimLike,
I: Iterator<Item = A>,
[src]
A: Borrow<D>,
D: DimLike,
I: Iterator<Item = A>,
fn maybe_product(self) -> Result<D, TractError>
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
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.
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>,