Uses of Interface
com.github.tonivade.purefun.effect.PureIO

Packages that use PureIO

Package	Description
com.github.tonivade.purefun.effect
com.github.tonivade.purefun.instances
com.github.tonivade.purefun.runtimes

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

Classes in com.github.tonivade.purefun.effect that implement PureIO

Modifier and Type	Class	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>

Fields in com.github.tonivade.purefun.effect declared as PureIO

Modifier and Type	Field	Description
private PureIO<?,?,Unit>	PureIOConnection.Cancellable.cancelToken
private final PureIO<R,Void,A>	PureIO.Recover.current
private final PureIO<Void,E,A>	EIO.instance
private final PureIO<R,Throwable,A>	RIO.instance
private final PureIO<Void,Throwable,A>	Task.instance
private final PureIO<Void,Void,A>	UIO.instance
private final PureIO<R,Void,A>	URIO.instance
private final PureIO<R,E,Tuple2<A,Consumer1<? super A>>>	Managed.resource
static final PureIO<?,?,Unit>	PureIO.UNIT

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

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 Kind<PureIO<R,E,?>,A>	PureIO.FlatMapped.current
private final Function1<? super R,? extends Kind<PureIO<R,E,?>,? extends A>>	PureIO.AccessM.function
private final Producer<Kind<PureIO<R,E,?>,? extends A>>	PureIO.Suspend.lazy
private final PartialFunction1<? super Throwable,? extends PureIO<R,E,? extends A>>	PureIO.Recover.mapper
private final Function1<? super A,? extends Kind<PureIO<R,F,?>,? extends B>>	PureIO.FlatMapped.next
private final Function1<? super E,? extends Kind<PureIO<R,F,?>,? extends B>>	PureIO.FlatMapped.nextError
private final Deque<PartialFunction1<? super Throwable,? extends Kind<PureIO<R,E,?>,? extends A>>>	StackItem.recover

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

Modifier and Type	Method	Description
static <R, E, A> PureIO<R,E,A>	PureIO.absorb(Kind<PureIO<R,E,?>,Either<E,A>> value)
static <R, E, A> PureIO<R,E,A>	PureIO.access(Function1<? super R,? extends A> map)
static <R, E, A> PureIO<R,E,A>	PureIO.accessM(Function1<? super R,? extends Kind<PureIO<R,E,?>,? extends A>> map)
default <B> PureIO<R,E,B>	PureIO.andThen(Kind<PureIO<R,E,?>,? extends B> next)
default <B> PureIO<R,E,B>	PureIO.ap(Kind<PureIO<R,E,?>,? extends Function1<? super A,? extends B>> apply)
static <R, E, A> PureIO<R,E,A>	PureIO.async(Consumer2<R,Consumer1<? super Try<? extends Either<E,? extends A>>>> consumer)
default <B, F> PureIO<R,F,B>	PureIO.bimap(Function1<? super E,? extends F> mapError, Function1<? super A,? extends B> map)
static <R, E, A extends AutoCloseable, B> PureIO<R,E,B>	PureIO.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>	PureIO.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>	PureIO.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>	PureIO.cancellable(Function2<R,Consumer1<? super Try<? extends Either<E,? extends A>>>,PureIO<R,?,Unit>> consumer)
static <R, E, A> PureIO<R,E,A>	PureIO.defer(Producer<Kind<PureIO<R,E,?>,? extends A>> lazy)
static <R, E> PureIO<R,E,R>	PureIO.env()
static <R> PureIO<R,Throwable,Unit>	PureIO.exec(CheckedRunnable task)
default <B> PureIO<R,E,B>	PureIO.flatMap(Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> map)
default <F> PureIO<R,F,A>	PureIO.flatMapError(Function1<? super E,? extends Kind<PureIO<R,F,?>,? extends A>> map)
default <F, B> PureIO<R,F,B>	PureIO.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>>	PureIO.fork()
static <R, E> PureIO<R,E,Unit>	PureIO.forked(Executor executor)
static <R, E, A> PureIO<R,E,A>	PureIO.fromEither(Producer<Either<E,? extends A>> task)
static <R, E, A> PureIO<R,E,A>	PureIO.fromEither(Either<E,? extends A> task)
static <R, A> PureIO<R,Throwable,A>	PureIO.fromOption(Producer<Option<? extends A>> task)
static <R, A> PureIO<R,Throwable,A>	PureIO.fromOption(Option<? extends A> task)
static <R, E, A> PureIO<R,E,A>	PureIO.fromPromise(Promise<? extends Either<E,? extends A>> promise)
static <R, A> PureIO<R,Throwable,A>	PureIO.fromTry(Producer<Try<? extends A>> task)
static <R, A> PureIO<R,Throwable,A>	PureIO.fromTry(Try<? extends A> task)
static <R, E, A> PureIO<R,E,A>	PureIO.later(Producer<? extends A> task)
default <B> PureIO<R,E,B>	PureIO.map(Function1<? super A,? extends B> map)
default <B> PureIO<R,B,A>	PureIO.mapError(Function1<? super E,? extends B> map)
static <R, E, A> PureIO<R,E,A>	PureIO.never()
default PureIO<R,E,A>	PureIO.orElse(Kind<PureIO<R,E,?>,? extends A> other)
static <R, E, A, B, C> PureIO<R,E,C>	PureIO.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>	PureIO.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)
static <R, E, A> PureIO<R,E,A>	PureIO.pure(A value)
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, 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, E, A> PureIO<R,E,A>	PureIO.raiseError(E error)
static <R, A> PureIO<R,Throwable,A>	PureIO.redeem(Kind<PureIO<R,Void,?>,? extends A> value)
default <X extends Throwable> PureIO<R,X,A>	PureIO.refineOrDie(Class<X> type)
default PureIO<R,E,A>	PureIO.repeat()
default PureIO<R,E,A>	PureIO.repeat(int times)
private static <R, E, A> PureIO<R,E,A>	PureIO.repeat(PureIO<R,E,A> self, PureIO<R,E,Unit> pause, int times)
default PureIO<R,E,A>	PureIO.repeat(Duration delay)
default PureIO<R,E,A>	PureIO.repeat(Duration delay, int times)
default PureIO<R,E,A>	PureIO.retry()
default PureIO<R,E,A>	PureIO.retry(int maxRetries)
private static <R, E, A> PureIO<R,E,A>	PureIO.retry(PureIO<R,E,A> self, PureIO<R,E,Unit> pause, int maxRetries)
default PureIO<R,E,A>	PureIO.retry(Duration delay)
default PureIO<R,E,A>	PureIO.retry(Duration delay, int maxRetries)
static <R, E> PureIO<R,E,Unit>	PureIO.run(Runnable task)
static <R, E> PureIO<R,E,Unit>	PureIO.sleep(Duration delay)
static <R, E> PureIO<R,E,Unit>	PureIO.sleep(Executor executor, Duration delay)
default PureIO<R,A,E>	PureIO.swap()
static <R, A> PureIO<R,Throwable,A>	PureIO.task(Producer<? extends A> task)
static <R, E, A> PureIO<R,E,A>	PureIO.throwError(Throwable error)
default PureIO<R,E,Tuple2<Duration,A>>	PureIO.timed()
default PureIO<R,E,A>	PureIO.timeout(Duration duration)
default PureIO<R,E,A>	PureIO.timeout(Executor executor, Duration duration)
<R> PureIO<R,E,A>	EIO.toPureIO()
static <R, E, A> PureIO<R,E,A>	PureIOOf.toPureIO(Kind<PureIO<R,E,?>,? extends A> value)
PureIO<R,Throwable,A>	RIO.toPureIO()
<R> PureIO<R,Throwable,A>	Task.toPureIO()
<R, E> PureIO<R,E,A>	UIO.toPureIO()
<E> PureIO<R,E,A>	URIO.toPureIO()
static <R, E, A> PureIO<R,E,Sequence<A>>	PureIO.traverse(Sequence<? extends Kind<PureIO<R,E,?>,A>> sequence)
static <R, E, A> PureIO<R,E,Sequence<A>>	PureIO.traverse(Executor executor, Sequence<? extends Kind<PureIO<R,E,?>,A>> sequence)
static <R, E> PureIO<R,E,Unit>	PureIO.unit()
<B> PureIO<R,E,B>	Managed.use(Function1<? super A,? extends PureIO<R,E,? extends B>> use)
default <B> PureIO<R,E,Tuple2<A,B>>	PureIO.zip(Kind<PureIO<R,E,?>,? extends B> other)
default <B> PureIO<R,E,A>	PureIO.zipLeft(Kind<PureIO<R,E,?>,? extends B> other)
default <B> PureIO<R,E,B>	PureIO.zipRight(Kind<PureIO<R,E,?>,? extends B> other)
default <B, C> PureIO<R,E,C>	PureIO.zipWith(Kind<PureIO<R,E,?>,? extends B> other, Function2<? super A,? super B,? extends C> mapper)

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

Modifier and Type	Method	Description
static <R, E, A> Kind<PureIO<R,E,?>,A>	PureIO.accessM(R env, PureIO.AccessM<R,E,A> accessM)
default PureIO<R,E,Fiber<PureIO<R,E,?>,A>>	PureIO.fork()
static <R, A, B> Function1<A,PureIO<R,Throwable,B>>	PureIO.lift(Function1<? super A,? 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,PureIO<R,Throwable,B>>	PureIO.liftOption(Function1<? super A,? extends Option<? extends B>> function)
static <R, A, B> Function1<A,PureIO<R,Throwable,B>>	PureIO.liftTry(Function1<? super A,? extends Try<? extends B>> function)
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, 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)
Option<PureIO<R,E,A>>	CallStack.tryHandle(Throwable error)
Option<PureIO<R,E,A>>	StackItem.tryHandle(Throwable error)
private static <R, E, F, A, B> Kind<PureIO<R,E,?>,A>	PureIO.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)

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

Modifier and Type	Method	Description
private static <A> UIO<A>	UIO.fold(PureIO<Void,Throwable,A> zio)
private static <R, A> URIO<R,A>	URIO.fold(PureIO<R,Throwable,A> zio)
static <R, E, A extends AutoCloseable> Managed<R,E,A>	Managed.from(PureIO<R,E,? extends A> resource)
static <R, E, A> Managed<R,E,A>	Managed.from(PureIO<R,E,? extends A> resource, Consumer1<? super A> release)
static <R, E, A> Managed<R,E,A>	Managed.pure(PureIO<R,E,? extends A> resource)
private static <R, E, A> PureIO<R,E,A>	PureIO.repeat(PureIO<R,E,A> self, PureIO<R,E,Unit> pause, int times)
private static <R, E, A> PureIO<R,E,A>	PureIO.retry(PureIO<R,E,A> self, PureIO<R,E,Unit> pause, int maxRetries)
void	PureIOConnection.Cancellable.setCancelToken(PureIO<?,?,Unit> cancel)
void	PureIOConnection.setCancelToken(PureIO<?,?,Unit> cancel)
void	PureIOConnection.Uncancellable.setCancelToken(PureIO<?,?,Unit> cancel)

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

Modifier and Type	Method	Description
static <R, E, A> PureIO<R,E,A>	PureIO.absorb(Kind<PureIO<R,E,?>,Either<E,A>> value)
static <R, E, A> PureIO<R,E,A>	PureIO.accessM(Function1<? super R,? extends Kind<PureIO<R,E,?>,? extends A>> map)
void	CallStack.add(PartialFunction1<? super Throwable,? extends Kind<PureIO<R,E,?>,? extends A>> mapError)
void	StackItem.add(PartialFunction1<? super Throwable,? extends Kind<PureIO<R,E,?>,? extends A>> mapError)
default <B> PureIO<R,E,B>	PureIO.andThen(Kind<PureIO<R,E,?>,? extends B> next)
default <B> PureIO<R,E,B>	PureIO.ap(Kind<PureIO<R,E,?>,? extends Function1<? super A,? extends B>> apply)
static <R, E, A extends AutoCloseable, B> PureIO<R,E,B>	PureIO.bracket(Kind<PureIO<R,E,?>,? extends A> acquire, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> use)
static <R, E, A extends AutoCloseable, B> PureIO<R,E,B>	PureIO.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>	PureIO.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>	PureIO.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>	PureIO.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, B> PureIO<R,E,B>	PureIO.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>	PureIO.cancellable(Function2<R,Consumer1<? super Try<? extends Either<E,? extends A>>>,PureIO<R,?,Unit>> consumer)
static <R, E, A> PureIO<R,E,A>	PureIO.defer(Producer<Kind<PureIO<R,E,?>,? extends A>> lazy)
default <B> PureIO<R,E,B>	PureIO.flatMap(Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> map)
default <F> PureIO<R,F,A>	PureIO.flatMapError(Function1<? super E,? extends Kind<PureIO<R,F,?>,? extends A>> map)
default <F, B> PureIO<R,F,B>	PureIO.foldM(Function1<? super E,? extends Kind<PureIO<R,F,?>,? extends B>> left, Function1<? super A,? extends Kind<PureIO<R,F,?>,? extends B>> right)
static <R, E, A extends AutoCloseable> Managed<R,E,A>	Managed.fromM(Function1<? super R,? extends PureIO<R,E,? extends A>> mapper)
static <R, E, A> Managed<R,E,A>	Managed.fromM(Function1<? super R,? extends PureIO<R,E,? extends A>> mapper, Consumer1<? super A> release)
default PureIO<R,E,A>	PureIO.orElse(Kind<PureIO<R,E,?>,? extends A> other)
static <R, E, A, B, C> PureIO<R,E,C>	PureIO.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>	PureIO.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)
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, 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> PureIO<R,Throwable,A>	PureIO.redeem(Kind<PureIO<R,Void,?>,? extends A> value)
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)
static <R, E, A> PureIO<R,E,A>	PureIOOf.toPureIO(Kind<PureIO<R,E,?>,? extends A> value)
static <R, E, A> PureIO<R,E,Sequence<A>>	PureIO.traverse(Sequence<? extends Kind<PureIO<R,E,?>,A>> sequence)
static <R, E, A> PureIO<R,E,Sequence<A>>	PureIO.traverse(Executor executor, Sequence<? extends Kind<PureIO<R,E,?>,A>> sequence)
private static <R, E, F, A, B> Kind<PureIO<R,E,?>,A>	PureIO.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)
private static <R, E, F, A, B> Kind<PureIO<R,E,?>,A>	PureIO.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)
private static <R, E, F, A, B> Kind<PureIO<R,E,?>,A>	PureIO.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)
<B> PureIO<R,E,B>	Managed.use(Function1<? super A,? extends PureIO<R,E,? extends B>> use)
default <B> PureIO<R,E,Tuple2<A,B>>	PureIO.zip(Kind<PureIO<R,E,?>,? extends B> other)
default <B> PureIO<R,E,A>	PureIO.zipLeft(Kind<PureIO<R,E,?>,? extends B> other)
default <B> PureIO<R,E,B>	PureIO.zipRight(Kind<PureIO<R,E,?>,? extends B> other)
default <B, C> PureIO<R,E,C>	PureIO.zipWith(Kind<PureIO<R,E,?>,? extends B> other, Function2<? super A,? super B,? extends C> mapper)

Constructors in com.github.tonivade.purefun.effect with parameters of type PureIO

Modifier	Constructor	Description
(package private)	EIO(PureIO<Void,E,A> value)
private	FlatMapped(PureIO<R,E,A> current, Function1<? super E,? extends Kind<PureIO<R,F,?>,? extends B>> nextError, Function1<? super A,? extends Kind<PureIO<R,F,?>,? extends B>> next)
private	Managed(PureIO<R,E,Tuple2<A,Consumer1<? super A>>> resource)
private	Recover(PureIO<R,Void,A> current, PartialFunction1<? super Throwable,? extends PureIO<R,E,? extends A>> mapper)
(package private)	RIO(PureIO<R,Throwable,A> value)
(package private)	Task(PureIO<Void,Throwable,A> value)
(package private)	UIO(PureIO<Void,Void,A> value)
(package private)	URIO(PureIO<R,Void,A> value)

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

Modifier	Constructor	Description
private	AccessM(Function1<? super R,? extends Kind<PureIO<R,E,?>,? extends A>> function)
private	Async(Function2<R,Consumer1<? super Try<? extends Either<E,? extends A>>>,PureIO<R,?,Unit>> callback)
private	FlatMapped(PureIO<R,E,A> current, Function1<? super E,? extends Kind<PureIO<R,F,?>,? extends B>> nextError, Function1<? super A,? extends Kind<PureIO<R,F,?>,? extends B>> next)
private	Recover(PureIO<R,Void,A> current, PartialFunction1<? super Throwable,? extends PureIO<R,E,? extends A>> mapper)
private	Suspend(Producer<Kind<PureIO<R,E,?>,? extends A>> lazy)

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

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

Modifier and Type	Method	Description
default <A, B> PureIO<R,E,B>	PureIOApplicative.ap(Kind<PureIO<R,E,?>,? extends A> value, Kind<PureIO<R,E,?>,? extends Function1<? super A,? extends B>> apply)
default <A> PureIO<R,Throwable,A>	PureIOAsync.asyncF(Function1<Consumer1<? super Try<? extends A>>,Kind<PureIO<R,Throwable,?>,Unit>> consumer)
default <A, B> PureIO<R,E,B>	PureIOBracket.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)
default <A> PureIO<R,E,A>	PureIODefer.defer(Producer<? extends Kind<PureIO<R,E,?>,? extends A>> defer)
default <A, B> PureIO<R,E,B>	PureIOMonad.flatMap(Kind<PureIO<R,E,?>,? extends A> value, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> map)
default <A> PureIO<R,Throwable,Fiber<PureIO<R,Throwable,?>,A>>	PureIOConcurrent.fork(Kind<PureIO<R,Throwable,?>,? extends A> value)
default <A> PureIO<R,E,A>	PureIOMonadError.handleErrorWith(Kind<PureIO<R,E,?>,A> value, Function1<? super E,? extends Kind<PureIO<R,E,?>,? extends A>> handler)
default <A, B> PureIO<R,E,B>	PureIOFunctor.map(Kind<PureIO<R,E,?>,? extends A> value, Function1<? super A,? extends B> map)
PureIO<R,Throwable,Unit>	PureIOConsole.println(String text)
default <A> PureIO<R,E,A>	PureIOPure.pure(A value)
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> PureIO<R,E,A>	PureIOMonadError.raiseError(E error)
PureIO<R,Throwable,String>	PureIOConsole.readln()
default PureIO<R,Throwable,Unit>	PureIOMonadDefer.sleep(Duration duration)

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

Modifier and Type	Method	Description
static <R, E> Applicative<PureIO<R,E,?>>	PureIOInstances.applicative()
static <R> Async<PureIO<R,Throwable,?>>	PureIOInstances.async()
static <R> Concurrent<PureIO<R,Throwable,?>>	PureIOInstances.concurrent()
static <R> Concurrent<PureIO<R,Throwable,?>>	PureIOInstances.concurrent(Executor executor)
static <R> Console<PureIO<R,Throwable,?>>	PureIOInstances.console()
default <A> PureIO<R,Throwable,Fiber<PureIO<R,Throwable,?>,A>>	PureIOConcurrent.fork(Kind<PureIO<R,Throwable,?>,? extends A> value)
static <R, E> Functor<PureIO<R,E,?>>	PureIOInstances.functor()
static <R, E> Monad<PureIO<R,E,?>>	PureIOInstances.monad()
static <R> MonadDefer<PureIO<R,Throwable,?>>	PureIOInstances.monadDefer()
static <R, E> MonadError<PureIO<R,E,?>,E>	PureIOInstances.monadError()
static <R> MonadThrow<PureIO<R,Throwable,?>>	PureIOInstances.monadThrow()
static <R> PureStream.Of<PureIO<R,Throwable,?>>	PureStreamInstances.ofPureIO()
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> 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)
static <R, E> Runtime<PureIO<R,E,?>>	PureIOInstances.runtime(R env)

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

Modifier and Type	Method	Description
default <A, B> PureIO<R,E,B>	PureIOApplicative.ap(Kind<PureIO<R,E,?>,? extends A> value, Kind<PureIO<R,E,?>,? extends Function1<? super A,? extends B>> apply)
default <A> PureIO<R,Throwable,A>	PureIOAsync.asyncF(Function1<Consumer1<? super Try<? extends A>>,Kind<PureIO<R,Throwable,?>,Unit>> consumer)
default <A, B> PureIO<R,E,B>	PureIOBracket.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)
default <A, B> PureIO<R,E,B>	PureIOBracket.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)
default <A> PureIO<R,E,A>	PureIODefer.defer(Producer<? extends Kind<PureIO<R,E,?>,? extends A>> defer)
default <A, B> PureIO<R,E,B>	PureIOMonad.flatMap(Kind<PureIO<R,E,?>,? extends A> value, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> map)
default <A, B> PureIO<R,E,B>	PureIOMonad.flatMap(Kind<PureIO<R,E,?>,? extends A> value, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> map)
default <A> PureIO<R,Throwable,Fiber<PureIO<R,Throwable,?>,A>>	PureIOConcurrent.fork(Kind<PureIO<R,Throwable,?>,? extends A> value)
default <A> PureIO<R,E,A>	PureIOMonadError.handleErrorWith(Kind<PureIO<R,E,?>,A> value, Function1<? super E,? extends Kind<PureIO<R,E,?>,? extends A>> handler)
default <A> PureIO<R,E,A>	PureIOMonadError.handleErrorWith(Kind<PureIO<R,E,?>,A> value, Function1<? super E,? extends Kind<PureIO<R,E,?>,? extends A>> handler)
default <A, B> PureIO<R,E,B>	PureIOFunctor.map(Kind<PureIO<R,E,?>,? extends A> value, Function1<? super A,? extends B> map)
default <T> Future<Sequence<T>>	PureIORuntime.parRun(Sequence<Kind<PureIO<R,E,?>,T>> values, Executor executor)
default <T> Future<T>	PureIORuntime.parRun(Kind<PureIO<R,E,?>,T> value, Executor executor)
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 <T> Sequence<T>	PureIORuntime.run(Sequence<Kind<PureIO<R,E,?>,T>> values)
default <T> T	PureIORuntime.run(Kind<PureIO<R,E,?>,T> value)

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

Methods in com.github.tonivade.purefun.runtimes with parameters of type PureIO

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