in algebird-core/src/main/scala/com/twitter/algebird/GeneratedProductAlgebra.scala [5451:6102]
def apply[X, A, B](
applyX: (A, B) => X,
unapplyX: X => Option[(A, B)]
)(implicit amonoid: Monoid[A], bmonoid: Monoid[B]): Monoid[X] =
new Product2Monoid[X, A, B](applyX, unapplyX)(amonoid, bmonoid)
def apply[X, A, B, C](
applyX: (A, B, C) => X,
unapplyX: X => Option[(A, B, C)]
)(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C]): Monoid[X] =
new Product3Monoid[X, A, B, C](applyX, unapplyX)(amonoid, bmonoid, cmonoid)
def apply[X, A, B, C, D](
applyX: (A, B, C, D) => X,
unapplyX: X => Option[(A, B, C, D)]
)(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D]): Monoid[X] =
new Product4Monoid[X, A, B, C, D](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid)
def apply[X, A, B, C, D, E](applyX: (A, B, C, D, E) => X, unapplyX: X => Option[(A, B, C, D, E)])(implicit
amonoid: Monoid[A],
bmonoid: Monoid[B],
cmonoid: Monoid[C],
dmonoid: Monoid[D],
emonoid: Monoid[E]
): Monoid[X] =
new Product5Monoid[X, A, B, C, D, E](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid, emonoid)
def apply[X, A, B, C, D, E, F](applyX: (A, B, C, D, E, F) => X, unapplyX: X => Option[(A, B, C, D, E, F)])(
implicit
amonoid: Monoid[A],
bmonoid: Monoid[B],
cmonoid: Monoid[C],
dmonoid: Monoid[D],
emonoid: Monoid[E],
fmonoid: Monoid[F]
): Monoid[X] =
new Product6Monoid[X, A, B, C, D, E, F](applyX, unapplyX)(
amonoid,
bmonoid,
cmonoid,
dmonoid,
emonoid,
fmonoid
)
def apply[X, A, B, C, D, E, F, G](
applyX: (A, B, C, D, E, F, G) => X,
unapplyX: X => Option[(A, B, C, D, E, F, G)]
)(implicit
amonoid: Monoid[A],
bmonoid: Monoid[B],
cmonoid: Monoid[C],
dmonoid: Monoid[D],
emonoid: Monoid[E],
fmonoid: Monoid[F],
gmonoid: Monoid[G]
): Monoid[X] =
new Product7Monoid[X, A, B, C, D, E, F, G](applyX, unapplyX)(
amonoid,
bmonoid,
cmonoid,
dmonoid,
emonoid,
fmonoid,
gmonoid
)
def apply[X, A, B, C, D, E, F, G, H](
applyX: (A, B, C, D, E, F, G, H) => X,
unapplyX: X => Option[(A, B, C, D, E, F, G, H)]
)(implicit
amonoid: Monoid[A],
bmonoid: Monoid[B],
cmonoid: Monoid[C],
dmonoid: Monoid[D],
emonoid: Monoid[E],
fmonoid: Monoid[F],
gmonoid: Monoid[G],
hmonoid: Monoid[H]
): Monoid[X] =
new Product8Monoid[X, A, B, C, D, E, F, G, H](applyX, unapplyX)(
amonoid,
bmonoid,
cmonoid,
dmonoid,
emonoid,
fmonoid,
gmonoid,
hmonoid
)
def apply[X, A, B, C, D, E, F, G, H, I](
applyX: (A, B, C, D, E, F, G, H, I) => X,
unapplyX: X => Option[(A, B, C, D, E, F, G, H, I)]
)(implicit
amonoid: Monoid[A],
bmonoid: Monoid[B],
cmonoid: Monoid[C],
dmonoid: Monoid[D],
emonoid: Monoid[E],
fmonoid: Monoid[F],
gmonoid: Monoid[G],
hmonoid: Monoid[H],
imonoid: Monoid[I]
): Monoid[X] =
new Product9Monoid[X, A, B, C, D, E, F, G, H, I](applyX, unapplyX)(
amonoid,
bmonoid,
cmonoid,
dmonoid,
emonoid,
fmonoid,
gmonoid,
hmonoid,
imonoid
)
def apply[X, A, B, C, D, E, F, G, H, I, J](
applyX: (A, B, C, D, E, F, G, H, I, J) => X,
unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J)]
)(implicit
amonoid: Monoid[A],
bmonoid: Monoid[B],
cmonoid: Monoid[C],
dmonoid: Monoid[D],
emonoid: Monoid[E],
fmonoid: Monoid[F],
gmonoid: Monoid[G],
hmonoid: Monoid[H],
imonoid: Monoid[I],
jmonoid: Monoid[J]
): Monoid[X] =
new Product10Monoid[X, A, B, C, D, E, F, G, H, I, J](applyX, unapplyX)(
amonoid,
bmonoid,
cmonoid,
dmonoid,
emonoid,
fmonoid,
gmonoid,
hmonoid,
imonoid,
jmonoid
)
def apply[X, A, B, C, D, E, F, G, H, I, J, K](
applyX: (A, B, C, D, E, F, G, H, I, J, K) => X,
unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K)]
)(implicit
amonoid: Monoid[A],
bmonoid: Monoid[B],
cmonoid: Monoid[C],
dmonoid: Monoid[D],
emonoid: Monoid[E],
fmonoid: Monoid[F],
gmonoid: Monoid[G],
hmonoid: Monoid[H],
imonoid: Monoid[I],
jmonoid: Monoid[J],
kmonoid: Monoid[K]
): Monoid[X] =
new Product11Monoid[X, A, B, C, D, E, F, G, H, I, J, K](applyX, unapplyX)(
amonoid,
bmonoid,
cmonoid,
dmonoid,
emonoid,
fmonoid,
gmonoid,
hmonoid,
imonoid,
jmonoid,
kmonoid
)
def apply[X, A, B, C, D, E, F, G, H, I, J, K, L](
applyX: (A, B, C, D, E, F, G, H, I, J, K, L) => X,
unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L)]
)(implicit
amonoid: Monoid[A],
bmonoid: Monoid[B],
cmonoid: Monoid[C],
dmonoid: Monoid[D],
emonoid: Monoid[E],
fmonoid: Monoid[F],
gmonoid: Monoid[G],
hmonoid: Monoid[H],
imonoid: Monoid[I],
jmonoid: Monoid[J],
kmonoid: Monoid[K],
lmonoid: Monoid[L]
): Monoid[X] =
new Product12Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L](applyX, unapplyX)(
amonoid,
bmonoid,
cmonoid,
dmonoid,
emonoid,
fmonoid,
gmonoid,
hmonoid,
imonoid,
jmonoid,
kmonoid,
lmonoid
)
def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M](
applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M) => X,
unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M)]
)(implicit
amonoid: Monoid[A],
bmonoid: Monoid[B],
cmonoid: Monoid[C],
dmonoid: Monoid[D],
emonoid: Monoid[E],
fmonoid: Monoid[F],
gmonoid: Monoid[G],
hmonoid: Monoid[H],
imonoid: Monoid[I],
jmonoid: Monoid[J],
kmonoid: Monoid[K],
lmonoid: Monoid[L],
mmonoid: Monoid[M]
): Monoid[X] =
new Product13Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M](applyX, unapplyX)(
amonoid,
bmonoid,
cmonoid,
dmonoid,
emonoid,
fmonoid,
gmonoid,
hmonoid,
imonoid,
jmonoid,
kmonoid,
lmonoid,
mmonoid
)
def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](
applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => X,
unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]
)(implicit
amonoid: Monoid[A],
bmonoid: Monoid[B],
cmonoid: Monoid[C],
dmonoid: Monoid[D],
emonoid: Monoid[E],
fmonoid: Monoid[F],
gmonoid: Monoid[G],
hmonoid: Monoid[H],
imonoid: Monoid[I],
jmonoid: Monoid[J],
kmonoid: Monoid[K],
lmonoid: Monoid[L],
mmonoid: Monoid[M],
nmonoid: Monoid[N]
): Monoid[X] =
new Product14Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](applyX, unapplyX)(
amonoid,
bmonoid,
cmonoid,
dmonoid,
emonoid,
fmonoid,
gmonoid,
hmonoid,
imonoid,
jmonoid,
kmonoid,
lmonoid,
mmonoid,
nmonoid
)
def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](
applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => X,
unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]
)(implicit
amonoid: Monoid[A],
bmonoid: Monoid[B],
cmonoid: Monoid[C],
dmonoid: Monoid[D],
emonoid: Monoid[E],
fmonoid: Monoid[F],
gmonoid: Monoid[G],
hmonoid: Monoid[H],
imonoid: Monoid[I],
jmonoid: Monoid[J],
kmonoid: Monoid[K],
lmonoid: Monoid[L],
mmonoid: Monoid[M],
nmonoid: Monoid[N],
omonoid: Monoid[O]
): Monoid[X] =
new Product15Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](applyX, unapplyX)(
amonoid,
bmonoid,
cmonoid,
dmonoid,
emonoid,
fmonoid,
gmonoid,
hmonoid,
imonoid,
jmonoid,
kmonoid,
lmonoid,
mmonoid,
nmonoid,
omonoid
)
def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](
applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => X,
unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
)(implicit
amonoid: Monoid[A],
bmonoid: Monoid[B],
cmonoid: Monoid[C],
dmonoid: Monoid[D],
emonoid: Monoid[E],
fmonoid: Monoid[F],
gmonoid: Monoid[G],
hmonoid: Monoid[H],
imonoid: Monoid[I],
jmonoid: Monoid[J],
kmonoid: Monoid[K],
lmonoid: Monoid[L],
mmonoid: Monoid[M],
nmonoid: Monoid[N],
omonoid: Monoid[O],
pmonoid: Monoid[P]
): Monoid[X] =
new Product16Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](applyX, unapplyX)(
amonoid,
bmonoid,
cmonoid,
dmonoid,
emonoid,
fmonoid,
gmonoid,
hmonoid,
imonoid,
jmonoid,
kmonoid,
lmonoid,
mmonoid,
nmonoid,
omonoid,
pmonoid
)
def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](
applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => X,
unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]
)(implicit
amonoid: Monoid[A],
bmonoid: Monoid[B],
cmonoid: Monoid[C],
dmonoid: Monoid[D],
emonoid: Monoid[E],
fmonoid: Monoid[F],
gmonoid: Monoid[G],
hmonoid: Monoid[H],
imonoid: Monoid[I],
jmonoid: Monoid[J],
kmonoid: Monoid[K],
lmonoid: Monoid[L],
mmonoid: Monoid[M],
nmonoid: Monoid[N],
omonoid: Monoid[O],
pmonoid: Monoid[P],
qmonoid: Monoid[Q]
): Monoid[X] =
new Product17Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](applyX, unapplyX)(
amonoid,
bmonoid,
cmonoid,
dmonoid,
emonoid,
fmonoid,
gmonoid,
hmonoid,
imonoid,
jmonoid,
kmonoid,
lmonoid,
mmonoid,
nmonoid,
omonoid,
pmonoid,
qmonoid
)
def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](
applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => X,
unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]
)(implicit
amonoid: Monoid[A],
bmonoid: Monoid[B],
cmonoid: Monoid[C],
dmonoid: Monoid[D],
emonoid: Monoid[E],
fmonoid: Monoid[F],
gmonoid: Monoid[G],
hmonoid: Monoid[H],
imonoid: Monoid[I],
jmonoid: Monoid[J],
kmonoid: Monoid[K],
lmonoid: Monoid[L],
mmonoid: Monoid[M],
nmonoid: Monoid[N],
omonoid: Monoid[O],
pmonoid: Monoid[P],
qmonoid: Monoid[Q],
rmonoid: Monoid[R]
): Monoid[X] =
new Product18Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](applyX, unapplyX)(
amonoid,
bmonoid,
cmonoid,
dmonoid,
emonoid,
fmonoid,
gmonoid,
hmonoid,
imonoid,
jmonoid,
kmonoid,
lmonoid,
mmonoid,
nmonoid,
omonoid,
pmonoid,
qmonoid,
rmonoid
)
def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](
applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => X,
unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]
)(implicit
amonoid: Monoid[A],
bmonoid: Monoid[B],
cmonoid: Monoid[C],
dmonoid: Monoid[D],
emonoid: Monoid[E],
fmonoid: Monoid[F],
gmonoid: Monoid[G],
hmonoid: Monoid[H],
imonoid: Monoid[I],
jmonoid: Monoid[J],
kmonoid: Monoid[K],
lmonoid: Monoid[L],
mmonoid: Monoid[M],
nmonoid: Monoid[N],
omonoid: Monoid[O],
pmonoid: Monoid[P],
qmonoid: Monoid[Q],
rmonoid: Monoid[R],
smonoid: Monoid[S]
): Monoid[X] =
new Product19Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](
applyX,
unapplyX
)(
amonoid,
bmonoid,
cmonoid,
dmonoid,
emonoid,
fmonoid,
gmonoid,
hmonoid,
imonoid,
jmonoid,
kmonoid,
lmonoid,
mmonoid,
nmonoid,
omonoid,
pmonoid,
qmonoid,
rmonoid,
smonoid
)
def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](
applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => X,
unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]
)(implicit
amonoid: Monoid[A],
bmonoid: Monoid[B],
cmonoid: Monoid[C],
dmonoid: Monoid[D],
emonoid: Monoid[E],
fmonoid: Monoid[F],
gmonoid: Monoid[G],
hmonoid: Monoid[H],
imonoid: Monoid[I],
jmonoid: Monoid[J],
kmonoid: Monoid[K],
lmonoid: Monoid[L],
mmonoid: Monoid[M],
nmonoid: Monoid[N],
omonoid: Monoid[O],
pmonoid: Monoid[P],
qmonoid: Monoid[Q],
rmonoid: Monoid[R],
smonoid: Monoid[S],
tmonoid: Monoid[T]
): Monoid[X] =
new Product20Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](
applyX,
unapplyX
)(
amonoid,
bmonoid,
cmonoid,
dmonoid,
emonoid,
fmonoid,
gmonoid,
hmonoid,
imonoid,
jmonoid,
kmonoid,
lmonoid,
mmonoid,
nmonoid,
omonoid,
pmonoid,
qmonoid,
rmonoid,
smonoid,
tmonoid
)
def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](
applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => X,
unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]
)(implicit
amonoid: Monoid[A],
bmonoid: Monoid[B],
cmonoid: Monoid[C],
dmonoid: Monoid[D],
emonoid: Monoid[E],
fmonoid: Monoid[F],
gmonoid: Monoid[G],
hmonoid: Monoid[H],
imonoid: Monoid[I],
jmonoid: Monoid[J],
kmonoid: Monoid[K],
lmonoid: Monoid[L],
mmonoid: Monoid[M],
nmonoid: Monoid[N],
omonoid: Monoid[O],
pmonoid: Monoid[P],
qmonoid: Monoid[Q],
rmonoid: Monoid[R],
smonoid: Monoid[S],
tmonoid: Monoid[T],
umonoid: Monoid[U]
): Monoid[X] =
new Product21Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](
applyX,
unapplyX
)(
amonoid,
bmonoid,
cmonoid,
dmonoid,
emonoid,
fmonoid,
gmonoid,
hmonoid,
imonoid,
jmonoid,
kmonoid,
lmonoid,
mmonoid,
nmonoid,
omonoid,
pmonoid,
qmonoid,
rmonoid,
smonoid,
tmonoid,
umonoid
)
def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](
applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => X,
unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]
)(implicit
amonoid: Monoid[A],
bmonoid: Monoid[B],
cmonoid: Monoid[C],
dmonoid: Monoid[D],
emonoid: Monoid[E],
fmonoid: Monoid[F],
gmonoid: Monoid[G],
hmonoid: Monoid[H],
imonoid: Monoid[I],
jmonoid: Monoid[J],
kmonoid: Monoid[K],
lmonoid: Monoid[L],
mmonoid: Monoid[M],
nmonoid: Monoid[N],
omonoid: Monoid[O],
pmonoid: Monoid[P],
qmonoid: Monoid[Q],
rmonoid: Monoid[R],
smonoid: Monoid[S],
tmonoid: Monoid[T],
umonoid: Monoid[U],
vmonoid: Monoid[V]
): Monoid[X] =
new Product22Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](
applyX,
unapplyX
)(
amonoid,
bmonoid,
cmonoid,
dmonoid,
emonoid,
fmonoid,
gmonoid,
hmonoid,
imonoid,
jmonoid,
kmonoid,
lmonoid,
mmonoid,
nmonoid,
omonoid,
pmonoid,
qmonoid,
rmonoid,
smonoid,
tmonoid,
umonoid,
vmonoid
)
}
trait ProductGroups {