Package com.github.tonivade.purefun.effect

Interface PureIO<R,E,A>

All Superinterfaces:

Applicable<PureIO<R,E,?>,A>, Bindable<PureIO<R,E,?>,A>, Effect<PureIO<R,E,?>,A>, Kind<PureIO<R,E,?>,A>, Mappable<PureIO<R,E,?>,A>, PureIOOf<R,E,A>

All Known Implementing Classes:

PureIO.AccessM, PureIO.Async, PureIO.Attempt, PureIO.Delay, PureIO.Failure, PureIO.FlatMapped, PureIO.Pure, PureIO.Recover, PureIO.Suspend, PureIO.Throw

public sealed interface PureIO<R,E,A>
extends PureIOOf<R,E,A>, Effect<PureIO<R,E,?>,A>
permits PureIO.Pure<R,E,A>, PureIO.Failure<R,E,A>, PureIO.Throw<R,E,A>, PureIO.FlatMapped<R,E,A,F,B>, PureIO.Delay<R,E,A>, PureIO.Suspend<R,E,A>, PureIO.Async<R,E,A>, PureIO.Attempt<R,E,A>, PureIO.Recover<R,E,A>, PureIO.AccessM<R,E,A>

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static final class	PureIO.AccessM<R,E,A>
static final class	PureIO.Async<R,E,A>
static final class	PureIO.Attempt<R,E,A>
static final class	PureIO.Delay<R,E,A>
static final class	PureIO.Failure<R,E,A>
static final class	PureIO.FlatMapped<R,E,A,F,B>
static final class	PureIO.Pure<R,E,A>
static final class	PureIO.Recover<R,E,A>
static final class	PureIO.Suspend<R,E,A>
static final class	PureIO.Throw<R,E,A>

Nested classes/interfaces inherited from interface com.github.tonivade.purefun.core.Applicable

Applicable.Map2<F extends Applicable<F,?>,A,B>, Applicable.Map3<F extends Applicable<F,?>,A,B,C>, Applicable.Map4<F extends Applicable<F,?>,A,B,C,D>, Applicable.Map5<F extends Applicable<F,?>,A,B,C,D,E>

Field Summary

Fields

Modifier and Type	Field	Description
static final PureIO<?,?,Unit>	UNIT

Method Summary

Modifier and Type	Method	Description
static <R, E, A> PureIO<R,E,A>	absorb(Kind<PureIO<R,E,?>,Either<E,A>> value)
static <R, E, A> PureIO<R,E,A>	access(Function1<? super R,? extends A> map)
static <R, E, A> PureIO<R,E,A>	accessM(Function1<? super R,? extends Kind<PureIO<R,E,?>,? extends A>> map)
static <R, E, A> Kind<PureIO<R,E,?>,A>	accessM(R env, PureIO.AccessM<R,E,A> accessM)
default <B> PureIO<R,E,B>	andThen(Kind<PureIO<R,E,?>,? extends B> next)
default <B> PureIO<R,E,B>	ap(Kind<PureIO<R,E,?>,? extends Function1<? super A,? extends B>> apply)
static <R, E, A> PureIO<R,E,A>	async(Consumer2<R,Consumer1<? super Try<? extends Either<E,? extends A>>>> consumer)
default <B, F> PureIO<R,F,B>	bimap(Function1<? super E,? extends F> mapError, Function1<? super A,? extends B> map)
static <R, E, A extends AutoCloseable, B> PureIO<R,E,B>	bracket(Kind<PureIO<R,E,?>,? extends A> acquire, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> use)
static <R, E, A, B> PureIO<R,E,B>	bracket(Kind<PureIO<R,E,?>,? extends A> acquire, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> use, Consumer1<? super A> release)
static <R, E, A, B> PureIO<R,E,B>	bracket(Kind<PureIO<R,E,?>,? extends A> acquire, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> use, Function1<? super A,? extends Kind<PureIO<R,E,?>,Unit>> release)
static <R, E, A> PureIO<R,E,A>	cancellable(Function2<R,Consumer1<? super Try<? extends Either<E,? extends A>>>,PureIO<R,?,Unit>> consumer)
static <R, E, A> PureIO<R,E,A>	defer(Producer<Kind<PureIO<R,E,?>,? extends A>> lazy)
static <R, E> PureIO<R,E,R>	env()
static <R> PureIO<R,Throwable,Unit>	exec(CheckedRunnable task)
private static <R, E, A> Promise<Either<E,A>>	executeAsync(R env, PureIO.Async<R,E,A> current, PureIOConnection connection, Promise<Either<E,A>> promise)
default <B> PureIO<R,E,B>	flatMap(Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> map)
default <F> PureIO<R,F,A>	flatMapError(Function1<? super E,? extends Kind<PureIO<R,F,?>,? extends A>> map)
default <B> URIO<R,B>	fold(Function1<? super E,? extends B> mapError, Function1<? super A,? extends B> map)
default <F, B> PureIO<R,F,B>	foldM(Function1<? super E,? extends Kind<PureIO<R,F,?>,? extends B>> left, Function1<? super A,? extends Kind<PureIO<R,F,?>,? extends B>> right)
default PureIO<R,E,Fiber<PureIO<R,E,?>,A>>	fork()
static <R, E> PureIO<R,E,Unit>	forked(Executor executor)
static <R, E, A> PureIO<R,E,A>	fromEither(Producer<Either<E,? extends A>> task)
static <R, E, A> PureIO<R,E,A>	fromEither(Either<E,? extends A> task)
static <R, A> PureIO<R,Throwable,A>	fromOption(Producer<Option<? extends A>> task)
static <R, A> PureIO<R,Throwable,A>	fromOption(Option<? extends A> task)
static <R, E, A> PureIO<R,E,A>	fromPromise(Promise<? extends Either<E,? extends A>> promise)
static <R, A> PureIO<R,Throwable,A>	fromTry(Producer<Try<? extends A>> task)
static <R, A> PureIO<R,Throwable,A>	fromTry(Try<? extends A> task)
static <R, E, A> PureIO<R,E,A>	later(Producer<? extends A> task)
static <R, A, B> Function1<A,PureIO<R,Throwable,B>>	lift(Function1<? super A,? extends B> function)
static <R, E, A, B> Function1<A,PureIO<R,E,B>>	liftEither(Function1<? super A,? extends Either<E,? extends B>> function)
static <R, A, B> Function1<A,PureIO<R,Throwable,B>>	liftOption(Function1<? super A,? extends Option<? extends B>> function)
static <R, A, B> Function1<A,PureIO<R,Throwable,B>>	liftTry(Function1<? super A,? extends Try<? extends B>> function)
default <B> PureIO<R,E,B>	map(Function1<? super A,? extends B> map)
default <B> PureIO<R,B,A>	mapError(Function1<? super E,? extends B> map)
static <R, E, A> PureIO<R,E,A>	never()
default PureIO<R,E,A>	orElse(Kind<PureIO<R,E,?>,? extends A> other)
static <R, E, A, B, C> PureIO<R,E,C>	parMap2(Kind<PureIO<R,E,?>,? extends A> za, Kind<PureIO<R,E,?>,? extends B> zb, Function2<? super A,? super B,? extends C> mapper)
static <R, E, A, B, C> PureIO<R,E,C>	parMap2(Executor executor, Kind<PureIO<R,E,?>,? extends A> za, Kind<PureIO<R,E,?>,? extends B> zb, Function2<? super A,? super B,? extends C> mapper)
default Either<E,A>	provide(R env)
default void	provideAsync(R env, Consumer1<? super Try<? extends Either<E,A>>> callback)
default void	provideAsync(R env, Executor executor, Consumer1<? super Try<? extends Either<E,A>>> callback)
static <R, E, A> PureIO<R,E,A>	pure(A value)
static <R, E, A, B> PureIO<R,E,Either<A,B>>	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>>	race(Executor executor, Kind<PureIO<R,E,?>,? extends A> fa, Kind<PureIO<R,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>>>	racePair(Executor executor, Kind<PureIO<R,E,?>,? extends A> fa, Kind<PureIO<R,E,?>,? extends B> fb)
static <R, E, A> PureIO<R,E,A>	raiseError(E error)
default URIO<R,A>	recover(Function1<? super E,? extends A> mapError)
static <R, A> PureIO<R,Throwable,A>	redeem(Kind<PureIO<R,Void,?>,? extends A> value)
default <X extends Throwable> PureIO<R,X,A>	refineOrDie(Class<X> type)
default PureIO<R,E,A>	repeat()
default PureIO<R,E,A>	repeat(int times)
private static <R, E, A> PureIO<R,E,A>	repeat(PureIO<R,E,A> self, PureIO<R,E,Unit> pause, int times)
default PureIO<R,E,A>	repeat(Duration delay)
default PureIO<R,E,A>	repeat(Duration delay, int times)
default PureIO<R,E,A>	retry()
default PureIO<R,E,A>	retry(int maxRetries)
private static <R, E, A> PureIO<R,E,A>	retry(PureIO<R,E,A> self, PureIO<R,E,Unit> pause, int maxRetries)
default PureIO<R,E,A>	retry(Duration delay)
default PureIO<R,E,A>	retry(Duration delay, int maxRetries)
static <R, E> PureIO<R,E,Unit>	run(Runnable task)
default Future<Either<E,A>>	runAsync(R env)
private static <R, E, A> Promise<Either<E,A>>	runAsync(R env, Kind<PureIO<R,E,?>,A> current, PureIOConnection connection)
private static <R, E, F, G, A, B, C> Promise<Either<E,A>>	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>>	runAsync(R env, Executor executor)
private static <R, E, A> void	setCancelToken(R env, PureIO.Async<R,E,A> current, PureIOConnection connection, Promise<Either<E,A>> promise)
static <R, E> PureIO<R,E,Unit>	sleep(Duration delay)
static <R, E> PureIO<R,E,Unit>	sleep(Executor executor, Duration delay)
default PureIO<R,A,E>	swap()
static <R, A> PureIO<R,Throwable,A>	task(Producer<? extends A> task)
static <R, E, A> PureIO<R,E,A>	throwError(Throwable error)
default PureIO<R,E,Tuple2<Duration,A>>	timed()
default PureIO<R,E,A>	timeout(Duration duration)
default PureIO<R,E,A>	timeout(Executor executor, Duration duration)
default Managed<R,E,A>	toManaged()
default Managed<R,E,A>	toManaged(Consumer1<? super A> release)
default RIO<R,A>	toRIO()
default URIO<R,A>	toURIO()
static <R, E, A> PureIO<R,E,Sequence<A>>	traverse(Sequence<? extends Kind<PureIO<R,E,?>,A>> sequence)
static <R, E, A> PureIO<R,E,Sequence<A>>	traverse(Executor executor, Sequence<? extends Kind<PureIO<R,E,?>,A>> sequence)
static <R, E> PureIO<R,E,Unit>	unit()
private static <R, E, F, A, B> Kind<PureIO<R,E,?>,A>	unwrap(R env, Kind<PureIO<R,E,?>,A> current, CallStack<R,F,B> stack, Function1<Kind<PureIO<R,E,?>,? extends A>,Kind<PureIO<R,F,?>,? extends B>> next)
default <B> PureIO<R,E,Tuple2<A,B>>	zip(Kind<PureIO<R,E,?>,? extends B> other)
default <B> PureIO<R,E,A>	zipLeft(Kind<PureIO<R,E,?>,? extends B> other)
default <B> PureIO<R,E,B>	zipRight(Kind<PureIO<R,E,?>,? extends B> other)
default <B, C> PureIO<R,E,C>	zipWith(Kind<PureIO<R,E,?>,? extends B> other, Function2<? super A,? super B,? extends C> mapper)

Methods inherited from interface com.github.tonivade.purefun.Kind

fix, kind

Field Details

UNIT

static final PureIO<?,?,Unit> UNIT

Method Details

provide

default Either<E,A> provide(@Nullable
 R env)

runAsync

default Future<Either<E,A>> runAsync(@Nullable
 R env)

runAsync

default Future<Either<E,A>> runAsync(@Nullable
 R env,
 Executor executor)

provideAsync

default void provideAsync(@Nullable
 R env,
 Consumer1<? super Try<? extends Either<E,A>>> callback)

provideAsync

default void provideAsync(@Nullable
 R env,
 Executor executor,
 Consumer1<? super Try<? extends Either<E,A>>> callback)

swap

default PureIO<R,A,E> swap()

map

default <B> PureIO<R,E,B> map(Function1<? super A,? extends B> map)

Specified by:

map in interface Applicable<R,E>

Specified by:

map in interface Bindable<R,E>

Specified by:

map in interface Effect<R,E>

Specified by:

map in interface Mappable<R,E>

mapError

default <B> PureIO<R,B,A> mapError(Function1<? super E,? extends B> map)

bimap

default <B,
F> PureIO<R,F,B> bimap(Function1<? super E,? extends F> mapError,
 Function1<? super A,? extends B> map)

flatMap

default <B> PureIO<R,E,B> flatMap(Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> map)

Specified by:

flatMap in interface Bindable<R,E>

Specified by:

flatMap in interface Effect<R,E>

flatMapError

default <F> PureIO<R,F,A> flatMapError(Function1<? super E,? extends Kind<PureIO<R,F,?>,? extends A>> map)

foldM

default <F,
B> PureIO<R,F,B> foldM(Function1<? super E,? extends Kind<PureIO<R,F,?>,? extends B>> left,
 Function1<? super A,? extends Kind<PureIO<R,F,?>,? extends B>> right)

andThen

default <B> PureIO<R,E,B> andThen(Kind<PureIO<R,E,?>,? extends B> next)

Specified by:

andThen in interface Bindable<R,E>

Specified by:

andThen in interface Effect<R,E>

ap

default <B> PureIO<R,E,B> ap(Kind<PureIO<R,E,?>,? extends Function1<? super A,? extends B>> apply)

Specified by:

ap in interface Applicable<R,E>

Specified by:

ap in interface Effect<R,E>

fold

default <B> URIO<R,B> fold(Function1<? super E,? extends B> mapError,
 Function1<? super A,? extends B> map)

recover

default URIO<R,A> recover(Function1<? super E,? extends A> mapError)

orElse

default PureIO<R,E,A> orElse(Kind<PureIO<R,E,?>,? extends A> other)

zip

default <B> PureIO<R,E,Tuple2<A,B>> zip(Kind<PureIO<R,E,?>,? extends B> other)

Specified by:

zip in interface Applicable<R,E>

Specified by:

zip in interface Effect<R,E>

zipLeft

default <B> PureIO<R,E,A> zipLeft(Kind<PureIO<R,E,?>,? extends B> other)

Specified by:

zipLeft in interface Applicable<R,E>

Specified by:

zipLeft in interface Effect<R,E>

zipRight

default <B> PureIO<R,E,B> zipRight(Kind<PureIO<R,E,?>,? extends B> other)

Specified by:

zipRight in interface Applicable<R,E>

Specified by:

zipRight in interface Effect<R,E>

zipWith

default <B,
C> PureIO<R,E,C> zipWith(Kind<PureIO<R,E,?>,? extends B> other,
 Function2<? super A,? super B,? extends C> mapper)

Specified by:

zipWith in interface Applicable<R,E>

Specified by:

zipWith in interface Effect<R,E>

repeat

default PureIO<R,E,A> repeat()

Specified by:

repeat in interface Effect<R,E>

repeat

default PureIO<R,E,A> repeat(int times)

Specified by:

repeat in interface Effect<R,E>

repeat

default PureIO<R,E,A> repeat(Duration delay)

Specified by:

repeat in interface Effect<R,E>

repeat

default PureIO<R,E,A> repeat(Duration delay,
 int times)

Specified by:

repeat in interface Effect<R,E>

retry

default PureIO<R,E,A> retry()

Specified by:

retry in interface Effect<R,E>

retry

default PureIO<R,E,A> retry(int maxRetries)

Specified by:

retry in interface Effect<R,E>

retry

default PureIO<R,E,A> retry(Duration delay)

Specified by:

retry in interface Effect<R,E>

retry

default PureIO<R,E,A> retry(Duration delay,
 int maxRetries)

Specified by:

retry in interface Effect<R,E>

timed

default PureIO<R,E,Tuple2<Duration,A>> timed()

Specified by:

timed in interface Effect<R,E>

fork

default PureIO<R,E,Fiber<PureIO<R,E,?>,A>> fork()

timeout

default PureIO<R,E,A> timeout(Duration duration)

Specified by:

timeout in interface Effect<R,E>

timeout

default PureIO<R,E,A> timeout(Executor executor,
 Duration duration)

refineOrDie

default <X extends Throwable> PureIO<R,X,A> refineOrDie(Class<X> type)

toURIO

default URIO<R,A> toURIO()

toRIO

default RIO<R,A> toRIO()

toManaged

default Managed<R,E,A> toManaged()

toManaged

default Managed<R,E,A> toManaged(Consumer1<? super A> release)

accessM

static <R,
E,
A> PureIO<R,E,A> accessM(Function1<? super R,? extends Kind<PureIO<R,E,?>,? extends A>> map)

access

static <R,
E,
A> PureIO<R,E,A> access(Function1<? super R,? extends A> map)

env

static <R,
E> PureIO<R,E,R> env()

forked

static <R,
E> PureIO<R,E,Unit> forked(Executor executor)

parMap2

static <R,
E,
A,
B,
C> PureIO<R,E,C> parMap2(Kind<PureIO<R,E,?>,? extends A> za,
 Kind<PureIO<R,E,?>,? extends B> zb,
 Function2<? super A,? super B,? extends C> mapper)

parMap2

static <R,
E,
A,
B,
C> PureIO<R,E,C> parMap2(Executor executor,
 Kind<PureIO<R,E,?>,? extends A> za,
 Kind<PureIO<R,E,?>,? extends B> zb,
 Function2<? super A,? super B,? extends C> mapper)

race

static <R,
E,
A,
B> PureIO<R,E,Either<A,B>> race(Kind<PureIO<R,E,?>,? extends A> fa,
 Kind<PureIO<R,E,?>,? extends B> fb)

race

static <R,
E,
A,
B> PureIO<R,E,Either<A,B>> race(Executor executor,
 Kind<PureIO<R,E,?>,? extends A> fa,
 Kind<PureIO<R,E,?>,? extends B> fb)

racePair

static <R,
E,
A,
B>
PureIO<R,E,Either<Tuple2<A,Fiber<PureIO<R,E,?>,B>>,Tuple2<Fiber<PureIO<R,E,?>,A>,B>>> racePair(Executor executor,
 Kind<PureIO<R,E,?>,? extends A> fa,
 Kind<PureIO<R,E,?>,? extends B> fb)

absorb

static <R,
E,
A> PureIO<R,E,A> absorb(Kind<PureIO<R,E,?>,Either<E,A>> value)

lift

static <R,
A,
B> Function1<A,PureIO<R,Throwable,B>> lift(Function1<? super A,? extends B> function)

liftOption

static <R,
A,
B> Function1<A,PureIO<R,Throwable,B>> liftOption(Function1<? super A,? extends Option<? extends B>> function)

liftTry

static <R,
A,
B> Function1<A,PureIO<R,Throwable,B>> liftTry(Function1<? super A,? extends Try<? extends B>> function)

liftEither

static <R,
E,
A,
B> Function1<A,PureIO<R,E,B>> liftEither(Function1<? super A,? extends Either<E,? extends B>> function)

fromOption

static <R,
A> PureIO<R,Throwable,A> fromOption(Option<? extends A> task)

fromOption

static <R,
A> PureIO<R,Throwable,A> fromOption(Producer<Option<? extends A>> task)

fromTry

static <R,
A> PureIO<R,Throwable,A> fromTry(Try<? extends A> task)

fromTry

static <R,
A> PureIO<R,Throwable,A> fromTry(Producer<Try<? extends A>> task)

fromEither

static <R,
E,
A> PureIO<R,E,A> fromEither(Either<E,? extends A> task)

fromEither

static <R,
E,
A> PureIO<R,E,A> fromEither(Producer<Either<E,? extends A>> task)

fromPromise

static <R,
E,
A> PureIO<R,E,A> fromPromise(Promise<? extends Either<E,? extends A>> promise)

exec

static <R> PureIO<R,Throwable,Unit> exec(CheckedRunnable task)

run

static <R,
E> PureIO<R,E,Unit> run(Runnable task)

pure

static <R,
E,
A> PureIO<R,E,A> pure(A value)

defer

static <R,
E,
A> PureIO<R,E,A> defer(Producer<Kind<PureIO<R,E,?>,? extends A>> lazy)

task

static <R,
A> PureIO<R,Throwable,A> task(Producer<? extends A> task)

later

static <R,
E,
A> PureIO<R,E,A> later(Producer<? extends A> task)

never

static <R,
E,
A> PureIO<R,E,A> never()

async

static <R,
E,
A> PureIO<R,E,A> async(Consumer2<R,Consumer1<? super Try<? extends Either<E,? extends A>>>> consumer)

cancellable

static <R,
E,
A> PureIO<R,E,A> cancellable(Function2<R,Consumer1<? super Try<? extends Either<E,? extends A>>>,PureIO<R,?,Unit>> consumer)

raiseError

static <R,
E,
A> PureIO<R,E,A> raiseError(E error)

throwError

static <R,
E,
A> PureIO<R,E,A> throwError(Throwable error)

redeem

static <R,
A> PureIO<R,Throwable,A> redeem(Kind<PureIO<R,Void,?>,? extends A> value)

sleep

static <R,
E> PureIO<R,E,Unit> sleep(Duration delay)

sleep

static <R,
E> PureIO<R,E,Unit> sleep(Executor executor,
 Duration delay)

traverse

static <R,
E,
A> PureIO<R,E,Sequence<A>> traverse(Sequence<? extends Kind<PureIO<R,E,?>,A>> sequence)

traverse

static <R,
E,
A> PureIO<R,E,Sequence<A>> traverse(Executor executor,
 Sequence<? extends Kind<PureIO<R,E,?>,A>> sequence)

bracket

static <R,
E,
A extends AutoCloseable,
B>
PureIO<R,E,B> bracket(Kind<PureIO<R,E,?>,? extends A> acquire,
 Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> use)

bracket

static <R,
E,
A,
B> PureIO<R,E,B> bracket(Kind<PureIO<R,E,?>,? extends A> acquire,
 Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> use,
 Consumer1<? super A> release)

bracket

static <R,
E,
A,
B> PureIO<R,E,B> bracket(Kind<PureIO<R,E,?>,? extends A> acquire,
 Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> use,
 Function1<? super A,? extends Kind<PureIO<R,E,?>,Unit>> release)

unit

static <R,
E> PureIO<R,E,Unit> unit()

runAsync

private static <R,
E,
A> Promise<Either<E,A>> runAsync(@Nullable
 R env,
 Kind<PureIO<R,E,?>,A> current,
 PureIOConnection connection)

runAsync

private static <R,
E,
F,
G,
A,
B,
C>
Promise<Either<E,A>> runAsync(@Nullable
 R env,
 Kind<PureIO<R,E,?>,A> current,
 PureIOConnection connection,
 CallStack<R,E,A> stack,
 Promise<Either<E,A>> promise)

unwrap

private static <R,
E,
F,
A,
B>
Kind<PureIO<R,E,?>,A> unwrap(@Nullable
 R env,
 Kind<PureIO<R,E,?>,A> current,
 CallStack<R,F,B> stack,
 Function1<Kind<PureIO<R,E,?>,? extends A>,Kind<PureIO<R,F,?>,? extends B>> next)

accessM

static <R,
E,
A> Kind<PureIO<R,E,?>,A> accessM(@Nullable
 R env,
 PureIO.AccessM<R,E,A> accessM)

executeAsync

private static <R,
E,
A> Promise<Either<E,A>> executeAsync(@Nullable
 R env,
 PureIO.Async<R,E,A> current,
 PureIOConnection connection,
 Promise<Either<E,A>> promise)

setCancelToken

private static <R,
E,
A> void setCancelToken(@Nullable
 R env,
 PureIO.Async<R,E,A> current,
 PureIOConnection connection,
 Promise<Either<E,A>> promise)

repeat

private static <R,
E,
A> PureIO<R,E,A> repeat(PureIO<R,E,A> self,
 PureIO<R,E,Unit> pause,
 int times)

retry

private static <R,
E,
A> PureIO<R,E,A> retry(PureIO<R,E,A> self,
 PureIO<R,E,Unit> pause,
 int maxRetries)