Hi guys, the stdlib

fun List<Pair<K,V>>.toMap()

drops duplicate entries without providing a way to merge them. Is there a stdlib function that can do this? I often need this when dealing with maps containing quantities. I implement it this way:

fun <K, V> List<Pair<K, V>>.toMap(combine: (V, V) -> V?): Map<K, V> {
    val result = mutableMapOf<K, V>()
    for ((k, v) in this) {
        result.merge(k, v, combine)
    }
    return result
}

Another one I'm missing is merging 2 maps provided a function to recombine the values of keys that are present in both maps.

groupBy

But

groupBy

only groups values in lists, it doesn't

reduce

these lists, so it is still quite cumbersome to use it:

fun <K, V> List<Pair<K, V>>.toMap(combine: (V, V) -> V): Map<K, V> =
        groupBy({ it.first }, { it.second})
        .mapValues { it.value.reduce { v1, v2 -> combine(v1, v2) } }

Or am I missing something here?

merge functions do indeed not exist (yet). I had this problem before: https://discuss.kotlinlang.org/t/associate-associateby-merge-strategy-default/2849

Nice thread, and nice point you raised then, thanks for the link! However, I'm not asking for a change in `toMap()`'s default. I'm just asking for another stdlib function, like an overload of

toMap()

to actually allow the users to avoid reimplementing a mix of

groupBy

+

reduce

for such a common use case. The critical point here is: is that a really common use case, or am I the only one who needs to merge things? Also, seeing this overload in the autocomplete would probably make the users think of "Oh yeah, what if there are duplicates?"

I completely agree btw, seems like more people are having our problem

I find Kotlin so nice to read in general, I'm just sad this use case needs to let multiple operations surface in user code, when what we want to express is a single concept/step.

Int was an example, you'd ofcourse use V?. But groupingBy in general is better performance in general over groupBy. groupBy makes a map immediatly where you would map values (reducing a list to a singular value). groupingBy with a collector would do exactly would you want: merge only on the two given values

Indeed, altough

groupingBy

still creates an intermediate

Grouping

instance, but I have to admit it's already better. Anyway, I can also express the initial function directly with the following:

fun <K, V> List<Pair<K, V>>.toMap(combine: (V, V) -> V?): Map<K, V> =
        fold(mutableMapOf<K, V>()) { m, p -> m.merge(p.first, p.second, combine); m }

Using

fold

directly solves the problem of intermediate stuff, but it's still a bit overkill, because reading that is not very nice to my eye 🙂

That's also possible. Only addition I would propose is to make your function for an Iterable, instead of a list, so it would work with other collections

Yes of course, that would be better. Anyway, thanks for taking the time to discuss it with me, I wish there were direct support for this in the stdlib. I don't know if such additions should be discussed here, or in the forum, or if people usually directly create formal KEEPs

There's #language-evolution for general discussion and #language-proposals for discussing a KEEP. So perhaps start in #language-evolution and get a feel for what people in that group think/suggest. For now, obviously you can create your function as an extension so until (if) it appears in the stdlib, at least you have a nice name for it.

Thanks a lot