SelfPromise

def claim : B

Claim promise or throw exception, should only be called once

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

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

def apply (): B

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

def asInstanceOf [T0] : T0

def clone (): AnyRef

def completeOption : Option[B]

Some value if promise is complete, otherwise None

def delegate : Promise[A]

def either : Promise[Either[Throwable, B]] with SelfPromise[Either[Throwable, B]] { def claim: Product with Either[Throwable,B] with Serializable }

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

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

def failed : Promise[Throwable]

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

filter still used for certain cases in for expressions

def finalize (): Unit

def flatMap [B, C, That <: Promise[C]] (f: (B) ⇒ 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: (B) ⇒ X): Promise[X]

Project any resulting exception or result into a unified type X

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

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

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

def hashCode (): Int

def isComplete : Boolean

def isInstanceOf [T0] : Boolean

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

Create a left projection of a contained either

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

Map the promised value to something else

def ne (arg0: AnyRef): Boolean

def notify (): Unit

def notifyAll (): Unit

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

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

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

def option : Promise[Option[B]]

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

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

lazy val result : Either[Throwable, B]

Internal cache of promised value or exception thrown

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

Create a right projection of a contained either

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

def timeout : Duration

def toString (): String

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

Facilitates projection over promised iterables

def wait (): Unit

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

def wait (arg0: Long): Unit

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

Support if clauses in for expressions.