Use helper functions in generated code #4303
Open
+36
−51
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
joroKr21
force-pushed
the
helper-boilerplate
branch
from
95ff4bf to
9ae2ce5
Compare
joroKr21
force-pushed
the
helper-boilerplate
branch
from
9ae2ce5 to
007ea26
Compare
|
Can you post a diff of the before/after? it'd help review this, otherwise all reviewers have to check on their own |
joroKr21
force-pushed
the
helper-boilerplate
branch
from
007ea26 to
1926ba8
Compare
diff --git a/./core/.jvm/target/scala-2.13/src_managed_main/main/cats/FlatMapArityFunctions.scala b/./core/.jvm/target/scala-2.13/src_managed/main/cats/FlatMapArityFunctions.scala
index 8654c44db..d101f5b5c 100644
--- a/./core/.jvm/target/scala-2.13/src_managed_main/main/cats/FlatMapArityFunctions.scala
+++ b/./core/.jvm/target/scala-2.13/src_managed/main/cats/FlatMapArityFunctions.scala
@@ -10,45 +10,66 @@ package cats
*/
trait FlatMapArityFunctions[F[_]] { self: FlatMap[F] =>
/** @group FlatMapArity */
- def flatMap2[A0, A1, Z](f0:F[A0], f1:F[A1])(f: (A0, A1) => F[Z]): F[Z] = self.flatten(self.map2(f0:F[A0], f1:F[A1])(f))
+ def flatMap2[A0, A1, Z](f0:F[A0], f1:F[A1])(f: (A0, A1) => F[Z]): F[Z] =
+ flatten(map2(f0, f1)(f))
/** @group FlatMapArity */
- def flatMap3[A0, A1, A2, Z](f0:F[A0], f1:F[A1], f2:F[A2])(f: (A0, A1, A2) => F[Z]): F[Z] = self.flatten(self.map3(f0:F[A0], f1:F[A1], f2:F[A2])(f))
+ def flatMap3[A0, A1, A2, Z](f0:F[A0], f1:F[A1], f2:F[A2])(f: (A0, A1, A2) => F[Z]): F[Z] =
+ flatten(map3(f0, f1, f2)(f))
/** @group FlatMapArity */
- def flatMap4[A0, A1, A2, A3, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3])(f: (A0, A1, A2, A3) => F[Z]): F[Z] = self.flatten(self.map4(f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3])(f))
+ def flatMap4[A0, A1, A2, A3, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3])(f: (A0, A1, A2, A3) => F[Z]): F[Z] =
+ flatten(map4(f0, f1, f2, f3)(f))
/** @group FlatMapArity */
- def flatMap5[A0, A1, A2, A3, A4, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4])(f: (A0, A1, A2, A3, A4) => F[Z]): F[Z] = self.flatten(self.map5(f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4])(f))
+ def flatMap5[A0, A1, A2, A3, A4, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4])(f: (A0, A1, A2, A3, A4) => F[Z]): F[Z] =
+ flatten(map5(f0, f1, f2, f3, f4)(f))
/** @group FlatMapArity */
- def flatMap6[A0, A1, A2, A3, A4, A5, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5])(f: (A0, A1, A2, A3, A4, A5) => F[Z]): F[Z] = self.flatten(self.map6(f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5])(f))
+ def flatMap6[A0, A1, A2, A3, A4, A5, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5])(f: (A0, A1, A2, A3, A4, A5) => F[Z]): F[Z] =
+ flatten(map6(f0, f1, f2, f3, f4, f5)(f))
/** @group FlatMapArity */
- def flatMap7[A0, A1, A2, A3, A4, A5, A6, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => F[Z]): F[Z] = self.flatten(self.map7(f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6])(f))
+ def flatMap7[A0, A1, A2, A3, A4, A5, A6, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => F[Z]): F[Z] =
+ flatten(map7(f0, f1, f2, f3, f4, f5, f6)(f))
/** @group FlatMapArity */
- def flatMap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => F[Z]): F[Z] = self.flatten(self.map8(f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7])(f))
+ def flatMap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => F[Z]): F[Z] =
+ flatten(map8(f0, f1, f2, f3, f4, f5, f6, f7)(f))
/** @group FlatMapArity */
- def flatMap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => F[Z]): F[Z] = self.flatten(self.map9(f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8])(f))
+ def flatMap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => F[Z]): F[Z] =
+ flatten(map9(f0, f1, f2, f3, f4, f5, f6, f7, f8)(f))
/** @group FlatMapArity */
- def flatMap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => F[Z]): F[Z] = self.flatten(self.map10(f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9])(f))
+ def flatMap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => F[Z]): F[Z] =
+ flatten(map10(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9)(f))
/** @group FlatMapArity */
- def flatMap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => F[Z]): F[Z] = self.flatten(self.map11(f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10])(f))
+ def flatMap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => F[Z]): F[Z] =
+ flatten(map11(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)(f))
/** @group FlatMapArity */
- def flatMap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => F[Z]): F[Z] = self.flatten(self.map12(f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11])(f))
+ def flatMap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => F[Z]): F[Z] =
+ flatten(map12(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11)(f))
/** @group FlatMapArity */
- def flatMap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => F[Z]): F[Z] = self.flatten(self.map13(f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12])(f))
+ def flatMap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => F[Z]): F[Z] =
+ flatten(map13(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12)(f))
/** @group FlatMapArity */
- def flatMap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => F[Z]): F[Z] = self.flatten(self.map14(f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13])(f))
+ def flatMap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => F[Z]): F[Z] =
+ flatten(map14(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13)(f))
/** @group FlatMapArity */
- def flatMap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => F[Z]): F[Z] = self.flatten(self.map15(f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14])(f))
+ def flatMap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => F[Z]): F[Z] =
+ flatten(map15(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14)(f))
/** @group FlatMapArity */
- def flatMap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => F[Z]): F[Z] = self.flatten(self.map16(f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15])(f))
+ def flatMap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => F[Z]): F[Z] =
+ flatten(map16(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15)(f))
/** @group FlatMapArity */
- def flatMap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => F[Z]): F[Z] = self.flatten(self.map17(f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16])(f))
+ def flatMap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => F[Z]): F[Z] =
+ flatten(map17(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16)(f))
/** @group FlatMapArity */
- def flatMap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => F[Z]): F[Z] = self.flatten(self.map18(f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17])(f))
+ def flatMap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => F[Z]): F[Z] =
+ flatten(map18(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17)(f))
/** @group FlatMapArity */
- def flatMap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => F[Z]): F[Z] = self.flatten(self.map19(f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18])(f))
+ def flatMap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => F[Z]): F[Z] =
+ flatten(map19(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18)(f))
/** @group FlatMapArity */
- def flatMap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18], f19:F[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => F[Z]): F[Z] = self.flatten(self.map20(f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18], f19:F[A19])(f))
+ def flatMap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18], f19:F[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => F[Z]): F[Z] =
+ flatten(map20(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19)(f))
/** @group FlatMapArity */
- def flatMap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18], f19:F[A19], f20:F[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => F[Z]): F[Z] = self.flatten(self.map21(f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18], f19:F[A19], f20:F[A20])(f))
+ def flatMap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18], f19:F[A19], f20:F[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => F[Z]): F[Z] =
+ flatten(map21(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20)(f))
/** @group FlatMapArity */
- def flatMap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18], f19:F[A19], f20:F[A20], f21:F[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => F[Z]): F[Z] = self.flatten(self.map22(f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18], f19:F[A19], f20:F[A20], f21:F[A21])(f))
+ def flatMap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18], f19:F[A19], f20:F[A20], f21:F[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => F[Z]): F[Z] =
+ flatten(map22(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21)(f))
}
\ No newline at end of file
diff --git a/./core/.jvm/target/scala-2.13/src_managed_main/main/cats/FoldableNFunctions.scala b/./core/.jvm/target/scala-2.13/src_managed/main/cats/FoldableNFunctions.scala
index 1c00aafca..eadbe0071 100644
--- a/./core/.jvm/target/scala-2.13/src_managed_main/main/cats/FoldableNFunctions.scala
+++ b/./core/.jvm/target/scala-2.13/src_managed/main/cats/FoldableNFunctions.scala
@@ -27,67 +27,70 @@ package cats
*
*/
trait FoldableNFunctions[F[_]] { self: Foldable[F] =>
+ private def slidingN[A, B](fa: F[A], n: Int)(f: Seq[A] => B) =
+ toIterable(fa).iterator.sliding(n).withPartial(false).map(f).toList
+
/** @group FoldableSlidingN */
def sliding2[A](fa: F[A]): List[(A, A)] =
- toIterable(fa).iterator.sliding(2).withPartial(false).map(x => (x(0), x(1))).toList
+ slidingN(fa, 2)(x => (x(0), x(1)))
/** @group FoldableSlidingN */
def sliding3[A](fa: F[A]): List[(A, A, A)] =
- toIterable(fa).iterator.sliding(3).withPartial(false).map(x => (x(0), x(1), x(2))).toList
+ slidingN(fa, 3)(x => (x(0), x(1), x(2)))
/** @group FoldableSlidingN */
def sliding4[A](fa: F[A]): List[(A, A, A, A)] =
- toIterable(fa).iterator.sliding(4).withPartial(false).map(x => (x(0), x(1), x(2), x(3))).toList
+ slidingN(fa, 4)(x => (x(0), x(1), x(2), x(3)))
/** @group FoldableSlidingN */
def sliding5[A](fa: F[A]): List[(A, A, A, A, A)] =
- toIterable(fa).iterator.sliding(5).withPartial(false).map(x => (x(0), x(1), x(2), x(3), x(4))).toList
+ slidingN(fa, 5)(x => (x(0), x(1), x(2), x(3), x(4)))
/** @group FoldableSlidingN */
def sliding6[A](fa: F[A]): List[(A, A, A, A, A, A)] =
- toIterable(fa).iterator.sliding(6).withPartial(false).map(x => (x(0), x(1), x(2), x(3), x(4), x(5))).toList
+ slidingN(fa, 6)(x => (x(0), x(1), x(2), x(3), x(4), x(5)))
/** @group FoldableSlidingN */
def sliding7[A](fa: F[A]): List[(A, A, A, A, A, A, A)] =
- toIterable(fa).iterator.sliding(7).withPartial(false).map(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6))).toList
+ slidingN(fa, 7)(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6)))
/** @group FoldableSlidingN */
def sliding8[A](fa: F[A]): List[(A, A, A, A, A, A, A, A)] =
- toIterable(fa).iterator.sliding(8).withPartial(false).map(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7))).toList
+ slidingN(fa, 8)(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7)))
/** @group FoldableSlidingN */
def sliding9[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A)] =
- toIterable(fa).iterator.sliding(9).withPartial(false).map(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8))).toList
+ slidingN(fa, 9)(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8)))
/** @group FoldableSlidingN */
def sliding10[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A)] =
- toIterable(fa).iterator.sliding(10).withPartial(false).map(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9))).toList
+ slidingN(fa, 10)(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9)))
/** @group FoldableSlidingN */
def sliding11[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A)] =
- toIterable(fa).iterator.sliding(11).withPartial(false).map(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10))).toList
+ slidingN(fa, 11)(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10)))
/** @group FoldableSlidingN */
def sliding12[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A)] =
- toIterable(fa).iterator.sliding(12).withPartial(false).map(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11))).toList
+ slidingN(fa, 12)(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11)))
/** @group FoldableSlidingN */
def sliding13[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A)] =
- toIterable(fa).iterator.sliding(13).withPartial(false).map(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12))).toList
+ slidingN(fa, 13)(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12)))
/** @group FoldableSlidingN */
def sliding14[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A)] =
- toIterable(fa).iterator.sliding(14).withPartial(false).map(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12), x(13))).toList
+ slidingN(fa, 14)(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12), x(13)))
/** @group FoldableSlidingN */
def sliding15[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)] =
- toIterable(fa).iterator.sliding(15).withPartial(false).map(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12), x(13), x(14))).toList
+ slidingN(fa, 15)(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12), x(13), x(14)))
/** @group FoldableSlidingN */
def sliding16[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)] =
- toIterable(fa).iterator.sliding(16).withPartial(false).map(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12), x(13), x(14), x(15))).toList
+ slidingN(fa, 16)(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12), x(13), x(14), x(15)))
/** @group FoldableSlidingN */
def sliding17[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)] =
- toIterable(fa).iterator.sliding(17).withPartial(false).map(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12), x(13), x(14), x(15), x(16))).toList
+ slidingN(fa, 17)(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12), x(13), x(14), x(15), x(16)))
/** @group FoldableSlidingN */
def sliding18[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)] =
- toIterable(fa).iterator.sliding(18).withPartial(false).map(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12), x(13), x(14), x(15), x(16), x(17))).toList
+ slidingN(fa, 18)(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12), x(13), x(14), x(15), x(16), x(17)))
/** @group FoldableSlidingN */
def sliding19[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)] =
- toIterable(fa).iterator.sliding(19).withPartial(false).map(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12), x(13), x(14), x(15), x(16), x(17), x(18))).toList
+ slidingN(fa, 19)(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12), x(13), x(14), x(15), x(16), x(17), x(18)))
/** @group FoldableSlidingN */
def sliding20[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)] =
- toIterable(fa).iterator.sliding(20).withPartial(false).map(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12), x(13), x(14), x(15), x(16), x(17), x(18), x(19))).toList
+ slidingN(fa, 20)(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12), x(13), x(14), x(15), x(16), x(17), x(18), x(19)))
/** @group FoldableSlidingN */
def sliding21[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)] =
- toIterable(fa).iterator.sliding(21).withPartial(false).map(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12), x(13), x(14), x(15), x(16), x(17), x(18), x(19), x(20))).toList
+ slidingN(fa, 21)(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12), x(13), x(14), x(15), x(16), x(17), x(18), x(19), x(20)))
/** @group FoldableSlidingN */
def sliding22[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)] =
- toIterable(fa).iterator.sliding(22).withPartial(false).map(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12), x(13), x(14), x(15), x(16), x(17), x(18), x(19), x(20), x(21))).toList
+ slidingN(fa, 22)(x => (x(0), x(1), x(2), x(3), x(4), x(5), x(6), x(7), x(8), x(9), x(10), x(11), x(12), x(13), x(14), x(15), x(16), x(17), x(18), x(19), x(20), x(21)))
}
\ No newline at end of file
diff --git a/./core/.jvm/target/scala-2.13/src_managed_main/main/cats/ParallelArityFunctions2.scala b/./core/.jvm/target/scala-2.13/src_managed/main/cats/ParallelArityFunctions2.scala
index 30b0b3665..0c74f1c15 100644
--- a/./core/.jvm/target/scala-2.13/src_managed_main/main/cats/ParallelArityFunctions2.scala
+++ b/./core/.jvm/target/scala-2.13/src_managed/main/cats/ParallelArityFunctions2.scala
@@ -11,65 +11,65 @@ package cats
abstract class ParallelArityFunctions2 extends ParallelArityFunctions {
/** @group ParTupleArity */
def parTuple2[M[_], A0, A1](m0:M[A0], m1:M[A1])(implicit p: NonEmptyParallel[M]): M[(A0, A1)] =
- p.flatMap.map(Parallel.parProduct(m0, m1)) { case (a0, a1) => (a0, a1) }
+ parMap2(m0, m1)(Tuple2.apply)
/** @group ParTupleArity */
def parTuple3[M[_], A0, A1, A2](m0:M[A0], m1:M[A1], m2:M[A2])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, m2))) { case (a0, (a1, a2)) => (a0, a1, a2) }
+ parMap3(m0, m1, m2)(Tuple3.apply)
/** @group ParTupleArity */
def parTuple4[M[_], A0, A1, A2, A3](m0:M[A0], m1:M[A1], m2:M[A2], m3:M[A3])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, Parallel.parProduct(m2, m3)))) { case (a0, (a1, (a2, a3))) => (a0, a1, a2, a3) }
+ parMap4(m0, m1, m2, m3)(Tuple4.apply)
/** @group ParTupleArity */
def parTuple5[M[_], A0, A1, A2, A3, A4](m0:M[A0], m1:M[A1], m2:M[A2], m3:M[A3], m4:M[A4])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, Parallel.parProduct(m2, Parallel.parProduct(m3, m4))))) { case (a0, (a1, (a2, (a3, a4)))) => (a0, a1, a2, a3, a4) }
+ parMap5(m0, m1, m2, m3, m4)(Tuple5.apply)
/** @group ParTupleArity */
def parTuple6[M[_], A0, A1, A2, A3, A4, A5](m0:M[A0], m1:M[A1], m2:M[A2], m3:M[A3], m4:M[A4], m5:M[A5])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, Parallel.parProduct(m2, Parallel.parProduct(m3, Parallel.parProduct(m4, m5)))))) { case (a0, (a1, (a2, (a3, (a4, a5))))) => (a0, a1, a2, a3, a4, a5) }
+ parMap6(m0, m1, m2, m3, m4, m5)(Tuple6.apply)
/** @group ParTupleArity */
def parTuple7[M[_], A0, A1, A2, A3, A4, A5, A6](m0:M[A0], m1:M[A1], m2:M[A2], m3:M[A3], m4:M[A4], m5:M[A5], m6:M[A6])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, Parallel.parProduct(m2, Parallel.parProduct(m3, Parallel.parProduct(m4, Parallel.parProduct(m5, m6))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, a6)))))) => (a0, a1, a2, a3, a4, a5, a6) }
+ parMap7(m0, m1, m2, m3, m4, m5, m6)(Tuple7.apply)
/** @group ParTupleArity */
def parTuple8[M[_], A0, A1, A2, A3, A4, A5, A6, A7](m0:M[A0], m1:M[A1], m2:M[A2], m3:M[A3], m4:M[A4], m5:M[A5], m6:M[A6], m7:M[A7])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, Parallel.parProduct(m2, Parallel.parProduct(m3, Parallel.parProduct(m4, Parallel.parProduct(m5, Parallel.parProduct(m6, m7)))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, a7))))))) => (a0, a1, a2, a3, a4, a5, a6, a7) }
+ parMap8(m0, m1, m2, m3, m4, m5, m6, m7)(Tuple8.apply)
/** @group ParTupleArity */
def parTuple9[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8](m0:M[A0], m1:M[A1], m2:M[A2], m3:M[A3], m4:M[A4], m5:M[A5], m6:M[A6], m7:M[A7], m8:M[A8])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, Parallel.parProduct(m2, Parallel.parProduct(m3, Parallel.parProduct(m4, Parallel.parProduct(m5, Parallel.parProduct(m6, Parallel.parProduct(m7, m8))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, a8)))))))) => (a0, a1, a2, a3, a4, a5, a6, a7, a8) }
+ parMap9(m0, m1, m2, m3, m4, m5, m6, m7, m8)(Tuple9.apply)
/** @group ParTupleArity */
def parTuple10[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](m0:M[A0], m1:M[A1], m2:M[A2], m3:M[A3], m4:M[A4], m5:M[A5], m6:M[A6], m7:M[A7], m8:M[A8], m9:M[A9])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, Parallel.parProduct(m2, Parallel.parProduct(m3, Parallel.parProduct(m4, Parallel.parProduct(m5, Parallel.parProduct(m6, Parallel.parProduct(m7, Parallel.parProduct(m8, m9)))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, a9))))))))) => (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) }
+ parMap10(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9)(Tuple10.apply)
/** @group ParTupleArity */
def parTuple11[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](m0:M[A0], m1:M[A1], m2:M[A2], m3:M[A3], m4:M[A4], m5:M[A5], m6:M[A6], m7:M[A7], m8:M[A8], m9:M[A9], m10:M[A10])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, Parallel.parProduct(m2, Parallel.parProduct(m3, Parallel.parProduct(m4, Parallel.parProduct(m5, Parallel.parProduct(m6, Parallel.parProduct(m7, Parallel.parProduct(m8, Parallel.parProduct(m9, m10))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, a10)))))))))) => (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) }
+ parMap11(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10)(Tuple11.apply)
/** @group ParTupleArity */
def parTuple12[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](m0:M[A0], m1:M[A1], m2:M[A2], m3:M[A3], m4:M[A4], m5:M[A5], m6:M[A6], m7:M[A7], m8:M[A8], m9:M[A9], m10:M[A10], m11:M[A11])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, Parallel.parProduct(m2, Parallel.parProduct(m3, Parallel.parProduct(m4, Parallel.parProduct(m5, Parallel.parProduct(m6, Parallel.parProduct(m7, Parallel.parProduct(m8, Parallel.parProduct(m9, Parallel.parProduct(m10, m11)))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, a11))))))))))) => (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) }
+ parMap12(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11)(Tuple12.apply)
/** @group ParTupleArity */
def parTuple13[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](m0:M[A0], m1:M[A1], m2:M[A2], m3:M[A3], m4:M[A4], m5:M[A5], m6:M[A6], m7:M[A7], m8:M[A8], m9:M[A9], m10:M[A10], m11:M[A11], m12:M[A12])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, Parallel.parProduct(m2, Parallel.parProduct(m3, Parallel.parProduct(m4, Parallel.parProduct(m5, Parallel.parProduct(m6, Parallel.parProduct(m7, Parallel.parProduct(m8, Parallel.parProduct(m9, Parallel.parProduct(m10, Parallel.parProduct(m11, m12))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, a12)))))))))))) => (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) }
+ parMap13(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12)(Tuple13.apply)
/** @group ParTupleArity */
def parTuple14[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](m0:M[A0], m1:M[A1], m2:M[A2], m3:M[A3], m4:M[A4], m5:M[A5], m6:M[A6], m7:M[A7], m8:M[A8], m9:M[A9], m10:M[A10], m11:M[A11], m12:M[A12], m13:M[A13])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, Parallel.parProduct(m2, Parallel.parProduct(m3, Parallel.parProduct(m4, Parallel.parProduct(m5, Parallel.parProduct(m6, Parallel.parProduct(m7, Parallel.parProduct(m8, Parallel.parProduct(m9, Parallel.parProduct(m10, Parallel.parProduct(m11, Parallel.parProduct(m12, m13)))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, a13))))))))))))) => (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) }
+ parMap14(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13)(Tuple14.apply)
/** @group ParTupleArity */
def parTuple15[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](m0:M[A0], m1:M[A1], m2:M[A2], m3:M[A3], m4:M[A4], m5:M[A5], m6:M[A6], m7:M[A7], m8:M[A8], m9:M[A9], m10:M[A10], m11:M[A11], m12:M[A12], m13:M[A13], m14:M[A14])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, Parallel.parProduct(m2, Parallel.parProduct(m3, Parallel.parProduct(m4, Parallel.parProduct(m5, Parallel.parProduct(m6, Parallel.parProduct(m7, Parallel.parProduct(m8, Parallel.parProduct(m9, Parallel.parProduct(m10, Parallel.parProduct(m11, Parallel.parProduct(m12, Parallel.parProduct(m13, m14))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, a14)))))))))))))) => (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) }
+ parMap15(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14)(Tuple15.apply)
/** @group ParTupleArity */
def parTuple16[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](m0:M[A0], m1:M[A1], m2:M[A2], m3:M[A3], m4:M[A4], m5:M[A5], m6:M[A6], m7:M[A7], m8:M[A8], m9:M[A9], m10:M[A10], m11:M[A11], m12:M[A12], m13:M[A13], m14:M[A14], m15:M[A15])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, Parallel.parProduct(m2, Parallel.parProduct(m3, Parallel.parProduct(m4, Parallel.parProduct(m5, Parallel.parProduct(m6, Parallel.parProduct(m7, Parallel.parProduct(m8, Parallel.parProduct(m9, Parallel.parProduct(m10, Parallel.parProduct(m11, Parallel.parProduct(m12, Parallel.parProduct(m13, Parallel.parProduct(m14, m15)))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, a15))))))))))))))) => (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) }
+ parMap16(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15)(Tuple16.apply)
/** @group ParTupleArity */
def parTuple17[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](m0:M[A0], m1:M[A1], m2:M[A2], m3:M[A3], m4:M[A4], m5:M[A5], m6:M[A6], m7:M[A7], m8:M[A8], m9:M[A9], m10:M[A10], m11:M[A11], m12:M[A12], m13:M[A13], m14:M[A14], m15:M[A15], m16:M[A16])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, Parallel.parProduct(m2, Parallel.parProduct(m3, Parallel.parProduct(m4, Parallel.parProduct(m5, Parallel.parProduct(m6, Parallel.parProduct(m7, Parallel.parProduct(m8, Parallel.parProduct(m9, Parallel.parProduct(m10, Parallel.parProduct(m11, Parallel.parProduct(m12, Parallel.parProduct(m13, Parallel.parProduct(m14, Parallel.parProduct(m15, m16))))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, a16)))))))))))))))) => (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) }
+ parMap17(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16)(Tuple17.apply)
/** @group ParTupleArity */
def parTuple18[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](m0:M[A0], m1:M[A1], m2:M[A2], m3:M[A3], m4:M[A4], m5:M[A5], m6:M[A6], m7:M[A7], m8:M[A8], m9:M[A9], m10:M[A10], m11:M[A11], m12:M[A12], m13:M[A13], m14:M[A14], m15:M[A15], m16:M[A16], m17:M[A17])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, Parallel.parProduct(m2, Parallel.parProduct(m3, Parallel.parProduct(m4, Parallel.parProduct(m5, Parallel.parProduct(m6, Parallel.parProduct(m7, Parallel.parProduct(m8, Parallel.parProduct(m9, Parallel.parProduct(m10, Parallel.parProduct(m11, Parallel.parProduct(m12, Parallel.parProduct(m13, Parallel.parProduct(m14, Parallel.parProduct(m15, Parallel.parProduct(m16, m17)))))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, a17))))))))))))))))) => (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) }
+ parMap18(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17)(Tuple18.apply)
/** @group ParTupleArity */
def parTuple19[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](m0:M[A0], m1:M[A1], m2:M[A2], m3:M[A3], m4:M[A4], m5:M[A5], m6:M[A6], m7:M[A7], m8:M[A8], m9:M[A9], m10:M[A10], m11:M[A11], m12:M[A12], m13:M[A13], m14:M[A14], m15:M[A15], m16:M[A16], m17:M[A17], m18:M[A18])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, Parallel.parProduct(m2, Parallel.parProduct(m3, Parallel.parProduct(m4, Parallel.parProduct(m5, Parallel.parProduct(m6, Parallel.parProduct(m7, Parallel.parProduct(m8, Parallel.parProduct(m9, Parallel.parProduct(m10, Parallel.parProduct(m11, Parallel.parProduct(m12, Parallel.parProduct(m13, Parallel.parProduct(m14, Parallel.parProduct(m15, Parallel.parProduct(m16, Parallel.parProduct(m17, m18))))))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, (a17, a18)))))))))))))))))) => (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) }
+ parMap19(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18)(Tuple19.apply)
/** @group ParTupleArity */
def parTuple20[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](m0:M[A0], m1:M[A1], m2:M[A2], m3:M[A3], m4:M[A4], m5:M[A5], m6:M[A6], m7:M[A7], m8:M[A8], m9:M[A9], m10:M[A10], m11:M[A11], m12:M[A12], m13:M[A13], m14:M[A14], m15:M[A15], m16:M[A16], m17:M[A17], m18:M[A18], m19:M[A19])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, Parallel.parProduct(m2, Parallel.parProduct(m3, Parallel.parProduct(m4, Parallel.parProduct(m5, Parallel.parProduct(m6, Parallel.parProduct(m7, Parallel.parProduct(m8, Parallel.parProduct(m9, Parallel.parProduct(m10, Parallel.parProduct(m11, Parallel.parProduct(m12, Parallel.parProduct(m13, Parallel.parProduct(m14, Parallel.parProduct(m15, Parallel.parProduct(m16, Parallel.parProduct(m17, Parallel.parProduct(m18, m19)))))))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, (a17, (a18, a19))))))))))))))))))) => (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) }
+ parMap20(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19)(Tuple20.apply)
/** @group ParTupleArity */
def parTuple21[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](m0:M[A0], m1:M[A1], m2:M[A2], m3:M[A3], m4:M[A4], m5:M[A5], m6:M[A6], m7:M[A7], m8:M[A8], m9:M[A9], m10:M[A10], m11:M[A11], m12:M[A12], m13:M[A13], m14:M[A14], m15:M[A15], m16:M[A16], m17:M[A17], m18:M[A18], m19:M[A19], m20:M[A20])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, Parallel.parProduct(m2, Parallel.parProduct(m3, Parallel.parProduct(m4, Parallel.parProduct(m5, Parallel.parProduct(m6, Parallel.parProduct(m7, Parallel.parProduct(m8, Parallel.parProduct(m9, Parallel.parProduct(m10, Parallel.parProduct(m11, Parallel.parProduct(m12, Parallel.parProduct(m13, Parallel.parProduct(m14, Parallel.parProduct(m15, Parallel.parProduct(m16, Parallel.parProduct(m17, Parallel.parProduct(m18, Parallel.parProduct(m19, m20))))))))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, (a17, (a18, (a19, a20)))))))))))))))))))) => (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) }
+ parMap21(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20)(Tuple21.apply)
/** @group ParTupleArity */
def parTuple22[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](m0:M[A0], m1:M[A1], m2:M[A2], m3:M[A3], m4:M[A4], m5:M[A5], m6:M[A6], m7:M[A7], m8:M[A8], m9:M[A9], m10:M[A10], m11:M[A11], m12:M[A12], m13:M[A13], m14:M[A14], m15:M[A15], m16:M[A16], m17:M[A17], m18:M[A18], m19:M[A19], m20:M[A20], m21:M[A21])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)] =
- p.flatMap.map(Parallel.parProduct(m0, Parallel.parProduct(m1, Parallel.parProduct(m2, Parallel.parProduct(m3, Parallel.parProduct(m4, Parallel.parProduct(m5, Parallel.parProduct(m6, Parallel.parProduct(m7, Parallel.parProduct(m8, Parallel.parProduct(m9, Parallel.parProduct(m10, Parallel.parProduct(m11, Parallel.parProduct(m12, Parallel.parProduct(m13, Parallel.parProduct(m14, Parallel.parProduct(m15, Parallel.parProduct(m16, Parallel.parProduct(m17, Parallel.parProduct(m18, Parallel.parProduct(m19, Parallel.parProduct(m20, m21)))))))))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, (a17, (a18, (a19, (a20, a21))))))))))))))))))))) => (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) }
+ parMap22(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21)(Tuple22.apply)
}
\ No newline at end of file
diff --git a/./core/.jvm/target/scala-2.13/src_managed_main/main/cats/SemigroupalArityFunctions.scala b/./core/.jvm/target/scala-2.13/src_managed/main/cats/SemigroupalArityFunctions.scala
index 9977b8562..aea4d0b89 100644
--- a/./core/.jvm/target/scala-2.13/src_managed_main/main/cats/SemigroupalArityFunctions.scala
+++ b/./core/.jvm/target/scala-2.13/src_managed/main/cats/SemigroupalArityFunctions.scala
@@ -36,7 +36,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, f1)) { case (a0, a1) => f(a0, a1) } { z => val (a0, a1) = g(z); (a0, a1) }
/** @group TupleArity */
def tuple2[F[_], A0, A1](f0:F[A0], f1:F[A1])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1)] =
- imap2(f0, f1)((_, _))(identity)
+ imap2(f0, f1)(Tuple2.apply)(identity)
/** @group TraverseArity */
def traverse2[F[_], G[_], A0, A1, Z](f0:F[A0], f1:F[A1])(f: (A0, A1) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, f1)) { case (a0, a1) => f(a0, a1) }
@@ -51,7 +51,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, f2))) { case (a0, (a1, a2)) => f(a0, a1, a2) } { z => val (a0, a1, a2) = g(z); (a0, (a1, a2)) }
/** @group TupleArity */
def tuple3[F[_], A0, A1, A2](f0:F[A0], f1:F[A1], f2:F[A2])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2)] =
- imap3(f0, f1, f2)((_, _, _))(identity)
+ imap3(f0, f1, f2)(Tuple3.apply)(identity)
/** @group TraverseArity */
def traverse3[F[_], G[_], A0, A1, A2, Z](f0:F[A0], f1:F[A1], f2:F[A2])(f: (A0, A1, A2) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, f2))) { case (a0, (a1, a2)) => f(a0, a1, a2) }
@@ -66,7 +66,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, f3)))) { case (a0, (a1, (a2, a3))) => f(a0, a1, a2, a3) } { z => val (a0, a1, a2, a3) = g(z); (a0, (a1, (a2, a3))) }
/** @group TupleArity */
def tuple4[F[_], A0, A1, A2, A3](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2, A3)] =
- imap4(f0, f1, f2, f3)((_, _, _, _))(identity)
+ imap4(f0, f1, f2, f3)(Tuple4.apply)(identity)
/** @group TraverseArity */
def traverse4[F[_], G[_], A0, A1, A2, A3, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3])(f: (A0, A1, A2, A3) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, f3)))) { case (a0, (a1, (a2, a3))) => f(a0, a1, a2, a3) }
@@ -81,7 +81,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, f4))))) { case (a0, (a1, (a2, (a3, a4)))) => f(a0, a1, a2, a3, a4) } { z => val (a0, a1, a2, a3, a4) = g(z); (a0, (a1, (a2, (a3, a4)))) }
/** @group TupleArity */
def tuple5[F[_], A0, A1, A2, A3, A4](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2, A3, A4)] =
- imap5(f0, f1, f2, f3, f4)((_, _, _, _, _))(identity)
+ imap5(f0, f1, f2, f3, f4)(Tuple5.apply)(identity)
/** @group TraverseArity */
def traverse5[F[_], G[_], A0, A1, A2, A3, A4, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4])(f: (A0, A1, A2, A3, A4) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, f4))))) { case (a0, (a1, (a2, (a3, a4)))) => f(a0, a1, a2, a3, a4) }
@@ -96,7 +96,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, f5)))))) { case (a0, (a1, (a2, (a3, (a4, a5))))) => f(a0, a1, a2, a3, a4, a5) } { z => val (a0, a1, a2, a3, a4, a5) = g(z); (a0, (a1, (a2, (a3, (a4, a5))))) }
/** @group TupleArity */
def tuple6[F[_], A0, A1, A2, A3, A4, A5](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2, A3, A4, A5)] =
- imap6(f0, f1, f2, f3, f4, f5)((_, _, _, _, _, _))(identity)
+ imap6(f0, f1, f2, f3, f4, f5)(Tuple6.apply)(identity)
/** @group TraverseArity */
def traverse6[F[_], G[_], A0, A1, A2, A3, A4, A5, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5])(f: (A0, A1, A2, A3, A4, A5) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, f5)))))) { case (a0, (a1, (a2, (a3, (a4, a5))))) => f(a0, a1, a2, a3, a4, a5) }
@@ -111,7 +111,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, f6))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, a6)))))) => f(a0, a1, a2, a3, a4, a5, a6) } { z => val (a0, a1, a2, a3, a4, a5, a6) = g(z); (a0, (a1, (a2, (a3, (a4, (a5, a6)))))) }
/** @group TupleArity */
def tuple7[F[_], A0, A1, A2, A3, A4, A5, A6](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2, A3, A4, A5, A6)] =
- imap7(f0, f1, f2, f3, f4, f5, f6)((_, _, _, _, _, _, _))(identity)
+ imap7(f0, f1, f2, f3, f4, f5, f6)(Tuple7.apply)(identity)
/** @group TraverseArity */
def traverse7[F[_], G[_], A0, A1, A2, A3, A4, A5, A6, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, f6))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, a6)))))) => f(a0, a1, a2, a3, a4, a5, a6) }
@@ -126,7 +126,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, f7)))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, a7))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7) } { z => val (a0, a1, a2, a3, a4, a5, a6, a7) = g(z); (a0, (a1, (a2, (a3, (a4, (a5, (a6, a7))))))) }
/** @group TupleArity */
def tuple8[F[_], A0, A1, A2, A3, A4, A5, A6, A7](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2, A3, A4, A5, A6, A7)] =
- imap8(f0, f1, f2, f3, f4, f5, f6, f7)((_, _, _, _, _, _, _, _))(identity)
+ imap8(f0, f1, f2, f3, f4, f5, f6, f7)(Tuple8.apply)(identity)
/** @group TraverseArity */
def traverse8[F[_], G[_], A0, A1, A2, A3, A4, A5, A6, A7, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, f7)))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, a7))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7) }
@@ -141,7 +141,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, f8))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, a8)))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8) } { z => val (a0, a1, a2, a3, a4, a5, a6, a7, a8) = g(z); (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, a8)))))))) }
/** @group TupleArity */
def tuple9[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2, A3, A4, A5, A6, A7, A8)] =
- imap9(f0, f1, f2, f3, f4, f5, f6, f7, f8)((_, _, _, _, _, _, _, _, _))(identity)
+ imap9(f0, f1, f2, f3, f4, f5, f6, f7, f8)(Tuple9.apply)(identity)
/** @group TraverseArity */
def traverse9[F[_], G[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, f8))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, a8)))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8) }
@@ -156,7 +156,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, f9)))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, a9))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) } { z => val (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) = g(z); (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, a9))))))))) }
/** @group TupleArity */
def tuple10[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)] =
- imap10(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9)((_, _, _, _, _, _, _, _, _, _))(identity)
+ imap10(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9)(Tuple10.apply)(identity)
/** @group TraverseArity */
def traverse10[F[_], G[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, f9)))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, a9))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) }
@@ -171,7 +171,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, f10))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, a10)))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) } { z => val (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) = g(z); (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, a10)))))))))) }
/** @group TupleArity */
def tuple11[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)] =
- imap11(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)((_, _, _, _, _, _, _, _, _, _, _))(identity)
+ imap11(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)(Tuple11.apply)(identity)
/** @group TraverseArity */
def traverse11[F[_], G[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, f10))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, a10)))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) }
@@ -186,7 +186,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, f11)))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, a11))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) } { z => val (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) = g(z); (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, a11))))))))))) }
/** @group TupleArity */
def tuple12[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)] =
- imap12(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11)((_, _, _, _, _, _, _, _, _, _, _, _))(identity)
+ imap12(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11)(Tuple12.apply)(identity)
/** @group TraverseArity */
def traverse12[F[_], G[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, f11)))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, a11))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) }
@@ -201,7 +201,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, f12))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, a12)))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) } { z => val (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) = g(z); (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, a12)))))))))))) }
/** @group TupleArity */
def tuple13[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)] =
- imap13(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12)((_, _, _, _, _, _, _, _, _, _, _, _, _))(identity)
+ imap13(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12)(Tuple13.apply)(identity)
/** @group TraverseArity */
def traverse13[F[_], G[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, f12))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, a12)))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) }
@@ -216,7 +216,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, semigroupal.product(f12, f13)))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, a13))))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) } { z => val (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) = g(z); (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, a13))))))))))))) }
/** @group TupleArity */
def tuple14[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)] =
- imap14(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13)((_, _, _, _, _, _, _, _, _, _, _, _, _, _))(identity)
+ imap14(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13)(Tuple14.apply)(identity)
/** @group TraverseArity */
def traverse14[F[_], G[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, semigroupal.product(f12, f13)))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, a13))))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) }
@@ -231,7 +231,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, semigroupal.product(f12, semigroupal.product(f13, f14))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, a14)))))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) } { z => val (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) = g(z); (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, a14)))))))))))))) }
/** @group TupleArity */
def tuple15[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)] =
- imap15(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14)((_, _, _, _, _, _, _, _, _, _, _, _, _, _, _))(identity)
+ imap15(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14)(Tuple15.apply)(identity)
/** @group TraverseArity */
def traverse15[F[_], G[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, semigroupal.product(f12, semigroupal.product(f13, f14))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, a14)))))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) }
@@ -246,7 +246,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, semigroupal.product(f12, semigroupal.product(f13, semigroupal.product(f14, f15)))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, a15))))))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) } { z => val (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) = g(z); (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, a15))))))))))))))) }
/** @group TupleArity */
def tuple16[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)] =
- imap16(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15)((_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _))(identity)
+ imap16(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15)(Tuple16.apply)(identity)
/** @group TraverseArity */
def traverse16[F[_], G[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, semigroupal.product(f12, semigroupal.product(f13, semigroupal.product(f14, f15)))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, a15))))))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) }
@@ -261,7 +261,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, semigroupal.product(f12, semigroupal.product(f13, semigroupal.product(f14, semigroupal.product(f15, f16))))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, a16)))))))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) } { z => val (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) = g(z); (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, a16)))))))))))))))) }
/** @group TupleArity */
def tuple17[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)] =
- imap17(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16)((_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _))(identity)
+ imap17(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16)(Tuple17.apply)(identity)
/** @group TraverseArity */
def traverse17[F[_], G[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, semigroupal.product(f12, semigroupal.product(f13, semigroupal.product(f14, semigroupal.product(f15, f16))))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, a16)))))))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) }
@@ -276,7 +276,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, semigroupal.product(f12, semigroupal.product(f13, semigroupal.product(f14, semigroupal.product(f15, semigroupal.product(f16, f17)))))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, a17))))))))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) } { z => val (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) = g(z); (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, a17))))))))))))))))) }
/** @group TupleArity */
def tuple18[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)] =
- imap18(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17)((_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _))(identity)
+ imap18(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17)(Tuple18.apply)(identity)
/** @group TraverseArity */
def traverse18[F[_], G[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, semigroupal.product(f12, semigroupal.product(f13, semigroupal.product(f14, semigroupal.product(f15, semigroupal.product(f16, f17)))))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, a17))))))))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) }
@@ -291,7 +291,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, semigroupal.product(f12, semigroupal.product(f13, semigroupal.product(f14, semigroupal.product(f15, semigroupal.product(f16, semigroupal.product(f17, f18))))))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, (a17, a18)))))))))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) } { z => val (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) = g(z); (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, (a17, a18)))))))))))))))))) }
/** @group TupleArity */
def tuple19[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)] =
- imap19(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18)((_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _))(identity)
+ imap19(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18)(Tuple19.apply)(identity)
/** @group TraverseArity */
def traverse19[F[_], G[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, semigroupal.product(f12, semigroupal.product(f13, semigroupal.product(f14, semigroupal.product(f15, semigroupal.product(f16, semigroupal.product(f17, f18))))))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, (a17, a18)))))))))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) }
@@ -306,7 +306,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, semigroupal.product(f12, semigroupal.product(f13, semigroupal.product(f14, semigroupal.product(f15, semigroupal.product(f16, semigroupal.product(f17, semigroupal.product(f18, f19)))))))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, (a17, (a18, a19))))))))))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) } { z => val (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) = g(z); (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, (a17, (a18, a19))))))))))))))))))) }
/** @group TupleArity */
def tuple20[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18], f19:F[A19])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)] =
- imap20(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19)((_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _))(identity)
+ imap20(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19)(Tuple20.apply)(identity)
/** @group TraverseArity */
def traverse20[F[_], G[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18], f19:F[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, semigroupal.product(f12, semigroupal.product(f13, semigroupal.product(f14, semigroupal.product(f15, semigroupal.product(f16, semigroupal.product(f17, semigroupal.product(f18, f19)))))))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, (a17, (a18, a19))))))))))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) }
@@ -321,7 +321,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, semigroupal.product(f12, semigroupal.product(f13, semigroupal.product(f14, semigroupal.product(f15, semigroupal.product(f16, semigroupal.product(f17, semigroupal.product(f18, semigroupal.product(f19, f20))))))))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, (a17, (a18, (a19, a20)))))))))))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) } { z => val (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) = g(z); (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, (a17, (a18, (a19, a20)))))))))))))))))))) }
/** @group TupleArity */
def tuple21[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18], f19:F[A19], f20:F[A20])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)] =
- imap21(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20)((_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _))(identity)
+ imap21(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20)(Tuple21.apply)(identity)
/** @group TraverseArity */
def traverse21[F[_], G[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18], f19:F[A19], f20:F[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, semigroupal.product(f12, semigroupal.product(f13, semigroupal.product(f14, semigroupal.product(f15, semigroupal.product(f16, semigroupal.product(f17, semigroupal.product(f18, semigroupal.product(f19, f20))))))))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, (a17, (a18, (a19, a20)))))))))))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) }
@@ -336,7 +336,7 @@ trait SemigroupalArityFunctions {
invariant.imap(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, semigroupal.product(f12, semigroupal.product(f13, semigroupal.product(f14, semigroupal.product(f15, semigroupal.product(f16, semigroupal.product(f17, semigroupal.product(f18, semigroupal.product(f19, semigroupal.product(f20, f21)))))))))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, (a17, (a18, (a19, (a20, a21))))))))))))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) } { z => val (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) = g(z); (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, (a17, (a18, (a19, (a20, a21))))))))))))))))))))) }
/** @group TupleArity */
def tuple22[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18], f19:F[A19], f20:F[A20], f21:F[A21])(implicit semigroupal: Semigroupal[F], invariant: Invariant[F]):F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)] =
- imap22(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21)((_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _))(identity)
+ imap22(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21)(Tuple22.apply)(identity)
/** @group TraverseArity */
def traverse22[F[_], G[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0:F[A0], f1:F[A1], f2:F[A2], f3:F[A3], f4:F[A4], f5:F[A5], f6:F[A6], f7:F[A7], f8:F[A8], f9:F[A9], f10:F[A10], f11:F[A11], f12:F[A12], f13:F[A13], f14:F[A14], f15:F[A15], f16:F[A16], f17:F[A17], f18:F[A18], f19:F[A19], f20:F[A20], f21:F[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => G[Z])(implicit semigroupal: Semigroupal[F], traverse: Traverse[F], applicative: Applicative[G]): G[F[Z]] =
traverse.traverse(semigroupal.product(f0, semigroupal.product(f1, semigroupal.product(f2, semigroupal.product(f3, semigroupal.product(f4, semigroupal.product(f5, semigroupal.product(f6, semigroupal.product(f7, semigroupal.product(f8, semigroupal.product(f9, semigroupal.product(f10, semigroupal.product(f11, semigroupal.product(f12, semigroupal.product(f13, semigroupal.product(f14, semigroupal.product(f15, semigroupal.product(f16, semigroupal.product(f17, semigroupal.product(f18, semigroupal.product(f19, semigroupal.product(f20, f21)))))))))))))))))))))) { case (a0, (a1, (a2, (a3, (a4, (a5, (a6, (a7, (a8, (a9, (a10, (a11, (a12, (a13, (a14, (a15, (a16, (a17, (a18, (a19, (a20, a21))))))))))))))))))))) => f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) }
diff --git a/./core/.jvm/target/scala-2.13/src_managed_main/main/cats/syntax/TupleParallelSyntax.scala b/./core/.jvm/target/scala-2.13/src_managed/main/cats/syntax/TupleParallelSyntax.scala
index 96a4a834f..bbe52cca9 100644
--- a/./core/.jvm/target/scala-2.13/src_managed_main/main/cats/syntax/TupleParallelSyntax.scala
+++ b/./core/.jvm/target/scala-2.13/src_managed/main/cats/syntax/TupleParallelSyntax.scala
@@ -5,137 +5,137 @@ package syntax
import cats.Parallel
trait TupleParallelSyntax {
- implicit def catsSyntaxTuple1Parallel[M[_], A0](t1: Tuple1[M[A0]]): Tuple1ParallelOps[M, A0] = new Tuple1ParallelOps(t1)
- implicit def catsSyntaxTuple2Parallel[M[_], A0, A1](t2: Tuple2[M[A0], M[A1]]): Tuple2ParallelOps[M, A0, A1] = new Tuple2ParallelOps(t2)
- implicit def catsSyntaxTuple3Parallel[M[_], A0, A1, A2](t3: Tuple3[M[A0], M[A1], M[A2]]): Tuple3ParallelOps[M, A0, A1, A2] = new Tuple3ParallelOps(t3)
- implicit def catsSyntaxTuple4Parallel[M[_], A0, A1, A2, A3](t4: Tuple4[M[A0], M[A1], M[A2], M[A3]]): Tuple4ParallelOps[M, A0, A1, A2, A3] = new Tuple4ParallelOps(t4)
- implicit def catsSyntaxTuple5Parallel[M[_], A0, A1, A2, A3, A4](t5: Tuple5[M[A0], M[A1], M[A2], M[A3], M[A4]]): Tuple5ParallelOps[M, A0, A1, A2, A3, A4] = new Tuple5ParallelOps(t5)
- implicit def catsSyntaxTuple6Parallel[M[_], A0, A1, A2, A3, A4, A5](t6: Tuple6[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5]]): Tuple6ParallelOps[M, A0, A1, A2, A3, A4, A5] = new Tuple6ParallelOps(t6)
- implicit def catsSyntaxTuple7Parallel[M[_], A0, A1, A2, A3, A4, A5, A6](t7: Tuple7[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6]]): Tuple7ParallelOps[M, A0, A1, A2, A3, A4, A5, A6] = new Tuple7ParallelOps(t7)
- implicit def catsSyntaxTuple8Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7](t8: Tuple8[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7]]): Tuple8ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7] = new Tuple8ParallelOps(t8)
- implicit def catsSyntaxTuple9Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8](t9: Tuple9[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8]]): Tuple9ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8] = new Tuple9ParallelOps(t9)
- implicit def catsSyntaxTuple10Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](t10: Tuple10[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9]]): Tuple10ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9] = new Tuple10ParallelOps(t10)
- implicit def catsSyntaxTuple11Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](t11: Tuple11[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10]]): Tuple11ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10] = new Tuple11ParallelOps(t11)
- implicit def catsSyntaxTuple12Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](t12: Tuple12[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11]]): Tuple12ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11] = new Tuple12ParallelOps(t12)
- implicit def catsSyntaxTuple13Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](t13: Tuple13[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12]]): Tuple13ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12] = new Tuple13ParallelOps(t13)
- implicit def catsSyntaxTuple14Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](t14: Tuple14[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13]]): Tuple14ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13] = new Tuple14ParallelOps(t14)
- implicit def catsSyntaxTuple15Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](t15: Tuple15[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14]]): Tuple15ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14] = new Tuple15ParallelOps(t15)
- implicit def catsSyntaxTuple16Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](t16: Tuple16[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15]]): Tuple16ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15] = new Tuple16ParallelOps(t16)
- implicit def catsSyntaxTuple17Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](t17: Tuple17[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16]]): Tuple17ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16] = new Tuple17ParallelOps(t17)
- implicit def catsSyntaxTuple18Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](t18: Tuple18[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17]]): Tuple18ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17] = new Tuple18ParallelOps(t18)
- implicit def catsSyntaxTuple19Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](t19: Tuple19[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17], M[A18]]): Tuple19ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18] = new Tuple19ParallelOps(t19)
- implicit def catsSyntaxTuple20Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](t20: Tuple20[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17], M[A18], M[A19]]): Tuple20ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19] = new Tuple20ParallelOps(t20)
- implicit def catsSyntaxTuple21Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](t21: Tuple21[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17], M[A18], M[A19], M[A20]]): Tuple21ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20] = new Tuple21ParallelOps(t21)
- implicit def catsSyntaxTuple22Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](t22: Tuple22[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17], M[A18], M[A19], M[A20], M[A21]]): Tuple22ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21] = new Tuple22ParallelOps(t22)
+ implicit def catsSyntaxTuple1Parallel[M[_], A0](t: Tuple1[M[A0]]): Tuple1ParallelOps[M, A0] = new Tuple1ParallelOps(t)
+ implicit def catsSyntaxTuple2Parallel[M[_], A0, A1](t: (M[A0], M[A1])): Tuple2ParallelOps[M, A0, A1] = new Tuple2ParallelOps(t)
+ implicit def catsSyntaxTuple3Parallel[M[_], A0, A1, A2](t: (M[A0], M[A1], M[A2])): Tuple3ParallelOps[M, A0, A1, A2] = new Tuple3ParallelOps(t)
+ implicit def catsSyntaxTuple4Parallel[M[_], A0, A1, A2, A3](t: (M[A0], M[A1], M[A2], M[A3])): Tuple4ParallelOps[M, A0, A1, A2, A3] = new Tuple4ParallelOps(t)
+ implicit def catsSyntaxTuple5Parallel[M[_], A0, A1, A2, A3, A4](t: (M[A0], M[A1], M[A2], M[A3], M[A4])): Tuple5ParallelOps[M, A0, A1, A2, A3, A4] = new Tuple5ParallelOps(t)
+ implicit def catsSyntaxTuple6Parallel[M[_], A0, A1, A2, A3, A4, A5](t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5])): Tuple6ParallelOps[M, A0, A1, A2, A3, A4, A5] = new Tuple6ParallelOps(t)
+ implicit def catsSyntaxTuple7Parallel[M[_], A0, A1, A2, A3, A4, A5, A6](t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6])): Tuple7ParallelOps[M, A0, A1, A2, A3, A4, A5, A6] = new Tuple7ParallelOps(t)
+ implicit def catsSyntaxTuple8Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7](t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7])): Tuple8ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7] = new Tuple8ParallelOps(t)
+ implicit def catsSyntaxTuple9Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8](t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8])): Tuple9ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8] = new Tuple9ParallelOps(t)
+ implicit def catsSyntaxTuple10Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9])): Tuple10ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9] = new Tuple10ParallelOps(t)
+ implicit def catsSyntaxTuple11Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10])): Tuple11ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10] = new Tuple11ParallelOps(t)
+ implicit def catsSyntaxTuple12Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11])): Tuple12ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11] = new Tuple12ParallelOps(t)
+ implicit def catsSyntaxTuple13Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12])): Tuple13ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12] = new Tuple13ParallelOps(t)
+ implicit def catsSyntaxTuple14Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13])): Tuple14ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13] = new Tuple14ParallelOps(t)
+ implicit def catsSyntaxTuple15Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14])): Tuple15ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14] = new Tuple15ParallelOps(t)
+ implicit def catsSyntaxTuple16Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15])): Tuple16ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15] = new Tuple16ParallelOps(t)
+ implicit def catsSyntaxTuple17Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16])): Tuple17ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16] = new Tuple17ParallelOps(t)
+ implicit def catsSyntaxTuple18Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17])): Tuple18ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17] = new Tuple18ParallelOps(t)
+ implicit def catsSyntaxTuple19Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17], M[A18])): Tuple19ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18] = new Tuple19ParallelOps(t)
+ implicit def catsSyntaxTuple20Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17], M[A18], M[A19])): Tuple20ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19] = new Tuple20ParallelOps(t)
+ implicit def catsSyntaxTuple21Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17], M[A18], M[A19], M[A20])): Tuple21ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20] = new Tuple21ParallelOps(t)
+ implicit def catsSyntaxTuple22Parallel[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17], M[A18], M[A19], M[A20], M[A21])): Tuple22ParallelOps[M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21] = new Tuple22ParallelOps(t)
}
-private[syntax] final class Tuple1ParallelOps[M[_], A0](private val t1: Tuple1[M[A0]]) extends Serializable {
- def parMap[Z](f: (A0) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = p.flatMap.map(t1._1)(f)
+private[syntax] final class Tuple1ParallelOps[M[_], A0](private val t: Tuple1[M[A0]]) extends Serializable {
+ def parMap[Z](f: (A0) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = p.flatMap.map(t._1)(f)
- def parFlatMap[Z](f: (A0) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = p.flatMap.flatMap(t1._1)(f)
-}
-private[syntax] final class Tuple2ParallelOps[M[_], A0, A1](private val t2: Tuple2[M[A0], M[A1]]) extends Serializable {
- def parMapN[Z](f: (A0, A1) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap2(t2._1, t2._2)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1)] = Parallel.parTuple2(t2._1, t2._2)
- def parFlatMapN[Z](f: (A0, A1) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap2(t2._1, t2._2)(f)
-}
-private[syntax] final class Tuple3ParallelOps[M[_], A0, A1, A2](private val t3: Tuple3[M[A0], M[A1], M[A2]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap3(t3._1, t3._2, t3._3)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2)] = Parallel.parTuple3(t3._1, t3._2, t3._3)
- def parFlatMapN[Z](f: (A0, A1, A2) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap3(t3._1, t3._2, t3._3)(f)
-}
-private[syntax] final class Tuple4ParallelOps[M[_], A0, A1, A2, A3](private val t4: Tuple4[M[A0], M[A1], M[A2], M[A3]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2, A3) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap4(t4._1, t4._2, t4._3, t4._4)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3)] = Parallel.parTuple4(t4._1, t4._2, t4._3, t4._4)
- def parFlatMapN[Z](f: (A0, A1, A2, A3) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap4(t4._1, t4._2, t4._3, t4._4)(f)
-}
-private[syntax] final class Tuple5ParallelOps[M[_], A0, A1, A2, A3, A4](private val t5: Tuple5[M[A0], M[A1], M[A2], M[A3], M[A4]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2, A3, A4) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap5(t5._1, t5._2, t5._3, t5._4, t5._5)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4)] = Parallel.parTuple5(t5._1, t5._2, t5._3, t5._4, t5._5)
- def parFlatMapN[Z](f: (A0, A1, A2, A3, A4) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap5(t5._1, t5._2, t5._3, t5._4, t5._5)(f)
-}
-private[syntax] final class Tuple6ParallelOps[M[_], A0, A1, A2, A3, A4, A5](private val t6: Tuple6[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2, A3, A4, A5) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap6(t6._1, t6._2, t6._3, t6._4, t6._5, t6._6)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5)] = Parallel.parTuple6(t6._1, t6._2, t6._3, t6._4, t6._5, t6._6)
- def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap6(t6._1, t6._2, t6._3, t6._4, t6._5, t6._6)(f)
-}
-private[syntax] final class Tuple7ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6](private val t7: Tuple7[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap7(t7._1, t7._2, t7._3, t7._4, t7._5, t7._6, t7._7)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6)] = Parallel.parTuple7(t7._1, t7._2, t7._3, t7._4, t7._5, t7._6, t7._7)
- def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap7(t7._1, t7._2, t7._3, t7._4, t7._5, t7._6, t7._7)(f)
-}
-private[syntax] final class Tuple8ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7](private val t8: Tuple8[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap8(t8._1, t8._2, t8._3, t8._4, t8._5, t8._6, t8._7, t8._8)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7)] = Parallel.parTuple8(t8._1, t8._2, t8._3, t8._4, t8._5, t8._6, t8._7, t8._8)
- def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap8(t8._1, t8._2, t8._3, t8._4, t8._5, t8._6, t8._7, t8._8)(f)
-}
-private[syntax] final class Tuple9ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8](private val t9: Tuple9[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap9(t9._1, t9._2, t9._3, t9._4, t9._5, t9._6, t9._7, t9._8, t9._9)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8)] = Parallel.parTuple9(t9._1, t9._2, t9._3, t9._4, t9._5, t9._6, t9._7, t9._8, t9._9)
- def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap9(t9._1, t9._2, t9._3, t9._4, t9._5, t9._6, t9._7, t9._8, t9._9)(f)
-}
-private[syntax] final class Tuple10ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](private val t10: Tuple10[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap10(t10._1, t10._2, t10._3, t10._4, t10._5, t10._6, t10._7, t10._8, t10._9, t10._10)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)] = Parallel.parTuple10(t10._1, t10._2, t10._3, t10._4, t10._5, t10._6, t10._7, t10._8, t10._9, t10._10)
- def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap10(t10._1, t10._2, t10._3, t10._4, t10._5, t10._6, t10._7, t10._8, t10._9, t10._10)(f)
-}
-private[syntax] final class Tuple11ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](private val t11: Tuple11[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap11(t11._1, t11._2, t11._3, t11._4, t11._5, t11._6, t11._7, t11._8, t11._9, t11._10, t11._11)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)] = Parallel.parTuple11(t11._1, t11._2, t11._3, t11._4, t11._5, t11._6, t11._7, t11._8, t11._9, t11._10, t11._11)
- def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap11(t11._1, t11._2, t11._3, t11._4, t11._5, t11._6, t11._7, t11._8, t11._9, t11._10, t11._11)(f)
-}
-private[syntax] final class Tuple12ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](private val t12: Tuple12[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap12(t12._1, t12._2, t12._3, t12._4, t12._5, t12._6, t12._7, t12._8, t12._9, t12._10, t12._11, t12._12)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)] = Parallel.parTuple12(t12._1, t12._2, t12._3, t12._4, t12._5, t12._6, t12._7, t12._8, t12._9, t12._10, t12._11, t12._12)
- def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap12(t12._1, t12._2, t12._3, t12._4, t12._5, t12._6, t12._7, t12._8, t12._9, t12._10, t12._11, t12._12)(f)
-}
-private[syntax] final class Tuple13ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](private val t13: Tuple13[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap13(t13._1, t13._2, t13._3, t13._4, t13._5, t13._6, t13._7, t13._8, t13._9, t13._10, t13._11, t13._12, t13._13)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)] = Parallel.parTuple13(t13._1, t13._2, t13._3, t13._4, t13._5, t13._6, t13._7, t13._8, t13._9, t13._10, t13._11, t13._12, t13._13)
- def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap13(t13._1, t13._2, t13._3, t13._4, t13._5, t13._6, t13._7, t13._8, t13._9, t13._10, t13._11, t13._12, t13._13)(f)
-}
-private[syntax] final class Tuple14ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](private val t14: Tuple14[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap14(t14._1, t14._2, t14._3, t14._4, t14._5, t14._6, t14._7, t14._8, t14._9, t14._10, t14._11, t14._12, t14._13, t14._14)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)] = Parallel.parTuple14(t14._1, t14._2, t14._3, t14._4, t14._5, t14._6, t14._7, t14._8, t14._9, t14._10, t14._11, t14._12, t14._13, t14._14)
- def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap14(t14._1, t14._2, t14._3, t14._4, t14._5, t14._6, t14._7, t14._8, t14._9, t14._10, t14._11, t14._12, t14._13, t14._14)(f)
-}
-private[syntax] final class Tuple15ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](private val t15: Tuple15[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap15(t15._1, t15._2, t15._3, t15._4, t15._5, t15._6, t15._7, t15._8, t15._9, t15._10, t15._11, t15._12, t15._13, t15._14, t15._15)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)] = Parallel.parTuple15(t15._1, t15._2, t15._3, t15._4, t15._5, t15._6, t15._7, t15._8, t15._9, t15._10, t15._11, t15._12, t15._13, t15._14, t15._15)
- def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap15(t15._1, t15._2, t15._3, t15._4, t15._5, t15._6, t15._7, t15._8, t15._9, t15._10, t15._11, t15._12, t15._13, t15._14, t15._15)(f)
-}
-private[syntax] final class Tuple16ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](private val t16: Tuple16[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap16(t16._1, t16._2, t16._3, t16._4, t16._5, t16._6, t16._7, t16._8, t16._9, t16._10, t16._11, t16._12, t16._13, t16._14, t16._15, t16._16)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)] = Parallel.parTuple16(t16._1, t16._2, t16._3, t16._4, t16._5, t16._6, t16._7, t16._8, t16._9, t16._10, t16._11, t16._12, t16._13, t16._14, t16._15, t16._16)
- def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap16(t16._1, t16._2, t16._3, t16._4, t16._5, t16._6, t16._7, t16._8, t16._9, t16._10, t16._11, t16._12, t16._13, t16._14, t16._15, t16._16)(f)
-}
-private[syntax] final class Tuple17ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](private val t17: Tuple17[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap17(t17._1, t17._2, t17._3, t17._4, t17._5, t17._6, t17._7, t17._8, t17._9, t17._10, t17._11, t17._12, t17._13, t17._14, t17._15, t17._16, t17._17)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)] = Parallel.parTuple17(t17._1, t17._2, t17._3, t17._4, t17._5, t17._6, t17._7, t17._8, t17._9, t17._10, t17._11, t17._12, t17._13, t17._14, t17._15, t17._16, t17._17)
- def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap17(t17._1, t17._2, t17._3, t17._4, t17._5, t17._6, t17._7, t17._8, t17._9, t17._10, t17._11, t17._12, t17._13, t17._14, t17._15, t17._16, t17._17)(f)
-}
-private[syntax] final class Tuple18ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](private val t18: Tuple18[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap18(t18._1, t18._2, t18._3, t18._4, t18._5, t18._6, t18._7, t18._8, t18._9, t18._10, t18._11, t18._12, t18._13, t18._14, t18._15, t18._16, t18._17, t18._18)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)] = Parallel.parTuple18(t18._1, t18._2, t18._3, t18._4, t18._5, t18._6, t18._7, t18._8, t18._9, t18._10, t18._11, t18._12, t18._13, t18._14, t18._15, t18._16, t18._17, t18._18)
- def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap18(t18._1, t18._2, t18._3, t18._4, t18._5, t18._6, t18._7, t18._8, t18._9, t18._10, t18._11, t18._12, t18._13, t18._14, t18._15, t18._16, t18._17, t18._18)(f)
-}
-private[syntax] final class Tuple19ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](private val t19: Tuple19[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17], M[A18]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap19(t19._1, t19._2, t19._3, t19._4, t19._5, t19._6, t19._7, t19._8, t19._9, t19._10, t19._11, t19._12, t19._13, t19._14, t19._15, t19._16, t19._17, t19._18, t19._19)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)] = Parallel.parTuple19(t19._1, t19._2, t19._3, t19._4, t19._5, t19._6, t19._7, t19._8, t19._9, t19._10, t19._11, t19._12, t19._13, t19._14, t19._15, t19._16, t19._17, t19._18, t19._19)
- def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap19(t19._1, t19._2, t19._3, t19._4, t19._5, t19._6, t19._7, t19._8, t19._9, t19._10, t19._11, t19._12, t19._13, t19._14, t19._15, t19._16, t19._17, t19._18, t19._19)(f)
-}
-private[syntax] final class Tuple20ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](private val t20: Tuple20[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17], M[A18], M[A19]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap20(t20._1, t20._2, t20._3, t20._4, t20._5, t20._6, t20._7, t20._8, t20._9, t20._10, t20._11, t20._12, t20._13, t20._14, t20._15, t20._16, t20._17, t20._18, t20._19, t20._20)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)] = Parallel.parTuple20(t20._1, t20._2, t20._3, t20._4, t20._5, t20._6, t20._7, t20._8, t20._9, t20._10, t20._11, t20._12, t20._13, t20._14, t20._15, t20._16, t20._17, t20._18, t20._19, t20._20)
- def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap20(t20._1, t20._2, t20._3, t20._4, t20._5, t20._6, t20._7, t20._8, t20._9, t20._10, t20._11, t20._12, t20._13, t20._14, t20._15, t20._16, t20._17, t20._18, t20._19, t20._20)(f)
-}
-private[syntax] final class Tuple21ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](private val t21: Tuple21[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17], M[A18], M[A19], M[A20]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap21(t21._1, t21._2, t21._3, t21._4, t21._5, t21._6, t21._7, t21._8, t21._9, t21._10, t21._11, t21._12, t21._13, t21._14, t21._15, t21._16, t21._17, t21._18, t21._19, t21._20, t21._21)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)] = Parallel.parTuple21(t21._1, t21._2, t21._3, t21._4, t21._5, t21._6, t21._7, t21._8, t21._9, t21._10, t21._11, t21._12, t21._13, t21._14, t21._15, t21._16, t21._17, t21._18, t21._19, t21._20, t21._21)
- def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap21(t21._1, t21._2, t21._3, t21._4, t21._5, t21._6, t21._7, t21._8, t21._9, t21._10, t21._11, t21._12, t21._13, t21._14, t21._15, t21._16, t21._17, t21._18, t21._19, t21._20, t21._21)(f)
-}
-private[syntax] final class Tuple22ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](private val t22: Tuple22[M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17], M[A18], M[A19], M[A20], M[A21]]) extends Serializable {
- def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap22(t22._1, t22._2, t22._3, t22._4, t22._5, t22._6, t22._7, t22._8, t22._9, t22._10, t22._11, t22._12, t22._13, t22._14, t22._15, t22._16, t22._17, t22._18, t22._19, t22._20, t22._21, t22._22)(f)
- def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)] = Parallel.parTuple22(t22._1, t22._2, t22._3, t22._4, t22._5, t22._6, t22._7, t22._8, t22._9, t22._10, t22._11, t22._12, t22._13, t22._14, t22._15, t22._16, t22._17, t22._18, t22._19, t22._20, t22._21, t22._22)
- def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap22(t22._1, t22._2, t22._3, t22._4, t22._5, t22._6, t22._7, t22._8, t22._9, t22._10, t22._11, t22._12, t22._13, t22._14, t22._15, t22._16, t22._17, t22._18, t22._19, t22._20, t22._21, t22._22)(f)
+ def parFlatMap[Z](f: (A0) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = p.flatMap.flatMap(t._1)(f)
+}
+private[syntax] final class Tuple2ParallelOps[M[_], A0, A1](private val t: (M[A0], M[A1])) extends Serializable {
+ def parMapN[Z](f: (A0, A1) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap2(t._1, t._2)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1)] = Parallel.parTuple2(t._1, t._2)
+ def parFlatMapN[Z](f: (A0, A1) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap2(t._1, t._2)(f)
+}
+private[syntax] final class Tuple3ParallelOps[M[_], A0, A1, A2](private val t: (M[A0], M[A1], M[A2])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap3(t._1, t._2, t._3)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2)] = Parallel.parTuple3(t._1, t._2, t._3)
+ def parFlatMapN[Z](f: (A0, A1, A2) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap3(t._1, t._2, t._3)(f)
+}
+private[syntax] final class Tuple4ParallelOps[M[_], A0, A1, A2, A3](private val t: (M[A0], M[A1], M[A2], M[A3])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2, A3) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap4(t._1, t._2, t._3, t._4)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3)] = Parallel.parTuple4(t._1, t._2, t._3, t._4)
+ def parFlatMapN[Z](f: (A0, A1, A2, A3) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap4(t._1, t._2, t._3, t._4)(f)
+}
+private[syntax] final class Tuple5ParallelOps[M[_], A0, A1, A2, A3, A4](private val t: (M[A0], M[A1], M[A2], M[A3], M[A4])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2, A3, A4) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap5(t._1, t._2, t._3, t._4, t._5)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4)] = Parallel.parTuple5(t._1, t._2, t._3, t._4, t._5)
+ def parFlatMapN[Z](f: (A0, A1, A2, A3, A4) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap5(t._1, t._2, t._3, t._4, t._5)(f)
+}
+private[syntax] final class Tuple6ParallelOps[M[_], A0, A1, A2, A3, A4, A5](private val t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2, A3, A4, A5) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap6(t._1, t._2, t._3, t._4, t._5, t._6)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5)] = Parallel.parTuple6(t._1, t._2, t._3, t._4, t._5, t._6)
+ def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap6(t._1, t._2, t._3, t._4, t._5, t._6)(f)
+}
+private[syntax] final class Tuple7ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6](private val t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap7(t._1, t._2, t._3, t._4, t._5, t._6, t._7)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6)] = Parallel.parTuple7(t._1, t._2, t._3, t._4, t._5, t._6, t._7)
+ def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap7(t._1, t._2, t._3, t._4, t._5, t._6, t._7)(f)
+}
+private[syntax] final class Tuple8ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7](private val t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap8(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7)] = Parallel.parTuple8(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8)
+ def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap8(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8)(f)
+}
+private[syntax] final class Tuple9ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8](private val t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap9(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8)] = Parallel.parTuple9(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9)
+ def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap9(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9)(f)
+}
+private[syntax] final class Tuple10ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](private val t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap10(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)] = Parallel.parTuple10(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10)
+ def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap10(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10)(f)
+}
+private[syntax] final class Tuple11ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](private val t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap11(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)] = Parallel.parTuple11(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11)
+ def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap11(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11)(f)
+}
+private[syntax] final class Tuple12ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](private val t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap12(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)] = Parallel.parTuple12(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12)
+ def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap12(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12)(f)
+}
+private[syntax] final class Tuple13ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](private val t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap13(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)] = Parallel.parTuple13(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13)
+ def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap13(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13)(f)
+}
+private[syntax] final class Tuple14ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](private val t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap14(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)] = Parallel.parTuple14(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14)
+ def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap14(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14)(f)
+}
+private[syntax] final class Tuple15ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](private val t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap15(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)] = Parallel.parTuple15(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15)
+ def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap15(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15)(f)
+}
+private[syntax] final class Tuple16ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](private val t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap16(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)] = Parallel.parTuple16(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16)
+ def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap16(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16)(f)
+}
+private[syntax] final class Tuple17ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](private val t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap17(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)] = Parallel.parTuple17(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17)
+ def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap17(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17)(f)
+}
+private[syntax] final class Tuple18ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](private val t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap18(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)] = Parallel.parTuple18(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18)
+ def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap18(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18)(f)
+}
+private[syntax] final class Tuple19ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](private val t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17], M[A18])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap19(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)] = Parallel.parTuple19(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19)
+ def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap19(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19)(f)
+}
+private[syntax] final class Tuple20ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](private val t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17], M[A18], M[A19])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap20(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)] = Parallel.parTuple20(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20)
+ def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap20(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20)(f)
+}
+private[syntax] final class Tuple21ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](private val t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17], M[A18], M[A19], M[A20])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap21(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)] = Parallel.parTuple21(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21)
+ def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap21(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21)(f)
+}
+private[syntax] final class Tuple22ParallelOps[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](private val t: (M[A0], M[A1], M[A2], M[A3], M[A4], M[A5], M[A6], M[A7], M[A8], M[A9], M[A10], M[A11], M[A12], M[A13], M[A14], M[A15], M[A16], M[A17], M[A18], M[A19], M[A20], M[A21])) extends Serializable {
+ def parMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z)(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parMap22(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21, t._22)(f)
+ def parTupled(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)] = Parallel.parTuple22(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21, t._22)
+ def parFlatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => M[Z])(implicit p: NonEmptyParallel[M]): M[Z] = Parallel.parFlatMap22(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21, t._22)(f)
}
diff --git a/./core/.jvm/target/scala-2.13/src_managed_main/main/cats/syntax/TupleSemigroupalSyntax.scala b/./core/.jvm/target/scala-2.13/src_managed/main/cats/syntax/TupleSemigroupalSyntax.scala
index 8fd42ce84..a581df161 100644
--- a/./core/.jvm/target/scala-2.13/src_managed_main/main/cats/syntax/TupleSemigroupalSyntax.scala
+++ b/./core/.jvm/target/scala-2.13/src_managed/main/cats/syntax/TupleSemigroupalSyntax.scala
@@ -3,225 +3,225 @@ package cats
package syntax
trait TupleSemigroupalSyntax {
- implicit def catsSyntaxTuple1Semigroupal[F[_], A0](t1: Tuple1[F[A0]]): Tuple1SemigroupalOps[F, A0] = new Tuple1SemigroupalOps(t1)
- implicit def catsSyntaxTuple2Semigroupal[F[_], A0, A1](t2: Tuple2[F[A0], F[A1]]): Tuple2SemigroupalOps[F, A0, A1] = new Tuple2SemigroupalOps(t2)
- implicit def catsSyntaxTuple3Semigroupal[F[_], A0, A1, A2](t3: Tuple3[F[A0], F[A1], F[A2]]): Tuple3SemigroupalOps[F, A0, A1, A2] = new Tuple3SemigroupalOps(t3)
- implicit def catsSyntaxTuple4Semigroupal[F[_], A0, A1, A2, A3](t4: Tuple4[F[A0], F[A1], F[A2], F[A3]]): Tuple4SemigroupalOps[F, A0, A1, A2, A3] = new Tuple4SemigroupalOps(t4)
- implicit def catsSyntaxTuple5Semigroupal[F[_], A0, A1, A2, A3, A4](t5: Tuple5[F[A0], F[A1], F[A2], F[A3], F[A4]]): Tuple5SemigroupalOps[F, A0, A1, A2, A3, A4] = new Tuple5SemigroupalOps(t5)
- implicit def catsSyntaxTuple6Semigroupal[F[_], A0, A1, A2, A3, A4, A5](t6: Tuple6[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5]]): Tuple6SemigroupalOps[F, A0, A1, A2, A3, A4, A5] = new Tuple6SemigroupalOps(t6)
- implicit def catsSyntaxTuple7Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6](t7: Tuple7[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6]]): Tuple7SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6] = new Tuple7SemigroupalOps(t7)
- implicit def catsSyntaxTuple8Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7](t8: Tuple8[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7]]): Tuple8SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7] = new Tuple8SemigroupalOps(t8)
- implicit def catsSyntaxTuple9Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8](t9: Tuple9[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8]]): Tuple9SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8] = new Tuple9SemigroupalOps(t9)
- implicit def catsSyntaxTuple10Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](t10: Tuple10[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9]]): Tuple10SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9] = new Tuple10SemigroupalOps(t10)
- implicit def catsSyntaxTuple11Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](t11: Tuple11[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10]]): Tuple11SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10] = new Tuple11SemigroupalOps(t11)
- implicit def catsSyntaxTuple12Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](t12: Tuple12[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11]]): Tuple12SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11] = new Tuple12SemigroupalOps(t12)
- implicit def catsSyntaxTuple13Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](t13: Tuple13[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12]]): Tuple13SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12] = new Tuple13SemigroupalOps(t13)
- implicit def catsSyntaxTuple14Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](t14: Tuple14[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13]]): Tuple14SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13] = new Tuple14SemigroupalOps(t14)
- implicit def catsSyntaxTuple15Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](t15: Tuple15[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14]]): Tuple15SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14] = new Tuple15SemigroupalOps(t15)
- implicit def catsSyntaxTuple16Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](t16: Tuple16[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15]]): Tuple16SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15] = new Tuple16SemigroupalOps(t16)
- implicit def catsSyntaxTuple17Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](t17: Tuple17[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16]]): Tuple17SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16] = new Tuple17SemigroupalOps(t17)
- implicit def catsSyntaxTuple18Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](t18: Tuple18[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17]]): Tuple18SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17] = new Tuple18SemigroupalOps(t18)
- implicit def catsSyntaxTuple19Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](t19: Tuple19[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17], F[A18]]): Tuple19SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18] = new Tuple19SemigroupalOps(t19)
- implicit def catsSyntaxTuple20Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](t20: Tuple20[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17], F[A18], F[A19]]): Tuple20SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19] = new Tuple20SemigroupalOps(t20)
- implicit def catsSyntaxTuple21Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](t21: Tuple21[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17], F[A18], F[A19], F[A20]]): Tuple21SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20] = new Tuple21SemigroupalOps(t21)
- implicit def catsSyntaxTuple22Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](t22: Tuple22[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17], F[A18], F[A19], F[A20], F[A21]]): Tuple22SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21] = new Tuple22SemigroupalOps(t22)
+ implicit def catsSyntaxTuple1Semigroupal[F[_], A0](t: Tuple1[F[A0]]): Tuple1SemigroupalOps[F, A0] = new Tuple1SemigroupalOps(t)
+ implicit def catsSyntaxTuple2Semigroupal[F[_], A0, A1](t: (F[A0], F[A1])): Tuple2SemigroupalOps[F, A0, A1] = new Tuple2SemigroupalOps(t)
+ implicit def catsSyntaxTuple3Semigroupal[F[_], A0, A1, A2](t: (F[A0], F[A1], F[A2])): Tuple3SemigroupalOps[F, A0, A1, A2] = new Tuple3SemigroupalOps(t)
+ implicit def catsSyntaxTuple4Semigroupal[F[_], A0, A1, A2, A3](t: (F[A0], F[A1], F[A2], F[A3])): Tuple4SemigroupalOps[F, A0, A1, A2, A3] = new Tuple4SemigroupalOps(t)
+ implicit def catsSyntaxTuple5Semigroupal[F[_], A0, A1, A2, A3, A4](t: (F[A0], F[A1], F[A2], F[A3], F[A4])): Tuple5SemigroupalOps[F, A0, A1, A2, A3, A4] = new Tuple5SemigroupalOps(t)
+ implicit def catsSyntaxTuple6Semigroupal[F[_], A0, A1, A2, A3, A4, A5](t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5])): Tuple6SemigroupalOps[F, A0, A1, A2, A3, A4, A5] = new Tuple6SemigroupalOps(t)
+ implicit def catsSyntaxTuple7Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6](t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6])): Tuple7SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6] = new Tuple7SemigroupalOps(t)
+ implicit def catsSyntaxTuple8Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7](t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7])): Tuple8SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7] = new Tuple8SemigroupalOps(t)
+ implicit def catsSyntaxTuple9Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8](t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8])): Tuple9SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8] = new Tuple9SemigroupalOps(t)
+ implicit def catsSyntaxTuple10Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9])): Tuple10SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9] = new Tuple10SemigroupalOps(t)
+ implicit def catsSyntaxTuple11Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10])): Tuple11SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10] = new Tuple11SemigroupalOps(t)
+ implicit def catsSyntaxTuple12Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11])): Tuple12SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11] = new Tuple12SemigroupalOps(t)
+ implicit def catsSyntaxTuple13Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12])): Tuple13SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12] = new Tuple13SemigroupalOps(t)
+ implicit def catsSyntaxTuple14Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13])): Tuple14SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13] = new Tuple14SemigroupalOps(t)
+ implicit def catsSyntaxTuple15Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14])): Tuple15SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14] = new Tuple15SemigroupalOps(t)
+ implicit def catsSyntaxTuple16Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15])): Tuple16SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15] = new Tuple16SemigroupalOps(t)
+ implicit def catsSyntaxTuple17Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16])): Tuple17SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16] = new Tuple17SemigroupalOps(t)
+ implicit def catsSyntaxTuple18Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17])): Tuple18SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17] = new Tuple18SemigroupalOps(t)
+ implicit def catsSyntaxTuple19Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17], F[A18])): Tuple19SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18] = new Tuple19SemigroupalOps(t)
+ implicit def catsSyntaxTuple20Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17], F[A18], F[A19])): Tuple20SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19] = new Tuple20SemigroupalOps(t)
+ implicit def catsSyntaxTuple21Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17], F[A18], F[A19], F[A20])): Tuple21SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20] = new Tuple21SemigroupalOps(t)
+ implicit def catsSyntaxTuple22Semigroupal[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17], F[A18], F[A19], F[A20], F[A21])): Tuple22SemigroupalOps[F, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21] = new Tuple22SemigroupalOps(t)
}
-private[syntax] final class Tuple1SemigroupalOps[F[_], A0](private val t1: Tuple1[F[A0]]) extends Serializable {
- def map[Z](f: (A0) => Z)(implicit functor: Functor[F]): F[Z] = functor.map(t1._1)(f)
- def contramap[Z](f: Z => (A0))(implicit contravariant: Contravariant[F]): F[Z] = contravariant.contramap(t1._1)(f)
- def imap[Z](f: (A0) => Z)(g: Z => (A0))(implicit invariant: Invariant[F]): F[Z] = invariant.imap(t1._1)(f)(g)
- def flatMap[Z](f: (A0) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap(t1._1)(f)
+private[syntax] final class Tuple1SemigroupalOps[F[_], A0](private val t: Tuple1[F[A0]]) extends Serializable {
+ def map[Z](f: (A0) => Z)(implicit functor: Functor[F]): F[Z] = functor.map(t._1)(f)
+ def contramap[Z](f: Z => (A0))(implicit contravariant: Contravariant[F]): F[Z] = contravariant.contramap(t._1)(f)
+ def imap[Z](f: (A0) => Z)(g: Z => (A0))(implicit invariant: Invariant[F]): F[Z] = invariant.imap(t._1)(f)(g)
+ def flatMap[Z](f: (A0) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap(t._1)(f)
- def traverse[G[_]: Applicative, Z](f: (A0) => G[Z])(implicit traverse: Traverse[F]): G[F[Z]] = traverse.traverse(t1._1)(f)
- def apWith[Z](f: F[(A0) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap(f)(t1._1)
-}
-private[syntax] final class Tuple2SemigroupalOps[F[_], A0, A1](private val t2: Tuple2[F[A0], F[A1]]) extends Serializable {
- def mapN[Z](f: (A0, A1) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map2(t2._1, t2._2)(f)
- def contramapN[Z](f: Z => (A0, A1))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap2(t2._1, t2._2)(f)
- def imapN[Z](f: (A0, A1) => Z)(g: Z => (A0, A1))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap2(t2._1, t2._2)(f)(g)
- def flatMapN[Z](f: (A0, A1) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap2(t2._1, t2._2)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1)] = Semigroupal.tuple2(t2._1, t2._2)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse2(t2._1, t2._2)(f)
- def apWith[Z](f: F[(A0, A1) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap2(f)(t2._1, t2._2)
-}
-private[syntax] final class Tuple3SemigroupalOps[F[_], A0, A1, A2](private val t3: Tuple3[F[A0], F[A1], F[A2]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map3(t3._1, t3._2, t3._3)(f)
- def contramapN[Z](f: Z => (A0, A1, A2))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap3(t3._1, t3._2, t3._3)(f)
- def imapN[Z](f: (A0, A1, A2) => Z)(g: Z => (A0, A1, A2))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap3(t3._1, t3._2, t3._3)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap3(t3._1, t3._2, t3._3)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2)] = Semigroupal.tuple3(t3._1, t3._2, t3._3)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse3(t3._1, t3._2, t3._3)(f)
- def apWith[Z](f: F[(A0, A1, A2) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap3(f)(t3._1, t3._2, t3._3)
-}
-private[syntax] final class Tuple4SemigroupalOps[F[_], A0, A1, A2, A3](private val t4: Tuple4[F[A0], F[A1], F[A2], F[A3]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2, A3) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map4(t4._1, t4._2, t4._3, t4._4)(f)
- def contramapN[Z](f: Z => (A0, A1, A2, A3))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap4(t4._1, t4._2, t4._3, t4._4)(f)
- def imapN[Z](f: (A0, A1, A2, A3) => Z)(g: Z => (A0, A1, A2, A3))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap4(t4._1, t4._2, t4._3, t4._4)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2, A3) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap4(t4._1, t4._2, t4._3, t4._4)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3)] = Semigroupal.tuple4(t4._1, t4._2, t4._3, t4._4)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse4(t4._1, t4._2, t4._3, t4._4)(f)
- def apWith[Z](f: F[(A0, A1, A2, A3) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap4(f)(t4._1, t4._2, t4._3, t4._4)
-}
-private[syntax] final class Tuple5SemigroupalOps[F[_], A0, A1, A2, A3, A4](private val t5: Tuple5[F[A0], F[A1], F[A2], F[A3], F[A4]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2, A3, A4) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map5(t5._1, t5._2, t5._3, t5._4, t5._5)(f)
- def contramapN[Z](f: Z => (A0, A1, A2, A3, A4))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap5(t5._1, t5._2, t5._3, t5._4, t5._5)(f)
- def imapN[Z](f: (A0, A1, A2, A3, A4) => Z)(g: Z => (A0, A1, A2, A3, A4))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap5(t5._1, t5._2, t5._3, t5._4, t5._5)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2, A3, A4) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap5(t5._1, t5._2, t5._3, t5._4, t5._5)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4)] = Semigroupal.tuple5(t5._1, t5._2, t5._3, t5._4, t5._5)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse5(t5._1, t5._2, t5._3, t5._4, t5._5)(f)
- def apWith[Z](f: F[(A0, A1, A2, A3, A4) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap5(f)(t5._1, t5._2, t5._3, t5._4, t5._5)
-}
-private[syntax] final class Tuple6SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5](private val t6: Tuple6[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2, A3, A4, A5) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map6(t6._1, t6._2, t6._3, t6._4, t6._5, t6._6)(f)
- def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap6(t6._1, t6._2, t6._3, t6._4, t6._5, t6._6)(f)
- def imapN[Z](f: (A0, A1, A2, A3, A4, A5) => Z)(g: Z => (A0, A1, A2, A3, A4, A5))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap6(t6._1, t6._2, t6._3, t6._4, t6._5, t6._6)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap6(t6._1, t6._2, t6._3, t6._4, t6._5, t6._6)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5)] = Semigroupal.tuple6(t6._1, t6._2, t6._3, t6._4, t6._5, t6._6)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse6(t6._1, t6._2, t6._3, t6._4, t6._5, t6._6)(f)
- def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap6(f)(t6._1, t6._2, t6._3, t6._4, t6._5, t6._6)
-}
-private[syntax] final class Tuple7SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6](private val t7: Tuple7[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map7(t7._1, t7._2, t7._3, t7._4, t7._5, t7._6, t7._7)(f)
- def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap7(t7._1, t7._2, t7._3, t7._4, t7._5, t7._6, t7._7)(f)
- def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap7(t7._1, t7._2, t7._3, t7._4, t7._5, t7._6, t7._7)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap7(t7._1, t7._2, t7._3, t7._4, t7._5, t7._6, t7._7)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6)] = Semigroupal.tuple7(t7._1, t7._2, t7._3, t7._4, t7._5, t7._6, t7._7)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse7(t7._1, t7._2, t7._3, t7._4, t7._5, t7._6, t7._7)(f)
- def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap7(f)(t7._1, t7._2, t7._3, t7._4, t7._5, t7._6, t7._7)
-}
-private[syntax] final class Tuple8SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7](private val t8: Tuple8[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map8(t8._1, t8._2, t8._3, t8._4, t8._5, t8._6, t8._7, t8._8)(f)
- def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap8(t8._1, t8._2, t8._3, t8._4, t8._5, t8._6, t8._7, t8._8)(f)
- def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap8(t8._1, t8._2, t8._3, t8._4, t8._5, t8._6, t8._7, t8._8)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap8(t8._1, t8._2, t8._3, t8._4, t8._5, t8._6, t8._7, t8._8)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7)] = Semigroupal.tuple8(t8._1, t8._2, t8._3, t8._4, t8._5, t8._6, t8._7, t8._8)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse8(t8._1, t8._2, t8._3, t8._4, t8._5, t8._6, t8._7, t8._8)(f)
- def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap8(f)(t8._1, t8._2, t8._3, t8._4, t8._5, t8._6, t8._7, t8._8)
-}
-private[syntax] final class Tuple9SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8](private val t9: Tuple9[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map9(t9._1, t9._2, t9._3, t9._4, t9._5, t9._6, t9._7, t9._8, t9._9)(f)
- def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap9(t9._1, t9._2, t9._3, t9._4, t9._5, t9._6, t9._7, t9._8, t9._9)(f)
- def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap9(t9._1, t9._2, t9._3, t9._4, t9._5, t9._6, t9._7, t9._8, t9._9)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap9(t9._1, t9._2, t9._3, t9._4, t9._5, t9._6, t9._7, t9._8, t9._9)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8)] = Semigroupal.tuple9(t9._1, t9._2, t9._3, t9._4, t9._5, t9._6, t9._7, t9._8, t9._9)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse9(t9._1, t9._2, t9._3, t9._4, t9._5, t9._6, t9._7, t9._8, t9._9)(f)
- def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap9(f)(t9._1, t9._2, t9._3, t9._4, t9._5, t9._6, t9._7, t9._8, t9._9)
-}
-private[syntax] final class Tuple10SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](private val t10: Tuple10[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map10(t10._1, t10._2, t10._3, t10._4, t10._5, t10._6, t10._7, t10._8, t10._9, t10._10)(f)
- def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap10(t10._1, t10._2, t10._3, t10._4, t10._5, t10._6, t10._7, t10._8, t10._9, t10._10)(f)
- def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap10(t10._1, t10._2, t10._3, t10._4, t10._5, t10._6, t10._7, t10._8, t10._9, t10._10)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap10(t10._1, t10._2, t10._3, t10._4, t10._5, t10._6, t10._7, t10._8, t10._9, t10._10)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)] = Semigroupal.tuple10(t10._1, t10._2, t10._3, t10._4, t10._5, t10._6, t10._7, t10._8, t10._9, t10._10)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse10(t10._1, t10._2, t10._3, t10._4, t10._5, t10._6, t10._7, t10._8, t10._9, t10._10)(f)
- def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap10(f)(t10._1, t10._2, t10._3, t10._4, t10._5, t10._6, t10._7, t10._8, t10._9, t10._10)
-}
-private[syntax] final class Tuple11SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](private val t11: Tuple11[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map11(t11._1, t11._2, t11._3, t11._4, t11._5, t11._6, t11._7, t11._8, t11._9, t11._10, t11._11)(f)
- def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap11(t11._1, t11._2, t11._3, t11._4, t11._5, t11._6, t11._7, t11._8, t11._9, t11._10, t11._11)(f)
- def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap11(t11._1, t11._2, t11._3, t11._4, t11._5, t11._6, t11._7, t11._8, t11._9, t11._10, t11._11)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap11(t11._1, t11._2, t11._3, t11._4, t11._5, t11._6, t11._7, t11._8, t11._9, t11._10, t11._11)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)] = Semigroupal.tuple11(t11._1, t11._2, t11._3, t11._4, t11._5, t11._6, t11._7, t11._8, t11._9, t11._10, t11._11)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse11(t11._1, t11._2, t11._3, t11._4, t11._5, t11._6, t11._7, t11._8, t11._9, t11._10, t11._11)(f)
- def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap11(f)(t11._1, t11._2, t11._3, t11._4, t11._5, t11._6, t11._7, t11._8, t11._9, t11._10, t11._11)
-}
-private[syntax] final class Tuple12SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](private val t12: Tuple12[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map12(t12._1, t12._2, t12._3, t12._4, t12._5, t12._6, t12._7, t12._8, t12._9, t12._10, t12._11, t12._12)(f)
- def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap12(t12._1, t12._2, t12._3, t12._4, t12._5, t12._6, t12._7, t12._8, t12._9, t12._10, t12._11, t12._12)(f)
- def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap12(t12._1, t12._2, t12._3, t12._4, t12._5, t12._6, t12._7, t12._8, t12._9, t12._10, t12._11, t12._12)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap12(t12._1, t12._2, t12._3, t12._4, t12._5, t12._6, t12._7, t12._8, t12._9, t12._10, t12._11, t12._12)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)] = Semigroupal.tuple12(t12._1, t12._2, t12._3, t12._4, t12._5, t12._6, t12._7, t12._8, t12._9, t12._10, t12._11, t12._12)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse12(t12._1, t12._2, t12._3, t12._4, t12._5, t12._6, t12._7, t12._8, t12._9, t12._10, t12._11, t12._12)(f)
- def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap12(f)(t12._1, t12._2, t12._3, t12._4, t12._5, t12._6, t12._7, t12._8, t12._9, t12._10, t12._11, t12._12)
-}
-private[syntax] final class Tuple13SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](private val t13: Tuple13[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map13(t13._1, t13._2, t13._3, t13._4, t13._5, t13._6, t13._7, t13._8, t13._9, t13._10, t13._11, t13._12, t13._13)(f)
- def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap13(t13._1, t13._2, t13._3, t13._4, t13._5, t13._6, t13._7, t13._8, t13._9, t13._10, t13._11, t13._12, t13._13)(f)
- def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap13(t13._1, t13._2, t13._3, t13._4, t13._5, t13._6, t13._7, t13._8, t13._9, t13._10, t13._11, t13._12, t13._13)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap13(t13._1, t13._2, t13._3, t13._4, t13._5, t13._6, t13._7, t13._8, t13._9, t13._10, t13._11, t13._12, t13._13)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)] = Semigroupal.tuple13(t13._1, t13._2, t13._3, t13._4, t13._5, t13._6, t13._7, t13._8, t13._9, t13._10, t13._11, t13._12, t13._13)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse13(t13._1, t13._2, t13._3, t13._4, t13._5, t13._6, t13._7, t13._8, t13._9, t13._10, t13._11, t13._12, t13._13)(f)
- def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap13(f)(t13._1, t13._2, t13._3, t13._4, t13._5, t13._6, t13._7, t13._8, t13._9, t13._10, t13._11, t13._12, t13._13)
-}
-private[syntax] final class Tuple14SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](private val t14: Tuple14[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map14(t14._1, t14._2, t14._3, t14._4, t14._5, t14._6, t14._7, t14._8, t14._9, t14._10, t14._11, t14._12, t14._13, t14._14)(f)
- def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap14(t14._1, t14._2, t14._3, t14._4, t14._5, t14._6, t14._7, t14._8, t14._9, t14._10, t14._11, t14._12, t14._13, t14._14)(f)
- def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap14(t14._1, t14._2, t14._3, t14._4, t14._5, t14._6, t14._7, t14._8, t14._9, t14._10, t14._11, t14._12, t14._13, t14._14)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap14(t14._1, t14._2, t14._3, t14._4, t14._5, t14._6, t14._7, t14._8, t14._9, t14._10, t14._11, t14._12, t14._13, t14._14)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)] = Semigroupal.tuple14(t14._1, t14._2, t14._3, t14._4, t14._5, t14._6, t14._7, t14._8, t14._9, t14._10, t14._11, t14._12, t14._13, t14._14)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse14(t14._1, t14._2, t14._3, t14._4, t14._5, t14._6, t14._7, t14._8, t14._9, t14._10, t14._11, t14._12, t14._13, t14._14)(f)
- def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap14(f)(t14._1, t14._2, t14._3, t14._4, t14._5, t14._6, t14._7, t14._8, t14._9, t14._10, t14._11, t14._12, t14._13, t14._14)
-}
-private[syntax] final class Tuple15SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](private val t15: Tuple15[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map15(t15._1, t15._2, t15._3, t15._4, t15._5, t15._6, t15._7, t15._8, t15._9, t15._10, t15._11, t15._12, t15._13, t15._14, t15._15)(f)
- def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap15(t15._1, t15._2, t15._3, t15._4, t15._5, t15._6, t15._7, t15._8, t15._9, t15._10, t15._11, t15._12, t15._13, t15._14, t15._15)(f)
- def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap15(t15._1, t15._2, t15._3, t15._4, t15._5, t15._6, t15._7, t15._8, t15._9, t15._10, t15._11, t15._12, t15._13, t15._14, t15._15)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap15(t15._1, t15._2, t15._3, t15._4, t15._5, t15._6, t15._7, t15._8, t15._9, t15._10, t15._11, t15._12, t15._13, t15._14, t15._15)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)] = Semigroupal.tuple15(t15._1, t15._2, t15._3, t15._4, t15._5, t15._6, t15._7, t15._8, t15._9, t15._10, t15._11, t15._12, t15._13, t15._14, t15._15)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse15(t15._1, t15._2, t15._3, t15._4, t15._5, t15._6, t15._7, t15._8, t15._9, t15._10, t15._11, t15._12, t15._13, t15._14, t15._15)(f)
- def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap15(f)(t15._1, t15._2, t15._3, t15._4, t15._5, t15._6, t15._7, t15._8, t15._9, t15._10, t15._11, t15._12, t15._13, t15._14, t15._15)
-}
-private[syntax] final class Tuple16SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](private val t16: Tuple16[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map16(t16._1, t16._2, t16._3, t16._4, t16._5, t16._6, t16._7, t16._8, t16._9, t16._10, t16._11, t16._12, t16._13, t16._14, t16._15, t16._16)(f)
- def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap16(t16._1, t16._2, t16._3, t16._4, t16._5, t16._6, t16._7, t16._8, t16._9, t16._10, t16._11, t16._12, t16._13, t16._14, t16._15, t16._16)(f)
- def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap16(t16._1, t16._2, t16._3, t16._4, t16._5, t16._6, t16._7, t16._8, t16._9, t16._10, t16._11, t16._12, t16._13, t16._14, t16._15, t16._16)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap16(t16._1, t16._2, t16._3, t16._4, t16._5, t16._6, t16._7, t16._8, t16._9, t16._10, t16._11, t16._12, t16._13, t16._14, t16._15, t16._16)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)] = Semigroupal.tuple16(t16._1, t16._2, t16._3, t16._4, t16._5, t16._6, t16._7, t16._8, t16._9, t16._10, t16._11, t16._12, t16._13, t16._14, t16._15, t16._16)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse16(t16._1, t16._2, t16._3, t16._4, t16._5, t16._6, t16._7, t16._8, t16._9, t16._10, t16._11, t16._12, t16._13, t16._14, t16._15, t16._16)(f)
- def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap16(f)(t16._1, t16._2, t16._3, t16._4, t16._5, t16._6, t16._7, t16._8, t16._9, t16._10, t16._11, t16._12, t16._13, t16._14, t16._15, t16._16)
-}
-private[syntax] final class Tuple17SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](private val t17: Tuple17[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map17(t17._1, t17._2, t17._3, t17._4, t17._5, t17._6, t17._7, t17._8, t17._9, t17._10, t17._11, t17._12, t17._13, t17._14, t17._15, t17._16, t17._17)(f)
- def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap17(t17._1, t17._2, t17._3, t17._4, t17._5, t17._6, t17._7, t17._8, t17._9, t17._10, t17._11, t17._12, t17._13, t17._14, t17._15, t17._16, t17._17)(f)
- def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap17(t17._1, t17._2, t17._3, t17._4, t17._5, t17._6, t17._7, t17._8, t17._9, t17._10, t17._11, t17._12, t17._13, t17._14, t17._15, t17._16, t17._17)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap17(t17._1, t17._2, t17._3, t17._4, t17._5, t17._6, t17._7, t17._8, t17._9, t17._10, t17._11, t17._12, t17._13, t17._14, t17._15, t17._16, t17._17)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)] = Semigroupal.tuple17(t17._1, t17._2, t17._3, t17._4, t17._5, t17._6, t17._7, t17._8, t17._9, t17._10, t17._11, t17._12, t17._13, t17._14, t17._15, t17._16, t17._17)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse17(t17._1, t17._2, t17._3, t17._4, t17._5, t17._6, t17._7, t17._8, t17._9, t17._10, t17._11, t17._12, t17._13, t17._14, t17._15, t17._16, t17._17)(f)
- def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap17(f)(t17._1, t17._2, t17._3, t17._4, t17._5, t17._6, t17._7, t17._8, t17._9, t17._10, t17._11, t17._12, t17._13, t17._14, t17._15, t17._16, t17._17)
-}
-private[syntax] final class Tuple18SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](private val t18: Tuple18[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map18(t18._1, t18._2, t18._3, t18._4, t18._5, t18._6, t18._7, t18._8, t18._9, t18._10, t18._11, t18._12, t18._13, t18._14, t18._15, t18._16, t18._17, t18._18)(f)
- def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap18(t18._1, t18._2, t18._3, t18._4, t18._5, t18._6, t18._7, t18._8, t18._9, t18._10, t18._11, t18._12, t18._13, t18._14, t18._15, t18._16, t18._17, t18._18)(f)
- def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap18(t18._1, t18._2, t18._3, t18._4, t18._5, t18._6, t18._7, t18._8, t18._9, t18._10, t18._11, t18._12, t18._13, t18._14, t18._15, t18._16, t18._17, t18._18)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap18(t18._1, t18._2, t18._3, t18._4, t18._5, t18._6, t18._7, t18._8, t18._9, t18._10, t18._11, t18._12, t18._13, t18._14, t18._15, t18._16, t18._17, t18._18)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)] = Semigroupal.tuple18(t18._1, t18._2, t18._3, t18._4, t18._5, t18._6, t18._7, t18._8, t18._9, t18._10, t18._11, t18._12, t18._13, t18._14, t18._15, t18._16, t18._17, t18._18)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse18(t18._1, t18._2, t18._3, t18._4, t18._5, t18._6, t18._7, t18._8, t18._9, t18._10, t18._11, t18._12, t18._13, t18._14, t18._15, t18._16, t18._17, t18._18)(f)
- def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap18(f)(t18._1, t18._2, t18._3, t18._4, t18._5, t18._6, t18._7, t18._8, t18._9, t18._10, t18._11, t18._12, t18._13, t18._14, t18._15, t18._16, t18._17, t18._18)
-}
-private[syntax] final class Tuple19SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](private val t19: Tuple19[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17], F[A18]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map19(t19._1, t19._2, t19._3, t19._4, t19._5, t19._6, t19._7, t19._8, t19._9, t19._10, t19._11, t19._12, t19._13, t19._14, t19._15, t19._16, t19._17, t19._18, t19._19)(f)
- def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap19(t19._1, t19._2, t19._3, t19._4, t19._5, t19._6, t19._7, t19._8, t19._9, t19._10, t19._11, t19._12, t19._13, t19._14, t19._15, t19._16, t19._17, t19._18, t19._19)(f)
- def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap19(t19._1, t19._2, t19._3, t19._4, t19._5, t19._6, t19._7, t19._8, t19._9, t19._10, t19._11, t19._12, t19._13, t19._14, t19._15, t19._16, t19._17, t19._18, t19._19)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap19(t19._1, t19._2, t19._3, t19._4, t19._5, t19._6, t19._7, t19._8, t19._9, t19._10, t19._11, t19._12, t19._13, t19._14, t19._15, t19._16, t19._17, t19._18, t19._19)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)] = Semigroupal.tuple19(t19._1, t19._2, t19._3, t19._4, t19._5, t19._6, t19._7, t19._8, t19._9, t19._10, t19._11, t19._12, t19._13, t19._14, t19._15, t19._16, t19._17, t19._18, t19._19)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse19(t19._1, t19._2, t19._3, t19._4, t19._5, t19._6, t19._7, t19._8, t19._9, t19._10, t19._11, t19._12, t19._13, t19._14, t19._15, t19._16, t19._17, t19._18, t19._19)(f)
- def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap19(f)(t19._1, t19._2, t19._3, t19._4, t19._5, t19._6, t19._7, t19._8, t19._9, t19._10, t19._11, t19._12, t19._13, t19._14, t19._15, t19._16, t19._17, t19._18, t19._19)
-}
-private[syntax] final class Tuple20SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](private val t20: Tuple20[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17], F[A18], F[A19]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map20(t20._1, t20._2, t20._3, t20._4, t20._5, t20._6, t20._7, t20._8, t20._9, t20._10, t20._11, t20._12, t20._13, t20._14, t20._15, t20._16, t20._17, t20._18, t20._19, t20._20)(f)
- def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap20(t20._1, t20._2, t20._3, t20._4, t20._5, t20._6, t20._7, t20._8, t20._9, t20._10, t20._11, t20._12, t20._13, t20._14, t20._15, t20._16, t20._17, t20._18, t20._19, t20._20)(f)
- def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap20(t20._1, t20._2, t20._3, t20._4, t20._5, t20._6, t20._7, t20._8, t20._9, t20._10, t20._11, t20._12, t20._13, t20._14, t20._15, t20._16, t20._17, t20._18, t20._19, t20._20)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap20(t20._1, t20._2, t20._3, t20._4, t20._5, t20._6, t20._7, t20._8, t20._9, t20._10, t20._11, t20._12, t20._13, t20._14, t20._15, t20._16, t20._17, t20._18, t20._19, t20._20)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)] = Semigroupal.tuple20(t20._1, t20._2, t20._3, t20._4, t20._5, t20._6, t20._7, t20._8, t20._9, t20._10, t20._11, t20._12, t20._13, t20._14, t20._15, t20._16, t20._17, t20._18, t20._19, t20._20)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse20(t20._1, t20._2, t20._3, t20._4, t20._5, t20._6, t20._7, t20._8, t20._9, t20._10, t20._11, t20._12, t20._13, t20._14, t20._15, t20._16, t20._17, t20._18, t20._19, t20._20)(f)
- def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap20(f)(t20._1, t20._2, t20._3, t20._4, t20._5, t20._6, t20._7, t20._8, t20._9, t20._10, t20._11, t20._12, t20._13, t20._14, t20._15, t20._16, t20._17, t20._18, t20._19, t20._20)
-}
-private[syntax] final class Tuple21SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](private val t21: Tuple21[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17], F[A18], F[A19], F[A20]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map21(t21._1, t21._2, t21._3, t21._4, t21._5, t21._6, t21._7, t21._8, t21._9, t21._10, t21._11, t21._12, t21._13, t21._14, t21._15, t21._16, t21._17, t21._18, t21._19, t21._20, t21._21)(f)
- def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap21(t21._1, t21._2, t21._3, t21._4, t21._5, t21._6, t21._7, t21._8, t21._9, t21._10, t21._11, t21._12, t21._13, t21._14, t21._15, t21._16, t21._17, t21._18, t21._19, t21._20, t21._21)(f)
- def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap21(t21._1, t21._2, t21._3, t21._4, t21._5, t21._6, t21._7, t21._8, t21._9, t21._10, t21._11, t21._12, t21._13, t21._14, t21._15, t21._16, t21._17, t21._18, t21._19, t21._20, t21._21)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap21(t21._1, t21._2, t21._3, t21._4, t21._5, t21._6, t21._7, t21._8, t21._9, t21._10, t21._11, t21._12, t21._13, t21._14, t21._15, t21._16, t21._17, t21._18, t21._19, t21._20, t21._21)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)] = Semigroupal.tuple21(t21._1, t21._2, t21._3, t21._4, t21._5, t21._6, t21._7, t21._8, t21._9, t21._10, t21._11, t21._12, t21._13, t21._14, t21._15, t21._16, t21._17, t21._18, t21._19, t21._20, t21._21)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse21(t21._1, t21._2, t21._3, t21._4, t21._5, t21._6, t21._7, t21._8, t21._9, t21._10, t21._11, t21._12, t21._13, t21._14, t21._15, t21._16, t21._17, t21._18, t21._19, t21._20, t21._21)(f)
- def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap21(f)(t21._1, t21._2, t21._3, t21._4, t21._5, t21._6, t21._7, t21._8, t21._9, t21._10, t21._11, t21._12, t21._13, t21._14, t21._15, t21._16, t21._17, t21._18, t21._19, t21._20, t21._21)
-}
-private[syntax] final class Tuple22SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](private val t22: Tuple22[F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17], F[A18], F[A19], F[A20], F[A21]]) extends Serializable {
- def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map22(t22._1, t22._2, t22._3, t22._4, t22._5, t22._6, t22._7, t22._8, t22._9, t22._10, t22._11, t22._12, t22._13, t22._14, t22._15, t22._16, t22._17, t22._18, t22._19, t22._20, t22._21, t22._22)(f)
- def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap22(t22._1, t22._2, t22._3, t22._4, t22._5, t22._6, t22._7, t22._8, t22._9, t22._10, t22._11, t22._12, t22._13, t22._14, t22._15, t22._16, t22._17, t22._18, t22._19, t22._20, t22._21, t22._22)(f)
- def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap22(t22._1, t22._2, t22._3, t22._4, t22._5, t22._6, t22._7, t22._8, t22._9, t22._10, t22._11, t22._12, t22._13, t22._14, t22._15, t22._16, t22._17, t22._18, t22._19, t22._20, t22._21, t22._22)(f)(g)
- def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap22(t22._1, t22._2, t22._3, t22._4, t22._5, t22._6, t22._7, t22._8, t22._9, t22._10, t22._11, t22._12, t22._13, t22._14, t22._15, t22._16, t22._17, t22._18, t22._19, t22._20, t22._21, t22._22)(f)
- def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)] = Semigroupal.tuple22(t22._1, t22._2, t22._3, t22._4, t22._5, t22._6, t22._7, t22._8, t22._9, t22._10, t22._11, t22._12, t22._13, t22._14, t22._15, t22._16, t22._17, t22._18, t22._19, t22._20, t22._21, t22._22)
- def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse22(t22._1, t22._2, t22._3, t22._4, t22._5, t22._6, t22._7, t22._8, t22._9, t22._10, t22._11, t22._12, t22._13, t22._14, t22._15, t22._16, t22._17, t22._18, t22._19, t22._20, t22._21, t22._22)(f)
- def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap22(f)(t22._1, t22._2, t22._3, t22._4, t22._5, t22._6, t22._7, t22._8, t22._9, t22._10, t22._11, t22._12, t22._13, t22._14, t22._15, t22._16, t22._17, t22._18, t22._19, t22._20, t22._21, t22._22)
+ def traverse[G[_]: Applicative, Z](f: (A0) => G[Z])(implicit traverse: Traverse[F]): G[F[Z]] = traverse.traverse(t._1)(f)
+ def apWith[Z](f: F[(A0) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap(f)(t._1)
+}
+private[syntax] final class Tuple2SemigroupalOps[F[_], A0, A1](private val t: (F[A0], F[A1])) extends Serializable {
+ def mapN[Z](f: (A0, A1) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map2(t._1, t._2)(f)
+ def contramapN[Z](f: Z => (A0, A1))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap2(t._1, t._2)(f)
+ def imapN[Z](f: (A0, A1) => Z)(g: Z => (A0, A1))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap2(t._1, t._2)(f)(g)
+ def flatMapN[Z](f: (A0, A1) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap2(t._1, t._2)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1)] = Semigroupal.tuple2(t._1, t._2)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse2(t._1, t._2)(f)
+ def apWith[Z](f: F[(A0, A1) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap2(f)(t._1, t._2)
+}
+private[syntax] final class Tuple3SemigroupalOps[F[_], A0, A1, A2](private val t: (F[A0], F[A1], F[A2])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map3(t._1, t._2, t._3)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap3(t._1, t._2, t._3)(f)
+ def imapN[Z](f: (A0, A1, A2) => Z)(g: Z => (A0, A1, A2))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap3(t._1, t._2, t._3)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap3(t._1, t._2, t._3)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2)] = Semigroupal.tuple3(t._1, t._2, t._3)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse3(t._1, t._2, t._3)(f)
+ def apWith[Z](f: F[(A0, A1, A2) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap3(f)(t._1, t._2, t._3)
+}
+private[syntax] final class Tuple4SemigroupalOps[F[_], A0, A1, A2, A3](private val t: (F[A0], F[A1], F[A2], F[A3])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2, A3) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map4(t._1, t._2, t._3, t._4)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2, A3))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap4(t._1, t._2, t._3, t._4)(f)
+ def imapN[Z](f: (A0, A1, A2, A3) => Z)(g: Z => (A0, A1, A2, A3))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap4(t._1, t._2, t._3, t._4)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2, A3) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap4(t._1, t._2, t._3, t._4)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3)] = Semigroupal.tuple4(t._1, t._2, t._3, t._4)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse4(t._1, t._2, t._3, t._4)(f)
+ def apWith[Z](f: F[(A0, A1, A2, A3) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap4(f)(t._1, t._2, t._3, t._4)
+}
+private[syntax] final class Tuple5SemigroupalOps[F[_], A0, A1, A2, A3, A4](private val t: (F[A0], F[A1], F[A2], F[A3], F[A4])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2, A3, A4) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map5(t._1, t._2, t._3, t._4, t._5)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2, A3, A4))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap5(t._1, t._2, t._3, t._4, t._5)(f)
+ def imapN[Z](f: (A0, A1, A2, A3, A4) => Z)(g: Z => (A0, A1, A2, A3, A4))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap5(t._1, t._2, t._3, t._4, t._5)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2, A3, A4) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap5(t._1, t._2, t._3, t._4, t._5)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4)] = Semigroupal.tuple5(t._1, t._2, t._3, t._4, t._5)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse5(t._1, t._2, t._3, t._4, t._5)(f)
+ def apWith[Z](f: F[(A0, A1, A2, A3, A4) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap5(f)(t._1, t._2, t._3, t._4, t._5)
+}
+private[syntax] final class Tuple6SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5](private val t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2, A3, A4, A5) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map6(t._1, t._2, t._3, t._4, t._5, t._6)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap6(t._1, t._2, t._3, t._4, t._5, t._6)(f)
+ def imapN[Z](f: (A0, A1, A2, A3, A4, A5) => Z)(g: Z => (A0, A1, A2, A3, A4, A5))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap6(t._1, t._2, t._3, t._4, t._5, t._6)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap6(t._1, t._2, t._3, t._4, t._5, t._6)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5)] = Semigroupal.tuple6(t._1, t._2, t._3, t._4, t._5, t._6)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse6(t._1, t._2, t._3, t._4, t._5, t._6)(f)
+ def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap6(f)(t._1, t._2, t._3, t._4, t._5, t._6)
+}
+private[syntax] final class Tuple7SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6](private val t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map7(t._1, t._2, t._3, t._4, t._5, t._6, t._7)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap7(t._1, t._2, t._3, t._4, t._5, t._6, t._7)(f)
+ def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap7(t._1, t._2, t._3, t._4, t._5, t._6, t._7)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap7(t._1, t._2, t._3, t._4, t._5, t._6, t._7)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6)] = Semigroupal.tuple7(t._1, t._2, t._3, t._4, t._5, t._6, t._7)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse7(t._1, t._2, t._3, t._4, t._5, t._6, t._7)(f)
+ def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap7(f)(t._1, t._2, t._3, t._4, t._5, t._6, t._7)
+}
+private[syntax] final class Tuple8SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7](private val t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map8(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap8(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8)(f)
+ def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap8(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap8(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7)] = Semigroupal.tuple8(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse8(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8)(f)
+ def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap8(f)(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8)
+}
+private[syntax] final class Tuple9SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8](private val t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map9(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap9(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9)(f)
+ def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap9(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap9(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8)] = Semigroupal.tuple9(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse9(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9)(f)
+ def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap9(f)(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9)
+}
+private[syntax] final class Tuple10SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](private val t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map10(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap10(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10)(f)
+ def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap10(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap10(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)] = Semigroupal.tuple10(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse10(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10)(f)
+ def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap10(f)(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10)
+}
+private[syntax] final class Tuple11SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](private val t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map11(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap11(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11)(f)
+ def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap11(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap11(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)] = Semigroupal.tuple11(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse11(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11)(f)
+ def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap11(f)(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11)
+}
+private[syntax] final class Tuple12SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](private val t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map12(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap12(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12)(f)
+ def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap12(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap12(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)] = Semigroupal.tuple12(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse12(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12)(f)
+ def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap12(f)(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12)
+}
+private[syntax] final class Tuple13SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](private val t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map13(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap13(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13)(f)
+ def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap13(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap13(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)] = Semigroupal.tuple13(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse13(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13)(f)
+ def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap13(f)(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13)
+}
+private[syntax] final class Tuple14SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](private val t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map14(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap14(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14)(f)
+ def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap14(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap14(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)] = Semigroupal.tuple14(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse14(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14)(f)
+ def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap14(f)(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14)
+}
+private[syntax] final class Tuple15SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](private val t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map15(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap15(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15)(f)
+ def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap15(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap15(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)] = Semigroupal.tuple15(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse15(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15)(f)
+ def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap15(f)(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15)
+}
+private[syntax] final class Tuple16SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](private val t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map16(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap16(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16)(f)
+ def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap16(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap16(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)] = Semigroupal.tuple16(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse16(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16)(f)
+ def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap16(f)(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16)
+}
+private[syntax] final class Tuple17SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](private val t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map17(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap17(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17)(f)
+ def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap17(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap17(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)] = Semigroupal.tuple17(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse17(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17)(f)
+ def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap17(f)(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17)
+}
+private[syntax] final class Tuple18SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](private val t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map18(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap18(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18)(f)
+ def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap18(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap18(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)] = Semigroupal.tuple18(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse18(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18)(f)
+ def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap18(f)(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18)
+}
+private[syntax] final class Tuple19SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](private val t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17], F[A18])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map19(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap19(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19)(f)
+ def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap19(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap19(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)] = Semigroupal.tuple19(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse19(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19)(f)
+ def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap19(f)(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19)
+}
+private[syntax] final class Tuple20SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](private val t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17], F[A18], F[A19])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map20(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap20(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20)(f)
+ def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap20(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap20(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)] = Semigroupal.tuple20(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse20(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20)(f)
+ def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap20(f)(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20)
+}
+private[syntax] final class Tuple21SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](private val t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17], F[A18], F[A19], F[A20])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map21(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap21(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21)(f)
+ def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap21(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap21(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)] = Semigroupal.tuple21(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse21(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21)(f)
+ def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap21(f)(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21)
+}
+private[syntax] final class Tuple22SemigroupalOps[F[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](private val t: (F[A0], F[A1], F[A2], F[A3], F[A4], F[A5], F[A6], F[A7], F[A8], F[A9], F[A10], F[A11], F[A12], F[A13], F[A14], F[A15], F[A16], F[A17], F[A18], F[A19], F[A20], F[A21])) extends Serializable {
+ def mapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map22(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21, t._22)(f)
+ def contramapN[Z](f: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21))(implicit contravariant: Contravariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.contramap22(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21, t._22)(f)
+ def imapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z)(g: Z => (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21))(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.imap22(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21, t._22)(f)(g)
+ def flatMapN[Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => F[Z])(implicit flatMap: FlatMap[F]): F[Z] = flatMap.flatMap22(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21, t._22)(f)
+ def tupled(implicit invariant: Invariant[F], semigroupal: Semigroupal[F]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)] = Semigroupal.tuple22(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21, t._22)
+ def traverseN[G[_]: Applicative, Z](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => G[Z])(implicit traverse: Traverse[F], semigroupal: Semigroupal[F]): G[F[Z]] = Semigroupal.traverse22(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21, t._22)(f)
+ def apWith[Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(implicit apply: Apply[F]): F[Z] = apply.ap22(f)(t._1, t._2, t._3, t._4, t._5, t._6, t._7, t._8, t._9, t._10, t._11, t._12, t._13, t._14, t._15, t._16, t._17, t._18, t._19, t._20, t._21, t._22)
} |
kubukoz
approved these changes
Dec 24, 2024
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
It makes the generated code a bit simpler