Remove redundant Monad constraints from Parallel syntax

Author: joroKr21

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

@@ -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.5.1")
+  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.5.1")
+  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.5.1")
+  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.5.1")
+  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.5.1")
 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 {
@@ -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.5.1")
 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.5.1")
 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.5.1")
 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],