Hi! What would be a cold equivalent of RxJava's `...

# coroutines

[dimsuz]

Hi!

What would be a cold equivalent of RxJava's Single in coroutines? for example Single.fromCallable { doNetworkRequest() } would emit only upon subscription. Should I just use Flow which calls a suspending function inside? or is this too complex?

[dimsuz]

OK, I think the

scope.launch { doNetworkRequest() }

Is actually conceptually the same as Single.fromCallable

[tseisel]

launch is hot. The conceptually closest to Single is the following :

scope.async(start = CoroutineStart.LAZY) { doNetworkRequest() }

Note that you have to call deferred.await() to trigger computation

[dimsuz]

oh, thanks. I remember reading about this construct, but for some reason I thought it must be manually started with .start() didn't know that awaiting would start it too. Missed it, it's actually mentioned in docs

[elizarov]

The closest concept to Rx Single is a simple suspending function. It would “emit” (do something) only when you call it.

[elizarov]

Don’t use flow or anything more complicated for that. All this complexity is not needed in Kotlin.

[dimsuz]

OK, so basically the solution is to delay suspending function call up until to the point where it's needed.

For example where in Rx I would return Single<> for consumers, now I return suspend fun and do this transitively through all app layers up to the point (e.g in UI) where in Rx I would call subscribe(), but now I call launch()

[elizarov]

You don’t need to “return Single” anymore. Whenever you’ve declared fun foo(): Single<T> you now declare suspend fun foo(): T which your consumers call when they need.

[elizarov]

It vastly simplifies all the code, both implementation and use-site.

[dimsuz]

That's what I meant. Tried to draw an analogy between my Rx-thinking and Coroutine thinking 🙂

[elizarov]

Indeed, subscribe gets replaced with launch. It is the correct analogy.

[dimsuz]

Thank you! So far I really like using coroutines (started learning recently hence silly questions).