Generators/Streams

[rssh]

• the idea of the feature: generator

  def myStream = asyncStream[Channel[T]] {
       for(i <- 1 to 10)
          emitt(i)
  }

where the stream can be any class, which has appropriative implemented typeclass.

[renghen]

We could come up with a transformation for delimited continuation, and thereby create generators and other construct out of it.

[rssh]

I was thinking in 'more local' terms.

About delimited continuations and generators: can you describe, how this will be visible from the application programmer point of view?

[renghen]

I was thinking of implementing multi prompt delimited continuation as annotations to methods/functions, which then are transformation into a functions with an implicit continuation object like in kotlin or the upcoming loom.

[rssh]

Let' s think about types:

def withoutContinuation(n:Int):Int {
     N
}

@Annotation???
def withContinuation(n:Int): ReturnType??? = Wrapper??? {
     for(i <- 1 to N)  {
        emit[???].  i
     }
}

How the second function will look in full? What will be the return type: Int or Stream[Int] or something third?
Can we write a function type? What role the annotation is played here?

Btw, It's relatively easy to implement a variant wich return stream:

   def  asyncStream[S[_],T](f:  AsyncStreamAdapter[S,T] ?=>. Unit )

but not sure, is it this can be named delimited çontinuations.

It will be possible to move forward, looking at motivation examples of usage.

[rssh]

Just understand, that the second example can't be not valid in this context, because in continuation return type is not stream emit.

So, yet one question: how the reincarnation of:

val x = reset {
   shift { k: (Int=>Int) =>
       k(k(k(7)))
    } + 1
} * 2

will look?

[renghen]

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.

[rssh]

Generators are added.

• initial implementation: https://github.com/rssh/dotty-cps-async/tree/master/shared/src/main/scala/cps/stream
• basic tests: https://github.com/rssh/dotty-cps-async/blob/master/shared/src/test/scala/cps/stream/TestFtBasicUsage.scala

Note, that the main value is not a minimal async stream supplied here [AsyncList], but integration modules with akka-streams, fs2, zio-stream which will be added to cps-async-connect.