Package com.github.tonivade.purefun.effect

Class RIO<R,A>

java.lang.Object

com.github.tonivade.purefun.effect.RIO<R,A>

All Implemented Interfaces:

Applicable<RIO<R,?>,A>, Bindable<RIO<R,?>,A>, Effect<RIO<R,?>,A>, Mappable<RIO<R,?>,A>, Recoverable, RIOOf<R,A>, Kind<RIO<R,?>,A>

public final class RIO<R,A>
extends Object
implements RIOOf<R,A>, Effect<RIO<R,?>,A>, Recoverable

Nested Class Summary

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
private final PureIO<R,Throwable,A>	instance
private static final RIO<?,Unit>	UNIT

Constructor Summary

Constructors

Constructor	Description
RIO(PureIO<R,Throwable,A> value)

Method Summary

Modifier and Type	Method	Description
static <R, A> RIO<R,A>	absorb(RIO<R,Either<Throwable,A>> value)
static <R, A> RIO<R,A>	access(Function1<? super R,? extends A> map)
static <R, A> RIO<R,A>	accessM(Function1<? super R,? extends Kind<RIO<R,?>,? extends A>> map)
<B> RIO<R,B>	andThen(Kind<RIO<R,?>,? extends B> next)
<B> RIO<R,B>	ap(Kind<RIO<R,?>,? extends Function1<? super A,? extends B>> apply)
static <R, A> RIO<R,A>	async(Consumer2<R,Consumer1<? super Try<? extends A>>> consumer)
static <R, A extends AutoCloseable, B> RIO<R,B>	bracket(Kind<RIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> use)
static <R, A, B> RIO<R,B>	bracket(Kind<RIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> use, Consumer1<? super A> release)
static <R, A, B> RIO<R,B>	bracket(Kind<RIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> use, Function1<? super A,? extends Kind<RIO<R,?>,Unit>> release)
static <R, A> RIO<R,A>	cancellable(Function2<R,Consumer1<? super Try<? extends A>>,RIO<R,Unit>> consumer)
static <R, A> RIO<R,A>	defer(Producer<Kind<RIO<R,?>,? extends A>> lazy)
static <R> RIO<R,R>	env()
static <R> RIO<R,Unit>	exec(CheckedRunnable task)
<B> RIO<R,B>	flatMap(Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> map)
<B> URIO<R,B>	fold(Function1<? super Throwable,? extends B> mapError, Function1<? super A,? extends B> map)
<B> RIO<R,B>	foldM(Function1<? super Throwable,? extends Kind<RIO<R,?>,? extends B>> mapError, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> map)
RIO<R,Fiber<RIO<R,?>,A>>	fork()
static <R> RIO<R,Unit>	forked(Executor executor)
static <R, A> RIO<R,A>	fromEither(Producer<Either<Throwable,? extends A>> task)
static <R, A> RIO<R,A>	fromEither(Either<Throwable,? extends A> task)
static <R, A> RIO<R,A>	fromOption(Producer<Option<? extends A>> task)
static <R, A> RIO<R,A>	fromOption(Option<? extends A> task)
static <R, A> RIO<R,A>	fromTry(Producer<Try<? extends A>> task)
static <R, A> RIO<R,A>	fromTry(Try<? extends A> task)
static <R, A, B> Function1<A,RIO<R,B>>	lift(Function1<? super A,? extends B> function)
static <R, A, B> Function1<A,RIO<R,B>>	liftEither(Function1<? super A,? extends Either<Throwable,? extends B>> function)
static <R, A, B> Function1<A,RIO<R,B>>	liftOption(Function1<? super A,? extends Option<? extends B>> function)
static <R, A, B> Function1<A,RIO<R,B>>	liftTry(Function1<? super A,? extends Try<? extends B>> function)
<B> RIO<R,B>	map(Function1<? super A,? extends B> map)
static <R, A> RIO<R,A>	never()
RIO<R,A>	orElse(Kind<RIO<R,?>,? extends A> other)
static <R, A, B, C> RIO<R,C>	parMap2(Kind<RIO<R,?>,? extends A> za, Kind<RIO<R,?>,? extends B> zb, Function2<? super A,? super B,? extends C> mapper)
static <R, A, B, C> RIO<R,C>	parMap2(Executor executor, Kind<RIO<R,?>,? extends A> za, Kind<RIO<R,?>,? extends B> zb, Function2<? super A,? super B,? extends C> mapper)
static <R, A> RIO<R,A>	pure(A value)
static <R, A, B> RIO<R,Either<A,B>>	race(Kind<RIO<R,?>,? extends A> fa, Kind<RIO<R,?>,? extends B> fb)
static <R, A, B> RIO<R,Either<A,B>>	race(Executor executor, Kind<RIO<R,?>,? extends A> fa, Kind<RIO<R,?>,? extends B> fb)
static <R, A, B> RIO<R,Either<Tuple2<A,Fiber<RIO<R,?>,B>>,Tuple2<Fiber<RIO<R,?>,A>,B>>>	racePair(Executor executor, Kind<RIO<R,?>,? extends A> fa, Kind<RIO<R,?>,? extends B> fb)
static <R, A> RIO<R,A>	raiseError(Throwable throwable)
URIO<R,A>	recover(Function1<? super Throwable,? extends A> mapError)
<X extends Throwable> URIO<R,A>	recoverWith(Class<X> type, Function1<? super X,? extends A> function)
RIO<R,A>	repeat()
RIO<R,A>	repeat(int times)
RIO<R,A>	repeat(Duration delay)
RIO<R,A>	repeat(Duration delay, int times)
RIO<R,A>	retry()
RIO<R,A>	retry(int maxRetries)
RIO<R,A>	retry(Duration delay)
RIO<R,A>	retry(Duration delay, int maxRetries)
Future<A>	runAsync(R env)
Future<A>	runAsync(R env, Executor executor)
void	safeRunAsync(R env, Consumer1<? super Try<? extends A>> callback)
Try<A>	safeRunSync(R env)
static <R> RIO<R,Unit>	sleep(Duration delay)
static <R> RIO<R,Unit>	sleep(Executor executor, Duration delay)
static <R, A> RIO<R,A>	task(Producer<? extends A> task)
RIO<R,Tuple2<Duration,A>>	timed()
RIO<R,A>	timeout(Duration duration)
RIO<R,A>	timeout(Executor executor, Duration duration)
<E> EIO<E,A>	toEIO()
PureIO<R,Throwable,A>	toPureIO()
URIO<R,A>	toURIO()
static <R, A> RIO<R,Sequence<A>>	traverse(Sequence<? extends Kind<RIO<R,?>,A>> sequence)
static <R, A> RIO<R,Sequence<A>>	traverse(Executor executor, Sequence<? extends Kind<RIO<R,?>,A>> sequence)
static <R> RIO<R,Unit>	unit()
<B> RIO<R,Tuple2<A,B>>	zip(Kind<RIO<R,?>,? extends B> other)
<B> RIO<R,A>	zipLeft(Kind<RIO<R,?>,? extends B> other)
<B> RIO<R,B>	zipRight(Kind<RIO<R,?>,? extends B> other)
<B, C> RIO<R,C>	zipWith(Kind<RIO<R,?>,? extends B> other, Function2<? super A,? super B,? extends C> mapper)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

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

fix, kind

Methods inherited from interface com.github.tonivade.purefun.core.Recoverable

sneakyThrow

Field Details

UNIT

private static final RIO<?,Unit> UNIT

instance

private final PureIO<R,Throwable,A> instance

Constructor Details

RIO

RIO(PureIO<R,Throwable,A> value)

Method Details

safeRunSync

public Try<A> safeRunSync(R env)

toPureIO

public PureIO<R,Throwable,A> toPureIO()

toEIO

public <E> EIO<E,A> toEIO()

toURIO

public URIO<R,A> toURIO()

runAsync

public Future<A> runAsync(R env)

runAsync

public Future<A> runAsync(R env,
 Executor executor)

safeRunAsync

public void safeRunAsync(R env,
 Consumer1<? super Try<? extends A>> callback)

map

public <B> RIO<R,B> map(Function1<? super A,? extends B> map)

Specified by:

map in interface Applicable<R,A>

Specified by:

map in interface Bindable<R,A>

Specified by:

map in interface Effect<R,A>

Specified by:

map in interface Mappable<R,A>

flatMap

public <B> RIO<R,B> flatMap(Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> map)

Specified by:

flatMap in interface Bindable<R,A>

Specified by:

flatMap in interface Effect<R,A>

andThen

public <B> RIO<R,B> andThen(Kind<RIO<R,?>,? extends B> next)

Specified by:

andThen in interface Bindable<R,A>

Specified by:

andThen in interface Effect<R,A>

ap

public <B> RIO<R,B> ap(Kind<RIO<R,?>,? extends Function1<? super A,? extends B>> apply)

Specified by:

ap in interface Applicable<R,A>

Specified by:

ap in interface Effect<R,A>

recover

public URIO<R,A> recover(Function1<? super Throwable,? extends A> mapError)

recoverWith

public <X extends Throwable> URIO<R,A> recoverWith(Class<X> type,
 Function1<? super X,? extends A> function)

fold

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

foldM

public <B> RIO<R,B> foldM(Function1<? super Throwable,? extends Kind<RIO<R,?>,? extends B>> mapError,
 Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> map)

orElse

public RIO<R,A> orElse(Kind<RIO<R,?>,? extends A> other)

zip

public <B> RIO<R,Tuple2<A,B>> zip(Kind<RIO<R,?>,? extends B> other)

Specified by:

zip in interface Applicable<R,A>

Specified by:

zip in interface Effect<R,A>

zipLeft

public <B> RIO<R,A> zipLeft(Kind<RIO<R,?>,? extends B> other)

Specified by:

zipLeft in interface Applicable<R,A>

Specified by:

zipLeft in interface Effect<R,A>

zipRight

public <B> RIO<R,B> zipRight(Kind<RIO<R,?>,? extends B> other)

Specified by:

zipRight in interface Applicable<R,A>

Specified by:

zipRight in interface Effect<R,A>

zipWith

public <B,
C> RIO<R,C> zipWith(Kind<RIO<R,?>,? extends B> other,
 Function2<? super A,? super B,? extends C> mapper)

Specified by:

zipWith in interface Applicable<R,A>

Specified by:

zipWith in interface Effect<R,A>

fork

public RIO<R,Fiber<RIO<R,?>,A>> fork()

timeout

public RIO<R,A> timeout(Duration duration)

Specified by:

timeout in interface Effect<R,A>

timeout

public RIO<R,A> timeout(Executor executor,
 Duration duration)

repeat

public RIO<R,A> repeat()

Specified by:

repeat in interface Effect<R,A>

repeat

public RIO<R,A> repeat(int times)

Specified by:

repeat in interface Effect<R,A>

repeat

public RIO<R,A> repeat(Duration delay)

Specified by:

repeat in interface Effect<R,A>

repeat

public RIO<R,A> repeat(Duration delay,
 int times)

Specified by:

repeat in interface Effect<R,A>

retry

public RIO<R,A> retry()

Specified by:

retry in interface Effect<R,A>

retry

public RIO<R,A> retry(int maxRetries)

Specified by:

retry in interface Effect<R,A>

retry

public RIO<R,A> retry(Duration delay)

Specified by:

retry in interface Effect<R,A>

retry

public RIO<R,A> retry(Duration delay,
 int maxRetries)

Specified by:

retry in interface Effect<R,A>

timed

public RIO<R,Tuple2<Duration,A>> timed()

Specified by:

timed in interface Effect<R,A>

forked

public static <R> RIO<R,Unit> forked(Executor executor)

accessM

public static <R,
A> RIO<R,A> accessM(Function1<? super R,? extends Kind<RIO<R,?>,? extends A>> map)

access

public static <R,
A> RIO<R,A> access(Function1<? super R,? extends A> map)

env

public static <R> RIO<R,R> env()

absorb

public static <R,
A> RIO<R,A> absorb(RIO<R,Either<Throwable,A>> value)

parMap2

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

parMap2

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

race

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

race

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

racePair

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

sleep

public static <R> RIO<R,Unit> sleep(Duration delay)

sleep

public static <R> RIO<R,Unit> sleep(Executor executor,
 Duration delay)

lift

public static <R,
A,
B> Function1<A,RIO<R,B>> lift(Function1<? super A,? extends B> function)

liftOption

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

liftTry

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

liftEither

public static <R,
A,
B> Function1<A,RIO<R,B>> liftEither(Function1<? super A,? extends Either<Throwable,? extends B>> function)

fromOption

public static <R,
A> RIO<R,A> fromOption(Option<? extends A> task)

fromOption

public static <R,
A> RIO<R,A> fromOption(Producer<Option<? extends A>> task)

fromTry

public static <R,
A> RIO<R,A> fromTry(Try<? extends A> task)

fromTry

public static <R,
A> RIO<R,A> fromTry(Producer<Try<? extends A>> task)

fromEither

public static <R,
A> RIO<R,A> fromEither(Either<Throwable,? extends A> task)

fromEither

public static <R,
A> RIO<R,A> fromEither(Producer<Either<Throwable,? extends A>> task)

exec

public static <R> RIO<R,Unit> exec(CheckedRunnable task)

pure

public static <R,
A> RIO<R,A> pure(A value)

raiseError

public static <R,
A> RIO<R,A> raiseError(Throwable throwable)

defer

public static <R,
A> RIO<R,A> defer(Producer<Kind<RIO<R,?>,? extends A>> lazy)

task

public static <R,
A> RIO<R,A> task(Producer<? extends A> task)

never

public static <R,
A> RIO<R,A> never()

async

public static <R,
A> RIO<R,A> async(Consumer2<R,Consumer1<? super Try<? extends A>>> consumer)

cancellable

public static <R,
A> RIO<R,A> cancellable(Function2<R,Consumer1<? super Try<? extends A>>,RIO<R,Unit>> consumer)

traverse

public static <R,
A> RIO<R,Sequence<A>> traverse(Sequence<? extends Kind<RIO<R,?>,A>> sequence)

traverse

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

bracket

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

bracket

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

bracket

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

unit

public static <R> RIO<R,Unit> unit()