Future

type for Futures which need to be executed in parallel when using an Applicative instance

The names of the product elements

The name of the type

Create a Future that will evaluate a using the given ExecutorService.

Create a Future from an asynchronous computation, which takes the form of a function with which we can register a callback. This can be used to translate from a callback-based API to a straightforward monadic version. See Task.async for a version that allows for asynchronous exceptions.

Promote a non-strict value to a Future. Note that since Future is unmemoized, this will recompute a each time it is sequenced into a larger computation. Memoize a with a lazy value before calling this function if memoization is desired.

Returns a Future that produces the same result as the given Future, but forks its evaluation off into a separate (logical) thread, using the given ExecutorService. Note that this forking is only described by the returned Future--nothing occurs until the Future is run.

Calls Nondeterminism[Future].gatherUnordered.

Convert a strict value to a Future.

Create a Future that will evaluate a after at least the given delay.

Produce f in the main trampolining loop, Future.step, using a fresh call stack. The standard trampolining primitive, useful for avoiding stack overflows.

This Applicative instance runs Futures in parallel.

It is different from the Applicative instance obtained from Monad[Future] which runs futures sequentially.