hi everyone, I am trying to use the

produce

method to create a channel inside a suspending method but I have some problems. I have a different behaviour defining my method as

CoroutineScope

extension method and using

coroutineScope

inside a suspending method. These are the two versions:

private fun CoroutineScope.produceExtension(): ReceiveChannel<Int> = produce {
    send(1)
    send(2)
    send(3)
}

private suspend fun produceCoroutineScope(): ReceiveChannel<Int> = coroutineScope {
    produce {
        send(1)
        send(2)
        send(3)
    }
}
`

Using the second method I am not able to use the channel (the method never ends), I have already opened an issue with the complete code here https://github.com/Kotlin/kotlinx.coroutines/issues/645 Am I doing something wrong? Should the two methods be equivalent?

Better report to kotlinx.coroutines repo https://github.com/Kotlin/kotlinx.coroutines/issues

thanks, I’ll open an issue there as well

Why do you use suspend function and why do you need coroutineScope in this case?

it’s because I’d like to define that method in another class so I can’t define it as extension function

Oh, I see, new produce

you are right, passing the scope as parameter works but I’d like to avoid passing it on all the methods

But this is the way how you cannect async code to your scope

are you sure? Isn’t the

coroutineScope

method another valid way of doing it?

The second doesn’t work as expected probably because

coroutineScope

will suspend until the producer is closed, which doesn’t happen in this example 🤔 Anyway though, you could define it as extension function in another class and execute like so:

with(anotherClassInstance) {
  produceExtension()
}

assuming this is already within a coroutine scope

even adding a

close

invocation I have the same problem (and I’d like to consume the values before the channel is closed)

Yeah, Kingsley right, this is because produce coroutineScope suspended

ok, I haven’t read that comment