# [−][src]Enum itertools::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));```

#### `pub fn as_ref(&self) -> Either<&L, &R>`[src]

Convert `&Either<L, R>` to `Either<&L, &R>`.

```use either::*;

let left: Either<_, ()> = Left("some value");
assert_eq!(left.as_ref(), Left(&"some value"));

let right: Either<(), _> = Right("some value");
assert_eq!(right.as_ref(), Right(&"some value"));```

#### `pub fn as_mut(&mut self) -> Either<&mut L, &mut R>`[src]

Convert `&mut Either<L, R>` to `Either<&mut L, &mut R>`.

```use either::*;

fn mutate_left(value: &mut Either<u32, u32>) {
if let Some(l) = value.as_mut().left() {
*l = 999;
}
}

let mut left = Left(123);
let mut right = Right(123);
mutate_left(&mut left);
mutate_left(&mut right);
assert_eq!(left, Left(999));
assert_eq!(right, Right(123));```

#### `pub fn flip(self) -> Either<R, L>`[src]

Convert `Either<L, R>` to `Either<R, L>`.

```use either::*;

let left: Either<_, ()> = Left(123);
assert_eq!(left.flip(), Right(123));

let right: Either<(), _> = Right("some value");
assert_eq!(right.flip(), Left("some value"));```

#### `pub fn map_left<F, M>(self, f: F) -> Either<M, R> where    F: FnOnce(L) -> M, `[src]

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]

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

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>, `[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);```

#### `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> 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> 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> 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.

## Blanket Implementations

### `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, 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.