How to sum a map of maps of same key in scala

Question

I have the following map of maps :

var map1 : mutable.Map[String, Map[String, Double]]
map1("U1" -> ("a"-> 2.1, "b"->3.21, "c"->7.1), 
     "U2" -> ("a"-> 3.1, "b"->12.1, "c"->1.4)
    )

I want to traverse through this map and merge all the values in a way that i get the following:

finalMap = ("a"->5.2, "b"->15.22, "c"->8.5)

I came across the this and imported scalaz for the solution but I'm a little unclear as to how to use the |+| on the values iterable.

I'm using the following code :

finalMap : Map[String, Double]()
map1.values.foreach{ (valueMap : Map[String, Double]) => 
  finalMap  |+| valueMap 
}

Any pointers on how to correct this

Answer 1

To complement dhg's answer :

First, to use |+| on a Map[A, B] we need a Semigroup[B] instance. In this case Semigroup[Double]. But scalaz itself doesn't give you this instance, because it wouldn't follow the rules/laws of a correct Semigroup instance (related scalaz issue).

No despair, because we can still get an instance from the project scalaz-outlaws (which only supports scalaz 7.1.x it seems). Using the Double outlaw instance we can now combine two Doubles, while ignoring the deprecation message urging us not to use Monoid[Double] because it doesn't uphold the laws :

import scalaz.syntax.semigroup._
import scalaz.outlaws.std.double._

1.0 |+| 2.0
// <console>:18: warning: value doubleMonoid in trait DoubleOutlawInstances 
// is deprecated: Monoid[Double] violates the associativity law
//        1.0 |+| 2.0
//        ^
// res0: Double = 3.0

Second, we can simplify the reduce / fold with scalaz by using the Monoid[Double] implicitly instead of using |+| directly.

import scalaz.std.map._
import scalaz.outlaws.std.double._
import scalaz.syntax.foldable._

val map = Map("U1" -> Map("a"-> 2.1, "b"->3.21, "c"->7.1), 
              "U2" -> Map("a"-> 3.1, "b"->12.1, "c"->1.4))

map.concatenate
// Map[String,Double] = Map(a -> 5.2, b -> 15.309999999999999, c -> 8.5)

The map.concatenate is analogous to

map.values.fold(Monoid[Map[String, Double]].zero)(_ |+| _)

Answer 2

First, use vals and immutable data structures. Second, look up how to initialize collections; there are many, many examples on the web.

val map1 = Map("U1" -> Map("a"-> 2.1, "b"->3.21, "c"->7.1), 
               "U2" -> Map("a"-> 3.1, "b"->12.1, "c"->1.4))

Finally, what you are trying to do is reduce all of the Maps in values into a single Map. You can do that like this:

val finalMap = map1.values.reduce(_ |+| _)
// finalMap: Map[String,Double] = Map(a -> 5.2, b -> 15.31, c -> 8.5)

If you think that map1 might be empty, then use fold instead, which is basically a reduce in which you give an initial value:

map1.values.fold(Map.empty)(_ |+| _)
// res0: Map[String,Double] = Map(a -> 5.2, b -> 15.31, c -> 8.5)

val emptyMap = Map.empty[String, Map[String, Double]]
emptyMap.values.fold(Map.empty)(_ |+| _)
// res1: Map[String,Double] = Map()