SelfPromise

abstract def claim: B

Claim promise or throw exception, should only be called once

abstract def replay: Promise[B]

Replay operations that produce the promised value

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

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

def apply(): B

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

final 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]]

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: (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 flatten[B](implicit pv: <:<[Promise[B], Promise[Promise[B]]]): Promise[B]

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

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

def hashCode(): Int

val http: HttpExecutor

def isComplete: Boolean

final 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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final 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

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

def toString(): String

def values[B](implicit ev: <:<[Promise[B], 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: (B) ⇒ Boolean): Promise[B]

Support if clauses in for expressions.