From 2537bfd36d0f54cdce03f33a9b2daf48c1aa567b Mon Sep 17 00:00:00 2001 From: Luka Jacobowitz Date: Tue, 16 Jun 2020 13:27:05 -0400 Subject: [PATCH] Add Parallel traverseFilter functions (#3467) * Add Parallel traverseFilter functions * Move syntax to AllSyntax --- core/src/main/scala/cats/Parallel.scala | 68 +++++++++++++++++++ core/src/main/scala/cats/syntax/all.scala | 1 + core/src/main/scala/cats/syntax/package.scala | 1 + .../src/main/scala/cats/syntax/parallel.scala | 26 +++++++ 4 files changed, 96 insertions(+) diff --git a/core/src/main/scala/cats/Parallel.scala b/core/src/main/scala/cats/Parallel.scala index 1187b71942..5cc12b3850 100644 --- a/core/src/main/scala/cats/Parallel.scala +++ b/core/src/main/scala/cats/Parallel.scala @@ -130,6 +130,74 @@ object Parallel extends ParallelArityFunctions2 { def apply[M[_], F[_]](implicit P: Parallel.Aux[M, F]): Parallel.Aux[M, F] = P def apply[M[_]](implicit P: Parallel[M], D: DummyImplicit): Parallel.Aux[M, P.F] = P + /** + * Like `TraverseFilter#traverseFilter`, but uses the applicative instance + * corresponding to the Parallel instance instead. + * + * Example: + * {{{ + * scala> import cats.implicits._ + * scala> import cats.data._ + * scala> val list: List[Int] = List(1, 2, 3, 4) + * scala> def validate(n: Int): EitherNec[String, Option[Int]] = + * | if (n > 100) Left(NonEmptyChain.one("Too large")) + * | else if (n % 3 =!= 0) Right(Some(n)) + * | else Right(None) + * scala> list.parTraverseFilter(validate) + * res0: EitherNec[String, List[Int]] = Right(List(1, 2, 4)) + * }}} + */ + def parTraverseFilter[T[_], M[_], A, B]( + ta: T[A] + )(f: A => M[Option[B]])(implicit T: TraverseFilter[T], P: Parallel[M]): M[T[B]] = { + val ftb: P.F[T[B]] = T.traverseFilter[P.F, A, B](ta)(a => P.parallel(f(a)))(P.applicative) + + P.sequential(ftb) + } + + /** + * Like `TraverseFilter#sequenceFilter`, but uses the applicative instance + * corresponding to the Parallel instance instead. + * + * Example: + * {{{ + * scala> import cats.implicits._ + * scala> import cats.data._ + * scala> val list: List[EitherNec[String, Option[Int]]] = List(Left(NonEmptyChain.one("Error")), Left(NonEmptyChain.one("Warning!"))) + * scala> list.parSequenceFilter + * res0: EitherNec[String, List[Int]] = Left(Chain(Error, Warning!)) + * }}} + */ + def parSequenceFilter[T[_], M[_], A](ta: T[M[Option[A]]])(implicit T: TraverseFilter[T], P: Parallel[M]): M[T[A]] = { + val fta: P.F[T[A]] = T.traverseFilter[P.F, M[Option[A]], A](ta)(P.parallel.apply(_))(P.applicative) + + P.sequential(fta) + } + + /** + * Like `TraverseFilter#filterA`, but uses the applicative instance + * corresponding to the Parallel instance instead. + * + * Example: + * {{{ + * scala> import cats.implicits._ + * scala> import cats.data._ + * scala> val list: List[Int] = List(1, 2, 3, 4) + * scala> def validate(n: Int): EitherNec[String, Boolean] = + * | if (n > 100) Left(NonEmptyChain.one("Too large")) + * | else Right(n % 3 =!= 0) + * scala> list.parFilterA(validate) + * res0: EitherNec[String, List[Int]] = Right(List(1, 2, 4)) + * }}} + */ + def parFilterA[T[_], M[_], A]( + ta: T[A] + )(f: A => M[Boolean])(implicit T: TraverseFilter[T], P: Parallel[M]): M[T[A]] = { + val fta: P.F[T[A]] = T.filterA(ta)(a => P.parallel(f(a)))(P.applicative) + + P.sequential(fta) + } + /** * Like `Traverse[A].sequence`, but uses the applicative instance * corresponding to the Parallel instance instead. diff --git a/core/src/main/scala/cats/syntax/all.scala b/core/src/main/scala/cats/syntax/all.scala index c19ea72e45..45b8a8d3fc 100644 --- a/core/src/main/scala/cats/syntax/all.scala +++ b/core/src/main/scala/cats/syntax/all.scala @@ -60,6 +60,7 @@ trait AllSyntax with VectorSyntax with WriterSyntax with ParallelFoldMapASyntax + with ParallelTraverseFilterSyntax trait AllSyntaxBinCompat0 extends UnorderedTraverseSyntax with ApplicativeErrorExtension with TrySyntax diff --git a/core/src/main/scala/cats/syntax/package.scala b/core/src/main/scala/cats/syntax/package.scala index baee94711d..7490e7824f 100644 --- a/core/src/main/scala/cats/syntax/package.scala +++ b/core/src/main/scala/cats/syntax/package.scala @@ -49,6 +49,7 @@ package object syntax { with ParallelBitraverseSyntax with ParallelUnorderedTraverseSyntax with ParallelFoldMapASyntax + with ParallelTraverseFilterSyntax object partialOrder extends PartialOrderSyntax object profunctor extends ProfunctorSyntax object reducible extends ReducibleSyntax with ReducibleSyntaxBinCompat0 diff --git a/core/src/main/scala/cats/syntax/parallel.scala b/core/src/main/scala/cats/syntax/parallel.scala index 499c101b1d..17b1a94f5d 100644 --- a/core/src/main/scala/cats/syntax/parallel.scala +++ b/core/src/main/scala/cats/syntax/parallel.scala @@ -9,6 +9,7 @@ import cats.{ Monoid, Parallel, Traverse, + TraverseFilter, UnorderedTraverse } @@ -41,6 +42,18 @@ trait ParallelFlatSyntax { ): ParallelFlatSequenceOps[T, M, A] = new ParallelFlatSequenceOps[T, M, A](tmta) } +trait ParallelTraverseFilterSyntax { + implicit final def catsSyntaxParallelTraverseFilter[T[_]: TraverseFilter, A]( + ta: T[A] + ): ParallelTraverseFilterOps[T, A] = + new ParallelTraverseFilterOps[T, A](ta) + + implicit final def catsSyntaxParallelSequenceFilter[T[_]: TraverseFilter, M[_]: Parallel, A]( + tmoa: T[M[Option[A]]] + ): ParallelSequenceFilterOps[T, M, A] = + new ParallelSequenceFilterOps[T, M, A](tmoa) +} + trait ParallelTraverseSyntax { implicit final def catsSyntaxParallelTraverse_[T[_]: Foldable, A](ta: T[A]): ParallelTraversable_Ops[T, A] = new ParallelTraversable_Ops[T, A](ta) @@ -100,6 +113,19 @@ final class ParallelTraversableOps[T[_], A](private val ta: T[A]) extends AnyVal } +final class ParallelTraverseFilterOps[T[_], A](private val ta: T[A]) extends AnyVal { + def parTraverseFilter[M[_]: Parallel, B](f: A => M[Option[B]])(implicit T: TraverseFilter[T]): M[T[B]] = + Parallel.parTraverseFilter(ta)(f) + + def parFilterA[M[_]: Parallel](f: A => M[Boolean])(implicit T: TraverseFilter[T]): M[T[A]] = + Parallel.parFilterA(ta)(f) +} + +final class ParallelSequenceFilterOps[T[_], M[_], A](private val tmoa: T[M[Option[A]]]) extends AnyVal { + def parSequenceFilter(implicit P: Parallel[M], T: TraverseFilter[T]): M[T[A]] = + Parallel.parSequenceFilter(tmoa) +} + final class ParallelTraversable_Ops[T[_], A](private val ta: T[A]) extends AnyVal { def parTraverse_[M[_], B](f: A => M[B])(implicit T: Foldable[T], P: Parallel[M]): M[Unit] = Parallel.parTraverse_(ta)(f)