• Home
• dev.travisbrown
• cats-core_2.12
• 2.1.0-CATS_3043-1
• source code
• TupleSemigroupalSyntax.scala

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

cats.syntax.TupleSemigroupalSyntax.scala Maven / Gradle / Ivy

// auto-generated boilerplate by /project/Boilerplate.scala
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)
}

private[syntax] final class Tuple1SemigroupalOps[F[_], A0](private val t1: Tuple1[F[A0]]) {
  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 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]]) {
  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 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]]) {
  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 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]]) {
  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 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]]) {
  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 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]]) {
  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 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]]) {
  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 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]]) {
  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 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]]) {
  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 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]]) {
  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 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]]) {
  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 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]]) {
  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 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]]) {
  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 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]]) {
  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 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]]) {
  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 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]]) {
  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 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]]) {
  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 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]]) {
  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 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]]) {
  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 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]]) {
  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 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]]) {
  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 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]]) {
  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 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)
}