Callback

A Callback is a Monad for doing in-thread non-blocking operations. It is essentially a "function builder" that uses function composition to chain together a callback function that is eventually passed to another function.

Normally if you have a function that requires a callback, the function looks something like:

def doSomething(param, param, callBack: result => Unit)

and then you'd call it like

doSomething(arg1, arg2, result => println("got the result"))

This is the well-known continuation pattern, and it something we'd like to avoid due to the common occurrance of deeply nested "callback hell". Instead, the Callback allows us to define out function as

def doSomething(param1, param2): Callback[Result]

and call it like

val c = doSomething(arg1, arg2)
c.map{ result =>
  println("got the result")
}.execute()

Thus, in practice working with Callbacks is very similar to working with Futures. The big differences from a future are:

1. Callbacks are not thread safe at all. They are entirely intended to stay inside a single worker. Otherwise just use Futures.

2. The execute() method needs to be called once the callback has been fully built, which unlike futures requires some part of the code to know when a callback is ready to be invoked

Using Callbacks in Services

When building services, particularly when working with service clients, you will usually be getting Callbacks back from clients when requests are sent. *Do not call execute yourself!* on these Callbacks. They must be returned as part of request processing, and Colossus will invoke the callback itself.

Using Callbacks elsewhere

If you are using Callbacks in some custom situation outside of services, be aware that exceptions thrown inside a map or flatMap are properly caught and can be recovered using recover and recoverWith, however exceptions thrown in the "final" handler passed to execute are not caught. This is because the final block cannot be mapped on (since it is only passed when the callback is executed) and throwing the exception is preferrable to suppressing it.

Any exception that is thrown in this block is however rethrown as a CallbackExecutionException. Therefore, any "trigger" function you wrap inside a callback should properly catch this exception.

Linear Supertypes

AnyRef, Any

Known Subclasses

MappedCallback, UnmappedCallback

Abstract Value Members

abstract def execute(onComplete: (Try[O]) ⇒ Unit = _ => ()): Unit
abstract def flatMap[U](f: (O) ⇒ Callback[U]): Callback[U]
abstract def map[U](f: (O) ⇒ U): Callback[U]
abstract def mapTry[U](f: (Try[O]) ⇒ Try[U]): Callback[U]
abstract def recover[U >: O](p: PartialFunction[Throwable, U]): Callback[U]
abstract def recoverWith[U >: O](p: PartialFunction[Throwable, Callback[U]]): Callback[U]

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toFuture(implicit ex: ExecutionContext): Future[O]

Hook a future into the callback and execute the caller.
Hook a future into the callback and execute the caller. Use this if you need to hand a callback to something out-of-thread
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def withFilter(f: (O) ⇒ Boolean): Callback[O]
def zip[B, C](b: Callback[B], c: Callback[C]): Callback[(O, B, C)]
def zip[B](b: Callback[B]): Callback[(O, B)]

Related Docs: object Callback | package service

trait Callback[+O] extends AnyRef

Using Callbacks in Services

Using Callbacks elsewhere

Abstract Value Members

abstract def execute(onComplete: (Try[O]) ⇒ Unit = _ => ()): Unit

abstract def flatMap[U](f: (O) ⇒ Callback[U]): Callback[U]

abstract def map[U](f: (O) ⇒ U): Callback[U]

abstract def mapTry[U](f: (Try[O]) ⇒ Try[U]): Callback[U]

abstract def recover[U >: O](p: PartialFunction[Throwable, U]): Callback[U]

abstract def recoverWith[U >: O](p: PartialFunction[Throwable, Callback[U]]): Callback[U]

Concrete Value Members

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

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def toFuture(implicit ex: ExecutionContext): Future[O]

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def withFilter(f: (O) ⇒ Boolean): Callback[O]

def zip[B, C](b: Callback[B], c: Callback[C]): Callback[(O, B, C)]

def zip[B](b: Callback[B]): Callback[(O, B)]

Inherited from AnyRef

Inherited from Any

Ungrouped