Merge two maps with custom reduce function for Kotlin

merge-maps.kt

private fun <K, V> Map<K, V>.mergeReduce(other: Map<K, V>, reduce: (V, V) -> V = { a, b -> b }): Map<K, V> {
    val result = LinkedHashMap<K, V>(this.size() + other.size())
    result.putAll(this)
    other.forEach { e ->
        val existing = result[e.key]

        if (existing == null) {
            result[e.key] = e.value
        }
        else {
            result[e.key] = reduce(e.value, existing)
        }
    }

    return result
}

I would suggest one more alternative

fun <K, V> Map<K, V>.mergeReduce(other: Map<K, V>, reduce: (V, V) -> V = { a, b -> b }): Map<K, V> =
    other.entries.fold(this.toMutableMap()) { acc, entry ->
        acc[entry.key] = acc[entry.key]?.let { reduce(entry.value, it) } ?: entry.value
        acc
    }

Based on @vickychijwani's but using Java's merge:

fun <K, V> Map<K, V>.mergeReduce(other: Map<K, V>, reduce: (V, V) -> V): Map<K, V> {
	val result = LinkedHashMap<K, V>(this)
	for ((key, value) in other) {
		result.merge(key, value, reduce)
	}
	return result
}

I really liked the compactness of what @golonzovsky proposed, but I wanted:

1. support for merging multiple maps without multiple toMutableMap() calls
2. an in-place option if I already had a mutable map

So:

fun <K, V> Map<K, V>.mergeReduce(vararg others: Map<K, V>, reduce: (V, V) -> V): Map<K, V> =
		this.toMutableMap().apply { others.forEach { other -> other.forEach { merge(it.key, it.value, reduce) } } }

fun <K, V> MutableMap<K, V>.mergeReduceInPlace(vararg others: Map<K, V>, reduce: (V, V) -> V) =
		others.forEach { other -> other.forEach { merge(it.key, it.value, reduce) } }

For those who are interested, this method is provided as part of https://github.com/LukasForst/katlib