I'm confused as how to to plug a suspending function into a flow I notice the flowOf builder, but t...

# coroutines

[ursus]

I'm confused as how to to plug a suspending function into a flow

I notice the flowOf builder, but that requires value, so that means its evaluated beforehand

I'd expect something like this

flowOf {
   someSuspendFunction()
}

am I missing something, or is it left to clients to create such extension

comming from rx, I have it mapped in by brain as such

Observable.just == flowOf(value)
Observable.fromCallable == flowOf { .. }

[ephemient]

flow { emit(someSuspendFunction()) }

[ursus]

yea but thats too much crap 😄 I'd expect it in the builders file, since it has like 20 of these, but the actual 2 you would most often use, one is missing?

[ursus]

so I created the

fun <T> flowOf(action: suspend () -> T): Flow<T> {
    return flow { emit(action()) }
}

but imports get messed up if I need something like this

foo
.flatMapLatest {
    if (!it) {
        flowOf(Uninitialized)
    } else {
        my.package.name.flowOf { repository.syncDocuments() }
    }
}

[ursus]

obviously thats a naming issue but .. still odd design choice

[ephemient]

you could name it flowOf and import both, but seems like a bad idea to me, due to overload resolution

[ursus]

btw what's this one?

@FlowPreview
public fun <T> (suspend () -> T).asFlow(): Flow<T> = flow {
    emit(invoke())
}

[ursus]

{ repository.syncDocuments() }                          .asFlow()

complains Suspension functions can be called only within coroutine body

[ephemient]

type inference isn't smart enough, maybe

[ephemient]

perhaps one of

val lambda: suspend () -> Unit = { repository.syncDocuments() }
lambda.asFlow()

or repository::syncDocuments.asFlow()

[ursus]

yea function reference works but thats just a coincidence it has no params

[ephemient]

https://youtrack.jetbrains.com/issue/KT-22765

[ursus]

yea, well

[ursus]

suspend { repository.syncDocuments() }
                            .asFlow()

that suspend literal is news to me

[Adam Powell]

a one emit and close flow is better modeled as a suspend fun that returns a value instead

[ursus]

yea I know, its Flow logic, just need essentially this

observable.switchMap { single.toObservable() }

the toObservable extension

[Adam Powell]

isn't that the same as

flow.mapLatest { mySuspendFun(it) }

?

[ursus]

not sure, im new, esentially I was looking for flowOf(suspend { ...}) I never knew of the syntax

a builder function

[Arslan Armanuly]

In cases where you need flow with single object can be solved like this

foo
.flatMapLatest {
    flow {
        if (!it) {
            emit(Uninitialized)
        } else {
            emitAll(repository.syncDocuments())
        }
    }
}

[Erik]

Since you're used to Rx, you might know https://rxmarbles.com/
Likewise, there is https://flowmarbles.com/