mutable.Map deep merge
Existe uma maneira concisa de fundir profundamente dois mapas mutáveis no 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 = ???
Exemplos:
EU.
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)))
Ou seja, se houver a mesma chave apresentada em ambos os mapas, os valores aos quais as chaves correspondem ( List[Int]
) serão mesclados.
Existe uma maneira de implementá-lo de forma concisa, evitando muitas verificações se a chave específica é apresentada ou não em outro mapa? Usar libs FP como scalaz ou cats também está ok.
Respostas
Estou adicionando outra resposta usando gatos.
O que você está descrevendo é, na verdade, o comportamento dos gatos . Semigrupo . Portanto, você pode apenas usar o |+|
operador combine ( ) para mesclar mapas:
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)))
O problema é que cats lib não fornece uma instância de Semigroup para mutable.Map
, mas você pode derivar de um para imutável:
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)
Mas lembre-se de que isso realmente converte o mapa mutável em imutável e, em seguida, mescla e converte de volta para o mapa mutável, portanto, provavelmente não é muito eficiente.
Isso pode funcionar.
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
}
}
Não testei com o mutable
Maps, mas deve funcionar mais ou menos da mesma forma.