cps

AsynsShift is a marker base trait for typeclass, which provides 'shifted' variants of the hight-order methods of T, which called when we need to pass a cps-transformed function as an argument for this method.

The general convention is next:

• Let us have object O and method m(f: A=>B):R which accept hight-order argument f: A=>B. (for example - map in List).
• If we want to defined transformation of argument for any monad F, we should define the AsyncShift[O] with method m[F[_],...](o:O, m:CpsMonad[F])(f: A=>F[B]).
• Return type of this method can be F[R] or R or AsyncSubst[R].

Also we should define a given instance of AsyncShift[O], visible from our async block. I.e. implementation for our list will look as:

   class MyShiftedList[T] extentds AsyncShift[List[T]] {

     def map[F[_],S](m:CpsMonad[M], c:List[T])(f: T=>F[S]): F[List[T]] =
         ... // implementation here

   }

   transparent inline given myShiftedList[T]: AsyncShift[List[T]] = MyShiftedList[T]()

After this, you can freely use awaits inside "List.map":

  async {
    ....
    val fetched = uris.map(uri => await(fetch(uri)))
    ...
  }

see https://rssh.github.io/dotty-cps-async/HighOrderFunctions.html

Companion object where defined given AsyncShift instances for Scala standard library objects.

Marker interface for forcing monad evaluation before discard. Useful for pure effect monads. AwaitValueDiscard[F,T].apply(ft) is transformed to await(ft) during evaluation of async macro.

Async Effect Monad

Monad, which is compatible with passing data via callbacks.

Interoperability with Future: allows

   async[F]{ .. await[Future](..) ... }

Marker typeclass for wrappers, which we can await. Such traits can be not monads itself (for example, its impossible to set monad structure over js.Promise) but can be convertable into cps monads.

Marker trait for concurrent effect monads.

Monad, where we can define an effect of starting operation in different execution flow.

Base trait of CpsContextMonad which provide Ctx as a monad context Mixin this trait into your CosMonad in cases, when you monad have internal API and you potentially want to use moand context as generic type.

Marker trait, which mark effect monad, where actual evaluation of expression happens after building a monad, during effect evaluation stage.

evaluation of expression inside async block always delayed.

Marker class which mean that CpsRuntimeAwait implemented in such way, that performance penalty in comparison with cps run is relative low and we can not to use cps transformation in async block for such monad.

Basic CpsMonad operations. Implementing this typeclass is enough to use async/await with supports of basic control-flow constructions (if, loops, but no exceptions).

Base for context operations inside monad

CpsMonadConversion -- conversion from F[_] to G[_]. If the given instance of such morphism exists, then await[F] can be used inside async[G]

Trait for minimal monad context, which provides an instance of CpsMonad. Mixin this trait into your monad in cases, when you monad have no internal API.

How this monad can be memoized.

see chapter in User Guide

marker trait for context with NOOP intercaprAwait operation

When this typeclass is implemented for a monad F, dotty-cps-async can use runtime await invocations for handling of high-order functions when shifted variants are not available.

Monad, where we can spawn some event and be sure that one be evaluated, event if we drop result.

Interoperability with Future: allows

  async[Future]{
     ...
     await[F](..)
     ...
  }

If you monad supports this typeclass, than you can use try/catch/finally inside await.

When cps.customValueDiscard is on, value can be discarded only for types T for which exists ValueDiscard[T]

see chapter in User Guide

marker object for value discarding. When this object is imported into current scope, then discarding values inside async block is translated to summon[ValueDiscard[T]].apply()

marker object for enabling warning about discarding non-primitve values without custom discard.

async block, which can contains awaits. better look on this as the first part of the next signature:

  async[F](using CpsMonad[F])[T](inline body:T):F[T]

i.e. async return a transitional object, which accepts body and perform async transform with the given CpsMonad[F].

Generator syntax. usage:

val s = asyncStream[fs.Stream[IO,Int]] { out =>
  for(i <- 1 to N) out.emit(i)
}

Pseudofunction, which can be used inside async block, to 'await' (i.e. receive value of t:T from ft:F[T]).

marker object for value discarding. When this object is imported into current scope, then discarding values inside async block is translated to summon[ValueDiscard[T]].apply()

marker object for enabling warning about discarding non-primitve values without custom discard.