Add traverseCollect to TraverseFilter typeclass

core/src/main/scala/cats/TraverseFilter.scala

@@ -22,6 +22,7 @@
 package cats
 
 import cats.data.State
+import cats.implicits.toTraverseOps
 
 import scala.collection.immutable.{HashSet, TreeSet}
 
@@ -56,6 +57,20 @@ trait TraverseFilter[F[_]] extends FunctorFilter[F] {
    */
   def traverseFilter[G[_], A, B](fa: F[A])(f: A => G[Option[B]])(implicit G: Applicative[G]): G[F[B]]
 
+  /**
+   * A combined [[traverse]] and [[collect]].
+   *
+   * scala> import cats.implicits._
+   * scala> val m: Map[Int, String] = Map(1 -> "one", 2 -> "two")
+   * scala> val l: List[Int] = List(1, 2, 3, 4)
+   * scala> def asString: PartialFunction[Int, Eval[Option[String]]] = { case n if n % 2 == 0 => Now(m.get(n)) }
+   * scala> val result: Eval[List[String]] = l.traverseCollect(asString)
+   * scala> result.value
+   * res0: List[String] = List(two)
+   */
+  def traverseCollect[G[_], A, B](fa: F[A])(f: PartialFunction[A, G[B]])(implicit G: Applicative[G]): G[F[B]] =
+    traverseFilter(fa)(a => f.lift(a).sequence)
+
   /**
    * {{{
    * scala> import cats.implicits._

core/src/main/scala/cats/syntax/traverseFilter.scala

@@ -27,6 +27,9 @@ trait TraverseFilterSyntax extends TraverseFilter.ToTraverseFilterOps
 private[syntax] trait TraverseFilterSyntaxBinCompat0 {
   implicit def toSequenceFilterOps[F[_], G[_], A](fgoa: F[G[Option[A]]]): SequenceFilterOps[F, G, A] =
     new SequenceFilterOps(fgoa)
+
+  implicit def toTraverseCollectOps[F[_], G[_], A](fa: F[A]): TraverseCollectOps[F, G, A] =
+    new TraverseCollectOps(fa)
 }
 
 final class SequenceFilterOps[F[_], G[_], A](private val fgoa: F[G[Option[A]]]) extends AnyVal {
@@ -41,3 +44,12 @@ final class SequenceFilterOps[F[_], G[_], A](private val fgoa: F[G[Option[A]]])
    */
   def sequenceFilter(implicit F: TraverseFilter[F], G: Applicative[G]): G[F[A]] = F.sequenceFilter(fgoa)
 }
+
+final class TraverseCollectOps[F[_], G[_], A](private val fa: F[A]) extends AnyVal {
+
+  def traverseCollect[B](f: PartialFunction[A, G[B]])(implicit
+    F: TraverseFilter[F],
+    G: Applicative[G]
+  ): G[F[B]] =
+    F.traverseCollect(fa)(f)
+}

laws/src/main/scala/cats/laws/TraverseFilterLaws.scala

@@ -52,6 +52,14 @@ trait TraverseFilterLaws[F[_]] extends FunctorFilterLaws[F] {
     G: Monad[G]
   ): IsEq[G[F[B]]] =
     fa.traverseEither(a => f(a).map(_.toRight(e)))((_, _) => Applicative[G].unit) <-> fa.traverseFilter(f)
+
+  def traverseCollectRef[G[_], A, B](
+    fa: F[A]
+  )(f: PartialFunction[A, G[B]])(implicit G: Applicative[G]): IsEq[G[F[B]]] = {
+    val lhs = fa.traverseCollect(f)
+    val rhs = fa.traverseFilter(a => f.lift(a).sequence)
+    lhs <-> rhs
+  }
 }
 
 object TraverseFilterLaws {

tests/shared/src/test/scala/cats/tests/SyntaxSuite.scala

@@ -580,4 +580,11 @@ object SyntaxSuite {
 
     val result: Either[A, List[B]] = f.sequenceFilter
   }
+
+  def testTraverseCollect[A, B]: Unit = {
+    val list = mock[List[A]]
+    val f = mock[PartialFunction[A, Option[B]]]
+
+    val result: Option[List[B]] = list.traverseCollect(f)
+  }
 }