Scala Map with mutable default value always point to the same object

user_1248918 0
Viewed 97

Scala version:3.1

I want to create a String -> Int map, that each key may point to many Int.

Therefore I choose map with default mutable Buffer[Int].

But it seems the all the keys always point to the same Buffer[Int]

Notice it is also weird in the first m("a") += 1 that, it print out nothing after this += but default value changed so that it print two 1 in the next println.

Also, how I can fix the problem that mutable.Map's += is overriden by Buffer's +=. I am expecting the map insert a new Buffer if the key doens't exist, then call += of the buffer.

  import scala.collection.mutable
  val m: mutable.Map[String, mutable.Buffer[Int]] =
    mutable.HashMap.empty.withDefaultValue(mutable.Buffer.empty)

  m("a") += 1
  println(m) // Map()

  m("a") = m("a") += 1

  println(m) // Map(a -> ArrayBuffer(1, 1))

  m("b") = m("b") += 2 // Map(a -> ArrayBuffer(1, 1, 2), b -> ArrayBuffer(1, 1, 2)) , not expecting this, key is correct but

  println(m) // Map(a -> ArrayBuffer(1, 1, 2), b -> ArrayBuffer(1, 1, 2))

  m("a") = m("a") += 2

  println(m) // Map(a -> ArrayBuffer(1, 1, 2, 2), b -> ArrayBuffer(1, 1, 2, 2)) , 
  // this is not as I expected. The keys are correct, however their values are all the same ArrayBuffer
mutable data-structures scala
1 Answers

TL;DR: withDefaultValue is useless here.

Note the signature of withDefaultValue is:

def withDefaultValue(d: V): Map[K, V]

The parameter d is taken by value, not by name (=> V), therefore it is only evaluated once. Therefore any key not present in the original map will return the same empty buffer you created once.

And what you get withDefaultValue (and withDefault) is a new map-like object, not the original map. Only assigning the results (m("a") = ...) will change it.

Note: The default is only used for apply. Other methods like get, contains, iterator, keys, etc. are not affected by withDefaultValue.

Consider this example:

val m = new HashMap[Integer, Buffer[String]]()
val mm = m.withDefault(_ => Buffer.empty)
mm(1).append("4")
mm(1) // ArrayBuffer()

What you probably want is getOrElseUpdate (you can define a helper function if you'd like) with the signature

getOrElseUpdate(key: K, defaultValue: => V): V

Note how defaultValue is called by name this time, and each call will create a new buffer:

val m: mutable.Map[String, mutable.Buffer[Int]] =
    mutable.HashMap.empty

def mm(key: String): mutable.Buffer[Int] = m.getOrElseUpdate(key, mutable.Buffer.empty)

mm("a") += 1
mm("b") += 2
// now buffers at `a` and `b` are distinct
user_2882010
Related