Promise

abstract def addListener(f: () ⇒ Unit): Unit

Listener to be called in an executor when promise is available

abstract def claim: A

Claim promise or throw exception, should only be called once

abstract def isComplete: Boolean

True if promised value is available

abstract def timeout: Duration

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def apply(): A

Blocks until promised value is available, returns promised value or throws ExecutionException.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def completeOption: Option[A]

Some value if promise is complete, otherwise None

def either: Promise[Either[Throwable, A]] with SelfPromise[Either[Throwable, A]] { def claim: Product with Serializable with scala.util.Either[Throwable,A] }

Project promised value into an either containing the value or any exception thrown retrieving it.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def failed: Promise[Throwable]

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

filter still used for certain cases in for expressions

def finalize(): Unit

def flatMap[B, C, That <: Promise[C]](f: (A) ⇒ B)(implicit guarantor: Guarantor[B, C, That]): Promise[C]

Bind this Promise to another Promise, or something which an implicit Guarantor may convert to a Promise.

def fold[X](fa: (Throwable) ⇒ X, fb: (A) ⇒ X): Promise[X]

Project any resulting exception or result into a unified type X

def foreach[U](f: (A) ⇒ U): Unit

Cause some side effect with the promised value, if it is produced with no exception

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def left[B, C](implicit ev: <:<[Promise[A], Promise[Either[B, C]]]): LeftProjection[B, C]

Create a left projection of a contained either

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

Map the promised value to something else

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onComplete[U](f: (Either[Throwable, A]) ⇒ U): Promise[A]

def onFailure[U](f: PartialFunction[Throwable, U]): Promise[A]

def onSuccess[U](f: PartialFunction[A, U]): Promise[A]

def option: Promise[Option[A]]

Project promised value into an Option containing the value if retrived with no exception

def recover[B >: A](f: PartialFunction[Throwable, B]): Promise[B]

lazy val result: Either[Throwable, A]

Internal cache of promised value or exception thrown

def right[B, C](implicit ev: <:<[Promise[A], Promise[Either[B, C]]]): RightProjection[B, C]

Create a right projection of a contained either

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

def toString(): String

def values[B](implicit ev: <:<[Promise[A], Promise[Iterable[B]]]): Values[B]

Facilitates projection over promised iterables

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

Support if clauses in for expressions.