More convenient direct syntax

[fwbrasil]

I've been considering ways to make the direct syntax more convenient but with a smaller scope than #211. The integration with dotty-cps-async is working well but it'd be nice if we had a way to avoid the need for await calls. Currently, code using the direct syntax looks like this:

import kyo.*

val a: String < IO =
    defer {
        val a: String = await(IO("hello"))
        val b: String = await(IO("world"))
        a + " " + b
    }

To avoid the need for await, we could have wrappers of Kyo's regular APIs using transparent inline to automatically insert the necessary awaits. Each API would have a counterpart in a kyo.direct package. Example for IO:

package kyo.direct

// Interop with the regular monadic APIs via a type bound
opaque type IO <: kyo.IO = kyo.IO

object IO:
    transparent inline def apply[A, S](inline f: => A)(using Frame): A = await(kyo.IO(f))

Users would then import kyo.direct.* instead of import kyo.*, which wouldn't require explicit awaits:

import kyo.direct.*

val a: String < IO =
    defer {
        val a: String = IO("hello")
        val b: String = IO("world")
        a + " " + b
    }

We might hit limitations but my initial tests indicate it's a viable approach.

If we decide to proceed, I think we could merge kyo-direct into kyo-prelude so the direct wrappers stay in the same module as their monadic APIs. Another option is having separate modules like kyo-prelude-direct and kyo-core-direct but I think it'd make maintenance harder and we might end up with too many modules.

cc/ @rssh

[fwbrasil]

I've prepared a prototype to explore the idea: https://gist.github.com/fwbrasil/bc8e27aeaf7c0c992b0d103638a71b90

It's possible to execute it with:

scala-cli https://gist.github.com/fwbrasil/bc8e27aeaf7c0c992b0d103638a71b90

[rssh]

It is possible to call. IO("hello") outside defer brackets?
If not - it means that we will have two completely different API for sync and async part.

[fwbrasil]

If not - it means that we will have two completely different API for sync and async part.

Yes, the idea is to have wrapper APIs via transparent inline in a different package. In Kyo's context, it's not about sync/async but efffectful/non-effectful since the pending type can express an unbounded number of effects, not only async.

[fwbrasil]

The mix of code that requires await with code that doesn't require await is too confusing. Closing.