type for Tasks which need to be executed in parallel when using an Applicative instance
signals task was interrupted *
Utility function - evaluate a
and catch and return any exceptions.
Create a Task
that will evaluate a
using the given ExecutorService
.
Create a Task
from an asynchronous computation, which takes the form
of a function with which we can register a callback.
Create a Task
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.
Promote a non-strict value to a Task
, catching exceptions in
the process.
Promote a non-strict value to a Task
, catching exceptions in
the process. Note that since Task
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.
A Task
which fails with the given Throwable
.
Returns a Task
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 Task
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 Task
--nothing occurs until the Task
is run.
Like Nondeterminism[Task].gatherUnordered
, but if exceptionCancels
is true,
exceptions in any task try to immediately cancel all other running tasks.
Like Nondeterminism[Task].gatherUnordered
, but if exceptionCancels
is true,
exceptions in any task try to immediately cancel all other running tasks. If
exceptionCancels
is false, in the event of an error, all tasks are run to completion
before the error is returned.
7.0.3
Convert a strict value to a Task
.
Convert a strict value to a Task
. Also see 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.
This Applicative instance runs Tasks in parallel.
This Applicative instance runs Tasks in parallel.
It is different from the Applicative instance obtained from Monad[Task] which runs tasks sequentially.
Create a Task
that starts evaluating a
using the given ExecutorService
right away.
Create a Task
that starts evaluating a
using the given ExecutorService
right away.
This will start executing side effects immediately, and is thus morally equivalent to
unsafePerformIO
. The resulting Task
cannot be rerun to repeat the effects.
Use with care.