Question

I’ve been digging around in the Scala code. It looks like TreeMap uses the following builder class.

class MapBuilder[A, B, Coll <: scala.collection.GenMap[A, B] with scala.collection.GenMapLike[A, B, Coll]](empty: Coll)
extends Builder[(A, B), Coll] {
  protected var elems: Coll = empty
  def +=(x: (A, B)): this.type = {
    elems = (elems + x).asInstanceOf[Coll]
      // the cast is necessary because right now we cannot enforce statically that
      // for every map of type Coll, `+` yields again a Coll. With better support
      // for hk-types we might be able to enforce this in the future, though.
    this
  }
  def clear() { elems = empty }
  def result: Coll = elems
}

I don’t understand the cast, but that’s besides the point. It looks as though, for example, when two TreeMaps are ++-ed together, a new TreeMap is instantiated and then all the key-value pairs from both TreeMaps are added. Since TreeMapis immutable, why can’t we start from one of the TreeMaps and just add the items from the other? Is this just because ++works on both immutable and mutable types, so we need to make a defensive copy, and some collections may have more efficient strategies?

Answer 1

If this is our code:

val a = TreeMap(1->'a, 2->'b)
val b = TreeMap(3->'c, 4->'d)
val c = a ++ b

Then ++ is defined in TreeMap as:

override def ++[B1 >: B] (xs: GenTraversableOnce[(A, B1)]): TreeMap[A, B1] = 
  ((repr: TreeMap[A, B1]) /: xs.seq) (_ + _)

So we start with a and fold each element of b into it to get the final result.

In other words, it appears to be doing exactly what you expected. Or did I miss something?