fixup! #11 Add groupMap and groupMapReduce extensions

simplify impl and tweak test

Author: NthPortal

compat/src/main/scala-2.11_2.12/scala/collection/compat/PackageShared.scala

@@ -253,34 +253,30 @@ class TraversableExtensionMethods[A](private val self: c.Traversable[A]) extends
 class TraversableLikeExtensionMethods[A, Repr](private val self: c.GenTraversableLike[A, Repr])
     extends AnyVal {
 
-  def groupMap[K, B, VThat, That](key: A => K)(f: A => B)(
-      implicit traversable: IsTraversableLikeAux[A, Repr],
-      innerBf: CanBuildFrom[Repr, B, VThat],
-      outerBf: CanBuildFrom[c.GenMap[K, Repr], (K, VThat), That]): That = {
-    val grouped = self.groupBy(key)
-    val outerB = outerBf(grouped)
-    for ((k, repr) <- grouped.toIterator) {
-      val innerB = innerBf(repr)
-      for (a <- traversable.conversion(repr)) innerB += f(a)
-      outerB.+=((k, innerB.result()))
+  def groupMap[K, B, That](key: A => K)(f: A => B)(
+      implicit bf: CanBuildFrom[Repr, B, That]): Map[K, That] = {
+    val map = m.Map.empty[K, m.Builder[B, That]]
+    for (elem <- self) {
+      val k    = key(elem)
+      val bldr = map.getOrElseUpdate(k, bf(self.repr))
+      bldr += f(elem)
     }
-    outerB.result()
+    val res = Map.newBuilder[K, That]
+    for ((k, bldr) <- map) res += ((k, bldr.result()))
+    res.result()
   }
 
-  def groupMapReduce[K, B, That](key: A => K)(f: A => B)(reduce: (B, B) => B)(
-      implicit traversable: IsTraversableLikeAux[A, Repr],
-      bf: CanBuildFrom[c.GenMap[K, Repr], (K, B), That]): That = {
-    val grouped = self.groupBy(key)
-    val b = bf(grouped)
-    for ((k, repr) <- grouped.toIterator) {
-      val elem = traversable
-        .conversion(repr)
-        .toIterator
-        .map(f)
-        .reduce(reduce)
-      b.+=((k, elem))
+  def groupMapReduce[K, B](key: A => K)(f: A => B)(reduce: (B, B) => B): Map[K, B] = {
+    val map = m.Map.empty[K, B]
+    for (elem <- self) {
+      val k = key(elem)
+      val v = map.get(k) match {
+        case Some(b) => reduce(b, f(elem))
+        case None => f(elem)
+      }
+      map.put(k, v)
     }
-    b.result()
+    map.toMap
   }
 }
 

compat/src/test/scala/test/scala/collection/TraversableLikeTest.scala

@@ -29,7 +29,7 @@ class TraversableLikeTest {
   @Test
   def groupMapReduce(): Unit = {
     val res = Seq("foo", "test", "bar", "baz")
-      .groupMapReduce(_.length)(_.toUpperCase())(_ + _)
-    assertEquals(Map(3 -> "FOOBARBAZ", 4 -> "TEST"), res)
+      .groupMapReduce(_.length)(_ => 1)(_ + _)
+    assertEquals(Map(3 -> 3, 4 -> 1), res)
   }
 }