hi everyone, I am trying to use the `produce` method to create a channel inside a suspending method ...

# coroutines

[fabiocollini]

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?

[gildor]

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

[fabiocollini]

thanks, I’ll open an issue there as well

[gildor]

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

[fabiocollini]

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

[fabiocollini]

and I want to use the non deprecated version of produce method defined in CoroutineScope

[gildor]

Oh, I see, new produce

[gildor]

Not sure why itt doesn’t emit events, but instead you should pass scope there to connect to existing coroutine scope

[gildor]

or create CoroutineScope using parent context:
CoroutineScope(coroutineContext)
nope, this doesn’t work

[fabiocollini]

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

[gildor]

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

[fabiocollini]

are you sure? Isn’t the coroutineScope method another valid way of doing it?

[kingsley]

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

[fabiocollini]

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

[fabiocollini]

I wasn’t aware of that syntax, thanks for pointing it out 🙂

[fabiocollini]

however I still think that the two methods should do the same thing

[gildor]

Yeah, Kingsley right, this is because produce coroutineScope suspended

[gildor]

No, they do not do the same in this case, because now coroutineScope alwys waits for child coroutine

[gildor]

We need extension functions with multiple receivers!

[gildor]

Also, see this comment:
https://kotlinlang.slack.com/archives/C1CFAFJSK/p1538030491000100?thread_ts=1538026229.000100&cid=C1CFAFJSK

[fabiocollini]

ok, I haven’t read that comment

[fabiocollini]

so, probably I can use the with method until they define the integration of channels with structured concurrency