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.

Implemented types

IZIO<NoEnv, L, R>

Available extensions

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

asZIO → ZIO<NoEnv, L, R>: no setterinherited
hashCode → int: The hash code for this object.
no setterinherited
runtimeType → Type: A representation of the runtime type of the object.
no setterinherited
toZIO → ZIO<NoEnv, E, A>: Available on Either<E, A>, provided by the ZIOEitherExt extension
Alias for ZIO.fromEither
no setter

Methods

alt(covariant Either<L, R> orElse()) → Either<L, R>: Return the current Either if it is a Right, otherwise return the result of orElse.
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.
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.
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.
call(covariant Either<L, B> chain) → Either<L, B>: Chain multiple functions having the same left type L.
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.
duplicate() → Either<L, Either<L, R>>: Wrap this Either inside another Either.
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.
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.
flatMapExit(Exit<E, B> f(A _)) → Exit<E, B>: Available on Exit<E, A>, provided by the ExitExt extension
flatMapExitEither(Either<E, B> f(A _)) → Exit<E, B>: Available on Exit<E, A>, provided by the ExitExt extension
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.
liftExit<E2>() → Exit<E2, A>: Available on Exit<E, A>, provided by the ExitExt extension
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.
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.
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.
mapFailure<E2>(E2 f(E _)) → Exit<E2, A>: Available on Exit<E, A>, provided by the ExitExt extension
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.
matchExit<E2, B>(Either<E2, B> onFailure(E _), Either<E2, B> onSuccess(A _)) → Exit<E2, B>: Available on Exit<E, A>, provided by the ExitExt extension
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.
swap() → Either<R, L>: Swap the values contained inside the Left and Right of this Either.
toExit() → Exit<E, A>: Available on Either<E, A>, provided by the EitherExitExt extension
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

Operators

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

Static Methods

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.