From d356fa3c89dc288d5880e8fc87202675ea91601e Mon Sep 17 00:00:00 2001 From: "Dr. Carsten Leue" Date: Thu, 29 Feb 2024 16:27:23 +0100 Subject: [PATCH] fix: more auto generated templates fo DI Signed-off-by: Dr. Carsten Leue --- context/readerioeither/gen.go | 2 +- context/readerioeither/generic/gen.go | 2 +- di/doc.go | 2 +- di/gen.go | 897 +++++++++++++- either/doc.go | 2 +- either/gen.go | 517 +++++++- function/binds.go | 2 +- function/gen.go | 2 +- identity/gen.go | 2 +- internal/apply/doc.go | 2 +- internal/apply/gen.go | 1552 ++++++++++++++++++++++++- io/gen.go | 2 +- io/generic/gen.go | 2 +- ioeither/gen.go | 2 +- ioeither/generic/gen.go | 2 +- iooption/gen.go | 2 +- iooption/generic/gen.go | 2 +- option/gen.go | 2 +- reader/gen.go | 2 +- reader/generic/gen.go | 2 +- readerioeither/gen.go | 2 +- readerioeither/generic/gen.go | 2 +- tuple/doc.go | 2 +- tuple/gen.go | 927 ++++++++++++++- 24 files changed, 3899 insertions(+), 34 deletions(-) diff --git a/context/readerioeither/gen.go b/context/readerioeither/gen.go index dedb01c..e718d1a 100644 --- a/context/readerioeither/gen.go +++ b/context/readerioeither/gen.go @@ -2,7 +2,7 @@ package readerioeither // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-10-23 08:30:39.012572 +0200 CEST m=+0.008846101 +// 2024-02-29 16:18:46.1201552 +0100 CET m=+0.020664901 import ( "context" diff --git a/context/readerioeither/generic/gen.go b/context/readerioeither/generic/gen.go index 3cc2f5e..0da74be 100644 --- a/context/readerioeither/generic/gen.go +++ b/context/readerioeither/generic/gen.go @@ -2,7 +2,7 @@ package generic // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-10-23 08:30:39.012572 +0200 CEST m=+0.008846101 +// 2024-02-29 16:18:46.1217523 +0100 CET m=+0.022262001 import ( "context" diff --git a/di/doc.go b/di/doc.go index f39c66f..4abca7d 100644 --- a/di/doc.go +++ b/di/doc.go @@ -40,4 +40,4 @@ // [MakeInjector]: [github.com/IBM/fp-go/di/erasure.MakeInjector] package di -//go:generate go run .. di --count 10 --filename gen.go +//go:generate go run .. di --count 15 --filename gen.go diff --git a/di/gen.go b/di/gen.go index 80b1152..568ff3a 100644 --- a/di/gen.go +++ b/di/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-12-18 21:40:11.0891062 +0100 CET m=+0.007755601 +// 2024-02-29 16:18:47.9991921 +0100 CET m=+0.012914901 package di @@ -41,7 +41,7 @@ func MakeProviderFactory1[T1 any, R any]( ) } -// MakeTokenWithDefault1 creates an [InjectionToken] with a default implementation with 1 dependenciess +// MakeTokenWithDefault1 creates an [InjectionToken] with a default implementation with 1 dependencies func MakeTokenWithDefault1[T1 any, R any]( name string, d1 Dependency[T1], @@ -102,7 +102,7 @@ func MakeProviderFactory2[T1, T2 any, R any]( ) } -// MakeTokenWithDefault2 creates an [InjectionToken] with a default implementation with 2 dependenciess +// MakeTokenWithDefault2 creates an [InjectionToken] with a default implementation with 2 dependencies func MakeTokenWithDefault2[T1, T2 any, R any]( name string, d1 Dependency[T1], @@ -173,7 +173,7 @@ func MakeProviderFactory3[T1, T2, T3 any, R any]( ) } -// MakeTokenWithDefault3 creates an [InjectionToken] with a default implementation with 3 dependenciess +// MakeTokenWithDefault3 creates an [InjectionToken] with a default implementation with 3 dependencies func MakeTokenWithDefault3[T1, T2, T3 any, R any]( name string, d1 Dependency[T1], @@ -254,7 +254,7 @@ func MakeProviderFactory4[T1, T2, T3, T4 any, R any]( ) } -// MakeTokenWithDefault4 creates an [InjectionToken] with a default implementation with 4 dependenciess +// MakeTokenWithDefault4 creates an [InjectionToken] with a default implementation with 4 dependencies func MakeTokenWithDefault4[T1, T2, T3, T4 any, R any]( name string, d1 Dependency[T1], @@ -345,7 +345,7 @@ func MakeProviderFactory5[T1, T2, T3, T4, T5 any, R any]( ) } -// MakeTokenWithDefault5 creates an [InjectionToken] with a default implementation with 5 dependenciess +// MakeTokenWithDefault5 creates an [InjectionToken] with a default implementation with 5 dependencies func MakeTokenWithDefault5[T1, T2, T3, T4, T5 any, R any]( name string, d1 Dependency[T1], @@ -446,7 +446,7 @@ func MakeProviderFactory6[T1, T2, T3, T4, T5, T6 any, R any]( ) } -// MakeTokenWithDefault6 creates an [InjectionToken] with a default implementation with 6 dependenciess +// MakeTokenWithDefault6 creates an [InjectionToken] with a default implementation with 6 dependencies func MakeTokenWithDefault6[T1, T2, T3, T4, T5, T6 any, R any]( name string, d1 Dependency[T1], @@ -557,7 +557,7 @@ func MakeProviderFactory7[T1, T2, T3, T4, T5, T6, T7 any, R any]( ) } -// MakeTokenWithDefault7 creates an [InjectionToken] with a default implementation with 7 dependenciess +// MakeTokenWithDefault7 creates an [InjectionToken] with a default implementation with 7 dependencies func MakeTokenWithDefault7[T1, T2, T3, T4, T5, T6, T7 any, R any]( name string, d1 Dependency[T1], @@ -678,7 +678,7 @@ func MakeProviderFactory8[T1, T2, T3, T4, T5, T6, T7, T8 any, R any]( ) } -// MakeTokenWithDefault8 creates an [InjectionToken] with a default implementation with 8 dependenciess +// MakeTokenWithDefault8 creates an [InjectionToken] with a default implementation with 8 dependencies func MakeTokenWithDefault8[T1, T2, T3, T4, T5, T6, T7, T8 any, R any]( name string, d1 Dependency[T1], @@ -809,7 +809,7 @@ func MakeProviderFactory9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any, R any]( ) } -// MakeTokenWithDefault9 creates an [InjectionToken] with a default implementation with 9 dependenciess +// MakeTokenWithDefault9 creates an [InjectionToken] with a default implementation with 9 dependencies func MakeTokenWithDefault9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any, R any]( name string, d1 Dependency[T1], @@ -950,7 +950,7 @@ func MakeProviderFactory10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any, R any]( ) } -// MakeTokenWithDefault10 creates an [InjectionToken] with a default implementation with 10 dependenciess +// MakeTokenWithDefault10 creates an [InjectionToken] with a default implementation with 10 dependencies func MakeTokenWithDefault10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any, R any]( name string, d1 Dependency[T1], @@ -1011,3 +1011,878 @@ func MakeProvider10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any, R any]( f, )) } + +// eraseProviderFactory11 creates a function that takes a variadic number of untyped arguments and from a function of 11 strongly typed arguments and 11 dependencies +func eraseProviderFactory11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any, R any]( + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] { + ft := eraseTuple(T.Tupled11(f)) + t1 := lookupAt[T1](0, d1) + t2 := lookupAt[T2](1, d2) + t3 := lookupAt[T3](2, d3) + t4 := lookupAt[T4](3, d4) + t5 := lookupAt[T5](4, d5) + t6 := lookupAt[T6](5, d6) + t7 := lookupAt[T7](6, d7) + t8 := lookupAt[T8](7, d8) + t9 := lookupAt[T9](8, d9) + t10 := lookupAt[T10](9, d10) + t11 := lookupAt[T11](10, d11) + return func(params ...any) IOE.IOEither[error, any] { + return ft(E.SequenceT11( + t1(params), + t2(params), + t3(params), + t4(params), + t5(params), + t6(params), + t7(params), + t8(params), + t9(params), + t10(params), + t11(params), + )) + } +} + +// MakeProviderFactory11 creates a [DIE.ProviderFactory] from a function with 11 arguments and 11 dependencies +func MakeProviderFactory11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any, R any]( + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) IOE.IOEither[error, R], +) DIE.ProviderFactory { + return DIE.MakeProviderFactory( + A.From[DIE.Dependency]( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + ), + eraseProviderFactory11( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + f, + ), + ) +} + +// MakeTokenWithDefault11 creates an [InjectionToken] with a default implementation with 11 dependencies +func MakeTokenWithDefault11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any, R any]( + name string, + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) IOE.IOEither[error, R], +) InjectionToken[R] { + return MakeTokenWithDefault[R](name, MakeProviderFactory11( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + f, + )) +} + +// MakeProvider11 creates a [DIE.Provider] for an [InjectionToken] from a function with 11 dependencies +func MakeProvider11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any, R any]( + token InjectionToken[R], + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) IOE.IOEither[error, R], +) DIE.Provider { + return DIE.MakeProvider( + token, + MakeProviderFactory11( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + f, + )) +} + +// eraseProviderFactory12 creates a function that takes a variadic number of untyped arguments and from a function of 12 strongly typed arguments and 12 dependencies +func eraseProviderFactory12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any, R any]( + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + d12 Dependency[T12], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] { + ft := eraseTuple(T.Tupled12(f)) + t1 := lookupAt[T1](0, d1) + t2 := lookupAt[T2](1, d2) + t3 := lookupAt[T3](2, d3) + t4 := lookupAt[T4](3, d4) + t5 := lookupAt[T5](4, d5) + t6 := lookupAt[T6](5, d6) + t7 := lookupAt[T7](6, d7) + t8 := lookupAt[T8](7, d8) + t9 := lookupAt[T9](8, d9) + t10 := lookupAt[T10](9, d10) + t11 := lookupAt[T11](10, d11) + t12 := lookupAt[T12](11, d12) + return func(params ...any) IOE.IOEither[error, any] { + return ft(E.SequenceT12( + t1(params), + t2(params), + t3(params), + t4(params), + t5(params), + t6(params), + t7(params), + t8(params), + t9(params), + t10(params), + t11(params), + t12(params), + )) + } +} + +// MakeProviderFactory12 creates a [DIE.ProviderFactory] from a function with 12 arguments and 12 dependencies +func MakeProviderFactory12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any, R any]( + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + d12 Dependency[T12], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) IOE.IOEither[error, R], +) DIE.ProviderFactory { + return DIE.MakeProviderFactory( + A.From[DIE.Dependency]( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + d12, + ), + eraseProviderFactory12( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + d12, + f, + ), + ) +} + +// MakeTokenWithDefault12 creates an [InjectionToken] with a default implementation with 12 dependencies +func MakeTokenWithDefault12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any, R any]( + name string, + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + d12 Dependency[T12], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) IOE.IOEither[error, R], +) InjectionToken[R] { + return MakeTokenWithDefault[R](name, MakeProviderFactory12( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + d12, + f, + )) +} + +// MakeProvider12 creates a [DIE.Provider] for an [InjectionToken] from a function with 12 dependencies +func MakeProvider12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any, R any]( + token InjectionToken[R], + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + d12 Dependency[T12], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) IOE.IOEither[error, R], +) DIE.Provider { + return DIE.MakeProvider( + token, + MakeProviderFactory12( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + d12, + f, + )) +} + +// eraseProviderFactory13 creates a function that takes a variadic number of untyped arguments and from a function of 13 strongly typed arguments and 13 dependencies +func eraseProviderFactory13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any, R any]( + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + d12 Dependency[T12], + d13 Dependency[T13], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] { + ft := eraseTuple(T.Tupled13(f)) + t1 := lookupAt[T1](0, d1) + t2 := lookupAt[T2](1, d2) + t3 := lookupAt[T3](2, d3) + t4 := lookupAt[T4](3, d4) + t5 := lookupAt[T5](4, d5) + t6 := lookupAt[T6](5, d6) + t7 := lookupAt[T7](6, d7) + t8 := lookupAt[T8](7, d8) + t9 := lookupAt[T9](8, d9) + t10 := lookupAt[T10](9, d10) + t11 := lookupAt[T11](10, d11) + t12 := lookupAt[T12](11, d12) + t13 := lookupAt[T13](12, d13) + return func(params ...any) IOE.IOEither[error, any] { + return ft(E.SequenceT13( + t1(params), + t2(params), + t3(params), + t4(params), + t5(params), + t6(params), + t7(params), + t8(params), + t9(params), + t10(params), + t11(params), + t12(params), + t13(params), + )) + } +} + +// MakeProviderFactory13 creates a [DIE.ProviderFactory] from a function with 13 arguments and 13 dependencies +func MakeProviderFactory13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any, R any]( + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + d12 Dependency[T12], + d13 Dependency[T13], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) IOE.IOEither[error, R], +) DIE.ProviderFactory { + return DIE.MakeProviderFactory( + A.From[DIE.Dependency]( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + d12, + d13, + ), + eraseProviderFactory13( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + d12, + d13, + f, + ), + ) +} + +// MakeTokenWithDefault13 creates an [InjectionToken] with a default implementation with 13 dependencies +func MakeTokenWithDefault13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any, R any]( + name string, + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + d12 Dependency[T12], + d13 Dependency[T13], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) IOE.IOEither[error, R], +) InjectionToken[R] { + return MakeTokenWithDefault[R](name, MakeProviderFactory13( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + d12, + d13, + f, + )) +} + +// MakeProvider13 creates a [DIE.Provider] for an [InjectionToken] from a function with 13 dependencies +func MakeProvider13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any, R any]( + token InjectionToken[R], + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + d12 Dependency[T12], + d13 Dependency[T13], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) IOE.IOEither[error, R], +) DIE.Provider { + return DIE.MakeProvider( + token, + MakeProviderFactory13( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + d12, + d13, + f, + )) +} + +// eraseProviderFactory14 creates a function that takes a variadic number of untyped arguments and from a function of 14 strongly typed arguments and 14 dependencies +func eraseProviderFactory14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any, R any]( + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + d12 Dependency[T12], + d13 Dependency[T13], + d14 Dependency[T14], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] { + ft := eraseTuple(T.Tupled14(f)) + t1 := lookupAt[T1](0, d1) + t2 := lookupAt[T2](1, d2) + t3 := lookupAt[T3](2, d3) + t4 := lookupAt[T4](3, d4) + t5 := lookupAt[T5](4, d5) + t6 := lookupAt[T6](5, d6) + t7 := lookupAt[T7](6, d7) + t8 := lookupAt[T8](7, d8) + t9 := lookupAt[T9](8, d9) + t10 := lookupAt[T10](9, d10) + t11 := lookupAt[T11](10, d11) + t12 := lookupAt[T12](11, d12) + t13 := lookupAt[T13](12, d13) + t14 := lookupAt[T14](13, d14) + return func(params ...any) IOE.IOEither[error, any] { + return ft(E.SequenceT14( + t1(params), + t2(params), + t3(params), + t4(params), + t5(params), + t6(params), + t7(params), + t8(params), + t9(params), + t10(params), + t11(params), + t12(params), + t13(params), + t14(params), + )) + } +} + +// MakeProviderFactory14 creates a [DIE.ProviderFactory] from a function with 14 arguments and 14 dependencies +func MakeProviderFactory14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any, R any]( + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + d12 Dependency[T12], + d13 Dependency[T13], + d14 Dependency[T14], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) IOE.IOEither[error, R], +) DIE.ProviderFactory { + return DIE.MakeProviderFactory( + A.From[DIE.Dependency]( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + d12, + d13, + d14, + ), + eraseProviderFactory14( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + d12, + d13, + d14, + f, + ), + ) +} + +// MakeTokenWithDefault14 creates an [InjectionToken] with a default implementation with 14 dependencies +func MakeTokenWithDefault14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any, R any]( + name string, + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + d12 Dependency[T12], + d13 Dependency[T13], + d14 Dependency[T14], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) IOE.IOEither[error, R], +) InjectionToken[R] { + return MakeTokenWithDefault[R](name, MakeProviderFactory14( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + d12, + d13, + d14, + f, + )) +} + +// MakeProvider14 creates a [DIE.Provider] for an [InjectionToken] from a function with 14 dependencies +func MakeProvider14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any, R any]( + token InjectionToken[R], + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + d12 Dependency[T12], + d13 Dependency[T13], + d14 Dependency[T14], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) IOE.IOEither[error, R], +) DIE.Provider { + return DIE.MakeProvider( + token, + MakeProviderFactory14( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + d12, + d13, + d14, + f, + )) +} + +// eraseProviderFactory15 creates a function that takes a variadic number of untyped arguments and from a function of 15 strongly typed arguments and 15 dependencies +func eraseProviderFactory15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any, R any]( + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + d12 Dependency[T12], + d13 Dependency[T13], + d14 Dependency[T14], + d15 Dependency[T15], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] { + ft := eraseTuple(T.Tupled15(f)) + t1 := lookupAt[T1](0, d1) + t2 := lookupAt[T2](1, d2) + t3 := lookupAt[T3](2, d3) + t4 := lookupAt[T4](3, d4) + t5 := lookupAt[T5](4, d5) + t6 := lookupAt[T6](5, d6) + t7 := lookupAt[T7](6, d7) + t8 := lookupAt[T8](7, d8) + t9 := lookupAt[T9](8, d9) + t10 := lookupAt[T10](9, d10) + t11 := lookupAt[T11](10, d11) + t12 := lookupAt[T12](11, d12) + t13 := lookupAt[T13](12, d13) + t14 := lookupAt[T14](13, d14) + t15 := lookupAt[T15](14, d15) + return func(params ...any) IOE.IOEither[error, any] { + return ft(E.SequenceT15( + t1(params), + t2(params), + t3(params), + t4(params), + t5(params), + t6(params), + t7(params), + t8(params), + t9(params), + t10(params), + t11(params), + t12(params), + t13(params), + t14(params), + t15(params), + )) + } +} + +// MakeProviderFactory15 creates a [DIE.ProviderFactory] from a function with 15 arguments and 15 dependencies +func MakeProviderFactory15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any, R any]( + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + d12 Dependency[T12], + d13 Dependency[T13], + d14 Dependency[T14], + d15 Dependency[T15], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) IOE.IOEither[error, R], +) DIE.ProviderFactory { + return DIE.MakeProviderFactory( + A.From[DIE.Dependency]( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + d12, + d13, + d14, + d15, + ), + eraseProviderFactory15( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + d12, + d13, + d14, + d15, + f, + ), + ) +} + +// MakeTokenWithDefault15 creates an [InjectionToken] with a default implementation with 15 dependencies +func MakeTokenWithDefault15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any, R any]( + name string, + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + d12 Dependency[T12], + d13 Dependency[T13], + d14 Dependency[T14], + d15 Dependency[T15], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) IOE.IOEither[error, R], +) InjectionToken[R] { + return MakeTokenWithDefault[R](name, MakeProviderFactory15( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + d12, + d13, + d14, + d15, + f, + )) +} + +// MakeProvider15 creates a [DIE.Provider] for an [InjectionToken] from a function with 15 dependencies +func MakeProvider15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any, R any]( + token InjectionToken[R], + d1 Dependency[T1], + d2 Dependency[T2], + d3 Dependency[T3], + d4 Dependency[T4], + d5 Dependency[T5], + d6 Dependency[T6], + d7 Dependency[T7], + d8 Dependency[T8], + d9 Dependency[T9], + d10 Dependency[T10], + d11 Dependency[T11], + d12 Dependency[T12], + d13 Dependency[T13], + d14 Dependency[T14], + d15 Dependency[T15], + f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) IOE.IOEither[error, R], +) DIE.Provider { + return DIE.MakeProvider( + token, + MakeProviderFactory15( + d1, + d2, + d3, + d4, + d5, + d6, + d7, + d8, + d9, + d10, + d11, + d12, + d13, + d14, + d15, + f, + )) +} diff --git a/either/doc.go b/either/doc.go index beb35c5..17a4f26 100644 --- a/either/doc.go +++ b/either/doc.go @@ -16,4 +16,4 @@ // Package option defines the [Either] datastructure and its monadic operations package either -//go:generate go run .. either --count 10 --filename gen.go +//go:generate go run .. either --count 15 --filename gen.go diff --git a/either/gen.go b/either/gen.go index ac4122f..5009f64 100644 --- a/either/gen.go +++ b/either/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-10-23 08:30:40.410373 +0200 CEST m=+0.010337601 +// 2024-02-29 16:18:50.8721435 +0100 CET m=+0.070394501 package either @@ -679,3 +679,518 @@ func TraverseTuple10[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ) } } + +// Eitherize11 converts a function with 11 parameters returning a tuple into a function with 11 parameters returning an Either +// The inverse function is [Uneitherize11] +func Eitherize11[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) Either[error, R] { + return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10) Either[error, R] { + return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)) + } +} + +// Uneitherize11 converts a function with 11 parameters returning an Either into a function with 11 parameters returning a tuple +// The inverse function is [Eitherize11] +func Uneitherize11[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) (R, error) { + return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10) (R, error) { + return UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)) + } +} + +// SequenceT11 converts 11 parameters of [Either[E, T]] into a [Either[E, Tuple11]]. +func SequenceT11[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](t1 Either[E, T1], t2 Either[E, T2], t3 Either[E, T3], t4 Either[E, T4], t5 Either[E, T5], t6 Either[E, T6], t7 Either[E, T7], t8 Either[E, T8], t9 Either[E, T9], t10 Either[E, T10], t11 Either[E, T11]) Either[E, T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] { + return A.SequenceT11( + Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]], + Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T2], + Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T3], + Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T4], + Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T5], + Ap[func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T6], + Ap[func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T7], + Ap[func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T8], + Ap[func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T9], + Ap[func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T10], + Ap[T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T11], + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + ) +} + +// SequenceTuple11 converts a [Tuple11] of [Either[E, T]] into an [Either[E, Tuple11]]. +func SequenceTuple11[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](t T.Tuple11[Either[E, T1], Either[E, T2], Either[E, T3], Either[E, T4], Either[E, T5], Either[E, T6], Either[E, T7], Either[E, T8], Either[E, T9], Either[E, T10], Either[E, T11]]) Either[E, T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] { + return A.SequenceTuple11( + Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]], + Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T2], + Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T3], + Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T4], + Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T5], + Ap[func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T6], + Ap[func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T7], + Ap[func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T8], + Ap[func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T9], + Ap[func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T10], + Ap[T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T11], + t, + ) +} + +// TraverseTuple11 converts a [Tuple11] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple11]]. +func TraverseTuple11[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], F9 ~func(A9) Either[E, T9], F10 ~func(A10) Either[E, T10], F11 ~func(A11) Either[E, T11], E, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10, A11, T11 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11) func(T.Tuple11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Either[E, T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] { + return func(t T.Tuple11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Either[E, T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] { + return A.TraverseTuple11( + Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]], + Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T2], + Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T3], + Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T4], + Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T5], + Ap[func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T6], + Ap[func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T7], + Ap[func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T8], + Ap[func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T9], + Ap[func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T10], + Ap[T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T11], + f1, + f2, + f3, + f4, + f5, + f6, + f7, + f8, + f9, + f10, + f11, + t, + ) + } +} + +// Eitherize12 converts a function with 12 parameters returning a tuple into a function with 12 parameters returning an Either +// The inverse function is [Uneitherize12] +func Eitherize12[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) Either[error, R] { + return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11) Either[error, R] { + return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11)) + } +} + +// Uneitherize12 converts a function with 12 parameters returning an Either into a function with 12 parameters returning a tuple +// The inverse function is [Eitherize12] +func Uneitherize12[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) (R, error) { + return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11) (R, error) { + return UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11)) + } +} + +// SequenceT12 converts 12 parameters of [Either[E, T]] into a [Either[E, Tuple12]]. +func SequenceT12[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](t1 Either[E, T1], t2 Either[E, T2], t3 Either[E, T3], t4 Either[E, T4], t5 Either[E, T5], t6 Either[E, T6], t7 Either[E, T7], t8 Either[E, T8], t9 Either[E, T9], t10 Either[E, T10], t11 Either[E, T11], t12 Either[E, T12]) Either[E, T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] { + return A.SequenceT12( + Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]], + Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T2], + Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T3], + Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T4], + Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T5], + Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T6], + Ap[func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T7], + Ap[func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T8], + Ap[func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T9], + Ap[func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T10], + Ap[func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T11], + Ap[T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T12], + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + ) +} + +// SequenceTuple12 converts a [Tuple12] of [Either[E, T]] into an [Either[E, Tuple12]]. +func SequenceTuple12[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](t T.Tuple12[Either[E, T1], Either[E, T2], Either[E, T3], Either[E, T4], Either[E, T5], Either[E, T6], Either[E, T7], Either[E, T8], Either[E, T9], Either[E, T10], Either[E, T11], Either[E, T12]]) Either[E, T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] { + return A.SequenceTuple12( + Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]], + Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T2], + Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T3], + Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T4], + Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T5], + Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T6], + Ap[func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T7], + Ap[func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T8], + Ap[func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T9], + Ap[func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T10], + Ap[func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T11], + Ap[T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T12], + t, + ) +} + +// TraverseTuple12 converts a [Tuple12] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple12]]. +func TraverseTuple12[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], F9 ~func(A9) Either[E, T9], F10 ~func(A10) Either[E, T10], F11 ~func(A11) Either[E, T11], F12 ~func(A12) Either[E, T12], E, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10, A11, T11, A12, T12 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12) func(T.Tuple12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Either[E, T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] { + return func(t T.Tuple12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Either[E, T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] { + return A.TraverseTuple12( + Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]], + Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T2], + Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T3], + Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T4], + Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T5], + Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T6], + Ap[func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T7], + Ap[func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T8], + Ap[func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T9], + Ap[func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T10], + Ap[func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T11], + Ap[T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T12], + f1, + f2, + f3, + f4, + f5, + f6, + f7, + f8, + f9, + f10, + f11, + f12, + t, + ) + } +} + +// Eitherize13 converts a function with 13 parameters returning a tuple into a function with 13 parameters returning an Either +// The inverse function is [Uneitherize13] +func Eitherize13[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) Either[error, R] { + return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12) Either[error, R] { + return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12)) + } +} + +// Uneitherize13 converts a function with 13 parameters returning an Either into a function with 13 parameters returning a tuple +// The inverse function is [Eitherize13] +func Uneitherize13[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) (R, error) { + return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12) (R, error) { + return UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12)) + } +} + +// SequenceT13 converts 13 parameters of [Either[E, T]] into a [Either[E, Tuple13]]. +func SequenceT13[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](t1 Either[E, T1], t2 Either[E, T2], t3 Either[E, T3], t4 Either[E, T4], t5 Either[E, T5], t6 Either[E, T6], t7 Either[E, T7], t8 Either[E, T8], t9 Either[E, T9], t10 Either[E, T10], t11 Either[E, T11], t12 Either[E, T12], t13 Either[E, T13]) Either[E, T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] { + return A.SequenceT13( + Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]], + Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T2], + Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T3], + Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T4], + Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T5], + Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T6], + Ap[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T7], + Ap[func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T8], + Ap[func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T9], + Ap[func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T10], + Ap[func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T11], + Ap[func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T12], + Ap[T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T13], + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + ) +} + +// SequenceTuple13 converts a [Tuple13] of [Either[E, T]] into an [Either[E, Tuple13]]. +func SequenceTuple13[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](t T.Tuple13[Either[E, T1], Either[E, T2], Either[E, T3], Either[E, T4], Either[E, T5], Either[E, T6], Either[E, T7], Either[E, T8], Either[E, T9], Either[E, T10], Either[E, T11], Either[E, T12], Either[E, T13]]) Either[E, T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] { + return A.SequenceTuple13( + Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]], + Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T2], + Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T3], + Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T4], + Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T5], + Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T6], + Ap[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T7], + Ap[func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T8], + Ap[func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T9], + Ap[func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T10], + Ap[func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T11], + Ap[func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T12], + Ap[T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T13], + t, + ) +} + +// TraverseTuple13 converts a [Tuple13] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple13]]. +func TraverseTuple13[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], F9 ~func(A9) Either[E, T9], F10 ~func(A10) Either[E, T10], F11 ~func(A11) Either[E, T11], F12 ~func(A12) Either[E, T12], F13 ~func(A13) Either[E, T13], E, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10, A11, T11, A12, T12, A13, T13 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13) func(T.Tuple13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Either[E, T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] { + return func(t T.Tuple13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Either[E, T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] { + return A.TraverseTuple13( + Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]], + Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T2], + Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T3], + Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T4], + Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T5], + Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T6], + Ap[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T7], + Ap[func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T8], + Ap[func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T9], + Ap[func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T10], + Ap[func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T11], + Ap[func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T12], + Ap[T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T13], + f1, + f2, + f3, + f4, + f5, + f6, + f7, + f8, + f9, + f10, + f11, + f12, + f13, + t, + ) + } +} + +// Eitherize14 converts a function with 14 parameters returning a tuple into a function with 14 parameters returning an Either +// The inverse function is [Uneitherize14] +func Eitherize14[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) Either[error, R] { + return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13) Either[error, R] { + return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13)) + } +} + +// Uneitherize14 converts a function with 14 parameters returning an Either into a function with 14 parameters returning a tuple +// The inverse function is [Eitherize14] +func Uneitherize14[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) (R, error) { + return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13) (R, error) { + return UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13)) + } +} + +// SequenceT14 converts 14 parameters of [Either[E, T]] into a [Either[E, Tuple14]]. +func SequenceT14[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](t1 Either[E, T1], t2 Either[E, T2], t3 Either[E, T3], t4 Either[E, T4], t5 Either[E, T5], t6 Either[E, T6], t7 Either[E, T7], t8 Either[E, T8], t9 Either[E, T9], t10 Either[E, T10], t11 Either[E, T11], t12 Either[E, T12], t13 Either[E, T13], t14 Either[E, T14]) Either[E, T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] { + return A.SequenceT14( + Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]], + Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T2], + Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T3], + Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T4], + Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T5], + Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T6], + Ap[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T7], + Ap[func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T8], + Ap[func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T9], + Ap[func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T10], + Ap[func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T11], + Ap[func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T12], + Ap[func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T13], + Ap[T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T14], + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + ) +} + +// SequenceTuple14 converts a [Tuple14] of [Either[E, T]] into an [Either[E, Tuple14]]. +func SequenceTuple14[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](t T.Tuple14[Either[E, T1], Either[E, T2], Either[E, T3], Either[E, T4], Either[E, T5], Either[E, T6], Either[E, T7], Either[E, T8], Either[E, T9], Either[E, T10], Either[E, T11], Either[E, T12], Either[E, T13], Either[E, T14]]) Either[E, T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] { + return A.SequenceTuple14( + Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]], + Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T2], + Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T3], + Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T4], + Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T5], + Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T6], + Ap[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T7], + Ap[func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T8], + Ap[func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T9], + Ap[func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T10], + Ap[func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T11], + Ap[func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T12], + Ap[func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T13], + Ap[T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T14], + t, + ) +} + +// TraverseTuple14 converts a [Tuple14] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple14]]. +func TraverseTuple14[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], F9 ~func(A9) Either[E, T9], F10 ~func(A10) Either[E, T10], F11 ~func(A11) Either[E, T11], F12 ~func(A12) Either[E, T12], F13 ~func(A13) Either[E, T13], F14 ~func(A14) Either[E, T14], E, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10, A11, T11, A12, T12, A13, T13, A14, T14 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14) func(T.Tuple14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Either[E, T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] { + return func(t T.Tuple14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Either[E, T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] { + return A.TraverseTuple14( + Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]], + Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T2], + Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T3], + Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T4], + Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T5], + Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T6], + Ap[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T7], + Ap[func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T8], + Ap[func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T9], + Ap[func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T10], + Ap[func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T11], + Ap[func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T12], + Ap[func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T13], + Ap[T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T14], + f1, + f2, + f3, + f4, + f5, + f6, + f7, + f8, + f9, + f10, + f11, + f12, + f13, + f14, + t, + ) + } +} + +// Eitherize15 converts a function with 15 parameters returning a tuple into a function with 15 parameters returning an Either +// The inverse function is [Uneitherize15] +func Eitherize15[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) Either[error, R] { + return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14) Either[error, R] { + return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14)) + } +} + +// Uneitherize15 converts a function with 15 parameters returning an Either into a function with 15 parameters returning a tuple +// The inverse function is [Eitherize15] +func Uneitherize15[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) (R, error) { + return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14) (R, error) { + return UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14)) + } +} + +// SequenceT15 converts 15 parameters of [Either[E, T]] into a [Either[E, Tuple15]]. +func SequenceT15[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](t1 Either[E, T1], t2 Either[E, T2], t3 Either[E, T3], t4 Either[E, T4], t5 Either[E, T5], t6 Either[E, T6], t7 Either[E, T7], t8 Either[E, T8], t9 Either[E, T9], t10 Either[E, T10], t11 Either[E, T11], t12 Either[E, T12], t13 Either[E, T13], t14 Either[E, T14], t15 Either[E, T15]) Either[E, T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] { + return A.SequenceT15( + Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]], + Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T2], + Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T3], + Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T4], + Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T5], + Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T6], + Ap[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T7], + Ap[func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T8], + Ap[func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T9], + Ap[func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T10], + Ap[func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T11], + Ap[func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T12], + Ap[func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T13], + Ap[func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T14], + Ap[T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T15], + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + ) +} + +// SequenceTuple15 converts a [Tuple15] of [Either[E, T]] into an [Either[E, Tuple15]]. +func SequenceTuple15[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](t T.Tuple15[Either[E, T1], Either[E, T2], Either[E, T3], Either[E, T4], Either[E, T5], Either[E, T6], Either[E, T7], Either[E, T8], Either[E, T9], Either[E, T10], Either[E, T11], Either[E, T12], Either[E, T13], Either[E, T14], Either[E, T15]]) Either[E, T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] { + return A.SequenceTuple15( + Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]], + Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T2], + Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T3], + Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T4], + Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T5], + Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T6], + Ap[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T7], + Ap[func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T8], + Ap[func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T9], + Ap[func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T10], + Ap[func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T11], + Ap[func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T12], + Ap[func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T13], + Ap[func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T14], + Ap[T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T15], + t, + ) +} + +// TraverseTuple15 converts a [Tuple15] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple15]]. +func TraverseTuple15[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], F9 ~func(A9) Either[E, T9], F10 ~func(A10) Either[E, T10], F11 ~func(A11) Either[E, T11], F12 ~func(A12) Either[E, T12], F13 ~func(A13) Either[E, T13], F14 ~func(A14) Either[E, T14], F15 ~func(A15) Either[E, T15], E, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10, A11, T11, A12, T12, A13, T13, A14, T14, A15, T15 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15) func(T.Tuple15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Either[E, T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] { + return func(t T.Tuple15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Either[E, T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] { + return A.TraverseTuple15( + Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]], + Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T2], + Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T3], + Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T4], + Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T5], + Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T6], + Ap[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T7], + Ap[func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T8], + Ap[func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T9], + Ap[func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T10], + Ap[func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T11], + Ap[func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T12], + Ap[func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T13], + Ap[func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T14], + Ap[T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T15], + f1, + f2, + f3, + f4, + f5, + f6, + f7, + f8, + f9, + f10, + f11, + f12, + f13, + f14, + f15, + t, + ) + } +} diff --git a/function/binds.go b/function/binds.go index 966e70b..6528b09 100644 --- a/function/binds.go +++ b/function/binds.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2024-01-31 21:45:01.6437619 +0100 CET m=+0.032758901 +// 2024-02-29 16:19:01.120389 +0100 CET m=+0.011216001 package function diff --git a/function/gen.go b/function/gen.go index b997eae..de5766a 100644 --- a/function/gen.go +++ b/function/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2024-01-31 21:44:55.7538323 +0100 CET m=+0.013067701 +// 2024-02-29 16:18:53.6664566 +0100 CET m=+0.011085101 package function diff --git a/identity/gen.go b/identity/gen.go index 871040f..05ce1ae 100644 --- a/identity/gen.go +++ b/identity/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-10-23 08:30:50.5492271 +0200 CEST m=+0.023274501 +// 2024-02-29 16:19:02.7798504 +0100 CET m=+0.021933401 package identity diff --git a/internal/apply/doc.go b/internal/apply/doc.go index 12751ad..35921b5 100644 --- a/internal/apply/doc.go +++ b/internal/apply/doc.go @@ -15,4 +15,4 @@ package apply -//go:generate go run ../.. apply --count 10 --filename gen.go +//go:generate go run ../.. apply --count 15 --filename gen.go diff --git a/internal/apply/gen.go b/internal/apply/gen.go index f1d0710..e2c3f67 100644 --- a/internal/apply/gen.go +++ b/internal/apply/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-10-23 08:30:54.1909432 +0200 CEST m=+0.014252201 +// 2024-02-29 16:19:04.4975371 +0100 CET m=+0.017695301 package apply @@ -1533,3 +1533,1553 @@ func TraverseTuple10[ fap9(f10(t.F10)), ) } + +// tupleConstructor11 returns a curried version of [T.MakeTuple11] +func tupleConstructor11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any]() func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] { + return F.Curry11(T.MakeTuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) +} + +// SequenceT11 is a utility function used to implement the sequence operation for higher kinded types based only on map and ap. +// The function takes 11 higher higher kinded types and returns a higher kinded type of a [Tuple11] with the resolved values. +func SequenceT11[ + MAP ~func(func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) func(HKT_T1) HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11, + AP1 ~func(HKT_T2) func(HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11) HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11, + AP2 ~func(HKT_T3) func(HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11) HKT_F_T4_T5_T6_T7_T8_T9_T10_T11, + AP3 ~func(HKT_T4) func(HKT_F_T4_T5_T6_T7_T8_T9_T10_T11) HKT_F_T5_T6_T7_T8_T9_T10_T11, + AP4 ~func(HKT_T5) func(HKT_F_T5_T6_T7_T8_T9_T10_T11) HKT_F_T6_T7_T8_T9_T10_T11, + AP5 ~func(HKT_T6) func(HKT_F_T6_T7_T8_T9_T10_T11) HKT_F_T7_T8_T9_T10_T11, + AP6 ~func(HKT_T7) func(HKT_F_T7_T8_T9_T10_T11) HKT_F_T8_T9_T10_T11, + AP7 ~func(HKT_T8) func(HKT_F_T8_T9_T10_T11) HKT_F_T9_T10_T11, + AP8 ~func(HKT_T9) func(HKT_F_T9_T10_T11) HKT_F_T10_T11, + AP9 ~func(HKT_T10) func(HKT_F_T10_T11) HKT_F_T11, + AP10 ~func(HKT_T11) func(HKT_F_T11) HKT_TUPLE11, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + HKT_T1, // HKT[T1] + HKT_T2, // HKT[T2] + HKT_T3, // HKT[T3] + HKT_T4, // HKT[T4] + HKT_T5, // HKT[T5] + HKT_T6, // HKT[T6] + HKT_T7, // HKT[T7] + HKT_T8, // HKT[T8] + HKT_T9, // HKT[T9] + HKT_T10, // HKT[T10] + HKT_T11, // HKT[T11] + HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11, // HKT[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11, // HKT[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T4_T5_T6_T7_T8_T9_T10_T11, // HKT[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T5_T6_T7_T8_T9_T10_T11, // HKT[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T6_T7_T8_T9_T10_T11, // HKT[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T7_T8_T9_T10_T11, // HKT[func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T8_T9_T10_T11, // HKT[func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T9_T10_T11, // HKT[func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T10_T11, // HKT[func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T11, // HKT[func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_TUPLE11 any, // HKT[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] +]( + fmap MAP, + fap1 AP1, + fap2 AP2, + fap3 AP3, + fap4 AP4, + fap5 AP5, + fap6 AP6, + fap7 AP7, + fap8 AP8, + fap9 AP9, + fap10 AP10, + t1 HKT_T1, + t2 HKT_T2, + t3 HKT_T3, + t4 HKT_T4, + t5 HKT_T5, + t6 HKT_T6, + t7 HKT_T7, + t8 HKT_T8, + t9 HKT_T9, + t10 HKT_T10, + t11 HKT_T11, +) HKT_TUPLE11 { + return F.Pipe11( + t1, + fmap(tupleConstructor11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]()), + fap1(t2), + fap2(t3), + fap3(t4), + fap4(t5), + fap5(t6), + fap6(t7), + fap7(t8), + fap8(t9), + fap9(t10), + fap10(t11), + ) +} + +// SequenceTuple11 is a utility function used to implement the sequence operation for higher kinded types based only on map and ap. +// The function takes a [Tuple11] of higher higher kinded types and returns a higher kinded type of a [Tuple11] with the resolved values. +func SequenceTuple11[ + MAP ~func(func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) func(HKT_T1) HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11, + AP1 ~func(HKT_T2) func(HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11) HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11, + AP2 ~func(HKT_T3) func(HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11) HKT_F_T4_T5_T6_T7_T8_T9_T10_T11, + AP3 ~func(HKT_T4) func(HKT_F_T4_T5_T6_T7_T8_T9_T10_T11) HKT_F_T5_T6_T7_T8_T9_T10_T11, + AP4 ~func(HKT_T5) func(HKT_F_T5_T6_T7_T8_T9_T10_T11) HKT_F_T6_T7_T8_T9_T10_T11, + AP5 ~func(HKT_T6) func(HKT_F_T6_T7_T8_T9_T10_T11) HKT_F_T7_T8_T9_T10_T11, + AP6 ~func(HKT_T7) func(HKT_F_T7_T8_T9_T10_T11) HKT_F_T8_T9_T10_T11, + AP7 ~func(HKT_T8) func(HKT_F_T8_T9_T10_T11) HKT_F_T9_T10_T11, + AP8 ~func(HKT_T9) func(HKT_F_T9_T10_T11) HKT_F_T10_T11, + AP9 ~func(HKT_T10) func(HKT_F_T10_T11) HKT_F_T11, + AP10 ~func(HKT_T11) func(HKT_F_T11) HKT_TUPLE11, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + HKT_T1, // HKT[T1] + HKT_T2, // HKT[T2] + HKT_T3, // HKT[T3] + HKT_T4, // HKT[T4] + HKT_T5, // HKT[T5] + HKT_T6, // HKT[T6] + HKT_T7, // HKT[T7] + HKT_T8, // HKT[T8] + HKT_T9, // HKT[T9] + HKT_T10, // HKT[T10] + HKT_T11, // HKT[T11] + HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11, // HKT[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11, // HKT[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T4_T5_T6_T7_T8_T9_T10_T11, // HKT[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T5_T6_T7_T8_T9_T10_T11, // HKT[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T6_T7_T8_T9_T10_T11, // HKT[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T7_T8_T9_T10_T11, // HKT[func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T8_T9_T10_T11, // HKT[func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T9_T10_T11, // HKT[func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T10_T11, // HKT[func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T11, // HKT[func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_TUPLE11 any, // HKT[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] +]( + fmap MAP, + fap1 AP1, + fap2 AP2, + fap3 AP3, + fap4 AP4, + fap5 AP5, + fap6 AP6, + fap7 AP7, + fap8 AP8, + fap9 AP9, + fap10 AP10, + t T.Tuple11[HKT_T1, HKT_T2, HKT_T3, HKT_T4, HKT_T5, HKT_T6, HKT_T7, HKT_T8, HKT_T9, HKT_T10, HKT_T11], +) HKT_TUPLE11 { + return F.Pipe11( + t.F1, + fmap(tupleConstructor11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]()), + fap1(t.F2), + fap2(t.F3), + fap3(t.F4), + fap4(t.F5), + fap5(t.F6), + fap6(t.F7), + fap7(t.F8), + fap8(t.F9), + fap9(t.F10), + fap10(t.F11), + ) +} + +// TraverseTuple11 is a utility function used to implement the sequence operation for higher kinded types based only on map and ap. +// The function takes a [Tuple11] of base types and 11 functions that transform these based types into higher higher kinded types. It returns a higher kinded type of a [Tuple11] with the resolved values. +func TraverseTuple11[ + MAP ~func(func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) func(HKT_T1) HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11, + AP1 ~func(HKT_T2) func(HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11) HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11, + AP2 ~func(HKT_T3) func(HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11) HKT_F_T4_T5_T6_T7_T8_T9_T10_T11, + AP3 ~func(HKT_T4) func(HKT_F_T4_T5_T6_T7_T8_T9_T10_T11) HKT_F_T5_T6_T7_T8_T9_T10_T11, + AP4 ~func(HKT_T5) func(HKT_F_T5_T6_T7_T8_T9_T10_T11) HKT_F_T6_T7_T8_T9_T10_T11, + AP5 ~func(HKT_T6) func(HKT_F_T6_T7_T8_T9_T10_T11) HKT_F_T7_T8_T9_T10_T11, + AP6 ~func(HKT_T7) func(HKT_F_T7_T8_T9_T10_T11) HKT_F_T8_T9_T10_T11, + AP7 ~func(HKT_T8) func(HKT_F_T8_T9_T10_T11) HKT_F_T9_T10_T11, + AP8 ~func(HKT_T9) func(HKT_F_T9_T10_T11) HKT_F_T10_T11, + AP9 ~func(HKT_T10) func(HKT_F_T10_T11) HKT_F_T11, + AP10 ~func(HKT_T11) func(HKT_F_T11) HKT_TUPLE11, + F1 ~func(A1) HKT_T1, + F2 ~func(A2) HKT_T2, + F3 ~func(A3) HKT_T3, + F4 ~func(A4) HKT_T4, + F5 ~func(A5) HKT_T5, + F6 ~func(A6) HKT_T6, + F7 ~func(A7) HKT_T7, + F8 ~func(A8) HKT_T8, + F9 ~func(A9) HKT_T9, + F10 ~func(A10) HKT_T10, + F11 ~func(A11) HKT_T11, + A1, T1, + A2, T2, + A3, T3, + A4, T4, + A5, T5, + A6, T6, + A7, T7, + A8, T8, + A9, T9, + A10, T10, + A11, T11, + HKT_T1, // HKT[T1] + HKT_T2, // HKT[T2] + HKT_T3, // HKT[T3] + HKT_T4, // HKT[T4] + HKT_T5, // HKT[T5] + HKT_T6, // HKT[T6] + HKT_T7, // HKT[T7] + HKT_T8, // HKT[T8] + HKT_T9, // HKT[T9] + HKT_T10, // HKT[T10] + HKT_T11, // HKT[T11] + HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11, // HKT[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11, // HKT[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T4_T5_T6_T7_T8_T9_T10_T11, // HKT[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T5_T6_T7_T8_T9_T10_T11, // HKT[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T6_T7_T8_T9_T10_T11, // HKT[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T7_T8_T9_T10_T11, // HKT[func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T8_T9_T10_T11, // HKT[func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T9_T10_T11, // HKT[func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T10_T11, // HKT[func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_F_T11, // HKT[func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] + HKT_TUPLE11 any, // HKT[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] +]( + fmap MAP, + fap1 AP1, + fap2 AP2, + fap3 AP3, + fap4 AP4, + fap5 AP5, + fap6 AP6, + fap7 AP7, + fap8 AP8, + fap9 AP9, + fap10 AP10, + f1 F1, + f2 F2, + f3 F3, + f4 F4, + f5 F5, + f6 F6, + f7 F7, + f8 F8, + f9 F9, + f10 F10, + f11 F11, + t T.Tuple11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11], +) HKT_TUPLE11 { + return F.Pipe11( + f1(t.F1), + fmap(tupleConstructor11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]()), + fap1(f2(t.F2)), + fap2(f3(t.F3)), + fap3(f4(t.F4)), + fap4(f5(t.F5)), + fap5(f6(t.F6)), + fap6(f7(t.F7)), + fap7(f8(t.F8)), + fap8(f9(t.F9)), + fap9(f10(t.F10)), + fap10(f11(t.F11)), + ) +} + +// tupleConstructor12 returns a curried version of [T.MakeTuple12] +func tupleConstructor12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any]() func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] { + return F.Curry12(T.MakeTuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) +} + +// SequenceT12 is a utility function used to implement the sequence operation for higher kinded types based only on map and ap. +// The function takes 12 higher higher kinded types and returns a higher kinded type of a [Tuple12] with the resolved values. +func SequenceT12[ + MAP ~func(func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) func(HKT_T1) HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12, + AP1 ~func(HKT_T2) func(HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12) HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12, + AP2 ~func(HKT_T3) func(HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12) HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12, + AP3 ~func(HKT_T4) func(HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12) HKT_F_T5_T6_T7_T8_T9_T10_T11_T12, + AP4 ~func(HKT_T5) func(HKT_F_T5_T6_T7_T8_T9_T10_T11_T12) HKT_F_T6_T7_T8_T9_T10_T11_T12, + AP5 ~func(HKT_T6) func(HKT_F_T6_T7_T8_T9_T10_T11_T12) HKT_F_T7_T8_T9_T10_T11_T12, + AP6 ~func(HKT_T7) func(HKT_F_T7_T8_T9_T10_T11_T12) HKT_F_T8_T9_T10_T11_T12, + AP7 ~func(HKT_T8) func(HKT_F_T8_T9_T10_T11_T12) HKT_F_T9_T10_T11_T12, + AP8 ~func(HKT_T9) func(HKT_F_T9_T10_T11_T12) HKT_F_T10_T11_T12, + AP9 ~func(HKT_T10) func(HKT_F_T10_T11_T12) HKT_F_T11_T12, + AP10 ~func(HKT_T11) func(HKT_F_T11_T12) HKT_F_T12, + AP11 ~func(HKT_T12) func(HKT_F_T12) HKT_TUPLE12, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + HKT_T1, // HKT[T1] + HKT_T2, // HKT[T2] + HKT_T3, // HKT[T3] + HKT_T4, // HKT[T4] + HKT_T5, // HKT[T5] + HKT_T6, // HKT[T6] + HKT_T7, // HKT[T7] + HKT_T8, // HKT[T8] + HKT_T9, // HKT[T9] + HKT_T10, // HKT[T10] + HKT_T11, // HKT[T11] + HKT_T12, // HKT[T12] + HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12, // HKT[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12, // HKT[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12, // HKT[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T5_T6_T7_T8_T9_T10_T11_T12, // HKT[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T6_T7_T8_T9_T10_T11_T12, // HKT[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T7_T8_T9_T10_T11_T12, // HKT[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T8_T9_T10_T11_T12, // HKT[func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T9_T10_T11_T12, // HKT[func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T10_T11_T12, // HKT[func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T11_T12, // HKT[func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T12, // HKT[func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_TUPLE12 any, // HKT[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] +]( + fmap MAP, + fap1 AP1, + fap2 AP2, + fap3 AP3, + fap4 AP4, + fap5 AP5, + fap6 AP6, + fap7 AP7, + fap8 AP8, + fap9 AP9, + fap10 AP10, + fap11 AP11, + t1 HKT_T1, + t2 HKT_T2, + t3 HKT_T3, + t4 HKT_T4, + t5 HKT_T5, + t6 HKT_T6, + t7 HKT_T7, + t8 HKT_T8, + t9 HKT_T9, + t10 HKT_T10, + t11 HKT_T11, + t12 HKT_T12, +) HKT_TUPLE12 { + return F.Pipe12( + t1, + fmap(tupleConstructor12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]()), + fap1(t2), + fap2(t3), + fap3(t4), + fap4(t5), + fap5(t6), + fap6(t7), + fap7(t8), + fap8(t9), + fap9(t10), + fap10(t11), + fap11(t12), + ) +} + +// SequenceTuple12 is a utility function used to implement the sequence operation for higher kinded types based only on map and ap. +// The function takes a [Tuple12] of higher higher kinded types and returns a higher kinded type of a [Tuple12] with the resolved values. +func SequenceTuple12[ + MAP ~func(func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) func(HKT_T1) HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12, + AP1 ~func(HKT_T2) func(HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12) HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12, + AP2 ~func(HKT_T3) func(HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12) HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12, + AP3 ~func(HKT_T4) func(HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12) HKT_F_T5_T6_T7_T8_T9_T10_T11_T12, + AP4 ~func(HKT_T5) func(HKT_F_T5_T6_T7_T8_T9_T10_T11_T12) HKT_F_T6_T7_T8_T9_T10_T11_T12, + AP5 ~func(HKT_T6) func(HKT_F_T6_T7_T8_T9_T10_T11_T12) HKT_F_T7_T8_T9_T10_T11_T12, + AP6 ~func(HKT_T7) func(HKT_F_T7_T8_T9_T10_T11_T12) HKT_F_T8_T9_T10_T11_T12, + AP7 ~func(HKT_T8) func(HKT_F_T8_T9_T10_T11_T12) HKT_F_T9_T10_T11_T12, + AP8 ~func(HKT_T9) func(HKT_F_T9_T10_T11_T12) HKT_F_T10_T11_T12, + AP9 ~func(HKT_T10) func(HKT_F_T10_T11_T12) HKT_F_T11_T12, + AP10 ~func(HKT_T11) func(HKT_F_T11_T12) HKT_F_T12, + AP11 ~func(HKT_T12) func(HKT_F_T12) HKT_TUPLE12, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + HKT_T1, // HKT[T1] + HKT_T2, // HKT[T2] + HKT_T3, // HKT[T3] + HKT_T4, // HKT[T4] + HKT_T5, // HKT[T5] + HKT_T6, // HKT[T6] + HKT_T7, // HKT[T7] + HKT_T8, // HKT[T8] + HKT_T9, // HKT[T9] + HKT_T10, // HKT[T10] + HKT_T11, // HKT[T11] + HKT_T12, // HKT[T12] + HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12, // HKT[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12, // HKT[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12, // HKT[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T5_T6_T7_T8_T9_T10_T11_T12, // HKT[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T6_T7_T8_T9_T10_T11_T12, // HKT[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T7_T8_T9_T10_T11_T12, // HKT[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T8_T9_T10_T11_T12, // HKT[func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T9_T10_T11_T12, // HKT[func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T10_T11_T12, // HKT[func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T11_T12, // HKT[func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T12, // HKT[func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_TUPLE12 any, // HKT[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] +]( + fmap MAP, + fap1 AP1, + fap2 AP2, + fap3 AP3, + fap4 AP4, + fap5 AP5, + fap6 AP6, + fap7 AP7, + fap8 AP8, + fap9 AP9, + fap10 AP10, + fap11 AP11, + t T.Tuple12[HKT_T1, HKT_T2, HKT_T3, HKT_T4, HKT_T5, HKT_T6, HKT_T7, HKT_T8, HKT_T9, HKT_T10, HKT_T11, HKT_T12], +) HKT_TUPLE12 { + return F.Pipe12( + t.F1, + fmap(tupleConstructor12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]()), + fap1(t.F2), + fap2(t.F3), + fap3(t.F4), + fap4(t.F5), + fap5(t.F6), + fap6(t.F7), + fap7(t.F8), + fap8(t.F9), + fap9(t.F10), + fap10(t.F11), + fap11(t.F12), + ) +} + +// TraverseTuple12 is a utility function used to implement the sequence operation for higher kinded types based only on map and ap. +// The function takes a [Tuple12] of base types and 12 functions that transform these based types into higher higher kinded types. It returns a higher kinded type of a [Tuple12] with the resolved values. +func TraverseTuple12[ + MAP ~func(func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) func(HKT_T1) HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12, + AP1 ~func(HKT_T2) func(HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12) HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12, + AP2 ~func(HKT_T3) func(HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12) HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12, + AP3 ~func(HKT_T4) func(HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12) HKT_F_T5_T6_T7_T8_T9_T10_T11_T12, + AP4 ~func(HKT_T5) func(HKT_F_T5_T6_T7_T8_T9_T10_T11_T12) HKT_F_T6_T7_T8_T9_T10_T11_T12, + AP5 ~func(HKT_T6) func(HKT_F_T6_T7_T8_T9_T10_T11_T12) HKT_F_T7_T8_T9_T10_T11_T12, + AP6 ~func(HKT_T7) func(HKT_F_T7_T8_T9_T10_T11_T12) HKT_F_T8_T9_T10_T11_T12, + AP7 ~func(HKT_T8) func(HKT_F_T8_T9_T10_T11_T12) HKT_F_T9_T10_T11_T12, + AP8 ~func(HKT_T9) func(HKT_F_T9_T10_T11_T12) HKT_F_T10_T11_T12, + AP9 ~func(HKT_T10) func(HKT_F_T10_T11_T12) HKT_F_T11_T12, + AP10 ~func(HKT_T11) func(HKT_F_T11_T12) HKT_F_T12, + AP11 ~func(HKT_T12) func(HKT_F_T12) HKT_TUPLE12, + F1 ~func(A1) HKT_T1, + F2 ~func(A2) HKT_T2, + F3 ~func(A3) HKT_T3, + F4 ~func(A4) HKT_T4, + F5 ~func(A5) HKT_T5, + F6 ~func(A6) HKT_T6, + F7 ~func(A7) HKT_T7, + F8 ~func(A8) HKT_T8, + F9 ~func(A9) HKT_T9, + F10 ~func(A10) HKT_T10, + F11 ~func(A11) HKT_T11, + F12 ~func(A12) HKT_T12, + A1, T1, + A2, T2, + A3, T3, + A4, T4, + A5, T5, + A6, T6, + A7, T7, + A8, T8, + A9, T9, + A10, T10, + A11, T11, + A12, T12, + HKT_T1, // HKT[T1] + HKT_T2, // HKT[T2] + HKT_T3, // HKT[T3] + HKT_T4, // HKT[T4] + HKT_T5, // HKT[T5] + HKT_T6, // HKT[T6] + HKT_T7, // HKT[T7] + HKT_T8, // HKT[T8] + HKT_T9, // HKT[T9] + HKT_T10, // HKT[T10] + HKT_T11, // HKT[T11] + HKT_T12, // HKT[T12] + HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12, // HKT[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12, // HKT[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12, // HKT[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T5_T6_T7_T8_T9_T10_T11_T12, // HKT[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T6_T7_T8_T9_T10_T11_T12, // HKT[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T7_T8_T9_T10_T11_T12, // HKT[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T8_T9_T10_T11_T12, // HKT[func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T9_T10_T11_T12, // HKT[func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T10_T11_T12, // HKT[func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T11_T12, // HKT[func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_F_T12, // HKT[func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] + HKT_TUPLE12 any, // HKT[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] +]( + fmap MAP, + fap1 AP1, + fap2 AP2, + fap3 AP3, + fap4 AP4, + fap5 AP5, + fap6 AP6, + fap7 AP7, + fap8 AP8, + fap9 AP9, + fap10 AP10, + fap11 AP11, + f1 F1, + f2 F2, + f3 F3, + f4 F4, + f5 F5, + f6 F6, + f7 F7, + f8 F8, + f9 F9, + f10 F10, + f11 F11, + f12 F12, + t T.Tuple12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12], +) HKT_TUPLE12 { + return F.Pipe12( + f1(t.F1), + fmap(tupleConstructor12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]()), + fap1(f2(t.F2)), + fap2(f3(t.F3)), + fap3(f4(t.F4)), + fap4(f5(t.F5)), + fap5(f6(t.F6)), + fap6(f7(t.F7)), + fap7(f8(t.F8)), + fap8(f9(t.F9)), + fap9(f10(t.F10)), + fap10(f11(t.F11)), + fap11(f12(t.F12)), + ) +} + +// tupleConstructor13 returns a curried version of [T.MakeTuple13] +func tupleConstructor13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any]() func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] { + return F.Curry13(T.MakeTuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) +} + +// SequenceT13 is a utility function used to implement the sequence operation for higher kinded types based only on map and ap. +// The function takes 13 higher higher kinded types and returns a higher kinded type of a [Tuple13] with the resolved values. +func SequenceT13[ + MAP ~func(func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) func(HKT_T1) HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13, + AP1 ~func(HKT_T2) func(HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13) HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13, + AP2 ~func(HKT_T3) func(HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13) HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13, + AP3 ~func(HKT_T4) func(HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13) HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13, + AP4 ~func(HKT_T5) func(HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13) HKT_F_T6_T7_T8_T9_T10_T11_T12_T13, + AP5 ~func(HKT_T6) func(HKT_F_T6_T7_T8_T9_T10_T11_T12_T13) HKT_F_T7_T8_T9_T10_T11_T12_T13, + AP6 ~func(HKT_T7) func(HKT_F_T7_T8_T9_T10_T11_T12_T13) HKT_F_T8_T9_T10_T11_T12_T13, + AP7 ~func(HKT_T8) func(HKT_F_T8_T9_T10_T11_T12_T13) HKT_F_T9_T10_T11_T12_T13, + AP8 ~func(HKT_T9) func(HKT_F_T9_T10_T11_T12_T13) HKT_F_T10_T11_T12_T13, + AP9 ~func(HKT_T10) func(HKT_F_T10_T11_T12_T13) HKT_F_T11_T12_T13, + AP10 ~func(HKT_T11) func(HKT_F_T11_T12_T13) HKT_F_T12_T13, + AP11 ~func(HKT_T12) func(HKT_F_T12_T13) HKT_F_T13, + AP12 ~func(HKT_T13) func(HKT_F_T13) HKT_TUPLE13, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + HKT_T1, // HKT[T1] + HKT_T2, // HKT[T2] + HKT_T3, // HKT[T3] + HKT_T4, // HKT[T4] + HKT_T5, // HKT[T5] + HKT_T6, // HKT[T6] + HKT_T7, // HKT[T7] + HKT_T8, // HKT[T8] + HKT_T9, // HKT[T9] + HKT_T10, // HKT[T10] + HKT_T11, // HKT[T11] + HKT_T12, // HKT[T12] + HKT_T13, // HKT[T13] + HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13, // HKT[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13, // HKT[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13, // HKT[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13, // HKT[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T6_T7_T8_T9_T10_T11_T12_T13, // HKT[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T7_T8_T9_T10_T11_T12_T13, // HKT[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T8_T9_T10_T11_T12_T13, // HKT[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T9_T10_T11_T12_T13, // HKT[func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T10_T11_T12_T13, // HKT[func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T11_T12_T13, // HKT[func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T12_T13, // HKT[func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T13, // HKT[func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_TUPLE13 any, // HKT[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] +]( + fmap MAP, + fap1 AP1, + fap2 AP2, + fap3 AP3, + fap4 AP4, + fap5 AP5, + fap6 AP6, + fap7 AP7, + fap8 AP8, + fap9 AP9, + fap10 AP10, + fap11 AP11, + fap12 AP12, + t1 HKT_T1, + t2 HKT_T2, + t3 HKT_T3, + t4 HKT_T4, + t5 HKT_T5, + t6 HKT_T6, + t7 HKT_T7, + t8 HKT_T8, + t9 HKT_T9, + t10 HKT_T10, + t11 HKT_T11, + t12 HKT_T12, + t13 HKT_T13, +) HKT_TUPLE13 { + return F.Pipe13( + t1, + fmap(tupleConstructor13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]()), + fap1(t2), + fap2(t3), + fap3(t4), + fap4(t5), + fap5(t6), + fap6(t7), + fap7(t8), + fap8(t9), + fap9(t10), + fap10(t11), + fap11(t12), + fap12(t13), + ) +} + +// SequenceTuple13 is a utility function used to implement the sequence operation for higher kinded types based only on map and ap. +// The function takes a [Tuple13] of higher higher kinded types and returns a higher kinded type of a [Tuple13] with the resolved values. +func SequenceTuple13[ + MAP ~func(func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) func(HKT_T1) HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13, + AP1 ~func(HKT_T2) func(HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13) HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13, + AP2 ~func(HKT_T3) func(HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13) HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13, + AP3 ~func(HKT_T4) func(HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13) HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13, + AP4 ~func(HKT_T5) func(HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13) HKT_F_T6_T7_T8_T9_T10_T11_T12_T13, + AP5 ~func(HKT_T6) func(HKT_F_T6_T7_T8_T9_T10_T11_T12_T13) HKT_F_T7_T8_T9_T10_T11_T12_T13, + AP6 ~func(HKT_T7) func(HKT_F_T7_T8_T9_T10_T11_T12_T13) HKT_F_T8_T9_T10_T11_T12_T13, + AP7 ~func(HKT_T8) func(HKT_F_T8_T9_T10_T11_T12_T13) HKT_F_T9_T10_T11_T12_T13, + AP8 ~func(HKT_T9) func(HKT_F_T9_T10_T11_T12_T13) HKT_F_T10_T11_T12_T13, + AP9 ~func(HKT_T10) func(HKT_F_T10_T11_T12_T13) HKT_F_T11_T12_T13, + AP10 ~func(HKT_T11) func(HKT_F_T11_T12_T13) HKT_F_T12_T13, + AP11 ~func(HKT_T12) func(HKT_F_T12_T13) HKT_F_T13, + AP12 ~func(HKT_T13) func(HKT_F_T13) HKT_TUPLE13, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + HKT_T1, // HKT[T1] + HKT_T2, // HKT[T2] + HKT_T3, // HKT[T3] + HKT_T4, // HKT[T4] + HKT_T5, // HKT[T5] + HKT_T6, // HKT[T6] + HKT_T7, // HKT[T7] + HKT_T8, // HKT[T8] + HKT_T9, // HKT[T9] + HKT_T10, // HKT[T10] + HKT_T11, // HKT[T11] + HKT_T12, // HKT[T12] + HKT_T13, // HKT[T13] + HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13, // HKT[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13, // HKT[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13, // HKT[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13, // HKT[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T6_T7_T8_T9_T10_T11_T12_T13, // HKT[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T7_T8_T9_T10_T11_T12_T13, // HKT[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T8_T9_T10_T11_T12_T13, // HKT[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T9_T10_T11_T12_T13, // HKT[func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T10_T11_T12_T13, // HKT[func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T11_T12_T13, // HKT[func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T12_T13, // HKT[func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T13, // HKT[func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_TUPLE13 any, // HKT[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] +]( + fmap MAP, + fap1 AP1, + fap2 AP2, + fap3 AP3, + fap4 AP4, + fap5 AP5, + fap6 AP6, + fap7 AP7, + fap8 AP8, + fap9 AP9, + fap10 AP10, + fap11 AP11, + fap12 AP12, + t T.Tuple13[HKT_T1, HKT_T2, HKT_T3, HKT_T4, HKT_T5, HKT_T6, HKT_T7, HKT_T8, HKT_T9, HKT_T10, HKT_T11, HKT_T12, HKT_T13], +) HKT_TUPLE13 { + return F.Pipe13( + t.F1, + fmap(tupleConstructor13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]()), + fap1(t.F2), + fap2(t.F3), + fap3(t.F4), + fap4(t.F5), + fap5(t.F6), + fap6(t.F7), + fap7(t.F8), + fap8(t.F9), + fap9(t.F10), + fap10(t.F11), + fap11(t.F12), + fap12(t.F13), + ) +} + +// TraverseTuple13 is a utility function used to implement the sequence operation for higher kinded types based only on map and ap. +// The function takes a [Tuple13] of base types and 13 functions that transform these based types into higher higher kinded types. It returns a higher kinded type of a [Tuple13] with the resolved values. +func TraverseTuple13[ + MAP ~func(func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) func(HKT_T1) HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13, + AP1 ~func(HKT_T2) func(HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13) HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13, + AP2 ~func(HKT_T3) func(HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13) HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13, + AP3 ~func(HKT_T4) func(HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13) HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13, + AP4 ~func(HKT_T5) func(HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13) HKT_F_T6_T7_T8_T9_T10_T11_T12_T13, + AP5 ~func(HKT_T6) func(HKT_F_T6_T7_T8_T9_T10_T11_T12_T13) HKT_F_T7_T8_T9_T10_T11_T12_T13, + AP6 ~func(HKT_T7) func(HKT_F_T7_T8_T9_T10_T11_T12_T13) HKT_F_T8_T9_T10_T11_T12_T13, + AP7 ~func(HKT_T8) func(HKT_F_T8_T9_T10_T11_T12_T13) HKT_F_T9_T10_T11_T12_T13, + AP8 ~func(HKT_T9) func(HKT_F_T9_T10_T11_T12_T13) HKT_F_T10_T11_T12_T13, + AP9 ~func(HKT_T10) func(HKT_F_T10_T11_T12_T13) HKT_F_T11_T12_T13, + AP10 ~func(HKT_T11) func(HKT_F_T11_T12_T13) HKT_F_T12_T13, + AP11 ~func(HKT_T12) func(HKT_F_T12_T13) HKT_F_T13, + AP12 ~func(HKT_T13) func(HKT_F_T13) HKT_TUPLE13, + F1 ~func(A1) HKT_T1, + F2 ~func(A2) HKT_T2, + F3 ~func(A3) HKT_T3, + F4 ~func(A4) HKT_T4, + F5 ~func(A5) HKT_T5, + F6 ~func(A6) HKT_T6, + F7 ~func(A7) HKT_T7, + F8 ~func(A8) HKT_T8, + F9 ~func(A9) HKT_T9, + F10 ~func(A10) HKT_T10, + F11 ~func(A11) HKT_T11, + F12 ~func(A12) HKT_T12, + F13 ~func(A13) HKT_T13, + A1, T1, + A2, T2, + A3, T3, + A4, T4, + A5, T5, + A6, T6, + A7, T7, + A8, T8, + A9, T9, + A10, T10, + A11, T11, + A12, T12, + A13, T13, + HKT_T1, // HKT[T1] + HKT_T2, // HKT[T2] + HKT_T3, // HKT[T3] + HKT_T4, // HKT[T4] + HKT_T5, // HKT[T5] + HKT_T6, // HKT[T6] + HKT_T7, // HKT[T7] + HKT_T8, // HKT[T8] + HKT_T9, // HKT[T9] + HKT_T10, // HKT[T10] + HKT_T11, // HKT[T11] + HKT_T12, // HKT[T12] + HKT_T13, // HKT[T13] + HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13, // HKT[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13, // HKT[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13, // HKT[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13, // HKT[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T6_T7_T8_T9_T10_T11_T12_T13, // HKT[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T7_T8_T9_T10_T11_T12_T13, // HKT[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T8_T9_T10_T11_T12_T13, // HKT[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T9_T10_T11_T12_T13, // HKT[func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T10_T11_T12_T13, // HKT[func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T11_T12_T13, // HKT[func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T12_T13, // HKT[func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_F_T13, // HKT[func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] + HKT_TUPLE13 any, // HKT[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] +]( + fmap MAP, + fap1 AP1, + fap2 AP2, + fap3 AP3, + fap4 AP4, + fap5 AP5, + fap6 AP6, + fap7 AP7, + fap8 AP8, + fap9 AP9, + fap10 AP10, + fap11 AP11, + fap12 AP12, + f1 F1, + f2 F2, + f3 F3, + f4 F4, + f5 F5, + f6 F6, + f7 F7, + f8 F8, + f9 F9, + f10 F10, + f11 F11, + f12 F12, + f13 F13, + t T.Tuple13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13], +) HKT_TUPLE13 { + return F.Pipe13( + f1(t.F1), + fmap(tupleConstructor13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]()), + fap1(f2(t.F2)), + fap2(f3(t.F3)), + fap3(f4(t.F4)), + fap4(f5(t.F5)), + fap5(f6(t.F6)), + fap6(f7(t.F7)), + fap7(f8(t.F8)), + fap8(f9(t.F9)), + fap9(f10(t.F10)), + fap10(f11(t.F11)), + fap11(f12(t.F12)), + fap12(f13(t.F13)), + ) +} + +// tupleConstructor14 returns a curried version of [T.MakeTuple14] +func tupleConstructor14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any]() func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] { + return F.Curry14(T.MakeTuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) +} + +// SequenceT14 is a utility function used to implement the sequence operation for higher kinded types based only on map and ap. +// The function takes 14 higher higher kinded types and returns a higher kinded type of a [Tuple14] with the resolved values. +func SequenceT14[ + MAP ~func(func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) func(HKT_T1) HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, + AP1 ~func(HKT_T2) func(HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14) HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, + AP2 ~func(HKT_T3) func(HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14) HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, + AP3 ~func(HKT_T4) func(HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14) HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, + AP4 ~func(HKT_T5) func(HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14) HKT_F_T6_T7_T8_T9_T10_T11_T12_T13_T14, + AP5 ~func(HKT_T6) func(HKT_F_T6_T7_T8_T9_T10_T11_T12_T13_T14) HKT_F_T7_T8_T9_T10_T11_T12_T13_T14, + AP6 ~func(HKT_T7) func(HKT_F_T7_T8_T9_T10_T11_T12_T13_T14) HKT_F_T8_T9_T10_T11_T12_T13_T14, + AP7 ~func(HKT_T8) func(HKT_F_T8_T9_T10_T11_T12_T13_T14) HKT_F_T9_T10_T11_T12_T13_T14, + AP8 ~func(HKT_T9) func(HKT_F_T9_T10_T11_T12_T13_T14) HKT_F_T10_T11_T12_T13_T14, + AP9 ~func(HKT_T10) func(HKT_F_T10_T11_T12_T13_T14) HKT_F_T11_T12_T13_T14, + AP10 ~func(HKT_T11) func(HKT_F_T11_T12_T13_T14) HKT_F_T12_T13_T14, + AP11 ~func(HKT_T12) func(HKT_F_T12_T13_T14) HKT_F_T13_T14, + AP12 ~func(HKT_T13) func(HKT_F_T13_T14) HKT_F_T14, + AP13 ~func(HKT_T14) func(HKT_F_T14) HKT_TUPLE14, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + HKT_T1, // HKT[T1] + HKT_T2, // HKT[T2] + HKT_T3, // HKT[T3] + HKT_T4, // HKT[T4] + HKT_T5, // HKT[T5] + HKT_T6, // HKT[T6] + HKT_T7, // HKT[T7] + HKT_T8, // HKT[T8] + HKT_T9, // HKT[T9] + HKT_T10, // HKT[T10] + HKT_T11, // HKT[T11] + HKT_T12, // HKT[T12] + HKT_T13, // HKT[T13] + HKT_T14, // HKT[T14] + HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T6_T7_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T7_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T9_T10_T11_T12_T13_T14, // HKT[func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T10_T11_T12_T13_T14, // HKT[func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T11_T12_T13_T14, // HKT[func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T12_T13_T14, // HKT[func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T13_T14, // HKT[func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T14, // HKT[func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_TUPLE14 any, // HKT[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] +]( + fmap MAP, + fap1 AP1, + fap2 AP2, + fap3 AP3, + fap4 AP4, + fap5 AP5, + fap6 AP6, + fap7 AP7, + fap8 AP8, + fap9 AP9, + fap10 AP10, + fap11 AP11, + fap12 AP12, + fap13 AP13, + t1 HKT_T1, + t2 HKT_T2, + t3 HKT_T3, + t4 HKT_T4, + t5 HKT_T5, + t6 HKT_T6, + t7 HKT_T7, + t8 HKT_T8, + t9 HKT_T9, + t10 HKT_T10, + t11 HKT_T11, + t12 HKT_T12, + t13 HKT_T13, + t14 HKT_T14, +) HKT_TUPLE14 { + return F.Pipe14( + t1, + fmap(tupleConstructor14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]()), + fap1(t2), + fap2(t3), + fap3(t4), + fap4(t5), + fap5(t6), + fap6(t7), + fap7(t8), + fap8(t9), + fap9(t10), + fap10(t11), + fap11(t12), + fap12(t13), + fap13(t14), + ) +} + +// SequenceTuple14 is a utility function used to implement the sequence operation for higher kinded types based only on map and ap. +// The function takes a [Tuple14] of higher higher kinded types and returns a higher kinded type of a [Tuple14] with the resolved values. +func SequenceTuple14[ + MAP ~func(func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) func(HKT_T1) HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, + AP1 ~func(HKT_T2) func(HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14) HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, + AP2 ~func(HKT_T3) func(HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14) HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, + AP3 ~func(HKT_T4) func(HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14) HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, + AP4 ~func(HKT_T5) func(HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14) HKT_F_T6_T7_T8_T9_T10_T11_T12_T13_T14, + AP5 ~func(HKT_T6) func(HKT_F_T6_T7_T8_T9_T10_T11_T12_T13_T14) HKT_F_T7_T8_T9_T10_T11_T12_T13_T14, + AP6 ~func(HKT_T7) func(HKT_F_T7_T8_T9_T10_T11_T12_T13_T14) HKT_F_T8_T9_T10_T11_T12_T13_T14, + AP7 ~func(HKT_T8) func(HKT_F_T8_T9_T10_T11_T12_T13_T14) HKT_F_T9_T10_T11_T12_T13_T14, + AP8 ~func(HKT_T9) func(HKT_F_T9_T10_T11_T12_T13_T14) HKT_F_T10_T11_T12_T13_T14, + AP9 ~func(HKT_T10) func(HKT_F_T10_T11_T12_T13_T14) HKT_F_T11_T12_T13_T14, + AP10 ~func(HKT_T11) func(HKT_F_T11_T12_T13_T14) HKT_F_T12_T13_T14, + AP11 ~func(HKT_T12) func(HKT_F_T12_T13_T14) HKT_F_T13_T14, + AP12 ~func(HKT_T13) func(HKT_F_T13_T14) HKT_F_T14, + AP13 ~func(HKT_T14) func(HKT_F_T14) HKT_TUPLE14, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + HKT_T1, // HKT[T1] + HKT_T2, // HKT[T2] + HKT_T3, // HKT[T3] + HKT_T4, // HKT[T4] + HKT_T5, // HKT[T5] + HKT_T6, // HKT[T6] + HKT_T7, // HKT[T7] + HKT_T8, // HKT[T8] + HKT_T9, // HKT[T9] + HKT_T10, // HKT[T10] + HKT_T11, // HKT[T11] + HKT_T12, // HKT[T12] + HKT_T13, // HKT[T13] + HKT_T14, // HKT[T14] + HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T6_T7_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T7_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T9_T10_T11_T12_T13_T14, // HKT[func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T10_T11_T12_T13_T14, // HKT[func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T11_T12_T13_T14, // HKT[func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T12_T13_T14, // HKT[func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T13_T14, // HKT[func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T14, // HKT[func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_TUPLE14 any, // HKT[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] +]( + fmap MAP, + fap1 AP1, + fap2 AP2, + fap3 AP3, + fap4 AP4, + fap5 AP5, + fap6 AP6, + fap7 AP7, + fap8 AP8, + fap9 AP9, + fap10 AP10, + fap11 AP11, + fap12 AP12, + fap13 AP13, + t T.Tuple14[HKT_T1, HKT_T2, HKT_T3, HKT_T4, HKT_T5, HKT_T6, HKT_T7, HKT_T8, HKT_T9, HKT_T10, HKT_T11, HKT_T12, HKT_T13, HKT_T14], +) HKT_TUPLE14 { + return F.Pipe14( + t.F1, + fmap(tupleConstructor14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]()), + fap1(t.F2), + fap2(t.F3), + fap3(t.F4), + fap4(t.F5), + fap5(t.F6), + fap6(t.F7), + fap7(t.F8), + fap8(t.F9), + fap9(t.F10), + fap10(t.F11), + fap11(t.F12), + fap12(t.F13), + fap13(t.F14), + ) +} + +// TraverseTuple14 is a utility function used to implement the sequence operation for higher kinded types based only on map and ap. +// The function takes a [Tuple14] of base types and 14 functions that transform these based types into higher higher kinded types. It returns a higher kinded type of a [Tuple14] with the resolved values. +func TraverseTuple14[ + MAP ~func(func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) func(HKT_T1) HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, + AP1 ~func(HKT_T2) func(HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14) HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, + AP2 ~func(HKT_T3) func(HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14) HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, + AP3 ~func(HKT_T4) func(HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14) HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, + AP4 ~func(HKT_T5) func(HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14) HKT_F_T6_T7_T8_T9_T10_T11_T12_T13_T14, + AP5 ~func(HKT_T6) func(HKT_F_T6_T7_T8_T9_T10_T11_T12_T13_T14) HKT_F_T7_T8_T9_T10_T11_T12_T13_T14, + AP6 ~func(HKT_T7) func(HKT_F_T7_T8_T9_T10_T11_T12_T13_T14) HKT_F_T8_T9_T10_T11_T12_T13_T14, + AP7 ~func(HKT_T8) func(HKT_F_T8_T9_T10_T11_T12_T13_T14) HKT_F_T9_T10_T11_T12_T13_T14, + AP8 ~func(HKT_T9) func(HKT_F_T9_T10_T11_T12_T13_T14) HKT_F_T10_T11_T12_T13_T14, + AP9 ~func(HKT_T10) func(HKT_F_T10_T11_T12_T13_T14) HKT_F_T11_T12_T13_T14, + AP10 ~func(HKT_T11) func(HKT_F_T11_T12_T13_T14) HKT_F_T12_T13_T14, + AP11 ~func(HKT_T12) func(HKT_F_T12_T13_T14) HKT_F_T13_T14, + AP12 ~func(HKT_T13) func(HKT_F_T13_T14) HKT_F_T14, + AP13 ~func(HKT_T14) func(HKT_F_T14) HKT_TUPLE14, + F1 ~func(A1) HKT_T1, + F2 ~func(A2) HKT_T2, + F3 ~func(A3) HKT_T3, + F4 ~func(A4) HKT_T4, + F5 ~func(A5) HKT_T5, + F6 ~func(A6) HKT_T6, + F7 ~func(A7) HKT_T7, + F8 ~func(A8) HKT_T8, + F9 ~func(A9) HKT_T9, + F10 ~func(A10) HKT_T10, + F11 ~func(A11) HKT_T11, + F12 ~func(A12) HKT_T12, + F13 ~func(A13) HKT_T13, + F14 ~func(A14) HKT_T14, + A1, T1, + A2, T2, + A3, T3, + A4, T4, + A5, T5, + A6, T6, + A7, T7, + A8, T8, + A9, T9, + A10, T10, + A11, T11, + A12, T12, + A13, T13, + A14, T14, + HKT_T1, // HKT[T1] + HKT_T2, // HKT[T2] + HKT_T3, // HKT[T3] + HKT_T4, // HKT[T4] + HKT_T5, // HKT[T5] + HKT_T6, // HKT[T6] + HKT_T7, // HKT[T7] + HKT_T8, // HKT[T8] + HKT_T9, // HKT[T9] + HKT_T10, // HKT[T10] + HKT_T11, // HKT[T11] + HKT_T12, // HKT[T12] + HKT_T13, // HKT[T13] + HKT_T14, // HKT[T14] + HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T6_T7_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T7_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T8_T9_T10_T11_T12_T13_T14, // HKT[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T9_T10_T11_T12_T13_T14, // HKT[func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T10_T11_T12_T13_T14, // HKT[func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T11_T12_T13_T14, // HKT[func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T12_T13_T14, // HKT[func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T13_T14, // HKT[func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_F_T14, // HKT[func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] + HKT_TUPLE14 any, // HKT[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] +]( + fmap MAP, + fap1 AP1, + fap2 AP2, + fap3 AP3, + fap4 AP4, + fap5 AP5, + fap6 AP6, + fap7 AP7, + fap8 AP8, + fap9 AP9, + fap10 AP10, + fap11 AP11, + fap12 AP12, + fap13 AP13, + f1 F1, + f2 F2, + f3 F3, + f4 F4, + f5 F5, + f6 F6, + f7 F7, + f8 F8, + f9 F9, + f10 F10, + f11 F11, + f12 F12, + f13 F13, + f14 F14, + t T.Tuple14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14], +) HKT_TUPLE14 { + return F.Pipe14( + f1(t.F1), + fmap(tupleConstructor14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]()), + fap1(f2(t.F2)), + fap2(f3(t.F3)), + fap3(f4(t.F4)), + fap4(f5(t.F5)), + fap5(f6(t.F6)), + fap6(f7(t.F7)), + fap7(f8(t.F8)), + fap8(f9(t.F9)), + fap9(f10(t.F10)), + fap10(f11(t.F11)), + fap11(f12(t.F12)), + fap12(f13(t.F13)), + fap13(f14(t.F14)), + ) +} + +// tupleConstructor15 returns a curried version of [T.MakeTuple15] +func tupleConstructor15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any]() func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] { + return F.Curry15(T.MakeTuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) +} + +// SequenceT15 is a utility function used to implement the sequence operation for higher kinded types based only on map and ap. +// The function takes 15 higher higher kinded types and returns a higher kinded type of a [Tuple15] with the resolved values. +func SequenceT15[ + MAP ~func(func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) func(HKT_T1) HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, + AP1 ~func(HKT_T2) func(HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, + AP2 ~func(HKT_T3) func(HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, + AP3 ~func(HKT_T4) func(HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, + AP4 ~func(HKT_T5) func(HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, + AP5 ~func(HKT_T6) func(HKT_F_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T7_T8_T9_T10_T11_T12_T13_T14_T15, + AP6 ~func(HKT_T7) func(HKT_F_T7_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T8_T9_T10_T11_T12_T13_T14_T15, + AP7 ~func(HKT_T8) func(HKT_F_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T9_T10_T11_T12_T13_T14_T15, + AP8 ~func(HKT_T9) func(HKT_F_T9_T10_T11_T12_T13_T14_T15) HKT_F_T10_T11_T12_T13_T14_T15, + AP9 ~func(HKT_T10) func(HKT_F_T10_T11_T12_T13_T14_T15) HKT_F_T11_T12_T13_T14_T15, + AP10 ~func(HKT_T11) func(HKT_F_T11_T12_T13_T14_T15) HKT_F_T12_T13_T14_T15, + AP11 ~func(HKT_T12) func(HKT_F_T12_T13_T14_T15) HKT_F_T13_T14_T15, + AP12 ~func(HKT_T13) func(HKT_F_T13_T14_T15) HKT_F_T14_T15, + AP13 ~func(HKT_T14) func(HKT_F_T14_T15) HKT_F_T15, + AP14 ~func(HKT_T15) func(HKT_F_T15) HKT_TUPLE15, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + HKT_T1, // HKT[T1] + HKT_T2, // HKT[T2] + HKT_T3, // HKT[T3] + HKT_T4, // HKT[T4] + HKT_T5, // HKT[T5] + HKT_T6, // HKT[T6] + HKT_T7, // HKT[T7] + HKT_T8, // HKT[T8] + HKT_T9, // HKT[T9] + HKT_T10, // HKT[T10] + HKT_T11, // HKT[T11] + HKT_T12, // HKT[T12] + HKT_T13, // HKT[T13] + HKT_T14, // HKT[T14] + HKT_T15, // HKT[T15] + HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T7_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T10_T11_T12_T13_T14_T15, // HKT[func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T11_T12_T13_T14_T15, // HKT[func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T12_T13_T14_T15, // HKT[func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T13_T14_T15, // HKT[func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T14_T15, // HKT[func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T15, // HKT[func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_TUPLE15 any, // HKT[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] +]( + fmap MAP, + fap1 AP1, + fap2 AP2, + fap3 AP3, + fap4 AP4, + fap5 AP5, + fap6 AP6, + fap7 AP7, + fap8 AP8, + fap9 AP9, + fap10 AP10, + fap11 AP11, + fap12 AP12, + fap13 AP13, + fap14 AP14, + t1 HKT_T1, + t2 HKT_T2, + t3 HKT_T3, + t4 HKT_T4, + t5 HKT_T5, + t6 HKT_T6, + t7 HKT_T7, + t8 HKT_T8, + t9 HKT_T9, + t10 HKT_T10, + t11 HKT_T11, + t12 HKT_T12, + t13 HKT_T13, + t14 HKT_T14, + t15 HKT_T15, +) HKT_TUPLE15 { + return F.Pipe15( + t1, + fmap(tupleConstructor15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]()), + fap1(t2), + fap2(t3), + fap3(t4), + fap4(t5), + fap5(t6), + fap6(t7), + fap7(t8), + fap8(t9), + fap9(t10), + fap10(t11), + fap11(t12), + fap12(t13), + fap13(t14), + fap14(t15), + ) +} + +// SequenceTuple15 is a utility function used to implement the sequence operation for higher kinded types based only on map and ap. +// The function takes a [Tuple15] of higher higher kinded types and returns a higher kinded type of a [Tuple15] with the resolved values. +func SequenceTuple15[ + MAP ~func(func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) func(HKT_T1) HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, + AP1 ~func(HKT_T2) func(HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, + AP2 ~func(HKT_T3) func(HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, + AP3 ~func(HKT_T4) func(HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, + AP4 ~func(HKT_T5) func(HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, + AP5 ~func(HKT_T6) func(HKT_F_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T7_T8_T9_T10_T11_T12_T13_T14_T15, + AP6 ~func(HKT_T7) func(HKT_F_T7_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T8_T9_T10_T11_T12_T13_T14_T15, + AP7 ~func(HKT_T8) func(HKT_F_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T9_T10_T11_T12_T13_T14_T15, + AP8 ~func(HKT_T9) func(HKT_F_T9_T10_T11_T12_T13_T14_T15) HKT_F_T10_T11_T12_T13_T14_T15, + AP9 ~func(HKT_T10) func(HKT_F_T10_T11_T12_T13_T14_T15) HKT_F_T11_T12_T13_T14_T15, + AP10 ~func(HKT_T11) func(HKT_F_T11_T12_T13_T14_T15) HKT_F_T12_T13_T14_T15, + AP11 ~func(HKT_T12) func(HKT_F_T12_T13_T14_T15) HKT_F_T13_T14_T15, + AP12 ~func(HKT_T13) func(HKT_F_T13_T14_T15) HKT_F_T14_T15, + AP13 ~func(HKT_T14) func(HKT_F_T14_T15) HKT_F_T15, + AP14 ~func(HKT_T15) func(HKT_F_T15) HKT_TUPLE15, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + HKT_T1, // HKT[T1] + HKT_T2, // HKT[T2] + HKT_T3, // HKT[T3] + HKT_T4, // HKT[T4] + HKT_T5, // HKT[T5] + HKT_T6, // HKT[T6] + HKT_T7, // HKT[T7] + HKT_T8, // HKT[T8] + HKT_T9, // HKT[T9] + HKT_T10, // HKT[T10] + HKT_T11, // HKT[T11] + HKT_T12, // HKT[T12] + HKT_T13, // HKT[T13] + HKT_T14, // HKT[T14] + HKT_T15, // HKT[T15] + HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T7_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T10_T11_T12_T13_T14_T15, // HKT[func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T11_T12_T13_T14_T15, // HKT[func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T12_T13_T14_T15, // HKT[func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T13_T14_T15, // HKT[func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T14_T15, // HKT[func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T15, // HKT[func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_TUPLE15 any, // HKT[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] +]( + fmap MAP, + fap1 AP1, + fap2 AP2, + fap3 AP3, + fap4 AP4, + fap5 AP5, + fap6 AP6, + fap7 AP7, + fap8 AP8, + fap9 AP9, + fap10 AP10, + fap11 AP11, + fap12 AP12, + fap13 AP13, + fap14 AP14, + t T.Tuple15[HKT_T1, HKT_T2, HKT_T3, HKT_T4, HKT_T5, HKT_T6, HKT_T7, HKT_T8, HKT_T9, HKT_T10, HKT_T11, HKT_T12, HKT_T13, HKT_T14, HKT_T15], +) HKT_TUPLE15 { + return F.Pipe15( + t.F1, + fmap(tupleConstructor15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]()), + fap1(t.F2), + fap2(t.F3), + fap3(t.F4), + fap4(t.F5), + fap5(t.F6), + fap6(t.F7), + fap7(t.F8), + fap8(t.F9), + fap9(t.F10), + fap10(t.F11), + fap11(t.F12), + fap12(t.F13), + fap13(t.F14), + fap14(t.F15), + ) +} + +// TraverseTuple15 is a utility function used to implement the sequence operation for higher kinded types based only on map and ap. +// The function takes a [Tuple15] of base types and 15 functions that transform these based types into higher higher kinded types. It returns a higher kinded type of a [Tuple15] with the resolved values. +func TraverseTuple15[ + MAP ~func(func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) func(HKT_T1) HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, + AP1 ~func(HKT_T2) func(HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, + AP2 ~func(HKT_T3) func(HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, + AP3 ~func(HKT_T4) func(HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, + AP4 ~func(HKT_T5) func(HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, + AP5 ~func(HKT_T6) func(HKT_F_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T7_T8_T9_T10_T11_T12_T13_T14_T15, + AP6 ~func(HKT_T7) func(HKT_F_T7_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T8_T9_T10_T11_T12_T13_T14_T15, + AP7 ~func(HKT_T8) func(HKT_F_T8_T9_T10_T11_T12_T13_T14_T15) HKT_F_T9_T10_T11_T12_T13_T14_T15, + AP8 ~func(HKT_T9) func(HKT_F_T9_T10_T11_T12_T13_T14_T15) HKT_F_T10_T11_T12_T13_T14_T15, + AP9 ~func(HKT_T10) func(HKT_F_T10_T11_T12_T13_T14_T15) HKT_F_T11_T12_T13_T14_T15, + AP10 ~func(HKT_T11) func(HKT_F_T11_T12_T13_T14_T15) HKT_F_T12_T13_T14_T15, + AP11 ~func(HKT_T12) func(HKT_F_T12_T13_T14_T15) HKT_F_T13_T14_T15, + AP12 ~func(HKT_T13) func(HKT_F_T13_T14_T15) HKT_F_T14_T15, + AP13 ~func(HKT_T14) func(HKT_F_T14_T15) HKT_F_T15, + AP14 ~func(HKT_T15) func(HKT_F_T15) HKT_TUPLE15, + F1 ~func(A1) HKT_T1, + F2 ~func(A2) HKT_T2, + F3 ~func(A3) HKT_T3, + F4 ~func(A4) HKT_T4, + F5 ~func(A5) HKT_T5, + F6 ~func(A6) HKT_T6, + F7 ~func(A7) HKT_T7, + F8 ~func(A8) HKT_T8, + F9 ~func(A9) HKT_T9, + F10 ~func(A10) HKT_T10, + F11 ~func(A11) HKT_T11, + F12 ~func(A12) HKT_T12, + F13 ~func(A13) HKT_T13, + F14 ~func(A14) HKT_T14, + F15 ~func(A15) HKT_T15, + A1, T1, + A2, T2, + A3, T3, + A4, T4, + A5, T5, + A6, T6, + A7, T7, + A8, T8, + A9, T9, + A10, T10, + A11, T11, + A12, T12, + A13, T13, + A14, T14, + A15, T15, + HKT_T1, // HKT[T1] + HKT_T2, // HKT[T2] + HKT_T3, // HKT[T3] + HKT_T4, // HKT[T4] + HKT_T5, // HKT[T5] + HKT_T6, // HKT[T6] + HKT_T7, // HKT[T7] + HKT_T8, // HKT[T8] + HKT_T9, // HKT[T9] + HKT_T10, // HKT[T10] + HKT_T11, // HKT[T11] + HKT_T12, // HKT[T12] + HKT_T13, // HKT[T13] + HKT_T14, // HKT[T14] + HKT_T15, // HKT[T15] + HKT_F_T2_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T3_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T4_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T5_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T6_T7_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T7_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T8_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T9_T10_T11_T12_T13_T14_T15, // HKT[func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T10_T11_T12_T13_T14_T15, // HKT[func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T11_T12_T13_T14_T15, // HKT[func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T12_T13_T14_T15, // HKT[func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T13_T14_T15, // HKT[func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T14_T15, // HKT[func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_F_T15, // HKT[func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] + HKT_TUPLE15 any, // HKT[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] +]( + fmap MAP, + fap1 AP1, + fap2 AP2, + fap3 AP3, + fap4 AP4, + fap5 AP5, + fap6 AP6, + fap7 AP7, + fap8 AP8, + fap9 AP9, + fap10 AP10, + fap11 AP11, + fap12 AP12, + fap13 AP13, + fap14 AP14, + f1 F1, + f2 F2, + f3 F3, + f4 F4, + f5 F5, + f6 F6, + f7 F7, + f8 F8, + f9 F9, + f10 F10, + f11 F11, + f12 F12, + f13 F13, + f14 F14, + f15 F15, + t T.Tuple15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15], +) HKT_TUPLE15 { + return F.Pipe15( + f1(t.F1), + fmap(tupleConstructor15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]()), + fap1(f2(t.F2)), + fap2(f3(t.F3)), + fap3(f4(t.F4)), + fap4(f5(t.F5)), + fap5(f6(t.F6)), + fap6(f7(t.F7)), + fap7(f8(t.F8)), + fap8(f9(t.F9)), + fap9(f10(t.F10)), + fap10(f11(t.F11)), + fap11(f12(t.F12)), + fap12(f13(t.F13)), + fap13(f14(t.F14)), + fap14(f15(t.F15)), + ) +} diff --git a/io/gen.go b/io/gen.go index adeeb07..aae6f9b 100644 --- a/io/gen.go +++ b/io/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-10-23 08:30:56.7105551 +0200 CEST m=+0.011255201 +// 2024-02-29 16:19:10.2607969 +0100 CET m=+0.024787801 package io diff --git a/io/generic/gen.go b/io/generic/gen.go index faaf726..66d28d4 100644 --- a/io/generic/gen.go +++ b/io/generic/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-10-23 08:30:56.7105551 +0200 CEST m=+0.011255201 +// 2024-02-29 16:19:10.2613281 +0100 CET m=+0.025319001 package generic import ( diff --git a/ioeither/gen.go b/ioeither/gen.go index e36a88b..f26288b 100644 --- a/ioeither/gen.go +++ b/ioeither/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-10-23 08:30:58.6457744 +0200 CEST m=+0.080336501 +// 2024-02-29 16:19:13.144922 +0100 CET m=+0.065757301 package ioeither diff --git a/ioeither/generic/gen.go b/ioeither/generic/gen.go index 28b633f..31cf0dd 100644 --- a/ioeither/generic/gen.go +++ b/ioeither/generic/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-10-23 08:30:58.6556525 +0200 CEST m=+0.090214601 +// 2024-02-29 16:19:13.1643755 +0100 CET m=+0.085210801 package generic import ( diff --git a/iooption/gen.go b/iooption/gen.go index e013fc5..bd05c30 100644 --- a/iooption/gen.go +++ b/iooption/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-10-23 08:31:01.9227118 +0200 CEST m=+0.009977901 +// 2024-02-29 16:19:16.7939127 +0100 CET m=+0.053853301 package iooption diff --git a/iooption/generic/gen.go b/iooption/generic/gen.go index bc6bc7e..9f382c3 100644 --- a/iooption/generic/gen.go +++ b/iooption/generic/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-10-23 08:31:01.9227118 +0200 CEST m=+0.009977901 +// 2024-02-29 16:19:16.8032769 +0100 CET m=+0.063217501 package generic import ( diff --git a/option/gen.go b/option/gen.go index 3f39202..48cc917 100644 --- a/option/gen.go +++ b/option/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-10-23 08:31:07.8687134 +0200 CEST m=+0.012222901 +// 2024-02-29 16:19:19.6336283 +0100 CET m=+0.018011101 package option diff --git a/reader/gen.go b/reader/gen.go index 5fe93db..6691797 100644 --- a/reader/gen.go +++ b/reader/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-10-23 08:31:13.0131834 +0200 CEST m=+0.010996501 +// 2024-02-29 16:19:26.0521202 +0100 CET m=+0.018000401 package reader diff --git a/reader/generic/gen.go b/reader/generic/gen.go index 6a1a9ca..04c7792 100644 --- a/reader/generic/gen.go +++ b/reader/generic/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-10-23 08:31:13.0131834 +0200 CEST m=+0.010996501 +// 2024-02-29 16:19:26.0521202 +0100 CET m=+0.018000401 package generic // From0 converts a function with 1 parameters returning a [R] into a function with 0 parameters returning a [GRA] diff --git a/readerioeither/gen.go b/readerioeither/gen.go index 4294b03..6f2294f 100644 --- a/readerioeither/gen.go +++ b/readerioeither/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-10-23 08:31:16.2414489 +0200 CEST m=+0.013052301 +// 2024-02-29 16:19:28.6907128 +0100 CET m=+0.032796101 package readerioeither diff --git a/readerioeither/generic/gen.go b/readerioeither/generic/gen.go index 48401a8..345816a 100644 --- a/readerioeither/generic/gen.go +++ b/readerioeither/generic/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-10-23 08:31:16.241979 +0200 CEST m=+0.013582401 +// 2024-02-29 16:19:28.691247 +0100 CET m=+0.033330301 package generic import ( diff --git a/tuple/doc.go b/tuple/doc.go index ea8f873..23ebd35 100644 --- a/tuple/doc.go +++ b/tuple/doc.go @@ -15,4 +15,4 @@ package tuple -//go:generate go run .. tuple --count 10 --filename gen.go +//go:generate go run .. tuple --count 15 --filename gen.go diff --git a/tuple/gen.go b/tuple/gen.go index 132c212..6fb5250 100644 --- a/tuple/gen.go +++ b/tuple/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2024-02-08 08:36:32.8883679 +0100 CET m=+0.008054801 +// 2024-02-29 16:19:31.6574369 +0100 CET m=+0.012049601 package tuple @@ -104,6 +104,91 @@ type Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any] struct { F10 T10 } +// Tuple11 is a struct that carries 11 independently typed values +type Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any] struct { + F1 T1 + F2 T2 + F3 T3 + F4 T4 + F5 T5 + F6 T6 + F7 T7 + F8 T8 + F9 T9 + F10 T10 + F11 T11 +} + +// Tuple12 is a struct that carries 12 independently typed values +type Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any] struct { + F1 T1 + F2 T2 + F3 T3 + F4 T4 + F5 T5 + F6 T6 + F7 T7 + F8 T8 + F9 T9 + F10 T10 + F11 T11 + F12 T12 +} + +// Tuple13 is a struct that carries 13 independently typed values +type Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any] struct { + F1 T1 + F2 T2 + F3 T3 + F4 T4 + F5 T5 + F6 T6 + F7 T7 + F8 T8 + F9 T9 + F10 T10 + F11 T11 + F12 T12 + F13 T13 +} + +// Tuple14 is a struct that carries 14 independently typed values +type Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any] struct { + F1 T1 + F2 T2 + F3 T3 + F4 T4 + F5 T5 + F6 T6 + F7 T7 + F8 T8 + F9 T9 + F10 T10 + F11 T11 + F12 T12 + F13 T13 + F14 T14 +} + +// Tuple15 is a struct that carries 15 independently typed values +type Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any] struct { + F1 T1 + F2 T2 + F3 T3 + F4 T4 + F5 T5 + F6 T6 + F7 T7 + F8 T8 + F9 T9 + F10 T10 + F11 T11 + F12 T12 + F13 T13 + F14 T14 + F15 T15 +} + // MakeTuple1 is a function that converts its 1 parameters into a [Tuple1] func MakeTuple1[T1 any](t1 T1) Tuple1[T1] { return Tuple1[T1]{t1} @@ -1326,3 +1411,843 @@ func FromArray10[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4, ) } } + +// Push10 creates a [Tuple11] from a [Tuple10] by appending a constant value +func Push10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](value T11) func(Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] { + return func(t Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] { + return MakeTuple11(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, value) + } +} + +// MakeTuple11 is a function that converts its 11 parameters into a [Tuple11] +func MakeTuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11) Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] { + return Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11} +} + +// Tupled11 converts a function with 11 parameters into a function taking a Tuple11 +// The inverse function is [Untupled11] +func Tupled11[F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R any](f F) func(Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) R { + return func(t Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) R { + return f(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11) + } +} + +// Untupled11 converts a function with a [Tuple11] parameter into a function with 11 parameters +// The inverse function is [Tupled11] +func Untupled11[F ~func(Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) R { + return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11) R { + return f(MakeTuple11(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11)) + } +} + +// Monoid11 creates a [Monoid] for a [Tuple11] based on 11 monoids for the contained types +func Monoid11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7], m8 M.Monoid[T8], m9 M.Monoid[T9], m10 M.Monoid[T10], m11 M.Monoid[T11]) M.Monoid[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] { + return M.MakeMonoid(func(l, r Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] { + return MakeTuple11(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7), m8.Concat(l.F8, r.F8), m9.Concat(l.F9, r.F9), m10.Concat(l.F10, r.F10), m11.Concat(l.F11, r.F11)) + }, MakeTuple11(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty(), m8.Empty(), m9.Empty(), m10.Empty(), m11.Empty())) +} + +// Ord11 creates n [Ord] for a [Tuple11] based on 11 [Ord]s for the contained types +func Ord11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7], o8 O.Ord[T8], o9 O.Ord[T9], o10 O.Ord[T10], o11 O.Ord[T11]) O.Ord[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] { + return O.MakeOrd(func(l, r Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) int { + if c := o1.Compare(l.F1, r.F1); c != 0 { + return c + } + if c := o2.Compare(l.F2, r.F2); c != 0 { + return c + } + if c := o3.Compare(l.F3, r.F3); c != 0 { + return c + } + if c := o4.Compare(l.F4, r.F4); c != 0 { + return c + } + if c := o5.Compare(l.F5, r.F5); c != 0 { + return c + } + if c := o6.Compare(l.F6, r.F6); c != 0 { + return c + } + if c := o7.Compare(l.F7, r.F7); c != 0 { + return c + } + if c := o8.Compare(l.F8, r.F8); c != 0 { + return c + } + if c := o9.Compare(l.F9, r.F9); c != 0 { + return c + } + if c := o10.Compare(l.F10, r.F10); c != 0 { + return c + } + if c := o11.Compare(l.F11, r.F11); c != 0 { + return c + } + return 0 + }, func(l, r Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) bool { + return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7) && o8.Equals(l.F8, r.F8) && o9.Equals(l.F9, r.F9) && o10.Equals(l.F10, r.F10) && o11.Equals(l.F11, r.F11) + }) +} + +// Map11 maps each value of a [Tuple11] via a mapping function +func Map11[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, F7 ~func(T7) R7, F8 ~func(T8) R8, F9 ~func(T9) R9, F10 ~func(T10) R10, F11 ~func(T11) R11, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6, T7, R7, T8, R8, T9, R9, T10, R10, T11, R11 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11) func(Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) Tuple11[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11] { + return func(t Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) Tuple11[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11] { + return MakeTuple11( + f1(t.F1), + f2(t.F2), + f3(t.F3), + f4(t.F4), + f5(t.F5), + f6(t.F6), + f7(t.F7), + f8(t.F8), + f9(t.F9), + f10(t.F10), + f11(t.F11), + ) + } +} + +// Replicate11 creates a [Tuple11] with all fields set to the input value `t` +func Replicate11[T any](t T) Tuple11[T, T, T, T, T, T, T, T, T, T, T] { + return MakeTuple11(t, t, t, t, t, t, t, t, t, t, t) +} + +// String prints some debug info for the [Tuple11] +func (t Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) String() string { + return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11) +} + +// MarshalJSON marshals the [Tuple11] into a JSON array +func (t Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) MarshalJSON() ([]byte, error) { + return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11) +} + +// UnmarshalJSON unmarshals a JSON array into a [Tuple11] +func (t *Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) UnmarshalJSON(data []byte) error { + return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7, &t.F8, &t.F9, &t.F10, &t.F11) +} + +// ToArray converts the [Tuple11] into an array of type [R] using 11 transformation functions from [T] to [R] +// The inverse function is [FromArray11] +func ToArray11[F1 ~func(T1) R, F2 ~func(T2) R, F3 ~func(T3) R, F4 ~func(T4) R, F5 ~func(T5) R, F6 ~func(T6) R, F7 ~func(T7) R, F8 ~func(T8) R, F9 ~func(T9) R, F10 ~func(T10) R, F11 ~func(T11) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11) func(t Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) []R { + return func(t Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) []R { + return []R{ + f1(t.F1), + f2(t.F2), + f3(t.F3), + f4(t.F4), + f5(t.F5), + f6(t.F6), + f7(t.F7), + f8(t.F8), + f9(t.F9), + f10(t.F10), + f11(t.F11), + } + } +} + +// FromArray converts an array of [R] into a [Tuple11] using 11 functions from [R] to [T] +// The inverse function is [ToArray11] +func FromArray11[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4, F5 ~func(R) T5, F6 ~func(R) T6, F7 ~func(R) T7, F8 ~func(R) T8, F9 ~func(R) T9, F10 ~func(R) T10, F11 ~func(R) T11, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11) func(r []R) Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] { + return func(r []R) Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] { + return MakeTuple11( + f1(r[0]), + f2(r[1]), + f3(r[2]), + f4(r[3]), + f5(r[4]), + f6(r[5]), + f7(r[6]), + f8(r[7]), + f9(r[8]), + f10(r[9]), + f11(r[10]), + ) + } +} + +// Push11 creates a [Tuple12] from a [Tuple11] by appending a constant value +func Push11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](value T12) func(Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] { + return func(t Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] { + return MakeTuple12(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, value) + } +} + +// MakeTuple12 is a function that converts its 12 parameters into a [Tuple12] +func MakeTuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12) Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] { + return Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12} +} + +// Tupled12 converts a function with 12 parameters into a function taking a Tuple12 +// The inverse function is [Untupled12] +func Tupled12[F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R any](f F) func(Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) R { + return func(t Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) R { + return f(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12) + } +} + +// Untupled12 converts a function with a [Tuple12] parameter into a function with 12 parameters +// The inverse function is [Tupled12] +func Untupled12[F ~func(Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) R { + return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12) R { + return f(MakeTuple12(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12)) + } +} + +// Monoid12 creates a [Monoid] for a [Tuple12] based on 12 monoids for the contained types +func Monoid12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7], m8 M.Monoid[T8], m9 M.Monoid[T9], m10 M.Monoid[T10], m11 M.Monoid[T11], m12 M.Monoid[T12]) M.Monoid[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] { + return M.MakeMonoid(func(l, r Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] { + return MakeTuple12(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7), m8.Concat(l.F8, r.F8), m9.Concat(l.F9, r.F9), m10.Concat(l.F10, r.F10), m11.Concat(l.F11, r.F11), m12.Concat(l.F12, r.F12)) + }, MakeTuple12(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty(), m8.Empty(), m9.Empty(), m10.Empty(), m11.Empty(), m12.Empty())) +} + +// Ord12 creates n [Ord] for a [Tuple12] based on 12 [Ord]s for the contained types +func Ord12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7], o8 O.Ord[T8], o9 O.Ord[T9], o10 O.Ord[T10], o11 O.Ord[T11], o12 O.Ord[T12]) O.Ord[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] { + return O.MakeOrd(func(l, r Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) int { + if c := o1.Compare(l.F1, r.F1); c != 0 { + return c + } + if c := o2.Compare(l.F2, r.F2); c != 0 { + return c + } + if c := o3.Compare(l.F3, r.F3); c != 0 { + return c + } + if c := o4.Compare(l.F4, r.F4); c != 0 { + return c + } + if c := o5.Compare(l.F5, r.F5); c != 0 { + return c + } + if c := o6.Compare(l.F6, r.F6); c != 0 { + return c + } + if c := o7.Compare(l.F7, r.F7); c != 0 { + return c + } + if c := o8.Compare(l.F8, r.F8); c != 0 { + return c + } + if c := o9.Compare(l.F9, r.F9); c != 0 { + return c + } + if c := o10.Compare(l.F10, r.F10); c != 0 { + return c + } + if c := o11.Compare(l.F11, r.F11); c != 0 { + return c + } + if c := o12.Compare(l.F12, r.F12); c != 0 { + return c + } + return 0 + }, func(l, r Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) bool { + return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7) && o8.Equals(l.F8, r.F8) && o9.Equals(l.F9, r.F9) && o10.Equals(l.F10, r.F10) && o11.Equals(l.F11, r.F11) && o12.Equals(l.F12, r.F12) + }) +} + +// Map12 maps each value of a [Tuple12] via a mapping function +func Map12[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, F7 ~func(T7) R7, F8 ~func(T8) R8, F9 ~func(T9) R9, F10 ~func(T10) R10, F11 ~func(T11) R11, F12 ~func(T12) R12, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6, T7, R7, T8, R8, T9, R9, T10, R10, T11, R11, T12, R12 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12) func(Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) Tuple12[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12] { + return func(t Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) Tuple12[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12] { + return MakeTuple12( + f1(t.F1), + f2(t.F2), + f3(t.F3), + f4(t.F4), + f5(t.F5), + f6(t.F6), + f7(t.F7), + f8(t.F8), + f9(t.F9), + f10(t.F10), + f11(t.F11), + f12(t.F12), + ) + } +} + +// Replicate12 creates a [Tuple12] with all fields set to the input value `t` +func Replicate12[T any](t T) Tuple12[T, T, T, T, T, T, T, T, T, T, T, T] { + return MakeTuple12(t, t, t, t, t, t, t, t, t, t, t, t) +} + +// String prints some debug info for the [Tuple12] +func (t Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) String() string { + return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12) +} + +// MarshalJSON marshals the [Tuple12] into a JSON array +func (t Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) MarshalJSON() ([]byte, error) { + return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12) +} + +// UnmarshalJSON unmarshals a JSON array into a [Tuple12] +func (t *Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) UnmarshalJSON(data []byte) error { + return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7, &t.F8, &t.F9, &t.F10, &t.F11, &t.F12) +} + +// ToArray converts the [Tuple12] into an array of type [R] using 12 transformation functions from [T] to [R] +// The inverse function is [FromArray12] +func ToArray12[F1 ~func(T1) R, F2 ~func(T2) R, F3 ~func(T3) R, F4 ~func(T4) R, F5 ~func(T5) R, F6 ~func(T6) R, F7 ~func(T7) R, F8 ~func(T8) R, F9 ~func(T9) R, F10 ~func(T10) R, F11 ~func(T11) R, F12 ~func(T12) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12) func(t Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) []R { + return func(t Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) []R { + return []R{ + f1(t.F1), + f2(t.F2), + f3(t.F3), + f4(t.F4), + f5(t.F5), + f6(t.F6), + f7(t.F7), + f8(t.F8), + f9(t.F9), + f10(t.F10), + f11(t.F11), + f12(t.F12), + } + } +} + +// FromArray converts an array of [R] into a [Tuple12] using 12 functions from [R] to [T] +// The inverse function is [ToArray12] +func FromArray12[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4, F5 ~func(R) T5, F6 ~func(R) T6, F7 ~func(R) T7, F8 ~func(R) T8, F9 ~func(R) T9, F10 ~func(R) T10, F11 ~func(R) T11, F12 ~func(R) T12, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12) func(r []R) Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] { + return func(r []R) Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] { + return MakeTuple12( + f1(r[0]), + f2(r[1]), + f3(r[2]), + f4(r[3]), + f5(r[4]), + f6(r[5]), + f7(r[6]), + f8(r[7]), + f9(r[8]), + f10(r[9]), + f11(r[10]), + f12(r[11]), + ) + } +} + +// Push12 creates a [Tuple13] from a [Tuple12] by appending a constant value +func Push12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](value T13) func(Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] { + return func(t Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] { + return MakeTuple13(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, value) + } +} + +// MakeTuple13 is a function that converts its 13 parameters into a [Tuple13] +func MakeTuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13) Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] { + return Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13} +} + +// Tupled13 converts a function with 13 parameters into a function taking a Tuple13 +// The inverse function is [Untupled13] +func Tupled13[F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R any](f F) func(Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) R { + return func(t Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) R { + return f(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13) + } +} + +// Untupled13 converts a function with a [Tuple13] parameter into a function with 13 parameters +// The inverse function is [Tupled13] +func Untupled13[F ~func(Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) R { + return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13) R { + return f(MakeTuple13(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13)) + } +} + +// Monoid13 creates a [Monoid] for a [Tuple13] based on 13 monoids for the contained types +func Monoid13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7], m8 M.Monoid[T8], m9 M.Monoid[T9], m10 M.Monoid[T10], m11 M.Monoid[T11], m12 M.Monoid[T12], m13 M.Monoid[T13]) M.Monoid[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] { + return M.MakeMonoid(func(l, r Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] { + return MakeTuple13(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7), m8.Concat(l.F8, r.F8), m9.Concat(l.F9, r.F9), m10.Concat(l.F10, r.F10), m11.Concat(l.F11, r.F11), m12.Concat(l.F12, r.F12), m13.Concat(l.F13, r.F13)) + }, MakeTuple13(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty(), m8.Empty(), m9.Empty(), m10.Empty(), m11.Empty(), m12.Empty(), m13.Empty())) +} + +// Ord13 creates n [Ord] for a [Tuple13] based on 13 [Ord]s for the contained types +func Ord13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7], o8 O.Ord[T8], o9 O.Ord[T9], o10 O.Ord[T10], o11 O.Ord[T11], o12 O.Ord[T12], o13 O.Ord[T13]) O.Ord[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] { + return O.MakeOrd(func(l, r Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) int { + if c := o1.Compare(l.F1, r.F1); c != 0 { + return c + } + if c := o2.Compare(l.F2, r.F2); c != 0 { + return c + } + if c := o3.Compare(l.F3, r.F3); c != 0 { + return c + } + if c := o4.Compare(l.F4, r.F4); c != 0 { + return c + } + if c := o5.Compare(l.F5, r.F5); c != 0 { + return c + } + if c := o6.Compare(l.F6, r.F6); c != 0 { + return c + } + if c := o7.Compare(l.F7, r.F7); c != 0 { + return c + } + if c := o8.Compare(l.F8, r.F8); c != 0 { + return c + } + if c := o9.Compare(l.F9, r.F9); c != 0 { + return c + } + if c := o10.Compare(l.F10, r.F10); c != 0 { + return c + } + if c := o11.Compare(l.F11, r.F11); c != 0 { + return c + } + if c := o12.Compare(l.F12, r.F12); c != 0 { + return c + } + if c := o13.Compare(l.F13, r.F13); c != 0 { + return c + } + return 0 + }, func(l, r Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) bool { + return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7) && o8.Equals(l.F8, r.F8) && o9.Equals(l.F9, r.F9) && o10.Equals(l.F10, r.F10) && o11.Equals(l.F11, r.F11) && o12.Equals(l.F12, r.F12) && o13.Equals(l.F13, r.F13) + }) +} + +// Map13 maps each value of a [Tuple13] via a mapping function +func Map13[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, F7 ~func(T7) R7, F8 ~func(T8) R8, F9 ~func(T9) R9, F10 ~func(T10) R10, F11 ~func(T11) R11, F12 ~func(T12) R12, F13 ~func(T13) R13, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6, T7, R7, T8, R8, T9, R9, T10, R10, T11, R11, T12, R12, T13, R13 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13) func(Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) Tuple13[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13] { + return func(t Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) Tuple13[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13] { + return MakeTuple13( + f1(t.F1), + f2(t.F2), + f3(t.F3), + f4(t.F4), + f5(t.F5), + f6(t.F6), + f7(t.F7), + f8(t.F8), + f9(t.F9), + f10(t.F10), + f11(t.F11), + f12(t.F12), + f13(t.F13), + ) + } +} + +// Replicate13 creates a [Tuple13] with all fields set to the input value `t` +func Replicate13[T any](t T) Tuple13[T, T, T, T, T, T, T, T, T, T, T, T, T] { + return MakeTuple13(t, t, t, t, t, t, t, t, t, t, t, t, t) +} + +// String prints some debug info for the [Tuple13] +func (t Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) String() string { + return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13) +} + +// MarshalJSON marshals the [Tuple13] into a JSON array +func (t Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) MarshalJSON() ([]byte, error) { + return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13) +} + +// UnmarshalJSON unmarshals a JSON array into a [Tuple13] +func (t *Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) UnmarshalJSON(data []byte) error { + return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7, &t.F8, &t.F9, &t.F10, &t.F11, &t.F12, &t.F13) +} + +// ToArray converts the [Tuple13] into an array of type [R] using 13 transformation functions from [T] to [R] +// The inverse function is [FromArray13] +func ToArray13[F1 ~func(T1) R, F2 ~func(T2) R, F3 ~func(T3) R, F4 ~func(T4) R, F5 ~func(T5) R, F6 ~func(T6) R, F7 ~func(T7) R, F8 ~func(T8) R, F9 ~func(T9) R, F10 ~func(T10) R, F11 ~func(T11) R, F12 ~func(T12) R, F13 ~func(T13) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13) func(t Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) []R { + return func(t Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) []R { + return []R{ + f1(t.F1), + f2(t.F2), + f3(t.F3), + f4(t.F4), + f5(t.F5), + f6(t.F6), + f7(t.F7), + f8(t.F8), + f9(t.F9), + f10(t.F10), + f11(t.F11), + f12(t.F12), + f13(t.F13), + } + } +} + +// FromArray converts an array of [R] into a [Tuple13] using 13 functions from [R] to [T] +// The inverse function is [ToArray13] +func FromArray13[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4, F5 ~func(R) T5, F6 ~func(R) T6, F7 ~func(R) T7, F8 ~func(R) T8, F9 ~func(R) T9, F10 ~func(R) T10, F11 ~func(R) T11, F12 ~func(R) T12, F13 ~func(R) T13, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13) func(r []R) Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] { + return func(r []R) Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] { + return MakeTuple13( + f1(r[0]), + f2(r[1]), + f3(r[2]), + f4(r[3]), + f5(r[4]), + f6(r[5]), + f7(r[6]), + f8(r[7]), + f9(r[8]), + f10(r[9]), + f11(r[10]), + f12(r[11]), + f13(r[12]), + ) + } +} + +// Push13 creates a [Tuple14] from a [Tuple13] by appending a constant value +func Push13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](value T14) func(Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] { + return func(t Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] { + return MakeTuple14(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13, value) + } +} + +// MakeTuple14 is a function that converts its 14 parameters into a [Tuple14] +func MakeTuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14) Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] { + return Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14} +} + +// Tupled14 converts a function with 14 parameters into a function taking a Tuple14 +// The inverse function is [Untupled14] +func Tupled14[F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R any](f F) func(Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) R { + return func(t Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) R { + return f(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13, t.F14) + } +} + +// Untupled14 converts a function with a [Tuple14] parameter into a function with 14 parameters +// The inverse function is [Tupled14] +func Untupled14[F ~func(Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) R { + return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14) R { + return f(MakeTuple14(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14)) + } +} + +// Monoid14 creates a [Monoid] for a [Tuple14] based on 14 monoids for the contained types +func Monoid14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7], m8 M.Monoid[T8], m9 M.Monoid[T9], m10 M.Monoid[T10], m11 M.Monoid[T11], m12 M.Monoid[T12], m13 M.Monoid[T13], m14 M.Monoid[T14]) M.Monoid[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] { + return M.MakeMonoid(func(l, r Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] { + return MakeTuple14(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7), m8.Concat(l.F8, r.F8), m9.Concat(l.F9, r.F9), m10.Concat(l.F10, r.F10), m11.Concat(l.F11, r.F11), m12.Concat(l.F12, r.F12), m13.Concat(l.F13, r.F13), m14.Concat(l.F14, r.F14)) + }, MakeTuple14(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty(), m8.Empty(), m9.Empty(), m10.Empty(), m11.Empty(), m12.Empty(), m13.Empty(), m14.Empty())) +} + +// Ord14 creates n [Ord] for a [Tuple14] based on 14 [Ord]s for the contained types +func Ord14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7], o8 O.Ord[T8], o9 O.Ord[T9], o10 O.Ord[T10], o11 O.Ord[T11], o12 O.Ord[T12], o13 O.Ord[T13], o14 O.Ord[T14]) O.Ord[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] { + return O.MakeOrd(func(l, r Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) int { + if c := o1.Compare(l.F1, r.F1); c != 0 { + return c + } + if c := o2.Compare(l.F2, r.F2); c != 0 { + return c + } + if c := o3.Compare(l.F3, r.F3); c != 0 { + return c + } + if c := o4.Compare(l.F4, r.F4); c != 0 { + return c + } + if c := o5.Compare(l.F5, r.F5); c != 0 { + return c + } + if c := o6.Compare(l.F6, r.F6); c != 0 { + return c + } + if c := o7.Compare(l.F7, r.F7); c != 0 { + return c + } + if c := o8.Compare(l.F8, r.F8); c != 0 { + return c + } + if c := o9.Compare(l.F9, r.F9); c != 0 { + return c + } + if c := o10.Compare(l.F10, r.F10); c != 0 { + return c + } + if c := o11.Compare(l.F11, r.F11); c != 0 { + return c + } + if c := o12.Compare(l.F12, r.F12); c != 0 { + return c + } + if c := o13.Compare(l.F13, r.F13); c != 0 { + return c + } + if c := o14.Compare(l.F14, r.F14); c != 0 { + return c + } + return 0 + }, func(l, r Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) bool { + return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7) && o8.Equals(l.F8, r.F8) && o9.Equals(l.F9, r.F9) && o10.Equals(l.F10, r.F10) && o11.Equals(l.F11, r.F11) && o12.Equals(l.F12, r.F12) && o13.Equals(l.F13, r.F13) && o14.Equals(l.F14, r.F14) + }) +} + +// Map14 maps each value of a [Tuple14] via a mapping function +func Map14[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, F7 ~func(T7) R7, F8 ~func(T8) R8, F9 ~func(T9) R9, F10 ~func(T10) R10, F11 ~func(T11) R11, F12 ~func(T12) R12, F13 ~func(T13) R13, F14 ~func(T14) R14, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6, T7, R7, T8, R8, T9, R9, T10, R10, T11, R11, T12, R12, T13, R13, T14, R14 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14) func(Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) Tuple14[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14] { + return func(t Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) Tuple14[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14] { + return MakeTuple14( + f1(t.F1), + f2(t.F2), + f3(t.F3), + f4(t.F4), + f5(t.F5), + f6(t.F6), + f7(t.F7), + f8(t.F8), + f9(t.F9), + f10(t.F10), + f11(t.F11), + f12(t.F12), + f13(t.F13), + f14(t.F14), + ) + } +} + +// Replicate14 creates a [Tuple14] with all fields set to the input value `t` +func Replicate14[T any](t T) Tuple14[T, T, T, T, T, T, T, T, T, T, T, T, T, T] { + return MakeTuple14(t, t, t, t, t, t, t, t, t, t, t, t, t, t) +} + +// String prints some debug info for the [Tuple14] +func (t Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) String() string { + return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13, t.F14) +} + +// MarshalJSON marshals the [Tuple14] into a JSON array +func (t Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) MarshalJSON() ([]byte, error) { + return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13, t.F14) +} + +// UnmarshalJSON unmarshals a JSON array into a [Tuple14] +func (t *Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) UnmarshalJSON(data []byte) error { + return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7, &t.F8, &t.F9, &t.F10, &t.F11, &t.F12, &t.F13, &t.F14) +} + +// ToArray converts the [Tuple14] into an array of type [R] using 14 transformation functions from [T] to [R] +// The inverse function is [FromArray14] +func ToArray14[F1 ~func(T1) R, F2 ~func(T2) R, F3 ~func(T3) R, F4 ~func(T4) R, F5 ~func(T5) R, F6 ~func(T6) R, F7 ~func(T7) R, F8 ~func(T8) R, F9 ~func(T9) R, F10 ~func(T10) R, F11 ~func(T11) R, F12 ~func(T12) R, F13 ~func(T13) R, F14 ~func(T14) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14) func(t Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) []R { + return func(t Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) []R { + return []R{ + f1(t.F1), + f2(t.F2), + f3(t.F3), + f4(t.F4), + f5(t.F5), + f6(t.F6), + f7(t.F7), + f8(t.F8), + f9(t.F9), + f10(t.F10), + f11(t.F11), + f12(t.F12), + f13(t.F13), + f14(t.F14), + } + } +} + +// FromArray converts an array of [R] into a [Tuple14] using 14 functions from [R] to [T] +// The inverse function is [ToArray14] +func FromArray14[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4, F5 ~func(R) T5, F6 ~func(R) T6, F7 ~func(R) T7, F8 ~func(R) T8, F9 ~func(R) T9, F10 ~func(R) T10, F11 ~func(R) T11, F12 ~func(R) T12, F13 ~func(R) T13, F14 ~func(R) T14, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14) func(r []R) Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] { + return func(r []R) Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] { + return MakeTuple14( + f1(r[0]), + f2(r[1]), + f3(r[2]), + f4(r[3]), + f5(r[4]), + f6(r[5]), + f7(r[6]), + f8(r[7]), + f9(r[8]), + f10(r[9]), + f11(r[10]), + f12(r[11]), + f13(r[12]), + f14(r[13]), + ) + } +} + +// Push14 creates a [Tuple15] from a [Tuple14] by appending a constant value +func Push14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](value T15) func(Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] { + return func(t Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] { + return MakeTuple15(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13, t.F14, value) + } +} + +// MakeTuple15 is a function that converts its 15 parameters into a [Tuple15] +func MakeTuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, t15 T15) Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] { + return Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15} +} + +// Tupled15 converts a function with 15 parameters into a function taking a Tuple15 +// The inverse function is [Untupled15] +func Tupled15[F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R any](f F) func(Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) R { + return func(t Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) R { + return f(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13, t.F14, t.F15) + } +} + +// Untupled15 converts a function with a [Tuple15] parameter into a function with 15 parameters +// The inverse function is [Tupled15] +func Untupled15[F ~func(Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) R { + return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, t15 T15) R { + return f(MakeTuple15(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15)) + } +} + +// Monoid15 creates a [Monoid] for a [Tuple15] based on 15 monoids for the contained types +func Monoid15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7], m8 M.Monoid[T8], m9 M.Monoid[T9], m10 M.Monoid[T10], m11 M.Monoid[T11], m12 M.Monoid[T12], m13 M.Monoid[T13], m14 M.Monoid[T14], m15 M.Monoid[T15]) M.Monoid[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] { + return M.MakeMonoid(func(l, r Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] { + return MakeTuple15(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7), m8.Concat(l.F8, r.F8), m9.Concat(l.F9, r.F9), m10.Concat(l.F10, r.F10), m11.Concat(l.F11, r.F11), m12.Concat(l.F12, r.F12), m13.Concat(l.F13, r.F13), m14.Concat(l.F14, r.F14), m15.Concat(l.F15, r.F15)) + }, MakeTuple15(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty(), m8.Empty(), m9.Empty(), m10.Empty(), m11.Empty(), m12.Empty(), m13.Empty(), m14.Empty(), m15.Empty())) +} + +// Ord15 creates n [Ord] for a [Tuple15] based on 15 [Ord]s for the contained types +func Ord15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7], o8 O.Ord[T8], o9 O.Ord[T9], o10 O.Ord[T10], o11 O.Ord[T11], o12 O.Ord[T12], o13 O.Ord[T13], o14 O.Ord[T14], o15 O.Ord[T15]) O.Ord[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] { + return O.MakeOrd(func(l, r Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) int { + if c := o1.Compare(l.F1, r.F1); c != 0 { + return c + } + if c := o2.Compare(l.F2, r.F2); c != 0 { + return c + } + if c := o3.Compare(l.F3, r.F3); c != 0 { + return c + } + if c := o4.Compare(l.F4, r.F4); c != 0 { + return c + } + if c := o5.Compare(l.F5, r.F5); c != 0 { + return c + } + if c := o6.Compare(l.F6, r.F6); c != 0 { + return c + } + if c := o7.Compare(l.F7, r.F7); c != 0 { + return c + } + if c := o8.Compare(l.F8, r.F8); c != 0 { + return c + } + if c := o9.Compare(l.F9, r.F9); c != 0 { + return c + } + if c := o10.Compare(l.F10, r.F10); c != 0 { + return c + } + if c := o11.Compare(l.F11, r.F11); c != 0 { + return c + } + if c := o12.Compare(l.F12, r.F12); c != 0 { + return c + } + if c := o13.Compare(l.F13, r.F13); c != 0 { + return c + } + if c := o14.Compare(l.F14, r.F14); c != 0 { + return c + } + if c := o15.Compare(l.F15, r.F15); c != 0 { + return c + } + return 0 + }, func(l, r Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) bool { + return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7) && o8.Equals(l.F8, r.F8) && o9.Equals(l.F9, r.F9) && o10.Equals(l.F10, r.F10) && o11.Equals(l.F11, r.F11) && o12.Equals(l.F12, r.F12) && o13.Equals(l.F13, r.F13) && o14.Equals(l.F14, r.F14) && o15.Equals(l.F15, r.F15) + }) +} + +// Map15 maps each value of a [Tuple15] via a mapping function +func Map15[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, F7 ~func(T7) R7, F8 ~func(T8) R8, F9 ~func(T9) R9, F10 ~func(T10) R10, F11 ~func(T11) R11, F12 ~func(T12) R12, F13 ~func(T13) R13, F14 ~func(T14) R14, F15 ~func(T15) R15, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6, T7, R7, T8, R8, T9, R9, T10, R10, T11, R11, T12, R12, T13, R13, T14, R14, T15, R15 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15) func(Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) Tuple15[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15] { + return func(t Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) Tuple15[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15] { + return MakeTuple15( + f1(t.F1), + f2(t.F2), + f3(t.F3), + f4(t.F4), + f5(t.F5), + f6(t.F6), + f7(t.F7), + f8(t.F8), + f9(t.F9), + f10(t.F10), + f11(t.F11), + f12(t.F12), + f13(t.F13), + f14(t.F14), + f15(t.F15), + ) + } +} + +// Replicate15 creates a [Tuple15] with all fields set to the input value `t` +func Replicate15[T any](t T) Tuple15[T, T, T, T, T, T, T, T, T, T, T, T, T, T, T] { + return MakeTuple15(t, t, t, t, t, t, t, t, t, t, t, t, t, t, t) +} + +// String prints some debug info for the [Tuple15] +func (t Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) String() string { + return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13, t.F14, t.F15) +} + +// MarshalJSON marshals the [Tuple15] into a JSON array +func (t Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) MarshalJSON() ([]byte, error) { + return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13, t.F14, t.F15) +} + +// UnmarshalJSON unmarshals a JSON array into a [Tuple15] +func (t *Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) UnmarshalJSON(data []byte) error { + return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7, &t.F8, &t.F9, &t.F10, &t.F11, &t.F12, &t.F13, &t.F14, &t.F15) +} + +// ToArray converts the [Tuple15] into an array of type [R] using 15 transformation functions from [T] to [R] +// The inverse function is [FromArray15] +func ToArray15[F1 ~func(T1) R, F2 ~func(T2) R, F3 ~func(T3) R, F4 ~func(T4) R, F5 ~func(T5) R, F6 ~func(T6) R, F7 ~func(T7) R, F8 ~func(T8) R, F9 ~func(T9) R, F10 ~func(T10) R, F11 ~func(T11) R, F12 ~func(T12) R, F13 ~func(T13) R, F14 ~func(T14) R, F15 ~func(T15) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15) func(t Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) []R { + return func(t Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) []R { + return []R{ + f1(t.F1), + f2(t.F2), + f3(t.F3), + f4(t.F4), + f5(t.F5), + f6(t.F6), + f7(t.F7), + f8(t.F8), + f9(t.F9), + f10(t.F10), + f11(t.F11), + f12(t.F12), + f13(t.F13), + f14(t.F14), + f15(t.F15), + } + } +} + +// FromArray converts an array of [R] into a [Tuple15] using 15 functions from [R] to [T] +// The inverse function is [ToArray15] +func FromArray15[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4, F5 ~func(R) T5, F6 ~func(R) T6, F7 ~func(R) T7, F8 ~func(R) T8, F9 ~func(R) T9, F10 ~func(R) T10, F11 ~func(R) T11, F12 ~func(R) T12, F13 ~func(R) T13, F14 ~func(R) T14, F15 ~func(R) T15, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15) func(r []R) Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] { + return func(r []R) Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] { + return MakeTuple15( + f1(r[0]), + f2(r[1]), + f3(r[2]), + f4(r[3]), + f5(r[4]), + f6(r[5]), + f7(r[6]), + f8(r[7]), + f9(r[8]), + f10(r[9]), + f11(r[10]), + f12(r[11]), + f13(r[12]), + f14(r[13]), + f15(r[14]), + ) + } +}