Uses of Interface
com.github.tonivade.purefun.type.Either

Packages that use Either

Package	Description
com.github.tonivade.purefun.core
com.github.tonivade.purefun.effect
com.github.tonivade.purefun.free
com.github.tonivade.purefun.instances
com.github.tonivade.purefun.monad
com.github.tonivade.purefun.optics
com.github.tonivade.purefun.runtimes
com.github.tonivade.purefun.transformer
com.github.tonivade.purefun.type
com.github.tonivade.purefun.typeclasses

Uses of Either in com.github.tonivade.purefun.core

Methods in com.github.tonivade.purefun.core that return types with arguments of type Either

Modifier and Type	Method	Description
default Function1<A,Either<Throwable,R>>	Function1.liftEither()
default Function2<A,B,Either<Throwable,R>>	Function2.liftEither()
default Producer<Either<Throwable,T>>	Producer.liftEither()
default <L> Function1<A,Either<R,L>>	Function1.liftLeft()
default <L> Function1<A,Either<L,R>>	Function1.liftRight()

Uses of Either in com.github.tonivade.purefun.effect

Fields in com.github.tonivade.purefun.effect with type parameters of type Either

Modifier and Type	Field	Description
private final Function2<R,Consumer1<? super Try<? extends Either<E,? extends A>>>,PureIO<R,?,Unit>>	PureIO.Async.callback
private final Producer<Either<E,? extends A>>	PureIO.Delay.task

Methods in com.github.tonivade.purefun.effect that return Either

Modifier and Type	Method	Description
default Either<E,A>	PureIO.provide(R env)
Either<E,A>	EIO.safeRunSync()

Methods in com.github.tonivade.purefun.effect that return types with arguments of type Either

Modifier and Type	Method	Description
<B> Managed<R,E,Either<A,B>>	Managed.either(Managed<R,E,B> other)
private static <R, E, A> Promise<Either<E,A>>	PureIO.executeAsync(R env, PureIO.Async<R,E,A> current, PureIOConnection connection, Promise<Either<E,A>> promise)
static <E, A, B> EIO<E,Either<A,B>>	EIO.race(Kind<EIO<E,?>,? extends A> fa, Kind<EIO<E,?>,? extends B> fb)
static <E, A, B> EIO<E,Either<A,B>>	EIO.race(Executor executor, Kind<EIO<E,?>,? extends A> fa, Kind<EIO<E,?>,? extends B> fb)
static <R, E, A, B> PureIO<R,E,Either<A,B>>	PureIO.race(Kind<PureIO<R,E,?>,? extends A> fa, Kind<PureIO<R,E,?>,? extends B> fb)
static <R, E, A, B> PureIO<R,E,Either<A,B>>	PureIO.race(Executor executor, Kind<PureIO<R,E,?>,? extends A> fa, Kind<PureIO<R,E,?>,? extends B> fb)
static <R, A, B> RIO<R,Either<A,B>>	RIO.race(Kind<RIO<R,?>,? extends A> fa, Kind<RIO<R,?>,? extends B> fb)
static <R, A, B> RIO<R,Either<A,B>>	RIO.race(Executor executor, Kind<RIO<R,?>,? extends A> fa, Kind<RIO<R,?>,? extends B> fb)
static <A, B> Task<Either<A,B>>	Task.race(Kind<Task<?>,? extends A> fa, Kind<Task<?>,? extends B> fb)
static <A, B> Task<Either<A,B>>	Task.race(Executor executor, Kind<Task<?>,? extends A> fa, Kind<Task<?>,? extends B> fb)
static <A, B> UIO<Either<A,B>>	UIO.race(Kind<UIO<?>,? extends A> fa, Kind<UIO<?>,? extends B> fb)
static <A, B> UIO<Either<A,B>>	UIO.race(Executor executor, Kind<UIO<?>,? extends A> fa, Kind<UIO<?>,? extends B> fb)
static <R, A, B> URIO<R,Either<A,B>>	URIO.race(Kind<URIO<R,?>,? extends A> fa, Kind<URIO<R,?>,? extends B> fb)
static <R, A, B> URIO<R,Either<A,B>>	URIO.race(Executor executor, Kind<URIO<R,?>,? extends A> fa, Kind<URIO<R,?>,? extends B> fb)
static <E, A, B> EIO<E,Either<Tuple2<A,Fiber<EIO<E,?>,B>>,Tuple2<Fiber<EIO<E,?>,A>,B>>>	EIO.racePair(Executor executor, Kind<EIO<E,?>,? extends A> fa, Kind<EIO<E,?>,? extends B> fb)
static <R, E, A, B> PureIO<R,E,Either<Tuple2<A,Fiber<PureIO<R,E,?>,B>>,Tuple2<Fiber<PureIO<R,E,?>,A>,B>>>	PureIO.racePair(Executor executor, Kind<PureIO<R,E,?>,? extends A> fa, Kind<PureIO<R,E,?>,? extends B> fb)
static <R, A, B> RIO<R,Either<Tuple2<A,Fiber<RIO<R,?>,B>>,Tuple2<Fiber<RIO<R,?>,A>,B>>>	RIO.racePair(Executor executor, Kind<RIO<R,?>,? extends A> fa, Kind<RIO<R,?>,? extends B> fb)
static <A, B> Task<Either<Tuple2<A,Fiber<Task<?>,B>>,Tuple2<Fiber<Task<?>,A>,B>>>	Task.racePair(Executor executor, Kind<Task<?>,? extends A> fa, Kind<Task<?>,? extends B> fb)
static <A, B> UIO<Either<Tuple2<A,Fiber<UIO<?>,B>>,Tuple2<Fiber<UIO<?>,A>,B>>>	UIO.racePair(Executor executor, Kind<UIO<?>,? extends A> fa, Kind<UIO<?>,? extends B> fb)
static <R, A, B> URIO<R,Either<Tuple2<A,Fiber<URIO<R,?>,B>>,Tuple2<Fiber<URIO<R,?>,A>,B>>>	URIO.racePair(Executor executor, Kind<URIO<R,?>,? extends A> fa, Kind<URIO<R,?>,? extends B> fb)
Future<Either<E,A>>	EIO.runAsync()
Future<Either<E,A>>	EIO.runAsync(Executor executor)
default Future<Either<E,A>>	PureIO.runAsync(R env)
private static <R, E, A> Promise<Either<E,A>>	PureIO.runAsync(R env, Kind<PureIO<R,E,?>,A> current, PureIOConnection connection)
private static <R, E, F, G, A, B, C> Promise<Either<E,A>>	PureIO.runAsync(R env, Kind<PureIO<R,E,?>,A> current, PureIOConnection connection, CallStack<R,E,A> stack, Promise<Either<E,A>> promise)
default Future<Either<E,A>>	PureIO.runAsync(R env, Executor executor)

Methods in com.github.tonivade.purefun.effect with parameters of type Either

Modifier and Type	Method	Description
static <E, A> EIO<E,A>	EIO.fromEither(Either<E,? extends A> task)
static <R, E, A> PureIO<R,E,A>	PureIO.fromEither(Either<E,? extends A> task)
static <R, A> RIO<R,A>	RIO.fromEither(Either<Throwable,? extends A> task)
static <A> Task<A>	Task.fromEither(Either<Throwable,? extends A> task)
static <T> UIO<T>	UIO.fromEither(Either<Throwable,? extends T> task)
static <R, T> URIO<R,T>	URIO.fromEither(Either<Throwable,? extends T> task)

Method parameters in com.github.tonivade.purefun.effect with type arguments of type Either

Modifier and Type	Method	Description
static <E, A> EIO<E,A>	EIO.absorb(EIO<E,Either<E,A>> value)
static <R, E, A> PureIO<R,E,A>	PureIO.absorb(Kind<PureIO<R,E,?>,Either<E,A>> value)
static <R, A> RIO<R,A>	RIO.absorb(RIO<R,Either<Throwable,A>> value)
static <A> Task<A>	Task.absorb(Task<Either<Throwable,A>> value)
static <E, A> EIO<E,A>	EIO.async(Consumer1<Consumer1<? super Try<? extends Either<E,? extends A>>>> consumer)
static <R, E, A> PureIO<R,E,A>	PureIO.async(Consumer2<R,Consumer1<? super Try<? extends Either<E,? extends A>>>> consumer)
static <E, A> EIO<E,A>	EIO.cancellable(Function1<Consumer1<? super Try<? extends Either<E,? extends A>>>,EIO<E,Unit>> consumer)
static <R, E, A> PureIO<R,E,A>	PureIO.cancellable(Function2<R,Consumer1<? super Try<? extends Either<E,? extends A>>>,PureIO<R,?,Unit>> consumer)
private static <R, E, A> Promise<Either<E,A>>	PureIO.executeAsync(R env, PureIO.Async<R,E,A> current, PureIOConnection connection, Promise<Either<E,A>> promise)
static <E, A> EIO<E,A>	EIO.fromEither(Producer<Either<E,? extends A>> task)
static <R, E, A> PureIO<R,E,A>	PureIO.fromEither(Producer<Either<E,? extends A>> task)
static <R, A> RIO<R,A>	RIO.fromEither(Producer<Either<Throwable,? extends A>> task)
static <A> Task<A>	Task.fromEither(Producer<Either<Throwable,? extends A>> task)
static <R, E, A> PureIO<R,E,A>	PureIO.fromPromise(Promise<? extends Either<E,? extends A>> promise)
static <E, A, B> Function1<A,EIO<E,B>>	EIO.liftEither(Function1<? super A,? extends Either<E,? extends B>> function)
static <R, E, A, B> Function1<A,PureIO<R,E,B>>	PureIO.liftEither(Function1<? super A,? extends Either<E,? extends B>> function)
static <R, A, B> Function1<A,RIO<R,B>>	RIO.liftEither(Function1<? super A,? extends Either<Throwable,? extends B>> function)
static <A, B> Function1<A,Task<B>>	Task.liftEither(Function1<? super A,? extends Either<Throwable,? extends B>> function)
static <A, B> Function1<A,UIO<B>>	UIO.liftEither(Function1<? super A,? extends Either<Throwable,? extends B>> function)
static <R, A, B> Function1<A,URIO<R,B>>	URIO.liftEither(Function1<? super A,? extends Either<Throwable,? extends B>> function)
default void	PureIO.provideAsync(R env, Consumer1<? super Try<? extends Either<E,A>>> callback)
default void	PureIO.provideAsync(R env, Executor executor, Consumer1<? super Try<? extends Either<E,A>>> callback)
private static <R, E, F, G, A, B, C> Promise<Either<E,A>>	PureIO.runAsync(R env, Kind<PureIO<R,E,?>,A> current, PureIOConnection connection, CallStack<R,E,A> stack, Promise<Either<E,A>> promise)
void	EIO.safeRunAsync(Consumer1<? super Try<? extends Either<E,? extends A>>> callback)
private static <R, E, A> void	PureIO.setCancelToken(R env, PureIO.Async<R,E,A> current, PureIOConnection connection, Promise<Either<E,A>> promise)

Constructor parameters in com.github.tonivade.purefun.effect with type arguments of type Either

Modifier	Constructor	Description
private	Async(Function2<R,Consumer1<? super Try<? extends Either<E,? extends A>>>,PureIO<R,?,Unit>> callback)
private	Delay(Producer<Either<E,? extends A>> task)

Uses of Either in com.github.tonivade.purefun.free

Fields in com.github.tonivade.purefun.free declared as Either

Modifier and Type	Field	Description
private final Either<Kind<F,T>,Kind<G,T>>	EitherK.either

Methods in com.github.tonivade.purefun.free that return types with arguments of type Either

Modifier and Type	Method	Description
private <G extends Kind<G, ?>> Kind<G,Either<Free<F,B>,B>>	Free.FlatMapped.foldStep(Monad<G> monad, FunctionK<F,G> interpreter)
private <G extends Kind<G, ?>> Kind<G,Either<Free<F,A>,A>>	Free.foldStep(Monad<G> monad, FunctionK<F,G> interpreter)

Constructors in com.github.tonivade.purefun.free with parameters of type Either

Modifier	Constructor	Description
private	EitherK(Either<Kind<F,T>,Kind<G,T>> either)

Uses of Either in com.github.tonivade.purefun.instances

Methods in com.github.tonivade.purefun.instances with type parameters of type Either

Modifier and Type	Method	Description
<R extends Kind<F, Either<E, A>>> R	MonadMTL.EffectE.run(Function<Kind<F,? extends Either<E,A>>,R> fixer)

Methods in com.github.tonivade.purefun.instances that return Either

Modifier and Type	Method	Description
default <T, R> Either<L,R>	EitherApplicative.ap(Kind<Either<L,?>,? extends T> value, Kind<Either<L,?>,? extends Function1<? super T,? extends R>> apply)
default <T, R> Either<L,R>	EitherMonad.flatMap(Kind<Either<L,?>,? extends T> value, Function1<? super T,? extends Kind<Either<L,?>,? extends R>> map)
default <A> Either<L,A>	EitherMonadError.handleErrorWith(Kind<Either<L,?>,A> value, Function1<? super L,? extends Kind<Either<L,?>,? extends A>> handler)
default <T, R> Either<L,R>	EitherFunctor.map(Kind<Either<L,?>,? extends T> value, Function1<? super T,? extends R> map)
default <T> Either<L,T>	EitherPure.pure(T value)
default <A> Either<L,A>	EitherMonadError.raiseError(L error)

Methods in com.github.tonivade.purefun.instances that return types with arguments of type Either

Modifier and Type	Method	Description
<A> Kind<F,Either<E,A>>	EitherTBracket.acquireRecover(E error)
default <A> Kind<F,Either<Throwable,A>>	EitherTMonadDefer.acquireRecover(Throwable error)
static <L> Applicative<Either<L,?>>	EitherInstances.applicative()
static <L, R> Eq<Either<L,R>>	EitherInstances.eq(Eq<L> leftEq, Eq<R> rightEq)
static <L> Foldable<Either<L,?>>	EitherInstances.foldable()
static <L> Functor<Either<L,?>>	EitherInstances.functor()
private <T, R> Trampoline<Kind<Either<L,?>,R>>	EitherMonad.loop(T value, Function1<T,? extends Kind<Either<L,?>,Either<T,R>>> map)
static <L> Monad<Either<L,?>>	EitherInstances.monad()
static <L> MonadError<Either<L,?>,L>	EitherInstances.monadError()
static MonadThrow<Either<Throwable,?>>	EitherInstances.monadThrow()
default <A, B> EIO<Throwable,Either<Tuple2<A,Fiber<EIO<Throwable,?>,B>>,Tuple2<Fiber<EIO<Throwable,?>,A>,B>>>	EIOConcurrent.racePair(Kind<EIO<Throwable,?>,? extends A> fa, Kind<EIO<Throwable,?>,? extends B> fb)
default <A, B> IO<Either<Tuple2<A,Fiber<IO<?>,B>>,Tuple2<Fiber<IO<?>,A>,B>>>	IOConcurrent.racePair(Kind<IO<?>,? extends A> fa, Kind<IO<?>,? extends B> fb)
default <A, B> PureIO<R,Throwable,Either<Tuple2<A,Fiber<PureIO<R,Throwable,?>,B>>,Tuple2<Fiber<PureIO<R,Throwable,?>,A>,B>>>	PureIOConcurrent.racePair(Kind<PureIO<R,Throwable,?>,? extends A> fa, Kind<PureIO<R,Throwable,?>,? extends B> fb)
default <A, B> RIO<R,Either<Tuple2<A,Fiber<RIO<R,?>,B>>,Tuple2<Fiber<RIO<R,?>,A>,B>>>	RIOConcurrent.racePair(Kind<RIO<R,?>,? extends A> fa, Kind<RIO<R,?>,? extends B> fb)
default <A, B> Task<Either<Tuple2<A,Fiber<Task<?>,B>>,Tuple2<Fiber<Task<?>,A>,B>>>	TaskConcurrent.racePair(Kind<Task<?>,? extends A> fa, Kind<Task<?>,? extends B> fb)
default <A, B> UIO<Either<Tuple2<A,Fiber<UIO<?>,B>>,Tuple2<Fiber<UIO<?>,A>,B>>>	UIOConcurrent.racePair(Kind<UIO<?>,? extends A> fa, Kind<UIO<?>,? extends B> fb)
default <A, B> URIO<R,Either<Tuple2<A,Fiber<URIO<R,?>,B>>,Tuple2<Fiber<URIO<R,?>,A>,B>>>	URIOConcurrent.racePair(Kind<URIO<R,?>,? extends A> fa, Kind<URIO<R,?>,? extends B> fb)
Kind<F,Either<E,A>>	MonadMTL.EffectE.run()
default <T, R> Kind<Either<L,?>,R>	EitherMonad.tailRecM(T value, Function1<T,? extends Kind<Either<L,?>,Either<T,R>>> map)
static <L> Traverse<Either<L,?>>	EitherInstances.traverse()
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Either<L,?>,R>>	EitherTraverse.traverse(Applicative<G> applicative, Kind<Either<L,?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)

Method parameters in com.github.tonivade.purefun.instances with type arguments of type Either

Modifier and Type	Method	Description
default <T, R> Either<L,R>	EitherApplicative.ap(Kind<Either<L,?>,? extends T> value, Kind<Either<L,?>,? extends Function1<? super T,? extends R>> apply)
<A> MonadMTL.EffectS<F,S,R,E,A>	MonadMTL.effect(Kind<F,Either<E,A>> value)
<A> MonadMTL.EffectE<F,E,A>	MonadMTL.effectE(Kind<F,Either<E,A>> value)
static <F extends Kind<F, ?>, L, R> Eq<Kind<EitherT<F,L,?>,R>>	EitherTInstances.eq(Eq<Kind<F,Either<L,R>>> eq)
default <T, R> Either<L,R>	EitherMonad.flatMap(Kind<Either<L,?>,? extends T> value, Function1<? super T,? extends Kind<Either<L,?>,? extends R>> map)
default <T, R> Either<L,R>	EitherMonad.flatMap(Kind<Either<L,?>,? extends T> value, Function1<? super T,? extends Kind<Either<L,?>,? extends R>> map)
default <A, B> B	EitherFoldable.foldLeft(Kind<Either<L,?>,? extends A> value, B initial, Function2<? super B,? super A,? extends B> mapper)
default <A, B> Eval<B>	EitherFoldable.foldRight(Kind<Either<L,?>,? extends A> value, Eval<? extends B> initial, Function2<? super A,? super Eval<? extends B>,? extends Eval<? extends B>> mapper)
default <A> Either<L,A>	EitherMonadError.handleErrorWith(Kind<Either<L,?>,A> value, Function1<? super L,? extends Kind<Either<L,?>,? extends A>> handler)
default <A> Either<L,A>	EitherMonadError.handleErrorWith(Kind<Either<L,?>,A> value, Function1<? super L,? extends Kind<Either<L,?>,? extends A>> handler)
private <T, R> Trampoline<Kind<Either<L,?>,R>>	EitherMonad.loop(T value, Function1<T,? extends Kind<Either<L,?>,Either<T,R>>> map)
private <T, R> Trampoline<Kind<Either<L,?>,R>>	EitherMonad.loop(T value, Function1<T,? extends Kind<Either<L,?>,Either<T,R>>> map)
private <T, R> Trampoline<Kind<Option<?>,R>>	OptionMonad.loop(T value, Function1<T,? extends Kind<Option<?>,Either<T,R>>> map)
private <T, R> Trampoline<Kind<Try<?>,R>>	TryMonad.loop(T value, Function1<T,? extends Kind<Try<?>,Either<T,R>>> map)
private <T, R> Trampoline<Kind<Validation<E,?>,R>>	ValidationMonad.loop(T value, Function1<T,? extends Kind<Validation<E,?>,Either<T,R>>> map)
default <T, R> Either<L,R>	EitherFunctor.map(Kind<Either<L,?>,? extends T> value, Function1<? super T,? extends R> map)
<R extends Kind<F, Either<E, A>>> R	MonadMTL.EffectE.run(Function<Kind<F,? extends Either<E,A>>,R> fixer)
default <A, B> Validation<E,B>	ValidationSelective.select(Kind<Validation<E,?>,Either<A,B>> value, Kind<Validation<E,?>,Function1<? super A,? extends B>> apply)
default <T, R> Kind<Either<L,?>,R>	EitherMonad.tailRecM(T value, Function1<T,? extends Kind<Either<L,?>,Either<T,R>>> map)
default <T, R> Kind<Either<L,?>,R>	EitherMonad.tailRecM(T value, Function1<T,? extends Kind<Either<L,?>,Either<T,R>>> map)
default <T, R> Kind<Option<?>,R>	OptionMonad.tailRecM(T value, Function1<T,? extends Kind<Option<?>,Either<T,R>>> map)
default <T, R> Kind<Try<?>,R>	TryMonad.tailRecM(T value, Function1<T,? extends Kind<Try<?>,Either<T,R>>> map)
default <T, R> Kind<Validation<E,?>,R>	ValidationMonad.tailRecM(T value, Function1<T,? extends Kind<Validation<E,?>,Either<T,R>>> map)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Either<L,?>,R>>	EitherTraverse.traverse(Applicative<G> applicative, Kind<Either<L,?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)

Uses of Either in com.github.tonivade.purefun.monad

Methods in com.github.tonivade.purefun.monad that return types with arguments of type Either

Modifier and Type	Method	Description
default IO<Either<Throwable,T>>	IO.either()
default <L, R> IO<Either<L,R>>	IO.either(Function1<? super Throwable,? extends L> mapError, Function1<? super T,? extends R> mapper)
static <A, B> IO<Either<A,B>>	IO.race(Kind<IO<?>,? extends A> fa, Kind<IO<?>,? extends B> fb)
static <A, B> IO<Either<A,B>>	IO.race(Executor executor, Kind<IO<?>,? extends A> fa, Kind<IO<?>,? extends B> fb)
static <A, B> IO<Either<Tuple2<A,Fiber<IO<?>,B>>,Tuple2<Fiber<IO<?>,A>,B>>>	IO.racePair(Executor executor, Kind<IO<?>,? extends A> fa, Kind<IO<?>,? extends B> fb)

Methods in com.github.tonivade.purefun.monad with parameters of type Either

Modifier and Type	Method	Description
static <T> IO<T>	IO.fromEither(Either<Throwable,? extends T> task)

Method parameters in com.github.tonivade.purefun.monad with type arguments of type Either

Modifier and Type	Method	Description
static <A, B> Function1<A,IO<B>>	IO.liftEither(Function1<? super A,? extends Either<Throwable,? extends B>> function)

Uses of Either in com.github.tonivade.purefun.optics

Fields in com.github.tonivade.purefun.optics with type parameters of type Either

Modifier and Type	Field	Description
private final Function1<S,Either<T,A>>	POptional.getOrModify
private final Function1<S,Either<T,A>>	PPrism.getOrModify

Methods in com.github.tonivade.purefun.optics that return Either

Modifier and Type	Method	Description
Either<S,A>	Optional.getOrModify(S target)
Either<T,A>	POptional.getOrModify(S target)
Either<T,A>	PPrism.getOrModify(S target)
Either<S,A>	Prism.getOrModify(S target)

Method parameters in com.github.tonivade.purefun.optics with type arguments of type Either

Modifier and Type	Method	Description
static <S, T, A, B> POptional<S,T,A,B>	POptional.of(Function2<S,B,T> set, Function1<S,Either<T,A>> getOrModify)
static <S, T, A, B> PPrism<S,T,A,B>	PPrism.of(Function1<S,Either<T,A>> getOrModify, Function1<B,T> reverseGet)

Constructor parameters in com.github.tonivade.purefun.optics with type arguments of type Either

Modifier	Constructor	Description
(package private)	PPrism(Function1<S,Either<T,A>> getOrModify, Function1<B,T> reverseGet)

Uses of Either in com.github.tonivade.purefun.runtimes

Methods in com.github.tonivade.purefun.runtimes that return types with arguments of type Either

Modifier and Type	Method	Description
<R, E, T> Function1<R,Either<E,T>>	ConsoleExecutor.run(PureIO<R,E,T> program)

Uses of Either in com.github.tonivade.purefun.transformer

Methods in com.github.tonivade.purefun.transformer that return types with arguments of type Either

Modifier and Type	Method	Description
default <V> Kind<F,Either<L,V>>	EitherT.flatMapF(Function1<? super R,? extends Kind<F,? extends Either<L,V>>> map)
Kind<F,Either<L,R>>	EitherT.value()

Methods in com.github.tonivade.purefun.transformer with parameters of type Either

Modifier and Type	Method	Description
static <F extends Kind<F, ?>, L, R> EitherT<F,L,R>	EitherT.lift(Monad<F> monad, Either<L,R> either)

Method parameters in com.github.tonivade.purefun.transformer with type arguments of type Either

Modifier and Type	Method	Description
default EitherT<F,L,R>	EitherT.filterOrElse(Matcher1<R> filter, Producer<Either<L,R>> orElse)
default <V> Kind<F,Either<L,V>>	EitherT.flatMapF(Function1<? super R,? extends Kind<F,? extends Either<L,V>>> map)
static <F extends Kind<F, ?>, L, R> EitherT<F,L,R>	EitherT.of(Monad<F> monad, Kind<F,Either<L,R>> value)

Uses of Either in com.github.tonivade.purefun.type

Classes in com.github.tonivade.purefun.type that implement Either

Modifier and Type	Class	Description
static final record	Either.Left<L,R>
static final record	Either.Right<L,R>

Methods in com.github.tonivade.purefun.type that return Either

Modifier and Type	Method	Description
default <T> Either<L,T>	Either.ap(Kind<Either<L,?>,? extends Function1<? super R,? extends T>> apply)
default <T, U> Either<T,U>	Either.bimap(Function1<? super L,? extends T> leftMapper, Function1<? super R,? extends U> rightMapper)
default Either<L,R>	Either.filterOrElse(Matcher1<? super R> matcher, Producer<? extends Kind<Either<L,?>,R>> orElse)
default <T> Either<L,T>	Either.flatMap(Function1<? super R,? extends Kind<Either<L,?>,? extends T>> map)
default <T> Either<T,R>	Either.flatMapLeft(Function1<? super L,? extends Either<? extends T,R>> map)
static <L, R> Either<L,R>	Either.left(L value)
default <T> Either<L,T>	Either.map(Function1<? super R,? extends T> map)
static <L, A, B, Z> Either<L,Z>	Either.map2(Either<L,? extends A> eitherA, Either<L,? extends B> eitherB, Function2<? super A,? super B,? extends Z> mapper)
default <T> Either<T,R>	Either.mapLeft(Function1<? super L,? extends T> map)
default Either<L,R>	Either.or(Producer<Kind<Either<L,?>,R>> orElse)
default Either<L,R>	Either.orElse(Kind<Either<L,?>,R> orElse)
static <L, R> Either<L,R>	Either.right(R value)
default Either<R,L>	Either.swap()
static <L, R> Either<L,R>	EitherOf.toEither(Kind<Either<L,?>,? extends R> value)
default Either<Throwable,T>	Option.toEither()
default Either<Throwable,T>	Try.toEither()
default Either<E,T>	Validation.toEither()

Methods in com.github.tonivade.purefun.type that return types with arguments of type Either

Modifier and Type	Method	Description
default Option<Either<L,R>>	Either.filter(Matcher1<? super R> matcher)
default Option<Either<L,R>>	Either.filterNot(Matcher1<? super R> matcher)

Methods in com.github.tonivade.purefun.type with parameters of type Either

Modifier and Type	Method	Description
static <R> Try<R>	Try.fromEither(Either<? extends Throwable,? extends R> value)
static <L, A, B, Z> Either<L,Z>	Either.map2(Either<L,? extends A> eitherA, Either<L,? extends B> eitherB, Function2<? super A,? super B,? extends Z> mapper)
static <A> A	Either.merge(Either<A,A> either)

Method parameters in com.github.tonivade.purefun.type with type arguments of type Either

Modifier and Type	Method	Description
default <T> Either<L,T>	Either.ap(Kind<Either<L,?>,? extends Function1<? super R,? extends T>> apply)
default Either<L,R>	Either.filterOrElse(Matcher1<? super R> matcher, Producer<? extends Kind<Either<L,?>,R>> orElse)
default <T> Either<L,T>	Either.flatMap(Function1<? super R,? extends Kind<Either<L,?>,? extends T>> map)
default <T> Either<T,R>	Either.flatMapLeft(Function1<? super L,? extends Either<? extends T,R>> map)
default Either<L,R>	Either.or(Producer<Kind<Either<L,?>,R>> orElse)
default Either<L,R>	Either.orElse(Kind<Either<L,?>,R> orElse)
static <E, T, R> Validation<E,R>	Validation.select(Validation<E,Either<T,R>> validation, Validation<E,Function1<? super T,? extends R>> apply)
static <L, R> Either<L,R>	EitherOf.toEither(Kind<Either<L,?>,? extends R> value)

Uses of Either in com.github.tonivade.purefun.typeclasses

Methods in com.github.tonivade.purefun.typeclasses that return types with arguments of type Either

Modifier and Type	Method	Description
<C> Schedule<F,A,Either<B,C>>	Schedule.andThenEither(Schedule<F,A,C> next)
<C> Schedule<F,A,Either<B,C>>	ScheduleImpl.andThenEither(Schedule<F,A,C> next)
default <A> Kind<F,Either<E,A>>	ApplicativeError.attempt(Kind<F,A> value)
private <T, C> ScheduleImpl<F,Either<S,T>,A,Either<B,C>>	ScheduleImpl.doAndThenEither(ScheduleImpl<F,T,A,C> other)
private <T, C> ScheduleImpl<F,Either<S,T>,A,Either<B,C>>	ScheduleImpl.doAndThenEither(ScheduleImpl<F,T,A,C> other)
default <A, B> Kind<F,Either<A,B>>	Concurrent.race(Kind<F,? extends A> fa, Kind<F,? extends B> fb)
<A, B> Kind<F,Either<Tuple2<A,Fiber<F,B>>,Tuple2<Fiber<F,A>,B>>>	Concurrent.racePair(Kind<F,? extends A> fa, Kind<F,? extends B> fb)
private <A, B, C, S> Kind<F,Either<C,B>>	MonadError.repeat(Kind<F,A> value, ScheduleImpl<F,S,A,B> schedule, Function2<E,Option<B>,Kind<F,C>> orElse)
default <A, B, C> Kind<F,Either<C,B>>	MonadError.repeatOrElseEither(Kind<F,A> value, Schedule<F,A,B> schedule, Function2<E,Option<B>,Kind<F,C>> orElse)
private <A, B, S> Kind<F,Either<B,A>>	MonadError.retry(Kind<F,A> value, ScheduleImpl<F,S,E,S> schedule, Function2<E,S,Kind<F,B>> orElse)
default <A, B, C> Kind<F,Either<B,A>>	MonadError.retryOrElseEither(Kind<F,A> value, Schedule<F,E,C> schedule, Function2<E,C,Kind<F,B>> orElse)
private Kind<F,Either<Unit,Unit>>	Selective.selector(Kind<F,Boolean> condition)
Kind<F,Either<Unit,S>>	Schedule.Update.update(A last, S state)
Kind<F,Either<Unit,S>>	ScheduleImpl.update(A last, S state)

Methods in com.github.tonivade.purefun.typeclasses with parameters of type Either

Modifier and Type	Method	Description
default <A> Kind<F,A>	ApplicativeError.fromEither(Either<E,? extends A> value)

Method parameters in com.github.tonivade.purefun.typeclasses with type arguments of type Either

Modifier and Type	Method	Description
default <A, B, C> Kind<F,C>	Selective.branch(Kind<F,Either<A,B>> value, Kind<F,Function1<? super A,? extends C>> applyA, Kind<F,Function1<? super B,? extends C>> applyB)
<Z> Schedule<F,A,Z>	Schedule.foldM(Z zero, Function2<? super Z,? super B,? extends Kind<F,Either<Unit,? extends Z>>> next)
<Z> Schedule<F,A,Z>	ScheduleImpl.foldM(Z zero, Function2<? super Z,? super B,? extends Kind<F,Either<Unit,? extends Z>>> next)
default <A, B> Kind<F,B>	Monad.select(Kind<F,Either<A,B>> value, Kind<F,Function1<? super A,? extends B>> apply)
<A, B> Kind<F,B>	Selective.select(Kind<F,Either<A,B>> value, Kind<F,Function1<? super A,? extends B>> apply)
default <T, R> Kind<F,R>	Monad.tailRecM(T value, Function1<T,? extends Kind<F,Either<T,R>>> map)
default <A, B> Schedule<F,A,B>	Schedule.Of.unfoldM(Kind<F,B> initial, Function1<B,Kind<F,Either<Unit,B>>> next)
static <F extends Kind<F, ?>, A, B> Schedule<F,A,B>	Schedule.unfoldM(Kind<F,B> initial, Function1<B,Kind<F,Either<Unit,B>>> next, F... reified)