Skip to content

Commit c993049

Browse files
larsrhlarsrh
authored
Merge pull request #3856 from joroKr21/parallel-syntax
Remove redundant Monad constraints from Parallel syntax
2 parents 68f576b + b56a028 commit c993049

File tree

1 file changed

+65
-25
lines changed

1 file changed

+65
-25
lines changed

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

+65-25
Original file line numberDiff line numberDiff line change
@@ -15,102 +15,124 @@ import cats.{
1515

1616
trait ParallelSyntax extends TupleParallelSyntax {
1717

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

21-
implicit final def catsSyntaxParallelSequence[T[_]: Traverse, M[_]: Monad, A](
22-
tma: T[M[A]]
23-
): ParallelSequenceOps[T, M, A] = new ParallelSequenceOps[T, M, A](tma)
22+
implicit final def catsSyntaxParallelTraverse1[T[_]: Traverse, A](ta: T[A]): ParallelTraversableOps1[T, A] =
23+
new ParallelTraversableOps1(ta)
2424

25-
implicit final def catsSyntaxParallelAp[M[_]: FlatMap, A](ma: M[A]): ParallelApOps[M, A] =
26-
new ParallelApOps[M, A](ma)
25+
@deprecated("Kept for binary compatibility", "2.6.0")
26+
final def catsSyntaxParallelSequence[T[_]: Traverse, M[_]: Monad, A](tma: T[M[A]]): ParallelSequenceOps[T, M, A] =
27+
new ParallelSequenceOps(tma)
28+
29+
implicit final def catsSyntaxParallelSequence1[T[_]: Traverse, M[_], A](tma: T[M[A]]): ParallelSequenceOps1[T, M, A] =
30+
new ParallelSequenceOps1(tma)
2731

32+
implicit final def catsSyntaxParallelAp[M[_]: FlatMap, A](ma: M[A]): ParallelApOps[M, A] =
33+
new ParallelApOps(ma)
2834
}
2935

3036
trait ParallelApplySyntax {
3137
implicit final def catsSyntaxParallelApply[F[_], A, B](fa: F[A => B]): ParallelApplyOps[F, A, B] =
32-
new ParallelApplyOps[F, A, B](fa)
38+
new ParallelApplyOps(fa)
3339
}
3440

3541
trait ParallelFlatSyntax {
36-
implicit final def catsSyntaxParallelFlatTraverse[T[_]: Traverse: FlatMap, A](
42+
@deprecated("Kept for binary compatibility", "2.6.0")
43+
final def catsSyntaxParallelFlatTraverse[T[_]: Traverse: FlatMap, A](ta: T[A]): ParallelFlatTraversableOps[T, A] =
44+
new ParallelFlatTraversableOps(ta)
45+
46+
implicit final def catsSyntaxParallelFlatTraverse1[T[_]: Traverse: FlatMap, A](
3747
ta: T[A]
38-
): ParallelFlatTraversableOps[T, A] = new ParallelFlatTraversableOps[T, A](ta)
48+
): ParallelFlatTraversableOps1[T, A] =
49+
new ParallelFlatTraversableOps1(ta)
3950

40-
implicit final def catsSyntaxParallelFlatSequence[T[_]: Traverse: FlatMap, M[_]: Monad, A](
51+
@deprecated("Kept for binary compatibility", "2.6.0")
52+
final def catsSyntaxParallelFlatSequence[T[_]: Traverse: FlatMap, M[_]: Monad, A](
4153
tmta: T[M[T[A]]]
42-
): ParallelFlatSequenceOps[T, M, A] = new ParallelFlatSequenceOps[T, M, A](tmta)
54+
): ParallelFlatSequenceOps[T, M, A] =
55+
new ParallelFlatSequenceOps(tmta)
56+
57+
implicit final def catsSyntaxParallelFlatSequence1[T[_]: Traverse: FlatMap, M[_], A](
58+
tmta: T[M[T[A]]]
59+
): ParallelFlatSequenceOps1[T, M, A] =
60+
new ParallelFlatSequenceOps1(tmta)
4361
}
4462

4563
trait ParallelTraverseFilterSyntax {
4664
implicit final def catsSyntaxParallelTraverseFilter[T[_]: TraverseFilter, A](
4765
ta: T[A]
4866
): ParallelTraverseFilterOps[T, A] =
49-
new ParallelTraverseFilterOps[T, A](ta)
67+
new ParallelTraverseFilterOps(ta)
5068

5169
implicit final def catsSyntaxParallelSequenceFilter[T[_]: TraverseFilter, M[_]: Parallel, A](
5270
tmoa: T[M[Option[A]]]
5371
): ParallelSequenceFilterOps[T, M, A] =
54-
new ParallelSequenceFilterOps[T, M, A](tmoa)
72+
new ParallelSequenceFilterOps(tmoa)
5573
}
5674

5775
trait ParallelTraverseSyntax {
5876
implicit final def catsSyntaxParallelTraverse_[T[_]: Foldable, A](ta: T[A]): ParallelTraversable_Ops[T, A] =
59-
new ParallelTraversable_Ops[T, A](ta)
77+
new ParallelTraversable_Ops(ta)
6078

6179
implicit final def catsSyntaxParallelSequence_[T[_]: Foldable, M[_], A](tma: T[M[A]]): ParallelSequence_Ops[T, M, A] =
62-
new ParallelSequence_Ops[T, M, A](tma)
80+
new ParallelSequence_Ops(tma)
6381
}
6482

6583
trait ParallelBitraverseSyntax {
6684
implicit final def catsSyntaxParallelBitraverse[T[_, _]: Bitraverse, A, B](
6785
tab: T[A, B]
6886
): ParallelBitraverseOps[T, A, B] =
69-
new ParallelBitraverseOps[T, A, B](tab)
87+
new ParallelBitraverseOps(tab)
7088

7189
implicit final def catsSyntaxParallelBisequence[T[_, _]: Bitraverse, M[_], A, B](
7290
tmamb: T[M[A], M[B]]
7391
): ParallelBisequenceOps[T, M, A, B] =
74-
new ParallelBisequenceOps[T, M, A, B](tmamb)
92+
new ParallelBisequenceOps(tmamb)
7593

7694
implicit final def catsSyntaxParallelLeftTraverse[T[_, _]: Bitraverse, A, B](
7795
tab: T[A, B]
7896
): ParallelLeftTraverseOps[T, A, B] =
79-
new ParallelLeftTraverseOps[T, A, B](tab)
97+
new ParallelLeftTraverseOps(tab)
8098

8199
implicit final def catsSyntaxParallelLeftSequence[T[_, _]: Bitraverse, M[_], A, B](
82100
tmab: T[M[A], B]
83101
): ParallelLeftSequenceOps[T, M, A, B] =
84-
new ParallelLeftSequenceOps[T, M, A, B](tmab)
102+
new ParallelLeftSequenceOps(tmab)
85103
}
86104

87105
trait ParallelUnorderedTraverseSyntax {
88106
implicit final def catsSyntaxParallelUnorderedTraverse[T[_], A](
89107
ta: T[A]
90108
): ParallelUnorderedTraverseOps[T, A] =
91-
new ParallelUnorderedTraverseOps[T, A](ta)
109+
new ParallelUnorderedTraverseOps(ta)
92110

93111
implicit final def catsSyntaxParallelUnorderedSequence[T[_], M[_], A](
94112
tma: T[M[A]]
95113
): ParallelUnorderedSequenceOps[T, M, A] =
96-
new ParallelUnorderedSequenceOps[T, M, A](tma)
114+
new ParallelUnorderedSequenceOps(tma)
97115

98116
implicit final def catsSyntaxParallelUnorderedFlatSequence[T[_], M[_], A](
99117
tmta: T[M[T[A]]]
100118
): ParallelUnorderedFlatSequenceOps[T, M, A] =
101-
new ParallelUnorderedFlatSequenceOps[T, M, A](tmta)
102-
119+
new ParallelUnorderedFlatSequenceOps(tmta)
103120
}
104121

105122
trait ParallelFoldMapASyntax {
106123
implicit final def catsSyntaxParallelFoldMapA[T[_], A](ta: T[A]): ParallelFoldMapAOps[T, A] =
107-
new ParallelFoldMapAOps[T, A](ta)
124+
new ParallelFoldMapAOps(ta)
108125
}
109126

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

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

116138
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
131153
Parallel.parTraverse_(ta)(f)
132154
}
133155

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

164+
final class ParallelFlatTraversableOps1[T[_], A](private val ta: T[A]) extends AnyVal {
165+
def parFlatTraverse[M[_], B](f: A => M[T[B]])(implicit T0: Traverse[T], T1: FlatMap[T], P: Parallel[M]): M[T[B]] =
166+
Parallel.parFlatTraverse(ta)(f)
167+
}
168+
169+
@deprecated("Kept for binary compatibility", "2.6.0")
141170
final class ParallelSequenceOps[T[_], M[_], A](private val tma: T[M[A]]) extends AnyVal {
142171
def parSequence(implicit M: Monad[M], T: Traverse[T], P: Parallel[M]): M[T[A]] =
143172
Parallel.parSequence(tma)
144173
}
145174

175+
final class ParallelSequenceOps1[T[_], M[_], A](private val tma: T[M[A]]) extends AnyVal {
176+
def parSequence(implicit T: Traverse[T], P: Parallel[M]): M[T[A]] =
177+
Parallel.parSequence(tma)
178+
}
179+
146180
final class ParallelSequence_Ops[T[_], M[_], A](private val tma: T[M[A]]) extends AnyVal {
147181
def parSequence_(implicit T: Foldable[T], P: Parallel[M]): M[Unit] =
148182
Parallel.parSequence_(tma)
149183
}
150184

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

191+
final class ParallelFlatSequenceOps1[T[_], M[_], A](private val tmta: T[M[T[A]]]) extends AnyVal {
192+
def parFlatSequence(implicit T0: Traverse[T], T1: FlatMap[T], P: Parallel[M]): M[T[A]] =
193+
Parallel.parFlatSequence(tmta)
194+
}
195+
156196
final class ParallelUnorderedSequenceOps[T[_], M[_], A](private val tmta: T[M[A]]) extends AnyVal {
157197
def parUnorderedSequence[F[_]](implicit
158198
P: Parallel.Aux[M, F],

0 commit comments

Comments
 (0)