Future

Type Members

case class NextThrewException(cause: Throwable) extends IllegalArgumentException with Product with Serializable

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
val ???: Future[Nothing]

Analogous to Predef.???
val DEFAULT_TIMEOUT: Duration
val Done: Future[Unit]
val False: Future[Boolean]
val Nil: Future[Seq[Nothing]]
val None: Future[Option[Nothing]]
val True: Future[Boolean]
val Unit: Future[Unit]
val Void: Future[Void]
def apply[A](a: ⇒ A): Future[A]

A factory function to "lift" computations into the Future monad.
A factory function to "lift" computations into the Future monad. It will catch nonfatal (see: com.twitter.util.NonFatal) exceptions and wrap them in the Throw[_] type. Non-exceptional values are wrapped in the Return[_] type.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def batched[In, Out](sizeThreshold: Int, timeThreshold: Duration = Duration.Top, sizePercentile: ⇒ Float = 1.0f)(f: (Seq[In]) ⇒ Future[Seq[Out]])(implicit timer: Timer): Batcher[In, Out]

Creates a "batched" Future that, given a function Seq[In] => Future[Seq[Out]], returns a In => Future[Out] interface that batches the underlying asynchronous operations.
Creates a "batched" Future that, given a function Seq[In] => Future[Seq[Out]], returns a In => Future[Out] interface that batches the underlying asynchronous operations. Thus, one can incrementally submit tasks to be performed when the criteria for batch flushing is met.
Example:
val timer = new JavaTimer(true) def processBatch(reqs: Seq[Request]): Future[Seq[Response]] val batcher = Future.batched(sizeThreshold = 10) { processBatch } val response: Future[Response] = batcher(new Request)
batcher will wait until 10 requests have been submitted, then delegate to the processBatch method to compute the responses.
Batchers can be constructed with both size- or time-based thresholds:
val batcher = Future.batched(sizeThreshold = 10, timeThreshold = 10.milliseconds) { ... }
To force the batcher to immediately process all unprocessed requests:
batcher.flushBatch()
A batcher's size can be controlled at runtime with the sizePercentile function argument. This function returns a float between 0.0 and 1.0, representing the fractional size of the sizeThreshold that should be used for the next batch to be collected.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[A](fs: List[Future[A]]): Future[List[A]]

Collect the results from the given futures into a new future of Seq[A].
Collect the results from the given futures into a new future of Seq[A]. If one or more of the given futures is exceptional, the resulting future result will be the first exception encountered.
TODO: This method should be deprecated in favour of Futures.collect().
fs
a java.util.List of Futures
returns
a Future[java.util.List[A]] containing the collected values from fs.
def collect[A, B](fs: Map[A, Future[B]]): Future[Map[A, B]]

Collect the results from the given map fs of futures into a new future of map.
Collect the results from the given map fs of futures into a new future of map. If one or more of the given Futures is exceptional, the resulting Future result will the first exception encountered.
fs
a map of Futures
returns
a Future[Map[A, B]] containing the collected values from fs
def collect[A](fs: Seq[Future[A]]): Future[Seq[A]]

Collect the results from the given futures into a new future of Seq[A].
Collect the results from the given futures into a new future of Seq[A]. If one or more of the given Futures is exceptional, the resulting Future result will be the first exception encountered.
fs
a sequence of Futures
returns
a Future[Seq[A]] containing the collected values from fs.
def collectToTry[A](fs: List[Future[A]]): Future[List[Try[A]]]

Collect the results from the given futures into a new future of java.util.List[Try[A]].
Collect the results from the given futures into a new future of java.util.List[Try[A]].
TODO: This method should be deprecated in favour of Futures.collectToTry().
fs
a java.util.List of Futures
returns
a Future[java.util.List[Try[A]]] containing the collected values from fs.
def collectToTry[A](fs: Seq[Future[A]]): Future[Seq[Try[A]]]

Collect the results from the given futures into a new future of Seq[Try[A]].
Collect the results from the given futures into a new future of Seq[Try[A]].
fs
a sequence of Futures
returns
a Future[Seq[Try[A]]] containing the collected values from fs.
def const[A](result: Try[A]): Future[A]

Makes a Future with a constant result.
def each[A](next: ⇒ Future[A])(body: (A) ⇒ Unit): Future[Nothing]

Produce values from next until it fails, synchronously applying body to each iteration.
Produce values from next until it fails, synchronously applying body to each iteration. The returned future indicates completion (via an exception).
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def exception[A](e: Throwable): Future[A]

Make a Future with an error.
Make a Future with an error. E.g., Future.exception(new Exception("boo")).
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def join[A](fs: List[Future[A]]): Future[Unit]

Take a sequence of Futures, wait till they all complete successfully.
Take a sequence of Futures, wait till they all complete successfully. The future fails immediately if any of the joined Futures do, mimicking the semantics of exceptions.
TODO: This method should be deprecated in favour of Futures.join().
fs
a java.util.List of Futures
returns
a Future[Unit] whose value is populated when all of the fs return.
def join[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I], j: Future[J], k: Future[K], l: Future[L], m: Future[M], n: Future[N], o: Future[O], p: Future[P], q: Future[Q], r: Future[R], s: Future[S], t: Future[T], u: Future[U], v: Future[V]): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]

Join 22 futures.
Join 22 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I], j: Future[J], k: Future[K], l: Future[L], m: Future[M], n: Future[N], o: Future[O], p: Future[P], q: Future[Q], r: Future[R], s: Future[S], t: Future[T], u: Future[U]): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]

Join 21 futures.
Join 21 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I], j: Future[J], k: Future[K], l: Future[L], m: Future[M], n: Future[N], o: Future[O], p: Future[P], q: Future[Q], r: Future[R], s: Future[S], t: Future[T]): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]

Join 20 futures.
Join 20 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I], j: Future[J], k: Future[K], l: Future[L], m: Future[M], n: Future[N], o: Future[O], p: Future[P], q: Future[Q], r: Future[R], s: Future[S]): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

Join 19 futures.
Join 19 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I], j: Future[J], k: Future[K], l: Future[L], m: Future[M], n: Future[N], o: Future[O], p: Future[P], q: Future[Q], r: Future[R]): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]

Join 18 futures.
Join 18 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I], j: Future[J], k: Future[K], l: Future[L], m: Future[M], n: Future[N], o: Future[O], p: Future[P], q: Future[Q]): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]

Join 17 futures.
Join 17 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I], j: Future[J], k: Future[K], l: Future[L], m: Future[M], n: Future[N], o: Future[O], p: Future[P]): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]

Join 16 futures.
Join 16 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I], j: Future[J], k: Future[K], l: Future[L], m: Future[M], n: Future[N], o: Future[O]): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

Join 15 futures.
Join 15 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B, C, D, E, F, G, H, I, J, K, L, M, N](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I], j: Future[J], k: Future[K], l: Future[L], m: Future[M], n: Future[N]): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]

Join 14 futures.
Join 14 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B, C, D, E, F, G, H, I, J, K, L, M](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I], j: Future[J], k: Future[K], l: Future[L], m: Future[M]): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M)]

Join 13 futures.
Join 13 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B, C, D, E, F, G, H, I, J, K, L](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I], j: Future[J], k: Future[K], l: Future[L]): Future[(A, B, C, D, E, F, G, H, I, J, K, L)]

Join 12 futures.
Join 12 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B, C, D, E, F, G, H, I, J, K](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I], j: Future[J], k: Future[K]): Future[(A, B, C, D, E, F, G, H, I, J, K)]

Join 11 futures.
Join 11 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B, C, D, E, F, G, H, I, J](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I], j: Future[J]): Future[(A, B, C, D, E, F, G, H, I, J)]

Join 10 futures.
Join 10 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B, C, D, E, F, G, H, I](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I]): Future[(A, B, C, D, E, F, G, H, I)]

Join 9 futures.
Join 9 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B, C, D, E, F, G, H](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H]): Future[(A, B, C, D, E, F, G, H)]

Join 8 futures.
Join 8 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B, C, D, E, F, G](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G]): Future[(A, B, C, D, E, F, G)]

Join 7 futures.
Join 7 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B, C, D, E, F](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F]): Future[(A, B, C, D, E, F)]

Join 6 futures.
Join 6 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B, C, D, E](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E]): Future[(A, B, C, D, E)]

Join 5 futures.
Join 5 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B, C, D](a: Future[A], b: Future[B], c: Future[C], d: Future[D]): Future[(A, B, C, D)]

Join 4 futures.
Join 4 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B, C](a: Future[A], b: Future[B], c: Future[C]): Future[(A, B, C)]

Join 3 futures.
Join 3 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A, B](a: Future[A], b: Future[B]): Future[(A, B)]

Join 2 futures.
Join 2 futures. The returned future is complete when all underlying futures complete. It fails immediately if any of them do.
def join[A](fs: Seq[Future[A]]): Future[Unit]

Take a sequence of Futures, wait till they all complete successfully.
Take a sequence of Futures, wait till they all complete successfully. The future fails immediately if any of the joined Futures do, mimicking the semantics of exceptions.
fs
a sequence of Futures
returns
a Future[Unit] whose value is populated when all of the fs return.
def monitored[A](mkFuture: ⇒ Future[A]): Future[A]

Run the computation mkFuture while installing a Monitor that translates any exception thrown into an encoded one.
Run the computation mkFuture while installing a Monitor that translates any exception thrown into an encoded one. If an exception is thrown anywhere, the underlying computation is interrupted with that exception.
This function is usually called to wrap a computation that returns a Future (f0) whose value is satisfied by the invocation of an onSuccess/onFailure/ensure callbacks of another future (f1). If an exception happens in the callbacks on f1, f0 is never satisfied. In this example, Future.monitored { f1 onSuccess g; f0 } will cancel f0 so that f0 never hangs.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
val never: Future[Nothing]

A new future that can never complete.
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def parallel[A](n: Int)(f: ⇒ Future[A]): Seq[Future[A]]
def rawException[A](e: Throwable): Future[A]

Make a Future with an error.
Make a Future with an error. E.g., Future.exception(new Exception("boo")). The exception is not wrapped in any way.
def select[A](fs: List[Future[A]]): Future[(Try[A], List[Future[A]])]

"Select" off the first future to be satisfied.
"Select" off the first future to be satisfied. Return this as a result, with the remainder of the Futures as a sequence.
TODO: This method should be deprecated in favour of Futures.select().
fs
a java.util.List
returns
a Future[Tuple2[Try[A], java.util.List[Future[A]]]] representing the first future to be satisfied and the rest of the futures.
def select[A](fs: Seq[Future[A]]): Future[(Try[A], Seq[Future[A]])]

"Select" off the first future to be satisfied.
"Select" off the first future to be satisfied. Return this as a result, with the remainder of the Futures as a sequence.
fs
a scala.collection.Seq
def selectIndex[A](fs: IndexedSeq[Future[A]]): Future[Int]

Select the index into fs of the first future to be satisfied.
Select the index into fs of the first future to be satisfied.
fs
cannot be empty
def sleep(howlong: Duration)(implicit timer: Timer): Future[Unit]

A unit future that completes after howlong.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def times[A](n: Int)(f: ⇒ Future[A]): Future[Unit]

Repeat a computation that returns a Future some number of times, after each computation completes.
def toString(): String

Definition Classes
AnyRef → Any
def unapply[A](f: Future[A]): Option[Try[A]]
def value[A](a: A): Future[A]

Make a Future with a constant value.
Make a Future with a constant value. E.g., Future.value(1) is a Future[Int].
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 when[A](p: Boolean)(f: ⇒ Future[A]): Future[Unit]

Perform the effects of the supplied Future only when the provided flag is true.
def whileDo[A](p: ⇒ Boolean)(f: ⇒ Future[A]): Future[Unit]

Repeat a computation that returns a Future while some predicate obtains, after each computation completes.

Deprecated Value Members

def flatten[A](ffa: Future[Future[A]]): Future[A]

Flattens a nested future.
Flattens a nested future. Same as ffa.flatten, but easier to call from Java.

Annotations
@deprecated
Deprecated
(Since version 6.20.1) Use Futures.flatten instead

Related Docs: class Future | package util

object Future

Type Members

case class NextThrewException(cause: Throwable) extends IllegalArgumentException with Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val ???: Future[Nothing]

val DEFAULT_TIMEOUT: Duration

val Done: Future[Unit]

val False: Future[Boolean]

val Nil: Future[Seq[Nothing]]

val None: Future[Option[Nothing]]

val True: Future[Boolean]

val Unit: Future[Unit]

val Void: Future[Void]

def apply[A](a: ⇒ A): Future[A]

final def asInstanceOf[T0]: T0

def batched[In, Out](sizeThreshold: Int, timeThreshold: Duration = Duration.Top, sizePercentile: ⇒ Float = 1.0f)(f: (Seq[In]) ⇒ Future[Seq[Out]])(implicit timer: Timer): Batcher[In, Out]

def clone(): AnyRef

def collect[A](fs: List[Future[A]]): Future[List[A]]

def collect[A, B](fs: Map[A, Future[B]]): Future[Map[A, B]]

def collect[A](fs: Seq[Future[A]]): Future[Seq[A]]

def collectToTry[A](fs: List[Future[A]]): Future[List[Try[A]]]

def collectToTry[A](fs: Seq[Future[A]]): Future[Seq[Try[A]]]

def const[A](result: Try[A]): Future[A]

def each[A](next: ⇒ Future[A])(body: (A) ⇒ Unit): Future[Nothing]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exception[A](e: Throwable): Future[A]

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def join[A](fs: List[Future[A]]): Future[Unit]

def join[A, B, C, D, E, F, G, H, I, J, K, L, M, N](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I], j: Future[J], k: Future[K], l: Future[L], m: Future[M], n: Future[N]): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]

def join[A, B, C, D, E, F, G, H, I, J, K, L, M](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I], j: Future[J], k: Future[K], l: Future[L], m: Future[M]): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M)]

def join[A, B, C, D, E, F, G, H, I, J, K, L](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I], j: Future[J], k: Future[K], l: Future[L]): Future[(A, B, C, D, E, F, G, H, I, J, K, L)]

def join[A, B, C, D, E, F, G, H, I, J, K](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I], j: Future[J], k: Future[K]): Future[(A, B, C, D, E, F, G, H, I, J, K)]

def join[A, B, C, D, E, F, G, H, I, J](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I], j: Future[J]): Future[(A, B, C, D, E, F, G, H, I, J)]

def join[A, B, C, D, E, F, G, H, I](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H], i: Future[I]): Future[(A, B, C, D, E, F, G, H, I)]

def join[A, B, C, D, E, F, G, H](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G], h: Future[H]): Future[(A, B, C, D, E, F, G, H)]

def join[A, B, C, D, E, F, G](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F], g: Future[G]): Future[(A, B, C, D, E, F, G)]

def join[A, B, C, D, E, F](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], f: Future[F]): Future[(A, B, C, D, E, F)]

def join[A, B, C, D, E](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E]): Future[(A, B, C, D, E)]

def join[A, B, C, D](a: Future[A], b: Future[B], c: Future[C], d: Future[D]): Future[(A, B, C, D)]

def join[A, B, C](a: Future[A], b: Future[B], c: Future[C]): Future[(A, B, C)]

def join[A, B](a: Future[A], b: Future[B]): Future[(A, B)]

def join[A](fs: Seq[Future[A]]): Future[Unit]

def monitored[A](mkFuture: ⇒ Future[A]): Future[A]

final def ne(arg0: AnyRef): Boolean

val never: Future[Nothing]

final def notify(): Unit

final def notifyAll(): Unit

def parallel[A](n: Int)(f: ⇒ Future[A]): Seq[Future[A]]

def rawException[A](e: Throwable): Future[A]

def select[A](fs: List[Future[A]]): Future[(Try[A], List[Future[A]])]

def select[A](fs: Seq[Future[A]]): Future[(Try[A], Seq[Future[A]])]

def selectIndex[A](fs: IndexedSeq[Future[A]]): Future[Int]

def sleep(howlong: Duration)(implicit timer: Timer): Future[Unit]

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

def times[A](n: Int)(f: ⇒ Future[A]): Future[Unit]

def toString(): String

def unapply[A](f: Future[A]): Option[Try[A]]

def value[A](a: A): Future[A]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def when[A](p: Boolean)(f: ⇒ Future[A]): Future[Unit]

def whileDo[A](p: ⇒ Boolean)(f: ⇒ Future[A]): Future[Unit]

Deprecated Value Members

def flatten[A](ffa: Future[Future[A]]): Future[A]

Inherited from AnyRef

Inherited from Any

Ungrouped