Either<L, R> class sealed

Represents a value of one of two possible types, Left or Right.

Either is commonly used to handle errors. Instead of returning placeholder values when a computation may fail (such as -1, null, etc.), we return an instance of Right containing the correct result when a computation is successful, otherwise we return an instance of Left containing information about the kind of error that occurred.

Inheritance
Mixed-in types

Constructors

Either.Do(DoFunctionEither<L, R> f)
Initialize a Do Notation chain.
factory
Either.flatten(Either<L, Either<L, R>> e)
Flat a Either contained inside another Either to be a single Either.
factory
Either.fromNullable(R? r, L onNull())
If r is null, then return the result of onNull in Left. Otherwise return Right(r).
factory
Either.fromOption(Option<R> m, L onNone())
Return an Either from a Option:
factory
Either.fromPredicate(R r, bool predicate(R r), L onFalse(R r))
If calling predicate with r returns true, then return Right(r). Otherwise return Left containing the result of onFalse.
factory
Either.left(L l)
Return a Left(l).
factory
Either.of(R r)
Return a Right(r).
factory
Either.right(R r)
Return a Right(r).
factory
Either.safeCast(dynamic value, L onError(dynamic value))
Safely cast a value to type R.
factory
Either.tryCatch(R run(), L onError(Object o, StackTrace s))
Try to execute run. If no error occurs, then return Right. Otherwise return Left containing the result of onError.
factory

Properties

hashCode → int
The hash code for this object.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited

Methods

all(bool predicate(R r)) → bool
Return the result of predicate applied to the value of Right. If the Either is Left, returns true.
override
alt(covariant Either<L, R> orElse()) → Either<L, R>
Return the current Either if it is a Right, otherwise return the result of orElse.
override
andThen<R2>(covariant Either<L, R2> then()) → Either<L, R2>
If this Either is a Right, then return the result of calling then. Otherwise return Left.
override
any(bool predicate(R r)) → bool
Return the result of predicate applied to the value of Right. If the Either is Left, returns false.
override
ap<C>(covariant Either<L, C Function(R r)> a) → Either<L, C>
Apply the function contained inside a to change the value on the Right from type R to a value of type C.
override
bimap<C, D>(C mLeft(L l), D mRight(R b)) → Either<C, D>
Define two functions to change both the Left and Right value of the Either.
bind<R2>(Either<L, R2> f(R r)) → Either<L, R2>
Used to chain multiple functions that return a Either.
bindFuture<R2>(Future<Either<L, R2>> f(R r)) → TaskEither<L, R2>
Used to chain multiple functions that return a Future<Either>.
call<B>(covariant Either<L, B> chain) → Either<L, B>
Chain multiple functions having the same left type L.
override
chainFirst<C>(covariant Either<L, C> chain(R b)) → Either<L, R>
Chain a request that returns another Either, execute it, ignore the result, and return the same value as the current Either.
override
concatenate(Monoid<R> monoid) → R
Use monoid to combine the value of Right.
override
duplicate() → Either<L, Either<L, R>>
Wrap this Either inside another Either.
override
elem(R r, Eq<R> eq) → bool
Return true when value of r is equal to the value inside this Either. If this Either is Left, then return false.
exists(bool predicate(R r)) → bool
Return the result of calliing predicate with the value of Either if it is a Right. Otherwise return false.
extend<Z>(Z f(Either<L, R> t)) → Either<L, Z>
Change the value of Either from type R to type Z based on the value of Either<L, R> using function f.
override
filterOrElse(bool f(R r), L onFalse(R r)) → Either<L, R>
If f applied on this Either as Right returns true, then return this Either. If it returns false, return the result of onFalse in a Left.
flatMap<C>(covariant Either<L, C> f(R a)) → Either<L, R2>
Used to chain multiple functions that return a Either.
override
fold<C>(C onLeft(L l), C onRight(R r)) → C
Execute onLeft when value is Left, otherwise execute onRight.
foldLeft<C>(C b, C f(C acc, R b)) → C
This method folds the value from left to right.
override
foldLeftWithIndex<C>(C c, C f(int i, C acc, R b)) → C
Return the result of f called with b and the value of Right. If this Either is Left, return b.
override
foldMap<C>(Monoid<C> monoid, C f(R b)) → C
Use monoid to combine the value of Right applied to f.
override
foldRight<C>(C b, C f(C acc, R b)) → C
This method folds the value from right to left.
override
foldRightWithIndex<C>(C c, C f(int i, C acc, R b)) → C
Return the result of f called with b and the value of Right. If this Either is Left, return b.
override
getLeft() → Option<L>
Extract the value from Left in a Option.
getOrElse(R orElse(L l)) → R
Return the value inside this Either if it is a Right. Otherwise return result of onElse.
getRight() → Option<R>
Extract the value from Right in a Option.
isLeft() → bool
Return true when this Either is Left.
isRight() → bool
Return true when this Either is Right.
length() → int
Returns 1 when Either is Right, 0 otherwise.
override
map<C>(C f(R a)) → Either<L, C>
If the Either is Right, then change its value from type R to type C using function f.
override
map2<C, D>(covariant Either<L, C> m1, D f(R b, C c)) → Either<L, D>
Change type of this Either based on its value of type R and the value of type C of another Either.
override
map3<C, D, E>(covariant Either<L, C> m1, covariant Either<L, D> m2, E f(R b, C c, D d)) → Either<L, E>
Change type of this Either based on its value of type R, the value of type C of a second Either, and the value of type D of a third Either.
override
mapLeft<C>(C f(L a)) → Either<C, R>
If the Either is Left, then change its value from type L to type C using function f.
match<C>(C onLeft(L l), C onRight(R r)) → C
Execute onLeft when value is Left, otherwise execute onRight.
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
orElse<L1>(Either<L1, R> onLeft(L l)) → Either<L1, R>
If this Either is Left, return the result of onLeft.
pure<C>(C c) → Either<L, C>
Return a Right containing the value c.
override
swap() → Either<R, L>
Swap the values contained inside the Left and Right of this Either.
toIOEither() → IOEither<L, R>
Convert this Either to a IOEither.
toNullable() → R?
Convert Either to nullable R?.
toOption() → Option<R>
Convert this Either to a Option:
toString() → String
A string representation of this object.
inherited
toTaskEither() → TaskEither<L, R>
Convert this Either to a TaskEither.

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

getEq<L, R>(Eq<L> eqL, Eq<R> eqR) → Eq<Either<L, R>>
Build an Eq<Either> by comparing the values inside two Either.
getSemigroup<L, R>(Semigroup<R> semigroup) → Semigroup<Either<L, R>>
Build a Semigroup<Either> from a Semigroup.
lefts<E, A>(List<Either<E, A>> list) → List<E>
Extract all the Left values from a List<Either<E, A>>.
partitionEithers<E, A>(List<Either<E, A>> list) → (List<E>, List<A>)
Extract all the Left and Right values from a List<Either<E, A>> and return them in two partitioned List inside a record.
rights<E, A>(List<Either<E, A>> list) → List<A>
Extract all the Right values from a List<Either<E, A>>.
safeCastStrict<L, R, V>(V value, L onError(V value)) → Either<L, R>
Safely cast a value to type R.
sequenceList<E, A>(List<Either<E, A>> list) → Either<E, List<A>>
Convert a List<Either<E, A>> to a single Either<E, List<A>>.
traverseList<E, A, B>(List<A> list, Either<E, B> f(A a)) → Either<E, List<B>>
Map each element in the list to an Either using the function f, and collect the result in an Either<E, List<B>>.
traverseListWithIndex<E, A, B>(List<A> list, Either<E, B> f(A a, int i)) → Either<E, List<B>>
Map each element in the list to an Either using the function f, and collect the result in an Either<E, List<B>>.
tryCatchK<L, R, T>(R run(T), L onError(Object o, StackTrace s)) → Either<L, R> Function(T)
Try to execute run. If no error occurs, then return Right. Otherwise return Left containing the result of onError.