sealed abstract class Future[+A] extends AnyRef
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.
- Source
- Future.scala
- Alphabetic
- By Inheritance
- Future
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def after(t: Long): Future[A]
- def after(t: Duration): Future[A]
Returns a
Future
that delays the execution of thisFuture
by the durationt
. - final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def flatMap[B](f: (A) => Future[B]): Future[B]
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def map[B](f: (A) => B): Future[B]
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def step: Future[A]
Evaluate this
Future
to a result, or another asynchronous computation.Evaluate this
Future
to a result, or another asynchronous computation. This has the effect of stripping off any 'pure' trampolined computation at the start of thisFuture
.- Annotations
- @tailrec()
- final def stepInterruptibly(cancel: AtomicBoolean): Future[A]
Like
step
, but may be interrupted by settingcancel
to true.Like
step
, but may be interrupted by settingcancel
to true.- Annotations
- @tailrec()
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def timed(timeout: Duration)(implicit scheduler: ScheduledExecutorService = Strategy.DefaultTimeoutScheduler): Future[\/[Throwable, A]]
- def timed(timeoutInMillis: Long)(implicit scheduler: ScheduledExecutorService): Future[\/[Throwable, A]]
Returns a
Future
which returns aTimeoutException
aftertimeoutInMillis
, and attempts to cancel the running computation.Returns a
Future
which returns aTimeoutException
aftertimeoutInMillis
, and attempts to cancel the running computation. This implementation will not block the future's execution thread - def toString(): String
- Definition Classes
- AnyRef → Any
- def unsafePerformAsync(cb: (A) => Unit): Unit
Run this
Future
, passing the result to the given callback once available.Run this
Future
, passing the result to the given callback once available. Any pure, non-asynchronous computation at the head of thisFuture
will be forced in the calling thread. At the firstAsync
encountered, control switches to whatever thread backs theAsync
and this function returns. - def unsafePerformAsyncInterruptibly(cb: (A) => Unit, cancel: AtomicBoolean): Unit
Run this computation to obtain an
A
, so long ascancel
remains false.Run this computation to obtain an
A
, so long ascancel
remains false. Because of trampolining, we get frequent opportunities to cancel while stepping through the trampoline, this should provide a fairly robust means of cancellation. - def unsafePerformListen(cb: (A) => Free.Trampoline[Unit]): Unit
Run this computation to obtain an
A
, then invoke the given callback.Run this computation to obtain an
A
, then invoke the given callback. Also seeunsafePerformAsync
. - def unsafePerformListenInterruptibly(cb: (A) => Free.Trampoline[Unit], cancel: AtomicBoolean): Unit
Run this computation to obtain an
A
, so long ascancel
remains false.Run this computation to obtain an
A
, so long ascancel
remains false. Because of trampolining, we get frequent opportunities to cancel while stepping through the trampoline, so this should provide a fairly robust means of cancellation. - def unsafePerformSync: A
Run this
Future
and block awaiting its result. - def unsafePerformSyncAttemptFor(timeout: Duration): \/[Throwable, A]
- def unsafePerformSyncAttemptFor(timeoutInMillis: Long): \/[Throwable, A]
Like
unsafePerformSyncFor
, but returnsTimeoutException
as left value.Like
unsafePerformSyncFor
, but returnsTimeoutException
as left value. Will not report any other exceptions that may be raised during computation ofA
- def unsafePerformSyncFor(timeout: Duration): A
- def unsafePerformSyncFor(timeoutInMillis: Long): A
Run this
Future
and block until its result is available, or untiltimeoutInMillis
milliseconds have elapsed, at which point aTimeoutException
will be thrown and theFuture
will attempt to be canceled. - def unsafeStart: Future[A]
Begins running this
Future
and returns a new future that blocks waiting for the result.Begins running this
Future
and returns a new future that blocks waiting for the result. Note that this will start executing side effects immediately, and is thus morally equivalent tounsafePerformIO
. The resultingFuture
cannot be rerun to repeat the effects.Use with care.
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
Deprecated Value Members
- def attemptRunFor(timeout: Duration): \/[Throwable, A]
- Annotations
- @deprecated
- Deprecated
(Since version 7.2) use unsafePerformSyncAttemptFor
- def attemptRunFor(timeoutInMillis: Long): \/[Throwable, A]
- Annotations
- @deprecated
- Deprecated
(Since version 7.2) use unsafePerformSyncAttemptFor
- def listen(cb: (A) => Free.Trampoline[Unit]): Unit
- Annotations
- @deprecated
- Deprecated
(Since version 7.2) use unsafePerformListen
- def listenInterruptibly(cb: (A) => Free.Trampoline[Unit], cancel: AtomicBoolean): Unit
- Annotations
- @deprecated
- Deprecated
(Since version 7.2) use unsafePerformListenInterruptibly
- def run: A
- Annotations
- @deprecated
- Deprecated
(Since version 7.2) use unsafePerformSync
- def runAsync(cb: (A) => Unit): Unit
- Annotations
- @deprecated
- Deprecated
(Since version 7.2) use unsafePerformAsync
- def runAsyncInterruptibly(cb: (A) => Unit, cancel: AtomicBoolean): Unit
- Annotations
- @deprecated
- Deprecated
(Since version 7.2) use unsafePerformAsyncInterruptibly
- def runFor(timeout: Duration): A
- Annotations
- @deprecated
- Deprecated
(Since version 7.2) use unsafePerformSyncFor
- def runFor(timeoutInMillis: Long): A
- Annotations
- @deprecated
- Deprecated
(Since version 7.2) use unsafePerformSyncFor
- def start: Future[A]
- Annotations
- @deprecated
- Deprecated
(Since version 7.2) use unsafeStart
- def unsafePerformTimed(timeoutInMillis: Long)(implicit scheduler: ScheduledExecutorService): Future[\/[Throwable, A]]
- Annotations
- @deprecated
- Deprecated
(Since version 7.2) use timed
- def unsafePerformTimed(timeout: Duration)(implicit scheduler: ScheduledExecutorService = Strategy.DefaultTimeoutScheduler): Future[\/[Throwable, A]]
- Annotations
- @deprecated
- Deprecated
(Since version 7.2) use timed