in algebird-core/src/main/scala/com/twitter/algebird/GeneratedProductAlgebra.scala [6103:6738]
def apply[X, A, B](
applyX: (A, B) => X,
unapplyX: X => Option[(A, B)]
)(implicit agroup: Group[A], bgroup: Group[B]): Group[X] =
new Product2Group[X, A, B](applyX, unapplyX)(agroup, bgroup)
def apply[X, A, B, C](
applyX: (A, B, C) => X,
unapplyX: X => Option[(A, B, C)]
)(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C]): Group[X] =
new Product3Group[X, A, B, C](applyX, unapplyX)(agroup, bgroup, cgroup)
def apply[X, A, B, C, D](
applyX: (A, B, C, D) => X,
unapplyX: X => Option[(A, B, C, D)]
)(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D]): Group[X] =
new Product4Group[X, A, B, C, D](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup)
def apply[X, A, B, C, D, E](applyX: (A, B, C, D, E) => X, unapplyX: X => Option[(A, B, C, D, E)])(implicit
agroup: Group[A],
bgroup: Group[B],
cgroup: Group[C],
dgroup: Group[D],
egroup: Group[E]
): Group[X] =
new Product5Group[X, A, B, C, D, E](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup)
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
agroup: Group[A],
bgroup: Group[B],
cgroup: Group[C],
dgroup: Group[D],
egroup: Group[E],
fgroup: Group[F]
): Group[X] =
new Product6Group[X, A, B, C, D, E, F](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup, fgroup)
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
agroup: Group[A],
bgroup: Group[B],
cgroup: Group[C],
dgroup: Group[D],
egroup: Group[E],
fgroup: Group[F],
ggroup: Group[G]
): Group[X] =
new Product7Group[X, A, B, C, D, E, F, G](applyX, unapplyX)(
agroup,
bgroup,
cgroup,
dgroup,
egroup,
fgroup,
ggroup
)
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
agroup: Group[A],
bgroup: Group[B],
cgroup: Group[C],
dgroup: Group[D],
egroup: Group[E],
fgroup: Group[F],
ggroup: Group[G],
hgroup: Group[H]
): Group[X] =
new Product8Group[X, A, B, C, D, E, F, G, H](applyX, unapplyX)(
agroup,
bgroup,
cgroup,
dgroup,
egroup,
fgroup,
ggroup,
hgroup
)
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
agroup: Group[A],
bgroup: Group[B],
cgroup: Group[C],
dgroup: Group[D],
egroup: Group[E],
fgroup: Group[F],
ggroup: Group[G],
hgroup: Group[H],
igroup: Group[I]
): Group[X] =
new Product9Group[X, A, B, C, D, E, F, G, H, I](applyX, unapplyX)(
agroup,
bgroup,
cgroup,
dgroup,
egroup,
fgroup,
ggroup,
hgroup,
igroup
)
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
agroup: Group[A],
bgroup: Group[B],
cgroup: Group[C],
dgroup: Group[D],
egroup: Group[E],
fgroup: Group[F],
ggroup: Group[G],
hgroup: Group[H],
igroup: Group[I],
jgroup: Group[J]
): Group[X] =
new Product10Group[X, A, B, C, D, E, F, G, H, I, J](applyX, unapplyX)(
agroup,
bgroup,
cgroup,
dgroup,
egroup,
fgroup,
ggroup,
hgroup,
igroup,
jgroup
)
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
agroup: Group[A],
bgroup: Group[B],
cgroup: Group[C],
dgroup: Group[D],
egroup: Group[E],
fgroup: Group[F],
ggroup: Group[G],
hgroup: Group[H],
igroup: Group[I],
jgroup: Group[J],
kgroup: Group[K]
): Group[X] =
new Product11Group[X, A, B, C, D, E, F, G, H, I, J, K](applyX, unapplyX)(
agroup,
bgroup,
cgroup,
dgroup,
egroup,
fgroup,
ggroup,
hgroup,
igroup,
jgroup,
kgroup
)
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
agroup: Group[A],
bgroup: Group[B],
cgroup: Group[C],
dgroup: Group[D],
egroup: Group[E],
fgroup: Group[F],
ggroup: Group[G],
hgroup: Group[H],
igroup: Group[I],
jgroup: Group[J],
kgroup: Group[K],
lgroup: Group[L]
): Group[X] =
new Product12Group[X, A, B, C, D, E, F, G, H, I, J, K, L](applyX, unapplyX)(
agroup,
bgroup,
cgroup,
dgroup,
egroup,
fgroup,
ggroup,
hgroup,
igroup,
jgroup,
kgroup,
lgroup
)
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
agroup: Group[A],
bgroup: Group[B],
cgroup: Group[C],
dgroup: Group[D],
egroup: Group[E],
fgroup: Group[F],
ggroup: Group[G],
hgroup: Group[H],
igroup: Group[I],
jgroup: Group[J],
kgroup: Group[K],
lgroup: Group[L],
mgroup: Group[M]
): Group[X] =
new Product13Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M](applyX, unapplyX)(
agroup,
bgroup,
cgroup,
dgroup,
egroup,
fgroup,
ggroup,
hgroup,
igroup,
jgroup,
kgroup,
lgroup,
mgroup
)
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
agroup: Group[A],
bgroup: Group[B],
cgroup: Group[C],
dgroup: Group[D],
egroup: Group[E],
fgroup: Group[F],
ggroup: Group[G],
hgroup: Group[H],
igroup: Group[I],
jgroup: Group[J],
kgroup: Group[K],
lgroup: Group[L],
mgroup: Group[M],
ngroup: Group[N]
): Group[X] =
new Product14Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](applyX, unapplyX)(
agroup,
bgroup,
cgroup,
dgroup,
egroup,
fgroup,
ggroup,
hgroup,
igroup,
jgroup,
kgroup,
lgroup,
mgroup,
ngroup
)
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
agroup: Group[A],
bgroup: Group[B],
cgroup: Group[C],
dgroup: Group[D],
egroup: Group[E],
fgroup: Group[F],
ggroup: Group[G],
hgroup: Group[H],
igroup: Group[I],
jgroup: Group[J],
kgroup: Group[K],
lgroup: Group[L],
mgroup: Group[M],
ngroup: Group[N],
ogroup: Group[O]
): Group[X] =
new Product15Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](applyX, unapplyX)(
agroup,
bgroup,
cgroup,
dgroup,
egroup,
fgroup,
ggroup,
hgroup,
igroup,
jgroup,
kgroup,
lgroup,
mgroup,
ngroup,
ogroup
)
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
agroup: Group[A],
bgroup: Group[B],
cgroup: Group[C],
dgroup: Group[D],
egroup: Group[E],
fgroup: Group[F],
ggroup: Group[G],
hgroup: Group[H],
igroup: Group[I],
jgroup: Group[J],
kgroup: Group[K],
lgroup: Group[L],
mgroup: Group[M],
ngroup: Group[N],
ogroup: Group[O],
pgroup: Group[P]
): Group[X] =
new Product16Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](applyX, unapplyX)(
agroup,
bgroup,
cgroup,
dgroup,
egroup,
fgroup,
ggroup,
hgroup,
igroup,
jgroup,
kgroup,
lgroup,
mgroup,
ngroup,
ogroup,
pgroup
)
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
agroup: Group[A],
bgroup: Group[B],
cgroup: Group[C],
dgroup: Group[D],
egroup: Group[E],
fgroup: Group[F],
ggroup: Group[G],
hgroup: Group[H],
igroup: Group[I],
jgroup: Group[J],
kgroup: Group[K],
lgroup: Group[L],
mgroup: Group[M],
ngroup: Group[N],
ogroup: Group[O],
pgroup: Group[P],
qgroup: Group[Q]
): Group[X] =
new Product17Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](applyX, unapplyX)(
agroup,
bgroup,
cgroup,
dgroup,
egroup,
fgroup,
ggroup,
hgroup,
igroup,
jgroup,
kgroup,
lgroup,
mgroup,
ngroup,
ogroup,
pgroup,
qgroup
)
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
agroup: Group[A],
bgroup: Group[B],
cgroup: Group[C],
dgroup: Group[D],
egroup: Group[E],
fgroup: Group[F],
ggroup: Group[G],
hgroup: Group[H],
igroup: Group[I],
jgroup: Group[J],
kgroup: Group[K],
lgroup: Group[L],
mgroup: Group[M],
ngroup: Group[N],
ogroup: Group[O],
pgroup: Group[P],
qgroup: Group[Q],
rgroup: Group[R]
): Group[X] =
new Product18Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](applyX, unapplyX)(
agroup,
bgroup,
cgroup,
dgroup,
egroup,
fgroup,
ggroup,
hgroup,
igroup,
jgroup,
kgroup,
lgroup,
mgroup,
ngroup,
ogroup,
pgroup,
qgroup,
rgroup
)
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
agroup: Group[A],
bgroup: Group[B],
cgroup: Group[C],
dgroup: Group[D],
egroup: Group[E],
fgroup: Group[F],
ggroup: Group[G],
hgroup: Group[H],
igroup: Group[I],
jgroup: Group[J],
kgroup: Group[K],
lgroup: Group[L],
mgroup: Group[M],
ngroup: Group[N],
ogroup: Group[O],
pgroup: Group[P],
qgroup: Group[Q],
rgroup: Group[R],
sgroup: Group[S]
): Group[X] =
new Product19Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](applyX, unapplyX)(
agroup,
bgroup,
cgroup,
dgroup,
egroup,
fgroup,
ggroup,
hgroup,
igroup,
jgroup,
kgroup,
lgroup,
mgroup,
ngroup,
ogroup,
pgroup,
qgroup,
rgroup,
sgroup
)
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
agroup: Group[A],
bgroup: Group[B],
cgroup: Group[C],
dgroup: Group[D],
egroup: Group[E],
fgroup: Group[F],
ggroup: Group[G],
hgroup: Group[H],
igroup: Group[I],
jgroup: Group[J],
kgroup: Group[K],
lgroup: Group[L],
mgroup: Group[M],
ngroup: Group[N],
ogroup: Group[O],
pgroup: Group[P],
qgroup: Group[Q],
rgroup: Group[R],
sgroup: Group[S],
tgroup: Group[T]
): Group[X] =
new Product20Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](applyX, unapplyX)(
agroup,
bgroup,
cgroup,
dgroup,
egroup,
fgroup,
ggroup,
hgroup,
igroup,
jgroup,
kgroup,
lgroup,
mgroup,
ngroup,
ogroup,
pgroup,
qgroup,
rgroup,
sgroup,
tgroup
)
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
agroup: Group[A],
bgroup: Group[B],
cgroup: Group[C],
dgroup: Group[D],
egroup: Group[E],
fgroup: Group[F],
ggroup: Group[G],
hgroup: Group[H],
igroup: Group[I],
jgroup: Group[J],
kgroup: Group[K],
lgroup: Group[L],
mgroup: Group[M],
ngroup: Group[N],
ogroup: Group[O],
pgroup: Group[P],
qgroup: Group[Q],
rgroup: Group[R],
sgroup: Group[S],
tgroup: Group[T],
ugroup: Group[U]
): Group[X] =
new Product21Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](applyX, unapplyX)(
agroup,
bgroup,
cgroup,
dgroup,
egroup,
fgroup,
ggroup,
hgroup,
igroup,
jgroup,
kgroup,
lgroup,
mgroup,
ngroup,
ogroup,
pgroup,
qgroup,
rgroup,
sgroup,
tgroup,
ugroup
)
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
agroup: Group[A],
bgroup: Group[B],
cgroup: Group[C],
dgroup: Group[D],
egroup: Group[E],
fgroup: Group[F],
ggroup: Group[G],
hgroup: Group[H],
igroup: Group[I],
jgroup: Group[J],
kgroup: Group[K],
lgroup: Group[L],
mgroup: Group[M],
ngroup: Group[N],
ogroup: Group[O],
pgroup: Group[P],
qgroup: Group[Q],
rgroup: Group[R],
sgroup: Group[S],
tgroup: Group[T],
ugroup: Group[U],
vgroup: Group[V]
): Group[X] =
new Product22Group[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
)(
agroup,
bgroup,
cgroup,
dgroup,
egroup,
fgroup,
ggroup,
hgroup,
igroup,
jgroup,
kgroup,
lgroup,
mgroup,
ngroup,
ogroup,
pgroup,
qgroup,
rgroup,
sgroup,
tgroup,
ugroup,
vgroup
)
}
trait ProductRings {