A modern programming language that makes developers happier.

kotlinlang

Can someone point me in the direction about some info about `Unconfined` &amp; `EmptyCoroutineContext` ?

What are you interested in? `Unconfined` is explained in KDoc and `EmptyCoroutineContext` is self-describing

I have a stack of bunch of cancel tasks, ~ `typealias CancelToken = suspend () -&gt; Unit`. i.e. to unregister callbacks.

On cancellation I want to basically fire and forgot them. They should all run in parallel, since in sequence a never terminating `CancelToken` might blocks others which would cause leaks.

```
typealias CancelToken = suspend () -&gt; Unit

fun main(args: Array&lt;String&gt;) {
  val stack = listOf&lt;CancelToken&gt;(
    { delay(10000000000) }, //blocks forever
    {
      delay(100)
      println("I cancelled first token: ${Thread.currentThread().name}")
    },
    {
      delay(200)
      println("I cancelled second token: ${Thread.currentThread().name}")
    }
  )

  stack.forEach { token -&gt;
    token.startCoroutine(RunAndForgetContinuation())
  }

}

class RunAndForgetContinuation&lt;A&gt; : Continuation&lt;A&gt; {
  override val context: CoroutineContext
    get() = EmptyCoroutineContext

  override fun resumeWith(result: Result&lt;A&gt;) = Unit
}
```

If I understand the self-describing name `EmptyCoroutineContext` correctly then I can use it to launch a coroutine from any context I am currently in.

I believe that is correct. Child jobs inherit the context from their parent, and adding `EmptyCoroutineContext` to an existing context will result in the same context.

so when using `fun (suspend () -&gt; Unit).startCoroutine` with `EmptyCoroutineContext` it forks with the context that is inherited?

I can only point to <https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.coroutines.experimental/-empty-coroutine-context/index.html>

But if you look at the source code of the `plus` operator you’ll see the behaviour

I’m not sure how your `startCoroutine` will work. To run your block you’d need a scope to begin with, which is attached to a context

`startCoroutine` allows me to run a `suspend` function with a continuation that I run on a context. In this case `EmptyCoroutineContext`. <https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.coroutines.experimental/start-coroutine.html>

Probably beyond my scope to help here.

Some more info on context can be found in the KEEP:

<https://github.com/Kotlin/KEEP/blob/master/proposals/coroutines.md#coroutine-context>