1.0.0[−][src]Struct tract_nnef::internal::tract_downcast_rs::__std::env::Args
An iterator over the arguments of a process, yielding a String
value for
each argument.
This struct is created by the std::env::args
function. See its
documentation for more.
The first element is traditionally the path of the executable, but it can be set to arbitrary text, and may not even exist. This means this property should not be relied upon for security purposes.
Trait Implementations
impl Debug for Args
1.16.0[src]
impl DoubleEndedIterator for Args
1.12.0[src]
fn next_back(&mut self) -> Option<String>
[src]
fn nth_back(&mut self, n: usize) -> Option<Self::Item>
1.37.0[src]
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
1.27.0[src]
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
fn rfold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
1.27.0[src]
F: FnMut(B, Self::Item) -> B,
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 ExactSizeIterator for Args
[src]
impl Iterator for Args
[src]
type Item = String
The type of the elements being iterated over.
fn next(&mut self) -> Option<String>
[src]
fn size_hint(&self) -> (usize, Option<usize>)
[src]
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 W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
#[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_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
1.27.0[src]
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
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<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
[src]
F: FnMut(B, Self::Item) -> B,
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>,
impl !Send for Args
1.26.0[src]
impl !Sync for Args
1.26.0[src]
Auto Trait Implementations
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 W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<T> Downcast for T where
T: Any,
T: Any,
fn into_any(self: Box<T>) -> Box<dyn Any + 'static>ⓘNotable traits for Box<W>
impl<W> Write for Box<W> where
W: Write + ?Sized, impl<R> Read for Box<R> where
R: Read + ?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<W>
impl<W> Write for Box<W> where
W: Write + ?Sized, impl<R> Read for Box<R> where
R: Read + ?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> 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, 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>,