При конкатенации двух неизменяемых карт кажется, что элементы правого операнда будут "перезаписывать" элементы левого:
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)
Я хотел бы знать, если это правило в Scala?
Из API Scala я не мог понять этот вопрос.
Да, это постоянное поведение
Map.++ определяется как:
override def ++[B1 >: B](xs: GenTraversableOnce[(A, B1)]): immutable.Map[A, B1] =
((repr: immutable.Map[A, B1]) /: xs.seq) (_ + _)
где repr - ваша текущая карта, а xs.seq дает вам последовательность пар/отображений, хранящихся на карте, которую вы передаете на ++.
Map./: описывается как:
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.
Обратите внимание, что не указано, что означает "слева направо" для неупорядоченной карты.
Ниже показано, что происходит за сценой, переопределяя ++ и увеличивая его с помощью отладочных println операторов:
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) */