Skip to content

Remove redundant Monad constraints from Parallel syntax #3856

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
larsrh merged 1 commit into from
Apr 18, 2021
Merged

Remove redundant Monad constraints from Parallel syntax #3856

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
90 changes: 65 additions & 25 deletions core/src/main/scala/cats/syntax/parallel.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,102 +15,124 @@ import cats.{

trait ParallelSyntax extends TupleParallelSyntax {

implicit final def catsSyntaxParallelTraverse[T[_]: Traverse, A](ta: T[A]): ParallelTraversableOps[T, A] =
new ParallelTraversableOps[T, A](ta)
@deprecated("Kept for binary compatibility", "2.6.0")
final def catsSyntaxParallelTraverse[T[_]: Traverse, A](ta: T[A]): ParallelTraversableOps[T, A] =
new ParallelTraversableOps(ta)

implicit final def catsSyntaxParallelSequence[T[_]: Traverse, M[_]: Monad, A](
tma: T[M[A]]
): ParallelSequenceOps[T, M, A] = new ParallelSequenceOps[T, M, A](tma)
implicit final def catsSyntaxParallelTraverse1[T[_]: Traverse, A](ta: T[A]): ParallelTraversableOps1[T, A] =
new ParallelTraversableOps1(ta)

implicit final def catsSyntaxParallelAp[M[_]: FlatMap, A](ma: M[A]): ParallelApOps[M, A] =
new ParallelApOps[M, A](ma)
@deprecated("Kept for binary compatibility", "2.6.0")
final def catsSyntaxParallelSequence[T[_]: Traverse, M[_]: Monad, A](tma: T[M[A]]): ParallelSequenceOps[T, M, A] =
new ParallelSequenceOps(tma)

implicit final def catsSyntaxParallelSequence1[T[_]: Traverse, M[_], A](tma: T[M[A]]): ParallelSequenceOps1[T, M, A] =
new ParallelSequenceOps1(tma)

implicit final def catsSyntaxParallelAp[M[_]: FlatMap, A](ma: M[A]): ParallelApOps[M, A] =
new ParallelApOps(ma)
}

trait ParallelApplySyntax {
implicit final def catsSyntaxParallelApply[F[_], A, B](fa: F[A => B]): ParallelApplyOps[F, A, B] =
new ParallelApplyOps[F, A, B](fa)
new ParallelApplyOps(fa)
}

trait ParallelFlatSyntax {
implicit final def catsSyntaxParallelFlatTraverse[T[_]: Traverse: FlatMap, A](
@deprecated("Kept for binary compatibility", "2.6.0")
final def catsSyntaxParallelFlatTraverse[T[_]: Traverse: FlatMap, A](ta: T[A]): ParallelFlatTraversableOps[T, A] =
new ParallelFlatTraversableOps(ta)

implicit final def catsSyntaxParallelFlatTraverse1[T[_]: Traverse: FlatMap, A](
ta: T[A]
): ParallelFlatTraversableOps[T, A] = new ParallelFlatTraversableOps[T, A](ta)
): ParallelFlatTraversableOps1[T, A] =
new ParallelFlatTraversableOps1(ta)

implicit final def catsSyntaxParallelFlatSequence[T[_]: Traverse: FlatMap, M[_]: Monad, A](
@deprecated("Kept for binary compatibility", "2.6.0")
final def catsSyntaxParallelFlatSequence[T[_]: Traverse: FlatMap, M[_]: Monad, A](
tmta: T[M[T[A]]]
): ParallelFlatSequenceOps[T, M, A] = new ParallelFlatSequenceOps[T, M, A](tmta)
): ParallelFlatSequenceOps[T, M, A] =
new ParallelFlatSequenceOps(tmta)

implicit final def catsSyntaxParallelFlatSequence1[T[_]: Traverse: FlatMap, M[_], A](
tmta: T[M[T[A]]]
): ParallelFlatSequenceOps1[T, M, A] =
new ParallelFlatSequenceOps1(tmta)
}

trait ParallelTraverseFilterSyntax {
implicit final def catsSyntaxParallelTraverseFilter[T[_]: TraverseFilter, A](
ta: T[A]
): ParallelTraverseFilterOps[T, A] =
new ParallelTraverseFilterOps[T, A](ta)
new ParallelTraverseFilterOps(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)
new ParallelSequenceFilterOps(tmoa)
}

trait ParallelTraverseSyntax {
implicit final def catsSyntaxParallelTraverse_[T[_]: Foldable, A](ta: T[A]): ParallelTraversable_Ops[T, A] =
new ParallelTraversable_Ops[T, A](ta)
new ParallelTraversable_Ops(ta)

implicit final def catsSyntaxParallelSequence_[T[_]: Foldable, M[_], A](tma: T[M[A]]): ParallelSequence_Ops[T, M, A] =
new ParallelSequence_Ops[T, M, A](tma)
new ParallelSequence_Ops(tma)
}

trait ParallelBitraverseSyntax {
implicit final def catsSyntaxParallelBitraverse[T[_, _]: Bitraverse, A, B](
tab: T[A, B]
): ParallelBitraverseOps[T, A, B] =
new ParallelBitraverseOps[T, A, B](tab)
new ParallelBitraverseOps(tab)

implicit final def catsSyntaxParallelBisequence[T[_, _]: Bitraverse, M[_], A, B](
tmamb: T[M[A], M[B]]
): ParallelBisequenceOps[T, M, A, B] =
new ParallelBisequenceOps[T, M, A, B](tmamb)
new ParallelBisequenceOps(tmamb)

implicit final def catsSyntaxParallelLeftTraverse[T[_, _]: Bitraverse, A, B](
tab: T[A, B]
): ParallelLeftTraverseOps[T, A, B] =
new ParallelLeftTraverseOps[T, A, B](tab)
new ParallelLeftTraverseOps(tab)

implicit final def catsSyntaxParallelLeftSequence[T[_, _]: Bitraverse, M[_], A, B](
tmab: T[M[A], B]
): ParallelLeftSequenceOps[T, M, A, B] =
new ParallelLeftSequenceOps[T, M, A, B](tmab)
new ParallelLeftSequenceOps(tmab)
}

trait ParallelUnorderedTraverseSyntax {
implicit final def catsSyntaxParallelUnorderedTraverse[T[_], A](
ta: T[A]
): ParallelUnorderedTraverseOps[T, A] =
new ParallelUnorderedTraverseOps[T, A](ta)
new ParallelUnorderedTraverseOps(ta)

implicit final def catsSyntaxParallelUnorderedSequence[T[_], M[_], A](
tma: T[M[A]]
): ParallelUnorderedSequenceOps[T, M, A] =
new ParallelUnorderedSequenceOps[T, M, A](tma)
new ParallelUnorderedSequenceOps(tma)

implicit final def catsSyntaxParallelUnorderedFlatSequence[T[_], M[_], A](
tmta: T[M[T[A]]]
): ParallelUnorderedFlatSequenceOps[T, M, A] =
new ParallelUnorderedFlatSequenceOps[T, M, A](tmta)

new ParallelUnorderedFlatSequenceOps(tmta)
}

trait ParallelFoldMapASyntax {
implicit final def catsSyntaxParallelFoldMapA[T[_], A](ta: T[A]): ParallelFoldMapAOps[T, A] =
new ParallelFoldMapAOps[T, A](ta)
new ParallelFoldMapAOps(ta)
}

@deprecated("Kept for binary compatibility", "2.6.0")
final class ParallelTraversableOps[T[_], A](private val ta: T[A]) extends AnyVal {
def parTraverse[M[_]: Monad, B](f: A => M[B])(implicit T: Traverse[T], P: Parallel[M]): M[T[B]] =
Parallel.parTraverse(ta)(f)
}

final class ParallelTraversableOps1[T[_], A](private val ta: T[A]) extends AnyVal {
def parTraverse[M[_], B](f: A => M[B])(implicit T: Traverse[T], P: Parallel[M]): M[T[B]] =
Parallel.parTraverse(ta)(f)
}

final class ParallelTraverseFilterOps[T[_], A](private val ta: T[A]) extends AnyVal {
Expand All @@ -131,28 +153,46 @@ final class ParallelTraversable_Ops[T[_], A](private val ta: T[A]) extends AnyVa
Parallel.parTraverse_(ta)(f)
}

@deprecated("Kept for binary compatibility", "2.6.0")
final class ParallelFlatTraversableOps[T[_], A](private val ta: T[A]) extends AnyVal {
def parFlatTraverse[M[_]: Monad, B](
f: A => M[T[B]]
)(implicit T0: Traverse[T], T1: FlatMap[T], P: Parallel[M]): M[T[B]] =
Parallel.parFlatTraverse(ta)(f)
}

final class ParallelFlatTraversableOps1[T[_], A](private val ta: T[A]) extends AnyVal {
def parFlatTraverse[M[_], B](f: A => M[T[B]])(implicit T0: Traverse[T], T1: FlatMap[T], P: Parallel[M]): M[T[B]] =
Parallel.parFlatTraverse(ta)(f)
}

@deprecated("Kept for binary compatibility", "2.6.0")
final class ParallelSequenceOps[T[_], M[_], A](private val tma: T[M[A]]) extends AnyVal {
def parSequence(implicit M: Monad[M], T: Traverse[T], P: Parallel[M]): M[T[A]] =
Parallel.parSequence(tma)
}

final class ParallelSequenceOps1[T[_], M[_], A](private val tma: T[M[A]]) extends AnyVal {
def parSequence(implicit T: Traverse[T], P: Parallel[M]): M[T[A]] =
Parallel.parSequence(tma)
}

final class ParallelSequence_Ops[T[_], M[_], A](private val tma: T[M[A]]) extends AnyVal {
def parSequence_(implicit T: Foldable[T], P: Parallel[M]): M[Unit] =
Parallel.parSequence_(tma)
}

@deprecated("Kept for binary compatibility", "2.6.0")
final class ParallelFlatSequenceOps[T[_], M[_], A](private val tmta: T[M[T[A]]]) extends AnyVal {
def parFlatSequence(implicit M: Monad[M], T0: Traverse[T], T1: FlatMap[T], P: Parallel[M]): M[T[A]] =
Parallel.parFlatSequence(tmta)
}

final class ParallelFlatSequenceOps1[T[_], M[_], A](private val tmta: T[M[T[A]]]) extends AnyVal {
def parFlatSequence(implicit T0: Traverse[T], T1: FlatMap[T], P: Parallel[M]): M[T[A]] =
Parallel.parFlatSequence(tmta)
}

final class ParallelUnorderedSequenceOps[T[_], M[_], A](private val tmta: T[M[A]]) extends AnyVal {
def parUnorderedSequence[F[_]](implicit
P: Parallel.Aux[M, F],
Expand Down