I've got a list maps, and I'd like to merge them i...

# functional

[reactormonk]

I've got a list maps, and I'd like to merge them into a single map, with a value merge function. Is there one such a collection operation?

[ephemient]

on JVM you could make use of https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#merge-K-V-java.util.function.BiFunction-

[ephemient]

sticking to pure Kotlin I don't think there's anything simple built-in, but you could

buildMap {
    for (map in listOfMaps) {
        map.mapValuesTo(this) { (key, value) ->
            if (contains(key)) mergeValues(getValue(key), value) else value
        }
    }
}

[reactormonk]

This is what I came up with:

CardMessageLinksDto(it.fold(mapOf<Uuid, CardMessageLinkDto>()) { acc, links ->
                    links.cardMessageLinks.fold(acc) { newLinks, link ->
                        val current = newLinks[link.uuid]
                        if (current != null) {
                            if (current.updated != null
                                && link.updated != null
                                && <http://current.updated.at|current.updated.at> < <http://link.updated.at|link.updated.at>) {
                                newLinks + (link.uuid to link)
                            } else
                            newLinks
                        } else {
                            newLinks + (link.uuid to link)
                        }
                    }
                }.values.toList())

[ephemient]

I suppose

listOfMaps.asSequence()
    .flatMap { it.entries }
    .groupingBy { it.key }
    .aggregate { _, acc, (_, value), first -> if (first) value else mergeValues(acc, value) }

could look a bit more functional

[Shawn]

funny enough, I think the Java stream API is much more ergonomic (and efficient) here than anything included in the Kotlin stdlib

mapList.stream()
        .flatMap(it -> it.entrySet().stream())
        .collect(toMap(
                Map.Entry::getKey,
                Map.Entry::getValue,
                Foo::mergingFunction));

[ephemient]

I suppose that if you didn't mind some extra intermediates

listOfMaps
    .flatMap { it.entries }
    .groupBy { it.key }
    .mapValues { entries ->
        val values = entries.map { it.value }
        values.reduce { value1, value2 -> mergeValues(value1, value2) }
    }

is pretty readable. and still O(N) in total entries as opposed to reactormonk's map + pair solution turning an O(N) problem into an O(N^2) solution