Cont
This construction supports
Async.cont
trait Async[F[_]] {
...
def cont[A](body: Cont[F, A]): F[A]
}
It's a low level operation meant for implementors, end users
should use
the use case.
should use
async
, start
or Deferred
instead, depending onthe use case.
It can be understood as providing an operation to resume an
asynchronously, of type
(interruptible) operation to semantically block until resumption,
of type
latter as
F
asynchronously, of type
Either[Throwable, A] => Unit
, and an(interruptible) operation to semantically block until resumption,
of type
F[A]
. We will refer to the former as resume
, and thelatter as
get
.These two operations capture the essence of semantic blocking, and
can be used to build
can be used to build
async
, which in turn can be used to buildFiber
, start
, Deferred
and so on.Refer to the default implementation to
example of usage.
Async[F].async
for anexample of usage.
The reason for the shape of the
as opposed to simply:
Cont
construction in Async[F].cont
,as opposed to simply:
trait Async[F[_]] {
...
def cont[A]: F[(Either[Throwable, A] => Unit, F[A])]
}
is that it's not safe to use concurrent operations such as
get.start
.The
to ensure that you can not call
operations up to
Cont
encoding therefore simulates higher-rank polymorphismto ensure that you can not call
start
on get
, but only useoperations up to
MonadCancel
(flatMap
, onCancel
, uncancelable
, etc).If you are an implementor, and you have an implementation of
you can override
to implement
async
but not cont
,you can override
Async[F].async
with your implementation, and use Async.defaultCont
to implement
Async[F].cont
.class Object
trait Matchable
class Any