FutureBase

abstract def flatMap[S](f: (T) ⇒ Future[S]): Future[S]

abstract def handle[U >: T](pf: PartialFunction[Throwable, U]): Future[U]

abstract def handleWith[U >: T](pf: PartialFunction[Throwable, Future[U]]): Future[U]

Creates a new future that will handle any matching throwable that this future might contain by assigning it a value of another future.

val f = future { Int.MaxValue }
future (6 / 0) handle { case e: ArithmeticException => f } // result: Int.MaxValue

abstract def map[S](f: (T) ⇒ S): Future[S]

abstract def onComplete[U](func: (Try[T]) ⇒ U): Unit

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flatMapSuccess[A, B](p: Promise[B], f: (A) ⇒ Future[B], value: A): Unit

final def getClass(): Class[_]

def handleFailure[U >: T](p: Promise[U], pf: PartialFunction[Throwable, U], t: Throwable): Unit

def handleWithFailure[U >: T](p: Promise[U], pf: PartialFunction[Throwable, Future[U]], t: Throwable): Any

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def mapSuccess[A, B](promise: Promise[B], f: (A) ⇒ B, value: A): Unit

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit