fix: update dependencies

Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>

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"

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"

context/readerioeither/http/request.go

@@ -26,7 +26,7 @@ import (
 	IOE "github.com/IBM/fp-go/ioeither"
 	IOEF "github.com/IBM/fp-go/ioeither/file"
 	J "github.com/IBM/fp-go/json"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
 type (
@@ -79,7 +79,7 @@ func ReadFullResponse(client Client) func(Requester) RIOE.ReaderIOEither[H.FullR
 						IOE.Of[error, io.ReadCloser],
 						IOEF.ReadAll[io.ReadCloser],
 					),
-					IOE.Map[error](F.Bind1st(T.MakeTuple2[*http.Response, []byte], resp)),
+					IOE.Map[error](F.Bind1st(P.MakePair[*http.Response, []byte], resp)),
 				)
 			}),
 		)

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

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,
+		))
+}

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

either/either.go

@@ -33,7 +33,7 @@ func Of[E, A any](value A) Either[E, A] {
 	return F.Pipe1(value, Right[E, A])
 }
 
-func FromIO[E, IO ~func() A, A any](f IO) Either[E, A] {
+func FromIO[E any, IO ~func() A, A any](f IO) Either[E, A] {
 	return F.Pipe1(f(), Right[E, A])
 }
 

either/either_test.go

@@ -22,6 +22,7 @@ import (
 
 	F "github.com/IBM/fp-go/function"
 	"github.com/IBM/fp-go/internal/utils"
+	IO "github.com/IBM/fp-go/io"
 	O "github.com/IBM/fp-go/option"
 	S "github.com/IBM/fp-go/string"
 	"github.com/stretchr/testify/assert"
@@ -71,7 +72,6 @@ func TestReduce(t *testing.T) {
 	assert.Equal(t, "foo", F.Pipe1(Left[string, string]("bar"), Reduce[string](s.Concat, "foo")))
 
 }
-
 func TestAp(t *testing.T) {
 	f := S.Size
 
@@ -120,3 +120,10 @@ func TestStringer(t *testing.T) {
 	var s fmt.Stringer = e
 	assert.Equal(t, exp, s.String())
 }
+
+func TestFromIO(t *testing.T) {
+	f := IO.Of("abc")
+	e := FromIO[error](f)
+
+	assert.Equal(t, Right[error]("abc"), e)
+}

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,
+		)
+	}
+}

exec/exec.go

@@ -16,18 +16,18 @@
 package exec
 
 import (
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
 type (
 	// CommandOutput represents the output of executing a command. The first field in the [Tuple2] is
 	// stdout, the second one is stderr. Use [StdOut] and [StdErr] to access these fields
-	CommandOutput = T.Tuple2[[]byte, []byte]
+	CommandOutput = P.Pair[[]byte, []byte]
 )
 
 var (
 	// StdOut returns the field of a [CommandOutput] representing `stdout`
-	StdOut = T.First[[]byte, []byte]
+	StdOut = P.Head[[]byte, []byte]
 	// StdErr returns the field of a [CommandOutput] representing `stderr`
-	StdErr = T.Second[[]byte, []byte]
+	StdErr = P.Tail[[]byte, []byte]
 )

file/getters.go

@@ -32,6 +32,11 @@ func ToReader[R io.Reader](r R) io.Reader {
 	return r
 }
 
+// ToWriter converts a [io.Writer]
+func ToWriter[W io.Writer](w W) io.Writer {
+	return w
+}
+
 // ToCloser converts a [io.Closer]
 func ToCloser[C io.Closer](c C) io.Closer {
 	return c

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
 

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
 

go.mod

@@ -3,15 +3,15 @@ module github.com/IBM/fp-go
 go 1.20
 
 require (
-	github.com/stretchr/testify v1.8.4
+	github.com/stretchr/testify v1.9.0
 	github.com/urfave/cli/v2 v2.27.1
 )
 
 require (
-	github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.4 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/xrash/smetrics v0.0.0-20231213231151-1d8dd44e695e // indirect
+	github.com/xrash/smetrics v0.0.0-20240312152122-5f08fbb34913 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,17 +1,17 @@
-github.com/cpuguy83/go-md2man/v2 v2.0.3 h1:qMCsGGgs+MAzDFyp9LpAe1Lqy/fY/qCovCm0qnXZOBM=
-github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4=
+github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/urfave/cli/v2 v2.27.1 h1:8xSQ6szndafKVRmfyeUMxkNUJQMjL1F2zmsZ+qHpfho=
 github.com/urfave/cli/v2 v2.27.1/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ=
-github.com/xrash/smetrics v0.0.0-20231213231151-1d8dd44e695e h1:+SOyEddqYF09QP7vr7CgJ1eti3pY9Fn3LHO1M1r/0sI=
-github.com/xrash/smetrics v0.0.0-20231213231151-1d8dd44e695e/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8=
+github.com/xrash/smetrics v0.0.0-20240312152122-5f08fbb34913 h1:+qGGcbkzsfDQNPPe9UDgpxAWQrhbbBXOYJFQDq/dtJw=
+github.com/xrash/smetrics v0.0.0-20240312152122-5f08fbb34913/go.mod h1:4aEEwZQutDLsQv2Deui4iYQ6DWTxR14g6m8Wv88+Xqk=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

http/types.go

@@ -18,15 +18,15 @@ package http
 import (
 	H "net/http"
 
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
 type (
 	// FullResponse represents a full http response, including headers and body
-	FullResponse = T.Tuple2[*H.Response, []byte]
+	FullResponse = P.Pair[*H.Response, []byte]
 )
 
 var (
-	Response = T.First[*H.Response, []byte]
-	Body     = T.Second[*H.Response, []byte]
+	Response = P.Head[*H.Response, []byte]
+	Body     = P.Tail[*H.Response, []byte]
 )

http/utils.go

@@ -28,12 +28,12 @@ import (
 	"github.com/IBM/fp-go/errors"
 	F "github.com/IBM/fp-go/function"
 	O "github.com/IBM/fp-go/option"
+	P "github.com/IBM/fp-go/pair"
 	R "github.com/IBM/fp-go/record/generic"
-	T "github.com/IBM/fp-go/tuple"
 )
 
 type (
-	ParsedMediaType = T.Tuple2[string, map[string]string]
+	ParsedMediaType = P.Pair[string, map[string]string]
 
 	HttpError struct {
 		statusCode int
@@ -45,17 +45,15 @@ type (
 
 var (
 	// mime type to check if a media type matches
-	reJSONMimeType = regexp.MustCompile(`application/(?:\w+\+)?json`)
+	isJSONMimeType = regexp.MustCompile(`application/(?:\w+\+)?json`).MatchString
 	// ValidateResponse validates an HTTP response and returns an [E.Either] if the response is not a success
 	ValidateResponse = E.FromPredicate(isValidStatus, StatusCodeError)
 	// alidateJsonContentTypeString parses a content type a validates that it is valid JSON
 	validateJSONContentTypeString = F.Flow2(
 		ParseMediaType,
 		E.ChainFirst(F.Flow2(
-			T.First[string, map[string]string],
-			E.FromPredicate(reJSONMimeType.MatchString, func(mimeType string) error {
-				return fmt.Errorf("mimetype [%s] is not a valid JSON content type", mimeType)
-			}),
+			P.Head[string, map[string]string],
+			E.FromPredicate(isJSONMimeType, errors.OnSome[string]("mimetype [%s] is not a valid JSON content type")),
 		)),
 	)
 	// ValidateJSONResponse checks if an HTTP response is a valid JSON response
@@ -81,7 +79,7 @@ const (
 // ParseMediaType parses a media type into a tuple
 func ParseMediaType(mediaType string) E.Either[error, ParsedMediaType] {
 	m, p, err := mime.ParseMediaType(mediaType)
-	return E.TryCatchError(T.MakeTuple2(m, p), err)
+	return E.TryCatchError(P.MakePair(m, p), err)
 }
 
 // Error fulfills the error interface

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
 

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

internal/exec/exec.go

@@ -23,7 +23,7 @@ import (
 
 	EX "github.com/IBM/fp-go/exec"
 
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
 func Exec(ctx context.Context, name string, args []string, in []byte) (EX.CommandOutput, error) {
@@ -42,5 +42,5 @@ func Exec(ctx context.Context, name string, args []string, in []byte) (EX.Comman
 		err = fmt.Errorf("command execution of [%s][%s] failed, stdout [%s], stderr [%s], cause [%w]", name, args, stdOut.String(), stdErr.String(), err)
 	}
 	// return the outputs
-	return T.MakeTuple2(stdOut.Bytes(), stdErr.Bytes()), err
+	return P.MakePair(stdOut.Bytes(), stdErr.Bytes()), err
 }

internal/statet/state.go

@@ -0,0 +1,198 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package state
+
+import (
+	F "github.com/IBM/fp-go/function"
+	P "github.com/IBM/fp-go/pair"
+)
+
+func Of[
+	HKTSA ~func(S) HKTA,
+	HKTA,
+	S, A any,
+](
+	fof func(P.Pair[A, S]) HKTA,
+
+	a A) HKTSA {
+
+	return F.Flow2(
+		F.Bind1st(P.MakePair[A, S], a),
+		fof,
+	)
+}
+
+func MonadMap[
+	HKTSA ~func(S) HKTA,
+	HKTSB ~func(S) HKTB,
+	HKTA,
+	HKTB,
+	S, A, B any,
+](
+	fmap func(HKTA, func(P.Pair[A, S]) P.Pair[B, S]) HKTB,
+
+	fa HKTSA,
+	f func(A) B,
+) HKTSB {
+
+	return F.Flow2(
+		fa,
+		F.Bind2nd(fmap, P.Map[S](f)),
+	)
+}
+
+func Map[
+	HKTSA ~func(S) HKTA,
+	HKTSB ~func(S) HKTB,
+	HKTA,
+	HKTB,
+	S, A, B any,
+](
+	fmap func(func(P.Pair[A, S]) P.Pair[B, S]) func(HKTA) HKTB,
+
+	f func(A) B,
+) func(HKTSA) HKTSB {
+	mp := fmap(P.Map[S](f))
+
+	return func(fa HKTSA) HKTSB {
+		return F.Flow2(
+			fa,
+			mp,
+		)
+	}
+}
+
+func MonadChain[
+	HKTSA ~func(S) HKTA,
+	HKTSB ~func(S) HKTB,
+	HKTA,
+	HKTB,
+	S, A any,
+](
+	fchain func(HKTA, func(P.Pair[A, S]) HKTB) HKTB,
+
+	fa HKTSA,
+	f func(A) HKTSB,
+) HKTSB {
+	return F.Flow2(
+		fa,
+		F.Bind2nd(fchain, func(a P.Pair[A, S]) HKTB {
+			return f(P.Head(a))(P.Tail(a))
+		}),
+	)
+}
+
+func Chain[
+	HKTSA ~func(S) HKTA,
+	HKTSB ~func(S) HKTB,
+	HKTA,
+	HKTB,
+	S, A any,
+](
+	fchain func(func(P.Pair[A, S]) HKTB) func(HKTA) HKTB,
+
+	f func(A) HKTSB,
+) func(HKTSA) HKTSB {
+	mp := fchain(func(a P.Pair[A, S]) HKTB {
+		return f(P.Head(a))(P.Tail(a))
+	})
+
+	return func(fa HKTSA) HKTSB {
+		return F.Flow2(
+			fa,
+			mp,
+		)
+	}
+}
+
+func MonadAp[
+	HKTSA ~func(S) HKTA,
+	HKTSB ~func(S) HKTB,
+	HKTSAB ~func(S) HKTAB,
+	HKTA,
+	HKTB,
+	HKTAB,
+
+	S, A, B any,
+](
+	fmap func(HKTA, func(P.Pair[A, S]) P.Pair[B, S]) HKTB,
+	fchain func(HKTAB, func(P.Pair[func(A) B, S]) HKTB) HKTB,
+
+	fab HKTSAB,
+	fa HKTSA,
+) HKTSB {
+	return func(s S) HKTB {
+		return fchain(fab(s), func(ab P.Pair[func(A) B, S]) HKTB {
+			return fmap(fa(P.Tail(ab)), P.Map[S](P.Head(ab)))
+		})
+	}
+}
+
+func Ap[
+	HKTSA ~func(S) HKTA,
+	HKTSB ~func(S) HKTB,
+	HKTSAB ~func(S) HKTAB,
+	HKTA,
+	HKTB,
+	HKTAB,
+
+	S, A, B any,
+](
+	fmap func(func(P.Pair[A, S]) P.Pair[B, S]) func(HKTA) HKTB,
+	fchain func(func(P.Pair[func(A) B, S]) HKTB) func(HKTAB) HKTB,
+
+	fa HKTSA,
+) func(HKTSAB) HKTSB {
+	return func(fab HKTSAB) HKTSB {
+		return F.Flow2(
+			fab,
+			fchain(func(ab P.Pair[func(A) B, S]) HKTB {
+				return fmap(P.Map[S](P.Head(ab)))(fa(P.Tail(ab)))
+			}),
+		)
+	}
+}
+
+func FromF[
+	HKTSA ~func(S) HKTA,
+	HKTA,
+
+	HKTFA,
+
+	S, A any,
+](
+	fmap func(HKTFA, func(A) P.Pair[A, S]) HKTA,
+	ma HKTFA) HKTSA {
+
+	f1 := F.Bind1st(fmap, ma)
+
+	return func(s S) HKTA {
+		return f1(F.Bind2nd(P.MakePair[A, S], s))
+	}
+}
+
+func FromState[
+	HKTSA ~func(S) HKTA,
+	ST ~func(S) P.Pair[A, S],
+	HKTA,
+
+	S, A any,
+](
+	fof func(P.Pair[A, S]) HKTA,
+	sa ST,
+) HKTSA {
+	return F.Flow2(sa, fof)
+}

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
 

io/generic/ap.go

@@ -27,16 +27,11 @@ const (
 
 // MonadApSeq implements the applicative on a single thread by first executing mab and the ma
 func MonadApSeq[GA ~func() A, GB ~func() B, GAB ~func() func(A) B, A, B any](mab GAB, ma GA) GB {
-	return MakeIO[GB](func() B {
-		return F.Pipe1(
-			ma(),
-			mab(),
-		)
-	})
+	return MonadChain(mab, F.Bind1st(MonadMap[GA, GB], ma))
 }
 
 // MonadApPar implements the applicative on two threads, the main thread executes mab and the actuall
-// apply operation and the second thred computes ma. Communication between the threads happens via a channel
+// apply operation and the second thread computes ma. Communication between the threads happens via a channel
 func MonadApPar[GA ~func() A, GB ~func() B, GAB ~func() func(A) B, A, B any](mab GAB, ma GA) GB {
 	return MakeIO[GB](func() B {
 		c := make(chan A)

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 (

io/generic/traverse.go

@@ -32,6 +32,28 @@ func MonadTraverseArray[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B
 	)
 }
 
+func MonadTraverseArraySeq[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B any](tas AAS, f func(A) GB) GBS {
+	return RA.MonadTraverse(
+		Of[GBS, BBS],
+		Map[GBS, func() func(B) BBS, BBS, func(B) BBS],
+		ApSeq[GBS, func() func(B) BBS, GB],
+
+		tas,
+		f,
+	)
+}
+
+func MonadTraverseArrayPar[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B any](tas AAS, f func(A) GB) GBS {
+	return RA.MonadTraverse(
+		Of[GBS, BBS],
+		Map[GBS, func() func(B) BBS, BBS, func(B) BBS],
+		ApPar[GBS, func() func(B) BBS, GB],
+
+		tas,
+		f,
+	)
+}
+
 func TraverseArray[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B any](f func(A) GB) func(AAS) GBS {
 	return RA.Traverse[AAS](
 		Of[GBS, BBS],
@@ -42,6 +64,26 @@ func TraverseArray[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B any](
 	)
 }
 
+func TraverseArraySeq[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B any](f func(A) GB) func(AAS) GBS {
+	return RA.Traverse[AAS](
+		Of[GBS, BBS],
+		Map[GBS, func() func(B) BBS, BBS, func(B) BBS],
+		ApSeq[GBS, func() func(B) BBS, GB],
+
+		f,
+	)
+}
+
+func TraverseArrayPar[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B any](f func(A) GB) func(AAS) GBS {
+	return RA.Traverse[AAS](
+		Of[GBS, BBS],
+		Map[GBS, func() func(B) BBS, BBS, func(B) BBS],
+		ApPar[GBS, func() func(B) BBS, GB],
+
+		f,
+	)
+}
+
 func TraverseArrayWithIndex[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B any](f func(int, A) GB) func(AAS) GBS {
 	return RA.TraverseWithIndex[AAS](
 		Of[GBS, BBS],
@@ -52,10 +94,38 @@ func TraverseArrayWithIndex[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A
 	)
 }
 
+func TraverseArrayWithIndexSeq[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B any](f func(int, A) GB) func(AAS) GBS {
+	return RA.TraverseWithIndex[AAS](
+		Of[GBS, BBS],
+		Map[GBS, func() func(B) BBS, BBS, func(B) BBS],
+		ApSeq[GBS, func() func(B) BBS, GB],
+
+		f,
+	)
+}
+
+func TraverseArrayWithIndexPar[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B any](f func(int, A) GB) func(AAS) GBS {
+	return RA.TraverseWithIndex[AAS](
+		Of[GBS, BBS],
+		Map[GBS, func() func(B) BBS, BBS, func(B) BBS],
+		ApPar[GBS, func() func(B) BBS, GB],
+
+		f,
+	)
+}
+
 func SequenceArray[GA ~func() A, GAS ~func() AAS, AAS ~[]A, GAAS ~[]GA, A any](tas GAAS) GAS {
 	return MonadTraverseArray[GA, GAS](tas, F.Identity[GA])
 }
 
+func SequenceArraySeq[GA ~func() A, GAS ~func() AAS, AAS ~[]A, GAAS ~[]GA, A any](tas GAAS) GAS {
+	return MonadTraverseArraySeq[GA, GAS](tas, F.Identity[GA])
+}
+
+func SequenceArrayPar[GA ~func() A, GAS ~func() AAS, AAS ~[]A, GAAS ~[]GA, A any](tas GAAS) GAS {
+	return MonadTraverseArrayPar[GA, GAS](tas, F.Identity[GA])
+}
+
 // MonadTraverseRecord transforms a record using an IO transform an IO of a record
 func MonadTraverseRecord[GBS ~func() MB, MA ~map[K]A, GB ~func() B, MB ~map[K]B, K comparable, A, B any](ma MA, f func(A) GB) GBS {
 	return RR.MonadTraverse[MA](
@@ -89,3 +159,71 @@ func TraverseRecordWithIndex[GB ~func() B, GBS ~func() MB, MA ~map[K]A, MB ~map[
 func SequenceRecord[GA ~func() A, GAS ~func() AAS, AAS ~map[K]A, GAAS ~map[K]GA, K comparable, A any](tas GAAS) GAS {
 	return MonadTraverseRecord[GAS](tas, F.Identity[GA])
 }
+
+// MonadTraverseRecordSeq transforms a record using an IO transform an IO of a record
+func MonadTraverseRecordSeq[GBS ~func() MB, MA ~map[K]A, GB ~func() B, MB ~map[K]B, K comparable, A, B any](ma MA, f func(A) GB) GBS {
+	return RR.MonadTraverse[MA](
+		Of[GBS, MB],
+		Map[GBS, func() func(B) MB, MB, func(B) MB],
+		ApSeq[GBS, func() func(B) MB, GB],
+		ma, f,
+	)
+}
+
+// TraverseRecordSeq transforms a record using an IO transform an IO of a record
+func TraverseRecordSeq[GBS ~func() MB, MA ~map[K]A, GB ~func() B, MB ~map[K]B, K comparable, A, B any](f func(A) GB) func(MA) GBS {
+	return RR.Traverse[MA](
+		Of[GBS, MB],
+		Map[GBS, func() func(B) MB, MB, func(B) MB],
+		ApSeq[GBS, func() func(B) MB, GB],
+		f,
+	)
+}
+
+// TraverseRecordWithIndexSeq transforms a record using an IO transform an IO of a record
+func TraverseRecordWithIndexSeq[GB ~func() B, GBS ~func() MB, MA ~map[K]A, MB ~map[K]B, K comparable, A, B any](f func(K, A) GB) func(MA) GBS {
+	return RR.TraverseWithIndex[MA](
+		Of[GBS, MB],
+		Map[GBS, func() func(B) MB, MB, func(B) MB],
+		ApSeq[GBS, func() func(B) MB, GB],
+		f,
+	)
+}
+
+func SequenceRecordSeq[GA ~func() A, GAS ~func() AAS, AAS ~map[K]A, GAAS ~map[K]GA, K comparable, A any](tas GAAS) GAS {
+	return MonadTraverseRecordSeq[GAS](tas, F.Identity[GA])
+}
+
+// MonadTraverseRecordPar transforms a record using an IO transform an IO of a record
+func MonadTraverseRecordPar[GBS ~func() MB, MA ~map[K]A, GB ~func() B, MB ~map[K]B, K comparable, A, B any](ma MA, f func(A) GB) GBS {
+	return RR.MonadTraverse[MA](
+		Of[GBS, MB],
+		Map[GBS, func() func(B) MB, MB, func(B) MB],
+		ApPar[GBS, func() func(B) MB, GB],
+		ma, f,
+	)
+}
+
+// TraverseRecordPar transforms a record using an IO transform an IO of a record
+func TraverseRecordPar[GBS ~func() MB, MA ~map[K]A, GB ~func() B, MB ~map[K]B, K comparable, A, B any](f func(A) GB) func(MA) GBS {
+	return RR.Traverse[MA](
+		Of[GBS, MB],
+		Map[GBS, func() func(B) MB, MB, func(B) MB],
+		ApPar[GBS, func() func(B) MB, GB],
+		f,
+	)
+}
+
+// TraverseRecordWithIndexPar transforms a record using an IO transform an IO of a record
+func TraverseRecordWithIndexPar[GB ~func() B, GBS ~func() MB, MA ~map[K]A, MB ~map[K]B, K comparable, A, B any](f func(K, A) GB) func(MA) GBS {
+	return RR.TraverseWithIndex[MA](
+		Of[GBS, MB],
+		Map[GBS, func() func(B) MB, MB, func(B) MB],
+		ApPar[GBS, func() func(B) MB, GB],
+		f,
+	)
+}
+
+func SequenceRecordPar[GA ~func() A, GAS ~func() AAS, AAS ~map[K]A, GAAS ~map[K]GA, K comparable, A any](tas GAAS) GAS {
+	return MonadTraverseRecordPar[GAS](tas, F.Identity[GA])
+}

io/sequence_test.go

@@ -0,0 +1,47 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package io
+
+import (
+	A "github.com/IBM/fp-go/array"
+	F "github.com/IBM/fp-go/function"
+	"github.com/stretchr/testify/assert"
+
+	"testing"
+)
+
+func TestMapSeq(t *testing.T) {
+	var results []string
+
+	handler := func(value string) IO[string] {
+		return func() string {
+			results = append(results, value)
+			return value
+		}
+	}
+
+	src := A.From("a", "b", "c")
+
+	res := F.Pipe2(
+		src,
+		TraverseArraySeq(handler),
+		Map(func(data []string) bool {
+			return assert.Equal(t, data, results)
+		}),
+	)
+
+	assert.True(t, res())
+}

io/traverse.go

@@ -60,3 +60,45 @@ func TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) IO[B]) func(ma
 func SequenceRecord[K comparable, A any](tas map[K]IO[A]) IO[map[K]A] {
 	return G.SequenceRecord[IO[A], IO[map[K]A]](tas)
 }
+
+func MonadTraverseArraySeq[A, B any](tas []A, f func(A) IO[B]) IO[[]B] {
+	return G.MonadTraverseArraySeq[IO[B], IO[[]B]](tas, f)
+}
+
+// TraverseArraySeq applies a function returning an [IO] to all elements in an array and the
+// transforms this into an [IO] of that array
+func TraverseArraySeq[A, B any](f func(A) IO[B]) func([]A) IO[[]B] {
+	return G.TraverseArraySeq[IO[B], IO[[]B], []A](f)
+}
+
+// TraverseArrayWithIndexSeq applies a function returning an [IO] to all elements in an array and the
+// transforms this into an [IO] of that array
+func TraverseArrayWithIndexSeq[A, B any](f func(int, A) IO[B]) func([]A) IO[[]B] {
+	return G.TraverseArrayWithIndexSeq[IO[B], IO[[]B], []A](f)
+}
+
+// SequenceArraySeq converts an array of [IO] to an [IO] of an array
+func SequenceArraySeq[A any](tas []IO[A]) IO[[]A] {
+	return G.SequenceArraySeq[IO[A], IO[[]A]](tas)
+}
+
+func MonadTraverseRecordSeq[K comparable, A, B any](tas map[K]A, f func(A) IO[B]) IO[map[K]B] {
+	return G.MonadTraverseRecordSeq[IO[map[K]B]](tas, f)
+}
+
+// TraverseRecord applies a function returning an [IO] to all elements in a record and the
+// transforms this into an [IO] of that record
+func TraverseRecordSeq[K comparable, A, B any](f func(A) IO[B]) func(map[K]A) IO[map[K]B] {
+	return G.TraverseRecordSeq[IO[map[K]B], map[K]A, IO[B]](f)
+}
+
+// TraverseRecordWithIndexSeq applies a function returning an [IO] to all elements in a record and the
+// transforms this into an [IO] of that record
+func TraverseRecordWithIndeSeq[K comparable, A, B any](f func(K, A) IO[B]) func(map[K]A) IO[map[K]B] {
+	return G.TraverseRecordWithIndexSeq[IO[B], IO[map[K]B], map[K]A](f)
+}
+
+// SequenceRecordSeq converts a record of [IO] to an [IO] of a record
+func SequenceRecordSeq[K comparable, A any](tas map[K]IO[A]) IO[map[K]A] {
+	return G.SequenceRecordSeq[IO[A], IO[map[K]A]](tas)
+}

ioeither/file/readall.go

@@ -18,20 +18,23 @@ package file
 import (
 	"io"
 
+	FL "github.com/IBM/fp-go/file"
+	F "github.com/IBM/fp-go/function"
 	IOE "github.com/IBM/fp-go/ioeither"
 )
 
-func onReadAll[R io.Reader](r R) IOE.IOEither[error, []byte] {
-	return IOE.TryCatchError(func() ([]byte, error) {
-		return io.ReadAll(r)
-	})
-}
+var (
+	// readAll is the adapted version of [io.ReadAll]
+	readAll = IOE.Eitherize1(io.ReadAll)
+)
 
 // ReadAll uses a generator function to create a stream, reads it and closes it
 func ReadAll[R io.ReadCloser](acquire IOE.IOEither[error, R]) IOE.IOEither[error, []byte] {
-	return IOE.WithResource[[]byte](
-		acquire,
-		Close[R])(
-		onReadAll[R],
+	return F.Pipe1(
+		F.Flow2(
+			FL.ToReader[R],
+			readAll,
+		),
+		IOE.WithResource[[]byte](acquire, Close[R]),
 	)
 }

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
 

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 (

ioeither/generic/monad.go

@@ -0,0 +1,56 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	ET "github.com/IBM/fp-go/either"
+	"github.com/IBM/fp-go/internal/monad"
+	"github.com/IBM/fp-go/internal/pointed"
+)
+
+type ioEitherPointed[E, A any, GA ~func() ET.Either[E, A]] struct{}
+
+type ioEitherMonad[E, A, B any, GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B]] struct{}
+
+func (o *ioEitherPointed[E, A, GA]) Of(a A) GA {
+	return Of[GA, E, A](a)
+}
+
+func (o *ioEitherMonad[E, A, B, GA, GB, GAB]) Of(a A) GA {
+	return Of[GA, E, A](a)
+}
+
+func (o *ioEitherMonad[E, A, B, GA, GB, GAB]) Map(f func(A) B) func(GA) GB {
+	return Map[GA, GB, E, A, B](f)
+}
+
+func (o *ioEitherMonad[E, A, B, GA, GB, GAB]) Chain(f func(A) GB) func(GA) GB {
+	return Chain[GA, GB, E, A, B](f)
+}
+
+func (o *ioEitherMonad[E, A, B, GA, GB, GAB]) Ap(fa GA) func(GAB) GB {
+	return Ap[GB, GAB, GA, E, A, B](fa)
+}
+
+// Pointed implements the pointed operations for [IOEither]
+func Pointed[E, A any, GA ~func() ET.Either[E, A]]() pointed.Pointed[A, GA] {
+	return &ioEitherPointed[E, A, GA]{}
+}
+
+// Monad implements the monadic operations for [IOEither]
+func Monad[E, A, B any, GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B]]() monad.Monad[A, B, GA, GB, GAB] {
+	return &ioEitherMonad[E, A, B, GA, GB, GAB]{}
+}

ioeither/http/request.go

@@ -27,7 +27,7 @@ import (
 	IOE "github.com/IBM/fp-go/ioeither"
 	IOEF "github.com/IBM/fp-go/ioeither/file"
 	J "github.com/IBM/fp-go/json"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
 type (
@@ -95,7 +95,7 @@ func ReadFullResponse(client Client) func(Requester) IOE.IOEither[error, H.FullR
 					IOE.Of[error, io.ReadCloser],
 					IOEF.ReadAll[io.ReadCloser],
 				),
-				IOE.Map[error](F.Bind1st(T.MakeTuple2[*http.Response, []byte], resp)),
+				IOE.Map[error](F.Bind1st(P.MakePair[*http.Response, []byte], resp)),
 			)
 		}),
 	)

ioeither/monad.go

@@ -0,0 +1,32 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ioeither
+
+import (
+	"github.com/IBM/fp-go/internal/monad"
+	"github.com/IBM/fp-go/internal/pointed"
+	G "github.com/IBM/fp-go/ioeither/generic"
+)
+
+// Pointed returns the pointed operations for [IOEither]
+func Pointed[E, A any]() pointed.Pointed[A, IOEither[E, A]] {
+	return G.Pointed[E, A, IOEither[E, A]]()
+}
+
+// Monad returns the monadic operations for [IOEither]
+func Monad[E, A, B any]() monad.Monad[A, B, IOEither[E, A], IOEither[E, B], IOEither[E, func(A) B]] {
+	return G.Monad[E, A, B, IOEither[E, A], IOEither[E, B], IOEither[E, func(A) B]]()
+}

ioeither/sequence_test.go

@@ -0,0 +1,48 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ioeither
+
+import (
+	A "github.com/IBM/fp-go/array"
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	"github.com/stretchr/testify/assert"
+
+	"testing"
+)
+
+func TestMapSeq(t *testing.T) {
+	var results []string
+
+	handler := func(value string) IOEither[error, string] {
+		return func() E.Either[error, string] {
+			results = append(results, value)
+			return E.Of[error](value)
+		}
+	}
+
+	src := A.From("a", "b", "c")
+
+	res := F.Pipe2(
+		src,
+		TraverseArraySeq(handler),
+		Map[error](func(data []string) bool {
+			return assert.Equal(t, data, results)
+		}),
+	)
+
+	assert.Equal(t, E.Of[error](true), res())
+}

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
 

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 (

iterator/stateless/compress.go

@@ -17,11 +17,11 @@ package stateless
 
 import (
 	G "github.com/IBM/fp-go/iterator/stateless/generic"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
 // Compress returns an [Iterator] that filters elements from a data [Iterator] returning only those that have a corresponding element in selector [Iterator] that evaluates to `true`.
 // Stops when either the data or selectors iterator has been exhausted.
 func Compress[U any](sel Iterator[bool]) func(Iterator[U]) Iterator[U] {
-	return G.Compress[Iterator[U], Iterator[bool], Iterator[T.Tuple2[U, bool]]](sel)
+	return G.Compress[Iterator[U], Iterator[bool], Iterator[P.Pair[U, bool]]](sel)
 }

iterator/stateless/generic/any.go

@@ -18,11 +18,11 @@ package generic
 import (
 	F "github.com/IBM/fp-go/function"
 	O "github.com/IBM/fp-go/option"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
 // Any returns `true` if any element of the iterable is `true`. If the iterable is empty, return `false`
-func Any[GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(U) bool, U any](pred FCT) func(ma GU) bool {
+func Any[GU ~func() O.Option[P.Pair[GU, U]], FCT ~func(U) bool, U any](pred FCT) func(ma GU) bool {
 	return F.Flow3(
 		Filter[GU](pred),
 		First[GU],

iterator/stateless/generic/bind.go

@@ -20,18 +20,18 @@ import (
 	C "github.com/IBM/fp-go/internal/chain"
 	F "github.com/IBM/fp-go/internal/functor"
 	O "github.com/IBM/fp-go/option"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
 // Bind creates an empty context of type [S] to be used with the [Bind] operation
-func Do[GS ~func() O.Option[T.Tuple2[GS, S]], S any](
+func Do[GS ~func() O.Option[P.Pair[GS, S]], S any](
 	empty S,
 ) GS {
 	return Of[GS](empty)
 }
 
 // Bind attaches the result of a computation to a context [S1] to produce a context [S2]
-func Bind[GS1 ~func() O.Option[T.Tuple2[GS1, S1]], GS2 ~func() O.Option[T.Tuple2[GS2, S2]], GA ~func() O.Option[T.Tuple2[GA, A]], S1, S2, A any](
+func Bind[GS1 ~func() O.Option[P.Pair[GS1, S1]], GS2 ~func() O.Option[P.Pair[GS2, S2]], GA ~func() O.Option[P.Pair[GA, A]], S1, S2, A any](
 	setter func(A) func(S1) S2,
 	f func(S1) GA,
 ) func(GS1) GS2 {
@@ -45,7 +45,7 @@ func Bind[GS1 ~func() O.Option[T.Tuple2[GS1, S1]], GS2 ~func() O.Option[T.Tuple2
 }
 
 // Let attaches the result of a computation to a context [S1] to produce a context [S2]
-func Let[GS1 ~func() O.Option[T.Tuple2[GS1, S1]], GS2 ~func() O.Option[T.Tuple2[GS2, S2]], S1, S2, A any](
+func Let[GS1 ~func() O.Option[P.Pair[GS1, S1]], GS2 ~func() O.Option[P.Pair[GS2, S2]], S1, S2, A any](
 	key func(A) func(S1) S2,
 	f func(S1) A,
 ) func(GS1) GS2 {
@@ -57,7 +57,7 @@ func Let[GS1 ~func() O.Option[T.Tuple2[GS1, S1]], GS2 ~func() O.Option[T.Tuple2[
 }
 
 // LetTo attaches the a value to a context [S1] to produce a context [S2]
-func LetTo[GS1 ~func() O.Option[T.Tuple2[GS1, S1]], GS2 ~func() O.Option[T.Tuple2[GS2, S2]], S1, S2, B any](
+func LetTo[GS1 ~func() O.Option[P.Pair[GS1, S1]], GS2 ~func() O.Option[P.Pair[GS2, S2]], S1, S2, B any](
 	key func(B) func(S1) S2,
 	b B,
 ) func(GS1) GS2 {
@@ -69,7 +69,7 @@ func LetTo[GS1 ~func() O.Option[T.Tuple2[GS1, S1]], GS2 ~func() O.Option[T.Tuple
 }
 
 // BindTo initializes a new state [S1] from a value [T]
-func BindTo[GS1 ~func() O.Option[T.Tuple2[GS1, S1]], GA ~func() O.Option[T.Tuple2[GA, A]], S1, A any](
+func BindTo[GS1 ~func() O.Option[P.Pair[GS1, S1]], GA ~func() O.Option[P.Pair[GA, A]], S1, A any](
 	setter func(A) S1,
 ) func(GA) GS1 {
 	return C.BindTo(
@@ -79,7 +79,7 @@ func BindTo[GS1 ~func() O.Option[T.Tuple2[GS1, S1]], GA ~func() O.Option[T.Tuple
 }
 
 // ApS attaches a value to a context [S1] to produce a context [S2] by considering the context and the value concurrently
-func ApS[GAS2 ~func() O.Option[T.Tuple2[GAS2, func(A) S2]], GS1 ~func() O.Option[T.Tuple2[GS1, S1]], GS2 ~func() O.Option[T.Tuple2[GS2, S2]], GA ~func() O.Option[T.Tuple2[GA, A]], S1, S2, A any](
+func ApS[GAS2 ~func() O.Option[P.Pair[GAS2, func(A) S2]], GS1 ~func() O.Option[P.Pair[GS1, S1]], GS2 ~func() O.Option[P.Pair[GS2, S2]], GA ~func() O.Option[P.Pair[GA, A]], S1, S2, A any](
 	setter func(A) func(S1) S2,
 	fa GA,
 ) func(GS1) GS2 {

iterator/stateless/generic/compress.go

@@ -18,17 +18,17 @@ package generic
 import (
 	F "github.com/IBM/fp-go/function"
 	O "github.com/IBM/fp-go/option"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
 // Compress returns an [Iterator] that filters elements from a data [Iterator] returning only those that have a corresponding element in selector [Iterator] that evaluates to `true`.
 // Stops when either the data or selectors iterator has been exhausted.
-func Compress[GU ~func() O.Option[T.Tuple2[GU, U]], GB ~func() O.Option[T.Tuple2[GB, bool]], CS ~func() O.Option[T.Tuple2[CS, T.Tuple2[U, bool]]], U any](sel GB) func(GU) GU {
+func Compress[GU ~func() O.Option[P.Pair[GU, U]], GB ~func() O.Option[P.Pair[GB, bool]], CS ~func() O.Option[P.Pair[CS, P.Pair[U, bool]]], U any](sel GB) func(GU) GU {
 	return F.Flow2(
 		Zip[GU, GB, CS](sel),
 		FilterMap[GU, CS](F.Flow2(
-			O.FromPredicate(T.Second[U, bool]),
-			O.Map(T.First[U, bool]),
+			O.FromPredicate(P.Tail[U, bool]),
+			O.Map(P.Head[U, bool]),
 		)),
 	)
 }

iterator/stateless/generic/cycle.go

@@ -18,12 +18,12 @@ package generic
 import (
 	F "github.com/IBM/fp-go/function"
 	O "github.com/IBM/fp-go/option"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
-func Cycle[GU ~func() O.Option[T.Tuple2[GU, U]], U any](ma GU) GU {
+func Cycle[GU ~func() O.Option[P.Pair[GU, U]], U any](ma GU) GU {
 	// avoid cyclic references
-	var m func(O.Option[T.Tuple2[GU, U]]) O.Option[T.Tuple2[GU, U]]
+	var m func(O.Option[P.Pair[GU, U]]) O.Option[P.Pair[GU, U]]
 
 	recurse := func(mu GU) GU {
 		return F.Nullary2(
@@ -32,11 +32,11 @@ func Cycle[GU ~func() O.Option[T.Tuple2[GU, U]], U any](ma GU) GU {
 		)
 	}
 
-	m = O.Fold(func() O.Option[T.Tuple2[GU, U]] {
+	m = O.Fold(func() O.Option[P.Pair[GU, U]] {
 		return recurse(ma)()
 	}, F.Flow2(
-		T.Map2(recurse, F.Identity[U]),
-		O.Of[T.Tuple2[GU, U]],
+		P.BiMap(recurse, F.Identity[U]),
+		O.Of[P.Pair[GU, U]],
 	))
 
 	return recurse(ma)

iterator/stateless/generic/dropwhile.go

@@ -18,17 +18,17 @@ package generic
 import (
 	F "github.com/IBM/fp-go/function"
 	O "github.com/IBM/fp-go/option"
-	P "github.com/IBM/fp-go/predicate"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
+	PR "github.com/IBM/fp-go/predicate"
 )
 
 // DropWhile creates an [Iterator] that drops elements from the [Iterator] as long as the predicate is true; afterwards, returns every element.
 // Note, the [Iterator] does not produce any output until the predicate first becomes false
-func DropWhile[GU ~func() O.Option[T.Tuple2[GU, U]], U any](pred func(U) bool) func(GU) GU {
+func DropWhile[GU ~func() O.Option[P.Pair[GU, U]], U any](pred func(U) bool) func(GU) GU {
 	// avoid cyclic references
-	var m func(O.Option[T.Tuple2[GU, U]]) O.Option[T.Tuple2[GU, U]]
+	var m func(O.Option[P.Pair[GU, U]]) O.Option[P.Pair[GU, U]]
 
-	fromPred := O.FromPredicate(P.Not(P.ContraMap(T.Second[GU, U])(pred)))
+	fromPred := O.FromPredicate(PR.Not(PR.ContraMap(P.Tail[GU, U])(pred)))
 
 	recurse := func(mu GU) GU {
 		return F.Nullary2(
@@ -37,11 +37,11 @@ func DropWhile[GU ~func() O.Option[T.Tuple2[GU, U]], U any](pred func(U) bool) f
 		)
 	}
 
-	m = O.Chain(func(t T.Tuple2[GU, U]) O.Option[T.Tuple2[GU, U]] {
+	m = O.Chain(func(t P.Pair[GU, U]) O.Option[P.Pair[GU, U]] {
 		return F.Pipe2(
 			t,
 			fromPred,
-			O.Fold(recurse(Next(t)), O.Of[T.Tuple2[GU, U]]),
+			O.Fold(recurse(Next(t)), O.Of[P.Pair[GU, U]]),
 		)
 	})
 

iterator/stateless/generic/first.go

@@ -18,13 +18,13 @@ package generic
 import (
 	F "github.com/IBM/fp-go/function"
 	O "github.com/IBM/fp-go/option"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
 // First returns the first item in an iterator if such an item exists
-func First[GU ~func() O.Option[T.Tuple2[GU, U]], U any](mu GU) O.Option[U] {
+func First[GU ~func() O.Option[P.Pair[GU, U]], U any](mu GU) O.Option[U] {
 	return F.Pipe1(
 		mu(),
-		O.Map(T.Second[GU, U]),
+		O.Map(P.Tail[GU, U]),
 	)
 }

iterator/stateless/generic/io.go

@@ -19,16 +19,16 @@ import (
 	F "github.com/IBM/fp-go/function"
 	L "github.com/IBM/fp-go/io/generic"
 	O "github.com/IBM/fp-go/option"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
 // FromLazy returns an iterator on top of a lazy function
-func FromLazy[GU ~func() O.Option[T.Tuple2[GU, U]], LZ ~func() U, U any](l LZ) GU {
+func FromLazy[GU ~func() O.Option[P.Pair[GU, U]], LZ ~func() U, U any](l LZ) GU {
 	return F.Pipe1(
 		l,
 		L.Map[LZ, GU](F.Flow2(
-			F.Bind1st(T.MakeTuple2[GU, U], Empty[GU]()),
-			O.Of[T.Tuple2[GU, U]],
+			F.Bind1st(P.MakePair[GU, U], Empty[GU]()),
+			O.Of[P.Pair[GU, U]],
 		)),
 	)
 }

iterator/stateless/generic/iterator.go

@@ -24,45 +24,45 @@ import (
 	M "github.com/IBM/fp-go/monoid"
 	N "github.com/IBM/fp-go/number"
 	O "github.com/IBM/fp-go/option"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
-// Next returns the iterator for the next element in an iterator `T.Tuple2`
-func Next[GU ~func() O.Option[T.Tuple2[GU, U]], U any](m T.Tuple2[GU, U]) GU {
-	return T.First(m)
+// Next returns the iterator for the next element in an iterator `P.Pair`
+func Next[GU ~func() O.Option[P.Pair[GU, U]], U any](m P.Pair[GU, U]) GU {
+	return P.Head(m)
 }
 
-// Current returns the current element in an iterator `T.Tuple2`
-func Current[GU ~func() O.Option[T.Tuple2[GU, U]], U any](m T.Tuple2[GU, U]) U {
-	return T.Second(m)
+// Current returns the current element in an iterator `P.Pair`
+func Current[GU ~func() O.Option[P.Pair[GU, U]], U any](m P.Pair[GU, U]) U {
+	return P.Tail(m)
 }
 
 // From constructs an array from a set of variadic arguments
-func From[GU ~func() O.Option[T.Tuple2[GU, U]], U any](data ...U) GU {
+func From[GU ~func() O.Option[P.Pair[GU, U]], U any](data ...U) GU {
 	return FromArray[GU](data)
 }
 
 // Empty returns the empty iterator
-func Empty[GU ~func() O.Option[T.Tuple2[GU, U]], U any]() GU {
+func Empty[GU ~func() O.Option[P.Pair[GU, U]], U any]() GU {
 	return IO.None[GU]()
 }
 
 // Of returns an iterator with one single element
-func Of[GU ~func() O.Option[T.Tuple2[GU, U]], U any](a U) GU {
-	return IO.Of[GU](T.MakeTuple2(Empty[GU](), a))
+func Of[GU ~func() O.Option[P.Pair[GU, U]], U any](a U) GU {
+	return IO.Of[GU](P.MakePair(Empty[GU](), a))
 }
 
 // FromArray returns an iterator from multiple elements
-func FromArray[GU ~func() O.Option[T.Tuple2[GU, U]], US ~[]U, U any](as US) GU {
+func FromArray[GU ~func() O.Option[P.Pair[GU, U]], US ~[]U, U any](as US) GU {
 	return A.MatchLeft(Empty[GU], func(head U, tail US) GU {
-		return func() O.Option[T.Tuple2[GU, U]] {
-			return O.Of(T.MakeTuple2(FromArray[GU](tail), head))
+		return func() O.Option[P.Pair[GU, U]] {
+			return O.Of(P.MakePair(FromArray[GU](tail), head))
 		}
 	})(as)
 }
 
 // reduce applies a function for each value of the iterator with a floating result
-func reduce[GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](as GU, f func(V, U) V, initial V) V {
+func reduce[GU ~func() O.Option[P.Pair[GU, U]], U, V any](as GU, f func(V, U) V, initial V) V {
 	next, ok := O.Unwrap(as())
 	current := initial
 	for ok {
@@ -74,18 +74,18 @@ func reduce[GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](as GU, f func(V, U)
 }
 
 // Reduce applies a function for each value of the iterator with a floating result
-func Reduce[GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](f func(V, U) V, initial V) func(GU) V {
+func Reduce[GU ~func() O.Option[P.Pair[GU, U]], U, V any](f func(V, U) V, initial V) func(GU) V {
 	return F.Bind23of3(reduce[GU, U, V])(f, initial)
 }
 
 // ToArray converts the iterator to an array
-func ToArray[GU ~func() O.Option[T.Tuple2[GU, U]], US ~[]U, U any](u GU) US {
+func ToArray[GU ~func() O.Option[P.Pair[GU, U]], US ~[]U, U any](u GU) US {
 	return Reduce[GU](A.Append[US], A.Empty[US]())(u)
 }
 
-func Map[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(U) V, U, V any](f FCT) func(ma GU) GV {
+func Map[GV ~func() O.Option[P.Pair[GV, V]], GU ~func() O.Option[P.Pair[GU, U]], FCT ~func(U) V, U, V any](f FCT) func(ma GU) GV {
 	// pre-declare to avoid cyclic reference
-	var m func(O.Option[T.Tuple2[GU, U]]) O.Option[T.Tuple2[GV, V]]
+	var m func(O.Option[P.Pair[GU, U]]) O.Option[P.Pair[GV, V]]
 
 	recurse := func(ma GU) GV {
 		return F.Nullary2(
@@ -94,17 +94,17 @@ func Map[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU,
 		)
 	}
 
-	m = O.Map(T.Map2(recurse, f))
+	m = O.Map(P.BiMap(recurse, f))
 
 	return recurse
 }
 
-func MonadMap[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](ma GU, f func(U) V) GV {
+func MonadMap[GV ~func() O.Option[P.Pair[GV, V]], GU ~func() O.Option[P.Pair[GU, U]], U, V any](ma GU, f func(U) V) GV {
 	return Map[GV, GU](f)(ma)
 }
 
-func concat[GU ~func() O.Option[T.Tuple2[GU, U]], U any](right, left GU) GU {
-	var m func(ma O.Option[T.Tuple2[GU, U]]) O.Option[T.Tuple2[GU, U]]
+func concat[GU ~func() O.Option[P.Pair[GU, U]], U any](right, left GU) GU {
+	var m func(ma O.Option[P.Pair[GU, U]]) O.Option[P.Pair[GU, U]]
 
 	recurse := func(left GU) GU {
 		return F.Nullary2(left, m)
@@ -113,16 +113,16 @@ func concat[GU ~func() O.Option[T.Tuple2[GU, U]], U any](right, left GU) GU {
 	m = O.Fold(
 		right,
 		F.Flow2(
-			T.Map2(recurse, F.Identity[U]),
-			O.Some[T.Tuple2[GU, U]],
+			P.BiMap(recurse, F.Identity[U]),
+			O.Some[P.Pair[GU, U]],
 		))
 
 	return recurse(left)
 }
 
-func Chain[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](f func(U) GV) func(GU) GV {
+func Chain[GV ~func() O.Option[P.Pair[GV, V]], GU ~func() O.Option[P.Pair[GU, U]], U, V any](f func(U) GV) func(GU) GV {
 	// pre-declare to avoid cyclic reference
-	var m func(O.Option[T.Tuple2[GU, U]]) O.Option[T.Tuple2[GV, V]]
+	var m func(O.Option[P.Pair[GU, U]]) O.Option[P.Pair[GV, V]]
 
 	recurse := func(ma GU) GV {
 		return F.Nullary2(
@@ -132,9 +132,9 @@ func Chain[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU
 	}
 	m = O.Chain(
 		F.Flow3(
-			T.Map2(recurse, f),
-			T.Tupled2(concat[GV]),
-			func(v GV) O.Option[T.Tuple2[GV, V]] {
+			P.BiMap(recurse, f),
+			P.Paired(concat[GV]),
+			func(v GV) O.Option[P.Pair[GV, V]] {
 				return v()
 			},
 		),
@@ -143,11 +143,11 @@ func Chain[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU
 	return recurse
 }
 
-func MonadChain[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](ma GU, f func(U) GV) GV {
+func MonadChain[GV ~func() O.Option[P.Pair[GV, V]], GU ~func() O.Option[P.Pair[GU, U]], U, V any](ma GU, f func(U) GV) GV {
 	return Chain[GV, GU](f)(ma)
 }
 
-func MonadChainFirst[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](ma GU, f func(U) GV) GU {
+func MonadChainFirst[GV ~func() O.Option[P.Pair[GV, V]], GU ~func() O.Option[P.Pair[GU, U]], U, V any](ma GU, f func(U) GV) GU {
 	return C.MonadChainFirst(
 		MonadChain[GU, GU, U, U],
 		MonadMap[GU, GV, V, U],
@@ -156,7 +156,7 @@ func MonadChainFirst[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T
 	)
 }
 
-func ChainFirst[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](f func(U) GV) func(GU) GU {
+func ChainFirst[GV ~func() O.Option[P.Pair[GV, V]], GU ~func() O.Option[P.Pair[GU, U]], U, V any](f func(U) GV) func(GU) GU {
 	return C.ChainFirst(
 		Chain[GU, GU, U, U],
 		Map[GU, GV, func(V) U, V, U],
@@ -164,14 +164,14 @@ func ChainFirst[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tupl
 	)
 }
 
-func Flatten[GV ~func() O.Option[T.Tuple2[GV, GU]], GU ~func() O.Option[T.Tuple2[GU, U]], U any](ma GV) GU {
+func Flatten[GV ~func() O.Option[P.Pair[GV, GU]], GU ~func() O.Option[P.Pair[GU, U]], U any](ma GV) GU {
 	return MonadChain(ma, F.Identity[GU])
 }
 
 // MakeBy returns an [Iterator] with an infinite number of elements initialized with `f(i)`
-func MakeBy[GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(int) U, U any](f FCT) GU {
+func MakeBy[GU ~func() O.Option[P.Pair[GU, U]], FCT ~func(int) U, U any](f FCT) GU {
 
-	var m func(int) O.Option[T.Tuple2[GU, U]]
+	var m func(int) O.Option[P.Pair[GU, U]]
 
 	recurse := func(i int) GU {
 		return F.Nullary2(
@@ -181,12 +181,12 @@ func MakeBy[GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(int) U, U any](f FCT
 	}
 
 	m = F.Flow3(
-		T.Replicate2[int],
-		T.Map2(F.Flow2(
+		P.Of[int],
+		P.BiMap(F.Flow2(
 			utils.Inc,
 			recurse),
 			f),
-		O.Of[T.Tuple2[GU, U]],
+		O.Of[P.Pair[GU, U]],
 	)
 
 	// bootstrap
@@ -194,13 +194,13 @@ func MakeBy[GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(int) U, U any](f FCT
 }
 
 // Replicate creates an infinite [Iterator] containing a value.
-func Replicate[GU ~func() O.Option[T.Tuple2[GU, U]], U any](a U) GU {
+func Replicate[GU ~func() O.Option[P.Pair[GU, U]], U any](a U) GU {
 	return MakeBy[GU](F.Constant1[int](a))
 }
 
 // Repeat creates an [Iterator] containing a value repeated the specified number of times.
 // Alias of [Replicate] combined with [Take]
-func Repeat[GU ~func() O.Option[T.Tuple2[GU, U]], U any](n int, a U) GU {
+func Repeat[GU ~func() O.Option[P.Pair[GU, U]], U any](n int, a U) GU {
 	return F.Pipe2(
 		a,
 		Replicate[GU],
@@ -209,13 +209,13 @@ func Repeat[GU ~func() O.Option[T.Tuple2[GU, U]], U any](n int, a U) GU {
 }
 
 // Count creates an [Iterator] containing a consecutive sequence of integers starting with the provided start value
-func Count[GU ~func() O.Option[T.Tuple2[GU, int]]](start int) GU {
+func Count[GU ~func() O.Option[P.Pair[GU, int]]](start int) GU {
 	return MakeBy[GU](N.Add(start))
 }
 
-func FilterMap[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(U) O.Option[V], U, V any](f FCT) func(ma GU) GV {
+func FilterMap[GV ~func() O.Option[P.Pair[GV, V]], GU ~func() O.Option[P.Pair[GU, U]], FCT ~func(U) O.Option[V], U, V any](f FCT) func(ma GU) GV {
 	// pre-declare to avoid cyclic reference
-	var m func(O.Option[T.Tuple2[GU, U]]) O.Option[T.Tuple2[GV, V]]
+	var m func(O.Option[P.Pair[GU, U]]) O.Option[P.Pair[GV, V]]
 
 	recurse := func(ma GU) GV {
 		return F.Nullary2(
@@ -226,11 +226,11 @@ func FilterMap[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple
 
 	m = O.Fold(
 		Empty[GV](),
-		func(t T.Tuple2[GU, U]) O.Option[T.Tuple2[GV, V]] {
+		func(t P.Pair[GU, U]) O.Option[P.Pair[GV, V]] {
 			r := recurse(Next(t))
 			return O.MonadFold(f(Current(t)), r, F.Flow2(
-				F.Bind1st(T.MakeTuple2[GV, V], r),
-				O.Some[T.Tuple2[GV, V]],
+				F.Bind1st(P.MakePair[GV, V], r),
+				O.Some[P.Pair[GV, V]],
 			))
 		},
 	)
@@ -238,26 +238,26 @@ func FilterMap[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple
 	return recurse
 }
 
-func Filter[GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(U) bool, U any](f FCT) func(ma GU) GU {
+func Filter[GU ~func() O.Option[P.Pair[GU, U]], FCT ~func(U) bool, U any](f FCT) func(ma GU) GU {
 	return FilterMap[GU, GU](O.FromPredicate(f))
 }
 
-func Ap[GUV ~func() O.Option[T.Tuple2[GUV, func(U) V]], GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](ma GU) func(fab GUV) GV {
+func Ap[GUV ~func() O.Option[P.Pair[GUV, func(U) V]], GV ~func() O.Option[P.Pair[GV, V]], GU ~func() O.Option[P.Pair[GU, U]], U, V any](ma GU) func(fab GUV) GV {
 	return Chain[GV, GUV](F.Bind1st(MonadMap[GV, GU], ma))
 }
 
-func MonadAp[GUV ~func() O.Option[T.Tuple2[GUV, func(U) V]], GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](fab GUV, ma GU) GV {
+func MonadAp[GUV ~func() O.Option[P.Pair[GUV, func(U) V]], GV ~func() O.Option[P.Pair[GV, V]], GU ~func() O.Option[P.Pair[GU, U]], U, V any](fab GUV, ma GU) GV {
 	return Ap[GUV, GV, GU](ma)(fab)
 }
 
-func FilterChain[GVV ~func() O.Option[T.Tuple2[GVV, GV]], GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(U) O.Option[GV], U, V any](f FCT) func(ma GU) GV {
+func FilterChain[GVV ~func() O.Option[P.Pair[GVV, GV]], GV ~func() O.Option[P.Pair[GV, V]], GU ~func() O.Option[P.Pair[GU, U]], FCT ~func(U) O.Option[GV], U, V any](f FCT) func(ma GU) GV {
 	return F.Flow2(
 		FilterMap[GVV, GU](f),
 		Flatten[GVV],
 	)
 }
 
-func FoldMap[GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(U) V, U, V any](m M.Monoid[V]) func(FCT) func(ma GU) V {
+func FoldMap[GU ~func() O.Option[P.Pair[GU, U]], FCT ~func(U) V, U, V any](m M.Monoid[V]) func(FCT) func(ma GU) V {
 	return func(f FCT) func(ma GU) V {
 		return Reduce[GU](func(cur V, a U) V {
 			return m.Concat(cur, f(a))
@@ -265,6 +265,6 @@ func FoldMap[GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(U) V, U, V any](m M
 	}
 }
 
-func Fold[GU ~func() O.Option[T.Tuple2[GU, U]], U any](m M.Monoid[U]) func(ma GU) U {
+func Fold[GU ~func() O.Option[P.Pair[GU, U]], U any](m M.Monoid[U]) func(ma GU) U {
 	return Reduce[GU](m.Concat, m.Empty())
 }

iterator/stateless/generic/last.go

@@ -18,10 +18,10 @@ package generic
 import (
 	F "github.com/IBM/fp-go/function"
 	O "github.com/IBM/fp-go/option"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
 // Last returns the last item in an iterator if such an item exists
-func Last[GU ~func() O.Option[T.Tuple2[GU, U]], U any](mu GU) O.Option[U] {
+func Last[GU ~func() O.Option[P.Pair[GU, U]], U any](mu GU) O.Option[U] {
 	return reduce(mu, F.Ignore1of2[O.Option[U]](O.Of[U]), O.None[U]())
 }

iterator/stateless/generic/monad.go

@@ -18,10 +18,10 @@ package generic
 import (
 	"github.com/IBM/fp-go/internal/monad"
 	O "github.com/IBM/fp-go/option"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
-type iteratorMonad[A, B any, GA ~func() O.Option[T.Tuple2[GA, A]], GB ~func() O.Option[T.Tuple2[GB, B]], GAB ~func() O.Option[T.Tuple2[GAB, func(A) B]]] struct{}
+type iteratorMonad[A, B any, GA ~func() O.Option[P.Pair[GA, A]], GB ~func() O.Option[P.Pair[GB, B]], GAB ~func() O.Option[P.Pair[GAB, func(A) B]]] struct{}
 
 func (o *iteratorMonad[A, B, GA, GB, GAB]) Of(a A) GA {
 	return Of[GA, A](a)
@@ -40,6 +40,6 @@ func (o *iteratorMonad[A, B, GA, GB, GAB]) Ap(fa GA) func(GAB) GB {
 }
 
 // Monad implements the monadic operations for iterators
-func Monad[A, B any, GA ~func() O.Option[T.Tuple2[GA, A]], GB ~func() O.Option[T.Tuple2[GB, B]], GAB ~func() O.Option[T.Tuple2[GAB, func(A) B]]]() monad.Monad[A, B, GA, GB, GAB] {
+func Monad[A, B any, GA ~func() O.Option[P.Pair[GA, A]], GB ~func() O.Option[P.Pair[GB, B]], GAB ~func() O.Option[P.Pair[GAB, func(A) B]]]() monad.Monad[A, B, GA, GB, GAB] {
 	return &iteratorMonad[A, B, GA, GB, GAB]{}
 }

iterator/stateless/generic/monoid.go

@@ -19,10 +19,10 @@ import (
 	F "github.com/IBM/fp-go/function"
 	M "github.com/IBM/fp-go/monoid"
 	O "github.com/IBM/fp-go/option"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
-func Monoid[GU ~func() O.Option[T.Tuple2[GU, U]], U any]() M.Monoid[GU] {
+func Monoid[GU ~func() O.Option[P.Pair[GU, U]], U any]() M.Monoid[GU] {
 	return M.MakeMonoid(
 		F.Swap(concat[GU]),
 		Empty[GU](),

iterator/stateless/generic/reflect.go

@@ -24,10 +24,10 @@ import (
 	N "github.com/IBM/fp-go/number"
 	I "github.com/IBM/fp-go/number/integer"
 	O "github.com/IBM/fp-go/option"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
-func FromReflect[GR ~func() O.Option[T.Tuple2[GR, R.Value]]](val R.Value) GR {
+func FromReflect[GR ~func() O.Option[P.Pair[GR, R.Value]]](val R.Value) GR {
 	// recursive callback
 	var recurse func(idx int) GR
 
@@ -41,8 +41,8 @@ func FromReflect[GR ~func() O.Option[T.Tuple2[GR, R.Value]]](val R.Value) GR {
 			L.Map(fromPred),
 			LG.Map[L.Lazy[O.Option[int]], GR](O.Map(
 				F.Flow2(
-					T.Replicate2[int],
-					T.Map2(F.Flow2(N.Add(1), recurse), val.Index),
+					P.Of[int],
+					P.BiMap(F.Flow2(N.Add(1), recurse), val.Index),
 				),
 			)),
 		)

iterator/stateless/generic/scan.go

@@ -18,14 +18,14 @@ package generic
 import (
 	F "github.com/IBM/fp-go/function"
 	O "github.com/IBM/fp-go/option"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
-func apTuple[A, B any](t T.Tuple2[func(A) B, A]) T.Tuple2[B, A] {
-	return T.MakeTuple2(t.F1(t.F2), t.F2)
+func apTuple[A, B any](t P.Pair[func(A) B, A]) P.Pair[B, A] {
+	return P.MakePair(P.Head(t)(P.Tail(t)), P.Tail(t))
 }
 
-func Scan[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(V, U) V, U, V any](f FCT, initial V) func(ma GU) GV {
+func Scan[GV ~func() O.Option[P.Pair[GV, V]], GU ~func() O.Option[P.Pair[GU, U]], FCT ~func(V, U) V, U, V any](f FCT, initial V) func(ma GU) GV {
 	// pre-declare to avoid cyclic reference
 	var m func(GU) func(V) GV
 
@@ -33,7 +33,7 @@ func Scan[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU,
 		return F.Nullary2(
 			ma,
 			O.Map(F.Flow2(
-				T.Map2(m, F.Bind1st(f, current)),
+				P.BiMap(m, F.Bind1st(f, current)),
 				apTuple[V, GV],
 			)),
 		)

iterator/stateless/generic/take.go

@@ -19,10 +19,10 @@ import (
 	F "github.com/IBM/fp-go/function"
 	N "github.com/IBM/fp-go/number/integer"
 	O "github.com/IBM/fp-go/option"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
-func Take[GU ~func() O.Option[T.Tuple2[GU, U]], U any](n int) func(ma GU) GU {
+func Take[GU ~func() O.Option[P.Pair[GU, U]], U any](n int) func(ma GU) GU {
 	// pre-declare to avoid cyclic reference
 	var recurse func(ma GU, idx int) GU
 
@@ -34,7 +34,7 @@ func Take[GU ~func() O.Option[T.Tuple2[GU, U]], U any](n int) func(ma GU) GU {
 			fromPred,
 			O.Chain(F.Ignore1of1[int](F.Nullary2(
 				ma,
-				O.Map(T.Map2(F.Bind2nd(recurse, idx+1), F.Identity[U])),
+				O.Map(P.BiMap(F.Bind2nd(recurse, idx+1), F.Identity[U])),
 			))),
 		)
 	}

iterator/stateless/generic/uniq.go

@@ -18,7 +18,7 @@ package generic
 import (
 	F "github.com/IBM/fp-go/function"
 	O "github.com/IBM/fp-go/option"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
 // addToMap makes a deep copy of a map and adds a value
@@ -31,23 +31,23 @@ func addToMap[A comparable](a A, m map[A]bool) map[A]bool {
 	return cpy
 }
 
-func Uniq[AS ~func() O.Option[T.Tuple2[AS, A]], K comparable, A any](f func(A) K) func(as AS) AS {
+func Uniq[AS ~func() O.Option[P.Pair[AS, A]], K comparable, A any](f func(A) K) func(as AS) AS {
 
 	var recurse func(as AS, mp map[K]bool) AS
 
 	recurse = func(as AS, mp map[K]bool) AS {
 		return F.Nullary2(
 			as,
-			O.Chain(func(a T.Tuple2[AS, A]) O.Option[T.Tuple2[AS, A]] {
+			O.Chain(func(a P.Pair[AS, A]) O.Option[P.Pair[AS, A]] {
 				return F.Pipe3(
-					a.F2,
+					P.Tail(a),
 					f,
 					O.FromPredicate(func(k K) bool {
 						_, ok := mp[k]
 						return !ok
 					}),
-					O.Fold(recurse(a.F1, mp), func(k K) O.Option[T.Tuple2[AS, A]] {
-						return O.Of(T.MakeTuple2(recurse(a.F1, addToMap(k, mp)), a.F2))
+					O.Fold(recurse(P.Head(a), mp), func(k K) O.Option[P.Pair[AS, A]] {
+						return O.Of(P.MakePair(recurse(P.Head(a), addToMap(k, mp)), P.Tail(a)))
 					}),
 				)
 			}),
@@ -57,6 +57,6 @@ func Uniq[AS ~func() O.Option[T.Tuple2[AS, A]], K comparable, A any](f func(A) K
 	return F.Bind2nd(recurse, make(map[K]bool, 0))
 }
 
-func StrictUniq[AS ~func() O.Option[T.Tuple2[AS, A]], A comparable](as AS) AS {
+func StrictUniq[AS ~func() O.Option[P.Pair[AS, A]], A comparable](as AS) AS {
 	return Uniq[AS](F.Identity[A])(as)
 }

iterator/stateless/generic/zip.go

@@ -18,29 +18,29 @@ package generic
 import (
 	F "github.com/IBM/fp-go/function"
 	O "github.com/IBM/fp-go/option"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
 // ZipWith applies a function to pairs of elements at the same index in two iterators, collecting the results in a new iterator. If one
 // input iterator is short, excess elements of the longer iterator are discarded.
-func ZipWith[AS ~func() O.Option[T.Tuple2[AS, A]], BS ~func() O.Option[T.Tuple2[BS, B]], CS ~func() O.Option[T.Tuple2[CS, C]], FCT ~func(A, B) C, A, B, C any](fa AS, fb BS, f FCT) CS {
+func ZipWith[AS ~func() O.Option[P.Pair[AS, A]], BS ~func() O.Option[P.Pair[BS, B]], CS ~func() O.Option[P.Pair[CS, C]], FCT ~func(A, B) C, A, B, C any](fa AS, fb BS, f FCT) CS {
 	// pre-declare to avoid cyclic reference
-	var m func(T.Tuple2[O.Option[T.Tuple2[AS, A]], O.Option[T.Tuple2[BS, B]]]) O.Option[T.Tuple2[CS, C]]
+	var m func(P.Pair[O.Option[P.Pair[AS, A]], O.Option[P.Pair[BS, B]]]) O.Option[P.Pair[CS, C]]
 
 	recurse := func(as AS, bs BS) CS {
-		return func() O.Option[T.Tuple2[CS, C]] {
+		return func() O.Option[P.Pair[CS, C]] {
 			// combine
 			return F.Pipe1(
-				T.MakeTuple2(as(), bs()),
+				P.MakePair(as(), bs()),
 				m,
 			)
 		}
 	}
 
 	m = F.Flow2(
-		O.SequenceTuple2[T.Tuple2[AS, A], T.Tuple2[BS, B]],
-		O.Map(func(t T.Tuple2[T.Tuple2[AS, A], T.Tuple2[BS, B]]) T.Tuple2[CS, C] {
-			return T.MakeTuple2(recurse(t.F1.F1, t.F2.F1), f(t.F1.F2, t.F2.F2))
+		O.SequencePair[P.Pair[AS, A], P.Pair[BS, B]],
+		O.Map(func(t P.Pair[P.Pair[AS, A], P.Pair[BS, B]]) P.Pair[CS, C] {
+			return P.MakePair(recurse(P.Head(P.Head(t)), P.Head(P.Tail(t))), f(P.Tail(P.Head(t)), P.Tail(P.Tail(t))))
 		}))
 
 	// trigger the recursion
@@ -49,6 +49,6 @@ func ZipWith[AS ~func() O.Option[T.Tuple2[AS, A]], BS ~func() O.Option[T.Tuple2[
 
 // Zip takes two iterators and returns an iterators of corresponding pairs. If one input iterators is short, excess elements of the
 // longer iterator are discarded
-func Zip[AS ~func() O.Option[T.Tuple2[AS, A]], BS ~func() O.Option[T.Tuple2[BS, B]], CS ~func() O.Option[T.Tuple2[CS, T.Tuple2[A, B]]], A, B any](fb BS) func(AS) CS {
-	return F.Bind23of3(ZipWith[AS, BS, CS, func(A, B) T.Tuple2[A, B]])(fb, T.MakeTuple2[A, B])
+func Zip[AS ~func() O.Option[P.Pair[AS, A]], BS ~func() O.Option[P.Pair[BS, B]], CS ~func() O.Option[P.Pair[CS, P.Pair[A, B]]], A, B any](fb BS) func(AS) CS {
+	return F.Bind23of3(ZipWith[AS, BS, CS, func(A, B) P.Pair[A, B]])(fb, P.MakePair[A, B])
 }

iterator/stateless/iterator.go

@@ -20,19 +20,19 @@ import (
 	L "github.com/IBM/fp-go/lazy"
 	M "github.com/IBM/fp-go/monoid"
 	O "github.com/IBM/fp-go/option"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
 // Iterator represents a stateless, pure way to iterate over a sequence
-type Iterator[U any] L.Lazy[O.Option[T.Tuple2[Iterator[U], U]]]
+type Iterator[U any] L.Lazy[O.Option[P.Pair[Iterator[U], U]]]
 
-// Next returns the [Iterator] for the next element in an iterator `T.Tuple2`
-func Next[U any](m T.Tuple2[Iterator[U], U]) Iterator[U] {
+// Next returns the [Iterator] for the next element in an iterator `P.Pair`
+func Next[U any](m P.Pair[Iterator[U], U]) Iterator[U] {
 	return G.Next(m)
 }
 
-// Current returns the current element in an [Iterator] `T.Tuple2`
-func Current[U any](m T.Tuple2[Iterator[U], U]) U {
+// Current returns the current element in an [Iterator] `P.Pair`
+func Current[U any](m P.Pair[Iterator[U], U]) U {
 	return G.Current(m)
 }
 

iterator/stateless/scan_test.go

@@ -19,7 +19,7 @@ import (
 	"testing"
 
 	F "github.com/IBM/fp-go/function"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -29,14 +29,14 @@ func TestScan(t *testing.T) {
 
 	dst := F.Pipe1(
 		src,
-		Scan(func(cur T.Tuple2[int, string], val string) T.Tuple2[int, string] {
-			return T.MakeTuple2(cur.F1+1, val)
-		}, T.MakeTuple2(0, "")),
+		Scan(func(cur P.Pair[int, string], val string) P.Pair[int, string] {
+			return P.MakePair(P.Head(cur)+1, val)
+		}, P.MakePair(0, "")),
 	)
 
 	assert.Equal(t, ToArray(From(
-		T.MakeTuple2(1, "a"),
-		T.MakeTuple2(2, "b"),
-		T.MakeTuple2(3, "c"),
+		P.MakePair(1, "a"),
+		P.MakePair(2, "b"),
+		P.MakePair(3, "c"),
 	)), ToArray(dst))
 }

iterator/stateless/zip.go

@@ -17,7 +17,7 @@ package stateless
 
 import (
 	G "github.com/IBM/fp-go/iterator/stateless/generic"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
 // ZipWith applies a function to pairs of elements at the same index in two iterators, collecting the results in a new iterator. If one
@@ -28,6 +28,6 @@ func ZipWith[FCT ~func(A, B) C, A, B, C any](fa Iterator[A], fb Iterator[B], f F
 
 // Zip takes two iterators and returns an iterators of corresponding pairs. If one input iterators is short, excess elements of the
 // longer iterator are discarded
-func Zip[A, B any](fb Iterator[B]) func(Iterator[A]) Iterator[T.Tuple2[A, B]] {
-	return G.Zip[Iterator[A], Iterator[B], Iterator[T.Tuple2[A, B]]](fb)
+func Zip[A, B any](fb Iterator[B]) func(Iterator[A]) Iterator[P.Pair[A, B]] {
+	return G.Zip[Iterator[A], Iterator[B], Iterator[P.Pair[A, B]]](fb)
 }

iterator/stateless/zip_test.go

@@ -19,7 +19,7 @@ import (
 	"fmt"
 	"testing"
 
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -40,5 +40,5 @@ func TestZip(t *testing.T) {
 
 	res := Zip[string](left)(right)
 
-	assert.Equal(t, ToArray(From(T.MakeTuple2("a", 1), T.MakeTuple2("b", 2), T.MakeTuple2("c", 3))), ToArray(res))
+	assert.Equal(t, ToArray(From(P.MakePair("a", 1), P.MakePair("b", 2), P.MakePair("c", 3))), ToArray(res))
 }

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
 

option/pair.go

@@ -0,0 +1,30 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package option
+
+import (
+	P "github.com/IBM/fp-go/pair"
+	PG "github.com/IBM/fp-go/pair/generic"
+)
+
+// SequencePair converts a [Pair] of [Option[T]] into an [Option[Pair]].
+func SequencePair[T1, T2 any](t P.Pair[Option[T1], Option[T2]]) Option[P.Pair[T1, T2]] {
+	return PG.SequencePair(
+		Map[T1, func(T2) P.Pair[T1, T2]],
+		Ap[P.Pair[T1, T2], T2],
+		t,
+	)
+}

pair/generic/sequence.go

@@ -0,0 +1,71 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	F "github.com/IBM/fp-go/function"
+	P "github.com/IBM/fp-go/pair"
+)
+
+// SequencePair is a utility function used to implement the sequence operation for higher kinded types based only on map and ap.
+// The function takes a [Pair] of higher higher kinded types and returns a higher kinded type of a [Pair] with the resolved values.
+func SequencePair[
+	MAP ~func(func(T1) func(T2) P.Pair[T1, T2]) func(HKT_T1) HKT_F_T2,
+	AP1 ~func(HKT_T2) func(HKT_F_T2) HKT_PAIR,
+	T1,
+	T2,
+	HKT_T1, // HKT[T1]
+	HKT_T2, // HKT[T2]
+	HKT_F_T2, // HKT[func(T2) P.Pair[T1, T2]]
+	HKT_PAIR any, // HKT[Pair[T1, T2]]
+](
+	fmap MAP,
+	fap1 AP1,
+	t P.Pair[HKT_T1, HKT_T2],
+) HKT_PAIR {
+	return F.Pipe2(
+		P.Head(t),
+		fmap(F.Curry2(P.MakePair[T1, T2])),
+		fap1(P.Tail(t)),
+	)
+}
+
+// TraversePair is a utility function used to implement the sequence operation for higher kinded types based only on map and ap.
+// The function takes a [Pair] of base types and 2 functions that transform these based types into higher higher kinded types. It returns a higher kinded type of a [Pair] with the resolved values.
+func TraversePair[
+	MAP ~func(func(T1) func(T2) P.Pair[T1, T2]) func(HKT_T1) HKT_F_T2,
+	AP1 ~func(HKT_T2) func(HKT_F_T2) HKT_PAIR,
+	F1 ~func(A1) HKT_T1,
+	F2 ~func(A2) HKT_T2,
+	A1, T1,
+	A2, T2,
+	HKT_T1, // HKT[T1]
+	HKT_T2, // HKT[T2]
+	HKT_F_T2, // HKT[func(T2) P.Pair[T1, T2]]
+	HKT_PAIR any, // HKT[Pair[T1, T2]]
+](
+	fmap MAP,
+	fap1 AP1,
+	f1 F1,
+	f2 F2,
+	t P.Pair[A1, A2],
+) HKT_PAIR {
+	return F.Pipe2(
+		f1(P.Head(t)),
+		fmap(F.Curry2(P.MakePair[T1, T2])),
+		fap1(f2(P.Tail(t))),
+	)
+}

pair/pair.go

@@ -25,7 +25,7 @@ import (
 
 type (
 	pair struct {
-		head, Tail any
+		h, t any
 	}
 
 	// Pair defines a data structure that holds two strongly typed values
@@ -36,7 +36,7 @@ type (
 //
 // go:noinline
 func pairString(s *pair) string {
-	return fmt.Sprintf("Pair[%T, %t](%v, %v)", s.head, s.Tail, s.head, s.Tail)
+	return fmt.Sprintf("Pair[%T, %t](%v, %v)", s.h, s.t, s.h, s.t)
 }
 
 // Format prints some debug info for the object
@@ -63,12 +63,12 @@ func (s Pair[A, B]) Format(f fmt.State, c rune) {
 
 // Of creates a [Pair] with the same value to to both fields
 func Of[A any](value A) Pair[A, A] {
-	return Pair[A, A]{head: value, Tail: value}
+	return Pair[A, A]{h: value, t: value}
 }
 
 // FromTuple creates a [Pair] from a [T.Tuple2]
 func FromTuple[A, B any](t T.Tuple2[A, B]) Pair[A, B] {
-	return Pair[A, B]{head: t.F1, Tail: t.F2}
+	return Pair[A, B]{h: t.F1, t: t.F2}
 }
 
 // ToTuple creates a [T.Tuple2] from a [Pair]
@@ -78,22 +78,22 @@ func ToTuple[A, B any](t Pair[A, B]) T.Tuple2[A, B] {
 
 // MakePair creates a [Pair] from two values
 func MakePair[A, B any](a A, b B) Pair[A, B] {
-	return Pair[A, B]{head: a, Tail: b}
+	return Pair[A, B]{h: a, t: b}
 }
 
 // Head returns the head value of the pair
 func Head[A, B any](fa Pair[A, B]) A {
-	return fa.head.(A)
+	return fa.h.(A)
 }
 
 // Tail returns the head value of the pair
 func Tail[A, B any](fa Pair[A, B]) B {
-	return fa.Tail.(B)
+	return fa.t.(B)
 }
 
 // MonadMapHead maps the head value
 func MonadMapHead[B, A, A1 any](fa Pair[A, B], f func(A) A1) Pair[A1, B] {
-	return Pair[A1, B]{f(Head(fa)), fa.Tail}
+	return Pair[A1, B]{f(Head(fa)), fa.t}
 }
 
 // MonadMap maps the head value
@@ -103,7 +103,7 @@ func MonadMap[B, A, A1 any](fa Pair[A, B], f func(A) A1) Pair[A1, B] {
 
 // MonadMapTail maps the Tail value
 func MonadMapTail[A, B, B1 any](fa Pair[A, B], f func(B) B1) Pair[A, B1] {
-	return Pair[A, B1]{fa.head, f(Tail(fa))}
+	return Pair[A, B1]{fa.h, f(Tail(fa))}
 }
 
 // MonadBiMap maps both values
@@ -136,13 +136,13 @@ func BiMap[A, B, A1, B1 any](f func(A) A1, g func(B) B1) func(Pair[A, B]) Pair[A
 // MonadChainHead chains on the head value
 func MonadChainHead[B, A, A1 any](sg Sg.Semigroup[B], fa Pair[A, B], f func(A) Pair[A1, B]) Pair[A1, B] {
 	fb := f(Head(fa))
-	return Pair[A1, B]{fb.head, sg.Concat(Tail(fa), Tail(fb))}
+	return Pair[A1, B]{fb.h, sg.Concat(Tail(fa), Tail(fb))}
 }
 
 // MonadChainTail chains on the Tail value
 func MonadChainTail[A, B, B1 any](sg Sg.Semigroup[A], fb Pair[A, B], f func(B) Pair[A, B1]) Pair[A, B1] {
 	fa := f(Tail(fb))
-	return Pair[A, B1]{sg.Concat(Head(fb), Head(fa)), fa.Tail}
+	return Pair[A, B1]{sg.Concat(Head(fb), Head(fa)), fa.t}
 }
 
 // MonadChain chains on the head value
@@ -202,3 +202,30 @@ func ApTail[A, B, B1 any](sg Sg.Semigroup[A], fb Pair[A, B]) func(Pair[A, func(B
 func Ap[B, A, A1 any](sg Sg.Semigroup[B], fa Pair[A, B]) func(Pair[func(A) A1, B]) Pair[A1, B] {
 	return ApHead[B, A, A1](sg, fa)
 }
+
+// Swap swaps the two channels
+func Swap[A, B any](fa Pair[A, B]) Pair[B, A] {
+	return MakePair(Tail(fa), Head(fa))
+}
+
+// Paired converts a function with 2 parameters into a function taking a [Pair]
+// The inverse function is [Unpaired]
+func Paired[F ~func(T1, T2) R, T1, T2, R any](f F) func(Pair[T1, T2]) R {
+	return func(t Pair[T1, T2]) R {
+		return f(Head(t), Tail(t))
+	}
+}
+
+// Unpaired converts a function with a [Pair] parameter into a function with 2 parameters
+// The inverse function is [Paired]
+func Unpaired[F ~func(Pair[T1, T2]) R, T1, T2, R any](f F) func(T1, T2) R {
+	return func(t1 T1, t2 T2) R {
+		return f(MakePair(t1, t2))
+	}
+}
+
+func Merge[F ~func(B) func(A) R, A, B, R any](f F) func(Pair[A, B]) R {
+	return func(p Pair[A, B]) R {
+		return f(Tail(p))(Head(p))
+	}
+}

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
 

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]

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
 

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 (

readerioeither/generic/reader.go

@@ -449,3 +449,15 @@ func MonadMapLeft[GREA1 ~func(R) GEA1, GREA2 ~func(R) GEA2, GEA1 ~func() ET.Eith
 func MapLeft[GREA1 ~func(R) GEA1, GREA2 ~func(R) GEA2, GEA1 ~func() ET.Either[E1, A], GEA2 ~func() ET.Either[E2, A], R, E1, E2, A any](f func(E1) E2) func(GREA1) GREA2 {
 	return F.Bind2nd(MonadMapLeft[GREA1, GREA2], f)
 }
+
+// Local changes the value of the local context during the execution of the action `ma` (similar to `Contravariant`'s
+// `contramap`).
+func Local[
+	GEA1 ~func(R1) GIOA,
+	GEA2 ~func(R2) GIOA,
+
+	GIOA ~func() ET.Either[E, A],
+	R1, R2, E, A any,
+](f func(R2) R1) func(GEA1) GEA2 {
+	return RD.Local[GEA1, GEA2](f)
+}

readerioeither/reader.go

@@ -289,3 +289,9 @@ func MonadMapLeft[R, E1, E2, A any](fa ReaderIOEither[R, E1, A], f func(E1) E2)
 func MapLeft[R, A, E1, E2 any](f func(E1) E2) func(ReaderIOEither[R, E1, A]) ReaderIOEither[R, E2, A] {
 	return G.MapLeft[ReaderIOEither[R, E1, A], ReaderIOEither[R, E2, A]](f)
 }
+
+// Local changes the value of the local context during the execution of the action `ma` (similar to `Contravariant`'s
+// `contramap`).
+func Local[R1, R2, E, A any](f func(R2) R1) func(ReaderIOEither[R1, E, A]) ReaderIOEither[R2, E, A] {
+	return G.Local[ReaderIOEither[R1, E, A], ReaderIOEither[R2, E, A]](f)
+}

scan.bat

@@ -0,0 +1,3 @@
+@echo off
+
+busybox find . -type f -name "*\.go" | busybox xargs gopls check

state/eq.go

@@ -0,0 +1,31 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package state
+
+import (
+	EQ "github.com/IBM/fp-go/eq"
+	G "github.com/IBM/fp-go/state/generic"
+)
+
+// Constructs an equal predicate for a [State]
+func Eq[S, A any](w EQ.Eq[S], a EQ.Eq[A]) func(S) EQ.Eq[State[S, A]] {
+	return G.Eq[State[S, A]](w, a)
+}
+
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
+func FromStrictEquals[S, A comparable]() func(S) EQ.Eq[State[S, A]] {
+	return G.FromStrictEquals[State[S, A]]()
+}

state/generic/eq.go

@@ -0,0 +1,36 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	EQ "github.com/IBM/fp-go/eq"
+	P "github.com/IBM/fp-go/pair"
+)
+
+// Constructs an equal predicate for a [State]
+func Eq[GA ~func(S) P.Pair[A, S], S, A any](w EQ.Eq[S], a EQ.Eq[A]) func(S) EQ.Eq[GA] {
+	eqp := P.Eq(a, w)
+	return func(s S) EQ.Eq[GA] {
+		return EQ.FromEquals(func(l, r GA) bool {
+			return eqp.Equals(l(s), r(s))
+		})
+	}
+}
+
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
+func FromStrictEquals[GA ~func(S) P.Pair[A, S], S, A comparable]() func(S) EQ.Eq[GA] {
+	return Eq[GA](EQ.FromStrictEquals[S](), EQ.FromStrictEquals[A]())
+}

state/generic/monad.go

@@ -0,0 +1,88 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	"github.com/IBM/fp-go/internal/applicative"
+	"github.com/IBM/fp-go/internal/functor"
+	"github.com/IBM/fp-go/internal/monad"
+	"github.com/IBM/fp-go/internal/pointed"
+	P "github.com/IBM/fp-go/pair"
+)
+
+type statePointed[GA ~func(S) P.Pair[A, S], S, A any] struct{}
+
+type stateFunctor[GB ~func(S) P.Pair[B, S], GA ~func(S) P.Pair[A, S], S, A, B any] struct{}
+
+type stateApplicative[GB ~func(S) P.Pair[B, S], GAB ~func(S) P.Pair[func(A) B, S], GA ~func(S) P.Pair[A, S], S, A, B any] struct{}
+
+type stateMonad[GB ~func(S) P.Pair[B, S], GAB ~func(S) P.Pair[func(A) B, S], GA ~func(S) P.Pair[A, S], S, A, B any] struct{}
+
+func (o *statePointed[GA, S, A]) Of(a A) GA {
+	return Of[GA](a)
+}
+
+func (o *stateApplicative[GB, GAB, GA, S, A, B]) Of(a A) GA {
+	return Of[GA](a)
+}
+
+func (o *stateMonad[GB, GAB, GA, S, A, B]) Of(a A) GA {
+	return Of[GA](a)
+}
+
+func (o *stateFunctor[GB, GA, S, A, B]) Map(f func(A) B) func(GA) GB {
+	return Map[GB, GA](f)
+}
+
+func (o *stateApplicative[GB, GAB, GA, S, A, B]) Map(f func(A) B) func(GA) GB {
+	return Map[GB, GA](f)
+}
+
+func (o *stateMonad[GB, GAB, GA, S, A, B]) Map(f func(A) B) func(GA) GB {
+	return Map[GB, GA](f)
+}
+
+func (o *stateMonad[GB, GAB, GA, S, A, B]) Chain(f func(A) GB) func(GA) GB {
+	return Chain[GB, GA](f)
+}
+
+func (o *stateApplicative[GB, GAB, GA, S, A, B]) Ap(fa GA) func(GAB) GB {
+	return Ap[GB, GAB, GA](fa)
+}
+
+func (o *stateMonad[GB, GAB, GA, S, A, B]) Ap(fa GA) func(GAB) GB {
+	return Ap[GB, GAB, GA](fa)
+}
+
+// Pointed implements the pointed operations for [Writer]
+func Pointed[GA ~func(S) P.Pair[A, S], S, A any]() pointed.Pointed[A, GA] {
+	return &statePointed[GA, S, A]{}
+}
+
+// Functor implements the functor operations for [Writer]
+func Functor[GB ~func(S) P.Pair[B, S], GA ~func(S) P.Pair[A, S], S, A, B any]() functor.Functor[A, B, GA, GB] {
+	return &stateFunctor[GB, GA, S, A, B]{}
+}
+
+// Applicative implements the applicative operations for [Writer]
+func Applicative[GB ~func(S) P.Pair[B, S], GAB ~func(S) P.Pair[func(A) B, S], GA ~func(S) P.Pair[A, S], S, A, B any]() applicative.Applicative[A, B, GA, GB, GAB] {
+	return &stateApplicative[GB, GAB, GA, S, A, B]{}
+}
+
+// Monad implements the monadic operations for [Writer]
+func Monad[GB ~func(S) P.Pair[B, S], GAB ~func(S) P.Pair[func(A) B, S], GA ~func(S) P.Pair[A, S], S, A, B any]() monad.Monad[A, B, GA, GB, GAB] {
+	return &stateMonad[GB, GAB, GA, S, A, B]{}
+}

state/generic/state.go

@@ -0,0 +1,131 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	F "github.com/IBM/fp-go/function"
+	C "github.com/IBM/fp-go/internal/chain"
+	FC "github.com/IBM/fp-go/internal/functor"
+	P "github.com/IBM/fp-go/pair"
+)
+
+var (
+	undefined any = struct{}{}
+)
+
+func Get[GA ~func(S) P.Pair[S, S], S any]() GA {
+	return P.Of[S]
+}
+
+func Gets[GA ~func(S) P.Pair[A, S], FCT ~func(S) A, A, S any](f FCT) GA {
+	return func(s S) P.Pair[A, S] {
+		return P.MakePair(f(s), s)
+	}
+}
+
+func Put[GA ~func(S) P.Pair[any, S], S any]() GA {
+	return F.Bind1st(P.MakePair[any, S], undefined)
+}
+
+func Modify[GA ~func(S) P.Pair[any, S], FCT ~func(S) S, S any](f FCT) GA {
+	return F.Flow2(
+		f,
+		F.Bind1st(P.MakePair[any, S], undefined),
+	)
+}
+
+func Of[GA ~func(S) P.Pair[A, S], S, A any](a A) GA {
+	return F.Bind1st(P.MakePair[A, S], a)
+}
+
+func MonadMap[GB ~func(S) P.Pair[B, S], GA ~func(S) P.Pair[A, S], FCT ~func(A) B, S, A, B any](fa GA, f FCT) GB {
+	return func(s S) P.Pair[B, S] {
+		p2 := fa(s)
+		return P.MakePair(f(P.Head(p2)), P.Tail(p2))
+	}
+}
+
+func Map[GB ~func(S) P.Pair[B, S], GA ~func(S) P.Pair[A, S], FCT ~func(A) B, S, A, B any](f FCT) func(GA) GB {
+	return F.Bind2nd(MonadMap[GB, GA, FCT, S, A, B], f)
+}
+
+func MonadChain[GB ~func(S) P.Pair[B, S], GA ~func(S) P.Pair[A, S], FCT ~func(A) GB, S, A, B any](fa GA, f FCT) GB {
+	return func(s S) P.Pair[B, S] {
+		a := fa(s)
+		return f(P.Head(a))(P.Tail(a))
+	}
+}
+
+func Chain[GB ~func(S) P.Pair[B, S], GA ~func(S) P.Pair[A, S], FCT ~func(A) GB, S, A, B any](f FCT) func(GA) GB {
+	return F.Bind2nd(MonadChain[GB, GA, FCT, S, A, B], f)
+}
+
+func MonadAp[GB ~func(S) P.Pair[B, S], GAB ~func(S) P.Pair[func(A) B, S], GA ~func(S) P.Pair[A, S], S, A, B any](fab GAB, fa GA) GB {
+	return func(s S) P.Pair[B, S] {
+		f := fab(s)
+		a := fa(P.Tail(f))
+
+		return P.MakePair(P.Head(f)(P.Head(a)), P.Tail(a))
+	}
+}
+
+func Ap[GB ~func(S) P.Pair[B, S], GAB ~func(S) P.Pair[func(A) B, S], GA ~func(S) P.Pair[A, S], S, A, B any](ga GA) func(GAB) GB {
+	return F.Bind2nd(MonadAp[GB, GAB, GA, S, A, B], ga)
+}
+
+func MonadChainFirst[GB ~func(S) P.Pair[B, S], GA ~func(S) P.Pair[A, S], FCT ~func(A) GB, S, A, B any](ma GA, f FCT) GA {
+	return C.MonadChainFirst(
+		MonadChain[GA, GA, func(A) GA],
+		MonadMap[GA, GB, func(B) A],
+		ma,
+		f,
+	)
+}
+
+func ChainFirst[GB ~func(S) P.Pair[B, S], GA ~func(S) P.Pair[A, S], FCT ~func(A) GB, S, A, B any](f FCT) func(GA) GA {
+	return C.ChainFirst(
+		Chain[GA, GA, func(A) GA],
+		Map[GA, GB, func(B) A],
+		f,
+	)
+}
+
+func Flatten[GAA ~func(S) P.Pair[GA, S], GA ~func(S) P.Pair[A, S], S, A any](mma GAA) GA {
+	return MonadChain[GA, GAA, func(GA) GA](mma, F.Identity[GA])
+}
+
+func Execute[GA ~func(S) P.Pair[A, S], S, A any](s S) func(GA) S {
+	return func(fa GA) S {
+		return P.Tail(fa(s))
+	}
+}
+
+func Evaluate[GA ~func(S) P.Pair[A, S], S, A any](s S) func(GA) A {
+	return func(fa GA) A {
+		return P.Head(fa(s))
+	}
+}
+
+func MonadFlap[FAB ~func(A) B, GFAB ~func(S) P.Pair[FAB, S], GB ~func(S) P.Pair[B, S], S, A, B any](fab GFAB, a A) GB {
+	return FC.MonadFlap(
+		MonadMap[GB, GFAB, func(FAB) B],
+		fab,
+		a)
+}
+
+func Flap[FAB ~func(A) B, GFAB ~func(S) P.Pair[FAB, S], GB ~func(S) P.Pair[B, S], S, A, B any](a A) func(GFAB) GB {
+	return FC.Flap(Map[GB, GFAB, func(FAB) B], a)
+}

state/monad.go

@@ -0,0 +1,44 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package state
+
+import (
+	"github.com/IBM/fp-go/internal/applicative"
+	"github.com/IBM/fp-go/internal/functor"
+	"github.com/IBM/fp-go/internal/monad"
+	"github.com/IBM/fp-go/internal/pointed"
+	G "github.com/IBM/fp-go/state/generic"
+)
+
+// Pointed implements the pointed operations for [State]
+func Pointed[S, A any]() pointed.Pointed[A, State[S, A]] {
+	return G.Pointed[State[S, A], S, A]()
+}
+
+// Functor implements the pointed operations for [State]
+func Functor[S, A, B any]() functor.Functor[A, B, State[S, A], State[S, B]] {
+	return G.Functor[State[S, B], State[S, A], S, A, B]()
+}
+
+// Applicative implements the applicative operations for [State]
+func Applicative[S, A, B any]() applicative.Applicative[A, B, State[S, A], State[S, B], State[S, func(A) B]] {
+	return G.Applicative[State[S, B], State[S, func(A) B], State[S, A]]()
+}
+
+// Monad implements the monadic operations for [State]
+func Monad[S, A, B any]() monad.Monad[A, B, State[S, A], State[S, B], State[S, func(A) B]] {
+	return G.Monad[State[S, B], State[S, func(A) B], State[S, A]]()
+}

state/state.go

@@ -0,0 +1,97 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package state
+
+import (
+	P "github.com/IBM/fp-go/pair"
+	R "github.com/IBM/fp-go/reader"
+	G "github.com/IBM/fp-go/state/generic"
+)
+
+// State represents an operation on top of a current [State] that produces a value and a new [State]
+type State[S, A any] R.Reader[S, P.Pair[A, S]]
+
+func Get[S any]() State[S, S] {
+	return G.Get[State[S, S]]()
+}
+
+func Gets[FCT ~func(S) A, A, S any](f FCT) State[S, A] {
+	return G.Gets[State[S, A]](f)
+}
+
+func Put[S any]() State[S, any] {
+	return G.Put[State[S, any]]()
+}
+
+func Modify[FCT ~func(S) S, S any](f FCT) State[S, any] {
+	return G.Modify[State[S, any]](f)
+}
+
+func Of[S, A any](a A) State[S, A] {
+	return G.Of[State[S, A]](a)
+}
+
+func MonadMap[S any, FCT ~func(A) B, A, B any](fa State[S, A], f FCT) State[S, B] {
+	return G.MonadMap[State[S, B], State[S, A]](fa, f)
+}
+
+func Map[S any, FCT ~func(A) B, A, B any](f FCT) func(State[S, A]) State[S, B] {
+	return G.Map[State[S, B], State[S, A]](f)
+}
+
+func MonadChain[S any, FCT ~func(A) State[S, B], A, B any](fa State[S, A], f FCT) State[S, B] {
+	return G.MonadChain[State[S, B], State[S, A]](fa, f)
+}
+
+func Chain[S any, FCT ~func(A) State[S, B], A, B any](f FCT) func(State[S, A]) State[S, B] {
+	return G.Chain[State[S, B], State[S, A]](f)
+}
+
+func MonadAp[S, A, B any](fab State[S, func(A) B], fa State[S, A]) State[S, B] {
+	return G.MonadAp[State[S, B], State[S, func(A) B], State[S, A]](fab, fa)
+}
+
+func Ap[S, A, B any](ga State[S, A]) func(State[S, func(A) B]) State[S, B] {
+	return G.Ap[State[S, B], State[S, func(A) B], State[S, A]](ga)
+}
+
+func MonadChainFirst[S any, FCT ~func(A) State[S, B], A, B any](ma State[S, A], f FCT) State[S, A] {
+	return G.MonadChainFirst[State[S, B], State[S, A]](ma, f)
+}
+
+func ChainFirst[S any, FCT ~func(A) State[S, B], A, B any](f FCT) func(State[S, A]) State[S, A] {
+	return G.ChainFirst[State[S, B], State[S, A]](f)
+}
+
+func Flatten[S, A any](mma State[S, State[S, A]]) State[S, A] {
+	return G.Flatten[State[S, State[S, A]], State[S, A]](mma)
+}
+
+func Execute[A, S any](s S) func(State[S, A]) S {
+	return G.Execute[State[S, A]](s)
+}
+
+func Evaluate[A, S any](s S) func(State[S, A]) A {
+	return G.Evaluate[State[S, A]](s)
+}
+
+func MonadFlap[FAB ~func(A) B, S, A, B any](fab State[S, FAB], a A) State[S, B] {
+	return G.MonadFlap[FAB, State[S, FAB], State[S, B], S, A, B](fab, a)
+}
+
+func Flap[S, A, B any](a A) func(State[S, func(A) B]) State[S, B] {
+	return G.Flap[func(A) B, State[S, func(A) B], State[S, B]](a)
+}

state/testing/laws.go

@@ -0,0 +1,78 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package testing
+
+import (
+	"testing"
+
+	EQ "github.com/IBM/fp-go/eq"
+	L "github.com/IBM/fp-go/internal/monad/testing"
+	ST "github.com/IBM/fp-go/state"
+)
+
+// AssertLaws asserts the apply monad laws for the `Either` monad
+func AssertLaws[S, A, B, C any](t *testing.T,
+	eqw EQ.Eq[S],
+	eqa EQ.Eq[A],
+	eqb EQ.Eq[B],
+	eqc EQ.Eq[C],
+
+	ab func(A) B,
+	bc func(B) C,
+
+	s S,
+) func(a A) bool {
+
+	fofc := ST.Pointed[S, C]()
+	fofaa := ST.Pointed[S, func(A) A]()
+	fofbc := ST.Pointed[S, func(B) C]()
+	fofabb := ST.Pointed[S, func(func(A) B) B]()
+
+	fmap := ST.Functor[S, func(B) C, func(func(A) B) func(A) C]()
+
+	fapabb := ST.Applicative[S, func(A) B, B]()
+	fapabac := ST.Applicative[S, func(A) B, func(A) C]()
+
+	maa := ST.Monad[S, A, A]()
+	mab := ST.Monad[S, A, B]()
+	mac := ST.Monad[S, A, C]()
+	mbc := ST.Monad[S, B, C]()
+
+	return L.MonadAssertLaws(t,
+		ST.Eq(eqw, eqa)(s),
+		ST.Eq(eqw, eqb)(s),
+		ST.Eq(eqw, eqc)(s),
+
+		fofc,
+		fofaa,
+		fofbc,
+		fofabb,
+
+		fmap,
+
+		fapabb,
+		fapabac,
+
+		maa,
+		mab,
+		mac,
+		mbc,
+
+		ab,
+		bc,
+	)
+
+}

state/testing/laws_test.go

@@ -0,0 +1,49 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package testing
+
+import (
+	"fmt"
+	"testing"
+
+	A "github.com/IBM/fp-go/array"
+	EQ "github.com/IBM/fp-go/eq"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMonadLaws(t *testing.T) {
+	// some comparison
+	eqs := A.Eq[string](EQ.FromStrictEquals[string]())
+	eqa := EQ.FromStrictEquals[bool]()
+	eqb := EQ.FromStrictEquals[int]()
+	eqc := EQ.FromStrictEquals[string]()
+
+	ab := func(a bool) int {
+		if a {
+			return 1
+		}
+		return 0
+	}
+
+	bc := func(b int) string {
+		return fmt.Sprintf("value %d", b)
+	}
+
+	laws := AssertLaws(t, eqs, eqa, eqb, eqc, ab, bc, A.Empty[string]())
+
+	assert.True(t, laws(true))
+	assert.True(t, laws(false))
+}

statereaderioeither/eq.go

@@ -0,0 +1,35 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package statereaderioeither
+
+import (
+	EQ "github.com/IBM/fp-go/eq"
+	P "github.com/IBM/fp-go/pair"
+	RIOE "github.com/IBM/fp-go/readerioeither"
+	G "github.com/IBM/fp-go/statereaderioeither/generic"
+)
+
+// Eq implements the equals predicate for values contained in the [StateReaderIOEither] monad
+func Eq[
+	S, R, E, A any](eqr EQ.Eq[RIOE.ReaderIOEither[R, E, P.Pair[A, S]]]) func(S) EQ.Eq[StateReaderIOEither[S, R, E, A]] {
+	return G.Eq[StateReaderIOEither[S, R, E, A]](eqr)
+}
+
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
+func FromStrictEquals[
+	S, R any, E, A comparable]() func(R) func(S) EQ.Eq[StateReaderIOEither[S, R, E, A]] {
+	return G.FromStrictEquals[StateReaderIOEither[S, R, E, A]]()
+}

statereaderioeither/generic/eq.go

@@ -0,0 +1,49 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	ET "github.com/IBM/fp-go/either"
+	EQ "github.com/IBM/fp-go/eq"
+	F "github.com/IBM/fp-go/function"
+	P "github.com/IBM/fp-go/pair"
+	G "github.com/IBM/fp-go/readerioeither/generic"
+)
+
+// Eq implements the equals predicate for values contained in the [StateReaderIOEither] monad
+func Eq[
+	SRIOEA ~func(S) RIOEA,
+	RIOEA ~func(R) IOEA,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	S, R, E, A any](eqr EQ.Eq[RIOEA]) func(S) EQ.Eq[SRIOEA] {
+	return func(s S) EQ.Eq[SRIOEA] {
+		return EQ.FromEquals(func(l, r SRIOEA) bool {
+			return eqr.Equals(l(s), r(s))
+		})
+	}
+}
+
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
+func FromStrictEquals[
+	SRIOEA ~func(S) RIOEA,
+	RIOEA ~func(R) IOEA,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	S, R any, E, A comparable]() func(R) func(S) EQ.Eq[SRIOEA] {
+	return F.Flow2(
+		G.FromStrictEquals[RIOEA](),
+		Eq[SRIOEA, RIOEA, IOEA, S, R, E, A],
+	)
+}

statereaderioeither/generic/monad.go

@@ -0,0 +1,159 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	ET "github.com/IBM/fp-go/either"
+	"github.com/IBM/fp-go/internal/applicative"
+	"github.com/IBM/fp-go/internal/functor"
+	"github.com/IBM/fp-go/internal/monad"
+	"github.com/IBM/fp-go/internal/pointed"
+	P "github.com/IBM/fp-go/pair"
+)
+
+type stateReaderIOEitherPointed[
+	SRIOEA ~func(S) RIOEA,
+	RIOEA ~func(R) IOEA,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	S, R, E, A any,
+] struct{}
+
+type stateReaderIOEitherFunctor[
+	SRIOEA ~func(S) RIOEA,
+	SRIOEB ~func(S) RIOEB,
+	RIOEA ~func(R) IOEA,
+	RIOEB ~func(R) IOEB,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	S, R, E, A, B any,
+] struct{}
+
+type stateReaderIOEitherApplicative[
+	SRIOEA ~func(S) RIOEA,
+	SRIOEB ~func(S) RIOEB,
+	SRIOEAB ~func(S) RIOEAB,
+	RIOEA ~func(R) IOEA,
+	RIOEB ~func(R) IOEB,
+	RIOEAB ~func(R) IOEAB,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	IOEAB ~func() ET.Either[E, P.Pair[func(A) B, S]],
+	S, R, E, A, B any,
+] struct{}
+
+type stateReaderIOEitherMonad[
+	SRIOEA ~func(S) RIOEA,
+	SRIOEB ~func(S) RIOEB,
+	SRIOEAB ~func(S) RIOEAB,
+	RIOEA ~func(R) IOEA,
+	RIOEB ~func(R) IOEB,
+	RIOEAB ~func(R) IOEAB,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	IOEAB ~func() ET.Either[E, P.Pair[func(A) B, S]],
+	S, R, E, A, B any,
+] struct{}
+
+func (o *stateReaderIOEitherPointed[SRIOEA, RIOEA, IOEA, S, R, E, A]) Of(a A) SRIOEA {
+	return Of[SRIOEA](a)
+}
+
+func (o *stateReaderIOEitherMonad[SRIOEA, SRIOEB, SRIOEAB, RIOEA, RIOEB, RIOEAB, IOEA, IOEB, IOEAB, S, R, E, A, B]) Of(a A) SRIOEA {
+	return Of[SRIOEA](a)
+}
+
+func (o *stateReaderIOEitherApplicative[SRIOEA, SRIOEB, SRIOEAB, RIOEA, RIOEB, RIOEAB, IOEA, IOEB, IOEAB, S, R, E, A, B]) Of(a A) SRIOEA {
+	return Of[SRIOEA](a)
+}
+
+func (o *stateReaderIOEitherMonad[SRIOEA, SRIOEB, SRIOEAB, RIOEA, RIOEB, RIOEAB, IOEA, IOEB, IOEAB, S, R, E, A, B]) Map(f func(A) B) func(SRIOEA) SRIOEB {
+	return Map[SRIOEA, SRIOEB](f)
+}
+
+func (o *stateReaderIOEitherApplicative[SRIOEA, SRIOEB, SRIOEAB, RIOEA, RIOEB, RIOEAB, IOEA, IOEB, IOEAB, S, R, E, A, B]) Map(f func(A) B) func(SRIOEA) SRIOEB {
+	return Map[SRIOEA, SRIOEB](f)
+}
+
+func (o *stateReaderIOEitherFunctor[SRIOEA, SRIOEB, RIOEA, RIOEB, IOEA, IOEB, S, R, E, A, B]) Map(f func(A) B) func(SRIOEA) SRIOEB {
+	return Map[SRIOEA, SRIOEB](f)
+}
+
+func (o *stateReaderIOEitherMonad[SRIOEA, SRIOEB, SRIOEAB, RIOEA, RIOEB, RIOEAB, IOEA, IOEB, IOEAB, S, R, E, A, B]) Chain(f func(A) SRIOEB) func(SRIOEA) SRIOEB {
+	return Chain[SRIOEA, SRIOEB](f)
+}
+
+func (o *stateReaderIOEitherMonad[SRIOEA, SRIOEB, SRIOEAB, RIOEA, RIOEB, RIOEAB, IOEA, IOEB, IOEAB, S, R, E, A, B]) Ap(fa SRIOEA) func(SRIOEAB) SRIOEB {
+	return Ap[SRIOEA, SRIOEB, SRIOEAB, RIOEA, RIOEB, RIOEAB, IOEA, IOEB, IOEAB, S, R, E, A, B](fa)
+}
+
+func (o *stateReaderIOEitherApplicative[SRIOEA, SRIOEB, SRIOEAB, RIOEA, RIOEB, RIOEAB, IOEA, IOEB, IOEAB, S, R, E, A, B]) Ap(fa SRIOEA) func(SRIOEAB) SRIOEB {
+	return Ap[SRIOEA, SRIOEB, SRIOEAB, RIOEA, RIOEB, RIOEAB, IOEA, IOEB, IOEAB, S, R, E, A, B](fa)
+}
+
+// Pointed implements the pointed operations for [StateReaderIOEither]
+func Pointed[
+	SRIOEA ~func(S) RIOEA,
+	RIOEA ~func(R) IOEA,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	S, R, E, A any,
+]() pointed.Pointed[A, SRIOEA] {
+	return &stateReaderIOEitherPointed[SRIOEA, RIOEA, IOEA, S, R, E, A]{}
+}
+
+// Functor implements the functor operations for [StateReaderIOEither]
+func Functor[
+	SRIOEA ~func(S) RIOEA,
+	SRIOEB ~func(S) RIOEB,
+	RIOEA ~func(R) IOEA,
+	RIOEB ~func(R) IOEB,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	S, R, E, A, B any,
+]() functor.Functor[A, B, SRIOEA, SRIOEB] {
+	return &stateReaderIOEitherFunctor[SRIOEA, SRIOEB, RIOEA, RIOEB, IOEA, IOEB, S, R, E, A, B]{}
+}
+
+// Applicative implements the applicative operations for [StateReaderIOEither]
+func Applicative[
+	SRIOEA ~func(S) RIOEA,
+	SRIOEB ~func(S) RIOEB,
+	SRIOEAB ~func(S) RIOEAB,
+	RIOEA ~func(R) IOEA,
+	RIOEB ~func(R) IOEB,
+	RIOEAB ~func(R) IOEAB,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	IOEAB ~func() ET.Either[E, P.Pair[func(A) B, S]],
+	S, R, E, A, B any,
+]() applicative.Applicative[A, B, SRIOEA, SRIOEB, SRIOEAB] {
+	return &stateReaderIOEitherApplicative[SRIOEA, SRIOEB, SRIOEAB, RIOEA, RIOEB, RIOEAB, IOEA, IOEB, IOEAB, S, R, E, A, B]{}
+}
+
+// Monad implements the monadic operations for [StateReaderIOEither]
+func Monad[
+	SRIOEA ~func(S) RIOEA,
+	SRIOEB ~func(S) RIOEB,
+	SRIOEAB ~func(S) RIOEAB,
+	RIOEA ~func(R) IOEA,
+	RIOEB ~func(R) IOEB,
+	RIOEAB ~func(R) IOEAB,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	IOEAB ~func() ET.Either[E, P.Pair[func(A) B, S]],
+	S, R, E, A, B any,
+]() monad.Monad[A, B, SRIOEA, SRIOEB, SRIOEAB] {
+	return &stateReaderIOEitherMonad[SRIOEA, SRIOEB, SRIOEAB, RIOEA, RIOEB, RIOEAB, IOEA, IOEB, IOEAB, S, R, E, A, B]{}
+}

statereaderioeither/generic/state.go

@@ -0,0 +1,425 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	ET "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	ST "github.com/IBM/fp-go/internal/statet"
+	P "github.com/IBM/fp-go/pair"
+	G "github.com/IBM/fp-go/readerioeither/generic"
+)
+
+func Left[
+	SRIOEA ~func(S) RIOEA,
+	RIOEA ~func(R) IOEA,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	S, R, E, A any,
+](e E) SRIOEA {
+	return F.Constant1[S](G.Left[RIOEA](e))
+}
+
+func Right[
+	SRIOEA ~func(S) RIOEA,
+	RIOEA ~func(R) IOEA,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	S, R, E, A any,
+](a A) SRIOEA {
+	return ST.Of[SRIOEA](
+		G.Of[RIOEA],
+		a,
+	)
+}
+
+func Of[
+	SRIOEA ~func(S) RIOEA,
+	RIOEA ~func(R) IOEA,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	S, R, E, A any,
+](a A) SRIOEA {
+	return Right[SRIOEA](a)
+}
+
+func MonadMap[
+	SRIOEA ~func(S) RIOEA,
+	SRIOEB ~func(S) RIOEB,
+	RIOEA ~func(R) IOEA,
+	RIOEB ~func(R) IOEB,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	S, R, E, A, B any,
+](fa SRIOEA, f func(A) B) SRIOEB {
+	return ST.MonadMap[SRIOEA, SRIOEB](
+		G.MonadMap[RIOEA, RIOEB],
+		fa,
+		f,
+	)
+}
+
+func Map[
+	SRIOEA ~func(S) RIOEA,
+	SRIOEB ~func(S) RIOEB,
+	RIOEA ~func(R) IOEA,
+	RIOEB ~func(R) IOEB,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	S, R, E, A, B any,
+](f func(A) B) func(SRIOEA) SRIOEB {
+	return ST.Map[SRIOEA, SRIOEB](
+		G.Map[RIOEA, RIOEB],
+		f,
+	)
+}
+
+func MonadChain[
+	SRIOEA ~func(S) RIOEA,
+	SRIOEB ~func(S) RIOEB,
+	RIOEA ~func(R) IOEA,
+	RIOEB ~func(R) IOEB,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	S, R, E, A, B any,
+](fa SRIOEA, f func(A) SRIOEB) SRIOEB {
+	return ST.MonadChain[SRIOEA, SRIOEB](
+		G.MonadChain[RIOEA, RIOEB],
+		fa,
+		f,
+	)
+}
+
+func Chain[
+	SRIOEA ~func(S) RIOEA,
+	SRIOEB ~func(S) RIOEB,
+	RIOEA ~func(R) IOEA,
+	RIOEB ~func(R) IOEB,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	S, R, E, A, B any,
+](f func(A) SRIOEB) func(SRIOEA) SRIOEB {
+	return ST.Chain[SRIOEA, SRIOEB](
+		G.Chain[RIOEA, RIOEB],
+		f,
+	)
+}
+
+func MonadAp[
+	SRIOEA ~func(S) RIOEA,
+	SRIOEB ~func(S) RIOEB,
+	SRIOEAB ~func(S) RIOEAB,
+	RIOEA ~func(R) IOEA,
+	RIOEB ~func(R) IOEB,
+	RIOEAB ~func(R) IOEAB,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	IOEAB ~func() ET.Either[E, P.Pair[func(A) B, S]],
+	S, R, E, A, B any,
+](fab SRIOEAB, fa SRIOEA) SRIOEB {
+	return ST.MonadAp[SRIOEA, SRIOEB, SRIOEAB](
+		G.MonadMap[RIOEA, RIOEB],
+		G.MonadChain[RIOEAB, RIOEB],
+		fab,
+		fa,
+	)
+}
+
+func Ap[
+	SRIOEA ~func(S) RIOEA,
+	SRIOEB ~func(S) RIOEB,
+	SRIOEAB ~func(S) RIOEAB,
+	RIOEA ~func(R) IOEA,
+	RIOEB ~func(R) IOEB,
+	RIOEAB ~func(R) IOEAB,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	IOEAB ~func() ET.Either[E, P.Pair[func(A) B, S]],
+	S, R, E, A, B any,
+](fa SRIOEA) func(SRIOEAB) SRIOEB {
+	return ST.Ap[SRIOEA, SRIOEB, SRIOEAB](
+		G.Map[RIOEA, RIOEB],
+		G.Chain[RIOEAB, RIOEB],
+		fa,
+	)
+}
+
+// Conversions
+
+func FromReaderIOEither[
+	SRIOEA ~func(S) RIOEA,
+	RIOEA_IN ~func(R) IOEA_IN,
+
+	RIOEA ~func(R) IOEA,
+
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEA_IN ~func() ET.Either[E, A],
+
+	S, R, E, A any,
+](fa RIOEA_IN) SRIOEA {
+	return ST.FromF[SRIOEA](
+		G.MonadMap[RIOEA_IN, RIOEA],
+		fa,
+	)
+}
+
+func FromReaderEither[
+	SRIOEA ~func(S) RIOEA,
+	RIOEA_IN ~func(R) IOEA_IN,
+	RIOEA ~func(R) IOEA,
+
+	REA_IN ~func(R) ET.Either[E, A],
+
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEA_IN ~func() ET.Either[E, A],
+
+	S, R, E, A any,
+](fa REA_IN) SRIOEA {
+	return FromReaderIOEither[SRIOEA](G.FromReaderEither[REA_IN, RIOEA_IN](fa))
+}
+
+func FromIOEither[
+	SRIOEA ~func(S) RIOEA,
+	RIOEA_IN ~func(R) IOEA_IN,
+	IOEA_IN ~func() ET.Either[E, A],
+	RIOEA ~func(R) IOEA,
+
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+
+	S, R, E, A any,
+](fa IOEA_IN) SRIOEA {
+	return FromReaderIOEither[SRIOEA](G.FromIOEither[RIOEA_IN](fa))
+}
+
+func FromIO[
+	SRIOEA ~func(S) RIOEA,
+	RIOEA_IN ~func(R) IOEA_IN,
+
+	IO_IN ~func() A,
+
+	RIOEA ~func(R) IOEA,
+
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEA_IN ~func() ET.Either[E, A],
+
+	S, R, E, A any,
+](fa IO_IN) SRIOEA {
+	return FromReaderIOEither[SRIOEA](G.FromIO[RIOEA_IN](fa))
+}
+
+func FromReader[
+	SRIOEA ~func(S) RIOEA,
+	RIOEA_IN ~func(R) IOEA_IN,
+
+	R_IN ~func(R) A,
+
+	RIOEA ~func(R) IOEA,
+
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEA_IN ~func() ET.Either[E, A],
+
+	S, R, E, A any,
+](fa R_IN) SRIOEA {
+	return FromReaderIOEither[SRIOEA](G.FromReader[R_IN, RIOEA_IN](fa))
+}
+
+func FromEither[
+	SRIOEA ~func(S) RIOEA,
+
+	RIOEA ~func(R) IOEA,
+
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+
+	S, R, E, A any,
+](ma ET.Either[E, A]) SRIOEA {
+	return ET.MonadFold(ma, Left[SRIOEA], Right[SRIOEA])
+}
+
+func FromState[
+	SRIOEA ~func(S) RIOEA,
+	STATE ~func(S) P.Pair[A, S],
+	RIOEA ~func(R) IOEA,
+
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+
+	S, R, E, A any,
+](fa STATE) SRIOEA {
+	return ST.FromState[SRIOEA](G.Of[RIOEA], fa)
+}
+
+// Combinators
+
+func Local[
+	SR1IOEA ~func(S) R1IOEA,
+	SR2IOEA ~func(S) R2IOEA,
+	R1IOEA ~func(R1) IOEA,
+	R2IOEA ~func(R2) IOEA,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	S, R1, R2, E, A any,
+](f func(R2) R1) func(SR1IOEA) SR2IOEA {
+	return func(ma SR1IOEA) SR2IOEA {
+		return F.Flow2(ma, G.Local[R1IOEA, R2IOEA](f))
+	}
+}
+
+func Asks[
+	SRIOEA ~func(S) RIOEA,
+	RIOEA ~func(R) IOEA,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	S, R, E, A any,
+](f func(R) SRIOEA) SRIOEA {
+	return func(s S) RIOEA {
+		return func(r R) IOEA {
+			return f(r)(s)(r)
+		}
+	}
+}
+
+func FromIOEitherK[
+	SRIOEB ~func(S) RIOEB,
+	RIOEB_IN ~func(R) IOEB_IN,
+	IOEB_IN ~func() ET.Either[E, B],
+	RIOEB ~func(R) IOEB,
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	S, R, E, A, B any,
+](f func(A) IOEB_IN) func(A) SRIOEB {
+	return F.Flow2(
+		f,
+		FromIOEither[SRIOEB, RIOEB_IN],
+	)
+}
+
+func FromEitherK[
+	SRIOEB ~func(S) RIOEB,
+	RIOEB ~func(R) IOEB,
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	S, R, E, A, B any,
+](f func(A) ET.Either[E, B]) func(A) SRIOEB {
+	return F.Flow2(
+		f,
+		FromEither[SRIOEB],
+	)
+}
+
+func FromIOK[
+	SRIOEB ~func(S) RIOEB,
+	RIOEB_IN ~func(R) IOEB_IN,
+
+	IOB_IN ~func() B,
+
+	RIOEB ~func(R) IOEB,
+
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	IOEB_IN ~func() ET.Either[E, B],
+
+	S, R, E, A, B any,
+](f func(A) IOB_IN) func(A) SRIOEB {
+	return F.Flow2(
+		f,
+		FromIO[SRIOEB, RIOEB_IN, IOB_IN],
+	)
+}
+
+func FromReaderIOEitherK[
+	SRIOEB ~func(S) RIOEB,
+	RIOEB_IN ~func(R) IOEB_IN,
+	IOEB_IN ~func() ET.Either[E, B],
+	RIOEB ~func(R) IOEB,
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	S, R, E, A, B any,
+](f func(A) RIOEB_IN) func(A) SRIOEB {
+	return F.Flow2(
+		f,
+		FromReaderIOEither[SRIOEB, RIOEB_IN],
+	)
+}
+
+func MonadChainReaderIOEitherK[
+	SRIOEA ~func(S) RIOEA,
+	SRIOEB ~func(S) RIOEB,
+	RIOEB_IN ~func(R) IOEB_IN,
+	RIOEA ~func(R) IOEA,
+	RIOEB ~func(R) IOEB,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	IOEB_IN ~func() ET.Either[E, B],
+	S, R, E, A, B any,
+](ma SRIOEA, f func(A) RIOEB_IN) SRIOEB {
+	return MonadChain(ma, FromReaderIOEitherK[SRIOEB, RIOEB_IN](f))
+}
+
+func ChainReaderIOEitherK[
+	SRIOEA ~func(S) RIOEA,
+	SRIOEB ~func(S) RIOEB,
+	RIOEB_IN ~func(R) IOEB_IN,
+	RIOEA ~func(R) IOEA,
+	RIOEB ~func(R) IOEB,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	IOEB_IN ~func() ET.Either[E, B],
+	S, R, E, A, B any,
+](f func(A) RIOEB_IN) func(SRIOEA) SRIOEB {
+	return Chain[SRIOEA](FromReaderIOEitherK[SRIOEB, RIOEB_IN](f))
+}
+
+func MonadChainIOEitherK[
+	SRIOEA ~func(S) RIOEA,
+	SRIOEB ~func(S) RIOEB,
+	RIOEB_IN ~func(R) IOEB_IN,
+	IOEB_IN ~func() ET.Either[E, B],
+	RIOEA ~func(R) IOEA,
+	RIOEB ~func(R) IOEB,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	S, R, E, A, B any,
+](ma SRIOEA, f func(A) IOEB_IN) SRIOEB {
+	return MonadChain(ma, FromIOEitherK[SRIOEB, RIOEB_IN](f))
+}
+
+func ChainIOEitherK[
+	SRIOEA ~func(S) RIOEA,
+	SRIOEB ~func(S) RIOEB,
+	RIOEB_IN ~func(R) IOEB_IN,
+	IOEB_IN ~func() ET.Either[E, B],
+	RIOEA ~func(R) IOEA,
+	RIOEB ~func(R) IOEB,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	S, R, E, A, B any,
+](f func(A) IOEB_IN) func(SRIOEA) SRIOEB {
+	return Chain[SRIOEA](FromIOEitherK[SRIOEB, RIOEB_IN](f))
+}
+
+func MonadChainEitherK[
+	SRIOEA ~func(S) RIOEA,
+	SRIOEB ~func(S) RIOEB,
+	RIOEA ~func(R) IOEA,
+	RIOEB ~func(R) IOEB,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	S, R, E, A, B any,
+](ma SRIOEA, f func(A) ET.Either[E, B]) SRIOEB {
+	return MonadChain(ma, FromEitherK[SRIOEB](f))
+}
+
+func ChainEitherK[
+	SRIOEA ~func(S) RIOEA,
+	SRIOEB ~func(S) RIOEB,
+	RIOEA ~func(R) IOEA,
+	RIOEB ~func(R) IOEB,
+	IOEA ~func() ET.Either[E, P.Pair[A, S]],
+	IOEB ~func() ET.Either[E, P.Pair[B, S]],
+	S, R, E, A, B any,
+](f func(A) ET.Either[E, B]) func(SRIOEA) SRIOEB {
+	return Chain[SRIOEA](FromEitherK[SRIOEB](f))
+}

statereaderioeither/monad.go

@@ -0,0 +1,44 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package statereaderioeither
+
+import (
+	"github.com/IBM/fp-go/internal/applicative"
+	"github.com/IBM/fp-go/internal/functor"
+	"github.com/IBM/fp-go/internal/monad"
+	"github.com/IBM/fp-go/internal/pointed"
+	G "github.com/IBM/fp-go/statereaderioeither/generic"
+)
+
+// Pointed returns the pointed operations for [StateReaderIOEither]
+func Pointed[S, R, E, A any]() pointed.Pointed[A, StateReaderIOEither[S, R, E, A]] {
+	return G.Pointed[StateReaderIOEither[S, R, E, A]]()
+}
+
+// Functor returns the functor operations for [StateReaderIOEither]
+func Functor[S, R, E, A, B any]() functor.Functor[A, B, StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B]] {
+	return G.Functor[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B]]()
+}
+
+// Applicative returns the applicative operations for [StateReaderIOEither]
+func Applicative[S, R, E, A, B any]() applicative.Applicative[A, B, StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B], StateReaderIOEither[S, R, E, func(A) B]] {
+	return G.Applicative[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B], StateReaderIOEither[S, R, E, func(A) B]]()
+}
+
+// Monad returns the monadic operations for [StateReaderIOEither]
+func Monad[S, R, E, A, B any]() monad.Monad[A, B, StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B], StateReaderIOEither[S, R, E, func(A) B]] {
+	return G.Monad[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B], StateReaderIOEither[S, R, E, func(A) B]]()
+}

statereaderioeither/state.go

@@ -0,0 +1,145 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package statereaderioeither
+
+import (
+	ET "github.com/IBM/fp-go/either"
+	IO "github.com/IBM/fp-go/io"
+	IOE "github.com/IBM/fp-go/ioeither"
+	RD "github.com/IBM/fp-go/reader"
+	RE "github.com/IBM/fp-go/readereither"
+	RIOE "github.com/IBM/fp-go/readerioeither"
+	ST "github.com/IBM/fp-go/state"
+	G "github.com/IBM/fp-go/statereaderioeither/generic"
+)
+
+func Left[S, R, A, E any](e E) StateReaderIOEither[S, R, E, A] {
+	return G.Left[StateReaderIOEither[S, R, E, A]](e)
+}
+
+func Right[S, R, E, A any](a A) StateReaderIOEither[S, R, E, A] {
+	return G.Right[StateReaderIOEither[S, R, E, A]](a)
+}
+
+func Of[S, R, E, A any](a A) StateReaderIOEither[S, R, E, A] {
+	return G.Of[StateReaderIOEither[S, R, E, A]](a)
+}
+
+func MonadMap[S, R, E, A, B any](fa StateReaderIOEither[S, R, E, A], f func(A) B) StateReaderIOEither[S, R, E, B] {
+	return G.MonadMap[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B]](fa, f)
+}
+
+func Map[S, R, E, A, B any](f func(A) B) func(StateReaderIOEither[S, R, E, A]) StateReaderIOEither[S, R, E, B] {
+	return G.Map[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B]](f)
+}
+
+func MonadChain[S, R, E, A, B any](fa StateReaderIOEither[S, R, E, A], f func(A) StateReaderIOEither[S, R, E, B]) StateReaderIOEither[S, R, E, B] {
+	return G.MonadChain[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B]](fa, f)
+}
+
+func Chain[S, R, E, A, B any](f func(A) StateReaderIOEither[S, R, E, B]) func(StateReaderIOEither[S, R, E, A]) StateReaderIOEither[S, R, E, B] {
+	return G.Chain[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B]](f)
+}
+
+func MonadAp[S, R, E, A, B any](fab StateReaderIOEither[S, R, E, func(A) B], fa StateReaderIOEither[S, R, E, A]) StateReaderIOEither[S, R, E, B] {
+	return G.MonadAp[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B], StateReaderIOEither[S, R, E, func(A) B]](fab, fa)
+}
+
+func Ap[S, R, E, A, B any](fa StateReaderIOEither[S, R, E, A]) func(StateReaderIOEither[S, R, E, func(A) B]) StateReaderIOEither[S, R, E, B] {
+	return G.Ap[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B], StateReaderIOEither[S, R, E, func(A) B]](fa)
+}
+
+func FromReaderIOEither[S, R, E, A any](fa RIOE.ReaderIOEither[R, E, A]) StateReaderIOEither[S, R, E, A] {
+	return G.FromReaderIOEither[StateReaderIOEither[S, R, E, A]](fa)
+}
+
+func FromReaderEither[S, R, E, A any](fa RE.ReaderEither[R, E, A]) StateReaderIOEither[S, R, E, A] {
+	return G.FromReaderEither[StateReaderIOEither[S, R, E, A], RIOE.ReaderIOEither[R, E, A]](fa)
+}
+
+func FromIOEither[S, R, E, A any](fa IOE.IOEither[E, A]) StateReaderIOEither[S, R, E, A] {
+	return G.FromIOEither[StateReaderIOEither[S, R, E, A], RIOE.ReaderIOEither[R, E, A]](fa)
+}
+
+func FromState[S, R, E, A any](sa ST.State[S, A]) StateReaderIOEither[S, R, E, A] {
+	return G.FromState[StateReaderIOEither[S, R, E, A]](sa)
+}
+
+func FromIO[S, R, E, A any](fa IO.IO[A]) StateReaderIOEither[S, R, E, A] {
+	return G.FromIO[StateReaderIOEither[S, R, E, A], RIOE.ReaderIOEither[R, E, A]](fa)
+}
+
+func FromReader[S, R, E, A any](fa RD.Reader[R, A]) StateReaderIOEither[S, R, E, A] {
+	return G.FromReader[StateReaderIOEither[S, R, E, A], RIOE.ReaderIOEither[R, E, A]](fa)
+}
+
+func FromEither[S, R, E, A any](ma ET.Either[E, A]) StateReaderIOEither[S, R, E, A] {
+	return G.FromEither[StateReaderIOEither[S, R, E, A]](ma)
+}
+
+// Combinators
+
+func Local[S, R1, R2, E, A, B any](f func(R2) R1) func(StateReaderIOEither[S, R1, E, A]) StateReaderIOEither[S, R2, E, A] {
+	return G.Local[StateReaderIOEither[S, R1, E, A], StateReaderIOEither[S, R2, E, A]](f)
+}
+
+func Asks[
+	S, R, E, A any,
+](f func(R) StateReaderIOEither[S, R, E, A]) StateReaderIOEither[S, R, E, A] {
+	return G.Asks[StateReaderIOEither[S, R, E, A]](f)
+}
+
+func FromEitherK[S, R, E, A, B any](f func(A) ET.Either[E, B]) func(A) StateReaderIOEither[S, R, E, B] {
+	return G.FromEitherK[StateReaderIOEither[S, R, E, B]](f)
+}
+
+func FromIOK[S, R, E, A, B any](f func(A) IO.IO[B]) func(A) StateReaderIOEither[S, R, E, B] {
+	return G.FromIOK[StateReaderIOEither[S, R, E, B], RIOE.ReaderIOEither[R, E, B]](f)
+}
+
+func FromIOEitherK[
+	S, R, E, A, B any,
+](f func(A) IOE.IOEither[E, B]) func(A) StateReaderIOEither[S, R, E, B] {
+	return G.FromIOEitherK[StateReaderIOEither[S, R, E, B], RIOE.ReaderIOEither[R, E, B]](f)
+}
+
+func FromReaderIOEitherK[S, R, E, A, B any](f func(A) RIOE.ReaderIOEither[R, E, B]) func(A) StateReaderIOEither[S, R, E, B] {
+	return G.FromReaderIOEitherK[StateReaderIOEither[S, R, E, B], RIOE.ReaderIOEither[R, E, B]](f)
+}
+
+func MonadChainReaderIOEitherK[S, R, E, A, B any](ma StateReaderIOEither[S, R, E, A], f func(A) RIOE.ReaderIOEither[R, E, B]) StateReaderIOEither[S, R, E, B] {
+	return G.MonadChainReaderIOEitherK[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B]](ma, f)
+}
+
+func ChainReaderIOEitherK[S, R, E, A, B any](f func(A) RIOE.ReaderIOEither[R, E, B]) func(StateReaderIOEither[S, R, E, A]) StateReaderIOEither[S, R, E, B] {
+	return G.ChainReaderIOEitherK[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B]](f)
+}
+
+func MonadChainIOEitherK[S, R, E, A, B any](ma StateReaderIOEither[S, R, E, A], f func(A) IOE.IOEither[E, B]) StateReaderIOEither[S, R, E, B] {
+	return G.MonadChainIOEitherK[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B], RIOE.ReaderIOEither[R, E, B]](ma, f)
+}
+
+func ChainIOEitherK[S, R, E, A, B any](f func(A) IOE.IOEither[E, B]) func(StateReaderIOEither[S, R, E, A]) StateReaderIOEither[S, R, E, B] {
+	return G.ChainIOEitherK[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B], RIOE.ReaderIOEither[R, E, B]](f)
+}
+
+func MonadChainEitherK[S, R, E, A, B any](ma StateReaderIOEither[S, R, E, A], f func(A) ET.Either[E, B]) StateReaderIOEither[S, R, E, B] {
+	return G.MonadChainEitherK[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B]](ma, f)
+}
+
+func ChainEitherK[S, R, E, A, B any](f func(A) ET.Either[E, B]) func(StateReaderIOEither[S, R, E, A]) StateReaderIOEither[S, R, E, B] {
+	return G.ChainEitherK[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B]](f)
+}

statereaderioeither/testing/laws.go

@@ -0,0 +1,87 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package testing
+
+import (
+	"testing"
+
+	ET "github.com/IBM/fp-go/either"
+	EQ "github.com/IBM/fp-go/eq"
+	L "github.com/IBM/fp-go/internal/monad/testing"
+	P "github.com/IBM/fp-go/pair"
+	RIOE "github.com/IBM/fp-go/readerioeither"
+	ST "github.com/IBM/fp-go/statereaderioeither"
+)
+
+// AssertLaws asserts the apply monad laws for the `Either` monad
+func AssertLaws[S, E, R, A, B, C any](t *testing.T,
+	eqs EQ.Eq[S],
+	eqe EQ.Eq[E],
+	eqa EQ.Eq[A],
+	eqb EQ.Eq[B],
+	eqc EQ.Eq[C],
+
+	ab func(A) B,
+	bc func(B) C,
+
+	s S,
+	r R,
+) func(a A) bool {
+
+	eqra := RIOE.Eq[R](ET.Eq(eqe, P.Eq(eqa, eqs)))(r)
+	eqrb := RIOE.Eq[R](ET.Eq(eqe, P.Eq(eqb, eqs)))(r)
+	eqrc := RIOE.Eq[R](ET.Eq(eqe, P.Eq(eqc, eqs)))(r)
+
+	fofc := ST.Pointed[S, R, E, C]()
+	fofaa := ST.Pointed[S, R, E, func(A) A]()
+	fofbc := ST.Pointed[S, R, E, func(B) C]()
+	fofabb := ST.Pointed[S, R, E, func(func(A) B) B]()
+
+	fmap := ST.Functor[S, R, E, func(B) C, func(func(A) B) func(A) C]()
+
+	fapabb := ST.Applicative[S, R, E, func(A) B, B]()
+	fapabac := ST.Applicative[S, R, E, func(A) B, func(A) C]()
+
+	maa := ST.Monad[S, R, E, A, A]()
+	mab := ST.Monad[S, R, E, A, B]()
+	mac := ST.Monad[S, R, E, A, C]()
+	mbc := ST.Monad[S, R, E, B, C]()
+
+	return L.MonadAssertLaws(t,
+		ST.Eq(eqra)(s),
+		ST.Eq(eqrb)(s),
+		ST.Eq(eqrc)(s),
+
+		fofc,
+		fofaa,
+		fofbc,
+		fofabb,
+
+		fmap,
+
+		fapabb,
+		fapabac,
+
+		maa,
+		mab,
+		mac,
+		mbc,
+
+		ab,
+		bc,
+	)
+
+}

statereaderioeither/testing/laws_test.go

@@ -0,0 +1,51 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package testing
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	A "github.com/IBM/fp-go/array"
+	EQ "github.com/IBM/fp-go/eq"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMonadLaws(t *testing.T) {
+	// some comparison
+	eqs := A.Eq[string](EQ.FromStrictEquals[string]())
+	eqe := EQ.FromStrictEquals[error]()
+	eqa := EQ.FromStrictEquals[bool]()
+	eqb := EQ.FromStrictEquals[int]()
+	eqc := EQ.FromStrictEquals[string]()
+
+	ab := func(a bool) int {
+		if a {
+			return 1
+		}
+		return 0
+	}
+
+	bc := func(b int) string {
+		return fmt.Sprintf("value %d", b)
+	}
+
+	laws := AssertLaws(t, eqs, eqe, eqa, eqb, eqc, ab, bc, A.Empty[string](), context.Background())
+
+	assert.True(t, laws(true))
+	assert.True(t, laws(false))
+}

statereaderioeither/type.go

@@ -0,0 +1,24 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package statereaderioeither
+
+import (
+	P "github.com/IBM/fp-go/pair"
+	RD "github.com/IBM/fp-go/reader"
+	RIOE "github.com/IBM/fp-go/readerioeither"
+)
+
+type StateReaderIOEither[S, R, E, A any] RD.Reader[S, RIOE.ReaderIOEither[R, E, P.Pair[A, S]]]

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

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]),
+		)
+	}
+}

writer/bind.go

@@ -17,20 +17,22 @@ package writer
 
 import (
 	M "github.com/IBM/fp-go/monoid"
+	SG "github.com/IBM/fp-go/semigroup"
 	G "github.com/IBM/fp-go/writer/generic"
 )
 
 // Bind creates an empty context of type [S] to be used with the [Bind] operation
-func Do[S, W any](m M.Monoid[W]) func(S) Writer[W, S] {
-	return G.Do[Writer[W, S], W, S](m)
+func Do[S, W any](m M.Monoid[W], s S) Writer[W, S] {
+	return G.Do[Writer[W, S], W, S](m, s)
 }
 
 // Bind attaches the result of a computation to a context [S1] to produce a context [S2]
 func Bind[S1, S2, T, W any](
+	s SG.Semigroup[W],
 	setter func(T) func(S1) S2,
 	f func(S1) Writer[W, T],
 ) func(Writer[W, S1]) Writer[W, S2] {
-	return G.Bind[Writer[W, S1], Writer[W, S2], Writer[W, T], W, S1, S2, T](setter, f)
+	return G.Bind[Writer[W, S1], Writer[W, S2], Writer[W, T], W, S1, S2, T](s, setter, f)
 }
 
 // Let attaches the result of a computation to a context [S1] to produce a context [S2]
@@ -58,8 +60,9 @@ func BindTo[W, S1, T any](
 
 // ApS attaches a value to a context [S1] to produce a context [S2] by considering the context and the value concurrently
 func ApS[S1, S2, T, W any](
+	s SG.Semigroup[W],
 	setter func(T) func(S1) S2,
 	fa Writer[W, T],
 ) func(Writer[W, S1]) Writer[W, S2] {
-	return G.ApS[Writer[W, S1], Writer[W, S2], Writer[W, T], W, S1, S2, T](setter, fa)
+	return G.ApS[Writer[W, S1], Writer[W, S2], Writer[W, T], W, S1, S2, T](s, setter, fa)
 }

writer/bind_test.go

@@ -34,33 +34,33 @@ var (
 )
 
 func getLastName(s utils.Initial) Writer[[]string, string] {
-	return Of[string](monoid)("Doe")
+	return Of[string](monoid, "Doe")
 }
 
 func getGivenName(s utils.WithLastName) Writer[[]string, string] {
-	return Of[string](monoid)("John")
+	return Of[string](monoid, "John")
 }
 
 func TestBind(t *testing.T) {
 
 	res := F.Pipe3(
-		Do[utils.Initial](monoid)(utils.Empty),
-		Bind(utils.SetLastName, getLastName),
-		Bind(utils.SetGivenName, getGivenName),
+		Do[utils.Initial](monoid, utils.Empty),
+		Bind(sg, utils.SetLastName, getLastName),
+		Bind(sg, utils.SetGivenName, getGivenName),
 		Map[[]string](utils.GetFullName),
 	)
 
-	assert.True(t, eq.Equals(res, Of[string](monoid)("John Doe")))
+	assert.True(t, eq.Equals(res, Of[string](monoid, "John Doe")))
 }
 
 func TestApS(t *testing.T) {
 
 	res := F.Pipe3(
-		Do[utils.Initial](monoid)(utils.Empty),
-		ApS(utils.SetLastName, Of[string](monoid)("Doe")),
-		ApS(utils.SetGivenName, Of[string](monoid)("John")),
+		Do[utils.Initial](monoid, utils.Empty),
+		ApS(sg, utils.SetLastName, Of[string](monoid, "Doe")),
+		ApS(sg, utils.SetGivenName, Of[string](monoid, "John")),
 		Map[[]string](utils.GetFullName),
 	)
 
-	assert.True(t, eq.Equals(res, Of[string](monoid)("John Doe")))
+	assert.True(t, eq.Equals(res, Of[string](monoid, "John Doe")))
 }

writer/generic/bind.go

@@ -16,26 +16,28 @@
 package generic
 
 import (
+	FCT "github.com/IBM/fp-go/function"
 	"github.com/IBM/fp-go/internal/apply"
 	C "github.com/IBM/fp-go/internal/chain"
 	F "github.com/IBM/fp-go/internal/functor"
 	M "github.com/IBM/fp-go/monoid"
+	P "github.com/IBM/fp-go/pair"
 	SG "github.com/IBM/fp-go/semigroup"
-	T "github.com/IBM/fp-go/tuple"
 )
 
 // Bind creates an empty context of type [S] to be used with the [Bind] operation
-func Do[GS ~func() T.Tuple3[S, W, SG.Semigroup[W]], W, S any](m M.Monoid[W]) func(S) GS {
-	return Of[GS, W, S](m)
+func Do[GS ~func() P.Pair[S, W], W, S any](m M.Monoid[W], s S) GS {
+	return Of[GS, W, S](m, s)
 }
 
 // Bind attaches the result of a computation to a context [S1] to produce a context [S2]
-func Bind[GS1 ~func() T.Tuple3[S1, W, SG.Semigroup[W]], GS2 ~func() T.Tuple3[S2, W, SG.Semigroup[W]], GT ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, S1, S2, A any](
+func Bind[GS1 ~func() P.Pair[S1, W], GS2 ~func() P.Pair[S2, W], GT ~func() P.Pair[A, W], W, S1, S2, A any](
+	s SG.Semigroup[W],
 	setter func(A) func(S1) S2,
 	f func(S1) GT,
 ) func(GS1) GS2 {
 	return C.Bind(
-		Chain[GS2, GS1, func(S1) GS2, W, S1, S2],
+		FCT.Bind1st(Chain[GS2, GS1, func(S1) GS2, W, S1, S2], s),
 		Map[GS2, GT, func(A) S2, W, A, S2],
 		setter,
 		f,
@@ -43,7 +45,7 @@ func Bind[GS1 ~func() T.Tuple3[S1, W, SG.Semigroup[W]], GS2 ~func() T.Tuple3[S2,
 }
 
 // Let attaches the result of a computation to a context [S1] to produce a context [S2]
-func Let[GS1 ~func() T.Tuple3[S1, W, SG.Semigroup[W]], GS2 ~func() T.Tuple3[S2, W, SG.Semigroup[W]], W, S1, S2, A any](
+func Let[GS1 ~func() P.Pair[S1, W], GS2 ~func() P.Pair[S2, W], W, S1, S2, A any](
 	key func(A) func(S1) S2,
 	f func(S1) A,
 ) func(GS1) GS2 {
@@ -55,7 +57,7 @@ func Let[GS1 ~func() T.Tuple3[S1, W, SG.Semigroup[W]], GS2 ~func() T.Tuple3[S2,
 }
 
 // LetTo attaches the a value to a context [S1] to produce a context [S2]
-func LetTo[GS1 ~func() T.Tuple3[S1, W, SG.Semigroup[W]], GS2 ~func() T.Tuple3[S2, W, SG.Semigroup[W]], W, S1, S2, B any](
+func LetTo[GS1 ~func() P.Pair[S1, W], GS2 ~func() P.Pair[S2, W], W, S1, S2, B any](
 	key func(B) func(S1) S2,
 	b B,
 ) func(GS1) GS2 {
@@ -67,7 +69,7 @@ func LetTo[GS1 ~func() T.Tuple3[S1, W, SG.Semigroup[W]], GS2 ~func() T.Tuple3[S2
 }
 
 // BindTo initializes a new state [S1] from a value [T]
-func BindTo[GS1 ~func() T.Tuple3[S1, W, SG.Semigroup[W]], GT ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, S1, A any](
+func BindTo[GS1 ~func() P.Pair[S1, W], GT ~func() P.Pair[A, W], W, S1, A any](
 	setter func(A) S1,
 ) func(GT) GS1 {
 	return C.BindTo(
@@ -77,13 +79,14 @@ func BindTo[GS1 ~func() T.Tuple3[S1, W, SG.Semigroup[W]], GT ~func() T.Tuple3[A,
 }
 
 // ApS attaches a value to a context [S1] to produce a context [S2] by considering the context and the value concurrently
-func ApS[GS1 ~func() T.Tuple3[S1, W, SG.Semigroup[W]], GS2 ~func() T.Tuple3[S2, W, SG.Semigroup[W]], GT ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, S1, S2, A any](
+func ApS[GS1 ~func() P.Pair[S1, W], GS2 ~func() P.Pair[S2, W], GT ~func() P.Pair[A, W], W, S1, S2, A any](
+	s SG.Semigroup[W],
 	setter func(A) func(S1) S2,
 	fa GT,
 ) func(GS1) GS2 {
 	return apply.ApS(
-		Ap[GS2, func() T.Tuple3[func(A) S2, W, SG.Semigroup[W]], GT, W, A, S2],
-		Map[func() T.Tuple3[func(A) S2, W, SG.Semigroup[W]], GS1, func(S1) func(A) S2],
+		FCT.Bind1st(Ap[GS2, func() P.Pair[func(A) S2, W], GT, W, A, S2], s),
+		Map[func() P.Pair[func(A) S2, W], GS1, func(S1) func(A) S2],
 		setter,
 		fa,
 	)

writer/generic/eq.go

@@ -17,21 +17,18 @@ package generic
 
 import (
 	EQ "github.com/IBM/fp-go/eq"
-	SG "github.com/IBM/fp-go/semigroup"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
 // Constructs an equal predicate for a [Writer]
-func Eq[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A any](w EQ.Eq[W], a EQ.Eq[A]) EQ.Eq[GA] {
+func Eq[GA ~func() P.Pair[A, W], W, A any](w EQ.Eq[W], a EQ.Eq[A]) EQ.Eq[GA] {
+	eqp := P.Eq(a, w)
 	return EQ.FromEquals(func(l, r GA) bool {
-		ll := l()
-		rr := r()
-
-		return a.Equals(ll.F1, rr.F1) && w.Equals(ll.F2, rr.F2)
+		return eqp.Equals(l(), r())
 	})
 }
 
 // FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
-func FromStrictEquals[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A comparable]() EQ.Eq[GA] {
+func FromStrictEquals[GA ~func() P.Pair[A, W], W, A comparable]() EQ.Eq[GA] {
 	return Eq[GA](EQ.FromStrictEquals[W](), EQ.FromStrictEquals[A]())
 }

writer/generic/monad.go

@@ -0,0 +1,106 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	"github.com/IBM/fp-go/internal/applicative"
+	"github.com/IBM/fp-go/internal/functor"
+	"github.com/IBM/fp-go/internal/monad"
+	"github.com/IBM/fp-go/internal/pointed"
+	M "github.com/IBM/fp-go/monoid"
+	P "github.com/IBM/fp-go/pair"
+	SG "github.com/IBM/fp-go/semigroup"
+)
+
+type writerPointed[GA ~func() P.Pair[A, W], W, A any] struct {
+	m M.Monoid[W]
+}
+
+type writerFunctor[GB ~func() P.Pair[B, W], GA ~func() P.Pair[A, W], W, A, B any] struct{}
+
+type writerApplicative[GB ~func() P.Pair[B, W], GAB ~func() P.Pair[func(A) B, W], GA ~func() P.Pair[A, W], W, A, B any] struct {
+	s SG.Semigroup[W]
+	m M.Monoid[W]
+}
+
+type writerMonad[GB ~func() P.Pair[B, W], GAB ~func() P.Pair[func(A) B, W], GA ~func() P.Pair[A, W], W, A, B any] struct {
+	s SG.Semigroup[W]
+	m M.Monoid[W]
+}
+
+func (o *writerPointed[GA, W, A]) Of(a A) GA {
+	return Of[GA](o.m, a)
+}
+
+func (o *writerApplicative[GB, GAB, GA, W, A, B]) Of(a A) GA {
+	return Of[GA](o.m, a)
+}
+
+func (o *writerMonad[GB, GAB, GA, W, A, B]) Of(a A) GA {
+	return Of[GA](o.m, a)
+}
+
+func (o *writerFunctor[GB, GA, W, A, B]) Map(f func(A) B) func(GA) GB {
+	return Map[GB, GA](f)
+}
+
+func (o *writerApplicative[GB, GAB, GA, W, A, B]) Map(f func(A) B) func(GA) GB {
+	return Map[GB, GA](f)
+}
+
+func (o *writerMonad[GB, GAB, GA, W, A, B]) Map(f func(A) B) func(GA) GB {
+	return Map[GB, GA](f)
+}
+
+func (o *writerMonad[GB, GAB, GA, W, A, B]) Chain(f func(A) GB) func(GA) GB {
+	return Chain[GB, GA](o.s, f)
+}
+
+func (o *writerApplicative[GB, GAB, GA, W, A, B]) Ap(fa GA) func(GAB) GB {
+	return Ap[GB, GAB, GA](o.s, fa)
+}
+
+func (o *writerMonad[GB, GAB, GA, W, A, B]) Ap(fa GA) func(GAB) GB {
+	return Ap[GB, GAB, GA](o.s, fa)
+}
+
+// Pointed implements the pointed operations for [Writer]
+func Pointed[GA ~func() P.Pair[A, W], W, A any](m M.Monoid[W]) pointed.Pointed[A, GA] {
+	return &writerPointed[GA, W, A]{
+		m: m,
+	}
+}
+
+// Functor implements the functor operations for [Writer]
+func Functor[GB ~func() P.Pair[B, W], GA ~func() P.Pair[A, W], W, A, B any]() functor.Functor[A, B, GA, GB] {
+	return &writerFunctor[GB, GA, W, A, B]{}
+}
+
+// Applicative implements the applicative operations for [Writer]
+func Applicative[GB ~func() P.Pair[B, W], GAB ~func() P.Pair[func(A) B, W], GA ~func() P.Pair[A, W], W, A, B any](m M.Monoid[W]) applicative.Applicative[A, B, GA, GB, GAB] {
+	return &writerApplicative[GB, GAB, GA, W, A, B]{
+		s: M.ToSemigroup(m),
+		m: m,
+	}
+}
+
+// Monad implements the monadic operations for [Writer]
+func Monad[GB ~func() P.Pair[B, W], GAB ~func() P.Pair[func(A) B, W], GA ~func() P.Pair[A, W], W, A, B any](m M.Monoid[W]) monad.Monad[A, B, GA, GB, GAB] {
+	return &writerMonad[GB, GAB, GA, W, A, B]{
+		s: M.ToSemigroup(m),
+		m: m,
+	}
+}

writer/generic/writer.go

@@ -21,133 +21,137 @@ import (
 	FC "github.com/IBM/fp-go/internal/functor"
 	IO "github.com/IBM/fp-go/io/generic"
 	M "github.com/IBM/fp-go/monoid"
+	P "github.com/IBM/fp-go/pair"
 	SG "github.com/IBM/fp-go/semigroup"
-	T "github.com/IBM/fp-go/tuple"
 )
 
-func Tell[GA ~func() T.Tuple3[any, W, SG.Semigroup[W]], W any](s SG.Semigroup[W]) func(W) GA {
-	return F.Flow2(
-		F.Bind13of3(T.MakeTuple3[any, W, SG.Semigroup[W]])(nil, s),
-		IO.Of[GA],
-	)
+var (
+	undefined any = struct{}{}
+)
+
+func Tell[GA ~func() P.Pair[any, W], W any](w W) GA {
+	return IO.Of[GA](P.MakePair[any](undefined, w))
 }
 
-func Of[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A any](m M.Monoid[W]) func(A) GA {
-	return F.Flow2(
-		F.Bind23of3(T.MakeTuple3[A, W, SG.Semigroup[W]])(m.Empty(), M.ToSemigroup(m)),
-		IO.Of[GA],
-	)
+func Of[GA ~func() P.Pair[A, W], W, A any](m M.Monoid[W], a A) GA {
+	return IO.Of[GA](P.MakePair(a, m.Empty()))
 }
 
 // Listen modifies the result to include the changes to the accumulator
-func Listen[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], GTA ~func() T.Tuple3[T.Tuple2[A, W], W, SG.Semigroup[W]], W, A any](fa GA) GTA {
-	return func() T.Tuple3[T.Tuple2[A, W], W, SG.Semigroup[W]] {
+func Listen[GA ~func() P.Pair[A, W], GTA ~func() P.Pair[P.Pair[A, W], W], W, A any](fa GA) GTA {
+	return func() P.Pair[P.Pair[A, W], W] {
 		t := fa()
-		return T.MakeTuple3(T.MakeTuple2(t.F1, t.F2), t.F2, t.F3)
+		return P.MakePair(t, P.Tail(t))
 	}
 }
 
 // Pass applies the returned function to the accumulator
-func Pass[GFA ~func() T.Tuple3[T.Tuple2[A, FCT], W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], FCT ~func(W) W, W, A any](fa GFA) GA {
-	return func() T.Tuple3[A, W, SG.Semigroup[W]] {
+func Pass[GFA ~func() P.Pair[P.Pair[A, FCT], W], GA ~func() P.Pair[A, W], FCT ~func(W) W, W, A any](fa GFA) GA {
+	return func() P.Pair[A, W] {
 		t := fa()
-		return T.MakeTuple3(t.F1.F1, t.F1.F2(t.F2), t.F3)
+		a := P.Head(t)
+		return P.MakePair(P.Head(a), P.Tail(a)(P.Tail(t)))
 	}
 }
 
-func MonadMap[GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], FCT ~func(A) B, W, A, B any](fa GA, f FCT) GB {
-	return IO.MonadMap[GA, GB](fa, T.Map3(f, F.Identity[W], F.Identity[SG.Semigroup[W]]))
+func MonadMap[GB ~func() P.Pair[B, W], GA ~func() P.Pair[A, W], FCT ~func(A) B, W, A, B any](fa GA, f FCT) GB {
+	return IO.MonadMap[GA, GB](fa, P.Map[W](f))
 }
 
-func Map[GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], FCT ~func(A) B, W, A, B any](f FCT) func(GA) GB {
-	return IO.Map[GA, GB](T.Map3(f, F.Identity[W], F.Identity[SG.Semigroup[W]]))
+func Map[GB ~func() P.Pair[B, W], GA ~func() P.Pair[A, W], FCT ~func(A) B, W, A, B any](f FCT) func(GA) GB {
+	return IO.Map[GA, GB](P.Map[W](f))
 }
 
-func MonadChain[GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], FCT ~func(A) GB, W, A, B any](fa GA, f FCT) GB {
-	return func() T.Tuple3[B, W, SG.Semigroup[W]] {
+func MonadChain[GB ~func() P.Pair[B, W], GA ~func() P.Pair[A, W], FCT ~func(A) GB, W, A, B any](s SG.Semigroup[W], fa GA, f FCT) GB {
+	return func() P.Pair[B, W] {
 		a := fa()
-		b := f(a.F1)()
+		b := f(P.Head(a))()
 
-		return T.MakeTuple3(b.F1, b.F3.Concat(a.F2, b.F2), b.F3)
+		return P.MakePair(P.Head(b), s.Concat(P.Tail(a), P.Tail(b)))
 	}
 }
 
-func Chain[GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], FCT ~func(A) GB, W, A, B any](f FCT) func(GA) GB {
-	return F.Bind2nd(MonadChain[GB, GA, FCT, W, A, B], f)
+func Chain[GB ~func() P.Pair[B, W], GA ~func() P.Pair[A, W], FCT ~func(A) GB, W, A, B any](s SG.Semigroup[W], f FCT) func(GA) GB {
+	return func(fa GA) GB {
+		return MonadChain(s, fa, f)
+	}
 }
 
-func MonadAp[GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], GAB ~func() T.Tuple3[func(A) B, W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A, B any](fab GAB, fa GA) GB {
-	return func() T.Tuple3[B, W, SG.Semigroup[W]] {
+func MonadAp[GB ~func() P.Pair[B, W], GAB ~func() P.Pair[func(A) B, W], GA ~func() P.Pair[A, W], W, A, B any](s SG.Semigroup[W], fab GAB, fa GA) GB {
+	return func() P.Pair[B, W] {
 		f := fab()
 		a := fa()
 
-		return T.MakeTuple3(f.F1(a.F1), f.F3.Concat(f.F2, a.F2), f.F3)
+		return P.MakePair(P.Head(f)(P.Head(a)), s.Concat(P.Tail(f), P.Tail(a)))
 	}
 }
 
-func Ap[GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], GAB ~func() T.Tuple3[func(A) B, W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A, B any](ga GA) func(GAB) GB {
-	return F.Bind2nd(MonadAp[GB, GAB, GA], ga)
+func Ap[GB ~func() P.Pair[B, W], GAB ~func() P.Pair[func(A) B, W], GA ~func() P.Pair[A, W], W, A, B any](s SG.Semigroup[W], ga GA) func(GAB) GB {
+	return func(fab GAB) GB {
+		return MonadAp[GB](s, fab, ga)
+	}
 }
 
-func MonadChainFirst[GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], FCT ~func(A) GB, W, A, B any](ma GA, f FCT) GA {
+func MonadChainFirst[GB ~func() P.Pair[B, W], GA ~func() P.Pair[A, W], FCT ~func(A) GB, W, A, B any](s SG.Semigroup[W], ma GA, f FCT) GA {
 	return C.MonadChainFirst(
-		MonadChain[GA, GA, func(A) GA],
+		F.Bind1of3(MonadChain[GA, GA, func(A) GA])(s),
 		MonadMap[GA, GB, func(B) A],
 		ma,
 		f,
 	)
 }
 
-func ChainFirst[GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], FCT ~func(A) GB, W, A, B any](f FCT) func(GA) GA {
+func ChainFirst[GB ~func() P.Pair[B, W], GA ~func() P.Pair[A, W], FCT ~func(A) GB, W, A, B any](s SG.Semigroup[W], f FCT) func(GA) GA {
 	return C.ChainFirst(
-		Chain[GA, GA, func(A) GA],
+		F.Bind1st(Chain[GA, GA, func(A) GA], s),
 		Map[GA, GB, func(B) A],
 		f,
 	)
 }
 
-func Flatten[GAA ~func() T.Tuple3[GA, W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A any](mma GAA) GA {
-	return MonadChain[GA, GAA, func(GA) GA](mma, F.Identity[GA])
+func Flatten[GAA ~func() P.Pair[GA, W], GA ~func() P.Pair[A, W], W, A any](s SG.Semigroup[W], mma GAA) GA {
+	return MonadChain[GA, GAA, func(GA) GA](s, mma, F.Identity[GA])
 }
 
-func Execute[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A any](fa GA) W {
-	return fa().F2
+func Execute[GA ~func() P.Pair[A, W], W, A any](fa GA) W {
+	return P.Tail(fa())
 }
 
-func Evaluate[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A any](fa GA) A {
-	return fa().F1
+func Evaluate[GA ~func() P.Pair[A, W], W, A any](fa GA) A {
+	return P.Head(fa())
 }
 
 // MonadCensor modifies the final accumulator value by applying a function
-func MonadCensor[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], FCT ~func(W) W, W, A any](fa GA, f FCT) GA {
-	return IO.MonadMap[GA, GA](fa, T.Map3(F.Identity[A], f, F.Identity[SG.Semigroup[W]]))
+func MonadCensor[GA ~func() P.Pair[A, W], FCT ~func(W) W, W, A any](fa GA, f FCT) GA {
+	return IO.MonadMap[GA, GA](fa, P.MapTail[A](f))
 }
 
 // Censor modifies the final accumulator value by applying a function
-func Censor[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], FCT ~func(W) W, W, A any](f FCT) func(GA) GA {
-	return IO.Map[GA, GA](T.Map3(F.Identity[A], f, F.Identity[SG.Semigroup[W]]))
+func Censor[GA ~func() P.Pair[A, W], FCT ~func(W) W, W, A any](f FCT) func(GA) GA {
+	return IO.Map[GA, GA](P.MapTail[A](f))
 }
 
 // MonadListens projects a value from modifications made to the accumulator during an action
-func MonadListens[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], GAB ~func() T.Tuple3[T.Tuple2[A, B], W, SG.Semigroup[W]], FCT ~func(W) B, W, A, B any](fa GA, f FCT) GAB {
-	return func() T.Tuple3[T.Tuple2[A, B], W, SG.Semigroup[W]] {
+func MonadListens[GA ~func() P.Pair[A, W], GAB ~func() P.Pair[P.Pair[A, B], W], FCT ~func(W) B, W, A, B any](fa GA, f FCT) GAB {
+	return func() P.Pair[P.Pair[A, B], W] {
 		a := fa()
-		return T.MakeTuple3(T.MakeTuple2(a.F1, f(a.F2)), a.F2, a.F3)
+		t := P.Tail(a)
+		return P.MakePair(P.MakePair(P.Head(a), f(t)), t)
 	}
 }
 
 // Listens projects a value from modifications made to the accumulator during an action
-func Listens[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], GAB ~func() T.Tuple3[T.Tuple2[A, B], W, SG.Semigroup[W]], FCT ~func(W) B, W, A, B any](f FCT) func(GA) GAB {
+func Listens[GA ~func() P.Pair[A, W], GAB ~func() P.Pair[P.Pair[A, B], W], FCT ~func(W) B, W, A, B any](f FCT) func(GA) GAB {
 	return F.Bind2nd(MonadListens[GA, GAB, FCT], f)
 }
 
-func MonadFlap[FAB ~func(A) B, GFAB ~func() T.Tuple3[FAB, W, SG.Semigroup[W]], GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], W, A, B any](fab GFAB, a A) GB {
+func MonadFlap[FAB ~func(A) B, GFAB ~func() P.Pair[FAB, W], GB ~func() P.Pair[B, W], W, A, B any](fab GFAB, a A) GB {
 	return FC.MonadFlap(
 		MonadMap[GB, GFAB, func(FAB) B],
 		fab,
 		a)
 }
 
-func Flap[FAB ~func(A) B, GFAB ~func() T.Tuple3[FAB, W, SG.Semigroup[W]], GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], W, A, B any](a A) func(GFAB) GB {
+func Flap[FAB ~func(A) B, GFAB ~func() P.Pair[FAB, W], GB ~func() P.Pair[B, W], W, A, B any](a A) func(GFAB) GB {
 	return FC.Flap(Map[GB, GFAB, func(FAB) B], a)
 }

writer/monad.go

@@ -0,0 +1,45 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package writer
+
+import (
+	"github.com/IBM/fp-go/internal/applicative"
+	"github.com/IBM/fp-go/internal/functor"
+	"github.com/IBM/fp-go/internal/monad"
+	"github.com/IBM/fp-go/internal/pointed"
+	M "github.com/IBM/fp-go/monoid"
+	G "github.com/IBM/fp-go/writer/generic"
+)
+
+// Pointed implements the pointed operations for [Writer]
+func Pointed[W, A any](m M.Monoid[W]) pointed.Pointed[A, Writer[W, A]] {
+	return G.Pointed[Writer[W, A], W, A](m)
+}
+
+// Functor implements the pointed operations for [Writer]
+func Functor[W, A, B any]() functor.Functor[A, B, Writer[W, A], Writer[W, B]] {
+	return G.Functor[Writer[W, B], Writer[W, A], W, A, B]()
+}
+
+// Applicative implements the applicative operations for [Writer]
+func Applicative[W, A, B any](m M.Monoid[W]) applicative.Applicative[A, B, Writer[W, A], Writer[W, B], Writer[W, func(A) B]] {
+	return G.Applicative[Writer[W, B], Writer[W, func(A) B], Writer[W, A]](m)
+}
+
+// Monad implements the monadic operations for [Writer]
+func Monad[W, A, B any](m M.Monoid[W]) monad.Monad[A, B, Writer[W, A], Writer[W, B], Writer[W, func(A) B]] {
+	return G.Monad[Writer[W, B], Writer[W, func(A) B], Writer[W, A]](m)
+}

writer/testing/laws.go

@@ -37,39 +37,40 @@ func AssertLaws[W, A, B, C any](t *testing.T,
 	bc func(B) C,
 ) func(a A) bool {
 
-	return L.AssertLaws(t,
+	fofc := WRT.Pointed[W, C](m)
+	fofaa := WRT.Pointed[W, func(A) A](m)
+	fofbc := WRT.Pointed[W, func(B) C](m)
+	fofabb := WRT.Pointed[W, func(func(A) B) B](m)
+
+	fmap := WRT.Functor[W, func(B) C, func(func(A) B) func(A) C]()
+
+	fapabb := WRT.Applicative[W, func(A) B, B](m)
+	fapabac := WRT.Applicative[W, func(A) B, func(A) C](m)
+
+	maa := WRT.Monad[W, A, A](m)
+	mab := WRT.Monad[W, A, B](m)
+	mac := WRT.Monad[W, A, C](m)
+	mbc := WRT.Monad[W, B, C](m)
+
+	return L.MonadAssertLaws(t,
 		WRT.Eq(eqw, eqa),
 		WRT.Eq(eqw, eqb),
 		WRT.Eq(eqw, eqc),
 
-		WRT.Of[A](m),
-		WRT.Of[B](m),
-		WRT.Of[C](m),
+		fofc,
+		fofaa,
+		fofbc,
+		fofabb,
 
-		WRT.Of[func(A) A](m),
-		WRT.Of[func(A) B](m),
-		WRT.Of[func(B) C](m),
-		WRT.Of[func(func(A) B) B](m),
+		fmap,
 
-		WRT.MonadMap[func(A) A, W, A, A],
-		WRT.MonadMap[func(A) B, W, A, B],
-		WRT.MonadMap[func(A) C, W, A, C],
-		WRT.MonadMap[func(B) C, W, B, C],
+		fapabb,
+		fapabac,
 
-		WRT.MonadMap[func(func(B) C) func(func(A) B) func(A) C, W, func(B) C, func(func(A) B) func(A) C],
-
-		WRT.MonadChain[func(A) WRT.Writer[W, A], W, A, A],
-		WRT.MonadChain[func(A) WRT.Writer[W, B], W, A, B],
-		WRT.MonadChain[func(A) WRT.Writer[W, C], W, A, C],
-		WRT.MonadChain[func(B) WRT.Writer[W, C], W, B, C],
-
-		WRT.MonadAp[A, A, W],
-		WRT.MonadAp[B, A, W],
-		WRT.MonadAp[C, B, W],
-		WRT.MonadAp[C, A, W],
-
-		WRT.MonadAp[B, func(A) B, W],
-		WRT.MonadAp[func(A) C, func(A) B, W],
+		maa,
+		mab,
+		mac,
+		mbc,
 
 		ab,
 		bc,

writer/writer.go

@@ -19,30 +19,30 @@ import (
 	EM "github.com/IBM/fp-go/endomorphism"
 	IO "github.com/IBM/fp-go/io"
 	M "github.com/IBM/fp-go/monoid"
-	S "github.com/IBM/fp-go/semigroup"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
+	SG "github.com/IBM/fp-go/semigroup"
 	G "github.com/IBM/fp-go/writer/generic"
 )
 
-type Writer[W, A any] IO.IO[T.Tuple3[A, W, S.Semigroup[W]]]
+type Writer[W, A any] IO.IO[P.Pair[A, W]]
 
 // Tell appends a value to the accumulator
-func Tell[W any](s S.Semigroup[W]) func(W) Writer[W, any] {
-	return G.Tell[Writer[W, any]](s)
+func Tell[W any](w W) Writer[W, any] {
+	return G.Tell[Writer[W, any]](w)
 }
 
-func Of[A, W any](m M.Monoid[W]) func(A) Writer[W, A] {
-	return G.Of[Writer[W, A]](m)
+func Of[A, W any](m M.Monoid[W], a A) Writer[W, A] {
+	return G.Of[Writer[W, A]](m, a)
 }
 
 // Listen modifies the result to include the changes to the accumulator
-func Listen[W, A any](fa Writer[W, A]) Writer[W, T.Tuple2[A, W]] {
-	return G.Listen[Writer[W, A], Writer[W, T.Tuple2[A, W]], W, A](fa)
+func Listen[W, A any](fa Writer[W, A]) Writer[W, P.Pair[A, W]] {
+	return G.Listen[Writer[W, A], Writer[W, P.Pair[A, W]], W, A](fa)
 }
 
 // Pass applies the returned function to the accumulator
-func Pass[W, A any](fa Writer[W, T.Tuple2[A, EM.Endomorphism[W]]]) Writer[W, A] {
-	return G.Pass[Writer[W, T.Tuple2[A, EM.Endomorphism[W]]], Writer[W, A]](fa)
+func Pass[W, A any](fa Writer[W, P.Pair[A, EM.Endomorphism[W]]]) Writer[W, A] {
+	return G.Pass[Writer[W, P.Pair[A, EM.Endomorphism[W]]], Writer[W, A]](fa)
 }
 
 func MonadMap[FCT ~func(A) B, W, A, B any](fa Writer[W, A], f FCT) Writer[W, B] {
@@ -53,32 +53,32 @@ func Map[W any, FCT ~func(A) B, A, B any](f FCT) func(Writer[W, A]) Writer[W, B]
 	return G.Map[Writer[W, B], Writer[W, A]](f)
 }
 
-func MonadChain[FCT ~func(A) Writer[W, B], W, A, B any](fa Writer[W, A], fct FCT) Writer[W, B] {
-	return G.MonadChain[Writer[W, B], Writer[W, A], FCT](fa, fct)
+func MonadChain[FCT ~func(A) Writer[W, B], W, A, B any](s SG.Semigroup[W], fa Writer[W, A], fct FCT) Writer[W, B] {
+	return G.MonadChain[Writer[W, B], Writer[W, A], FCT](s, fa, fct)
 }
 
-func Chain[A, B, W any](fa func(A) Writer[W, B]) func(Writer[W, A]) Writer[W, B] {
-	return G.Chain[Writer[W, B], Writer[W, A], func(A) Writer[W, B]](fa)
+func Chain[A, B, W any](s SG.Semigroup[W], fa func(A) Writer[W, B]) func(Writer[W, A]) Writer[W, B] {
+	return G.Chain[Writer[W, B], Writer[W, A], func(A) Writer[W, B]](s, fa)
 }
 
-func MonadAp[B, A, W any](fab Writer[W, func(A) B], fa Writer[W, A]) Writer[W, B] {
-	return G.MonadAp[Writer[W, B], Writer[W, func(A) B], Writer[W, A]](fab, fa)
+func MonadAp[B, A, W any](s SG.Semigroup[W], fab Writer[W, func(A) B], fa Writer[W, A]) Writer[W, B] {
+	return G.MonadAp[Writer[W, B], Writer[W, func(A) B], Writer[W, A]](s, fab, fa)
 }
 
-func Ap[B, A, W any](fa Writer[W, A]) func(Writer[W, func(A) B]) Writer[W, B] {
-	return G.Ap[Writer[W, B], Writer[W, func(A) B], Writer[W, A]](fa)
+func Ap[B, A, W any](s SG.Semigroup[W], fa Writer[W, A]) func(Writer[W, func(A) B]) Writer[W, B] {
+	return G.Ap[Writer[W, B], Writer[W, func(A) B], Writer[W, A]](s, fa)
 }
 
-func MonadChainFirst[FCT ~func(A) Writer[W, B], W, A, B any](fa Writer[W, A], fct FCT) Writer[W, A] {
-	return G.MonadChainFirst[Writer[W, B], Writer[W, A], FCT](fa, fct)
+func MonadChainFirst[FCT ~func(A) Writer[W, B], W, A, B any](s SG.Semigroup[W], fa Writer[W, A], fct FCT) Writer[W, A] {
+	return G.MonadChainFirst[Writer[W, B], Writer[W, A], FCT](s, fa, fct)
 }
 
-func ChainFirst[FCT ~func(A) Writer[W, B], W, A, B any](fct FCT) func(Writer[W, A]) Writer[W, A] {
-	return G.ChainFirst[Writer[W, B], Writer[W, A], FCT](fct)
+func ChainFirst[FCT ~func(A) Writer[W, B], W, A, B any](s SG.Semigroup[W], fct FCT) func(Writer[W, A]) Writer[W, A] {
+	return G.ChainFirst[Writer[W, B], Writer[W, A], FCT](s, fct)
 }
 
-func Flatten[W, A any](mma Writer[W, Writer[W, A]]) Writer[W, A] {
-	return G.Flatten[Writer[W, Writer[W, A]], Writer[W, A]](mma)
+func Flatten[W, A any](s SG.Semigroup[W], mma Writer[W, Writer[W, A]]) Writer[W, A] {
+	return G.Flatten[Writer[W, Writer[W, A]], Writer[W, A]](s, mma)
 }
 
 // Execute extracts the accumulator
@@ -102,13 +102,13 @@ func Censor[A any, FCT ~func(W) W, W any](f FCT) func(Writer[W, A]) Writer[W, A]
 }
 
 // MonadListens projects a value from modifications made to the accumulator during an action
-func MonadListens[A any, FCT ~func(W) B, W, B any](fa Writer[W, A], f FCT) Writer[W, T.Tuple2[A, B]] {
-	return G.MonadListens[Writer[W, A], Writer[W, T.Tuple2[A, B]]](fa, f)
+func MonadListens[A any, FCT ~func(W) B, W, B any](fa Writer[W, A], f FCT) Writer[W, P.Pair[A, B]] {
+	return G.MonadListens[Writer[W, A], Writer[W, P.Pair[A, B]]](fa, f)
 }
 
 // Listens projects a value from modifications made to the accumulator during an action
-func Listens[A any, FCT ~func(W) B, W, B any](f FCT) func(Writer[W, A]) Writer[W, T.Tuple2[A, B]] {
-	return G.Listens[Writer[W, A], Writer[W, T.Tuple2[A, B]]](f)
+func Listens[A any, FCT ~func(W) B, W, B any](f FCT) func(Writer[W, A]) Writer[W, P.Pair[A, B]] {
+	return G.Listens[Writer[W, A], Writer[W, P.Pair[A, B]]](f)
 }
 
 func MonadFlap[W, B, A any](fab Writer[W, func(A) B], a A) Writer[W, B] {

writer/writer_test.go

@@ -20,24 +20,22 @@ import (
 
 	A "github.com/IBM/fp-go/array"
 	F "github.com/IBM/fp-go/function"
-	S "github.com/IBM/fp-go/semigroup"
-	T "github.com/IBM/fp-go/tuple"
+	P "github.com/IBM/fp-go/pair"
 )
 
 func doubleAndLog(data int) Writer[[]string, int] {
-	return func() T.Tuple3[int, []string, S.Semigroup[[]string]] {
+	return func() P.Pair[int, []string] {
 		result := data * 2
-		return T.MakeTuple3(result, A.Of(fmt.Sprintf("Doubled %d -> %d", data, result)), sg)
+		return P.MakePair(result, A.Of(fmt.Sprintf("Doubled %d -> %d", data, result)))
 	}
 }
 
 func ExampleWriter_logging() {
 
-	res := F.Pipe4(
-		10,
-		Of[int](monoid),
-		Chain(doubleAndLog),
-		Chain(doubleAndLog),
+	res := F.Pipe3(
+		Of[int](monoid, 10),
+		Chain(sg, doubleAndLog),
+		Chain(sg, doubleAndLog),
 		Execute[[]string, int],
 	)