CpsConcurrentEffectMonadInstanceContext

Spawned[A] is a computation, which is executed in own flow. (i.e. Fiber, Future, etc ..)

run op in the context environment.

join two computations in such way, that they will execute concurrently.

For effect monads it is usually the same, as pure, but unlike pure, argument of evaluation is lazy.

Note, that delay is close to original return in haskell with lazy evaluation semantics. So, for effect monads, representing pure as eager function is a simplification of semantics, real binding to monads in math sence, should be with delay instead pure

Delayed evaluation of unit. If you want to override this for you monad, you should overrid delayed to.

shortcat for delayed evaluation of effect.

Wrap and flatten of monadic expression..

transform r into pure value or error.

map over result of checked evaluation of A

synonym for flatMapTry needed for processing awaits inside mapTry.

restore fa, ie if fa sucessful - return fa, otherwise apply fx to received error.

try to evaluate async operation and wrap successful or failed result into F.

try to evaluate synchonious operation and wrap successful or failed result into F.

async shift of tryPure.

ensure that action will run before getting value from fa

async shift of withAction.

This method is substituted instead withAction, when we use await inside withAction argument.

return result of fa after completition of action.

synonim for delay

called by the source, which accept callback inside

represent error e in monadic context.

bind combinator, which compose f over fa

flatMap over result of checked evaluation of A

join the op computation: i.e. result is op which will become available after the spawned execution will be done.

map a function f over fa

Pure - wrap value t inside monad.

Note, that pure use eager evaluation, which is different from Haskell.

spawn execution of operation in own execution flow.

Send cancel signal, which can be accepted or rejected by op flow.