Package com.github.tonivade.purefun.effect

Class Task<A>

java.lang.Object

com.github.tonivade.purefun.effect.Task<A>

All Implemented Interfaces:

Applicable<Task<?>,A>, Bindable<Task<?>,A>, Effect<Task<?>,A>, Mappable<Task<?>,A>, Recoverable, TaskOf<A>, Kind<Task<?>,A>

public final class Task<A>
extends Object
implements TaskOf<A>, Effect<Task<?>,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<Void,Throwable,A>	instance
private static final Task<Unit>	UNIT

Constructor Summary

Constructors

Constructor	Description
Task(PureIO<Void,Throwable,A> value)

Method Summary

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

instance

private final PureIO<Void,Throwable,A> instance

Constructor Details

Task

Task(PureIO<Void,Throwable,A> value)

Method Details

toPureIO

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

toEIO

public EIO<Throwable,A> toEIO()

toURIO

public <R> RIO<R,A> toURIO()

toUIO

public UIO<A> toUIO()

safeRunSync

public Try<A> safeRunSync()

runAsync

public Future<A> runAsync()

runAsync

public Future<A> runAsync(Executor executor)

safeRunAsync

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

map

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

Specified by:

map in interface Applicable<Task<?>,A>

Specified by:

map in interface Bindable<Task<?>,A>

Specified by:

map in interface Effect<Task<?>,A>

Specified by:

map in interface Mappable<Task<?>,A>

flatMap

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

Specified by:

flatMap in interface Bindable<Task<?>,A>

Specified by:

flatMap in interface Effect<Task<?>,A>

andThen

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

Specified by:

andThen in interface Bindable<Task<?>,A>

Specified by:

andThen in interface Effect<Task<?>,A>

ap

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

Specified by:

ap in interface Applicable<Task<?>,A>

Specified by:

ap in interface Effect<Task<?>,A>

foldM

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

fold

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

recoverWith

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

recover

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

orElse

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

zip

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

Specified by:

zip in interface Applicable<Task<?>,A>

Specified by:

zip in interface Effect<Task<?>,A>

zipLeft

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

Specified by:

zipLeft in interface Applicable<Task<?>,A>

Specified by:

zipLeft in interface Effect<Task<?>,A>

zipRight

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

Specified by:

zipRight in interface Applicable<Task<?>,A>

Specified by:

zipRight in interface Effect<Task<?>,A>

zipWith

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

Specified by:

zipWith in interface Applicable<Task<?>,A>

Specified by:

zipWith in interface Effect<Task<?>,A>

fork

public Task<Fiber<Task<?>,A>> fork()

timeout

public Task<A> timeout(Duration duration)

Specified by:

timeout in interface Effect<Task<?>,A>

timeout

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

repeat

public Task<A> repeat()

Specified by:

repeat in interface Effect<Task<?>,A>

repeat

public Task<A> repeat(int times)

Specified by:

repeat in interface Effect<Task<?>,A>

repeat

public Task<A> repeat(Duration delay)

Specified by:

repeat in interface Effect<Task<?>,A>

repeat

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

Specified by:

repeat in interface Effect<Task<?>,A>

retry

public Task<A> retry()

Specified by:

retry in interface Effect<Task<?>,A>

retry

public Task<A> retry(int maxRetries)

Specified by:

retry in interface Effect<Task<?>,A>

retry

public Task<A> retry(Duration delay)

Specified by:

retry in interface Effect<Task<?>,A>

retry

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

Specified by:

retry in interface Effect<Task<?>,A>

timed

public Task<Tuple2<Duration,A>> timed()

Specified by:

timed in interface Effect<Task<?>,A>

forked

public static Task<Unit> forked(Executor executor)

parMap2

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

parMap2

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

race

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

race

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

racePair

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

absorb

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

lift

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

liftOption

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

liftTry

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

liftEither

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

fromOption

public static <A> Task<A> fromOption(Option<? extends A> task)

fromOption

public static <A> Task<A> fromOption(Producer<Option<? extends A>> task)

fromTry

public static <A> Task<A> fromTry(Try<? extends A> task)

fromTry

public static <A> Task<A> fromTry(Producer<Try<? extends A>> task)

fromEither

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

fromEither

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

sleep

public static Task<Unit> sleep(Duration delay)

sleep

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

exec

public static Task<Unit> exec(CheckedRunnable task)

pure

public static <A> Task<A> pure(A value)

defer

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

task

public static <A> Task<A> task(Producer<? extends A> task)

never

public static <A> Task<A> never()

async

public static <A> Task<A> async(Consumer1<Consumer1<? super Try<? extends A>>> consumer)

asyncF

public static <A> Task<A> asyncF(Function1<Consumer1<? super Try<? extends A>>,Task<Unit>> consumer)

raiseError

public static <A> Task<A> raiseError(Throwable error)

traverse

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

traverse

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

bracket

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

bracket

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

bracket

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

unit

public static Task<Unit> unit()