Struct itertools::structs::ExactlyOneError [−][src]
Iterator returned for the error case of IterTools::exactly_one()
This iterator yields exactly the same elements as the input iterator.
During the execution of exactly_one the iterator must be mutated. This wrapper effectively “restores” the state of the input iterator when it’s handed back.
This is very similar to PutBackN except this iterator only supports 0-2 elements and does not
use a Vec
.
Trait Implementations
impl<I: Clone> Clone for ExactlyOneError<I> where
I: Iterator,
I::Item: Clone,
I::Item: Clone,
[src]
I: Iterator,
I::Item: Clone,
I::Item: Clone,
fn clone(&self) -> ExactlyOneError<I>ⓘNotable traits for ExactlyOneError<I>
impl<I> Iterator for ExactlyOneError<I> where
I: Iterator, type Item = I::Item;
[src]
Notable traits for ExactlyOneError<I>
impl<I> Iterator for ExactlyOneError<I> where
I: Iterator, type Item = I::Item;
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<I> Debug for ExactlyOneError<I> where
I: Iterator + Debug,
I::Item: Debug,
[src]
I: Iterator + Debug,
I::Item: Debug,
impl<I> Display for ExactlyOneError<I> where
I: Iterator,
[src]
I: Iterator,
impl<I> Error for ExactlyOneError<I> where
I: Iterator + Debug,
I::Item: Debug,
[src]
I: Iterator + Debug,
I::Item: Debug,
pub fn source(&self) -> Option<&(dyn Error + 'static)>
1.30.0[src]
pub fn backtrace(&self) -> Option<&Backtrace>
[src]
pub fn description(&self) -> &str
1.0.0[src]
pub fn cause(&self) -> Option<&dyn Error>
1.0.0[src]
impl<I> ExactSizeIterator for ExactlyOneError<I> where
I: ExactSizeIterator,
[src]
I: ExactSizeIterator,
impl<I> Iterator for ExactlyOneError<I> where
I: Iterator,
[src]
I: Iterator,
type Item = I::Item
The type of the elements being iterated over.
fn next(&mut self) -> Option<Self::Item>
[src]
fn size_hint(&self) -> (usize, Option<usize>)
[src]
pub fn count(self) -> usize
1.0.0[src]
pub fn last(self) -> Option<Self::Item>
1.0.0[src]
pub fn advance_by(&mut self, n: usize) -> Result<(), usize>
[src]
pub fn nth(&mut self, n: usize) -> Option<Self::Item>
1.0.0[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>,
1.0.0[src]
U: IntoIterator<Item = Self::Item>,
pub fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator,
1.0.0[src]
U: IntoIterator,
pub fn intersperse(self, separator: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
Self::Item: Clone,
pub fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> where
G: FnMut() -> Self::Item,
[src]
G: FnMut() -> Self::Item,
pub fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,
1.0.0[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,
1.0.0[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>,
1.0.0[src]
F: FnMut(Self::Item) -> Option<B>,
pub fn enumerate(self) -> Enumerate<Self>
1.0.0[src]
pub fn peekable(self) -> Peekable<Self>
1.0.0[src]
pub fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
pub fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[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>
1.0.0[src]
pub fn take(self, n: usize) -> Take<Self>
1.0.0[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>,
1.0.0[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,
1.0.0[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>
1.0.0[src]
pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
1.0.0[src]
F: FnMut(&Self::Item),
pub fn by_ref(&mut self) -> &mut Self
1.0.0[src]
#[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>,
1.0.0[src]
B: FromIterator<Self::Item>,
pub fn partition<B, F>(self, f: F) -> (B, B) where
F: FnMut(&Self::Item) -> bool,
B: Default + Extend<Self::Item>,
1.0.0[src]
F: FnMut(&Self::Item) -> bool,
B: Default + Extend<Self::Item>,
pub fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
P: FnMut(&T) -> bool,
[src]
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
P: FnMut(&T) -> bool,
pub fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]
P: FnMut(Self::Item) -> bool,
pub 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>,
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<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
1.0.0[src]
F: FnMut(B, Self::Item) -> B,
pub fn reduce<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
1.51.0[src]
F: FnMut(Self::Item, Self::Item) -> Self::Item,
pub fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]
F: FnMut(Self::Item) -> bool,
pub fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]
F: FnMut(Self::Item) -> bool,
pub fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
1.0.0[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,
1.0.0[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,
1.0.0[src]
Self: ExactSizeIterator + DoubleEndedIterator,
P: FnMut(Self::Item) -> bool,
pub fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
Self::Item: Ord,
pub fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
Self::Item: Ord,
pub fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
B: Ord,
1.6.0[src]
F: FnMut(&Self::Item) -> B,
B: Ord,
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
F: FnMut(&Self::Item) -> B,
B: Ord,
1.6.0[src]
F: FnMut(&Self::Item) -> B,
B: Ord,
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,
1.0.0[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>,
1.0.0[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,
1.0.0[src]
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
pub fn cycle(self) -> Cycle<Self> where
Self: Clone,
1.0.0[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
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
[src]
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
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
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
[src]
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
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
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
[src]
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
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
K: PartialOrd<K>,
F: FnMut(Self::Item) -> K,
[src]
K: PartialOrd<K>,
F: FnMut(Self::Item) -> K,
Auto Trait Implementations
impl<I> RefUnwindSafe for ExactlyOneError<I> where
I: RefUnwindSafe,
<I as Iterator>::Item: RefUnwindSafe,
I: RefUnwindSafe,
<I as Iterator>::Item: RefUnwindSafe,
impl<I> Send for ExactlyOneError<I> where
I: Send,
<I as Iterator>::Item: Send,
I: Send,
<I as Iterator>::Item: Send,
impl<I> Sync for ExactlyOneError<I> where
I: Sync,
<I as Iterator>::Item: Sync,
I: Sync,
<I as Iterator>::Item: Sync,
impl<I> Unpin for ExactlyOneError<I> where
I: Unpin,
<I as Iterator>::Item: Unpin,
I: Unpin,
<I as Iterator>::Item: Unpin,
impl<I> UnwindSafe for ExactlyOneError<I> where
I: UnwindSafe,
<I as Iterator>::Item: UnwindSafe,
I: UnwindSafe,
<I as Iterator>::Item: 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,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
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?
pub 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::IntoIter>ⓘNotable traits for Interleave<I, J>
impl<I, J> Iterator for Interleave<I, J> where
I: Iterator,
J: Iterator<Item = I::Item>, type Item = I::Item;
where
J: IntoIterator<Item = Self::Item>,
Self: Sized,
[src]
Notable traits for Interleave<I, J>
impl<I, J> Iterator for Interleave<I, J> where
I: Iterator,
J: Iterator<Item = I::Item>, type Item = I::Item;
J: IntoIterator<Item = Self::Item>,
Self: Sized,
fn interleave_shortest<J>(
self,
other: J
) -> InterleaveShortest<Self, J::IntoIter>ⓘNotable traits for InterleaveShortest<I, J>
impl<I, J> Iterator for InterleaveShortest<I, J> where
I: Iterator,
J: Iterator<Item = I::Item>, type Item = I::Item;
where
J: IntoIterator<Item = Self::Item>,
Self: Sized,
[src]
self,
other: J
) -> InterleaveShortest<Self, J::IntoIter>ⓘ
Notable traits for InterleaveShortest<I, J>
impl<I, J> Iterator for InterleaveShortest<I, J> where
I: Iterator,
J: Iterator<Item = I::Item>, type Item = I::Item;
J: IntoIterator<Item = Self::Item>,
Self: Sized,
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
Self: Sized,
Self::Item: Clone,
[src]
Self: Sized,
Self::Item: Clone,
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::Item>, type Item = I::Item;
where
Self: Sized,
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::Item>, type Item = I::Item;
Self: Sized,
F: FnMut() -> Self::Item,
fn zip_longest<J>(self, other: J) -> ZipLongest<Self, J::IntoIter>ⓘNotable traits for ZipLongest<T, U>
impl<T, U> Iterator for ZipLongest<T, U> where
T: Iterator,
U: Iterator, type Item = EitherOrBoth<T::Item, U::Item>;
where
J: IntoIterator,
Self: Sized,
[src]
Notable traits for ZipLongest<T, U>
impl<T, U> Iterator for ZipLongest<T, U> where
T: Iterator,
U: Iterator, type Item = EitherOrBoth<T::Item, U::Item>;
J: IntoIterator,
Self: Sized,
fn zip_eq<J>(self, other: J) -> ZipEq<Self, J::IntoIter>ⓘ where
J: IntoIterator,
Self: Sized,
[src]
J: IntoIterator,
Self: Sized,
fn batching<B, F>(self, f: F) -> Batching<Self, F>ⓘ where
F: FnMut(&mut Self) -> Option<B>,
Self: Sized,
[src]
F: FnMut(&mut Self) -> Option<B>,
Self: Sized,
fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F> where
Self: Sized,
F: FnMut(&Self::Item) -> K,
K: PartialEq,
[src]
Self: Sized,
F: FnMut(&Self::Item) -> K,
K: PartialEq,
fn chunks(self, size: usize) -> IntoChunks<Self> where
Self: Sized,
[src]
Self: Sized,
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::Item>,
T: HomogeneousTuple + Clone,
T::Item: Clone, type Item = T;
where
Self: Sized + Iterator<Item = T::Item>,
T: HomogeneousTuple,
T::Item: Clone,
[src]
Notable traits for TupleWindows<I, T>
impl<I, T> Iterator for TupleWindows<I, T> where
I: Iterator<Item = T::Item>,
T: HomogeneousTuple + Clone,
T::Item: Clone, type Item = T;
Self: Sized + Iterator<Item = T::Item>,
T: HomogeneousTuple,
T::Item: Clone,
fn circular_tuple_windows<T>(self) -> CircularTupleWindows<Self, T>ⓘNotable traits for CircularTupleWindows<I, T>
impl<I, T> Iterator for CircularTupleWindows<I, T> where
I: Iterator<Item = T::Item> + Clone,
T: TupleCollect + Clone,
T::Item: Clone, type Item = T;
where
Self: Sized + Clone + Iterator<Item = T::Item> + ExactSizeIterator,
T: TupleCollect + Clone,
T::Item: Clone,
[src]
Notable traits for CircularTupleWindows<I, T>
impl<I, T> Iterator for CircularTupleWindows<I, T> where
I: Iterator<Item = T::Item> + Clone,
T: TupleCollect + Clone,
T::Item: Clone, type Item = T;
Self: Sized + Clone + Iterator<Item = T::Item> + ExactSizeIterator,
T: TupleCollect + Clone,
T::Item: Clone,
fn tuples<T>(self) -> Tuples<Self, T>ⓘ where
Self: Sized + Iterator<Item = T::Item>,
T: HomogeneousTuple,
[src]
Self: Sized + Iterator<Item = T::Item>,
T: HomogeneousTuple,
fn tee(self) -> (Tee<Self>, Tee<Self>) where
Self: Sized,
Self::Item: Clone,
[src]
Self: Sized,
Self::Item: Clone,
fn step(self, n: usize) -> Step<Self>ⓘ where
Self: Sized,
[src]
Self: Sized,
fn map_into<R>(self) -> MapInto<Self, R> where
Self: Sized,
Self::Item: Into<R>,
[src]
Self: Sized,
Self::Item: Into<R>,
fn map_results<F, T, U, E>(self, f: F) -> MapOk<Self, F> where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> U,
[src]
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> U,
fn map_ok<F, T, U, E>(self, f: F) -> MapOk<Self, F> where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> U,
[src]
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> U,
fn filter_ok<F, T, E>(self, f: F) -> FilterOk<Self, F>ⓘ where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(&T) -> bool,
[src]
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(&T) -> bool,
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
I: Iterator<Item = Result<T, E>>,
F: FnMut(T) -> Option<U>, type Item = Result<U, E>;
where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> Option<U>,
[src]
Notable traits for FilterMapOk<I, F>
impl<I, F, T, U, E> Iterator for FilterMapOk<I, F> where
I: Iterator<Item = Result<T, E>>,
F: FnMut(T) -> Option<U>, type Item = Result<U, E>;
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> Option<U>,
fn merge<J>(self, other: J) -> Merge<Self, J::IntoIter> where
Self: Sized,
Self::Item: PartialOrd,
J: IntoIterator<Item = Self::Item>,
[src]
Self: Sized,
Self::Item: PartialOrd,
J: IntoIterator<Item = Self::Item>,
fn merge_by<J, F>(self, other: J, is_first: F) -> MergeBy<Self, J::IntoIter, F>ⓘ where
Self: Sized,
J: IntoIterator<Item = Self::Item>,
F: FnMut(&Self::Item, &Self::Item) -> bool,
[src]
Self: Sized,
J: IntoIterator<Item = Self::Item>,
F: FnMut(&Self::Item, &Self::Item) -> bool,
fn merge_join_by<J, F>(
self,
other: J,
cmp_fn: F
) -> MergeJoinBy<Self, J::IntoIter, F>ⓘNotable traits for MergeJoinBy<I, J, F>
impl<I, J, F> Iterator for MergeJoinBy<I, J, F> where
I: Iterator,
J: Iterator,
F: FnMut(&I::Item, &J::Item) -> Ordering, type Item = EitherOrBoth<I::Item, J::Item>;
where
J: IntoIterator,
F: FnMut(&Self::Item, &J::Item) -> Ordering,
Self: Sized,
[src]
self,
other: J,
cmp_fn: F
) -> MergeJoinBy<Self, J::IntoIter, F>ⓘ
Notable traits for MergeJoinBy<I, J, F>
impl<I, J, F> Iterator for MergeJoinBy<I, J, F> where
I: Iterator,
J: Iterator,
F: FnMut(&I::Item, &J::Item) -> Ordering, type Item = EitherOrBoth<I::Item, J::Item>;
J: IntoIterator,
F: FnMut(&Self::Item, &J::Item) -> Ordering,
Self: Sized,
fn kmerge(self) -> KMerge<<Self::Item as IntoIterator>::IntoIter> where
Self: Sized,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: PartialOrd,
[src]
Self: Sized,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: PartialOrd,
fn kmerge_by<F>(
self,
first: F
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F>ⓘ where
Self: Sized,
Self::Item: IntoIterator,
F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,
[src]
self,
first: F
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F>ⓘ where
Self: Sized,
Self::Item: IntoIterator,
F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,
fn cartesian_product<J>(self, other: J) -> Product<Self, J::IntoIter>ⓘ where
Self: Sized,
Self::Item: Clone,
J: IntoIterator,
J::IntoIter: Clone,
[src]
Self: Sized,
Self::Item: Clone,
J: IntoIterator,
J::IntoIter: Clone,
fn multi_cartesian_product(
self
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>ⓘNotable traits for MultiProduct<I>
impl<I> Iterator for MultiProduct<I> where
I: Iterator + Clone,
I::Item: Clone, type Item = Vec<I::Item>;
where
Self: Iterator + Sized,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::IntoIter: Clone,
<Self::Item as IntoIterator>::Item: Clone,
[src]
self
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>ⓘ
Notable traits for MultiProduct<I>
impl<I> Iterator for MultiProduct<I> where
I: Iterator + Clone,
I::Item: Clone, type Item = Vec<I::Item>;
Self: Iterator + Sized,
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
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,
[src]
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,
fn dedup(self) -> Dedup<Self> where
Self: Sized,
Self::Item: PartialEq,
[src]
Self: Sized,
Self::Item: PartialEq,
fn dedup_by<Cmp>(self, cmp: Cmp) -> DedupBy<Self, Cmp> where
Self: Sized,
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
[src]
Self: Sized,
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
fn dedup_with_count(self) -> DedupWithCount<Self> where
Self: Sized,
[src]
Self: Sized,
fn dedup_by_with_count<Cmp>(self, cmp: Cmp) -> DedupByWithCount<Self, Cmp> where
Self: Sized,
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
[src]
Self: Sized,
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
fn unique(self) -> Unique<Self>ⓘ where
Self: Sized,
Self::Item: Clone + Eq + Hash,
[src]
Self: Sized,
Self::Item: Clone + Eq + Hash,
fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>ⓘ where
Self: Sized,
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
[src]
Self: Sized,
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
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
I: PeekingNext,
F: FnMut(&I::Item) -> bool, type Item = I::Item;
where
Self: Sized + PeekingNext,
F: FnMut(&Self::Item) -> bool,
[src]
Notable traits for PeekingTakeWhile<'a, I, F>
impl<'a, I, F> Iterator for PeekingTakeWhile<'a, I, F> where
I: PeekingNext,
F: FnMut(&I::Item) -> bool, type Item = I::Item;
Self: Sized + PeekingNext,
F: FnMut(&Self::Item) -> bool,
fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>ⓘNotable traits for TakeWhileRef<'a, I, F>
impl<'a, I, F> Iterator for TakeWhileRef<'a, I, F> where
I: Iterator + Clone,
F: FnMut(&I::Item) -> bool, type Item = I::Item;
where
Self: Clone,
F: FnMut(&Self::Item) -> bool,
[src]
Notable traits for TakeWhileRef<'a, I, F>
impl<'a, I, F> Iterator for TakeWhileRef<'a, I, F> where
I: Iterator + Clone,
F: FnMut(&I::Item) -> bool, type Item = I::Item;
Self: Clone,
F: FnMut(&Self::Item) -> bool,
fn while_some<A>(self) -> WhileSome<Self>ⓘ where
Self: Sized + Iterator<Item = Option<A>>,
[src]
Self: Sized + 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: Sized + Clone,
Self::Item: Clone,
T: HasCombination<Self>,
[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: Sized + Clone,
Self::Item: Clone,
T: HasCombination<Self>,
fn combinations(self, k: usize) -> Combinations<Self>ⓘNotable traits for Combinations<I>
impl<I> Iterator for Combinations<I> where
I: Iterator,
I::Item: Clone, type Item = Vec<I::Item>;
where
Self: Sized,
Self::Item: Clone,
[src]
Notable traits for Combinations<I>
impl<I> Iterator for Combinations<I> where
I: Iterator,
I::Item: Clone, type Item = Vec<I::Item>;
Self: Sized,
Self::Item: Clone,
fn combinations_with_replacement(
self,
k: usize
) -> CombinationsWithReplacement<Self>ⓘNotable traits for CombinationsWithReplacement<I>
impl<I> Iterator for CombinationsWithReplacement<I> where
I: Iterator,
I::Item: Clone, type Item = Vec<I::Item>;
where
Self: Sized,
Self::Item: Clone,
[src]
self,
k: usize
) -> CombinationsWithReplacement<Self>ⓘ
Notable traits for CombinationsWithReplacement<I>
impl<I> Iterator for CombinationsWithReplacement<I> where
I: Iterator,
I::Item: Clone, type Item = Vec<I::Item>;
Self: Sized,
Self::Item: Clone,
fn permutations(self, k: usize) -> Permutations<Self>ⓘNotable traits for Permutations<I>
impl<I> Iterator for Permutations<I> where
I: Iterator,
I::Item: Clone, type Item = Vec<I::Item>;
where
Self: Sized,
Self::Item: Clone,
[src]
Notable traits for Permutations<I>
impl<I> Iterator for Permutations<I> where
I: Iterator,
I::Item: Clone, type Item = Vec<I::Item>;
Self: Sized,
Self::Item: Clone,
fn powerset(self) -> Powerset<Self>ⓘ where
Self: Sized,
Self::Item: Clone,
[src]
Self: Sized,
Self::Item: Clone,
fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>ⓘ where
Self: Sized,
F: FnMut(usize) -> Self::Item,
[src]
Self: Sized,
F: FnMut(usize) -> Self::Item,
fn with_position(self) -> WithPosition<Self>ⓘNotable traits for WithPosition<I>
impl<I: Iterator> Iterator for WithPosition<I> type Item = Position<I::Item>;
where
Self: Sized,
[src]
Notable traits for WithPosition<I>
impl<I: Iterator> Iterator for WithPosition<I> type Item = Position<I::Item>;
Self: Sized,
fn positions<P>(self, predicate: P) -> Positions<Self, P>ⓘ where
Self: Sized,
P: FnMut(Self::Item) -> bool,
[src]
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn update<F>(self, updater: F) -> Update<Self, F>ⓘ where
Self: Sized,
F: FnMut(&mut Self::Item),
[src]
Self: Sized,
F: FnMut(&mut Self::Item),
fn next_tuple<T>(&mut self) -> Option<T> where
Self: Sized + Iterator<Item = T::Item>,
T: HomogeneousTuple,
[src]
Self: Sized + Iterator<Item = T::Item>,
T: HomogeneousTuple,
fn collect_tuple<T>(self) -> Option<T> where
Self: Sized + Iterator<Item = T::Item>,
T: HomogeneousTuple,
[src]
Self: Sized + Iterator<Item = T::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: Sized,
Self::Item: PartialEq,
[src]
Self: Sized,
Self::Item: PartialEq,
fn dropping(self, n: usize) -> Self where
Self: Sized,
[src]
Self: Sized,
fn dropping_back(self, n: usize) -> Self where
Self: Sized,
Self: DoubleEndedIterator,
[src]
Self: Sized,
Self: DoubleEndedIterator,
fn foreach<F>(self, f: F) where
F: FnMut(Self::Item),
Self: Sized,
[src]
F: FnMut(Self::Item),
Self: Sized,
fn concat(self) -> Self::Item where
Self: Sized,
Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,
[src]
Self: Sized,
Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,
fn collect_vec(self) -> Vec<Self::Item> where
Self: Sized,
[src]
Self: Sized,
fn try_collect<T, U, E>(self) -> Result<U, E> where
Self: Sized + Iterator<Item = Result<T, E>>,
Result<U, E>: FromIterator<Result<T, E>>,
[src]
Self: Sized + Iterator<Item = Result<T, E>>,
Result<U, E>: FromIterator<Result<T, E>>,
fn set_from<'a, A: 'a, J>(&mut self, from: J) -> usize where
Self: Iterator<Item = &'a mut A>,
J: IntoIterator<Item = A>,
[src]
Self: Iterator<Item = &'a mut A>,
J: IntoIterator<Item = A>,
fn join(&mut self, sep: &str) -> String where
Self::Item: Display,
[src]
Self::Item: Display,
fn format(self, sep: &str) -> Format<'_, Self> where
Self: Sized,
[src]
Self: Sized,
fn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F> where
Self: Sized,
F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display) -> Result) -> Result,
[src]
Self: Sized,
F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display) -> Result) -> Result,
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,
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,
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,
fn fold1<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
Self: Sized,
[src]
F: FnMut(Self::Item, Self::Item) -> Self::Item,
Self: Sized,
fn tree_fold1<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
Self: Sized,
[src]
F: FnMut(Self::Item, Self::Item) -> Self::Item,
Self: Sized,
fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B> where
Self: Sized,
F: FnMut(B, Self::Item) -> FoldWhile<B>,
[src]
Self: Sized,
F: FnMut(B, Self::Item) -> FoldWhile<B>,
fn sum1<S>(self) -> Option<S> where
Self: Sized,
S: Sum<Self::Item>,
[src]
Self: Sized,
S: Sum<Self::Item>,
fn product1<P>(self) -> Option<P> where
Self: Sized,
P: Product<Self::Item>,
[src]
Self: Sized,
P: Product<Self::Item>,
fn sorted_unstable(self) -> IntoIter<Self::Item> where
Self: Sized,
Self::Item: Ord,
[src]
Self: Sized,
Self::Item: Ord,
fn sorted_unstable_by<F>(self, cmp: F) -> IntoIter<Self::Item> where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn sorted_unstable_by_key<K, F>(self, f: F) -> IntoIter<Self::Item> where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
[src]
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn sorted(self) -> IntoIter<Self::Item> where
Self: Sized,
Self::Item: Ord,
[src]
Self: Sized,
Self::Item: Ord,
fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item> where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item> where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
[src]
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn k_smallest(self, k: usize) -> IntoIter<Self::Item> where
Self: Sized,
Self::Item: Ord,
[src]
Self: Sized,
Self::Item: Ord,
fn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B) where
Self: Sized,
F: FnMut(Self::Item) -> Either<L, R>,
A: Default + Extend<L>,
B: Default + Extend<R>,
[src]
Self: Sized,
F: FnMut(Self::Item) -> Either<L, R>,
A: Default + Extend<L>,
B: Default + Extend<R>,
fn into_group_map<K, V>(self) -> HashMap<K, Vec<V>> where
Self: Iterator<Item = (K, V)> + Sized,
K: Hash + Eq,
[src]
Self: Iterator<Item = (K, V)> + Sized,
K: Hash + Eq,
fn into_group_map_by<K, V, F>(self, f: F) -> HashMap<K, Vec<V>> where
Self: Iterator<Item = V> + Sized,
K: Hash + Eq,
F: Fn(&V) -> K,
[src]
Self: Iterator<Item = V> + Sized,
K: Hash + Eq,
F: Fn(&V) -> K,
fn into_grouping_map<K, V>(self) -> GroupingMap<Self> where
Self: Iterator<Item = (K, V)> + Sized,
K: Hash + Eq,
[src]
Self: Iterator<Item = (K, V)> + Sized,
K: Hash + Eq,
fn into_grouping_map_by<K, V, F>(self, key_mapper: F) -> GroupingMapBy<Self, F> where
Self: Iterator<Item = V> + Sized,
K: Hash + Eq,
F: FnMut(&V) -> K,
[src]
Self: Iterator<Item = V> + Sized,
K: Hash + Eq,
F: FnMut(&V) -> K,
fn minmax(self) -> MinMaxResult<Self::Item> where
Self: Sized,
Self::Item: PartialOrd,
[src]
Self: Sized,
Self::Item: PartialOrd,
fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item> where
Self: Sized,
K: PartialOrd,
F: FnMut(&Self::Item) -> K,
[src]
Self: Sized,
K: PartialOrd,
F: FnMut(&Self::Item) -> K,
fn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item> where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn position_max(self) -> Option<usize> where
Self: Sized,
Self::Item: Ord,
[src]
Self: Sized,
Self::Item: Ord,
fn position_max_by_key<K, F>(self, key: F) -> Option<usize> where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
[src]
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn position_max_by<F>(self, compare: F) -> Option<usize> where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn position_min(self) -> Option<usize> where
Self: Sized,
Self::Item: Ord,
[src]
Self: Sized,
Self::Item: Ord,
fn position_min_by_key<K, F>(self, key: F) -> Option<usize> where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
[src]
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn position_min_by<F>(self, compare: F) -> Option<usize> where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn position_minmax(self) -> MinMaxResult<usize> where
Self: Sized,
Self::Item: PartialOrd,
[src]
Self: Sized,
Self::Item: PartialOrd,
fn position_minmax_by_key<K, F>(self, key: F) -> MinMaxResult<usize> where
Self: Sized,
K: PartialOrd,
F: FnMut(&Self::Item) -> K,
[src]
Self: Sized,
K: PartialOrd,
F: FnMut(&Self::Item) -> K,
fn position_minmax_by<F>(self, compare: F) -> MinMaxResult<usize> where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>> where
Self: Sized,
[src]
Self: Sized,
fn multipeek(self) -> MultiPeek<Self>ⓘ where
Self: Sized,
[src]
Self: Sized,
fn counts(self) -> HashMap<Self::Item, usize> where
Self: Sized,
Self::Item: Eq + Hash,
[src]
Self: Sized,
Self::Item: Eq + Hash,
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> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
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>,