A question about ArrowEffect#handle and introducing new effects

[toonvanacker]

Hello all,

I am slowly reading through the Kyo source code. I'm trying to fully understand the project because it sparked my interest. I came across ArrowEffect#handle, of which the documentation says:

This is the basic form of effect handling where each effect occurrence is processed independently. Unlike handleLoop, handle does not allow introducing new effects during the handling process (no S2 type parameter), making it more restrictive but simpler for basic transformations.

I am a bit confused about the claim that no new effects may be introduced during the handling process, because the ArrowEffect#handle does in fact have an S2 type parameter and as far as I understand the type signature seems to imply that introducing a new effect is allowed. I may be mistaken, since I'm still learning Scala, hence my question:

Is this me misunderstanding how this function works? If so, could some give me a hint as to why this does not allow introducing new effects?

Thanks in advance!
Toon

[johnhungerford]

@fwbrasil can you answer this? It does look like you can introduce new effects.

[fwbrasil]

Thank you for the ping @johnhungerford!

Yes, the scaladoc is incorrect. handle does allow introducing new effects but it has an important restriction: it's not possible to introduce new suspensions of the same effect that is being handled. Given that it recurses until all suspensions of the effect are handled, it'll just recurse indefinitely in case the handling introduces a suspension of the same effect. handle is enough for the majority of the effects but there are cases where it's necessary to suspend the same effect again.

A good example is stream.filter. It handles the stream and needs to emit elements of the same type again if they pass the filter:

def filter[VV >: V, S2](f: VV => Boolean < S2)(using tag: Tag[Emit[Chunk[VV]]], frame: Frame): Stream[VV, S & S2] =
    Stream(
        ArrowEffect.handleLoop(tag, emit)(
            [C] =>
                (input, cont) =>
                    Kyo.filter(input)(f).map { c =>
                        if c.isEmpty then Loop.continue(cont(()))
                        else Emit.valueWith(c)(Loop.continue(cont(())))
                }
        )
    )

Note how it's possible to first re-emit the current Chunk (Emit.valueWith(c)), which will need to be handled in an outer scope, and then resume the handling (Loop.continue(cont(()))).

As a side note, in Kyo we use a naming pattern where methods with the With suffix take a continuation function. Emit.valueWith(c)(Loop.continue(cont(()))) is equivalent to Emit.value(c).map(_ => Loop.continue(cont(()))) or Emit.value(c).andThen(Loop.continue(cont(())))

@toonvanacker would you mind creating an issue or PR for this? Thank you for the question 🙏

[toonvanacker]

Hello Flavio, thank you for the clear answer! I'll make an issue and a PR for this. It may take until the weekend, but I will get to it!