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.
datomisca.functional.builders.scala Maven / Gradle / Ivy
/*
* Copyright 2012 Pellucid and Zenexity
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package datomisca
package functional
import scala.language.higherKinds
class Builder[M[_]](combi: Combinator[M]) {
class Builder2[A1, A2](m1: M[A1], m2:M[A2]) {
def ~[A3](m3: M[A3]) = new Builder3[A1, A2, A3](combi(m1, m2), m3)
def and[A3](m3: M[A3]) = this.~(m3)
def apply[B](f: (A1, A2) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2, B](combi(m1, m2), { case a1 ~ a2 => f(a1, a2) })
def apply[B](f: B => (A1, A2))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2) => new ~(a1, a2) } })
def tupled(implicit v: Variant[M]): M[(A1, A2)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2) => (a1, a2))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2)) => (a._1, a._2))(f)
}
}
class Builder3[A1, A2, A3](m1: M[A1 ~ A2], m2:M[A3]) {
def ~[A4](m3: M[A4]) = new Builder4[A1, A2, A3, A4](combi(m1, m2), m3)
def and[A4](m3: M[A4]) = this.~(m3)
def apply[B](f: (A1, A2, A3) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2~A3, B](combi(m1, m2), { case a1 ~ a2 ~ a3 => f(a1, a2, a3) })
def apply[B](f: B => (A1, A2, A3))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2~A3, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2, a3) => new ~(new ~(a1, a2), a3) } })
def tupled(implicit v: Variant[M]): M[(A1, A2, A3)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2, a3: A3) => (a1, a2, a3))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2, A3)) => (a._1, a._2, a._3))(f)
}
}
class Builder4[A1, A2, A3, A4](m1: M[A1 ~ A2 ~ A3], m2:M[A4]) {
def ~[A5](m3: M[A5]) = new Builder5[A1, A2, A3, A4, A5](combi(m1, m2), m3)
def and[A5](m3: M[A5]) = this.~(m3)
def apply[B](f: (A1, A2, A3, A4) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2~A3~A4, B](combi(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 => f(a1, a2, a3, a4) })
def apply[B](f: B => (A1, A2, A3, A4))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2~A3~A4, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2, a3, a4) => new ~(new ~(new ~(a1, a2), a3), a4) } })
def tupled(implicit v: Variant[M]): M[(A1, A2, A3, A4)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2, a3: A3, a4: A4) => (a1, a2, a3, a4))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2, A3, A4)) => (a._1, a._2, a._3, a._4))(f)
}
}
class Builder5[A1, A2, A3, A4, A5](m1: M[A1 ~ A2 ~ A3 ~ A4], m2:M[A5]) {
def ~[A6](m3: M[A6]) = new Builder6[A1, A2, A3, A4, A5, A6](combi(m1, m2), m3)
def and[A6](m3: M[A6]) = this.~(m3)
def apply[B](f: (A1, A2, A3, A4, A5) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2~A3~A4~A5, B](combi(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 => f(a1, a2, a3, a4, a5) })
def apply[B](f: B => (A1, A2, A3, A4, A5))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2~A3~A4~A5, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2, a3, a4, a5) => new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5) } })
def tupled(implicit v: Variant[M]): M[(A1, A2, A3, A4, A5)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2, a3: A3, a4: A4, a5: A5) => (a1, a2, a3, a4, a5))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2, A3, A4, A5)) => (a._1, a._2, a._3, a._4, a._5))(f)
}
}
class Builder6[A1, A2, A3, A4, A5, A6](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5], m2:M[A6]) {
def ~[A7](m3: M[A7]) = new Builder7[A1, A2, A3, A4, A5, A6, A7](combi(m1, m2), m3)
def and[A7](m3: M[A7]) = this.~(m3)
def apply[B](f: (A1, A2, A3, A4, A5, A6) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2~A3~A4~A5~A6, B](combi(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 => f(a1, a2, a3, a4, a5, a6) })
def apply[B](f: B => (A1, A2, A3, A4, A5, A6))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2~A3~A4~A5~A6, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2, a3, a4, a5, a6) => new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6) } })
def tupled(implicit v: Variant[M]): M[(A1, A2, A3, A4, A5, A6)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6) => (a1, a2, a3, a4, a5, a6))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2, A3, A4, A5, A6)) => (a._1, a._2, a._3, a._4, a._5, a._6))(f)
}
}
class Builder7[A1, A2, A3, A4, A5, A6, A7](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6], m2:M[A7]) {
def ~[A8](m3: M[A8]) = new Builder8[A1, A2, A3, A4, A5, A6, A7, A8](combi(m1, m2), m3)
def and[A8](m3: M[A8]) = this.~(m3)
def apply[B](f: (A1, A2, A3, A4, A5, A6, A7) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2~A3~A4~A5~A6~A7, B](combi(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 ~ a7 => f(a1, a2, a3, a4, a5, a6, a7) })
def apply[B](f: B => (A1, A2, A3, A4, A5, A6, A7))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2~A3~A4~A5~A6~A7, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2, a3, a4, a5, a6, a7) => new ~(new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6), a7) } })
def tupled(implicit v: Variant[M]): M[(A1, A2, A3, A4, A5, A6, A7)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7) => (a1, a2, a3, a4, a5, a6, a7))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2, A3, A4, A5, A6, A7)) => (a._1, a._2, a._3, a._4, a._5, a._6, a._7))(f)
}
}
class Builder8[A1, A2, A3, A4, A5, A6, A7, A8](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7], m2:M[A8]) {
def ~[A9](m3: M[A9]) = new Builder9[A1, A2, A3, A4, A5, A6, A7, A8, A9](combi(m1, m2), m3)
def and[A9](m3: M[A9]) = this.~(m3)
def apply[B](f: (A1, A2, A3, A4, A5, A6, A7, A8) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2~A3~A4~A5~A6~A7~A8, B](combi(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 ~ a7 ~ a8 => f(a1, a2, a3, a4, a5, a6, a7, a8) })
def apply[B](f: B => (A1, A2, A3, A4, A5, A6, A7, A8))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2~A3~A4~A5~A6~A7~A8, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2, a3, a4, a5, a6, a7, a8) => new ~(new ~(new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6), a7), a8) } })
def tupled(implicit v: Variant[M]): M[(A1, A2, A3, A4, A5, A6, A7, A8)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8) => (a1, a2, a3, a4, a5, a6, a7, a8))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2, A3, A4, A5, A6, A7, A8)) => (a._1, a._2, a._3, a._4, a._5, a._6, a._7, a._8))(f)
}
}
class Builder9[A1, A2, A3, A4, A5, A6, A7, A8, A9](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8], m2:M[A9]) {
def ~[A10](m3: M[A10]) = new Builder10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](combi(m1, m2), m3)
def and[A10](m3: M[A10]) = this.~(m3)
def apply[B](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2~A3~A4~A5~A6~A7~A8~A9, B](combi(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 ~ a7 ~ a8 ~ a9 => f(a1, a2, a3, a4, a5, a6, a7, a8, a9) })
def apply[B](f: B => (A1, A2, A3, A4, A5, A6, A7, A8, A9))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2~A3~A4~A5~A6~A7~A8~A9, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2, a3, a4, a5, a6, a7, a8, a9) => new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6), a7), a8), a9) } })
def tupled(implicit v: Variant[M]): M[(A1, A2, A3, A4, A5, A6, A7, A8, A9)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9) => (a1, a2, a3, a4, a5, a6, a7, a8, a9))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2, A3, A4, A5, A6, A7, A8, A9)) => (a._1, a._2, a._3, a._4, a._5, a._6, a._7, a._8, a._9))(f)
}
}
class Builder10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9], m2:M[A10]) {
def ~[A11](m3: M[A11]) = new Builder11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](combi(m1, m2), m3)
def and[A11](m3: M[A11]) = this.~(m3)
def apply[B](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10, B](combi(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 ~ a7 ~ a8 ~ a9 ~ a10 => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) })
def apply[B](f: B => (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6), a7), a8), a9), a10) } })
def tupled(implicit v: Variant[M]): M[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10) => (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) => (a._1, a._2, a._3, a._4, a._5, a._6, a._7, a._8, a._9, a._10))(f)
}
}
class Builder11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10], m2:M[A11]) {
def ~[A12](m3: M[A12]) = new Builder12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](combi(m1, m2), m3)
def and[A12](m3: M[A12]) = this.~(m3)
def apply[B](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11, B](combi(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 ~ a7 ~ a8 ~ a9 ~ a10 ~ a11 => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) })
def apply[B](f: B => (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) => new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6), a7), a8), a9), a10), a11) } })
def tupled(implicit v: Variant[M]): M[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10, a11: A11) => (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)) => (a._1, a._2, a._3, a._4, a._5, a._6, a._7, a._8, a._9, a._10, a._11))(f)
}
}
class Builder12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10 ~ A11], m2:M[A12]) {
def ~[A13](m3: M[A13]) = new Builder13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](combi(m1, m2), m3)
def and[A13](m3: M[A13]) = this.~(m3)
def apply[B](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12, B](combi(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 ~ a7 ~ a8 ~ a9 ~ a10 ~ a11 ~ a12 => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) })
def apply[B](f: B => (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) => new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6), a7), a8), a9), a10), a11), a12) } })
def tupled(implicit v: Variant[M]): M[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10, a11: A11, a12: A12) => (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)) => (a._1, a._2, a._3, a._4, a._5, a._6, a._7, a._8, a._9, a._10, a._11, a._12))(f)
}
}
class Builder13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10 ~ A11 ~ A12], m2:M[A13]) {
def ~[A14](m3: M[A14]) = new Builder14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](combi(m1, m2), m3)
def and[A14](m3: M[A14]) = this.~(m3)
def apply[B](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12~A13, B](combi(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 ~ a7 ~ a8 ~ a9 ~ a10 ~ a11 ~ a12 ~ a13 => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) })
def apply[B](f: B => (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12~A13, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) => new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6), a7), a8), a9), a10), a11), a12), a13) } })
def tupled(implicit v: Variant[M]): M[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10, a11: A11, a12: A12, a13: A13) => (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)) => (a._1, a._2, a._3, a._4, a._5, a._6, a._7, a._8, a._9, a._10, a._11, a._12, a._13))(f)
}
}
class Builder14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10 ~ A11 ~ A12 ~ A13], m2:M[A14]) {
def ~[A15](m3: M[A15]) = new Builder15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](combi(m1, m2), m3)
def and[A15](m3: M[A15]) = this.~(m3)
def apply[B](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12~A13~A14, B](combi(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 ~ a7 ~ a8 ~ a9 ~ a10 ~ a11 ~ a12 ~ a13 ~ a14 => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) })
def apply[B](f: B => (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12~A13~A14, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) => new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6), a7), a8), a9), a10), a11), a12), a13), a14) } })
def tupled(implicit v: Variant[M]): M[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10, a11: A11, a12: A12, a13: A13, a14: A14) => (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)) => (a._1, a._2, a._3, a._4, a._5, a._6, a._7, a._8, a._9, a._10, a._11, a._12, a._13, a._14))(f)
}
}
class Builder15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10 ~ A11 ~ A12 ~ A13 ~ A14], m2:M[A15]) {
def ~[A16](m3: M[A16]) = new Builder16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](combi(m1, m2), m3)
def and[A16](m3: M[A16]) = this.~(m3)
def apply[B](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12~A13~A14~A15, B](combi(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 ~ a7 ~ a8 ~ a9 ~ a10 ~ a11 ~ a12 ~ a13 ~ a14 ~ a15 => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) })
def apply[B](f: B => (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12~A13~A14~A15, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) => new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6), a7), a8), a9), a10), a11), a12), a13), a14), a15) } })
def tupled(implicit v: Variant[M]): M[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10, a11: A11, a12: A12, a13: A13, a14: A14, a15: A15) => (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)) => (a._1, a._2, a._3, a._4, a._5, a._6, a._7, a._8, a._9, a._10, a._11, a._12, a._13, a._14, a._15))(f)
}
}
class Builder16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10 ~ A11 ~ A12 ~ A13 ~ A14 ~ A15], m2:M[A16]) {
def ~[A17](m3: M[A17]) = new Builder17[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](combi(m1, m2), m3)
def and[A17](m3: M[A17]) = this.~(m3)
def apply[B](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12~A13~A14~A15~A16, B](combi(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 ~ a7 ~ a8 ~ a9 ~ a10 ~ a11 ~ a12 ~ a13 ~ a14 ~ a15 ~ a16 => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) })
def apply[B](f: B => (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12~A13~A14~A15~A16, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) => new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6), a7), a8), a9), a10), a11), a12), a13), a14), a15), a16) } })
def tupled(implicit v: Variant[M]): M[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10, a11: A11, a12: A12, a13: A13, a14: A14, a15: A15, a16: A16) => (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)) => (a._1, a._2, a._3, a._4, a._5, a._6, a._7, a._8, a._9, a._10, a._11, a._12, a._13, a._14, a._15, a._16))(f)
}
}
class Builder17[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10 ~ A11 ~ A12 ~ A13 ~ A14 ~ A15 ~ A16], m2:M[A17]) {
def ~[A18](m3: M[A18]) = new Builder18[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](combi(m1, m2), m3)
def and[A18](m3: M[A18]) = this.~(m3)
def apply[B](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12~A13~A14~A15~A16~A17, B](combi(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 ~ a7 ~ a8 ~ a9 ~ a10 ~ a11 ~ a12 ~ a13 ~ a14 ~ a15 ~ a16 ~ a17 => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) })
def apply[B](f: B => (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12~A13~A14~A15~A16~A17, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) => new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6), a7), a8), a9), a10), a11), a12), a13), a14), a15), a16), a17) } })
def tupled(implicit v: Variant[M]): M[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10, a11: A11, a12: A12, a13: A13, a14: A14, a15: A15, a16: A16, a17: A17) => (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)) => (a._1, a._2, a._3, a._4, a._5, a._6, a._7, a._8, a._9, a._10, a._11, a._12, a._13, a._14, a._15, a._16, a._17))(f)
}
}
class Builder18[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10 ~ A11 ~ A12 ~ A13 ~ A14 ~ A15 ~ A16 ~ A17], m2:M[A18]) {
def ~[A19](m3: M[A19]) = new Builder19[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](combi(m1, m2), m3)
def and[A19](m3: M[A19]) = this.~(m3)
def apply[B](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12~A13~A14~A15~A16~A17~A18, B](combi(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 ~ a7 ~ a8 ~ a9 ~ a10 ~ a11 ~ a12 ~ a13 ~ a14 ~ a15 ~ a16 ~ a17 ~ a18 => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) })
def apply[B](f: B => (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12~A13~A14~A15~A16~A17~A18, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) => new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6), a7), a8), a9), a10), a11), a12), a13), a14), a15), a16), a17), a18) } })
def tupled(implicit v: Variant[M]): M[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10, a11: A11, a12: A12, a13: A13, a14: A14, a15: A15, a16: A16, a17: A17, a18: A18) => (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)) => (a._1, a._2, a._3, a._4, a._5, a._6, a._7, a._8, a._9, a._10, a._11, a._12, a._13, a._14, a._15, a._16, a._17, a._18))(f)
}
}
class Builder19[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10 ~ A11 ~ A12 ~ A13 ~ A14 ~ A15 ~ A16 ~ A17 ~ A18], m2:M[A19]) {
def ~[A20](m3: M[A20]) = new Builder20[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](combi(m1, m2), m3)
def and[A20](m3: M[A20]) = this.~(m3)
def apply[B](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12~A13~A14~A15~A16~A17~A18~A19, B](combi(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 ~ a7 ~ a8 ~ a9 ~ a10 ~ a11 ~ a12 ~ a13 ~ a14 ~ a15 ~ a16 ~ a17 ~ a18 ~ a19 => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) })
def apply[B](f: B => (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12~A13~A14~A15~A16~A17~A18~A19, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) => new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6), a7), a8), a9), a10), a11), a12), a13), a14), a15), a16), a17), a18), a19) } })
def tupled(implicit v: Variant[M]): M[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10, a11: A11, a12: A12, a13: A13, a14: A14, a15: A15, a16: A16, a17: A17, a18: A18, a19: A19) => (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)) => (a._1, a._2, a._3, a._4, a._5, a._6, a._7, a._8, a._9, a._10, a._11, a._12, a._13, a._14, a._15, a._16, a._17, a._18, a._19))(f)
}
}
class Builder20[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10 ~ A11 ~ A12 ~ A13 ~ A14 ~ A15 ~ A16 ~ A17 ~ A18 ~ A19], m2:M[A20]) {
def ~[A21](m3: M[A21]) = new Builder21[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](combi(m1, m2), m3)
def and[A21](m3: M[A21]) = this.~(m3)
def apply[B](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12~A13~A14~A15~A16~A17~A18~A19~A20, B](combi(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 ~ a7 ~ a8 ~ a9 ~ a10 ~ a11 ~ a12 ~ a13 ~ a14 ~ a15 ~ a16 ~ a17 ~ a18 ~ a19 ~ a20 => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) })
def apply[B](f: B => (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12~A13~A14~A15~A16~A17~A18~A19~A20, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) => new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6), a7), a8), a9), a10), a11), a12), a13), a14), a15), a16), a17), a18), a19), a20) } })
def tupled(implicit v: Variant[M]): M[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10, a11: A11, a12: A12, a13: A13, a14: A14, a15: A15, a16: A16, a17: A17, a18: A18, a19: A19, a20: A20) => (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)) => (a._1, a._2, a._3, a._4, a._5, a._6, a._7, a._8, a._9, a._10, a._11, a._12, a._13, a._14, a._15, a._16, a._17, a._18, a._19, a._20))(f)
}
}
class Builder21[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10 ~ A11 ~ A12 ~ A13 ~ A14 ~ A15 ~ A16 ~ A17 ~ A18 ~ A19 ~ A20], m2:M[A21]) {
def ~[A22](m3: M[A22]) = new Builder22[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22](combi(m1, m2), m3)
def and[A22](m3: M[A22]) = this.~(m3)
def apply[B](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => B)(implicit functor: Functor[M]): M[B] =
functor.fmap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12~A13~A14~A15~A16~A17~A18~A19~A20~A21, B](combi(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 ~ a7 ~ a8 ~ a9 ~ a10 ~ a11 ~ a12 ~ a13 ~ a14 ~ a15 ~ a16 ~ a17 ~ a18 ~ a19 ~ a20 ~ a21 => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) })
def apply[B](f: B => (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21))(implicit functor: ContraFunctor[M]): M[B] =
functor.contramap[A1~A2~A3~A4~A5~A6~A7~A8~A9~A10~A11~A12~A13~A14~A15~A16~A17~A18~A19~A20~A21, B](combi(m1, m2), { (b: B) => f(b) match { case (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) => new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6), a7), a8), a9), a10), a11), a12), a13), a14), a15), a16), a17), a18), a19), a20), a21) } })
def tupled(implicit v: Variant[M]): M[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)] = (v: @unchecked) match {
case f: Functor[M] => apply((a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10, a11: A11, a12: A12, a13: A13, a14: A14, a15: A15, a16: A16, a17: A17, a18: A18, a19: A19, a20: A20, a21: A21) => (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21))(f)
case f: ContraFunctor[M] => apply((a: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)) => (a._1, a._2, a._3, a._4, a._5, a._6, a._7, a._8, a._9, a._10, a._11, a._12, a._13, a._14, a._15, a._16, a._17, a._18, a._19, a._20, a._21))(f)
}
}
case class Builder22[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10 ~ A11 ~ A12 ~ A13 ~ A14 ~ A15 ~ A16 ~ A17 ~ A18 ~ A19 ~ A20 ~ A21], m2: M[A22])
}
