How to implement this kotlin ReceiveChannel code properly - kotlin

Question

I am following a tutorial where the teacher uses the ProducerJob method to demonstrate kotlin coroutine but my IDE says that method is deprecated and I should use ReceiveChannel instead but that also says I should use a extensions on the coroutinescope instead but I can seem to be unable to implement that correctly.
Here the instructor's code:
fun produceNumbers() : ProducerJob<Int> = produce {
for (x in 1..5) {
println("send $x")
send(x)
}
println("Done")
}
fun main() = runBlocking{
val channel = produceNumbers()
channel.consumeEach {
println(it)
}
println("Main done")
}
And here is my code:
fun produceNumbers() : ReceiveChannel<Int> = produce {
for (x in 1..5) {
println("send $x")
send(x)
}
println("Done")
}
fun main() = runBlocking{
val channel = produceNumbers()
channel.consumeEach {
println(it)
}
println("Main done")
}
Does your code compile: Yes
Version: kotlinx-coroutines-core-0.27.0.eap13

Answer 1

The reason why it is recommended to declare your function as extension of CoroutineScope is that you need a scope for any coroutine-creating built-in function anyway. You should not be able to call produce without a scope, it should not compile in recent versions of Kotlin coroutines library.
Declaring your function as extension of CoroutineScope is done this way:
fun CoroutineScope.produceNumbers() : ReceiveChannel<Int> = produce {
for (x in 1..5) {
println("send $x")
send(x)
}
println("Done")
}
If you are not using it in an extension of CoroutineScope then you'll need to either provide a scope another way (like a field of an enclosing class, or method param), or use the GlobalScope, both of which are not recommended. The extension-based version above is a pattern that is recognizable and intuitive for coroutine users.
A more "reactive" approach would be using flows instead of channels:
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun produceNumbers() : Flow<Int> = flow {
for (x in 1..5) {
println("emit $x")
emit(x)
}
println("Done")
}
fun main() = runBlocking {
val flow = produceNumbers()
flow.collect {
println(it)
}
println("Main done")
}
Note that this will behave differently though, as it wont be started in a concurrent coroutine unless explicitly stated (e.g. using
flowOn(Dispatchers.Default)
, or replacing the flow {...} by a channelFlow {...}.