AsyncCallback

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply[A](f: ((Try[A]) ⇒ Callback) ⇒ Callback): AsyncCallback[A]

final def asInstanceOf[T0]: T0

implicit def asyncCallbackCovariance[A, B >: A](c: AsyncCallback[A]): AsyncCallback[B]

def byName[A](f: ⇒ AsyncCallback[A]): AsyncCallback[A]

Callback that is recreated each time it is used.

def clone(): AnyRef

def const[A](t: Try[A]): AsyncCallback[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def first[A](f: ((Try[A]) ⇒ Callback) ⇒ Callback): AsyncCallback[A]

def fromCallbackToFuture[A](c: CallbackTo[Future[A]])(implicit ec: ExecutionContext): AsyncCallback[A]

def fromCallbackToJsPromise[A](c: CallbackTo[Promise[A]]): AsyncCallback[A]

def fromFuture[A](fa: ⇒ Future[A])(implicit ec: ExecutionContext): AsyncCallback[A]

def fromJsPromise[A](pa: ⇒ Thenable[A]): AsyncCallback[A]

final def getClass(): Class[_]

def hashCode(): Int

def init[A, B](f: ((Try[B]) ⇒ Callback) ⇒ CallbackTo[A]): CallbackTo[(A, AsyncCallback[B])]

final def isInstanceOf[T0]: Boolean

def lazily[A](f: ⇒ AsyncCallback[A]): AsyncCallback[A]

Callback that isn't created until the first time it is used, after which it is reused.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def point[A](a: ⇒ A): AsyncCallback[A]

def promise[A]: CallbackTo[(AsyncCallback[A], (Try[A]) ⇒ Callback)]

Create an AsyncCallback and separately provide the completion function.

def pure[A](a: A): AsyncCallback[A]

def sequence[T[X] <: TraversableOnce[X], A](tca: ⇒ T[AsyncCallback[A]])(implicit cbf: CanBuildFrom[T[AsyncCallback[A]], A, T[A]]): AsyncCallback[T[A]]

Sequence stdlib T over AsyncCallback.

def sequenceOption[A](oca: ⇒ Option[AsyncCallback[A]]): AsyncCallback[Option[A]]

Sequence Option over AsyncCallback.

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

def tailrec[A, B](a: A)(f: (A) ⇒ AsyncCallback[Either[A, B]]): AsyncCallback[B]

Not literally tail-recursive because AsyncCallback is continuation-based, but this utility in this shape may still be useful.

def throwException[A](t: Throwable): AsyncCallback[A]

def toString(): String

def traverse[T[X] <: TraversableOnce[X], A, B](ta: ⇒ T[A])(f: (A) ⇒ AsyncCallback[B])(implicit cbf: CanBuildFrom[T[A], B, T[B]]): AsyncCallback[T[B]]

Traverse stdlib T over AsyncCallback.

def traverseOption[A, B](oa: ⇒ Option[A])(f: (A) ⇒ AsyncCallback[B]): AsyncCallback[Option[B]]

Traverse Option over AsyncCallback.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def fromCallback[A](c: CallbackTo[A]): AsyncCallback[A]