Enum sp_runtime :: Either Copy item path

Left(L)

A value of type L.

Right(R)

A value of type R.

Implementations§

impl<L, R> Either<L, R>

pub fn is_left(&self) -> bool

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

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>

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>

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> ⓘ

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> ⓘ

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 as_pin_ref(self: Pin<&Either<L, R>>) -> Either<Pin<&L>, Pin<&R>> ⓘ

Convert Pin<&Either<L, R>> to Either<Pin<&L>, Pin<&R>>, pinned projections of the inner variants.

pub fn as_pin_mut( self: Pin<&mut Either<L, R>>, ) -> Either<Pin<&mut L>, Pin<&mut R>> ⓘ

Convert Pin<&mut Either<L, R>> to Either<Pin<&mut L>, Pin<&mut R>>, pinned projections of the inner variants.

pub fn flip(self) -> Either<R, L> ⓘ

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,

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,

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 map_either<F, G, M, S>(self, f: F, g: G) -> Either<M, S> ⓘ
where F: FnOnce(L) -> M, G: FnOnce(R) -> S,

Apply the functions f and g to the Left and Right variants respectively. This is equivalent to bimap in functional programming.

use either::*;

let f = |s: String| s.len();
let g = |u: u8| u.to_string();

let left: Either<String, u8> = Left("loopy".into());
assert_eq!(left.map_either(f, g), Left(5));

let right: Either<String, u8> = Right(42);
assert_eq!(right.map_either(f, g), Right("42".into()));

pub fn map_either_with<Ctx, F, G, M, S>( self, ctx: Ctx, f: F, g: G, ) -> Either<M, S> ⓘ
where F: FnOnce(Ctx, L) -> M, G: FnOnce(Ctx, R) -> S,

Similar to map_either, with an added context ctx accessible to both functions.

use either::*;

let mut sum = 0;

// Both closures want to update the same value, so pass it as context.
let mut f = |sum: &mut usize, s: String| { *sum += s.len(); s.to_uppercase() };
let mut g = |sum: &mut usize, u: usize| { *sum += u; u.to_string() };

let left: Either<String, usize> = Left("loopy".into());
assert_eq!(left.map_either_with(&mut sum, &mut f, &mut g), Left("LOOPY".into()));

let right: Either<String, usize> = Right(42);
assert_eq!(right.map_either_with(&mut sum, &mut f, &mut g), Right("42".into()));

assert_eq!(sum, 47);

pub fn either<F, G, T>(self, f: F, g: G) -> T
where 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,

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>,

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>,

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 L: IntoIterator, R: IntoIterator<Item = <L as IntoIterator>::Item>,

Convert the inner value to an iterator.

This requires the Left and Right iterators to have the same item type. See factor_into_iter to iterate different types.

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 iter( &self, ) -> Either<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter> ⓘ
where &'a L: for<'a> IntoIterator, &'a R: for<'a> IntoIterator<Item = <&'a L as IntoIterator>::Item>,

Borrow the inner value as an iterator.

This requires the Left and Right iterators to have the same item type. See factor_iter to iterate different types.

use either::*;

let left: Either<_, &[u32]> = Left(vec![2, 3]);
let mut right: Either<Vec<u32>, _> = Right(&[4, 5][..]);
let mut all = vec![1];
all.extend(left.iter());
all.extend(right.iter());
assert_eq!(all, vec![1, 2, 3, 4, 5]);

pub fn iter_mut( &mut self, ) -> Either<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter> ⓘ
where &'a mut L: for<'a> IntoIterator, &'a mut R: for<'a> IntoIterator<Item = <&'a mut L as IntoIterator>::Item>,

Mutably borrow the inner value as an iterator.

This requires the Left and Right iterators to have the same item type. See factor_iter_mut to iterate different types.

use either::*;

let mut left: Either<_, &mut [u32]> = Left(vec![2, 3]);
for l in left.iter_mut() {
    *l *= *l
}
assert_eq!(left, Left(vec![4, 9]));

let mut inner = [4, 5];
let mut right: Either<Vec<u32>, _> = Right(&mut inner[..]);
for r in right.iter_mut() {
    *r *= *r
}
assert_eq!(inner, [16, 25]);

pub fn factor_into_iter( self, ) -> IterEither<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter>
where L: IntoIterator, R: IntoIterator,

Converts an Either of Iterators to be an Iterator of Eithers

Unlike into_iter, this does not require the Left and Right iterators to have the same item type.

use either::*;
let left: Either<_, Vec<u8>> = Left(&["hello"]);
assert_eq!(left.factor_into_iter().next(), Some(Left(&"hello")));
let right: Either<&[&str], _> = Right(vec![0, 1]);
assert_eq!(right.factor_into_iter().collect::<Vec<_>>(), vec![Right(0), Right(1)]);

pub fn factor_iter( &self, ) -> IterEither<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter>
where &'a L: for<'a> IntoIterator, &'a R: for<'a> IntoIterator,

Borrows an Either of Iterators to be an Iterator of Eithers

Unlike iter, this does not require the Left and Right iterators to have the same item type.

use either::*;
let left: Either<_, Vec<u8>> = Left(["hello"]);
assert_eq!(left.factor_iter().next(), Some(Left(&"hello")));
let right: Either<[&str; 2], _> = Right(vec![0, 1]);
assert_eq!(right.factor_iter().collect::<Vec<_>>(), vec![Right(&0), Right(&1)]);

pub fn factor_iter_mut( &mut self, ) -> IterEither<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter>
where &'a mut L: for<'a> IntoIterator, &'a mut R: for<'a> IntoIterator,

Mutably borrows an Either of Iterators to be an Iterator of Eithers

Unlike iter_mut, this does not require the Left and Right iterators to have the same item type.

use either::*;
let mut left: Either<_, Vec<u8>> = Left(["hello"]);
left.factor_iter_mut().for_each(|x| *x.unwrap_left() = "goodbye");
assert_eq!(left, Left(["goodbye"]));
let mut right: Either<[&str; 2], _> = Right(vec![0, 1, 2]);
right.factor_iter_mut().for_each(|x| if let Right(r) = x { *r = -*r; });
assert_eq!(right, Right(vec![0, -1, -2]));

pub fn left_or(self, other: L) -> L

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,

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,

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

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,

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,

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,

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,

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,

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,

Returns the right value

§Examples

let right: Either<(), _> = Right(3);
assert_eq!(right.expect_right("value was Left"), 3);

§Panics

When Either is a Left value

let left: Either<_, ()> = Left(3);
left.expect_right("value was Right");

pub fn either_into<T>(self) -> T
where L: Into<T>, R: Into<T>,

Convert the contained value into T

§Examples

// Both u16 and u32 can be converted to u64.
let left: Either<u16, u32> = Left(3u16);
assert_eq!(left.either_into::<u64>(), 3u64);
let right: Either<u16, u32> = Right(7u32);
assert_eq!(right.either_into::<u64>(), 7u64);

impl<L, R> Either<Option<L>, Option<R>>

pub fn factor_none(self) -> Option<Either<L, R>>

Factors out None from an Either of Option.

use either::*;
let left: Either<_, Option<String>> = Left(Some(vec![0]));
assert_eq!(left.factor_none(), Some(Left(vec![0])));

let right: Either<Option<Vec<u8>>, _> = Right(Some(String::new()));
assert_eq!(right.factor_none(), Some(Right(String::new())));

impl<L, R, E> Either<Result<L, E>, Result<R, E>>

pub fn factor_err(self) -> Result<Either<L, R>, E>

Factors out a homogenous type from an Either of Result.

Here, the homogeneous type is the Err type of the Result.

use either::*;
let left: Either<_, Result<String, u32>> = Left(Ok(vec![0]));
assert_eq!(left.factor_err(), Ok(Left(vec![0])));

let right: Either<Result<Vec<u8>, u32>, _> = Right(Ok(String::new()));
assert_eq!(right.factor_err(), Ok(Right(String::new())));

impl<T, L, R> Either<Result<T, L>, Result<T, R>>

pub fn factor_ok(self) -> Result<T, Either<L, R>>

Factors out a homogenous type from an Either of Result.

Here, the homogeneous type is the Ok type of the Result.

use either::*;
let left: Either<_, Result<u32, String>> = Left(Err(vec![0]));
assert_eq!(left.factor_ok(), Err(Left(vec![0])));

let right: Either<Result<u32, Vec<u8>>, _> = Right(Err(String::new()));
assert_eq!(right.factor_ok(), Err(Right(String::new())));

impl<T, L, R> Either<(T, L), (T, R)>

pub fn factor_first(self) -> (T, Either<L, R>)

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)>

pub fn factor_second(self) -> (Either<L, R>, T)

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);

pub fn copied(self) -> Either<L, R> ⓘ
where L: Copy, R: Copy,

Maps an Either<&L, &R> to an Either<L, R> by copying the contents of either branch.

impl<L, R> Either<&mut L, &mut R>

pub fn cloned(self) -> Either<L, R> ⓘ
where L: Clone, R: Clone,

Maps an Either<&mut L, &mut R> to an Either<L, R> by cloning the contents of either branch.

pub fn copied(self) -> Either<L, R> ⓘ
where L: Copy, R: Copy,

Maps an Either<&mut L, &mut R> to an Either<L, R> by copying the contents of either branch.

Trait Implementations§

fn skip_until(&mut self, byte: u8) -> Result<usize, Error>

🔬This is a nightly-only experimental API. (bufread_skip_until)

Skip all bytes until the delimiter byte or EOF is reached. Read more

1.0.0 · source§

fn split(self, byte: u8) -> Split<Self>
where Self: Sized,

Returns an iterator over the contents of this reader split on the byte byte. Read more

1.0.0 · source§

fn lines(self) -> Lines<Self>
where Self: Sized,

Returns an iterator over the lines of this reader. Read more

impl<L, R> Clone for Either<L, R>
where L: Clone, R: Clone,

fn clone(&self) -> Either<L, R> ⓘ

Returns a copy of the value. Read more

Convert from Result to Either with Ok => Right and Err => Left.

fn from(r: Result<R, L>) -> Either<L, R> ⓘ

Converts to this type from the input type.

impl<L, R> Future for Either<L, R>
where L: Future, R: Future<Output = <L as Future>::Output>,

Either<L, R> is a future if both L and R are futures.

type Output = <L as Future>::Output

The type of value produced on completion.

fn poll( self: Pin<&mut Either<L, R>>, cx: &mut Context<'_>, ) -> Poll<<Either<L, R> as Future>::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available. Read more

impl<L, R> Hash for Either<L, R>
where L: Hash, R: Hash,

fn hash<H>(&self, state: &mut H)
where __H: Hasher,

Feeds this value into the given Hasher. Read more

1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more

Searches for an element in an iterator, returning its index. Read more

fn next_chunk<const N: usize>( &mut self, ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
where Self: Sized,

🔬This is a nightly-only experimental API. (iter_next_chunk)

Advances the iterator and returns an array containing the next N values. Read more

fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)

Advances the iterator by n elements. Read more

1.28.0 · source§

fn step_by(self, step: usize) -> StepBy<Self>
where Self: Sized,

Creates an iterator starting at the same point, but stepping by the given amount at each iteration. Read more

1.0.0 · source§

fn chain(self, other: U) -> Chain<Self, ::IntoIter>
where Self: Sized, U: IntoIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both in sequence. Read more

1.0.0 · source§

fn zip(self, other: U) -> Zip<Self, ::IntoIter>
where Self: Sized, U: IntoIterator,

‘Zips up’ two iterators into a single iterator of pairs. Read more

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
where Self: Sized, G: FnMut() -> Self::Item,

🔬This is a nightly-only experimental API. (iter_intersperse)

fn fuse(self) -> Fuse<Self>
where Self: Sized,

Creates an iterator which ends after the first None. Read more

1.0.0 · source§

fn inspect<F>(self, f: F) -> Inspect<Self, F>
where Self: Sized, F: FnMut(&Self::Item),

Does something with each element of an iterator, passing the value on. Read more

1.0.0 · source§

fn by_ref(&mut self) -> &mut Self
where Self: Sized,

Borrows an iterator, rather than consuming it. Read more

fn collect_into<E>(self, collection: &mut E) -> &mut E
where E: Extend<Self::Item>, Self: Sized,

🔬This is a nightly-only experimental API. (iter_collect_into)

Collects all the items from an iterator into a collection. Read more

fn is_partitioned(self, predicate: P) -> bool
where Self: Sized, P: FnMut(Self::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_is_partitioned)

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

1.27.0 · source§

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

An iterator method that applies a function as long as it returns successfully, producing a single, final value. Read more

1.27.0 · source§

fn try_for_each<F, R>(&mut self, f: F) -> R
where Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = ()>,

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

1.51.0 · source§

fn reduce<F>(self, f: F) -> Option<Self::Item>
where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the elements to a single one, by repeatedly applying a reducing operation. Read more

fn try_reduce<R>( &mut self, f: impl FnMut(Self::Item, Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
where Self: Sized, R: Try<Output = Self::Item>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (iterator_try_reduce)

Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately. Read more

fn try_find<R>( &mut self, f: impl FnMut(&Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
where Self: Sized, R: Try<Output = bool>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (try_find)

Applies function to the elements of iterator and returns the first true result or the first error. Read more

1.6.0 · source§

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the maximum value from the specified function. Read more

1.15.0 · source§

fn max_by<F>(self, compare: F) -> Option<Self::Item>
where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the maximum value with respect to the specified comparison function. Read more

1.6.0 · source§

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the minimum value from the specified function. Read more

1.15.0 · source§

fn min_by<F>(self, compare: F) -> Option<Self::Item>
where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the minimum value with respect to the specified comparison function. Read more

1.0.0 · source§

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
where FromA: Default + Extend<A>, FromB: Default + Extend, Self: Sized + Iterator<Item = (A, B)>,

Converts an iterator of pairs into a pair of containers. Read more

1.36.0 · source§

fn copied<'a, T>(self) -> Copied<Self>
where T: 'a + Copy, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which copies all of its elements. Read more

1.0.0 · source§

fn cloned<'a, T>(self) -> Cloned<Self>
where T: 'a + Clone, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which clones all of its elements. Read more

fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
where Self: Sized,

🔬This is a nightly-only experimental API. (iter_array_chunks)

Returns an iterator over N elements of the iterator at a time. Read more

1.11.0 · source§

impl<L, R> PartialEq for Either<L, R>
where L: PartialEq, R: PartialEq,

fn eq(&self, other: &Either<L, R>) -> bool

This method tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

Either<L, R> implements Read if both L and R do.

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation. Read more

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer. Read more

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error>

Seek to an offset, in bytes, in a stream. Read more

1.55.0 · source§

fn rewind(&mut self) -> Result<(), Error>

Rewind to the beginning of a stream. Read more

fn stream_len(&mut self) -> Result<u64, Error>

🔬This is a nightly-only experimental API. (seek_stream_len)

Returns the length of this stream (in bytes). Read more

1.51.0 · source§

fn stream_position(&mut self) -> Result<u64, Error>

Returns the current seek position from the start of the stream. Read more

1.80.0 · source§

fn seek_relative(&mut self, offset: i64) -> Result<(), Error>

Seeks relative to the current position. Read more

impl<L, R> Write for Either<L, R>
where L: Write, R: Write,

Either<L, R> implements Write if both L and R do.

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation. Read more

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer. Read more

1.0.0 · source§

fn by_ref(&mut self) -> &mut Self
where Self: Sized,

Creates a “by reference” adapter for this instance of Write. Read more

impl<L, R> Copy for Either<L, R>
where L: Copy, R: Copy,

impl<L, R> Eq for Either<L, R>
where L: Eq, R: Eq,

impl<L, R> FusedIterator for Either<L, R>
where L: FusedIterator, R: FusedIterator<Item = <L as Iterator>::Item>,

impl<L, R> StructuralPartialEq for Either<L, R>

Auto Trait Implementations§

Views self as an immutable bit-slice region with the O ordering.

fn try_as_bits<O>(&self) -> Result<&BitSlice<T, O>, BitSpanError<T>>
where O: BitOrder,

Attempts to view self as an immutable bit-slice region with the O ordering. Read more

impl<T, U> AsByteSlice<T> for U
where T: ToByteSlice, U: AsRef<[T]> + ?Sized,

fn as_byte_slice(&self) -> &[u8] ⓘ

impl<A, T> AsMutBits<T> for A
where A: AsMut<[T]>, T: BitStore,

fn as_mut_bits<O>(&mut self) -> &mut BitSlice<T, O> ⓘ
where O: BitOrder,

Views self as a mutable bit-slice region with the O ordering.

fn try_as_mut_bits<O>(&mut self) -> Result<&mut BitSlice<T, O>, BitSpanError<T>>
where O: BitOrder,

Attempts to view self as a mutable bit-slice region with the O ordering. Read more

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> CallHasher for T
where T: Hash + ?Sized,

fn get_hash<H, B>(value: &H, build_hasher: &B) -> u64
where H: Hash + ?Sized, B: BuildHasher,

impl<T> CheckedConversion for T

fn checked_from<T>(t: T) -> Option<Self>
where Self: TryFrom<T>,

Convert from a value of T into an equivalent instance of Option<Self>. Read more

fn checked_into<T>(self) -> Option<T>
where Self: TryInto<T>,

Consume self to return Some equivalent value of Option<T>. Read more

Compare self to key and return their ordering.

impl<T> Conv for T

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more

impl<T> DynClone for T
where T: Clone,

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

fn into_par_iter(self) -> T

Converts self into a parallel iterator. Read more

impl<Src, Dest> IntoTuple<Dest> for Src
where Dest: FromTuple<Src>,

fn into_tuple(self) -> Dest

impl<T, Outer> IsWrappedBy<Outer> for T
where Outer: AsRef<T> + AsMut<T> + From<T>, T: From<Outer>,

fn from_ref(outer: &Outer) -> &T

Get a reference to the inner from the outer.

fn from_mut(outer: &mut Outer) -> &mut T

Get a mutable reference to the inner from the outer.

impl IteratorRandom for I
where I: Iterator,

fn choose<R>(self, rng: &mut R) -> Option<Self::Item>
where R: Rng + ?Sized,

Choose one element at random from the iterator. Read more

fn choose_stable<R>(self, rng: &mut R) -> Option<Self::Item>
where R: Rng + ?Sized,

Choose one element at random from the iterator. Read more

fn choose_multiple_fill<R>(self, rng: &mut R, buf: &mut [Self::Item]) -> usize
where R: Rng + ?Sized,

Collects values at random from the iterator into a supplied buffer until that buffer is filled. Read more

fn choose_multiple<R>(self, rng: &mut R, amount: usize) -> Vec<Self::Item>
where R: Rng + ?Sized,

Collects amount values at random from the iterator into a vector. Read more

👎Deprecated since 0.8.0: Use std .step_by() instead

Return an iterator adaptor that steps n elements in the base iterator for each iteration. Read more

fn map_into<R>(self) -> MapSpecialCase<Self, MapSpecialCaseFnInto<R>>
where Self: Sized, Self::Item: Into<R>,

Convert each item of the iterator using the Into trait. Read more

fn map_results<F, T, U, E>( self, f: F, ) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>
where Self: Sized + Iterator<Item = Result<T, E>>, F: FnMut(T) -> U,

👎Deprecated since 0.10.0: Use .map_ok() instead

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,

Fold Result values from an iterator. Read more

fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option
where Self: Iterator<Item = Option<A>>, F: FnMut(B, A) -> B,

Fold Option values from an iterator. Read more

fn fold1<F>(self, f: F) -> Option<Self::Item>
where F: FnMut(Self::Item, Self::Item) -> Self::Item, Self: Sized,

👎Deprecated since 0.10.2: Use Iterator::reduce instead

Converts an iterator of tuples into a tuple of containers. Read more

👎Deprecated since 0.8.0: Use std .step_by() instead

Return an iterator adaptor that steps n elements in the base iterator for each iteration. Read more

fn map_into<R>(self) -> MapSpecialCase<Self, MapSpecialCaseFnInto<R>>
where Self: Sized, Self::Item: Into<R>,

Convert each item of the iterator using the Into trait. Read more

fn map_results<F, T, U, E>( self, f: F, ) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>
where Self: Sized + Iterator<Item = Result<T, E>>, F: FnMut(T) -> U,

👎Deprecated since 0.10.0: Use .map_ok() instead

👎Deprecated since 0.8.0: Use .for_each() instead

👎Deprecated since 0.10.0: Use .fold_ok() instead

See .fold_ok().

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,

Fold Result values from an iterator. Read more

fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option
where Self: Iterator<Item = Option<A>>, F: FnMut(B, A) -> B,

Fold Option values from an iterator. Read more

fn fold1<F>(self, f: F) -> Option<Self::Item>
where F: FnMut(Self::Item, Self::Item) -> Self::Item, Self: Sized,

👎Deprecated since 0.10.2: Use Iterator::reduce instead

fn read_f32_into_unchecked<T>(&mut self, dst: &mut [f32]) -> Result<(), Error>
where T: ByteOrder,

👎Deprecated since 1.2.0: please use read_f32_into instead

DEPRECATED. Read more

fn read_f64_into<T>(&mut self, dst: &mut [f64]) -> Result<(), Error>
where T: ByteOrder,

Reads a sequence of IEEE754 double-precision (8 bytes) floating point numbers from the underlying reader. Read more

fn read_f64_into_unchecked<T>(&mut self, dst: &mut [f64]) -> Result<(), Error>
where T: ByteOrder,

👎Deprecated since 1.2.0: please use read_f64_into instead

Attempts to convert self into T using TryInto<T>. Read more

impl<T, U> TryFrom for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<F, T, E> TryFuture for F
where F: Future<Output = Result<T, E>> + ?Sized,

type Ok = T

The type of successful values yielded by this future

type Error = E

The type of failures yielded by this future

fn try_poll( self: Pin<&mut F>, cx: &mut Context<'_>, ) -> Poll<<F as Future>::Output>

Poll this TryFuture as if it were a Future. Read more

type Error = >::Error

The type returned in the event of a conversion error.

Returns an iterator over the string in Unicode Normalization Form KD (compatibility decomposition).

fn nfc(self) -> Recompositions

An Iterator over the string in Unicode Normalization Form C (canonical decomposition followed by canonical composition).

fn nfkc(self) -> Recompositions

An Iterator over the string in Unicode Normalization Form KC (compatibility decomposition followed by canonical composition).

fn cjk_compat_variants(self) -> Replacements

A transformation which replaces CJK Compatibility Ideograph codepoints with normal forms using Standardized Variation Sequences. This is not part of the canonical or compatibility decomposition algorithms, but performing it before those algorithms produces normalized output which better preserves the intent of the original text. Read more

fn stream_safe(self) -> StreamSafe

An Iterator over the string with Conjoining Grapheme Joiner characters inserted according to the Stream-Safe Text Process (UAX15-D4)

impl<T, S> UniqueSaturatedInto<T> for S
where T: Bounded, S: TryInto<T>,

fn unique_saturated_into(self) -> T

Consume self to return an equivalent value of T.

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more