Package com.github.tonivade.purefun.concurrent

Interface Future<T>

Type Parameters:

T - result of the computation

All Superinterfaces:

Bindable<Future<?>,T>, FutureOf<T>, Kind<Future<?>,T>, Mappable<Future<?>,T>

All Known Implementing Classes:

FutureImpl

public sealed interface Future<T>
extends FutureOf<T>, Bindable<Future<?>,T>
permits FutureImpl<T>

This type is an abstraction of a computation executed in another thread. To run the computation an Executor should be provided. If no Executor is provided, then a default instance is used.

The result of the computation is a Try<T>, this means that the computation can end successfully or with an error.

You can create instances of Future in this way:

• Future.success(value): returns a future that returns successfully with the given value.
• Future.failure(error): returns a future that returns an error with the given error.
• Future.task(computation): returns a future that eventually will execute the given computation.
• Future.async(consumer): returns a future that eventually will consume the result of a computation.
• Future.exec(runnable): returns a future that eventually will execute the given runnable.
• Future.delay(duration, computation): returns a future that eventually will execute the given computation, but after waiting the given duration.
• Future.defer(computation): returns a future that eventually will execute the given computation that returns another Future.
• Future.later(computation): returns a future that eventually will execute the given computation that returns another value.
• Future.bracket(acquire, usage, release): returns a future that eventually will acquire a resource, then use it, and finally release it.

A future can be cancellable by calling the method cancel. If the future has not been executed yet, the future will be cancelled and the result of the computation will be a Try.failure(CancellableException), but if the future has been executed, and is completed the calling of cancel method will not have any consequences. If the computation is running when the cancel method is called, and if the flag mayInterruptThread is true, then it will try to interrupt the thread running the computation and the result of the computation will be also a Try.failure(CancellableException).

If during the execution of the computation in a thread, this thread is interrupted for any reason, the result of the computation will be a Try.failure(InterruptedException).

See Also:

• Try
• Promise

Field Summary

Fields

Modifier and Type	Field	Description
static final Executor	DEFAULT_EXECUTOR

Method Summary

Modifier and Type	Method	Description
<R> Future<R>	andThen(Future<? extends R> next)
<R> Future<R>	ap(Future<Function1<? super T,? extends R>> apply)
static <T> Future<T>	async(Consumer1<Consumer1<? super Try<? extends T>>> consumer)
static <T> Future<T>	async(Executor executor, Consumer1<Consumer1<? super Try<? extends T>>> consumer)
Try<T>	await()
Try<T>	await(Duration timeout)
static <T extends AutoCloseable, R> Future<R>	bracket(Future<? extends T> acquire, Function1<? super T,? extends Future<? extends R>> use)
static <T, R> Future<R>	bracket(Future<? extends T> acquire, Function1<? super T,? extends Future<? extends R>> use, Consumer1<? super T> release)
static <T extends AutoCloseable, R> Future<R>	bracket(Executor executor, Future<? extends T> acquire, Function1<? super T,? extends Future<? extends R>> use)
static <T, R> Future<R>	bracket(Executor executor, Future<? extends T> acquire, Function1<? super T,? extends Future<? extends R>> use, Consumer1<? super T> release)
void	cancel(boolean mayInterruptThread)
static <T> Future<T>	delay(Duration timeout, Producer<? extends T> producer)
static <T> Future<T>	delay(Executor executor, Duration timeout, Producer<? extends T> producer)
static Future<Unit>	exec(CheckedRunnable task)
static Future<Unit>	exec(Executor executor, CheckedRunnable task)
static <T> Future<T>	failure(Throwable error)
static <T> Future<T>	failure(Executor executor, Throwable error)
Future<T>	filter(Matcher1<? super T> matcher)
default Future<T>	filterNot(Matcher1<? super T> matcher)
<R> Future<R>	flatMap(Function1<? super T,? extends Kind<Future<?>,? extends R>> mapper)
<U> Future<U>	fold(Function1<? super Throwable,? extends U> failureMapper, Function1<? super T,? extends U> successMapper)
static <T> Future<T>	from(Promise<? extends T> promise)
static <T> Future<T>	from(Callable<? extends T> callable)
static <T> Future<T>	from(CompletableFuture<? extends T> future)
static <T> Future<T>	from(Executor executor, Promise<? extends T> promise)
static <T> Future<T>	from(Executor executor, Callable<? extends T> callable)
static <T> Future<T>	from(Executor executor, CompletableFuture<? extends T> future)
static <T> Future<T>	from(Executor executor, Future<? extends T> future)
static <T> Future<T>	from(Future<? extends T> future)
default T	get()
default Throwable	getCause()
default T	getOrElse(Producer<? extends T> value)
default T	getOrElse(T value)
default T	getOrElseThrow()
default <X extends Throwable> T	getOrElseThrow(Producer<? extends X> producer)
boolean	isCancelled()
boolean	isCompleted()
static <T> Future<T>	later(Producer<? extends T> producer)
static <T> Future<T>	later(Executor executor, Producer<? extends T> producer)
<R> Future<R>	map(Function1<? super T,? extends R> mapper)
static <T, V, R> Future<R>	map2(Future<? extends T> fa, Future<? extends V> fb, Function2<? super T,? super V,? extends R> mapper)
Future<T>	mapError(Function1<? super Throwable,? extends Throwable> mapper)
Future<T>	onComplete(Consumer1<? super Try<? extends T>> callback)
Future<T>	onFailure(Consumer1<? super Throwable> callback)
Future<T>	onSuccess(Consumer1<? super T> callback)
Future<T>	orElse(Future<? extends T> other)
default Future<T>	recover(Function1<? super Throwable,? extends T> mapper)
<X extends Throwable> Future<T>	recoverWith(Class<X> type, Function1<? super X,? extends T> mapper)
static Future<Unit>	sleep(Duration delay)
static Future<Unit>	sleep(Executor executor, Duration delay)
static <T> Future<T>	success(Executor executor, T value)
static <T> Future<T>	success(T value)
static <T> Future<T>	task(Producer<? extends T> task)
static <T> Future<T>	task(Executor executor, Producer<? extends T> task)
default CompletableFuture<T>	toCompletableFuture()
Promise<T>	toPromise()
static <A> Future<Sequence<A>>	traverse(Sequence<Future<A>> sequence)
static <T, V> Future<Tuple2<T,V>>	tuple(Future<T> fa, Future<V> fb)

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

andThen

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

fix, kind

Field Details

DEFAULT_EXECUTOR

static final Executor DEFAULT_EXECUTOR

Method Details

await

Try<T> await()

await

Try<T> await(Duration timeout)

cancel

void cancel(boolean mayInterruptThread)

isCompleted

boolean isCompleted()

isCancelled

boolean isCancelled()

onSuccess

Future<T> onSuccess(Consumer1<? super T> callback)

onFailure

Future<T> onFailure(Consumer1<? super Throwable> callback)

onComplete

Future<T> onComplete(Consumer1<? super Try<? extends T>> callback)

map

<R> Future<R> map(Function1<? super T,? extends R> mapper)

Specified by:

map in interface Bindable<Future<?>,T>

Specified by:

map in interface Mappable<Future<?>,T>

mapError

Future<T> mapError(Function1<? super Throwable,? extends Throwable> mapper)

flatMap

<R> Future<R> flatMap(Function1<? super T,? extends Kind<Future<?>,? extends R>> mapper)

Specified by:

flatMap in interface Bindable<Future<?>,T>

andThen

<R> Future<R> andThen(Future<? extends R> next)

ap

<R> Future<R> ap(Future<Function1<? super T,? extends R>> apply)

filter

Future<T> filter(Matcher1<? super T> matcher)

filterNot

default Future<T> filterNot(Matcher1<? super T> matcher)

orElse

Future<T> orElse(Future<? extends T> other)

get

default T get()

getOrElse

default T getOrElse(T value)

getOrElse

default T getOrElse(Producer<? extends T> value)

getOrElseThrow

default T getOrElseThrow()

getOrElseThrow

default <X extends Throwable> T getOrElseThrow(Producer<? extends X> producer)
                                        throws X

Throws:

X

getCause

default Throwable getCause()

recover

default Future<T> recover(Function1<? super Throwable,? extends T> mapper)

recoverWith

<X extends Throwable> Future<T> recoverWith(Class<X> type,
 Function1<? super X,? extends T> mapper)

fold

<U> Future<U> fold(Function1<? super Throwable,? extends U> failureMapper,
 Function1<? super T,? extends U> successMapper)

toCompletableFuture

default CompletableFuture<T> toCompletableFuture()

toPromise

Promise<T> toPromise()

success

static <T> Future<T> success(T value)

success

static <T> Future<T> success(Executor executor,
 T value)

failure

static <T> Future<T> failure(Throwable error)

failure

static <T> Future<T> failure(Executor executor,
 Throwable error)

from

static <T> Future<T> from(Callable<? extends T> callable)

from

static <T> Future<T> from(Executor executor,
 Callable<? extends T> callable)

from

static <T> Future<T> from(Future<? extends T> future)

from

static <T> Future<T> from(Executor executor,
 Future<? extends T> future)

from

static <T> Future<T> from(CompletableFuture<? extends T> future)

from

static <T> Future<T> from(Executor executor,
 CompletableFuture<? extends T> future)

from

static <T> Future<T> from(Promise<? extends T> promise)

from

static <T> Future<T> from(Executor executor,
 Promise<? extends T> promise)

task

static <T> Future<T> task(Producer<? extends T> task)

task

static <T> Future<T> task(Executor executor,
 Producer<? extends T> task)

exec

static Future<Unit> exec(CheckedRunnable task)

exec

static Future<Unit> exec(Executor executor,
 CheckedRunnable task)

delay

static <T> Future<T> delay(Duration timeout,
 Producer<? extends T> producer)

delay

static <T> Future<T> delay(Executor executor,
 Duration timeout,
 Producer<? extends T> producer)

sleep

static Future<Unit> sleep(Duration delay)

sleep

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

later

static <T> Future<T> later(Producer<? extends T> producer)

later

static <T> Future<T> later(Executor executor,
 Producer<? extends T> producer)

bracket

static <T extends AutoCloseable,
R> Future<R> bracket(Future<? extends T> acquire,
 Function1<? super T,? extends Future<? extends R>> use)

bracket

static <T extends AutoCloseable,
R> Future<R> bracket(Executor executor,
 Future<? extends T> acquire,
 Function1<? super T,? extends Future<? extends R>> use)

bracket

static <T,
R> Future<R> bracket(Future<? extends T> acquire,
 Function1<? super T,? extends Future<? extends R>> use,
 Consumer1<? super T> release)

bracket

static <T,
R> Future<R> bracket(Executor executor,
 Future<? extends T> acquire,
 Function1<? super T,? extends Future<? extends R>> use,
 Consumer1<? super T> release)

traverse

static <A> Future<Sequence<A>> traverse(Sequence<Future<A>> sequence)

map2

static <T,
V,
R> Future<R> map2(Future<? extends T> fa,
 Future<? extends V> fb,
 Function2<? super T,? super V,? extends R> mapper)

tuple

static <T,
V> Future<Tuple2<T,V>> tuple(Future<T> fa,
 Future<V> fb)

async

static <T> Future<T> async(Consumer1<Consumer1<? super Try<? extends T>>> consumer)

async

static <T> Future<T> async(Executor executor,
 Consumer1<Consumer1<? super Try<? extends T>>> consumer)