#11 Add groupMap and groupMapReduce extensions

Author: NthPortal

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

@@ -30,6 +30,8 @@ private[compat] trait PackageShared {
    */
   type Factory[-A, +C] = CanBuildFrom[Nothing, A, C]
 
+  type IsTraversableLikeAux[A1, Repr] = IsTraversableLike[Repr] { type A = A1 }
+
   implicit class FactoryOps[-A, +C](private val factory: Factory[A, C]) {
 
     /**
@@ -154,6 +156,11 @@ private[compat] trait PackageShared {
       self: Traversable[A]): TraversableExtensionMethods[A] =
     new TraversableExtensionMethods[A](self)
 
+  implicit def toTraversableLikeExtensionMethods[Repr](self: Repr)(
+      implicit traversable: IsTraversableLike[Repr])
+    : TraversableLikeExtensionMethods[traversable.A, Repr] =
+    new TraversableLikeExtensionMethods[traversable.A, Repr](traversable.conversion(self))
+
   implicit def toTraversableOnceExtensionMethods[A](
       self: TraversableOnce[A]): TraversableOnceExtensionMethods[A] =
     new TraversableOnceExtensionMethods[A](self)
@@ -243,6 +250,40 @@ class TraversableExtensionMethods[A](private val self: c.Traversable[A]) extends
   def iterableFactory: GenericCompanion[Traversable] = self.companion
 }
 
+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()))
+    }
+    outerB.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))
+    }
+    b.result()
+  }
+}
+
 class MapViewExtensionMethods[K, V, C <: scala.collection.Map[K, V]](
     private val self: IterableView[(K, V), C])
     extends AnyVal {

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

@@ -0,0 +1,35 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package test.scala.collection
+
+import org.junit.Test
+import org.junit.Assert._
+
+import scala.collection.compat._
+
+class TraversableLikeTest {
+
+  @Test
+  def groupMap(): Unit = {
+    val res = Seq("foo", "test", "bar", "baz")
+      .groupMap(_.length)(_.toUpperCase())
+    assertEquals(Map(3 -> Seq("FOO", "BAR", "BAZ"), 4 -> Seq("TEST")), res)
+  }
+
+  @Test
+  def groupMapReduce(): Unit = {
+    val res = Seq("foo", "test", "bar", "baz")
+      .groupMapReduce(_.length)(_.toUpperCase())(_ + _)
+    assertEquals(Map(3 -> "FOOBARBAZ", 4 -> "TEST"), res)
+  }
+}