mutable.Map fusion profonde
Existe-t-il un moyen concis de fusionner profondément deux cartes mutables dans Scala?
case class K1(i: Int)
case class K2(i: Int)
def deepMerge(map: mutable.Map[K1, Map[K2, List[Int]]],
mergee: mutable.Map[K1, Map[K2, List[Int]]]
): Unit = ???
Exemples:
JE.
val map = mutable.Map(K1(1) -> Map(K2(1) -> List(1)))
val mergee = mutable.Map(K1(1) -> Map(K2(1) -> List(2)))
deepMerge(map, mergee)
map = mutable.Map(K1(1) -> Map(K2(1) -> List(1, 2)))
II.
val map = mutable.Map(K1(1) -> Map(K2(1) -> List(1)))
val mergee = mutable.Map(K1(1) -> Map(K2(2) -> List(1)))
deepMerge(map, mergee)
map = mutable.Map(K1(1) -> Map(K2(1) -> List(1), K2(2) -> List(1)))
III.
val map = mutable.Map(K1(1) -> Map(K2(1) -> List(1)))
val mergee = mutable.Map(K1(2) -> Map(K2(2) -> List(1)))
deepMerge(map, mergee)
map = mutable.Map(K1(1) -> Map(K2(1) -> List(1)), K1(2) -> Map(K2(2) -> List(1)))
C'est-à-dire que si la même clé est présentée dans les deux cartes, les valeurs auxquelles les clés correspondent ( List[Int]
) sont fusionnées.
Existe-t-il un moyen de l'implémenter de manière concise en évitant de vérifier si la clé particulière est présentée ou non dans une autre carte? L'utilisation de bibliothèques FP comme scalaz ou cats est également acceptable.
Réponses
J'ajoute une autre réponse en utilisant des chats.
Ce que vous décrivez est en fait le comportement des chats . Vous pouvez donc simplement utiliser l' |+|
opérateur combine ( ) pour fusionner en profondeur les cartes:
import cats.implicits._
import cats._
case class K1(i: Int)
case class K2(i: Int)
val map = Map(K1(1) -> Map(K2(1) -> List(1)))
val mergee = Map(K1(1) -> Map(K2(1) -> List(2)))
val deepMerged = map |+| mergee
println(deepMerged) // HashMap(K1(1) -> HashMap(K2(1) -> List(1, 2)))
Le problème est que cats lib ne fournit pas d'instance de Semigroup pour mutable.Map
, mais vous pouvez en dériver une pour immuable:
import cats.implicits._
import scala.collection.immutable
import scala.collection.mutable
import cats._
//here I derivive Semigroup instance for mutable.Map from instance for immutable.Map
implicit def mutableMapSemigroup[K, V: Semigroup]: Semigroup[mutable.Map[K, V]] = Semigroup[immutable.Map[K, V]].imap(c => mutable.Map.from(c))(c => immutable.Map.from(c))
case class K1(i: Int)
case class K2(i: Int)
val map = mutable.Map(K1(1) -> mutable.Map(K2(1) -> List(1)))
val mergee = mutable.Map(K1(1) -> mutable.Map(K2(1) -> List(2)))
println(map |+| mergee)
Mais gardez à l'esprit que cela convertit en fait la carte mutable en immuable, puis fusionne puis se reconvertit en carte mutable, donc ce n'est probablement pas très efficace.
Cela pourrait le faire.
def deepMerge(mergeA: Map[K1, Map[K2, List[Int]]],
mergeB: Map[K1, Map[K2, List[Int]]]
): Map[K1,Map[K2,List[Int]]] =
(mergeA.toList ++ mergeB.toList).groupMap(_._1)(_._2).map{
case (k1,ms) =>
k1 -> ms.flatMap(_.toList).groupMap(_._1)(_._2).map{
case (k2,ls) => k2 -> ls.flatten
}
}
Je ne l'ai pas testé avec mutable
Maps mais cela devrait fonctionner plus ou moins de la même manière.