Skip to content

Commit

Permalink
Remove redundant Monad constraints from Parallel syntax
Browse files Browse the repository at this point in the history
  • Loading branch information
@joroKr21
joroKr21 committed Apr 10, 2021
1 parent 9753b34 commit b56a028
Showing 1 changed file with 65 additions and 25 deletions.
90 changes: 65 additions & 25 deletions core/src/main/scala/cats/syntax/parallel.scala
View file
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

0 comments on commit b56a028

Please sign in to comment.