[][src]Enum sp_runtime::Either

pub enum Either<L, R> {
    Left(L),
    Right(R),
}

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

Left(L)

A value of type L.

Right(R)

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>

Notable traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read
impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write
impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>, 
type Item = <L as Iterator>::Item;
[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>

Notable traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read
impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write
impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>, 
type Item = <L as Iterator>::Item;
[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>

Notable traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read
impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write
impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>, 
type Item = <L as Iterator>::Item;
[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>

Notable traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read
impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write
impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>, 
type Item = <L as Iterator>::Item;
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>

Notable traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read
impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write
impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>, 
type Item = <L as Iterator>::Item;
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]

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]

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>

Notable traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read
impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write
impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>, 
type Item = <L as Iterator>::Item;
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>

Notable traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read
impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write
impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>, 
type Item = <L as Iterator>::Item;
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>

Notable traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read
impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write
impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>, 
type Item = <L as Iterator>::Item;
where
    L: IntoIterator,
    R: IntoIterator<Item = <L as IntoIterator>::Item>, 
[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]

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]

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]

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]

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]

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]

Returns the left value

Examples

let left: Either<_, ()> = Left(3);
assert_eq!(left.unwrap_left(), 3);

Panics

When Either is a Right value

This example panics
let right: Either<(), _> = Right(3);
right.unwrap_left();

pub fn unwrap_right(self) -> R where
    L: Debug
[src]

Returns the right value

Examples

let right: Either<(), _> = Right(3);
assert_eq!(right.unwrap_right(), 3);

Panics

When Either is a Left value

This example panics
let left: Either<_, ()> = Left(3);
left.unwrap_right();

pub fn expect_left(self, msg: &str) -> L where
    R: Debug
[src]

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

This example panics
let right: Either<(), _> = Right(3);
right.expect_left("value was Right");

pub fn expect_right(self, msg: &str) -> R where
    L: Debug
[src]

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

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

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>

Notable traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read
impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write
impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>, 
type Item = <L as Iterator>::Item;
where
    F: FnOnce(T) -> M, 
[src]

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
    L: AsMut<[Target]>,
    R: AsMut<[Target]>, 
[src]

impl<L, R> AsMut<CStr> for Either<L, R> where
    L: AsMut<CStr>,
    R: AsMut<CStr>, 
[src]

Requires crate feature use_std.

impl<L, R> AsMut<OsStr> for Either<L, R> where
    L: AsMut<OsStr>,
    R: AsMut<OsStr>, 
[src]

Requires crate feature use_std.

impl<L, R> AsMut<Path> for Either<L, R> where
    L: AsMut<Path>,
    R: AsMut<Path>, 
[src]

Requires crate feature use_std.

impl<L, R, Target> AsMut<Target> for Either<L, R> where
    L: AsMut<Target>,
    R: AsMut<Target>, 
[src]

impl<L, R> AsMut<str> for Either<L, R> where
    L: AsMut<str>,
    R: AsMut<str>, 
[src]

impl<L, R, Target> AsRef<[Target]> for Either<L, R> where
    L: AsRef<[Target]>,
    R: AsRef<[Target]>, 
[src]

impl<L, R> AsRef<CStr> for Either<L, R> where
    L: AsRef<CStr>,
    R: AsRef<CStr>, 
[src]

Requires crate feature use_std.

impl<L, R> AsRef<OsStr> for Either<L, R> where
    L: AsRef<OsStr>,
    R: AsRef<OsStr>, 
[src]

Requires crate feature use_std.

impl<L, R> AsRef<Path> for Either<L, R> where
    L: AsRef<Path>,
    R: AsRef<Path>, 
[src]

Requires crate feature use_std.

impl<L, R, Target> AsRef<Target> for Either<L, R> where
    L: AsRef<Target>,
    R: AsRef<Target>, 
[src]

impl<L, R> AsRef<str> for Either<L, R> where
    L: AsRef<str>,
    R: AsRef<str>, 
[src]

impl<L, R> BufRead for Either<L, R> where
    L: BufRead,
    R: BufRead
[src]

Requires crate feature "use_std"

impl<L, R> Clone for Either<L, R> where
    L: Clone,
    R: Clone
[src]

impl<L, R> Copy for Either<L, R> where
    L: Copy,
    R: Copy
[src]

impl<L, R> Debug for Either<L, R> where
    L: Debug,
    R: Debug
[src]

impl<L, R> Deref for Either<L, R> where
    L: Deref,
    R: Deref<Target = <L as Deref>::Target>, 
[src]

type Target = <L as Deref>::Target

The resulting type after dereferencing.

impl<L, R> DerefMut for Either<L, R> where
    L: DerefMut,
    R: DerefMut<Target = <L as Deref>::Target>, 
[src]

impl<L, R> Display for Either<L, R> where
    L: Display,
    R: Display
[src]

impl<L, R> DoubleEndedIterator for Either<L, R> where
    L: DoubleEndedIterator,
    R: DoubleEndedIterator<Item = <L as Iterator>::Item>, 
[src]

impl<L, R> Eq for Either<L, R> where
    L: Eq,
    R: Eq
[src]

impl<L, R> Error for Either<L, R> where
    L: Error,
    R: Error
[src]

Either implements Error if both L and R implement it.

impl<L, R> ExactSizeIterator for Either<L, R> where
    L: ExactSizeIterator,
    R: ExactSizeIterator<Item = <L as Iterator>::Item>, 
[src]

impl<L, R, A> Extend<A> for Either<L, R> where
    L: Extend<A>,
    R: Extend<A>, 
[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
    L: Hash,
    R: Hash
[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
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>, 
[src]

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.

impl<L, R> Ord for Either<L, R> where
    L: Ord,
    R: Ord
[src]

impl<L, R> PartialEq<Either<L, R>> for Either<L, R> where
    L: PartialEq<L>,
    R: PartialEq<R>, 
[src]

impl<L, R> PartialOrd<Either<L, R>> for Either<L, R> where
    L: PartialOrd<L>,
    R: PartialOrd<R>, 
[src]

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read
[src]

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

Requires crate feature "use_std"

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
    L: Write,
    R: Write
[src]

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

Requires crate feature "use_std"

Auto Trait Implementations

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

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

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

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

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

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

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

impl<T, U> AsMutByteSlice<T> for U where
    T: ToMutByteSlice,
    U: AsMut<[T]> + ?Sized

impl<U> AsMutSliceOf for U where
    U: AsMut<[u8]> + ?Sized

impl<U> AsSliceOf for U where
    U: AsRef<[u8]> + ?Sized

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> CheckedConversion for T[src]

impl<T> DynClone for T where
    T: Clone
[src]

impl<T> Error for T where
    T: 'static + Send + Sync + Debug + Display
[src]

impl<T> From<T> for T[src]

impl<T> Instrument for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<I> IntoIterator for I where
    I: Iterator
[src]

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?

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

pub fn from_ref(outer: &Outer) -> &T[src]

Get a reference to the inner from the outer.

pub fn from_mut(outer: &mut Outer) -> &mut T[src]

Get a mutable reference to the inner from the outer.

impl<I> IteratorRandom for I where
    I: Iterator
[src]

impl<T> Joiner for T where
    T: for<'a> Extend<&'a u8>, 

impl<T> MaybeDebug for T where
    T: Debug

impl<T> MaybeDebug for T where
    T: Debug

impl<T> MaybeDisplay for T where
    T: Display
[src]

impl<T> MaybeHash for T where
    T: Hash
[src]

impl<T> MaybeHash for T where
    T: Hash
[src]

impl<T> MaybeRefUnwindSafe for T where
    T: RefUnwindSafe
[src]

impl<T> Member for T where
    T: 'static + Clone + PartialEq<T> + Eq + Send + Sync + Debug
[src]

impl<W> Output for W where
    W: Write

impl<R> ReadBytesExt for R where
    R: Read + ?Sized

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T> SaturatedConversion for T[src]

impl<T> ToHex for T where
    T: AsRef<[u8]>, 
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T> ToString for T where
    T: Display + ?Sized
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<S, T> UncheckedInto<T> for S where
    T: UncheckedFrom<S>, 
[src]

impl<I> UnicodeNormalization<I> for I where
    I: Iterator<Item = char>, 

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

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

impl<W> WriteBytesExt for W where
    W: Write + ?Sized