We’re getting a flow of rows from the database (through r2dbc) like this: ```db.execute { ... }.asTy...

# coroutines

[Filip de Waard]

We’re getting a flow of rows from the database (through r2dbc) like this:

db.execute { ... }.asType<Foo>().fetch().flow()

Now we want to return a Map. Two ways of doing that are:

db.execute { ... }.asType<Foo>().fetch().flow().fold(mapOf()) { acc, it -> acc + (transform(it.bar) to it.baz) }

or:

db.execute { ... }.asType<Foo>().fetch().flow().map(transform(it.bar) to it.baz).toList().toMap()

Which is better and why?

[Javier]

I prefer the last one, more readable

[Filip de Waard]

is there a performance difference? e.g. due to toList?

[ephemient]

the first one is creating a new Map with every item in the flow, so the second one should be preferable from a performance standpoint too

[Filip de Waard]

thank you, @Javier and @ephemient!

[ephemient]

if you want to define your own extension, you could

suspend fun <T, K, V> Flow<T>.associate(transform: (T) -> Pair<K, V>): Map<K, V> = buildMap {
    collect {
        val (key, value) = transform(it)
        set(key, value)
    }
}

db.execute { ... }.asType<Foo>().fetch().flow().associate { transform(it.bar) to it.baz }

[Filip de Waard]

that would be more readable if we use it often, but would it also be faster?

[ephemient]

you can benchmark it yourself... but expect yes, it won't create an intermediate list

[Filip de Waard]

thanks a lot!