Either (Vavr 0.9.2 API)

Type Parameters:

L - The type of the Left value of an Either.

R - The type of the Right value of an Either.

All Superinterfaces:

Iterable<R>, Serializable, Value<R>

All Known Implementing Classes:

Either.Left, Either.Right
```
public interface Either<L,R>
extends Value<R>, Serializable
```
Either represents a value of two possible types. An Either is either a Either.Left or a Either.Right.
If the given Either is a Right and projected to a Left, the Left operations have no effect on the Right value.
If the given Either is a Left and projected to a Right, the Right operations have no effect on the Left value.
If a Left is projected to a Left or a Right is projected to a Right, the operations have an effect.
Example: A compute() function, which results either in an Integer value (in the case of success) or in an error message of type String (in the case of failure). By convention the success case is Right and the failure is Left.
```
 
 Either<String,Integer> value = compute().right().map(i -> i * 2).toEither();
 
 
```
If the result of compute() is Right(1), the value is Right(2).
If the result of compute() is Left("error"), the value is Left("error").
Author:

Daniel Dietrich

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static class`	`Either.Left<L,R>` The `Left` version of an `Either`.
`static class`	`Either.LeftProjection<L,R>` A left projection of an Either.
`static class`	`Either.Right<L,R>` The `Right` version of an `Either`.
`static class`	`Either.RightProjection<L,R>` A right projection of an Either.

Field Summary

Fields
Modifier and Type Field and Description

static long serialVersionUID

Fields
Modifier and Type	Field and Description
`static long`	`serialVersionUID`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default <X,Y> Either<X,Y>`	`bimap(Function<? super L,? extends X> leftMapper, Function<? super R,? extends Y> rightMapper)` Maps either the left or the right side of this disjunction.
`boolean`	`equals(Object o)` Clarifies that values have a proper equals() method implemented.
`default Option<Either<L,R>>`	`filter(Predicate<? super R> predicate)` Filters this right-biased `Either` by testing a predicate.
`default <U> Either<L,U>`	`flatMap(Function<? super R,? extends Either<L,? extends U>> mapper)` FlatMaps this right-biased Either.
`default <U> U`	`fold(Function<? super L,? extends U> leftMapper, Function<? super R,? extends U> rightMapper)` Folds either the left or the right side of this disjunction.
`R`	`get()` Gets the right value if this is a `Right` or throws if this is a `Left`.
`L`	`getLeft()` Returns the left value.
`default R`	`getOrElseGet(Function<? super L,? extends R> other)` Gets the Right value or an alternate value, if the projected Either is a Left.
`default <X extends Throwable> R`	`getOrElseThrow(Function<? super L,X> exceptionFunction)` Gets the Right value or throws, if the projected Either is a Left.
`int`	`hashCode()` Clarifies that values have a proper hashCode() method implemented.
`default boolean`	`isAsync()` A right-biased `Either`'s value is computed synchronously.
`default boolean`	`isEmpty()` Checks, this `Value` is empty, i.e.
`default boolean`	`isLazy()` A right-biased `Either`'s value is computed eagerly.
`boolean`	`isLeft()` Returns whether this Either is a Left.
`boolean`	`isRight()` Returns whether this Either is a Right.
`default boolean`	`isSingleValued()` A right-biased `Either` is single-valued.
`default Iterator<R>`	`iterator()` Returns a rich `io.vavr.collection.Iterator`.
`default Either.LeftProjection<L,R>`	`left()` Returns a LeftProjection of this Either.
`static <L,R> Either<L,R>`	`left(L left)` Constructs a `Either.Left`
`default <U> Either<L,U>`	`map(Function<? super R,? extends U> mapper)` Maps the value of this Either if it is a Right, performs no operation if this is a Left.
`default <U> Either<U,R>`	`mapLeft(Function<? super L,? extends U> leftMapper)` Maps the value of this Either if it is a Left, performs no operation if this is a Right.
`static <L,R> Either<L,R>`	`narrow(Either<? extends L,? extends R> either)` Narrows a widened `Either<? extends L, ? extends R>` to `Either<L, R>` by performing a type-safe cast.
`default Either<L,R>`	`orElse(Either<? extends L,? extends R> other)`
`default Either<L,R>`	`orElse(Supplier<? extends Either<? extends L,? extends R>> supplier)`
`default void`	`orElseRun(Consumer<? super L> action)` Runs an action in the case this is a projection on a Left value.
`default Either<L,R>`	`peek(Consumer<? super R> action)` Performs the given `action` on the first element if this is an eager implementation.
`default Either<L,R>`	`peekLeft(Consumer<? super L> action)`
`default Either.RightProjection<L,R>`	`right()` Returns a RightProjection of this Either.
`static <L,R> Either<L,R>`	`right(R right)` Constructs a `Either.Right`
`static <L,R> Either<Seq<L>,Seq<R>>`	`sequence(Iterable<? extends Either<? extends L,? extends R>> eithers)` Reduces many `Either`s into a single `Either` by transforming an `Iterable<Either<L, R>>` into a `Either<Seq<L>, Seq<R>>`.
`static <L,R> Either<L,Seq<R>>`	`sequenceRight(Iterable<? extends Either<? extends L,? extends R>> eithers)` Reduces many `Either`s into a single `Either` by transforming an `Iterable<Either<L, R>>` into a `Either<L, Seq<R>>`.
`default Either<R,L>`	`swap()` Converts a `Left` to a `Right` vice versa by wrapping the value in a new type.
`String`	`toString()` Clarifies that values have a proper toString() method implemented.

Methods inherited from interface io.vavr.Value
collect, collect, contains, corresponds, eq, exists, forAll, forEach, getOrElse, getOrElse, getOrElseThrow, getOrElseTry, getOrNull, narrow, out, out, spliterator, stderr, stdout, stringPrefix, toArray, toCharSeq, toCompletableFuture, toEither, toEither, toInvalid, toInvalid, toJavaArray, toJavaArray, toJavaCollection, toJavaList, toJavaList, toJavaMap, toJavaMap, toJavaMap, toJavaOptional, toJavaParallelStream, toJavaSet, toJavaSet, toJavaStream, toLeft, toLeft, toLinkedMap, toLinkedMap, toLinkedSet, toList, toMap, toMap, toOption, toPriorityQueue, toPriorityQueue, toQueue, toRight, toRight, toSet, toSortedMap, toSortedMap, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toStream, toTree, toTry, toTry, toValid, toValid, toValidation, toValidation, toVector

- Field Detail
  - serialVersionUID
```
static final long serialVersionUID
```
    See Also:
    
    Constant Field Values
- Method Detail
  - right
```
static <L,R> Either<L,R> right(R right)
```
    Constructs a Either.Right
    
    Type Parameters:
    
    L - Type of left value.
    
    R - Type of right value.
    
    Parameters:
    
    right - The value.
    
    Returns:
    
    A new Right instance.
  - left
```
static <L,R> Either<L,R> left(L left)
```
    Constructs a Either.Left
    
    Type Parameters:
    
    L - Type of left value.
    
    R - Type of right value.
    
    Parameters:
    
    left - The value.
    
    Returns:
    
    A new Left instance.
  - narrow
```
static <L,R> Either<L,R> narrow(Either<? extends L,? extends R> either)
```
    Narrows a widened Either<? extends L, ? extends R> to Either<L, R> by performing a type-safe cast. This is eligible because immutable/read-only collections are covariant.
    
    Type Parameters:
    
    L - Type of left value.
    
    R - Type of right value.
    
    Parameters:
    
    either - A Either.
    
    Returns:
    
    the given either instance as narrowed type Either<L, R>.
  - getLeft
```
L getLeft()
```
    Returns the left value.
    
    Returns:
    
    The left value.
    
    Throws:
    
    NoSuchElementException - if this is a Right.
  - isLeft
```
boolean isLeft()
```
    Returns whether this Either is a Left.
    
    Returns:
    
    true, if this is a Left, false otherwise
  - isRight
```
boolean isRight()
```
    Returns whether this Either is a Right.
    
    Returns:
    
    true, if this is a Right, false otherwise
  - left
```
default Either.LeftProjection<L,R> left()
```
    Returns a LeftProjection of this Either.
    
    Returns:
    
    a new LeftProjection of this
  - right
```
default Either.RightProjection<L,R> right()
```
    Returns a RightProjection of this Either.
    
    Returns:
    
    a new RightProjection of this
  - bimap
```
default <X,Y> Either<X,Y> bimap(Function<? super L,? extends X> leftMapper,
                                Function<? super R,? extends Y> rightMapper)
```
    Maps either the left or the right side of this disjunction.
    
    Type Parameters:
    
    X - The new left type of the resulting Either
    
    Y - The new right type of the resulting Either
    
    Parameters:
    
    leftMapper - maps the left value if this is a Left
    
    rightMapper - maps the right value if this is a Right
    
    Returns:
    
    A new Either instance
  - fold
```
default <U> U fold(Function<? super L,? extends U> leftMapper,
                   Function<? super R,? extends U> rightMapper)
```
    Folds either the left or the right side of this disjunction.
    
    Type Parameters:
    
    U - type of the folded value
    
    Parameters:
    
    leftMapper - maps the left value if this is a Left
    
    rightMapper - maps the right value if this is a Right
    
    Returns:
    
    A value of type U
  - sequence
```
static <L,R> Either<Seq<L>,Seq<R>> sequence(Iterable<? extends Either<? extends L,? extends R>> eithers)
```
    Reduces many Eithers into a single Either by transforming an Iterable<Either<L, R>> into a Either<Seq<L>, Seq<R>>.
    If any of the given Eithers is a Either.Left then sequence returns a Either.Left containing a non-empty Seq of all left values.
    If none of the given Eithers is a Either.Left then sequence returns a Either.Right containing a (possibly empty) Seq of all right values.
```
 // = Right(Seq())
 Either.sequence(List.empty())

 // = Right(Seq(1, 2))
 Either.sequence(List.of(Either.right(1), Either.right(2)))

 // = Left(Seq("x"))
 Either.sequence(List.of(Either.right(1), Either.left("x")))
 
```
    Type Parameters:
    
    L - closure of all left types of the given Eithers
    
    R - closure of all right types of the given Eithers
    
    Parameters:
    
    eithers - An Iterable of Eithers
    
    Returns:
    
    An Either of a Seq of left or right values
    
    Throws:
    
    NullPointerException - if eithers is null
  - sequenceRight
```
static <L,R> Either<L,Seq<R>> sequenceRight(Iterable<? extends Either<? extends L,? extends R>> eithers)
```
    Reduces many Eithers into a single Either by transforming an Iterable<Either<L, R>> into a Either<L, Seq<R>>.
    If any of the given Eithers is a Either.Left then sequenceRight returns a Either.Left containing the first left value (in iteration order).
    If none of the given Eithers is a Either.Left then sequenceRight returns a Either.Right containing a (possibly empty) Seq of all right values.
```
 // = Right(Seq())
 Either.sequenceRight(List.empty())

 // = Right(Seq(1, 2))
 Either.sequenceRight(List.of(Either.right(1), Either.right(2)))

 // = Left("x1")
 Either.sequenceRight(List.of(Either.right(1), Either.left("x1"), Either.left("x2")))
 
```
    Type Parameters:
    
    L - closure of all left types of the given Eithers
    
    R - closure of all right types of the given Eithers
    
    Parameters:
    
    eithers - An Iterable of Eithers
    
    Returns:
    
    An Either of either a Seq of right values or the first left value, if present.
    
    Throws:
    
    NullPointerException - if eithers is null
  - getOrElseGet
```
default R getOrElseGet(Function<? super L,? extends R> other)
```
    Gets the Right value or an alternate value, if the projected Either is a Left.
    
    Parameters:
    
    other - a function which converts a Left value to an alternative Right value
    
    Returns:
    
    the right value, if the underlying Either is a Right or else the alternative Right value provided by other by applying the Left value.
  - orElseRun
```
default void orElseRun(Consumer<? super L> action)
```
    Runs an action in the case this is a projection on a Left value.
    
    Parameters:
    
    action - an action which consumes a Left value
  - getOrElseThrow
```
default <X extends Throwable> R getOrElseThrow(Function<? super L,X> exceptionFunction)
                                        throws X extends Throwable
```
    Gets the Right value or throws, if the projected Either is a Left.
    
    Type Parameters:
    
    X - a throwable type
    
    Parameters:
    
    exceptionFunction - a function which creates an exception based on a Left value
    
    Returns:
    
    the right value, if the underlying Either is a Right or else throws the exception provided by exceptionFunction by applying the Left value.
    
    Throws:
    
    X - if the projected Either is a Left
    
    X extends Throwable
  - swap
```
default Either<R,L> swap()
```
    Converts a Left to a Right vice versa by wrapping the value in a new type.
    
    Returns:
    
    a new Either
  - flatMap
```
default <U> Either<L,U> flatMap(Function<? super R,? extends Either<L,? extends U>> mapper)
```
    FlatMaps this right-biased Either.
    
    Type Parameters:
    
    U - Component type of the mapped right value
    
    Parameters:
    
    mapper - A mapper
    
    Returns:
    
    this as Either<L, U> if this is a Left, otherwise the right mapping result
    
    Throws:
    
    NullPointerException - if mapper is null
  - map
```
default <U> Either<L,U> map(Function<? super R,? extends U> mapper)
```
    Maps the value of this Either if it is a Right, performs no operation if this is a Left.
```
 import static io.vavr.API.*;

 class Example {{

     // = Right("A")
     Right("a").map(String::toUpperCase);

     // = Left(1)
     Left(1).map(String::toUpperCase);

 }}
 
```
    Specified by:
    
    map in interface Value<R>
    
    Type Parameters:
    
    U - Component type of the mapped right value
    
    Parameters:
    
    mapper - A mapper
    
    Returns:
    
    a mapped Monad
    
    Throws:
    
    NullPointerException - if mapper is null
  - mapLeft
```
default <U> Either<U,R> mapLeft(Function<? super L,? extends U> leftMapper)
```
    Maps the value of this Either if it is a Left, performs no operation if this is a Right.
```
 import static io.vavr.API.*;

 class Example {

     // = Left(2)
     Left(1).mapLeft(i -> i + 1);

     // = Right("a")
     Right("a").mapLeft(i -> i + 1);

 }
 
```
    Type Parameters:
    
    U - Component type of the mapped right value
    
    Parameters:
    
    leftMapper - A mapper
    
    Returns:
    
    a mapped Monad
    
    Throws:
    
    NullPointerException - if mapper is null
  - filter
```
default Option<Either<L,R>> filter(Predicate<? super R> predicate)
```
    Filters this right-biased Either by testing a predicate.
    
    Parameters:
    
    predicate - A predicate
    
    Returns:
    
    a new Option instance
    
    Throws:
    
    NullPointerException - if predicate is null
  - get
```
R get()
```
    Gets the right value if this is a Right or throws if this is a Left.
    
    Specified by:
    
    get in interface Value<R>
    
    Returns:
    
    the right value
    
    Throws:
    
    NoSuchElementException - if this is a Left.
  - isEmpty
```
default boolean isEmpty()
```
    Description copied from interface: Value
    
    Checks, this Value is empty, i.e. if the underlying value is absent.
    
    Specified by:
    
    isEmpty in interface Value<R>
    
    Returns:
    
    false, if no underlying value is present, true otherwise.
  - orElse
```
default Either<L,R> orElse(Either<? extends L,? extends R> other)
```
  - orElse
```
default Either<L,R> orElse(Supplier<? extends Either<? extends L,? extends R>> supplier)
```
  - isAsync
```
default boolean isAsync()
```
    A right-biased Either's value is computed synchronously.
    
    Specified by:
    
    isAsync in interface Value<R>
    
    Returns:
    
    false
  - isLazy
```
default boolean isLazy()
```
    A right-biased Either's value is computed eagerly.
    
    Specified by:
    
    isLazy in interface Value<R>
    
    Returns:
    
    false
  - isSingleValued
```
default boolean isSingleValued()
```
    A right-biased Either is single-valued.
    
    Specified by:
    
    isSingleValued in interface Value<R>
    
    Returns:
    
    true
  - iterator
```
default Iterator<R> iterator()
```
    Description copied from interface: Value
    
    Returns a rich io.vavr.collection.Iterator.
    
    Specified by:
    
    iterator in interface Iterable<R>
    
    Specified by:
    
    iterator in interface Value<R>
    
    Returns:
    
    A new Iterator
  - peek
```
default Either<L,R> peek(Consumer<? super R> action)
```
    Description copied from interface: Value
    
    Performs the given action on the first element if this is an eager implementation. Performs the given action on all elements (the first immediately, successive deferred), if this is a lazy implementation.
    
    Specified by:
    
    peek in interface Value<R>
    
    Parameters:
    
    action - The action that will be performed on the element(s).
    
    Returns:
    
    this instance
  - peekLeft
```
default Either<L,R> peekLeft(Consumer<? super L> action)
```
  - equals
```
boolean equals(Object o)
```
    Description copied from interface: Value
    
    Clarifies that values have a proper equals() method implemented.
    See Object.equals(Object).
    
    Specified by:
    
    equals in interface Value<R>
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    o - An object
    
    Returns:
    
    true, if this equals o, false otherwise
  - hashCode
```
int hashCode()
```
    Description copied from interface: Value
    
    Clarifies that values have a proper hashCode() method implemented.
    See Object.hashCode().
    
    Specified by:
    
    hashCode in interface Value<R>
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    The hashcode of this object
  - toString
```
String toString()
```
    Description copied from interface: Value
    
    Clarifies that values have a proper toString() method implemented.
    See Object.toString().
    
    Specified by:
    
    toString in interface Value<R>
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    A String representation of this object

Interface Either<L,R>

Nested Class Summary

Field Summary

Method Summary

Methods inherited from interface io.vavr.Value

Field Detail

serialVersionUID

Method Detail

right

left

narrow

getLeft

isLeft

isRight

left

right

bimap

fold

sequence

sequenceRight

getOrElseGet

orElseRun

getOrElseThrow

swap

flatMap

map

mapLeft

filter

get

isEmpty

orElse

orElse

isAsync

isLazy

isSingleValued

iterator

peek

peekLeft

equals

hashCode

toString