Enum itertools::Either [−][src]
The enum Either
with variants Left
and Right
is a general purpose
sum type with two cases.
The Either
type is symmetric and treats its variants the same way, without
preference.
(For representing success or error, use the regular Result
enum instead.)
Variants
A value of type L
.
A value of type R
.
Implementations
impl<L, R> Either<L, R>
[src]
pub fn is_left(&self) -> bool
[src]
Return true if the value is the Left
variant.
use either::*; let values = [Left(1), Right("the right value")]; assert_eq!(values[0].is_left(), true); assert_eq!(values[1].is_left(), false);
pub fn is_right(&self) -> bool
[src]
Return true if the value is the Right
variant.
use either::*; let values = [Left(1), Right("the right value")]; assert_eq!(values[0].is_right(), false); assert_eq!(values[1].is_right(), true);
pub fn left(self) -> Option<L>
[src]
Convert the left side of Either<L, R>
to an Option<L>
.
use either::*; let left: Either<_, ()> = Left("some value"); assert_eq!(left.left(), Some("some value")); let right: Either<(), _> = Right(321); assert_eq!(right.left(), None);
pub fn right(self) -> Option<R>
[src]
Convert the right side of Either<L, R>
to an Option<R>
.
use either::*; let left: Either<_, ()> = Left("some value"); assert_eq!(left.right(), None); let right: Either<(), _> = Right(321); assert_eq!(right.right(), Some(321));
pub fn as_ref(&self) -> Either<&L, &R>ⓘ
[src]
Convert &Either<L, R>
to Either<&L, &R>
.
use either::*; let left: Either<_, ()> = Left("some value"); assert_eq!(left.as_ref(), Left(&"some value")); let right: Either<(), _> = Right("some value"); assert_eq!(right.as_ref(), Right(&"some value"));
pub fn as_mut(&mut self) -> Either<&mut L, &mut R>ⓘ
[src]
Convert &mut Either<L, R>
to Either<&mut L, &mut R>
.
use either::*; fn mutate_left(value: &mut Either<u32, u32>) { if let Some(l) = value.as_mut().left() { *l = 999; } } let mut left = Left(123); let mut right = Right(123); mutate_left(&mut left); mutate_left(&mut right); assert_eq!(left, Left(999)); assert_eq!(right, Right(123));
pub fn flip(self) -> Either<R, L>ⓘ
[src]
Convert Either<L, R>
to Either<R, L>
.
use either::*; let left: Either<_, ()> = Left(123); assert_eq!(left.flip(), Right(123)); let right: Either<(), _> = Right("some value"); assert_eq!(right.flip(), Left("some value"));
pub fn map_left<F, M>(self, f: F) -> Either<M, R>ⓘ where
F: FnOnce(L) -> M,
[src]
F: FnOnce(L) -> M,
Apply the function f
on the value in the Left
variant if it is present rewrapping the
result in Left
.
use either::*; let left: Either<_, u32> = Left(123); assert_eq!(left.map_left(|x| x * 2), Left(246)); let right: Either<u32, _> = Right(123); assert_eq!(right.map_left(|x| x * 2), Right(123));
pub fn map_right<F, S>(self, f: F) -> Either<L, S>ⓘ where
F: FnOnce(R) -> S,
[src]
F: FnOnce(R) -> S,
Apply the function f
on the value in the Right
variant if it is present rewrapping the
result in Right
.
use either::*; let left: Either<_, u32> = Left(123); assert_eq!(left.map_right(|x| x * 2), Left(123)); let right: Either<u32, _> = Right(123); assert_eq!(right.map_right(|x| x * 2), Right(246));
pub fn either<F, G, T>(self, f: F, g: G) -> T where
F: FnOnce(L) -> T,
G: FnOnce(R) -> T,
[src]
F: FnOnce(L) -> T,
G: FnOnce(R) -> T,
Apply one of two functions depending on contents, unifying their result. If the value is
Left(L)
then the first function f
is applied; if it is Right(R)
then the second
function g
is applied.
use either::*; fn square(n: u32) -> i32 { (n * n) as i32 } fn negate(n: i32) -> i32 { -n } let left: Either<u32, i32> = Left(4); assert_eq!(left.either(square, negate), 16); let right: Either<u32, i32> = Right(-4); assert_eq!(right.either(square, negate), 4);
pub fn either_with<Ctx, F, G, T>(self, ctx: Ctx, f: F, g: G) -> T where
F: FnOnce(Ctx, L) -> T,
G: FnOnce(Ctx, R) -> T,
[src]
F: FnOnce(Ctx, L) -> T,
G: FnOnce(Ctx, R) -> T,
Like either
, but provide some context to whichever of the
functions ends up being called.
// In this example, the context is a mutable reference use either::*; let mut result = Vec::new(); let values = vec![Left(2), Right(2.7)]; for value in values { value.either_with(&mut result, |ctx, integer| ctx.push(integer), |ctx, real| ctx.push(f64::round(real) as i32)); } assert_eq!(result, vec![2, 3]);
pub fn left_and_then<F, S>(self, f: F) -> Either<S, R>ⓘ where
F: FnOnce(L) -> Either<S, R>,
[src]
F: FnOnce(L) -> Either<S, R>,
Apply the function f
on the value in the Left
variant if it is present.
use either::*; let left: Either<_, u32> = Left(123); assert_eq!(left.left_and_then::<_,()>(|x| Right(x * 2)), Right(246)); let right: Either<u32, _> = Right(123); assert_eq!(right.left_and_then(|x| Right::<(), _>(x * 2)), Right(123));
pub fn right_and_then<F, S>(self, f: F) -> Either<L, S>ⓘ where
F: FnOnce(R) -> Either<L, S>,
[src]
F: FnOnce(R) -> Either<L, S>,
Apply the function f
on the value in the Right
variant if it is present.
use either::*; let left: Either<_, u32> = Left(123); assert_eq!(left.right_and_then(|x| Right(x * 2)), Left(123)); let right: Either<u32, _> = Right(123); assert_eq!(right.right_and_then(|x| Right(x * 2)), Right(246));
pub fn into_iter(
self
) -> Either<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter>ⓘ where
R: IntoIterator<Item = <L as IntoIterator>::Item>,
L: IntoIterator,
[src]
self
) -> Either<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter>ⓘ where
R: IntoIterator<Item = <L as IntoIterator>::Item>,
L: IntoIterator,
Convert the inner value to an iterator.
use either::*; let left: Either<_, Vec<u32>> = Left(vec![1, 2, 3, 4, 5]); let mut right: Either<Vec<u32>, _> = Right(vec![]); right.extend(left.into_iter()); assert_eq!(right, Right(vec![1, 2, 3, 4, 5]));
pub fn left_or(self, other: L) -> L
[src]
Return left value or given value
Arguments passed to left_or
are eagerly evaluated; if you are passing
the result of a function call, it is recommended to use left_or_else
,
which is lazily evaluated.
Examples
let left: Either<&str, &str> = Left("left"); assert_eq!(left.left_or("foo"), "left"); let right: Either<&str, &str> = Right("right"); assert_eq!(right.left_or("left"), "left");
pub fn left_or_default(self) -> L where
L: Default,
[src]
L: Default,
Return left or a default
Examples
let left: Either<String, u32> = Left("left".to_string()); assert_eq!(left.left_or_default(), "left"); let right: Either<String, u32> = Right(42); assert_eq!(right.left_or_default(), String::default());
pub fn left_or_else<F>(self, f: F) -> L where
F: FnOnce(R) -> L,
[src]
F: FnOnce(R) -> L,
Returns left value or computes it from a closure
Examples
let left: Either<String, u32> = Left("3".to_string()); assert_eq!(left.left_or_else(|_| unreachable!()), "3"); let right: Either<String, u32> = Right(3); assert_eq!(right.left_or_else(|x| x.to_string()), "3");
pub fn right_or(self, other: R) -> R
[src]
Return right value or given value
Arguments passed to right_or
are eagerly evaluated; if you are passing
the result of a function call, it is recommended to use right_or_else
,
which is lazily evaluated.
Examples
let right: Either<&str, &str> = Right("right"); assert_eq!(right.right_or("foo"), "right"); let left: Either<&str, &str> = Left("left"); assert_eq!(left.right_or("right"), "right");
pub fn right_or_default(self) -> R where
R: Default,
[src]
R: Default,
Return right or a default
Examples
let left: Either<String, u32> = Left("left".to_string()); assert_eq!(left.right_or_default(), u32::default()); let right: Either<String, u32> = Right(42); assert_eq!(right.right_or_default(), 42);
pub fn right_or_else<F>(self, f: F) -> R where
F: FnOnce(L) -> R,
[src]
F: FnOnce(L) -> R,
Returns right value or computes it from a closure
Examples
let left: Either<String, u32> = Left("3".to_string()); assert_eq!(left.right_or_else(|x| x.parse().unwrap()), 3); let right: Either<String, u32> = Right(3); assert_eq!(right.right_or_else(|_| unreachable!()), 3);
pub fn unwrap_left(self) -> L where
R: Debug,
[src]
R: Debug,
Returns the left value
Examples
let left: Either<_, ()> = Left(3); assert_eq!(left.unwrap_left(), 3);
Panics
When Either
is a Right
value
let right: Either<(), _> = Right(3); right.unwrap_left();
pub fn unwrap_right(self) -> R where
L: Debug,
[src]
L: Debug,
Returns the right value
Examples
let right: Either<(), _> = Right(3); assert_eq!(right.unwrap_right(), 3);
Panics
When Either
is a Left
value
let left: Either<_, ()> = Left(3); left.unwrap_right();
pub fn expect_left(self, msg: &str) -> L where
R: Debug,
[src]
R: Debug,
Returns the left value
Examples
let left: Either<_, ()> = Left(3); assert_eq!(left.expect_left("value was Right"), 3);
Panics
When Either
is a Right
value
let right: Either<(), _> = Right(3); right.expect_left("value was Right");
pub fn expect_right(self, msg: &str) -> R where
L: Debug,
[src]
L: Debug,
impl<T, L, R> Either<(T, L), (T, R)>
[src]
pub fn factor_first(self) -> (T, Either<L, R>)
[src]
Factor out a homogeneous type from an either of pairs.
Here, the homogeneous type is the first element of the pairs.
use either::*; let left: Either<_, (u32, String)> = Left((123, vec![0])); assert_eq!(left.factor_first().0, 123); let right: Either<(u32, Vec<u8>), _> = Right((123, String::new())); assert_eq!(right.factor_first().0, 123);
impl<T, L, R> Either<(L, T), (R, T)>
[src]
pub fn factor_second(self) -> (Either<L, R>, T)
[src]
Factor out a homogeneous type from an either of pairs.
Here, the homogeneous type is the second element of the pairs.
use either::*; let left: Either<_, (String, u32)> = Left((vec![0], 123)); assert_eq!(left.factor_second().1, 123); let right: Either<(Vec<u8>, u32), _> = Right((String::new(), 123)); assert_eq!(right.factor_second().1, 123);
impl<T> Either<T, T>
[src]
pub fn into_inner(self) -> T
[src]
Extract the value of an either over two equivalent types.
use either::*; let left: Either<_, u32> = Left(123); assert_eq!(left.into_inner(), 123); let right: Either<u32, _> = Right(123); assert_eq!(right.into_inner(), 123);
pub fn map<F, M>(self, f: F) -> Either<M, M>ⓘ where
F: FnOnce(T) -> M,
[src]
F: FnOnce(T) -> M,
Map f
over the contained value and return the result in the
corresponding variant.
use either::*; let value: Either<_, i32> = Right(42); let other = value.map(|x| x * 2); assert_eq!(other, Right(84));
Trait Implementations
impl<L, R, Target> AsMut<[Target]> for Either<L, R> where
R: AsMut<[Target]>,
L: AsMut<[Target]>,
[src]
R: AsMut<[Target]>,
L: AsMut<[Target]>,
pub fn as_mut(&mut self) -> &mut [Target]
[src]
impl<L, R> AsMut<CStr> for Either<L, R> where
R: AsMut<CStr>,
L: AsMut<CStr>,
[src]
R: AsMut<CStr>,
L: AsMut<CStr>,
Requires crate feature use_std
.
impl<L, R> AsMut<OsStr> for Either<L, R> where
R: AsMut<OsStr>,
L: AsMut<OsStr>,
[src]
R: AsMut<OsStr>,
L: AsMut<OsStr>,
Requires crate feature use_std
.
impl<L, R> AsMut<Path> for Either<L, R> where
R: AsMut<Path>,
L: AsMut<Path>,
[src]
R: AsMut<Path>,
L: AsMut<Path>,
Requires crate feature use_std
.
impl<L, R, Target> AsMut<Target> for Either<L, R> where
R: AsMut<Target>,
L: AsMut<Target>,
[src]
R: AsMut<Target>,
L: AsMut<Target>,
impl<L, R> AsMut<str> for Either<L, R> where
R: AsMut<str>,
L: AsMut<str>,
[src]
R: AsMut<str>,
L: AsMut<str>,
impl<L, R, Target> AsRef<[Target]> for Either<L, R> where
R: AsRef<[Target]>,
L: AsRef<[Target]>,
[src]
R: AsRef<[Target]>,
L: AsRef<[Target]>,
impl<L, R> AsRef<CStr> for Either<L, R> where
R: AsRef<CStr>,
L: AsRef<CStr>,
[src]
R: AsRef<CStr>,
L: AsRef<CStr>,
Requires crate feature use_std
.
impl<L, R> AsRef<OsStr> for Either<L, R> where
R: AsRef<OsStr>,
L: AsRef<OsStr>,
[src]
R: AsRef<OsStr>,
L: AsRef<OsStr>,
Requires crate feature use_std
.
impl<L, R> AsRef<Path> for Either<L, R> where
R: AsRef<Path>,
L: AsRef<Path>,
[src]
R: AsRef<Path>,
L: AsRef<Path>,
Requires crate feature use_std
.
impl<L, R, Target> AsRef<Target> for Either<L, R> where
R: AsRef<Target>,
L: AsRef<Target>,
[src]
R: AsRef<Target>,
L: AsRef<Target>,
impl<L, R> AsRef<str> for Either<L, R> where
R: AsRef<str>,
L: AsRef<str>,
[src]
R: AsRef<str>,
L: AsRef<str>,
impl<L, R> BufRead for Either<L, R> where
R: BufRead,
L: BufRead,
[src]
R: BufRead,
L: BufRead,
Requires crate feature "use_std"
pub fn fill_buf(&mut self) -> Result<&[u8], Error>
[src]
pub fn consume(&mut self, amt: usize)
[src]
pub fn read_until(
&mut self,
byte: u8,
buf: &mut Vec<u8, Global>
) -> Result<usize, Error>
1.0.0[src]
&mut self,
byte: u8,
buf: &mut Vec<u8, Global>
) -> Result<usize, Error>
pub fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
1.0.0[src]
pub fn split(self, byte: u8) -> Split<Self>
1.0.0[src]
pub fn lines(self) -> Lines<Self>
1.0.0[src]
impl<L, R> Clone for Either<L, R> where
R: Clone,
L: Clone,
[src]
R: Clone,
L: Clone,
impl<L, R> Copy for Either<L, R> where
R: Copy,
L: Copy,
[src]
R: Copy,
L: Copy,
impl<L, R> Debug for Either<L, R> where
R: Debug,
L: Debug,
[src]
R: Debug,
L: Debug,
impl<L, R> Deref for Either<L, R> where
R: Deref<Target = <L as Deref>::Target>,
L: Deref,
[src]
R: Deref<Target = <L as Deref>::Target>,
L: Deref,
type Target = <L as Deref>::Target
The resulting type after dereferencing.
pub fn deref(&self) -> &<Either<L, R> as Deref>::Targetⓘ
[src]
impl<L, R> DerefMut for Either<L, R> where
R: DerefMut<Target = <L as Deref>::Target>,
L: DerefMut,
[src]
R: DerefMut<Target = <L as Deref>::Target>,
L: DerefMut,
impl<L, R> Display for Either<L, R> where
R: Display,
L: Display,
[src]
R: Display,
L: Display,
impl<L, R> DoubleEndedIterator for Either<L, R> where
R: DoubleEndedIterator<Item = <L as Iterator>::Item>,
L: DoubleEndedIterator,
[src]
R: DoubleEndedIterator<Item = <L as Iterator>::Item>,
L: DoubleEndedIterator,
pub fn next_back(&mut self) -> Option<<Either<L, R> as Iterator>::Item>
[src]
pub fn advance_back_by(&mut self, n: usize) -> Result<(), usize>
[src]
pub fn nth_back(&mut self, n: usize) -> Option<Self::Item>
1.37.0[src]
pub fn 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>,
pub 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,
pub fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
1.27.0[src]
P: FnMut(&Self::Item) -> bool,
impl<L, R> Eq for Either<L, R> where
R: Eq,
L: Eq,
[src]
R: Eq,
L: Eq,
impl<L, R> Error for Either<L, R> where
R: Error,
L: Error,
[src]
R: Error,
L: Error,
Either
implements Error
if both L
and R
implement it.
pub fn description(&self) -> &str
[src]
pub fn cause(&self) -> Option<&dyn Error>
[src]
pub fn source(&self) -> Option<&(dyn Error + 'static)>
1.30.0[src]
pub fn backtrace(&self) -> Option<&Backtrace>
[src]
impl<L, R> ExactSizeIterator for Either<L, R> where
R: ExactSizeIterator<Item = <L as Iterator>::Item>,
L: ExactSizeIterator,
[src]
R: ExactSizeIterator<Item = <L as Iterator>::Item>,
L: ExactSizeIterator,
impl<L, R, A> Extend<A> for Either<L, R> where
R: Extend<A>,
L: Extend<A>,
[src]
R: Extend<A>,
L: Extend<A>,
pub fn extend<T>(&mut self, iter: T) where
T: IntoIterator<Item = A>,
[src]
T: IntoIterator<Item = A>,
pub fn extend_one(&mut self, item: A)
[src]
pub fn extend_reserve(&mut self, additional: usize)
[src]
impl<L, R> From<Result<R, L>> for Either<L, R>
[src]
Convert from Result
to Either
with Ok => Right
and Err => Left
.
impl<L, R> Hash for Either<L, R> where
R: Hash,
L: Hash,
[src]
R: Hash,
L: Hash,
pub fn hash<__H>(&self, state: &mut __H) where
__H: Hasher,
[src]
__H: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<L, R> Into<Result<R, L>> for Either<L, R>
[src]
Convert from Either
to Result
with Right => Ok
and Left => Err
.
impl<L, R> Iterator for Either<L, R> where
R: Iterator<Item = <L as Iterator>::Item>,
L: Iterator,
[src]
R: Iterator<Item = <L as Iterator>::Item>,
L: Iterator,
Either<L, R>
is an iterator if both L
and R
are iterators.
type Item = <L as Iterator>::Item
The type of the elements being iterated over.
pub fn next(&mut self) -> Option<<Either<L, R> as Iterator>::Item>
[src]
pub fn size_hint(&self) -> (usize, Option<usize>)
[src]
pub fn fold<Acc, G>(self, init: Acc, f: G) -> Acc where
G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,
[src]
G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,
pub fn count(self) -> usize
[src]
pub fn last(self) -> Option<<Either<L, R> as Iterator>::Item>
[src]
pub fn nth(&mut self, n: usize) -> Option<<Either<L, R> as Iterator>::Item>
[src]
pub fn collect<B>(self) -> B where
B: FromIterator<<Either<L, R> as Iterator>::Item>,
[src]
B: FromIterator<<Either<L, R> as Iterator>::Item>,
pub fn all<F>(&mut self, f: F) -> bool where
F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,
[src]
F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,
pub fn advance_by(&mut self, n: usize) -> Result<(), usize>
[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]
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 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 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,
impl<L, R> Ord for Either<L, R> where
R: Ord,
L: Ord,
[src]
R: Ord,
L: Ord,
pub fn cmp(&self, other: &Either<L, R>) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<L, R> PartialEq<Either<L, R>> for Either<L, R> where
R: PartialEq<R>,
L: PartialEq<L>,
[src]
R: PartialEq<R>,
L: PartialEq<L>,
pub fn eq(&self, other: &Either<L, R>) -> bool
[src]
pub fn ne(&self, other: &Either<L, R>) -> bool
[src]
impl<L, R> PartialOrd<Either<L, R>> for Either<L, R> where
R: PartialOrd<R>,
L: PartialOrd<L>,
[src]
R: PartialOrd<R>,
L: PartialOrd<L>,
pub fn partial_cmp(&self, other: &Either<L, R>) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl<L, R> Read for Either<L, R> where
R: Read,
L: Read,
[src]
R: Read,
L: Read,
Either<L, R>
implements Read
if both L
and R
do.
Requires crate feature "use_std"
pub fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>
[src]
pub fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>
[src]
pub fn read_vectored(
&mut self,
bufs: &mut [IoSliceMut<'_>]
) -> Result<usize, Error>
1.36.0[src]
&mut self,
bufs: &mut [IoSliceMut<'_>]
) -> Result<usize, Error>
pub fn is_read_vectored(&self) -> bool
[src]
pub unsafe fn initializer(&self) -> Initializer
[src]
pub fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
1.0.0[src]
pub fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
1.6.0[src]
pub fn by_ref(&mut self) -> &mut Self
1.0.0[src]
pub fn bytes(self) -> Bytes<Self>
1.0.0[src]
pub fn chain<R>(self, next: R) -> Chain<Self, R> where
R: Read,
1.0.0[src]
R: Read,
pub fn take(self, limit: u64) -> Take<Self>
1.0.0[src]
impl<L, R> StructuralEq for Either<L, R>
[src]
impl<L, R> StructuralPartialEq for Either<L, R>
[src]
impl<L, R> Write for Either<L, R> where
R: Write,
L: Write,
[src]
R: Write,
L: Write,
Either<L, R>
implements Write
if both L
and R
do.
Requires crate feature "use_std"
pub fn write(&mut self, buf: &[u8]) -> Result<usize, Error>
[src]
pub fn flush(&mut self) -> Result<(), Error>
[src]
pub fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>
1.36.0[src]
pub fn is_write_vectored(&self) -> bool
[src]
pub fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
1.0.0[src]
pub fn write_all_vectored(
&mut self,
bufs: &mut [IoSlice<'_>]
) -> Result<(), Error>
[src]
&mut self,
bufs: &mut [IoSlice<'_>]
) -> Result<(), Error>
pub fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>
1.0.0[src]
pub fn by_ref(&mut self) -> &mut Self
1.0.0[src]
Auto Trait Implementations
impl<L, R> RefUnwindSafe for Either<L, R> where
L: RefUnwindSafe,
R: RefUnwindSafe,
L: RefUnwindSafe,
R: RefUnwindSafe,
impl<L, R> Send for Either<L, R> where
L: Send,
R: Send,
L: Send,
R: Send,
impl<L, R> Sync for Either<L, R> where
L: Sync,
R: Sync,
L: Sync,
R: Sync,
impl<L, R> Unpin for Either<L, R> where
L: Unpin,
R: Unpin,
L: Unpin,
R: Unpin,
impl<L, R> UnwindSafe for Either<L, R> where
L: UnwindSafe,
R: UnwindSafe,
L: UnwindSafe,
R: 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>,