Map withDefault/withDefaultValue should return a Map

[MasseGuillaume]

This line compiles in 2.12 but not in 2.13:

https://github.com/akka/akka/blob/master/akka-actor-tests/src/test/scala/akka/routing/RoundRobinSpec.scala#L68

var map = Map.empty[Int, Int].withDefaultValue(0)
map = map + (1 -> 1)

2.12
def withDefault[V1 >: V](d: (K) ⇒ V1): Map[K, V1]

2.13
def withDefault[V1 >: V](d: (K) ⇒ V1): WithDefault[K, V1]

[julienrf]

That’s because the return type of withDefaultValue is too specific: we should widen it to Map[K, V] instead of Map.WithDefault[K, V].

Workaround 1:

var map: Map[Int, Int] = Map.empty[Int, Int].withDefaultValue(0)
map = map + (1 -> 1)

Workaround 2:

var map = Map.empty[Int, Int].withDefaultValue(0)
map = map.updated(1, 1)

[joshlemer]

@julienrf would it be a good idea to move this into MapOps so that it can return CC[K, V]?

[julienrf]

I think we tried at some point but that didn’t work well (but I don’t remember why…). You give it another try if you want!

[joshlemer]

Actually on second thought, is it worth giving up the greater specificity for the sake of type inference here? I remember on occasion being annoyed that one can't really use Map.WithDefault as a user because these methods upcast in previous versions. It is in fact useful to be able to rely upon a map having a default, because then it is safe to call apply and don't need to litter your code with needless option handling.

[julienrf]

I think I misunderstood your previous comment then. I thought you were suggesting to make Map.WithDefault extend MapOps so that we can refine the type returned by its transformation operations to preserve the information that the map has a default value.

I totally agree that it would be good to have such a thing, but I think we’ve previously tried and failed (I might be wrong, though).

[joshlemer]

@julienrf sorry, you didn't misinterpret me, I changed subjects :-). My second question was: Maybe it is better to leave this as-is and not fix it just for the sake of type inference? I personally have at some point wanted to write code against Map.WithDefault so that I can statically guarantee that I don't have to cover the case of missing keys, so perhaps the regression of breaking the type inference is actually a good thing.

[julienrf]

The problem is that the current implementation returns Map.WithDefault after you call map.withDefaultValue(xx), but then if you add, remove or transform that Map.WithDefault instance you only get back a Map (it is not statically known to be a Map.WithDefault). So, I think we should either widen the return type of withDefaultValue to be Map instead of Map.WithDefault, or make all transformation operations of Map.WithDefault also return a Map.WithDefault.

[joshlemer]

I thought I would actually try both approaches and see which one people like more.
The version which exposes WithDefault as return type of transformations is here:
https://github.com/joshlemer/scala/tree/issue/11017-part2-2.13
The version which upcasts withDefault[Value] methods is here:
https://github.com/joshlemer/scala/tree/issue/11017-2.13

[szeiger]

I think the current implementation is OK. You need to add a type annotation in cases like the one that prompted this ticket but in exchange you get more precise types. Keeping the WithDefault in the types to indicate whether this property is actually preserved by a transformation would be even nicer. It's worth a try but I fear it will complicate the implementation considerably for a small improvement.