Concaténer deux immuable cartes - quels sont les éléments à privilégier?

Lors de la concaténation de deux immuable cartes, il semble que les éléments de l'opérande de droite va "écraser" les éléments de la gauche: 

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)

Je voudrais savoir, si c'est une règle en Scala ?

De la Scala API je ne pouvais pas comprendre cette question.

InformationsquelleAutor John Threepwood | 2012-07-31
  1. 21

    Oui, ce comportement est constant

    • Je vous remercie. Si vous pouvez aussi me dire pourquoi (ou de donner une référence où la règle est définie), vous obtiendrez la accepté de répondre. 🙂
    • Dans la plupart des cas, la mise en œuvre de ++ s'appuie sur +, qui à son tour repose sur updated et dans ceci scaladoc il est précisé que updated retourne une nouvelle immuable carte mis à jour avec les nouvelles valeurs. Ouais, je sais, pas une preuve absolue, alors, probablement, vous ne fermez pas cette question encore et d'attendre une meilleure référence. La Java "Carte" de référence est le taureau$hit bien.
    InformationsquelleAutor Nikita Volkov
  2. 13

    Map.++ est défini comme:

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

    où repr est votre carte actuelle et xs.seq vous donne une séquence de paires/mappages stockées dans la carte que vous passez à ++.


    Map./: est décrit comme:

    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.

    Noter qu'il n'est pas spécifié que "de gauche à droite" signifie, pour un non-ordonnée de la carte.


    L'exemple suivant illustre ce qui se passe derrière la scène par de réimplanter ++ et en l'augmentant avec debug println états:

    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) */
    • dans votre méthode ++, vous n'obtenez pas de xs.seq comme vous l'a expliqué précédemment. Pourquoi est-ce?
    • remplace def seq de retourner lui-même, c'est à dire, this, xs.seq évalue donc à la même carte que xs n'. Je suppose que l'on pouvait remplacer def seq dans les sous-classes, mais je ne sais pas assez de la conception interne des collections de la bibliothèque pour voir quand cela serait utile ou même nécessaire.
    InformationsquelleAutor Malte Schwerhoff