type for Futures which need to be executed in parallel when using an Applicative instance
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.
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
.
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
.
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.
This Applicative instance runs Futures in parallel.
This Applicative instance runs Futures in parallel.
It is different from the Applicative instance obtained from Monad[Future] which runs futures sequentially.
Calls Nondeterminism[Future].gatherUnordered
.
Calls Nondeterminism[Future].gatherUnordered
.
7.0.3
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.
Produce f
in the main trampolining loop, Future.step
, using a fresh
call stack. The standard trampolining primitive, useful for avoiding
stack overflows.