weaken constraint on ParallelApOps and ParallelApplyOps methods

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

@@ -53,13 +53,24 @@ trait ParallelSyntax extends TupleParallelSyntax {
   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] =
+  @deprecated("Kept for binary compatibility", "2.8.0")
+  final def catsSyntaxParallelAp[M[_]: FlatMap, A](ma: M[A]): ParallelApOps[M, A] =
     new ParallelApOps(ma)
+
+  implicit final def catsSyntaxParallelAp1[M[_], A](ma: M[A]): ParallelApOps1[M, A] =
+    new ParallelApOps1(ma)
+
+  implicit final def catsSyntaxNonEmptyParallelAp[M[_], A](ma: M[A]): NonEmptyParallelApOps[M, A] =
+    new NonEmptyParallelApOps(ma)
 }
 
 trait ParallelApplySyntax {
-  implicit final def catsSyntaxParallelApply[F[_], A, B](fa: F[A => B]): ParallelApplyOps[F, A, B] =
+  @deprecated("Kept for binary compatibility", "2.8.0")
+  final def catsSyntaxParallelApply[F[_], A, B](fa: F[A => B]): ParallelApplyOps[F, A, B] =
     new ParallelApplyOps(fa)
+
+  implicit final def catsSyntaxNonEmptyParallelApply[F[_], A, B](fa: F[A => B]): NonEmptyParallelApplyOps[F, A, B] =
+    new NonEmptyParallelApplyOps(fa)
 }
 
 trait ParallelFlatSyntax {
@@ -258,8 +269,8 @@ final class ParallelUnorderedFlatSequenceOps[T[_], M[_], A](private val tmta: T[
     Parallel.parUnorderedFlatSequence(tmta)
 }
 
+@deprecated("Kept for binary compatibility", "2.8.0")
 final class ParallelApOps[M[_], A](private val ma: M[A]) extends AnyVal {
-
   def &>[B](mb: M[B])(implicit P: Parallel[M]): M[B] =
     P.parProductR(ma)(mb)
 
@@ -279,6 +290,29 @@ final class ParallelApOps[M[_], A](private val ma: M[A]) extends AnyVal {
     Parallel.parReplicateA(n, ma)
 }
 
+final class ParallelApOps1[M[_], A](private val ma: M[A]) extends AnyVal {
+  def parReplicateA(n: Int)(implicit P: Parallel[M]): M[List[A]] =
+    Parallel.parReplicateA(n, ma)
+}
+
+final class NonEmptyParallelApOps[M[_], A](private val ma: M[A]) extends AnyVal {
+  def &>[B](mb: M[B])(implicit P: NonEmptyParallel[M]): M[B] =
+    P.parProductR[A, B](ma)(mb)
+
+  def <&[B](mb: M[B])(implicit P: NonEmptyParallel[M]): M[A] =
+    P.parProductL[A, B](ma)(mb)
+
+  def parProductL[B](mb: M[B])(implicit P: NonEmptyParallel[M]): M[A] =
+    P.parProductL[A, B](ma)(mb)
+
+  def parProductR[B](mb: M[B])(implicit P: NonEmptyParallel[M]): M[B] =
+    P.parProductR[A, B](ma)(mb)
+
+  def parProduct[B](mb: M[B])(implicit P: NonEmptyParallel[M]): M[(A, B)] =
+    Parallel.parProduct(ma, mb)
+}
+
+@deprecated("Kept for binary compatibility", "2.8.0")
 final class ParallelApplyOps[M[_], A, B](private val mab: M[A => B]) extends AnyVal {
   def <&>(ma: M[A])(implicit P: Parallel[M]): M[B] =
     Parallel.parAp(mab)(ma)(P)
@@ -287,6 +321,14 @@ final class ParallelApplyOps[M[_], A, B](private val mab: M[A => B]) extends Any
     Parallel.parAp(mab)(ma)
 }
 
+final class NonEmptyParallelApplyOps[M[_], A, B](private val mab: M[A => B]) extends AnyVal {
+  def <&>(ma: M[A])(implicit P: NonEmptyParallel[M]): M[B] =
+    Parallel.parAp[M, A, B](mab)(ma)(P)
+
+  def parAp(ma: M[A])(implicit P: NonEmptyParallel[M]): M[B] =
+    Parallel.parAp[M, A, B](mab)(ma)
+}
+
 final class ParallelBitraverseOps[T[_, _], A, B](private val tab: T[A, B]) extends AnyVal {
   def parBitraverse[M[_], C, D](f: A => M[C], g: B => M[D])(implicit T: Bitraverse[T], P: Parallel[M]): M[T[C, D]] =
     Parallel.parBitraverse(tab)(f, g)

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

@@ -184,14 +184,20 @@ object SyntaxSuite {
     val gunit: G[F[A]] = fga.nonEmptySequence
   }
 
-  def testParallel[M[_]: Monad, F[_], T[_]: Traverse, A, B](implicit P: Parallel.Aux[M, F]): Unit = {
+  def testParallel[M[_]: Parallel, T[_]: Traverse, A, B]: Unit = {
     val ta = mock[T[A]]
     val f = mock[A => M[B]]
     val mtb = ta.parTraverse(f)
 
     val tma = mock[T[M[A]]]
     val mta = tma.parSequence
 
+    val ma = mock[M[A]]
+
+    val mla: M[List[A]] = ma.parReplicateA(mock[Int])
+  }
+
+  def testNonEmptyParallel[M[_]: NonEmptyParallel, A, B]: Unit = {
     val ma = mock[M[A]]
     val mb = mock[M[B]]
 
@@ -205,7 +211,6 @@ object SyntaxSuite {
     val mb4: M[B] = ma.parProductR(mb)
     val mab2: M[(A, B)] = ma.parProduct(mb)
     val mb5: M[B] = mab.parAp(ma)
-    val mla: M[List[A]] = ma.parReplicateA(mock[Int])
   }
 
   def testParallelUnorderedTraverse[M[_]: Monad, F[_]: CommutativeApplicative, T[_]: UnorderedTraverse: FlatMap, A, B](