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
- All
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: Duration)(implicit scheduler: ScheduledExecutorService = Strategy.DefaultTimeoutScheduler): Future[A]
Returns a
Future
that delays the execution of thisFuture
by the durationt
. - def afterMillis(delay: Long)(implicit scheduler: ScheduledExecutorService = Strategy.DefaultTimeoutScheduler): Future[A]
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
- def flatMap[B](f: (A) ⇒ Future[B]): Future[B]
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
-
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
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
-
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( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )