[][src]Enum either::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.

Methods

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

Important traits for Either<L, R>
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"));

Important traits for Either<L, R>
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));

Important traits for Either<L, R>
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"));

Important traits for Either<L, R>
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));

Important traits for Either<L, R>
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]

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

Important traits for Either<L, R>
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));

Important traits for Either<L, R>
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));

Important traits for Either<L, R>
pub fn into_iter(self) -> Either<L::IntoIter, R::IntoIter> where
    L: IntoIterator,
    R: IntoIterator<Item = L::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);

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

Important traits for Either<L, R>
pub fn map<F, M>(self, f: F) -> Either<M, M> 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> 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]

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

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

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

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

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

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> AsRef<Path> for Either<L, R> where
    L: AsRef<Path>,
    R: AsRef<Path>, 
[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<CStr> for Either<L, R> where
    L: AsRef<CStr>,
    R: AsRef<CStr>, 
[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> AsMut<str> for Either<L, R> where
    L: AsMut<str>,
    R: AsMut<str>, 
[src]

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> AsMut<OsStr> for Either<L, R> where
    L: AsMut<OsStr>,
    R: AsMut<OsStr>, 
[src]

Requires crate feature use_std.

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

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

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

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

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

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

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

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

Either<L, R> is an iterator if both L and R are iterators.

type Item = L::Item

The type of the elements being iterated over.

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

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

type Target = L::Target

The resulting type after dereferencing.

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

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

impl<L: Hash, R: Hash> Hash for Either<L, R>[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> 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"

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> BufRead for Either<L, R> where
    L: BufRead,
    R: BufRead
[src]

Requires crate feature "use_std"

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

impl<'de, L, R> Deserialize<'de> for Either<L, R> where
    L: Deserialize<'de>,
    R: Deserialize<'de>, 
[src]

Auto Trait Implementations

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

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

Blanket Implementations

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

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

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

type Owned = T

The resulting type after obtaining ownership.

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> 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<T> Borrow<T> for T where
    T: ?Sized
[src]

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

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

impl<T> DeserializeOwned for T where
    T: Deserialize<'de>, 
[src]