Concatenar dos mapas inmutables: ¿qué elementos se prefieren?

Question

Al concatenar dos mapas inmutables, parece que los elementos del operando de la derecha se "sobreescribir" los elementos de la izquierda:

scala> List((1, 2), (5, 6)).toMap ++ List((5, 9)).toMap 
res13: scala.collection.immutable.Map[Int,Int] = Map(1 -> 2, 5 -> 9) 

scala> List((5, 9)).toMap ++ List((1, 2), (5, 6)).toMap 
res14: scala.collection.immutable.Map[Int,Int] = Map(5 -> 6, 1 -> 2) 

Me gustaría saber, si esto es una regla en Scala?

Desde la API de Scala no pude resolver esta pregunta.

Answer 1

Sí, este comportamiento es constante

Answer 2

Map.++is defined as:

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

donde repr es su mapa actual y xs.seq le da una secuencia de los pares/asignaciones almacenados en el mapa que se pasa a ++.

Map./:is described as:

def /:[B](z: B)(op: (B, (A, B)) ⇒ B): B 

Applies a binary operator to a start value and all elements of this 
immutable map, going left to right. 

Note: /: is alternate syntax for foldLeft; 
z /: xs is the same as xs foldLeft z. 

Tenga en cuenta que no se especifica qué "de izquierda a derecha" significa para un mapa desordenada.

El siguiente ejemplo ilustra lo que sucede detrás de la escena por reimplementar ++ y aumentando con depuración println declaraciones:

val m1 = Map(1 -> "A", 2 -> "B", 3 -> "C") 
val m2 = Map(2 -> "X", 3 -> "Y", 4 -> "Z") 

println(m1.repr) 
    /* Map(1 -> A, 2 -> B, 3 -> C) */ 
println(m1.repr.getClass.getName) 
    /* scala.collection.immutable.Map$Map3 */ 

def ++[K, V](ts: Map[K, V], xs: Map[K, V]): Map[K, V] = 
    (ts /: xs) {case (acc, entry) => 
       println("acc = " + acc) 
       println("entry = " + entry) 
       acc + entry 
       } 

val m3 = ++(m1, m2) 
    /* 
    acc = Map(1 -> A, 2 -> B, 3 -> C) 
    entry = (2,X) 
    acc = Map(1 -> A, 2 -> X, 3 -> C) 
    entry = (3,Y) 
    acc = Map(1 -> A, 2 -> X, 3 -> Y) 
    entry = (4,Z) 
    */ 

println(m3) 
    /* Map(1 -> A, 2 -> X, 3 -> Y, 4 -> Z) */