Future

Instance Constructors

new Future()

Abstract Value Members

abstract def isReady(implicit permit: CanAwait): Boolean

Is this Awaitable ready? In other words: would calling Awaitable.ready block?
Is this Awaitable ready? In other words: would calling Awaitable.ready block?

Definition Classes
Awaitable
abstract def poll: Option[Try[A]]

Polls for an available result.
Polls for an available result. If the Future has been satisfied, returns Some(result), otherwise None.
abstract def raise(interrupt: Throwable): Unit

Raise the given throwable as an interrupt.
Raise the given throwable as an interrupt. Interrupts are one-shot and latest-interrupt wins. That is, the last interrupt to have been raised is delivered exactly once to the Promise responsible for making progress on the future (multiple such promises may be involved in flatMap chains).
Raising an interrupt does not alter the externally observable state of the Future. They are used to signal to the producer of the future's value that the result is no longer desired (for whatever reason given in the passed Throwable).
abstract def ready(timeout: Duration)(implicit permit: CanAwait): Future.this.type

Support for Await.ready.
Support for Await.ready. The use of the implicit permit is an access control mechanism: only Await.ready may call this method.

Definition Classes
Awaitable
Annotations
@throws( classOf[TimeoutException] ) @throws( classOf[InterruptedException] )
abstract def respond(k: (Try[A]) ⇒ Unit): Future[A]

When the computation completes, invoke the given callback function.
When the computation completes, invoke the given callback function.
The returned Future will be satisfied when this, the original future, is done.
This method is most useful for very generic code (like libraries). Otherwise, it is a best practice to use one of the alternatives (onSuccess, onFailure, etc.).
k
the side-effect to apply when the computation completes. The value of the input to k will be the result of the computation to this future.
returns
a chained Future[A]

Note
this should be used for side-effects.
See also
addEventListener for a Java friendly API.
ensure if you are not interested in the result of the computation.
transform to produce a new Future from the result of the computation.
abstract def result(timeout: Duration)(implicit permit: CanAwait): A

Support for Await.result.
Support for Await.result. The use of the implicit permit is an access control mechanism: only Await.result may call this method.

Definition Classes
Awaitable
Annotations
@throws( classOf[Exception] )
abstract def transform[B](f: (Try[A]) ⇒ Future[B]): Future[B]

When this future completes, run f on that completed result whether or not this computation was successful.
When this future completes, run f on that completed result whether or not this computation was successful.
The returned Future will be satisfied when this, the original future, and f are done.

See also
transformedBy for a Java friendly API.
handle and rescue for dealing strictly with exceptional computations.
map and flatMap for dealing strictly with successful computations.
respond for purely side-effecting callbacks.

Concrete 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 addEventListener(listener: FutureEventListener[_ >: A]): Future[A]

Register a FutureEventListener to be invoked when the computation completes.
Register a FutureEventListener to be invoked when the computation completes. This method is typically used by Java programs because it avoids the use of small Function objects.

Note
this should be used for side-effects
See also
transformedBy for a Java friendly way to produce a new Future from the result of a computation.
respond for a Scala API.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def before[B](f: ⇒ Future[B])(implicit ev: <:<[Future.this.type, Future[Unit]]): Future[B]

Sequentially compose this with f.
Sequentially compose this with f. This is as flatMap, but discards the result of this. Note that this applies only Unit-valued Futures — i.e. side-effects.
def by(timer: Timer, when: Time, exc: ⇒ Throwable): Future[A]

Returns a new Future that fails if it is not satisfied before the given time.
Returns a new Future that fails if it is not satisfied before the given time.
Note: On timeout, the underlying future is not interrupted.
Note: Interrupting a returned future would not prevent it from being satisfied with a given exception (when the time comes).
timer
to run timeout on.
when
indicates when to stop waiting for the result to be available.
exc
exception to throw.
def by(timer: Timer, when: Time): Future[A]

Returns a new Future that fails if it is not satisfied before the given time.
Returns a new Future that fails if it is not satisfied before the given time.
Note: On timeout, the underlying future is not interrupted.
def by(when: Time)(implicit timer: Timer): Future[A]

Returns a new Future that fails if it is not satisfied before the given time.
Returns a new Future that fails if it is not satisfied before the given time.
Same as the other by, but with an implicit timer. Sometimes this is more convenient.
Note: On timeout, the underlying future is not interrupted.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def delayed(howlong: Duration)(implicit timer: Timer): Future[A]

Delay the completion of this Future for at least howlong from now.
Delay the completion of this Future for at least howlong from now.
Note: Interrupting a returned future would not prevent it from becoming this future (when the time comes).
def ensure(f: ⇒ Unit): Future[A]

Invoked regardless of whether the computation completed successfully or unsuccessfully.
Invoked regardless of whether the computation completed successfully or unsuccessfully. Implemented in terms of respond so that subclasses control evaluation order. Returns a chained Future.
The returned Future will be satisfied when this, the original future, is done.
f
the side-effect to apply when the computation completes.

Note
this should be used for side-effects.
See also
respond if you need the result of the computation for usage in the side-effect.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def filter(p: (A) ⇒ Boolean): Future[A]
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]

If this, the original future, succeeds, run f on the result.
If this, the original future, succeeds, run f on the result.
The returned result is a Future that is satisfied when the original future and the callback, f, are done. If the original future fails, this one will also fail, without executing f and preserving the failed computation of this.

See also
map
def flatten[B](implicit ev: <:<[A, Future[B]]): Future[B]

Converts a Future[Future[B]] into a Future[B].
def foreach(k: (A) ⇒ Unit): Future[A]

Invoke the callback only if the Future returns successfully.
Invoke the callback only if the Future returns successfully. Useful for Scala for comprehensions. Use onSuccess instead of this method for more readable code.

See also
onSuccess
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def handle[B >: A](rescueException: PartialFunction[Throwable, B]): Future[B]

If this, the original future, results in an exceptional computation, rescueException may convert the failure into a new result.
If this, the original future, results in an exceptional computation, rescueException may convert the failure into a new result.
The returned result is a Future that is satisfied when the original future and the callback, rescueException, are done.
This is the equivalent of map for failed computations.

See also
rescue
def hashCode(): Int

Definition Classes
AnyRef → Any
def interruptible(): Future[A]

Makes a derivative Future which will be satisfied with the result of the parent.
Makes a derivative Future which will be satisfied with the result of the parent. However, if it's interrupted, it will detach from the parent Future, satisfy itself with the exception raised to it, and won't propagate the interruption back to the parent Future.
This is useful for when a Future is shared between many contexts, where it may not be useful to discard the underlying computation if just one context is no longer interested in the result. In particular, this is different from Future.masked in that it will prevent memory leaks if the parent Future will never be satisfied, because closures that are attached to this derivative Future will not be held onto by the killer Future.
def isDefined: Boolean

Is the result of the Future available yet?
def isDone(implicit ev: <:<[Future.this.type, Future[Unit]]): Boolean

Checks whether a Unit-typed Future is done.
Checks whether a Unit-typed Future is done. By convention, futures of type Future[Unit] are used for signalling.
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def join[B](other: Future[B]): Future[(A, B)]

Joins this future with a given other future into a Future[(A, B)] (future of a Tuple2).
Joins this future with a given other future into a Future[(A, B)] (future of a Tuple2). If this or other future fails, the returned Future is immediately satisfied by that failure.
def joinWith[B, C](other: Future[B])(fn: (A, B) ⇒ C): Future[C]

Joins this future with a given other future and applies fn to its result.
Joins this future with a given other future and applies fn to its result. If this or other future fails, the returned Future is immediately satisfied by that failure.
Before (using join):
```
val ab = a.join(b).map { case (a, b) => Foo(a, b) }
```
After (using joinWith):
```
val ab = a.joinWith(b)(Foo.apply)
```
def liftToTry: Future[Try[A]]

Returns the result of the computation as a Future[Try[A]].
def lowerFromTry[B](implicit ev: <:<[A, Try[B]]): Future[B]

Lowers a Future[Try[T]] into a Future[T].
def map[B](f: (A) ⇒ B): Future[B]

If this, the original future, succeeds, run f on the result.
If this, the original future, succeeds, run f on the result.
The returned result is a Future that is satisfied when the original future and the callback, f, are done. If the original future fails, this one will also fail, without executing f and preserving the failed computation of this.

See also
onSuccess for side-effecting chained computations.
flatMap for computations that return Futures.
def mask(pred: PartialFunction[Throwable, Boolean]): Future[A]

Returns an identical future except that it ignores interrupts which match a predicate
def masked: Future[A]

Returns an identical future that ignores all interrupts
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def onFailure(fn: (Throwable) ⇒ Unit): Future[A]

Invoke the function on the error, if the computation was unsuccessful.
Invoke the function on the error, if the computation was unsuccessful. Returns a chained Future as in respond.
returns
chained Future

Note
if fn is a PartialFunction and the input is not defined for a given Throwable, the resulting MatchError will propagate to the current Monitor. This will happen if you use a construct such as future.onFailure { case NonFatal(e) => ... } when the Throwable is "fatal".
,
this should be used for side-effects.
See also
handle and rescue to produce a new Future from the result of the computation.
def onSuccess(f: (A) ⇒ Unit): Future[A]

Invoke the function on the result, if the computation was successful.
Invoke the function on the result, if the computation was successful. Returns a chained Future as in respond.
returns
chained Future

Note
this should be used for side-effects.
See also
flatMap and map to produce a new Future from the result of the computation.
def or[U >: A](other: Future[U]): Future[U]

A synonym for select: Choose the first Future to be satisfied.
def proxyTo[B >: A](other: Promise[B]): Unit

Send updates from this Future to the other.
Send updates from this Future to the other. other must not yet be satisfied at the time of the call. After this call, nobody else should satisfy other.

Note
using proxyTo will mask interrupts to this future, and it's the user's responsibility to set an interrupt handler on other to raise on f. In some cases, using com.twitter.util.Promise.become may be more appropriate.
See also
com.twitter.util.Promise.become
def raiseWithin(timer: Timer, timeout: Duration, exc: Throwable): Future[A]

Returns a new Future that fails if this Future does not return in time.
Returns a new Future that fails if this Future does not return in time.
Note: On timeout, the underlying future is interrupted.
def raiseWithin(timeout: Duration, exc: Throwable)(implicit timer: Timer): Future[A]

Returns a new Future that fails if this Future does not return in time.
Returns a new Future that fails if this Future does not return in time.
Same as the other raiseWithin, but with an implicit timer. Sometimes this is more convenient.
Note: On timeout, the underlying future is interrupted.
def raiseWithin(timeout: Duration)(implicit timer: Timer): Future[A]

Returns a new Future that fails if this Future does not return in time.
Returns a new Future that fails if this Future does not return in time.
Same as the other raiseWithin, but with an implicit timer. Sometimes this is more convenient.
Note: On timeout, the underlying future is interrupted.
def rescue[B >: A](rescueException: PartialFunction[Throwable, Future[B]]): Future[B]

If this, the original future, results in an exceptional computation, rescueException may convert the failure into a new result.
If this, the original future, results in an exceptional computation, rescueException may convert the failure into a new result.
The returned result is a Future that is satisfied when the original future and the callback, rescueException, are done.
This is the equivalent of flatMap for failed computations.

See also
handle
def select[U >: A](other: Future[U]): Future[U]

Choose the first Future to be satisfied.
Choose the first Future to be satisfied.
other
another Future
returns
a new Future whose result is that of the first of this and other to return
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toJavaFuture: java.util.concurrent.Future[_ <: A]

Convert a Twitter Future to a Java native Future.
Convert a Twitter Future to a Java native Future. This should match the semantics of a Java Future as closely as possible to avoid issues with the way another API might use them. See:
http://download.oracle.com/javase/6/docs/api/java/util/concurrent/Future.html#cancel(boolean)
def toOffer: Offer[Try[A]]

An Offer for this future.
An Offer for this future.
The offer is activated when the future is satisfied.
def toString(): String

Definition Classes
AnyRef → Any
def transformedBy[B](transformer: FutureTransformer[A, B]): Future[B]

Transform the Future[A] into a Future[B] using the FutureTransformer.
Transform the Future[A] into a Future[B] using the FutureTransformer. The FutureTransformer handles both success (Return) and failure (Throw) values by implementing map/flatMap and handle/rescue. This method is typically used by Java programs because it avoids the use of small Function objects.

Note
The FutureTransformer must implement either flatMap or map and may optionally implement handle. Failing to implement a method will result in a run-time error (AbstractMethodError).
See also
addEventListener for a Java friendly way to perform side-effects.
transform for a Scala API.
def unit: Future[Unit]

Convert this Future[A] to a Future[Unit] by discarding the result.
Convert this Future[A] to a Future[Unit] by discarding the result.

Note
failed futures will remain as is.
def voided: Future[Void]

Convert this Future[A] to a Future[Void] by discarding the result.
Convert this Future[A] to a Future[Void] by discarding the result.

Note
failed futures will remain as is.
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( ... )
def willEqual[B](that: Future[B]): Future[Boolean]

Returns a Future[Boolean] indicating whether two Futures are equivalent.
Returns a Future[Boolean] indicating whether two Futures are equivalent.
Note that
```
Future.exception(e).willEqual(Future.exception(e)) == Future.value(true)
```
.
Future.exception(e).willEqual(Future.exception(e)) == Future.value(true) }}}
def withFilter(p: (A) ⇒ Boolean): Future[A]
def within(timer: Timer, timeout: Duration, exc: ⇒ Throwable): Future[A]

Returns a new Future that fails if it is not satisfied in time.
Returns a new Future that fails if it is not satisfied in time.
Note: On timeout, the underlying future is not interrupted.
timer
to run timeout on.
timeout
indicates how long you are willing to wait for the result to be available.
exc
exception to throw.
def within(timer: Timer, timeout: Duration): Future[A]

Returns a new Future that fails if it is not satisfied in time.
Returns a new Future that fails if it is not satisfied in time.
Note: On timeout, the underlying future is not interrupted.
def within(timeout: Duration)(implicit timer: Timer): Future[A]

Returns a new Future that fails if it is not satisfied in time.
Returns a new Future that fails if it is not satisfied in time.
Same as the other within, but with an implicit timer. Sometimes this is more convenient.
Note: On timeout, the underlying future is not interrupted.

Related Docs: object Future | package util

abstract class Future[+A] extends Awaitable[A]

Instance Constructors

new Future()

Abstract Value Members

abstract def isReady(implicit permit: CanAwait): Boolean

abstract def poll: Option[Try[A]]

abstract def raise(interrupt: Throwable): Unit

abstract def ready(timeout: Duration)(implicit permit: CanAwait): Future.this.type

abstract def respond(k: (Try[A]) ⇒ Unit): Future[A]

abstract def result(timeout: Duration)(implicit permit: CanAwait): A

abstract def transform[B](f: (Try[A]) ⇒ Future[B]): Future[B]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def addEventListener(listener: FutureEventListener[_ >: A]): Future[A]

final def asInstanceOf[T0]: T0

def before[B](f: ⇒ Future[B])(implicit ev: <:<[Future.this.type, Future[Unit]]): Future[B]

def by(timer: Timer, when: Time, exc: ⇒ Throwable): Future[A]

def by(timer: Timer, when: Time): Future[A]

def by(when: Time)(implicit timer: Timer): Future[A]

def clone(): AnyRef

def delayed(howlong: Duration)(implicit timer: Timer): Future[A]

def ensure(f: ⇒ Unit): Future[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(p: (A) ⇒ Boolean): Future[A]

def finalize(): Unit

def flatMap[B](f: (A) ⇒ Future[B]): Future[B]

def flatten[B](implicit ev: <:<[A, Future[B]]): Future[B]

def foreach(k: (A) ⇒ Unit): Future[A]

final def getClass(): Class[_]

def handle[B >: A](rescueException: PartialFunction[Throwable, B]): Future[B]

def hashCode(): Int

def interruptible(): Future[A]

def isDefined: Boolean

def isDone(implicit ev: <:<[Future.this.type, Future[Unit]]): Boolean

final def isInstanceOf[T0]: Boolean

def join[B](other: Future[B]): Future[(A, B)]

def joinWith[B, C](other: Future[B])(fn: (A, B) ⇒ C): Future[C]

def liftToTry: Future[Try[A]]

def lowerFromTry[B](implicit ev: <:<[A, Try[B]]): Future[B]

def map[B](f: (A) ⇒ B): Future[B]

def mask(pred: PartialFunction[Throwable, Boolean]): Future[A]

def masked: Future[A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onFailure(fn: (Throwable) ⇒ Unit): Future[A]

def onSuccess(f: (A) ⇒ Unit): Future[A]

def or[U >: A](other: Future[U]): Future[U]

def proxyTo[B >: A](other: Promise[B]): Unit

def raiseWithin(timer: Timer, timeout: Duration, exc: Throwable): Future[A]

def raiseWithin(timeout: Duration, exc: Throwable)(implicit timer: Timer): Future[A]

def raiseWithin(timeout: Duration)(implicit timer: Timer): Future[A]

def rescue[B >: A](rescueException: PartialFunction[Throwable, Future[B]]): Future[B]

def select[U >: A](other: Future[U]): Future[U]

final def synchronized[T0](arg0: ⇒ T0): T0

def toJavaFuture: java.util.concurrent.Future[_ <: A]

def toOffer: Offer[Try[A]]

def toString(): String

def transformedBy[B](transformer: FutureTransformer[A, B]): Future[B]

def unit: Future[Unit]

def voided: Future[Void]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def willEqual[B](that: Future[B]): Future[Boolean]

def withFilter(p: (A) ⇒ Boolean): Future[A]

def within(timer: Timer, timeout: Duration, exc: ⇒ Throwable): Future[A]

def within(timer: Timer, timeout: Duration): Future[A]

def within(timeout: Duration)(implicit timer: Timer): Future[A]

Inherited from Awaitable[A]

Inherited from AnyRef

Inherited from Any

Ungrouped