Delimited Continuations

[rssh]

hi sorry for being stranger, went into surgery, now catching up with different things, I just read about multicore ml, how they use fibers to implement their single shot delimited continuation.

cats-effect, zio, monix and even kotlin coroutine and later loom have something close to fibers, do you think we can use those as a runtime for continuation, thereby have a delimited continuation system in scala, I think you already did most of the hard work.

once we have single shot delimited continuation, we can build the generators, resumable exception, effect handlers, and so forth.

I am just shooting some ideas, I could be wrong.

Originally posted by @renghen in #39 (reply in thread)

[rssh]

It's quite an interesting theme, from the other side -- I can't find a good practical use-case, because for all cases, which I trying to invent, exists analog based on monadic context. On the other side -- I'm not sure, that I fully understand continuations. I.e. is this some monad, which allows in runtime to apply effects, then how does this differ from the combination of Monad + Effect handlers embedded in some framework (like ZLayer) [?]. If not - what is the essential difference (?). Run handlers within one monad (?) i.e. decouple the definition of handlers from monad?
Maybe this is the ability to call function N-tymes (multi-shot).
From reading effekt paper: https://github.com/b-studios/scala-effekt
Effect: Capability-passing style for type- and effect-safe, extensible effect handlers in Scala I still can't understand a perfect use-case. [except typing capacities].

Maybe slow but deterministic way will try to implement from scratch continuation monad, based on
https://www.microsoft.com/en-us/research/wp-content/uploads/2005/01/jfp-revised.pdf
And in the process discover - what exactly will be the use-case and what is missing in the current monadic interfaces.

[renghen]

from my talk with Daniel on the cats effect discord channel,

IO.async (or IO.cont) is shift in scheme.

So we only need syntactic sugar on top of that.

now is my question is the async await enough ?

or do we need something more?

[rssh]

I still can't understand, what your want to build. Having a concrete example (maybe in form of pseudocode, etc, can help)

[Even if you have 'direction' instead 'goal', setting a temporary concrete goal and achieving it will give you information, necessary for understanding the area, setting the next concrete goal, and formulate a global goal].

If you want to use IO.cont, then prepare an example which should be better to write in a direct style instead cont. [But as I remember, cont is an internal function, which lives in the 'Async' interpreter].

You want to have canonical shift / reset. -- write a code example with one inside async

• what typing should be for shift()?
• are we need reset() or async will give us bounds() ? If yes - what typing will be in reset()?
• what is the relationship between the types of async() and reset()?

Starting from this we will be able to understand the concrete architecture of such construction and think about how to build one.

[renghen]

Sorry for the confusion.

My point is as follows, we have many IO effect system in scala, from those we can build continuations construct/syntax in scala.

your work have already proven we can do async/await in a very simple way to any IO effect monad.

What I want to build is a full single shot multi prompt delimited continuation using tools such as cats effect fibers, cats fibers from daniel 's explanation are continuations, and that IO.async(IO.cont) is the equivalent of a shift(which I only learned yesterday)

My question is simple then, can we using those information build a reset/shift or a continue k a la multicore ml (https://github.com/ocamllabs/ocaml-effects-tutorial)

PS Raul does point out that we do NOT need a fiber system, also fibers are already continuation in cats.

[raulraja]

@renghen I actually meant there is no need to include any kind of fiber system. A compiler plugin can desugar functions that refer to continuations without fibers by transforming async/suspended/continuation functions to an efficient state machine. something like this https://gist.github.com/raulraja/3f339c00ed4b5e25330f4e80700bf91b for two simple functions, one that is sync and another that has an async completable callback. That is decompiled from a Kotlin program with suspended functions.

[renghen]

yes, you are right I mean to say we do not need a fiber system, but typo error sorry for that. I corrected it.

[rssh]

Btw, classical examples of the delimited continuations monad are added to tests:
https://github.com/rssh/dotty-cps-async/blob/master/shared/src/test/scala/cpstest/CpsContT.scala