Enum swc_common::pass::Either [−][src]
pub enum Either<L, R> { Left(L), Right(R), }
Expand description
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]
impl<L, R> Either<L, R>
[src]pub fn is_left(&self) -> bool
[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]
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]
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]
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]
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]
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]
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]
pub fn map_left<F, M>(self, f: F) -> Either<M, R>ⓘ where
F: FnOnce(L) -> M,
[src]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]
pub fn map_right<F, S>(self, f: F) -> Either<L, S>ⓘ where
F: FnOnce(R) -> S,
[src]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]
pub fn either<F, G, T>(self, f: F, g: G) -> T where
F: FnOnce(L) -> T,
G: FnOnce(R) -> T,
[src]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]
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]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]
pub fn left_and_then<F, S>(self, f: F) -> Either<S, R>ⓘ where
F: FnOnce(L) -> Either<S, R>,
[src]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]
pub fn right_and_then<F, S>(self, f: F) -> Either<L, S>ⓘ where
F: FnOnce(R) -> Either<L, S>,
[src]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]
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]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]
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]
pub fn left_or_default(self) -> L where
L: Default,
[src]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]
pub fn left_or_else<F>(self, f: F) -> L where
F: FnOnce(R) -> L,
[src]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]
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]
pub fn right_or_default(self) -> R where
R: Default,
[src]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]
pub fn right_or_else<F>(self, f: F) -> R where
F: FnOnce(L) -> R,
[src]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]
pub fn unwrap_left(self) -> L where
R: Debug,
[src]pub fn unwrap_right(self) -> R where
L: Debug,
[src]
pub fn unwrap_right(self) -> R where
L: Debug,
[src]pub fn expect_left(self, msg: &str) -> L where
R: Debug,
[src]
pub fn expect_left(self, msg: &str) -> L where
R: Debug,
[src]impl<T, L, R> Either<(T, L), (T, R)>
[src]
impl<T, L, R> Either<(T, L), (T, R)>
[src]pub fn factor_first(self) -> (T, Either<L, 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]
impl<T, L, R> Either<(L, T), (R, T)>
[src]pub fn factor_second(self) -> (Either<L, 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]
impl<T> Either<T, T>
[src]pub fn into_inner(self) -> 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);
Trait Implementations
impl<L, R, Target> AsMut<[Target]> for Either<L, R> where
R: AsMut<[Target]>,
L: AsMut<[Target]>,
[src]
impl<L, R, Target> AsMut<[Target]> for Either<L, R> where
R: AsMut<[Target]>,
L: AsMut<[Target]>,
[src]impl<L, R> AsMut<CStr> for Either<L, R> where
R: AsMut<CStr>,
L: AsMut<CStr>,
[src]
impl<L, R> AsMut<CStr> for Either<L, R> where
R: AsMut<CStr>,
L: AsMut<CStr>,
[src]Requires crate feature use_std
.
impl<L, R> AsMut<OsStr> for Either<L, R> where
R: AsMut<OsStr>,
L: AsMut<OsStr>,
[src]
impl<L, R> AsMut<OsStr> for Either<L, R> where
R: AsMut<OsStr>,
L: AsMut<OsStr>,
[src]Requires crate feature use_std
.
impl<L, R> AsMut<Path> for Either<L, R> where
R: AsMut<Path>,
L: AsMut<Path>,
[src]
impl<L, R> AsMut<Path> for Either<L, R> where
R: AsMut<Path>,
L: AsMut<Path>,
[src]Requires crate feature use_std
.
impl<L, R, Target> AsRef<[Target]> for Either<L, R> where
R: AsRef<[Target]>,
L: AsRef<[Target]>,
[src]
impl<L, R, Target> AsRef<[Target]> for Either<L, R> where
R: AsRef<[Target]>,
L: AsRef<[Target]>,
[src]impl<L, R> AsRef<CStr> for Either<L, R> where
R: AsRef<CStr>,
L: AsRef<CStr>,
[src]
impl<L, R> AsRef<CStr> for Either<L, R> where
R: AsRef<CStr>,
L: AsRef<CStr>,
[src]Requires crate feature use_std
.
impl<L, R> AsRef<OsStr> for Either<L, R> where
R: AsRef<OsStr>,
L: AsRef<OsStr>,
[src]
impl<L, R> AsRef<OsStr> for Either<L, R> where
R: AsRef<OsStr>,
L: AsRef<OsStr>,
[src]Requires crate feature use_std
.
impl<L, R> AsRef<Path> for Either<L, R> where
R: AsRef<Path>,
L: AsRef<Path>,
[src]
impl<L, R> AsRef<Path> for Either<L, R> where
R: AsRef<Path>,
L: AsRef<Path>,
[src]Requires crate feature use_std
.
impl<L, R> BufRead for Either<L, R> where
R: BufRead,
L: BufRead,
[src]
impl<L, R> BufRead for Either<L, R> where
R: BufRead,
L: BufRead,
[src]Requires crate feature "use_std"
pub fn fill_buf(&mut self) -> Result<&[u8], Error>
[src]
pub fn fill_buf(&mut self) -> Result<&[u8], Error>
[src]Returns the contents of the internal buffer, filling it with more data from the inner reader if it is empty. Read more
pub fn consume(&mut self, amt: usize)
[src]
pub fn consume(&mut self, amt: usize)
[src]Tells this buffer that amt
bytes have been consumed from the buffer,
so they should no longer be returned in calls to read
. Read more
fn read_until(
&mut self,
byte: u8,
buf: &mut Vec<u8, Global>
) -> Result<usize, Error>
1.0.0[src]
fn read_until(
&mut self,
byte: u8,
buf: &mut Vec<u8, Global>
) -> Result<usize, Error>
1.0.0[src]Read all bytes into buf
until the delimiter byte
or EOF is reached. Read more
fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
1.0.0[src]
fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
1.0.0[src]Read all bytes until a newline (the 0xA
byte) is reached, and append
them to the provided buffer. Read more
impl<L, R> Clone for Either<L, R> where
R: Clone,
L: Clone,
[src]
impl<L, R> Clone for Either<L, R> where
R: Clone,
L: Clone,
[src]impl<L, R> Deref for Either<L, R> where
R: Deref<Target = <L as Deref>::Target>,
L: Deref,
[src]
impl<L, R> Deref for Either<L, R> where
R: Deref<Target = <L as Deref>::Target>,
L: Deref,
[src]impl<L, R> DerefMut for Either<L, R> where
R: DerefMut<Target = <L as Deref>::Target>,
L: DerefMut,
[src]
impl<L, R> DerefMut for Either<L, R> where
R: DerefMut<Target = <L as Deref>::Target>,
L: DerefMut,
[src]impl<L, R> DoubleEndedIterator for Either<L, R> where
R: DoubleEndedIterator<Item = <L as Iterator>::Item>,
L: DoubleEndedIterator,
[src]
impl<L, R> DoubleEndedIterator for Either<L, R> where
R: DoubleEndedIterator<Item = <L as Iterator>::Item>,
L: DoubleEndedIterator,
[src]pub fn next_back(&mut self) -> Option<<Either<L, R> as Iterator>::Item>
[src]
pub fn next_back(&mut self) -> Option<<Either<L, R> as Iterator>::Item>
[src]Removes and returns an element from the end of the iterator. Read more
fn advance_back_by(&mut self, n: usize) -> Result<(), usize>
[src]
fn advance_back_by(&mut self, n: usize) -> Result<(), usize>
[src]🔬 This is a nightly-only experimental API. (iter_advance_by
)
recently added
Advances the iterator from the back by n
elements. Read more
fn nth_back(&mut self, n: usize) -> Option<Self::Item>
1.37.0[src]
fn nth_back(&mut self, n: usize) -> Option<Self::Item>
1.37.0[src]Returns the n
th element from the end of the iterator. Read more
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
1.27.0[src]
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
1.27.0[src]This is the reverse version of Iterator::try_fold()
: it takes
elements starting from the back of the iterator. Read more
impl<L, R> Error for Either<L, R> where
R: Error,
L: Error,
[src]
impl<L, R> Error for Either<L, R> where
R: Error,
L: Error,
[src]Either
implements Error
if both L
and R
implement it.
pub fn description(&self) -> &str
[src]
pub fn description(&self) -> &str
[src]use the Display impl or to_string()
pub fn cause(&self) -> Option<&dyn Error>
[src]
pub fn cause(&self) -> Option<&dyn Error>
[src]replaced by Error::source, which can support downcasting
impl<L, R> ExactSizeIterator for Either<L, R> where
R: ExactSizeIterator<Item = <L as Iterator>::Item>,
L: ExactSizeIterator,
[src]
impl<L, R> ExactSizeIterator for Either<L, R> where
R: ExactSizeIterator<Item = <L as Iterator>::Item>,
L: ExactSizeIterator,
[src]impl<L, R, A> Extend<A> for Either<L, R> where
R: Extend<A>,
L: Extend<A>,
[src]
impl<L, R, A> Extend<A> for Either<L, R> where
R: Extend<A>,
L: Extend<A>,
[src]pub fn extend<T>(&mut self, iter: T) where
T: IntoIterator<Item = A>,
[src]
pub fn extend<T>(&mut self, iter: T) where
T: IntoIterator<Item = A>,
[src]Extends a collection with the contents of an iterator. Read more
fn extend_one(&mut self, item: A)
[src]
fn extend_one(&mut self, item: A)
[src]extend_one
)Extends a collection with exactly one element.
fn extend_reserve(&mut self, additional: usize)
[src]
fn extend_reserve(&mut self, additional: usize)
[src]extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
impl<L, R> From<Result<R, L>> for Either<L, R>
[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> Into<Result<R, L>> for Either<L, R>
[src]
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]
impl<L, R> Iterator for Either<L, R> where
R: Iterator<Item = <L as Iterator>::Item>,
L: Iterator,
[src]Either<L, R>
is an iterator if both L
and R
are iterators.
pub fn next(&mut self) -> Option<<Either<L, R> as Iterator>::Item>
[src]
pub fn next(&mut self) -> Option<<Either<L, R> as Iterator>::Item>
[src]Advances the iterator and returns the next value. Read more
pub fn size_hint(&self) -> (usize, Option<usize>)
[src]
pub fn size_hint(&self) -> (usize, Option<usize>)
[src]Returns the bounds on the remaining length of the iterator. Read more
pub fn fold<Acc, G>(self, init: Acc, f: G) -> Acc where
G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,
[src]
pub fn fold<Acc, G>(self, init: Acc, f: G) -> Acc where
G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,
[src]Folds every element into an accumulator by applying an operation, returning the final result. Read more
pub fn count(self) -> usize
[src]
pub fn count(self) -> usize
[src]Consumes the iterator, counting the number of iterations and returning it. Read more
pub fn last(self) -> Option<<Either<L, R> as Iterator>::Item>
[src]
pub fn last(self) -> Option<<Either<L, R> as Iterator>::Item>
[src]Consumes the iterator, returning the last element. Read more
pub fn nth(&mut self, n: usize) -> Option<<Either<L, R> as Iterator>::Item>
[src]
pub fn nth(&mut self, n: usize) -> Option<<Either<L, R> as Iterator>::Item>
[src]Returns the n
th element of the iterator. Read more
pub fn collect<B>(self) -> B where
B: FromIterator<<Either<L, R> as Iterator>::Item>,
[src]
pub fn collect<B>(self) -> B where
B: FromIterator<<Either<L, R> as Iterator>::Item>,
[src]Transforms an iterator into a collection. Read more
pub fn all<F>(&mut self, f: F) -> bool where
F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,
[src]
pub fn all<F>(&mut self, f: F) -> bool where
F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,
[src]Tests if every element of the iterator matches a predicate. Read more
fn advance_by(&mut self, n: usize) -> Result<(), usize>
[src]
fn advance_by(&mut self, n: usize) -> Result<(), usize>
[src]🔬 This is a nightly-only experimental API. (iter_advance_by
)
recently added
Advances the iterator by n
elements. Read more
fn step_by(self, step: usize) -> StepBy<Self>
1.28.0[src]
fn step_by(self, step: usize) -> StepBy<Self>
1.28.0[src]Creates an iterator starting at the same point, but stepping by the given amount at each iteration. Read more
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>,
1.0.0[src]
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>,
1.0.0[src]Takes two iterators and creates a new iterator over both in sequence. Read more
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator,
1.0.0[src]
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator,
1.0.0[src]‘Zips up’ two iterators into a single iterator of pairs. Read more
fn intersperse(self, separator: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
fn intersperse(self, separator: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]🔬 This is a nightly-only experimental API. (iter_intersperse
)
recently added
Creates a new iterator which places a copy of separator
between adjacent
items of the original iterator. Read more
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> where
G: FnMut() -> Self::Item,
[src]
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> where
G: FnMut() -> Self::Item,
[src]🔬 This is a nightly-only experimental API. (iter_intersperse
)
recently added
Creates a new iterator which places an item generated by separator
between adjacent items of the original iterator. Read more
fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,
1.0.0[src]
fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,
1.0.0[src]Takes a closure and creates an iterator which calls that closure on each element. Read more
fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
1.21.0[src]
fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
1.21.0[src]Calls a closure on each element of an iterator. Read more
fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]Creates an iterator which uses a closure to determine if an element should be yielded. Read more
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
1.0.0[src]
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
1.0.0[src]Creates an iterator that both filters and maps. Read more
fn enumerate(self) -> Enumerate<Self>
1.0.0[src]
fn enumerate(self) -> Enumerate<Self>
1.0.0[src]Creates an iterator which gives the current iteration count as well as the next value. Read more
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]Creates an iterator that yields elements based on a predicate. Read more
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>,
[src]
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>,
[src]🔬 This is a nightly-only experimental API. (iter_map_while
)
recently added
Creates an iterator that both yields elements based on a predicate and maps. Read more
fn skip(self, n: usize) -> Skip<Self>
1.0.0[src]
fn skip(self, n: usize) -> Skip<Self>
1.0.0[src]Creates an iterator that skips the first n
elements. Read more
fn take(self, n: usize) -> Take<Self>
1.0.0[src]
fn take(self, n: usize) -> Take<Self>
1.0.0[src]Creates an iterator that yields the first n
elements, or fewer
if the underlying iterator ends sooner. Read more
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]
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]fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
1.0.0[src]
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
1.0.0[src]Creates an iterator that works like map, but flattens nested structure. Read more
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator,
1.29.0[src]
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator,
1.29.0[src]Creates an iterator that flattens nested structure. Read more
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
1.0.0[src]
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
1.0.0[src]Does something with each element of an iterator, passing the value on. Read more
fn partition<B, F>(self, f: F) -> (B, B) where
F: FnMut(&Self::Item) -> bool,
B: Default + Extend<Self::Item>,
1.0.0[src]
fn partition<B, F>(self, f: F) -> (B, B) where
F: FnMut(&Self::Item) -> bool,
B: Default + Extend<Self::Item>,
1.0.0[src]Consumes an iterator, creating two collections from it. Read more
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]
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]🔬 This is a nightly-only experimental API. (iter_partition_in_place
)
new API
Reorders the elements of this iterator in-place according to the given predicate,
such that all those that return true
precede all those that return false
.
Returns the number of true
elements found. Read more
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]🔬 This is a nightly-only experimental API. (iter_is_partitioned
)
new API
Checks if the elements of this iterator are partitioned according to the given predicate,
such that all those that return true
precede all those that return false
. Read more
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
1.27.0[src]
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
1.27.0[src]An iterator method that applies a function as long as it returns successfully, producing a single, final value. Read more
fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
1.27.0[src]
fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
1.27.0[src]An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error. Read more
fn reduce<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
1.51.0[src]
fn reduce<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
1.51.0[src]Reduces the elements to a single one, by repeatedly applying a reducing operation. Read more
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]Tests if any element of the iterator matches a predicate. Read more
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]Searches for an element of an iterator that satisfies a predicate. Read more
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,
1.30.0[src]
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,
1.30.0[src]Applies function to the elements of iterator and returns the first non-none result. Read more
fn try_find<F, R, E>(&mut self, f: F) -> Result<Option<Self::Item>, E> where
F: FnMut(&Self::Item) -> R,
R: Try<Output = bool, Residual = Result<Infallible, E>> + Try,
[src]
fn try_find<F, R, E>(&mut self, f: F) -> Result<Option<Self::Item>, E> where
F: FnMut(&Self::Item) -> R,
R: Try<Output = bool, Residual = Result<Infallible, E>> + Try,
[src]🔬 This is a nightly-only experimental API. (try_find
)
new API
Applies function to the elements of iterator and returns the first true result or the first error. Read more
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
1.0.0[src]
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
1.0.0[src]Searches for an element in an iterator, returning its index. Read more
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
Self: ExactSizeIterator + DoubleEndedIterator,
P: FnMut(Self::Item) -> bool,
1.0.0[src]
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
Self: ExactSizeIterator + DoubleEndedIterator,
P: FnMut(Self::Item) -> bool,
1.0.0[src]Searches for an element in an iterator from the right, returning its index. Read more
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]Returns the maximum element of an iterator. Read more
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]Returns the minimum element of an iterator. Read more
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
B: Ord,
1.6.0[src]
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
B: Ord,
1.6.0[src]Returns the element that gives the maximum value from the specified function. Read more
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]Returns the element that gives the maximum value with respect to the specified comparison function. Read more
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
B: Ord,
1.6.0[src]
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
B: Ord,
1.6.0[src]Returns the element that gives the minimum value from the specified function. Read more
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]Returns the element that gives the minimum value with respect to the specified comparison function. Read more
fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator,
1.0.0[src]
fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator,
1.0.0[src]Reverses an iterator’s direction. Read more
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]
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]Converts an iterator of pairs into a pair of containers. Read more
fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
1.36.0[src]
fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
1.36.0[src]Creates an iterator which copies all of its elements. Read more
fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
1.0.0[src]
fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
1.0.0[src]fn sum<S>(self) -> S where
S: Sum<Self::Item>,
1.11.0[src]
fn sum<S>(self) -> S where
S: Sum<Self::Item>,
1.11.0[src]Sums the elements of an iterator. Read more
fn product<P>(self) -> P where
P: Product<Self::Item>,
1.11.0[src]
fn product<P>(self) -> P where
P: Product<Self::Item>,
1.11.0[src]Iterates over the entire iterator, multiplying all the elements Read more
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
1.5.0[src]
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
1.5.0[src]Lexicographically compares the elements of this Iterator
with those
of another. Read more
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
[src]
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
[src]iter_order_by
)Lexicographically compares the elements of this Iterator
with those
of another with respect to the specified comparison function. Read more
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Lexicographically compares the elements of this Iterator
with those
of another. Read more
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]
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]iter_order_by
)Lexicographically compares the elements of this Iterator
with those
of another with respect to the specified comparison function. Read more
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
[src]
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
[src]iter_order_by
)fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Determines if the elements of this Iterator
are lexicographically
less than those of another. Read more
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Determines if the elements of this Iterator
are lexicographically
less or equal to those of another. Read more
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Determines if the elements of this Iterator
are lexicographically
greater than those of another. Read more
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Determines if the elements of this Iterator
are lexicographically
greater than or equal to those of another. Read more
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]🔬 This is a nightly-only experimental API. (is_sorted
)
new API
Checks if the elements of this iterator are sorted. Read more
fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]
fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]🔬 This is a nightly-only experimental API. (is_sorted
)
new API
Checks if the elements of this iterator are sorted using the given comparator function. Read more
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
[src]
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
[src]🔬 This is a nightly-only experimental API. (is_sorted
)
new API
Checks if the elements of this iterator are sorted using the given key extraction function. Read more
impl<L, R> Ord for Either<L, R> where
R: Ord,
L: Ord,
[src]
impl<L, R> Ord for Either<L, R> where
R: Ord,
L: Ord,
[src]impl<L, R> PartialOrd<Either<L, R>> for Either<L, R> where
R: PartialOrd<R>,
L: PartialOrd<L>,
[src]
impl<L, R> PartialOrd<Either<L, R>> for Either<L, R> where
R: PartialOrd<R>,
L: PartialOrd<L>,
[src]pub fn partial_cmp(&self, other: &Either<L, R>) -> Option<Ordering>
[src]
pub fn partial_cmp(&self, other: &Either<L, R>) -> Option<Ordering>
[src]This method returns an ordering between self
and other
values if one exists. Read more
#[must_use]fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]fn lt(&self, other: &Rhs) -> bool
1.0.0[src]This method tests less than (for self
and other
) and is used by the <
operator. Read more
#[must_use]fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]fn le(&self, other: &Rhs) -> bool
1.0.0[src]This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
impl<L, R> Read for Either<L, R> where
R: Read,
L: Read,
[src]
impl<L, R> Read for Either<L, R> where
R: Read,
L: Read,
[src]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(&mut self, buf: &mut [u8]) -> Result<usize, Error>
[src]Pull some bytes from this source into the specified buffer, returning how many bytes were read. Read more
pub fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>
[src]
pub fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>
[src]Read all bytes until EOF in this source, placing them into buf
. Read more
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
1.36.0[src]
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
1.36.0[src]Like read
, except that it reads into a slice of buffers. Read more
fn is_read_vectored(&self) -> bool
[src]
fn is_read_vectored(&self) -> bool
[src]can_vector
)Determines if this Read
er has an efficient read_vectored
implementation. Read more
unsafe fn initializer(&self) -> Initializer
[src]
unsafe fn initializer(&self) -> Initializer
[src]read_initializer
)Determines if this Read
er can work with buffers of uninitialized
memory. Read more
fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
1.0.0[src]
fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
1.0.0[src]Read all bytes until EOF in this source, appending them to buf
. Read more
fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
1.6.0[src]
fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
1.6.0[src]Read the exact number of bytes required to fill buf
. Read more
fn by_ref(&mut self) -> &mut Self
1.0.0[src]
fn by_ref(&mut self) -> &mut Self
1.0.0[src]Creates a “by reference” adaptor for this instance of Read
. Read more
impl<L, R> Write for Either<L, R> where
R: Write,
L: Write,
[src]
impl<L, R> Write for Either<L, R> where
R: Write,
L: Write,
[src]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 write(&mut self, buf: &[u8]) -> Result<usize, Error>
[src]Write a buffer into this writer, returning how many bytes were written. Read more
pub fn flush(&mut self) -> Result<(), Error>
[src]
pub fn flush(&mut self) -> Result<(), Error>
[src]Flush this output stream, ensuring that all intermediately buffered contents reach their destination. Read more
fn is_write_vectored(&self) -> bool
[src]
fn is_write_vectored(&self) -> bool
[src]can_vector
)Determines if this Write
r has an efficient write_vectored
implementation. Read more
fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
1.0.0[src]
fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
1.0.0[src]Attempts to write an entire buffer into this writer. Read more
fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>
[src]
fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>
[src]write_all_vectored
)Attempts to write multiple buffers into this writer. Read more
impl<L, R> Copy for Either<L, R> where
R: Copy,
L: Copy,
[src]
R: Copy,
L: Copy,
impl<L, R> Eq for Either<L, R> where
R: Eq,
L: Eq,
[src]
R: Eq,
L: Eq,
impl<L, R> StructuralEq for Either<L, R>
[src]
impl<L, R> StructuralPartialEq for Either<L, R>
[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> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<It> IdentifyLast for It where
It: Iterator,
[src]
impl<It> IdentifyLast for It where
It: Iterator,
[src]impl<I> IntoIterator for I where
I: Iterator,
[src]
impl<I> IntoIterator for I where
I: Iterator,
[src]impl<I> IteratorExt for I where
I: Iterator,
[src]
impl<I> IteratorExt for I where
I: Iterator,
[src]fn chain_with<F, I>(self, f: F) -> ChainWith<Self, F, I::IntoIter>ⓘ where
Self: Sized,
F: FnOnce() -> I,
I: IntoIterator<Item = Self::Item>,
[src]
fn chain_with<F, I>(self, f: F) -> ChainWith<Self, F, I::IntoIter>ⓘ where
Self: Sized,
F: FnOnce() -> I,
I: IntoIterator<Item = Self::Item>,
[src]Copied from https://stackoverflow.com/a/49456265/6193633
impl<R> ReadBytesExt for R where
R: Read + ?Sized,
impl<R> ReadBytesExt for R where
R: Read + ?Sized,
fn read_u8(&mut self) -> Result<u8, Error>
fn read_u8(&mut self) -> Result<u8, Error>
Reads an unsigned 8 bit integer from the underlying reader. Read more
fn read_i8(&mut self) -> Result<i8, Error>
fn read_i8(&mut self) -> Result<i8, Error>
Reads a signed 8 bit integer from the underlying reader. Read more
fn read_u16<T>(&mut self) -> Result<u16, Error> where
T: ByteOrder,
fn read_u16<T>(&mut self) -> Result<u16, Error> where
T: ByteOrder,
Reads an unsigned 16 bit integer from the underlying reader. Read more
fn read_i16<T>(&mut self) -> Result<i16, Error> where
T: ByteOrder,
fn read_i16<T>(&mut self) -> Result<i16, Error> where
T: ByteOrder,
Reads a signed 16 bit integer from the underlying reader. Read more
fn read_u24<T>(&mut self) -> Result<u32, Error> where
T: ByteOrder,
fn read_u24<T>(&mut self) -> Result<u32, Error> where
T: ByteOrder,
Reads an unsigned 24 bit integer from the underlying reader. Read more
fn read_i24<T>(&mut self) -> Result<i32, Error> where
T: ByteOrder,
fn read_i24<T>(&mut self) -> Result<i32, Error> where
T: ByteOrder,
Reads a signed 24 bit integer from the underlying reader. Read more
fn read_u32<T>(&mut self) -> Result<u32, Error> where
T: ByteOrder,
fn read_u32<T>(&mut self) -> Result<u32, Error> where
T: ByteOrder,
Reads an unsigned 32 bit integer from the underlying reader. Read more
fn read_i32<T>(&mut self) -> Result<i32, Error> where
T: ByteOrder,
fn read_i32<T>(&mut self) -> Result<i32, Error> where
T: ByteOrder,
Reads a signed 32 bit integer from the underlying reader. Read more
fn read_u48<T>(&mut self) -> Result<u64, Error> where
T: ByteOrder,
fn read_u48<T>(&mut self) -> Result<u64, Error> where
T: ByteOrder,
Reads an unsigned 48 bit integer from the underlying reader. Read more
fn read_i48<T>(&mut self) -> Result<i64, Error> where
T: ByteOrder,
fn read_i48<T>(&mut self) -> Result<i64, Error> where
T: ByteOrder,
Reads a signed 48 bit integer from the underlying reader. Read more
fn read_u64<T>(&mut self) -> Result<u64, Error> where
T: ByteOrder,
fn read_u64<T>(&mut self) -> Result<u64, Error> where
T: ByteOrder,
Reads an unsigned 64 bit integer from the underlying reader. Read more
fn read_i64<T>(&mut self) -> Result<i64, Error> where
T: ByteOrder,
fn read_i64<T>(&mut self) -> Result<i64, Error> where
T: ByteOrder,
Reads a signed 64 bit integer from the underlying reader. Read more
fn read_u128<T>(&mut self) -> Result<u128, Error> where
T: ByteOrder,
fn read_u128<T>(&mut self) -> Result<u128, Error> where
T: ByteOrder,
Reads an unsigned 128 bit integer from the underlying reader. Read more
fn read_i128<T>(&mut self) -> Result<i128, Error> where
T: ByteOrder,
fn read_i128<T>(&mut self) -> Result<i128, Error> where
T: ByteOrder,
Reads a signed 128 bit integer from the underlying reader. Read more
fn read_uint<T>(&mut self, nbytes: usize) -> Result<u64, Error> where
T: ByteOrder,
fn read_uint<T>(&mut self, nbytes: usize) -> Result<u64, Error> where
T: ByteOrder,
Reads an unsigned n-bytes integer from the underlying reader. Read more
fn read_int<T>(&mut self, nbytes: usize) -> Result<i64, Error> where
T: ByteOrder,
fn read_int<T>(&mut self, nbytes: usize) -> Result<i64, Error> where
T: ByteOrder,
Reads a signed n-bytes integer from the underlying reader. Read more
fn read_uint128<T>(&mut self, nbytes: usize) -> Result<u128, Error> where
T: ByteOrder,
fn read_uint128<T>(&mut self, nbytes: usize) -> Result<u128, Error> where
T: ByteOrder,
Reads an unsigned n-bytes integer from the underlying reader.
fn read_int128<T>(&mut self, nbytes: usize) -> Result<i128, Error> where
T: ByteOrder,
fn read_int128<T>(&mut self, nbytes: usize) -> Result<i128, Error> where
T: ByteOrder,
Reads a signed n-bytes integer from the underlying reader.
fn read_f32<T>(&mut self) -> Result<f32, Error> where
T: ByteOrder,
fn read_f32<T>(&mut self) -> Result<f32, Error> where
T: ByteOrder,
Reads a IEEE754 single-precision (4 bytes) floating point number from the underlying reader. Read more
fn read_f64<T>(&mut self) -> Result<f64, Error> where
T: ByteOrder,
fn read_f64<T>(&mut self) -> Result<f64, Error> where
T: ByteOrder,
Reads a IEEE754 double-precision (8 bytes) floating point number from the underlying reader. Read more
fn read_u16_into<T>(&mut self, dst: &mut [u16]) -> Result<(), Error> where
T: ByteOrder,
fn read_u16_into<T>(&mut self, dst: &mut [u16]) -> Result<(), Error> where
T: ByteOrder,
Reads a sequence of unsigned 16 bit integers from the underlying reader. Read more
fn read_u32_into<T>(&mut self, dst: &mut [u32]) -> Result<(), Error> where
T: ByteOrder,
fn read_u32_into<T>(&mut self, dst: &mut [u32]) -> Result<(), Error> where
T: ByteOrder,
Reads a sequence of unsigned 32 bit integers from the underlying reader. Read more
fn read_u64_into<T>(&mut self, dst: &mut [u64]) -> Result<(), Error> where
T: ByteOrder,
fn read_u64_into<T>(&mut self, dst: &mut [u64]) -> Result<(), Error> where
T: ByteOrder,
Reads a sequence of unsigned 64 bit integers from the underlying reader. Read more
fn read_u128_into<T>(&mut self, dst: &mut [u128]) -> Result<(), Error> where
T: ByteOrder,
fn read_u128_into<T>(&mut self, dst: &mut [u128]) -> Result<(), Error> where
T: ByteOrder,
Reads a sequence of unsigned 128 bit integers from the underlying reader. Read more
fn read_i8_into(&mut self, dst: &mut [i8]) -> Result<(), Error>
fn read_i8_into(&mut self, dst: &mut [i8]) -> Result<(), Error>
Reads a sequence of signed 8 bit integers from the underlying reader. Read more
fn read_i16_into<T>(&mut self, dst: &mut [i16]) -> Result<(), Error> where
T: ByteOrder,
fn read_i16_into<T>(&mut self, dst: &mut [i16]) -> Result<(), Error> where
T: ByteOrder,
Reads a sequence of signed 16 bit integers from the underlying reader. Read more
fn read_i32_into<T>(&mut self, dst: &mut [i32]) -> Result<(), Error> where
T: ByteOrder,
fn read_i32_into<T>(&mut self, dst: &mut [i32]) -> Result<(), Error> where
T: ByteOrder,
Reads a sequence of signed 32 bit integers from the underlying reader. Read more
fn read_i64_into<T>(&mut self, dst: &mut [i64]) -> Result<(), Error> where
T: ByteOrder,
fn read_i64_into<T>(&mut self, dst: &mut [i64]) -> Result<(), Error> where
T: ByteOrder,
Reads a sequence of signed 64 bit integers from the underlying reader. Read more
fn read_i128_into<T>(&mut self, dst: &mut [i128]) -> Result<(), Error> where
T: ByteOrder,
fn read_i128_into<T>(&mut self, dst: &mut [i128]) -> Result<(), Error> where
T: ByteOrder,
Reads a sequence of signed 128 bit integers from the underlying reader. Read more
fn read_f32_into<T>(&mut self, dst: &mut [f32]) -> Result<(), Error> where
T: ByteOrder,
fn read_f32_into<T>(&mut self, dst: &mut [f32]) -> Result<(), Error> where
T: ByteOrder,
Reads a sequence of IEEE754 single-precision (4 bytes) floating point numbers from the underlying reader. Read more
fn read_f32_into_unchecked<T>(&mut self, dst: &mut [f32]) -> Result<(), Error> where
T: ByteOrder,
fn read_f32_into_unchecked<T>(&mut self, dst: &mut [f32]) -> Result<(), Error> where
T: ByteOrder,
please use read_f32_into
instead
DEPRECATED. Read more
impl<T> ToOwned for T where
T: Clone,
[src]
impl<T> ToOwned for T where
T: Clone,
[src]type Owned = T
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn to_owned(&self) -> T
[src]Creates owned data from borrowed data, usually by cloning. Read more
pub fn clone_into(&self, target: &mut T)
[src]
pub fn clone_into(&self, target: &mut T)
[src]🔬 This is a nightly-only experimental API. (toowned_clone_into
)
recently added
Uses borrowed data to replace owned data, usually by cloning. Read more
impl<W> WriteBytesExt for W where
W: Write + ?Sized,
impl<W> WriteBytesExt for W where
W: Write + ?Sized,
fn write_u8(&mut self, n: u8) -> Result<(), Error>
fn write_u8(&mut self, n: u8) -> Result<(), Error>
Writes an unsigned 8 bit integer to the underlying writer. Read more
fn write_i8(&mut self, n: i8) -> Result<(), Error>
fn write_i8(&mut self, n: i8) -> Result<(), Error>
Writes a signed 8 bit integer to the underlying writer. Read more
fn write_u16<T>(&mut self, n: u16) -> Result<(), Error> where
T: ByteOrder,
fn write_u16<T>(&mut self, n: u16) -> Result<(), Error> where
T: ByteOrder,
Writes an unsigned 16 bit integer to the underlying writer. Read more
fn write_i16<T>(&mut self, n: i16) -> Result<(), Error> where
T: ByteOrder,
fn write_i16<T>(&mut self, n: i16) -> Result<(), Error> where
T: ByteOrder,
Writes a signed 16 bit integer to the underlying writer. Read more
fn write_u24<T>(&mut self, n: u32) -> Result<(), Error> where
T: ByteOrder,
fn write_u24<T>(&mut self, n: u32) -> Result<(), Error> where
T: ByteOrder,
Writes an unsigned 24 bit integer to the underlying writer. Read more
fn write_i24<T>(&mut self, n: i32) -> Result<(), Error> where
T: ByteOrder,
fn write_i24<T>(&mut self, n: i32) -> Result<(), Error> where
T: ByteOrder,
Writes a signed 24 bit integer to the underlying writer. Read more
fn write_u32<T>(&mut self, n: u32) -> Result<(), Error> where
T: ByteOrder,
fn write_u32<T>(&mut self, n: u32) -> Result<(), Error> where
T: ByteOrder,
Writes an unsigned 32 bit integer to the underlying writer. Read more
fn write_i32<T>(&mut self, n: i32) -> Result<(), Error> where
T: ByteOrder,
fn write_i32<T>(&mut self, n: i32) -> Result<(), Error> where
T: ByteOrder,
Writes a signed 32 bit integer to the underlying writer. Read more
fn write_u48<T>(&mut self, n: u64) -> Result<(), Error> where
T: ByteOrder,
fn write_u48<T>(&mut self, n: u64) -> Result<(), Error> where
T: ByteOrder,
Writes an unsigned 48 bit integer to the underlying writer. Read more
fn write_i48<T>(&mut self, n: i64) -> Result<(), Error> where
T: ByteOrder,
fn write_i48<T>(&mut self, n: i64) -> Result<(), Error> where
T: ByteOrder,
Writes a signed 48 bit integer to the underlying writer. Read more
fn write_u64<T>(&mut self, n: u64) -> Result<(), Error> where
T: ByteOrder,
fn write_u64<T>(&mut self, n: u64) -> Result<(), Error> where
T: ByteOrder,
Writes an unsigned 64 bit integer to the underlying writer. Read more
fn write_i64<T>(&mut self, n: i64) -> Result<(), Error> where
T: ByteOrder,
fn write_i64<T>(&mut self, n: i64) -> Result<(), Error> where
T: ByteOrder,
Writes a signed 64 bit integer to the underlying writer. Read more
fn write_u128<T>(&mut self, n: u128) -> Result<(), Error> where
T: ByteOrder,
fn write_u128<T>(&mut self, n: u128) -> Result<(), Error> where
T: ByteOrder,
Writes an unsigned 128 bit integer to the underlying writer.
fn write_i128<T>(&mut self, n: i128) -> Result<(), Error> where
T: ByteOrder,
fn write_i128<T>(&mut self, n: i128) -> Result<(), Error> where
T: ByteOrder,
Writes a signed 128 bit integer to the underlying writer.
fn write_uint<T>(&mut self, n: u64, nbytes: usize) -> Result<(), Error> where
T: ByteOrder,
fn write_uint<T>(&mut self, n: u64, nbytes: usize) -> Result<(), Error> where
T: ByteOrder,
Writes an unsigned n-bytes integer to the underlying writer. Read more
fn write_int<T>(&mut self, n: i64, nbytes: usize) -> Result<(), Error> where
T: ByteOrder,
fn write_int<T>(&mut self, n: i64, nbytes: usize) -> Result<(), Error> where
T: ByteOrder,
Writes a signed n-bytes integer to the underlying writer. Read more
fn write_uint128<T>(&mut self, n: u128, nbytes: usize) -> Result<(), Error> where
T: ByteOrder,
fn write_uint128<T>(&mut self, n: u128, nbytes: usize) -> Result<(), Error> where
T: ByteOrder,
Writes an unsigned n-bytes integer to the underlying writer. Read more
fn write_int128<T>(&mut self, n: i128, nbytes: usize) -> Result<(), Error> where
T: ByteOrder,
fn write_int128<T>(&mut self, n: i128, nbytes: usize) -> Result<(), Error> where
T: ByteOrder,
Writes a signed n-bytes integer to the underlying writer. Read more