A modern programming language that makes developers happier.

kotlinlang

```class ProduceStateScopeImpl&lt;T&gt;(
    state: MutableState&lt;T&gt;,
    override val coroutineContext: CoroutineContext
) : ProduceStateScope&lt;T&gt;, MutableState&lt;T&gt; by state {

    override suspend fun awaitDispose(onDispose: () -&gt; Unit): Nothing {
        try {
            suspendCancellableCoroutine&lt;Nothing&gt; { }
        } finally {
            onDispose()
        }
    }
}```
Why `suspendCancellableCoroutine&lt;Nothing&gt; { }` is being executed?

Presumably because something is calling `awaitDispose`?

Also this question has nothing to do with compose, did you mean to post in <#C1CFAFJSK|coroutines> ?

It's a class from compose-runtime :slightly_smiling_face:

It's the same basic pattern from `channelFlow`'s `awaitClose`

I will try to find out more about this, because it isn't clear to me

Can you elaborate on your question a bit? Why would you expect `suspendCancellableCoroutine` not to be executed?

when i saw the empty block i thought that nothing occurs

but of course the cancellation occurs anyway

```public suspend inline fun &lt;T&gt; suspendCancellableCoroutine(
    crossinline block: (CancellableContinuation&lt;T&gt;) -&gt; Unit
): T =
    suspendCoroutineUninterceptedOrReturn { uCont -&gt;
        val cancellable = CancellableContinuationImpl(uCont.intercepted(), resumeMode = MODE_CANCELLABLE)
        /*
         * For non-atomic cancellation we setup parent-child relationship immediately
         * in case when `block` blocks the current thread (e.g. Rx2 with trampoline scheduler), but
         * properly supports cancellation.
         */
        cancellable.initCancellability()
        block(cancellable)
        cancellable.getResult()
    }```


I was expecting a `coroutineContext.cancel ()` or something like that :sweat_smile:

Ah, yeah that happens when the underlying LaunchedEffect restarts for a new key or leaves the composition :slightly_smiling_face:

there are a new function in the kotlinx.coroutines a little more idiomatic, `awaitCancellation()`

```/**
 * Suspends until cancellation, in which case it will throw a [CancellationException].
 *
 * This function returns [Nothing], so it can be used in any coroutine,
 * regardless of the required return type.
 */
public suspend fun awaitCancellation(): Nothing = suspendCancellableCoroutine {}```

is the same implementation, no surprises :laughing:

Yep, we added the `awaitDispose` scoped method before `awaitCancellation` came in :slightly_smiling_face: