Add tapEach

compat/src/main/scala-2.11/scala/collection/compat/package.scala

@@ -12,4 +12,11 @@
 
 package scala.collection
 
-package object compat extends compat.PackageShared
+import scala.collection.generic.IsTraversableLike
+
+package object compat extends compat.PackageShared {
+  implicit def toTraversableLikeExtensionMethods[Repr](self: Repr)(
+    implicit traversable: IsTraversableLike[Repr])
+  : TraversableLikeExtensionMethods[traversable.A, Repr] =
+    new TraversableLikeExtensionMethods[traversable.A, Repr](traversable.conversion(self))
+}

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

@@ -233,6 +233,7 @@ class IteratorExtensionMethods[A](private val self: c.Iterator[A]) extends AnyVa
     self.sameElements(that.iterator)
   }
   def concat[B >: A](that: c.TraversableOnce[B]): c.TraversableOnce[B] = self ++ that
+  def tapEach[U](f: A => U): c.Iterator[A] = self.map(a => { f(a); a })
 }
 
 class TraversableOnceExtensionMethods[A](private val self: c.TraversableOnce[A]) extends AnyVal {
@@ -243,6 +244,38 @@ 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 tapEach[U](f: A => U)(implicit bf: CanBuildFrom[Repr, A, Repr]): Repr =
+    self.map(a => { f(a); a })
+
+  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)
+    }
+    val res = Map.newBuilder[K, That]
+    for ((k, bldr) <- map) res += ((k, bldr.result()))
+    res.result()
+  }
+
+  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)
+    }
+    map.toMap
+  }
+}
+
 class MapViewExtensionMethods[K, V, C <: scala.collection.Map[K, V]](
     private val self: IterableView[(K, V), C])
     extends AnyVal {

compat/src/main/scala-2.12/scala/collection/compat/package.scala

@@ -12,6 +12,7 @@
 
 package scala.collection
 
+import scala.collection.generic.IsTraversableLike
 import scala.collection.{mutable => m}
 
 package object compat extends compat.PackageShared {
@@ -24,4 +25,9 @@ package object compat extends compat.PackageShared {
     def from[K: Ordering, V](source: TraversableOnce[(K, V)]): m.SortedMap[K, V] =
       build(m.SortedMap.newBuilder[K, V], source)
   }
+
+  implicit def toTraversableLikeExtensionMethods[Repr](self: Repr)(
+    implicit traversable: IsTraversableLike[Repr])
+  : TraversableLikeExtensionMethods[traversable.A, Repr] =
+    new TraversableLikeExtensionMethods[traversable.A, Repr](traversable.conversion(self))
 }

compat/src/test/scala/test/scala/collection/CollectionTest.scala

@@ -81,4 +81,33 @@ class CollectionTest {
     assertFalse(it1.iterator.sameElements(it2))
     assertTrue(it2.iterator.sameElements(it3))
   }
+
+  @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)(_ => 1)(_ + _)
+    assertEquals(Map(3 -> 3, 4 -> 1), res)
+  }
+
+  @Test
+  def tapEach(): Unit = {
+    var count = 0
+    val it = Iterator(1, 2, 3).tapEach(count += _)
+    assertEquals(0, count)
+    it.foreach(_ => ())
+    assertEquals(6, count)
+    List(1, 2, 3).tapEach(count += _)
+    assertEquals(12, count)
+    val stream = Stream(1, 2, 3).tapEach(count += _)
+    assertEquals(13, count)
+    stream.force
+    assertEquals(18, count)
+  }
 }