Hello everyone. I was quite surprised that the following code doesn’t get compiled ```val map = muta...

# getting-started

[evkaky]

Hello everyone.
I was quite surprised that the following code doesn’t get compiled

val map = mutableMapOf("key1" to 1)
map["key1"] += 2

Why Is it not possible to use increment in such a way?

[hho]

map["key1"] gives you an instance of Int, which is immutable. You can't assign a new value to an Int.

[evkaky]

😭

[Roukanken]

for it to work, you would need to have implemented Int?.plusAssign(Int)
because it does not desugar into map.get(a) = map.get(a) + b but into map.get(a).plusAssign(b)

[hho]

Oh my. I hadn't even thought about nullability… 🤦

[Roukanken]

and yes, get(a) returns nullable, so that's another issue there 😛

[Ulrik Rasmussen]

You could do m.compute("key1") { _, i -> i?.let { it + 1 } }

[Ulrik Rasmussen]

Or simpler, m.computeIfPresent("key1") { _, i -> i + 1 }

[evkaky]

yeah, seems like this is the most clean solution @Ulrik Rasmussen
btw, Swift allows such a code

map["key1"]! += 2

[Ulrik Rasmussen]

I don't know Swift, but it probably has a more baked in notion of maps. In Kotlin, map[k] is just sugar for map.get(k)

[Travis Griggs]

Re Swift, I don't think it's the baked in nature of maps, it's that maps are structs in Swift. So the swift analog to OP's query actually would fail in Swift as well. In Swift, val becomes let (simplisitically) speaking, which would mean the struct was immutable. But once it was a var, it would be inherently mutable and would then work

[ephemient]

if there were an API like

fun <K, V> MutableMap<K, V>.findEntry(key: Key): MutableMap.MutableEntry<K, V>?

then you could

m.findEntry("key1")?.let { it.setValue(it.value + 2) }

but sadly there is no such API

[Ulrik Rasmussen]

Something like this can be obtained via lenses though: https://arrow-kt.io/docs/optics/at/

[Michael Böiers]

Something else you could do:

fun <K, V> MutableMap<K, V>.replace(key: K, value: (V) -> V) =
    compute(key) { _, old -> if (old == null) null else value(old) }

val map = mutableMapOf("a" to 42)
map.replace("a") { it + 1 }
println(map)

[ephemient]

computeIfPresent as mentioned earlier would be better than compute since you're ignoring the absent case

[Michael Böiers]

Yes, correct. I‘d still define an extension function to get rid of the unused function parameter.

[Michael Böiers]

fun <K, V> MutableMap<K, V>.replace(key: K, value: (V) -> V) =
    computeIfPresent(key) { _, old -> value(old) }

val map = mutableMapOf("a" to 42)
map.replace("a") { it + 1 }