Convert `CoroutineContext` into `Executor`

[ZakTaccardi]

I have to use an API that accepts an Executor as a parameter. How can I create an Executor that is backed by Dispatchers.Default?

Can a CoroutineDispatcher.asExecutor(): Executor function be added to support this use case?

fun externalApi(executor: Executor)

fun example() {
  val executor: Executor = Dispatchers.Default.asExecutor()
  
  externalApi(executor)
}

Even better would be a fun CoroutineContext.asExecutor(): Executor function. I would imagine if the receiver CoroutineContext does not have a ContinuationInterceptor, this function would throw.

[elizarov]

There is no "nice" public API like that, but you can already write without resorting to any kind of experimental API:

(Dispatchers.Default as ExecutorCoroutineDispatcher).executor

The only missing piece in this story is to provide a nicer API either via asExecutor extension function or via a dedicated type like DefautCoroutineDispatcher that would be implemented by Dispatchers.Default and will expose executor property on JVM. Note, that this API is related to #261.

[zach-klippenstein]

Couldn't you implement an Executor by simply forwarding Runnables to CoroutineDispatcher.dispatch with an empty context (or maybe a special uncaught exception handler)?

Or a simpler implementation that doesn't require knowing the dispatcher contracts but has a bit more overhead could just be:

CoroutineContext.asExecutor() = object : Executor {
  private val scope = CoroutineScope(this@asExecutor)

  override fun execute(command: Runnable) {
    scope.launch { command.run() }
  }
}

[elizarov]

Ok. It's easier to implement than to discuss. See PR #1457

[ZakTaccardi]

Is it doable to use a CoroutineContext or does it have to be a CoroutineDispatcher?

[zach-klippenstein]

Any given CoroutineContext doesn't necessarily contain a dispatcher, so you'd need to provide a default dispatcher to use if the context doesn't have one (or just copy EmptyCoroutineContext semantics and always fall back to Dispatchers.Default), but what is a reasonable default probably depends a lot on your specific use case.

[ZakTaccardi]

@zach-klippenstein For my use case, it would be fine to throw if the CoroutineContext does not contain a CoroutineDispatcher. I do something like the following:

AppDispatchers(
  val main: CoroutineContext = Dispatchers.Main,
  val default: CoroutineContext = Dispatchers.Default,
  val io: CoroutineContext = Dispatchers.IO,
)

CoroutineContext is preferred over CoroutineDispatcher as a type because it allows us to do something like dispatchers.copy(default = default + CoroutineExceptionHandler { ..}) (basically just the Liskov Substituion Principle)