Deferred

abstract class Deferred[F <: ([_$1] =>> Any), A]
A purely functional synchronization primitive which represents a single value
which may not yet be available.
When created, a Deferred is empty. It can then be completed exactly once,
and never be made empty again.
get on an empty Deferred will block until the Deferred is completed.
get on a completed Deferred will always immediately return its content.
complete(a) on an empty Deferred will set it to a, and notify any and
all readers currently blocked on a call to get.
complete(a) on a Deferred that has already been completed will not modify
its content, and result in a failed F.
Albeit simple, Deferred can be used in conjunction with Ref to build
complex concurrent behaviour and data structures like queues and semaphores.
Finally, the blocking mentioned above is semantic only, no actual threads are
blocked by the implementation.
Companion
object
class Object
trait Matchable
class Any
class AsyncDeferred[F, A]

Value members

Methods

def get: F[A]
Obtains the value of the Deferred, or waits until it has been completed.
The returned value may be canceled.
def complete(a: A): F[Boolean]
If this Deferred is empty, sets the current value to a, and notifies
any and all readers currently blocked on a get. Returns true.
If this Deferred has already been completed, returns false.
Satisfies:
Deferred[F, A].flatMap(r => r.complete(a) *> r.get) == a.pure[F]
def tryGet: F[Option[A]]
Obtains the current value of the Deferred, or None if it hasn't completed.
def mapK[G <: ([_$2] =>> Any)](f: FunctionK[F, G]): Deferred[G, A]
Modify the context F using transformation f.