If I create a new coroutine context and use `withC...

# coroutines

[Derek Berner]

If I create a new coroutine context and use withContext to launch a bunch of `Job`s in that context, does that mean I don't have to explicitly join all those jobs at the end of the block?

[dekans]

Yes, withContext() {...} is a CoroutineScope, it will persist until all its children are done.

[Derek Berner]

All right. This is starting to coalesce for me here. I think I was leaning too heavily on the `async`/`await` style of invocation in JS land.

[Derek Berner]

Is this a good tree to be barking up, or does this functionality already exist within kotlinx.coroutines?

[bdawg.io]

I'm kind of confused by
1) GlobalScope.launch when you're already inside of a CoroutineScope
2) .launch(content) and then immediately doing withContext using the same exact context. launch is already a CoroutineScope. No need to immediately open a nested one

[Derek Berner]

I'm a bit confused by coroutines in general... 😓

[Derek Berner]

So that's the result of a lot of trial and error, some stuff is there from previous attempts

[Derek Berner]

GlobalScope.launch makes it run as a daemon, right? So if a rogue consumer doesn't finish consuming, it won't block the runtime from exiting

[Derek Berner]

CoroutineScope receiver was part of an earlier attempt that I haven't gotten around to cleaning up

[Derek Berner]

And then withContext... I think I was originally thinking I needed to wait around for all those `launch`es to finish so I could do some cleanup

[bdawg.io]

launch {
    launch { delay(100) }
    launch { delay(200) }
    launch { delay(300) }
}

That top-level job doesn't complete until all of the children jobs complete too

[bdawg.io]

GlobalScope just removes it from being properly tracked by structured hierarchy. If the JVM runtime exits, all GlobalScope jobs will cancel too

[Derek Berner]

So something like...

interface TriplexChannel<I, out O> : SendChannel<I>, ReceiveChannel<O>, Closeable {
    data class Error<I>(val input: I, val error: Throwable)

    val errors: ReceiveChannel<Error<I>>
}

@ExperimentalCoroutinesApi
@UseExperimental(ExperimentalTypeInference::class)
fun <I, O> CoroutineScope.triplex(
    context: CoroutineContext = EmptyCoroutineContext,
    capacity: Int = Channel.RENDEZVOUS,
    capacityOut: Int = capacity,
    capacityErrors: Int = capacity,
    @BuilderInference block: suspend SendChannel<O>.(I) -> Unit
): TriplexChannel<I, O> {
    val channelIn = Channel<I>(capacity)
    val channelOut = Channel<O>(capacityOut)
    val channelErrors = Channel<TriplexChannel.Error<I>>(capacityErrors)

    launch(context) {
        for (value in channelIn) {
            launch {
                try {
                    channelOut.block(value)
                } catch (e: Throwable) {
                    when (e) {
                        is Error -> throw e
                        else -> channelErrors.send(TriplexChannel.Error(value, e))
                    }
                }
            }
        }
    }.invokeOnCompletion { e ->
        when(e) {
            null -> {
                channelOut.close()
                channelErrors.close()
            }
            else -> {
                launch { channelIn.close(e) }
                launch { channelOut.close(e) }
                launch { channelErrors.close(e) }
            }
        }
    }

    return object : TriplexChannel<I, O>, 
        SendChannel<I> by channelIn, 
        ReceiveChannel<O> by channelOut,
        Closeable
    {
        override val errors = channelErrors
        override fun close() {
            launch {
                channelIn.close()
            }
        }
    }
}

[Derek Berner]

That still relies on the caller to close the channel but at least kotlin provides use

[Derek Berner]

GlobalScope.triplex works too now that I think about it.