another alternative with a bit more code is https://github.com/arrow-kt/arrow/issues/1347

we are aslo missing proper kdocs for many data types and type classes that need to be documented

feel free to take a look at the sources and take on any part you see undocumented that you may be familiar with or want to learn

ask questions here and we'll help along the way

Thank you, Paco !

the main get's always stuck 🤔

unsafe runNonBlocking

I've created an issue/feedback related to thread swithing in Fx https://github.com/arrow-kt/arrow/issues/1394 related to what @raulraja and I talk about recently, please let me know if I'm assuming too much here 😅

I was assuming the same here, maybe @pakoito @simon.vergauwen @Jorge Castillo have thoughts on this ^^^ ?

I commented on the ticket, I believe the

continueOn

model is what will cause fewer assumptions

we say it with

bindIn

and the kx.coroutines framework

delay(Context) {}

may also cause confusion

In addition to continueOn, what if

ctx.effect

had a second argument which by default switches back to another context when the effect is completed?

!NonBlocking.effect(continueOn = UI) {
    foo()
}

or something similar

either that or we get rid of

ctx.effect

in favor of just continueOn

I like continueOn but I'd like even more to have a way to say run this in another thread, then come back to the current one.

I think I already suggested that not long ago

Or maybe just discussed it with @simon.vergauwen

I'm afraid you'd need to pass both contexts since there's no way to retain the current one?

I personally like

!NonBlocking.effect { ... }

for me it feels like any of the kotlin's

run, apply, etc

Me too but I think the param for the context to come back to would be required if I'm not wrong

I believe we had this discussion already, what's needed is just

fun runIn(runOn = NonBlocking, continueOn = EmptyCoroutineContext, f: suspend () -> A)

and

fun runIn(runOn = NonBlocking, continueOn = EmptyCoroutineContext, f: Kind<F, A>)

and that's just

delay(runOn) { }.continueOn(continueOn)

so it's not possible to know in which context we are and come back without telling explicitly, no?

That's what I assumed

So either you pass it as a param or as the function receiver

this works as expected

fun <F, A> ConcurrentCancellableContinuation<F, *>.runIn(
        runOn: CoroutineContext = NonBlocking,
        continueOn: CoroutineContext = EmptyCoroutineContext,
        f: suspend () -> A
): Kind<F, A> = defer(runOn) { f.effect() }.continueOn(continueOn)

(I just changed paco's delay to defer to make it work)

the usage would be

val result1 = fx {
    !effect { printCurrentThread() }
    !runIn(continueOn = Main) { printCurrentThread() }
    !effect { printCurrentThread() }
}