Whats the closest equivalent to below code using `...

# coroutines

[Pablichjenkov]

Whats the closest equivalent to below code using Flow. Or in other words the create and just operator equivalents.

Observable
		.create(
			{ emitter: Emitter<Boolean> ->
                                 // Do stuff and onNext
                        },
			Emitter.BackpressureMode.BUFFER
                  )

// Also for this 

Observable.just(true)

I am using bellow builder but wanted to see other alternatives

flow { flowCollector -> ...// Do stuff and emit }

[elizarov]

Observable.just(x)
-> flowOf(x)
Observable.create { e -> ... e.onNext(x) }
-> flow { ... emit(x) }

[elizarov]

BackpressureMode.BUFFER
-> append .buffer() operator

[Pablichjenkov]

Got you, thnks

[Paul Woitaschek]

@elizarov Wasn't that flow builder non thread safe?

[elizarov]

Indeed, it is not thread-safe. If “do stuff” is doing something across threads, then:
Observable.create({ e -> ... e.onNext(x) }, BUFFERED)
-> callbackFlow { ... offer(x) }

[elizarov]

(callbackFlow is buffered by default)

[Paul Woitaschek]

Maybe it should be called nonThreadSafeFlow instead of flow 😉

[elizarov]

This is oxymoron. Flow is a sequential, not a thread-safe primitive by design.

[elizarov]

For thread-safety and communication between coroutines we have a Channel

[elizarov]

To make this difference absolutely explicit we even have different method names. Flow -> emit, Channel -> `send`/`offer`.

[Paul Woitaschek]

What does this thread safety mean in the context of coroutines? emit says This method is not thread-safe and should not be invoked concurrently.

[Paul Woitaschek]

This is correct: flow<Int> { emitAll(flowOf(1, 2, 3)) }
And this isnt?

flow<Int> {
        coroutineScope {
          launch { emitAll(flowOf(1, 2, 3)) }
          launch { emitAll(flowOf(1, 2, 3)) }
        }

[gildor]

Yes, second is incorrect

[Pablichjenkov]

Good point @Paul Woitaschek. Then calling flow.emitt() from multiple threads does not garantee the events get pipelined? Is that correct?
Unless the flow is backed up by a channel?