Processes messages of type A
, one at a time.
Future
is a trampolined computation producing an A
that may
include asynchronous steps.
Future
is a trampolined computation producing an A
that may
include asynchronous steps. Like Trampoline
, arbitrary
monadic expressions involving map
and flatMap
are guaranteed
to use constant stack space. But in addition, one may construct a
Future
from an asynchronous computation, represented as a
function, listen: (A => Unit) => Unit
, which registers a callback
that will be invoked when the result becomes available. This makes
Future
useful as a concurrency primitive and as a control
structure for wrapping callback-based APIs with a more
straightforward, monadic API.
Unlike the Future
implementation in scala 2.10, map
and
flatMap
do NOT spawn new tasks and do not require an implicit
ExecutionContext
. Instead, map
and flatMap
merely add to
the current (trampolined) continuation that will be run by the
'current' thread, unless explicitly forked via Future.fork
or
Future.apply
. This means that Future
achieves much better thread
reuse than the 2.10 implementation and avoids needless thread
pool submit cycles.
Future
also differs from the scala 2.10 Future
type in that it
does not necessarily represent a _running_ computation. Instead, we
reintroduce nondeterminism _explicitly_ using the functions of the
scalaz.Nondeterminism
interface. This simplifies our implementation
and makes code easier to reason about, since the order of effects
and the points of nondeterminism are made fully explicit and do not
depend on Scala's evaluation order.
IMPORTANT NOTE: Future
does not include any error handling and
should generally only be used as a building block by library
writers who want to build on Future
's capabilities but wish to
design their own error handling strategy. See
scalaz.concurrent.Task
for a type that extends Future
with
proper error handling -- it is merely a wrapper for
Future[Throwable \/ A]
with a number of additional
convenience functions.
Evaluate an expression in some specific manner.
Evaluate an expression in some specific manner. A typical strategy will schedule asynchronous evaluation and return a function that, when called, will block until the result is ready.
Memory consistency effects: Actions in a thread prior to the submission of a
to the Strategy
happen-before any actions taken by a
, which in turn happen-before
the result is retrieved via returned function.
Task[A]
wraps a scalaz.concurrent.Future[Throwable \/ A]
,
with some convenience functions for handling exceptions.
Task[A]
wraps a scalaz.concurrent.Future[Throwable \/ A]
,
with some convenience functions for handling exceptions. Its
Monad
and Nondeterminism
instances are derived from Future.
Task
(and Future
) differ in several key ways from the Future
implementation in Scala 2.10 , and have a number of advantages. See the
documentation for scalaz.concurrent.Future for more information.
Task
is exception-safe when constructed using the primitives
in the companion object, but when calling the constructor, you
are responsible for ensuring the exception safety of the provided
Future
.
Safe App
trait that runs a scalaz.concurrent.Task
action.
Safe App
trait that runs a scalaz.concurrent.Task
action.
Clients should implement run
, runl
, or runc
.
Processes messages of type
A
, one at a time. Messages are submitted to the actor with the method!
. Processing is typically performed asynchronously, this is controlled by the providedstrategy
.Memory consistency guarantee: when each message is processed by the
handler
, any memory that it mutates is guaranteed to be visible by thehandler
when it processes the next message, even if thestrategy
runs the invocations ofhandler
on separate threads. This is achieved because theActor
reads a volatile memory location before entering its event loop, and writes to the same location before suspending.Implementation based on non-intrusive MPSC node-based queue, described by Dmitriy Vyukov: http://www.1024cores.net/home/lock-free-algorithms/queues/non-intrusive-mpsc-node-based-queue
The type of messages accepted by this actor.
The message handler
Exception handler, called if the message handler throws any
Throwable
.Execution strategy, for example, a strategy that is backed by an
ExecutorService