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

Object
HKT2<_EitherHKT, L, R>
Either

Mixed in types

Functor2<_EitherHKT, L, R>
Applicative2<_EitherHKT, L, R>
Monad2<_EitherHKT, L, R>
Foldable2<_EitherHKT, L, R>
Alt2<_EitherHKT, L, R>
Extend2<_EitherHKT, L, R>

Implementers

Left
Right

Constructors

Either(): const
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.
read-onlyinherited
runtimeType → Type: A representation of the runtime type of the object.
read-onlyinherited

Methods

all(bool predicate(R a)) → 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 a)) → 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(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, C>: 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: Return the result of f called with b and the value of Right. If this Either is Left, return b.
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: Return the result of f called with b and the value of Right. If this Either is Left, return b.
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>: Map each element in the list to an Either using the function f, and collect the result in an Either<E, List>.
traverseListWithIndex<E, A, B>(List<A> list, Either<E, B> f(A a, int i)) → Either<E, List>: Map each element in the list to an Either using the function f, and collect the result in an Either<E, List>.
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.