CompletableFuture

def await (atMost: Duration): Future[T]

Blocks the current thread until the Future has been completed or the timeout has expired, additionally bounding the waiting period according to the atMost parameter.

def await : Future[T]

Blocks the current thread until the Future has been completed or the timeout has expired.

def complete (value: Either[Throwable, T]): CompletableFuture.this.type

Completes this Future with the specified result, if not already completed.

implicit def dispatcher : MessageDispatcher

def isExpired : Boolean

Tests whether this Future's timeout has expired.

def onComplete (func: (Future[T]) ⇒ Unit): CompletableFuture.this.type

When this Future is completed, apply the provided function to the Future.

def onTimeout (func: (Future[T]) ⇒ Unit): CompletableFuture.this.type

Registers a function that will be executed when this Future times out.

   future onTimeout {
     f => doSomethingOnTimeout(f)
   }

def timeoutInNanos : Long

This Future's timeout in nanoseconds.

def value : Option[Either[Throwable, T]]

The contained value of this Future.

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def << (other: Future[T]): akka.dispatch.Future[T] @util.continuations.package.cps[akka.dispatch.Future[Any]]

def << (value: T): akka.dispatch.Future[T] @util.continuations.package.cps[akka.dispatch.Future[Any]]

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

def apply [A >: T] (): A @util.continuations.package.cps[akka.dispatch.Future[Any]]

For use only within a Future.

def as [A] (implicit m: Manifest[A]): Option[A]

Await completion of this Future and return its value if it conforms to A's erased type.

def asInstanceOf [T0] : T0

def asSilently [A] (implicit m: Manifest[A]): Option[A]

Await completion of this Future and return its value if it conforms to A's erased type, None otherwise.

def clone (): AnyRef

def completeWith (other: Future[T]): CompletableFuture.this.type

Completes this Future with the specified other Future, when that Future is completed, unless this Future has already been completed.

def completeWithException (exception: Throwable): CompletableFuture.this.type

Completes this Future with the specified exception, if not already completed.

def completeWithResult (result: T): CompletableFuture.this.type

Completes this Future with the specified result, if not already completed.

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

def exception : Option[Throwable]

Returns the contained exception of this Future if it exists.

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

def finalize (): Unit

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

Creates a new Future by applying a function to the successful result of this Future, and returns the result of the function as the new Future.

val future1 = for {
  a: Int    <- actor ? "Hello" // returns 5
  b: String <- actor ? a       // returns "10"
  c: String <- actor ? 7       // returns "14"
} yield b + "-" + c

def foreach (f: (T) ⇒ Unit): Unit

def get : T

Blocks awaiting completion of this Future, then returns the resulting value, or throws the completed exception

def getClass (): java.lang.Class[_]

def hashCode (): Int

def isCompleted : Boolean

Tests whether this Future has been completed.

def isInstanceOf [T0] : Boolean

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

Creates a new Future by applying a function to the successful result of this Future.

val future1 = for {
  a: Int    <- actor ? "Hello" // returns 5
  b: String <- actor ? a       // returns "10"
  c: String <- actor ? 7       // returns "14"
} yield b + "-" + c

def mapTo [A] (implicit m: Manifest[A]): Future[A]

Creates a new Future[A] which is completed with this Future's result if that conforms to A's erased type or a ClassCastException otherwise.

def ne (arg0: AnyRef): Boolean

def notify (): Unit

def notifyAll (): Unit

def onException (pf: PartialFunction[Throwable, Unit]): CompletableFuture.this.type

When the future is completed with an exception, apply the provided PartialFunction to the exception.

  future onException {
    case NumberFormatException ⇒ target ! "wrong format"
  }

def onResult (pf: PartialFunction[T, Unit]): CompletableFuture.this.type

When the future is completed with a valid result, apply the provided PartialFunction to the result.

  future onResult {
    case Foo ⇒ target ! "foo"
    case Bar ⇒ target ! "bar"
  }

def recover [A >: T] (pf: PartialFunction[Throwable, A]): Future[A]

Creates a new Future that will handle any matching Throwable that this Future might contain.

Future(6 / 0) failure { case e: ArithmeticException ⇒ 0 } // result: 0
Future(6 / 0) failure { case e: NotFoundException   ⇒ 0 } // result: exception
Future(6 / 2) failure { case e: ArithmeticException ⇒ 0 } // result: 3

def result : Option[T]

Returns the successful result of this Future if it exists.

def resultOrException : Option[T]

Returns the current result, throws the exception is one has been raised, else returns None

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

def toString (): String

def wait (): Unit

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

def wait (arg0: Long): Unit

def collect [A] (pf: PartialFunction[T, A]): Future[A]

Creates a new Future by applying a PartialFunction to the successful result of this Future if a match is found, or else return a MatchError.

val future1 = for {
  a <- actor ? Req("Hello") collect { case Res(x: Int)    ⇒ x }
  b <- actor ? Req(a)       collect { case Res(x: String) ⇒ x }
  c <- actor ? Req(7)       collect { case Res(x: String) ⇒ x }
} yield b + "-" + c

def failure [A >: T] (pf: PartialFunction[Throwable, A]): Future[A]

Creates a new Future that will handle any matching Throwable that this Future might contain.

Future(6 / 0) failure { case e: ArithmeticException ⇒ 0 } // result: 0
Future(6 / 0) failure { case e: NotFoundException   ⇒ 0 } // result: exception
Future(6 / 2) failure { case e: ArithmeticException ⇒ 0 } // result: 3

def receive (pf: PartialFunction[Any, Unit]): CompletableFuture.this.type

When the future is completed with a valid result, apply the provided PartialFunction to the result.

  future receive {
    case Foo ⇒ target ! "foo"
    case Bar ⇒ target ! "bar"
  }