Louis CAD A (fixed) basic approach ;-) suspend fun awaitTrigger1 () { coroutineScope { val win = coroutineContext::cancelChildren launch { awaitAutomaticTrigger(); win( null ) } launch { awaitManualTrigger(); win( null ) } } } version with some result suspend fun awaitTrigger2 () : T = coroutineScope { val deferred = CompletableDeferred<T>() launch { deferred.complete(awaitAutomaticTrigger()) } launch { deferred.complete(awaitManualTrigger()) } deferred.await().also { coroutineContext.cancelChildren() } } https://pl.kotl.in/i1YWEs2lC https://pl.kotl.in/oQyBHb2bg

Louis CAD You're right. It crashes. Looks like the coroutineScope {...} doesn't swollow cancellation (in this particular edge case) even when explicitly asked to cancel. I find it surprising because cancellation should be cooperative.. Even stranger thing is that when I change coroutineScope { ... } to launch { ... }.join() then it starts working as I expected in the first place. Either it's a bug in coroutines or I don't quite get all guarantees in coroutines machinery.

Same example with some result (for single thread dispatcher): suspend fun awaitTrigger () : T { var t: T? = null coroutineScope { val scope = this launch { t = awaitAutomaticTrigger(); scope.cancel() } launch { t = awaitManualTrigger(); scope.cancel() } } return t!! }

Louis CAD Yes, but that's fine because the winner already finished it's work (even though winner's Job is still active).

Why not just cancel the scope when a child wins? A basic approach: suspend fun awaitTrigger () { coroutineScope { val scope = this launch { awaitAutomaticTrigger(); scope.cancel() } launch { awaitManualTrigger(); scope.cancel() } } } It should gracefully cancel all losers. Also more flexible: we can for example always wait for some specific slow child by skipping cancel invocation.