fix: add more tests

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

.github/workflows/build.yml

@@ -29,7 +29,7 @@ jobs:
         go-version: [ '1.20.x', '1.21.x', '1.22.x']
     steps:
       # full checkout for semantic-release
-      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           fetch-depth: 0
       - name: Set up go ${{ matrix.go-version }}
@@ -55,7 +55,7 @@ jobs:
     steps:
       # full checkout for semantic-release
       - name: Full checkout
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           fetch-depth: 0
 
@@ -82,7 +82,7 @@ jobs:
 
       - name: Semantic Release
         run: |
-          npx -p conventional-changelog-conventionalcommits -p semantic-release semantic-release --dry-run ${{env.DRY_RUN}}
+          npx -p "conventional-changelog-conventionalcommits@<8" -p semantic-release semantic-release --dry-run ${{env.DRY_RUN}}
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
   

README.md

@@ -199,9 +199,9 @@ For that reason these implementations are kept in the `internal` package. These
 
 The following table lists the relationship between some selected operators
 
-| Opertator | Parameter        | Monad           | Result   |
-| --------  | ---------------- | --------------- | -------- |
-| Map       | `func(A) B`      | `HKT[A]`        | `HKT[B]` |
-| Chain     | `func(A) HKT[B]` | `HKT[A]` | `HKT[B]` |
-| Ap        | `HKT[A]`         | `HKT[func(A)B]` | `HKT[B]` |
-| Flap      | `A`              | `HKT[func(A)B]` | `HKT[B]` |
+| Operator | Parameter        | Monad           | Result   |
+| -------- | ---------------- | --------------- | -------- |
+| Map      | `func(A) B`      | `HKT[A]`        | `HKT[B]` |
+| Chain    | `func(A) HKT[B]` | `HKT[A]`        | `HKT[B]` |
+| Ap       | `HKT[A]`         | `HKT[func(A)B]` | `HKT[B]` |
+| Flap     | `A`              | `HKT[func(A)B]` | `HKT[B]` |

cli/contextreaderioeither.go

@@ -365,6 +365,70 @@ func generateContextReaderIOEitherEitherize(f, fg *os.File, i int) {
 	fmt.Fprintln(fg, "}")
 }
 
+func generateContextReaderIOEitherUneitherize(f, fg *os.File, i int) {
+	// non generic version
+	fmt.Fprintf(f, "\n// Uneitherize%d converts a function with %d parameters returning a [ReaderIOEither[R]] into a function with %d parameters returning a tuple.\n// The first parameter is considered to be the [context.Context].\n", i, i+1, i)
+	fmt.Fprintf(f, "func Uneitherize%d[F ~func(", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j)
+	}
+	fmt.Fprintf(f, ") ReaderIOEither[R]")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ", R any](f F) func(context.Context")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ") (R, error) {\n")
+	fmt.Fprintf(f, "  return G.Uneitherize%d[ReaderIOEither[R]", i)
+
+	fmt.Fprintf(f, ", func(context.Context")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ")(R, error)](f)\n")
+	fmt.Fprintln(f, "}")
+
+	// generic version
+	fmt.Fprintf(fg, "\n// Uneitherize%d converts a function with %d parameters returning a [GRA] into a function with %d parameters returning a tuple.\n// The first parameter is considered to be the [context.Context].\n", i, i, i)
+	fmt.Fprintf(fg, "func Uneitherize%d[GRA ~func(context.Context) GIOA, F ~func(context.Context", i)
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", T%d", j)
+	}
+	fmt.Fprintf(fg, ") (R, error), GIOA ~func() E.Either[error, R]")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", T%d", j)
+	}
+	fmt.Fprintf(fg, ", R any](f func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "T%d", j)
+	}
+	fmt.Fprintf(fg, ") GRA) F {\n")
+
+	fmt.Fprintf(fg, "  return func(c context.Context")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", t%d T%d", j, j)
+	}
+	fmt.Fprintf(fg, ") (R, error) {\n")
+	fmt.Fprintf(fg, "    return E.UnwrapError(f(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "t%d", j)
+	}
+	fmt.Fprintf(fg, ")(c)())\n")
+	fmt.Fprintf(fg, "  }\n")
+	fmt.Fprintf(fg, "}\n")
+}
+
 func generateContextReaderIOEitherHelpers(filename string, count int) error {
 	dir, err := os.Getwd()
 	if err != nil {
@@ -420,10 +484,12 @@ import (
 `)
 
 	generateContextReaderIOEitherEitherize(f, fg, 0)
+	generateContextReaderIOEitherUneitherize(f, fg, 0)
 
 	for i := 1; i <= count; i++ {
 		// eitherize
 		generateContextReaderIOEitherEitherize(f, fg, i)
+		generateContextReaderIOEitherUneitherize(f, fg, i)
 		// sequenceT
 		generateContextReaderIOEitherSequenceT("")(f, fg, i)
 		generateContextReaderIOEitherSequenceT("Seq")(f, fg, i)

cli/readerioeither.go

@@ -136,6 +136,70 @@ func generateReaderIOEitherEitherize(f, fg *os.File, i int) {
 	fmt.Fprintf(fg, "}\n")
 }
 
+func generateReaderIOEitherUneitherize(f, fg *os.File, i int) {
+	// non generic version
+	fmt.Fprintf(f, "\n// Uneitherize%d converts a function with %d parameters returning a [ReaderIOEither[C, error, R]] into a function with %d parameters returning a tuple.\n// The first parameter is considered to be the context [C].\n", i, i+1, i)
+	fmt.Fprintf(f, "func Uneitherize%d[F ~func(", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j)
+	}
+	fmt.Fprintf(f, ") ReaderIOEither[C, error, R]")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ", C, R any](f F) func(C")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ") (R, error) {\n")
+	fmt.Fprintf(f, "  return G.Uneitherize%d[ReaderIOEither[C, error, R]", i)
+
+	fmt.Fprintf(f, ", func(C")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ")(R, error)](f)\n")
+	fmt.Fprintln(f, "}")
+
+	// generic version
+	fmt.Fprintf(fg, "\n// Uneitherize%d converts a function with %d parameters returning a [GRA] into a function with %d parameters returning a tuple.\n// The first parameter is considered to be the context [C].\n", i, i, i)
+	fmt.Fprintf(fg, "func Uneitherize%d[GRA ~func(C) GIOA, F ~func(C", i)
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", T%d", j)
+	}
+	fmt.Fprintf(fg, ") (R, error), GIOA ~func() E.Either[error, R]")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", T%d", j)
+	}
+	fmt.Fprintf(fg, ", C, R any](f func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "T%d", j)
+	}
+	fmt.Fprintf(fg, ") GRA) F {\n")
+
+	fmt.Fprintf(fg, "  return func(c C")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", t%d T%d", j, j)
+	}
+	fmt.Fprintf(fg, ") (R, error) {\n")
+	fmt.Fprintf(fg, "    return E.UnwrapError(f(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "t%d", j)
+	}
+	fmt.Fprintf(fg, ")(c)())\n")
+	fmt.Fprintf(fg, "  }\n")
+	fmt.Fprintf(fg, "}\n")
+}
+
 func generateReaderIOEitherHelpers(filename string, count int) error {
 	dir, err := os.Getwd()
 	if err != nil {
@@ -197,12 +261,16 @@ import (
 	generateReaderIOEitherFrom(f, fg, 0)
 	// eitherize
 	generateReaderIOEitherEitherize(f, fg, 0)
+	// uneitherize
+	generateReaderIOEitherUneitherize(f, fg, 0)
 
 	for i := 1; i <= count; i++ {
 		// from
 		generateReaderIOEitherFrom(f, fg, i)
 		// eitherize
 		generateReaderIOEitherEitherize(f, fg, i)
+		// uneitherize
+		generateReaderIOEitherUneitherize(f, fg, i)
 	}
 
 	return nil

cli/templates/functions.go

@@ -0,0 +1,15 @@
+package templates
+
+import (
+	"text/template"
+
+	E "github.com/IBM/fp-go/either"
+)
+
+var (
+	templateFunctions = template.FuncMap{}
+)
+
+func Parse(name, tmpl string) E.Either[error, *template.Template] {
+	return E.TryCatchError(template.New(name).Funcs(templateFunctions).Parse(tmpl))
+}

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-05-24 22:24:01.4250895 +0200 CEST m=+0.014515801
 
 import (
 	"context"
@@ -17,12 +17,24 @@ func Eitherize0[F ~func(context.Context) (R, error), R any](f F) func() ReaderIO
 	return G.Eitherize0[ReaderIOEither[R]](f)
 }
 
+// Uneitherize0 converts a function with 1 parameters returning a [ReaderIOEither[R]] into a function with 0 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize0[F ~func() ReaderIOEither[R], R any](f F) func(context.Context) (R, error) {
+	return G.Uneitherize0[ReaderIOEither[R], func(context.Context) (R, error)](f)
+}
+
 // Eitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize1]
 func Eitherize1[F ~func(context.Context, T0) (R, error), T0, R any](f F) func(T0) ReaderIOEither[R] {
 	return G.Eitherize1[ReaderIOEither[R]](f)
 }
 
+// Uneitherize1 converts a function with 2 parameters returning a [ReaderIOEither[R]] into a function with 1 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize1[F ~func(T0) ReaderIOEither[R], T0, R any](f F) func(context.Context, T0) (R, error) {
+	return G.Uneitherize1[ReaderIOEither[R], func(context.Context, T0) (R, error)](f)
+}
+
 // SequenceT1 converts 1 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple1].
 func SequenceT1[T1 any](t1 ReaderIOEither[T1]) ReaderIOEither[T.Tuple1[T1]] {
 	return G.SequenceT1[ReaderIOEither[T.Tuple1[T1]]](t1)
@@ -74,6 +86,12 @@ func Eitherize2[F ~func(context.Context, T0, T1) (R, error), T0, T1, R any](f F)
 	return G.Eitherize2[ReaderIOEither[R]](f)
 }
 
+// Uneitherize2 converts a function with 3 parameters returning a [ReaderIOEither[R]] into a function with 2 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize2[F ~func(T0, T1) ReaderIOEither[R], T0, T1, R any](f F) func(context.Context, T0, T1) (R, error) {
+	return G.Uneitherize2[ReaderIOEither[R], func(context.Context, T0, T1) (R, error)](f)
+}
+
 // SequenceT2 converts 2 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple2].
 func SequenceT2[T1, T2 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2]) ReaderIOEither[T.Tuple2[T1, T2]] {
 	return G.SequenceT2[ReaderIOEither[T.Tuple2[T1, T2]]](t1, t2)
@@ -125,6 +143,12 @@ func Eitherize3[F ~func(context.Context, T0, T1, T2) (R, error), T0, T1, T2, R a
 	return G.Eitherize3[ReaderIOEither[R]](f)
 }
 
+// Uneitherize3 converts a function with 4 parameters returning a [ReaderIOEither[R]] into a function with 3 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize3[F ~func(T0, T1, T2) ReaderIOEither[R], T0, T1, T2, R any](f F) func(context.Context, T0, T1, T2) (R, error) {
+	return G.Uneitherize3[ReaderIOEither[R], func(context.Context, T0, T1, T2) (R, error)](f)
+}
+
 // SequenceT3 converts 3 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple3].
 func SequenceT3[T1, T2, T3 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3]) ReaderIOEither[T.Tuple3[T1, T2, T3]] {
 	return G.SequenceT3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](t1, t2, t3)
@@ -176,6 +200,12 @@ func Eitherize4[F ~func(context.Context, T0, T1, T2, T3) (R, error), T0, T1, T2,
 	return G.Eitherize4[ReaderIOEither[R]](f)
 }
 
+// Uneitherize4 converts a function with 5 parameters returning a [ReaderIOEither[R]] into a function with 4 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize4[F ~func(T0, T1, T2, T3) ReaderIOEither[R], T0, T1, T2, T3, R any](f F) func(context.Context, T0, T1, T2, T3) (R, error) {
+	return G.Uneitherize4[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3) (R, error)](f)
+}
+
 // SequenceT4 converts 4 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple4].
 func SequenceT4[T1, T2, T3, T4 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4]) ReaderIOEither[T.Tuple4[T1, T2, T3, T4]] {
 	return G.SequenceT4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](t1, t2, t3, t4)
@@ -227,6 +257,12 @@ func Eitherize5[F ~func(context.Context, T0, T1, T2, T3, T4) (R, error), T0, T1,
 	return G.Eitherize5[ReaderIOEither[R]](f)
 }
 
+// Uneitherize5 converts a function with 6 parameters returning a [ReaderIOEither[R]] into a function with 5 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize5[F ~func(T0, T1, T2, T3, T4) ReaderIOEither[R], T0, T1, T2, T3, T4, R any](f F) func(context.Context, T0, T1, T2, T3, T4) (R, error) {
+	return G.Uneitherize5[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3, T4) (R, error)](f)
+}
+
 // SequenceT5 converts 5 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple5].
 func SequenceT5[T1, T2, T3, T4, T5 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5]) ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]] {
 	return G.SequenceT5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](t1, t2, t3, t4, t5)
@@ -278,6 +314,12 @@ func Eitherize6[F ~func(context.Context, T0, T1, T2, T3, T4, T5) (R, error), T0,
 	return G.Eitherize6[ReaderIOEither[R]](f)
 }
 
+// Uneitherize6 converts a function with 7 parameters returning a [ReaderIOEither[R]] into a function with 6 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize6[F ~func(T0, T1, T2, T3, T4, T5) ReaderIOEither[R], T0, T1, T2, T3, T4, T5, R any](f F) func(context.Context, T0, T1, T2, T3, T4, T5) (R, error) {
+	return G.Uneitherize6[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3, T4, T5) (R, error)](f)
+}
+
 // SequenceT6 converts 6 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple6].
 func SequenceT6[T1, T2, T3, T4, T5, T6 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6]) ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
 	return G.SequenceT6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](t1, t2, t3, t4, t5, t6)
@@ -329,6 +371,12 @@ func Eitherize7[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6) (R, error),
 	return G.Eitherize7[ReaderIOEither[R]](f)
 }
 
+// Uneitherize7 converts a function with 8 parameters returning a [ReaderIOEither[R]] into a function with 7 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize7[F ~func(T0, T1, T2, T3, T4, T5, T6) ReaderIOEither[R], T0, T1, T2, T3, T4, T5, T6, R any](f F) func(context.Context, T0, T1, T2, T3, T4, T5, T6) (R, error) {
+	return G.Uneitherize7[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3, T4, T5, T6) (R, error)](f)
+}
+
 // SequenceT7 converts 7 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple7].
 func SequenceT7[T1, T2, T3, T4, T5, T6, T7 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6], t7 ReaderIOEither[T7]) ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
 	return G.SequenceT7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](t1, t2, t3, t4, t5, t6, t7)
@@ -380,6 +428,12 @@ func Eitherize8[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7) (R, err
 	return G.Eitherize8[ReaderIOEither[R]](f)
 }
 
+// Uneitherize8 converts a function with 9 parameters returning a [ReaderIOEither[R]] into a function with 8 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize8[F ~func(T0, T1, T2, T3, T4, T5, T6, T7) ReaderIOEither[R], T0, T1, T2, T3, T4, T5, T6, T7, R any](f F) func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7) (R, error) {
+	return G.Uneitherize8[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7) (R, error)](f)
+}
+
 // SequenceT8 converts 8 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple8].
 func SequenceT8[T1, T2, T3, T4, T5, T6, T7, T8 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6], t7 ReaderIOEither[T7], t8 ReaderIOEither[T8]) ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
 	return G.SequenceT8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](t1, t2, t3, t4, t5, t6, t7, t8)
@@ -431,6 +485,12 @@ func Eitherize9[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R,
 	return G.Eitherize9[ReaderIOEither[R]](f)
 }
 
+// Uneitherize9 converts a function with 10 parameters returning a [ReaderIOEither[R]] into a function with 9 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize9[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) ReaderIOEither[R], T0, T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error) {
+	return G.Uneitherize9[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error)](f)
+}
+
 // SequenceT9 converts 9 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple9].
 func SequenceT9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6], t7 ReaderIOEither[T7], t8 ReaderIOEither[T8], t9 ReaderIOEither[T9]) ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
 	return G.SequenceT9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](t1, t2, t3, t4, t5, t6, t7, t8, t9)
@@ -482,6 +542,12 @@ func Eitherize10[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
 	return G.Eitherize10[ReaderIOEither[R]](f)
 }
 
+// Uneitherize10 converts a function with 11 parameters returning a [ReaderIOEither[R]] into a function with 10 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize10[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ReaderIOEither[R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f F) func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error) {
+	return G.Uneitherize10[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error)](f)
+}
+
 // SequenceT10 converts 10 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple10].
 func SequenceT10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6], t7 ReaderIOEither[T7], t8 ReaderIOEither[T8], t9 ReaderIOEither[T9], t10 ReaderIOEither[T10]) ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
 	return G.SequenceT10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)

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-05-24 22:24:01.4250895 +0200 CEST m=+0.014515801
 
 import (
 	"context"
@@ -19,12 +19,28 @@ func Eitherize0[GRA ~func(context.Context) GIOA, F ~func(context.Context) (R, er
 	return RE.Eitherize0[GRA](f)
 }
 
+// Uneitherize0 converts a function with 0 parameters returning a [GRA] into a function with 0 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize0[GRA ~func(context.Context) GIOA, F ~func(context.Context) (R, error), GIOA ~func() E.Either[error, R], R any](f func() GRA) F {
+	return func(c context.Context) (R, error) {
+		return E.UnwrapError(f()(c)())
+	}
+}
+
 // Eitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning a [GRA]
 // The inverse function is [Uneitherize1]
 func Eitherize1[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0) (R, error), GIOA ~func() E.Either[error, R], T0, R any](f F) func(T0) GRA {
 	return RE.Eitherize1[GRA](f)
 }
 
+// Uneitherize1 converts a function with 1 parameters returning a [GRA] into a function with 1 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize1[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0) (R, error), GIOA ~func() E.Either[error, R], T0, R any](f func(T0) GRA) F {
+	return func(c context.Context, t0 T0) (R, error) {
+		return E.UnwrapError(f(t0)(c)())
+	}
+}
+
 // SequenceT1 converts 1 readers into a reader of a [T.Tuple1].
 func SequenceT1[
 	GR_TUPLE1 ~func(context.Context) GIO_TUPLE1,
@@ -169,6 +185,14 @@ func Eitherize2[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize2[GRA](f)
 }
 
+// Uneitherize2 converts a function with 2 parameters returning a [GRA] into a function with 2 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize2[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1) (R, error), GIOA ~func() E.Either[error, R], T0, T1, R any](f func(T0, T1) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1) (R, error) {
+		return E.UnwrapError(f(t0, t1)(c)())
+	}
+}
+
 // SequenceT2 converts 2 readers into a reader of a [T.Tuple2].
 func SequenceT2[
 	GR_TUPLE2 ~func(context.Context) GIO_TUPLE2,
@@ -364,6 +388,14 @@ func Eitherize3[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize3[GRA](f)
 }
 
+// Uneitherize3 converts a function with 3 parameters returning a [GRA] into a function with 3 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize3[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, R any](f func(T0, T1, T2) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2)(c)())
+	}
+}
+
 // SequenceT3 converts 3 readers into a reader of a [T.Tuple3].
 func SequenceT3[
 	GR_TUPLE3 ~func(context.Context) GIO_TUPLE3,
@@ -610,6 +642,14 @@ func Eitherize4[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize4[GRA](f)
 }
 
+// Uneitherize4 converts a function with 4 parameters returning a [GRA] into a function with 4 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize4[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, R any](f func(T0, T1, T2, T3) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3)(c)())
+	}
+}
+
 // SequenceT4 converts 4 readers into a reader of a [T.Tuple4].
 func SequenceT4[
 	GR_TUPLE4 ~func(context.Context) GIO_TUPLE4,
@@ -907,6 +947,14 @@ func Eitherize5[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize5[GRA](f)
 }
 
+// Uneitherize5 converts a function with 5 parameters returning a [GRA] into a function with 5 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize5[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, R any](f func(T0, T1, T2, T3, T4) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4)(c)())
+	}
+}
+
 // SequenceT5 converts 5 readers into a reader of a [T.Tuple5].
 func SequenceT5[
 	GR_TUPLE5 ~func(context.Context) GIO_TUPLE5,
@@ -1255,6 +1303,14 @@ func Eitherize6[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize6[GRA](f)
 }
 
+// Uneitherize6 converts a function with 6 parameters returning a [GRA] into a function with 6 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize6[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, R any](f func(T0, T1, T2, T3, T4, T5) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5)(c)())
+	}
+}
+
 // SequenceT6 converts 6 readers into a reader of a [T.Tuple6].
 func SequenceT6[
 	GR_TUPLE6 ~func(context.Context) GIO_TUPLE6,
@@ -1654,6 +1710,14 @@ func Eitherize7[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize7[GRA](f)
 }
 
+// Uneitherize7 converts a function with 7 parameters returning a [GRA] into a function with 7 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize7[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, R any](f func(T0, T1, T2, T3, T4, T5, T6) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6)(c)())
+	}
+}
+
 // SequenceT7 converts 7 readers into a reader of a [T.Tuple7].
 func SequenceT7[
 	GR_TUPLE7 ~func(context.Context) GIO_TUPLE7,
@@ -2104,6 +2168,14 @@ func Eitherize8[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize8[GRA](f)
 }
 
+// Uneitherize8 converts a function with 8 parameters returning a [GRA] into a function with 8 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize8[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7)(c)())
+	}
+}
+
 // SequenceT8 converts 8 readers into a reader of a [T.Tuple8].
 func SequenceT8[
 	GR_TUPLE8 ~func(context.Context) GIO_TUPLE8,
@@ -2605,6 +2677,14 @@ func Eitherize9[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize9[GRA](f)
 }
 
+// Uneitherize9 converts a function with 9 parameters returning a [GRA] into a function with 9 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize9[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8)(c)())
+	}
+}
+
 // SequenceT9 converts 9 readers into a reader of a [T.Tuple9].
 func SequenceT9[
 	GR_TUPLE9 ~func(context.Context) GIO_TUPLE9,
@@ -3157,6 +3237,14 @@ func Eitherize10[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T
 	return RE.Eitherize10[GRA](f)
 }
 
+// Uneitherize10 converts a function with 10 parameters returning a [GRA] into a function with 10 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize10[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)(c)())
+	}
+}
+
 // SequenceT10 converts 10 readers into a reader of a [T.Tuple10].
 func SequenceT10[
 	GR_TUPLE10 ~func(context.Context) GIO_TUPLE10,

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

context/readerioeither/reader.go

@@ -25,6 +25,7 @@ import (
 	IOE "github.com/IBM/fp-go/ioeither"
 	L "github.com/IBM/fp-go/lazy"
 	O "github.com/IBM/fp-go/option"
+	RIO "github.com/IBM/fp-go/readerio"
 )
 
 func FromEither[A any](e ET.Either[error, A]) ReaderIOEither[A] {
@@ -192,8 +193,7 @@ func Memoize[A any](rdr ReaderIOEither[A]) ReaderIOEither[A] {
 }
 
 // Flatten converts a nested [ReaderIOEither] into a [ReaderIOEither]
-func Flatten[
-	A any](rdr ReaderIOEither[ReaderIOEither[A]]) ReaderIOEither[A] {
+func Flatten[A any](rdr ReaderIOEither[ReaderIOEither[A]]) ReaderIOEither[A] {
 	return G.Flatten[ReaderIOEither[ReaderIOEither[A]]](rdr)
 }
 
@@ -204,3 +204,15 @@ func MonadFlap[B, A any](fab ReaderIOEither[func(A) B], a A) ReaderIOEither[B] {
 func Flap[B, A any](a A) func(ReaderIOEither[func(A) B]) ReaderIOEither[B] {
 	return G.Flap[ReaderIOEither[func(A) B], ReaderIOEither[B]](a)
 }
+
+func Fold[A, B any](onLeft func(error) ReaderIOEither[B], onRight func(A) ReaderIOEither[B]) func(ReaderIOEither[A]) ReaderIOEither[B] {
+	return G.Fold[ReaderIOEither[B], ReaderIOEither[A]](onLeft, onRight)
+}
+
+func GetOrElse[A any](onLeft func(error) RIO.ReaderIO[context.Context, A]) func(ReaderIOEither[A]) RIO.ReaderIO[context.Context, A] {
+	return G.GetOrElse[RIO.ReaderIO[context.Context, A], ReaderIOEither[A]](onLeft)
+}
+
+func OrLeft[A any](onLeft func(error) RIO.ReaderIO[context.Context, error]) func(ReaderIOEither[A]) ReaderIOEither[A] {
+	return G.OrLeft[ReaderIOEither[A]](onLeft)
+}

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/urfave/cli/v2 v2.27.1
+	github.com/stretchr/testify v1.9.0
+	github.com/urfave/cli/v2 v2.27.2
 )
 
 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,19 @@
-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/urfave/cli/v2 v2.27.2 h1:6e0H+AkS+zDckwPCUrZkKX38mRaau4nL2uipkJpbkcI=
+github.com/urfave/cli/v2 v2.27.2/go.mod h1:g0+79LmHHATl7DAcHO99smiR/T7uGLw84w8Y42x+4eM=
+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)
+}

internal/testing/sequence.go

@@ -0,0 +1,64 @@
+// 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"
+
+	EQ "github.com/IBM/fp-go/eq"
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/functor"
+	"github.com/IBM/fp-go/internal/pointed"
+	"github.com/stretchr/testify/assert"
+)
+
+// SequenceArrayTest tests if the sequence operation works in case the operation cannot error
+func SequenceArrayTest[
+	HKTA,
+	HKTB,
+	HKTAA any, // HKT[[]A]
+](
+	eq EQ.Eq[HKTB],
+
+	pa pointed.Pointed[string, HKTA],
+	pb pointed.Pointed[bool, HKTB],
+	faa functor.Functor[[]string, bool, HKTAA, HKTB],
+	seq func([]HKTA) HKTAA,
+) func(count int) func(t *testing.T) {
+
+	return func(count int) func(t *testing.T) {
+
+		exp := make([]string, count)
+		good := make([]HKTA, count)
+		for i := 0; i < count; i++ {
+			val := fmt.Sprintf("TestData %d", i)
+			exp[i] = val
+			good[i] = pa.Of(val)
+		}
+
+		return func(t *testing.T) {
+			res := F.Pipe2(
+				good,
+				seq,
+				faa.Map(func(act []string) bool {
+					return assert.Equal(t, exp, act)
+				}),
+			)
+			assert.True(t, eq.Equals(res, pb.Of(true)))
+		}
+	}
+}

io/eq.go

@@ -24,3 +24,8 @@ import (
 func Eq[A any](e EQ.Eq[A]) EQ.Eq[IO[A]] {
 	return G.Eq[IO[A]](e)
 }
+
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
+func FromStrictEquals[A comparable]() EQ.Eq[IO[A]] {
+	return G.FromStrictEquals[IO[A]]()
+}

io/functor.go

@@ -0,0 +1,26 @@
+// 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 io
+
+import (
+	"github.com/IBM/fp-go/internal/functor"
+	G "github.com/IBM/fp-go/io/generic"
+)
+
+// Functor returns the monadic operations for [IO]
+func Functor[A, B any]() functor.Functor[A, B, IO[A], IO[B]] {
+	return G.Functor[A, B, IO[A], IO[B]]()
+}

io/gen.go

@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-10-23 08:30:56.7105551 +0200 CEST m=+0.011255201
+// 2024-02-29 16:19:10.2607969 +0100 CET m=+0.024787801
 
 package io
 

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/eq.go

@@ -33,3 +33,8 @@ func Eq[GA ~func() A, A any](e EQ.Eq[A]) EQ.Eq[GA] {
 		return eq(l, r)()
 	})
 }
+
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
+func FromStrictEquals[GA ~func() A, A comparable]() EQ.Eq[GA] {
+	return Eq[GA](EQ.FromStrictEquals[A]())
+}

io/generic/functor.go

@@ -0,0 +1,31 @@
+// 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/functor"
+)
+
+type ioFunctor[A, B any, GA ~func() A, GB ~func() B] struct{}
+
+func (o *ioFunctor[A, B, GA, GB]) Map(f func(A) B) func(GA) GB {
+	return Map[GA, GB, A, B](f)
+}
+
+// Functor implements the functoric operations for [IO]
+func Functor[A, B any, GA ~func() A, GB ~func() B]() functor.Functor[A, B, GA, GB] {
+	return &ioFunctor[A, B, GA, GB]{}
+}

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/pointed.go

@@ -0,0 +1,31 @@
+// 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/pointed"
+)
+
+type ioPointed[A any, GA ~func() A] struct{}
+
+func (o *ioPointed[A, GA]) Of(a A) GA {
+	return Of[GA, A](a)
+}
+
+// Pointed implements the pointedic operations for [IO]
+func Pointed[A any, GA ~func() A]() pointed.Pointed[A, GA] {
+	return &ioPointed[A, GA]{}
+}

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/pointed.go

@@ -0,0 +1,26 @@
+// 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 io
+
+import (
+	"github.com/IBM/fp-go/internal/pointed"
+	G "github.com/IBM/fp-go/io/generic"
+)
+
+// Pointed returns the monadic operations for [IO]
+func Pointed[A any]() pointed.Pointed[A, IO[A]] {
+	return G.Pointed[A, IO[A]]()
+}

io/sequence_test.go

@@ -0,0 +1,65 @@
+// 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 (
+	"fmt"
+
+	A "github.com/IBM/fp-go/array"
+	F "github.com/IBM/fp-go/function"
+	TST "github.com/IBM/fp-go/internal/testing"
+	"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())
+}
+
+func TestSequenceArray(t *testing.T) {
+
+	s := TST.SequenceArrayTest(
+		FromStrictEquals[bool](),
+		Pointed[string](),
+		Pointed[bool](),
+		Functor[[]string, bool](),
+		SequenceArray[string],
+	)
+
+	for i := 0; i < 10; i++ {
+		t.Run(fmt.Sprintf("TestSequenceArray %d", i), s(i))
+	}
+}

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/array_test.go

@@ -16,25 +16,13 @@
 package option
 
 import (
+	"fmt"
 	"testing"
 
-	F "github.com/IBM/fp-go/function"
+	TST "github.com/IBM/fp-go/internal/testing"
 	"github.com/stretchr/testify/assert"
 )
 
-func TestSequenceArray(t *testing.T) {
-
-	one := Of(1)
-	two := Of(2)
-
-	res := F.Pipe1(
-		[]Option[int]{one, two},
-		SequenceArray[int],
-	)
-
-	assert.Equal(t, res, Of([]int{1, 2}))
-}
-
 func TestCompactArray(t *testing.T) {
 	ar := []Option[string]{
 		Of("ok"),
@@ -45,3 +33,18 @@ func TestCompactArray(t *testing.T) {
 	res := CompactArray(ar)
 	assert.Equal(t, 2, len(res))
 }
+
+func TestSequenceArray(t *testing.T) {
+
+	s := TST.SequenceArrayTest(
+		FromStrictEquals[bool](),
+		Pointed[string](),
+		Pointed[bool](),
+		Functor[[]string, bool](),
+		SequenceArray[string],
+	)
+
+	for i := 0; i < 10; i++ {
+		t.Run(fmt.Sprintf("TestSequenceArray %d", i), s(i))
+	}
+}

option/functor.go

@@ -0,0 +1,31 @@
+// 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 (
+	"github.com/IBM/fp-go/internal/functor"
+)
+
+type optionFunctor[A, B any] struct{}
+
+func (o *optionFunctor[A, B]) Map(f func(A) B) func(Option[A]) Option[B] {
+	return Map[A, B](f)
+}
+
+// Functor implements the functoric operations for [Option]
+func Functor[A, B any]() functor.Functor[A, B, Option[A], Option[B]] {
+	return &optionFunctor[A, B]{}
+}

option/gen.go

@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-10-23 08:31:07.8687134 +0200 CEST m=+0.012222901
+// 2024-02-29 16:19:19.6336283 +0100 CET m=+0.018011101
 
 package option
 

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

option/pointed.go

@@ -0,0 +1,31 @@
+// 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 (
+	"github.com/IBM/fp-go/internal/pointed"
+)
+
+type optionPointed[A any] struct{}
+
+func (o *optionPointed[A]) Of(a A) Option[A] {
+	return Of[A](a)
+}
+
+// Pointed implements the Pointed operations for [Option]
+func Pointed[A any]() pointed.Pointed[A, Option[A]] {
+	return &optionPointed[A]{}
+}

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-05-24 17:26:07.2835624 +0200 CEST m=+0.011499301
 
 package readerioeither
 
@@ -20,6 +20,12 @@ func Eitherize0[F ~func(C) (R, error), C, R any](f F) func() ReaderIOEither[C, e
 	return G.Eitherize0[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize0 converts a function with 1 parameters returning a [ReaderIOEither[C, error, R]] into a function with 0 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize0[F ~func() ReaderIOEither[C, error, R], C, R any](f F) func(C) (R, error) {
+	return G.Uneitherize0[ReaderIOEither[C, error, R], func(C) (R, error)](f)
+}
+
 // From1 converts a function with 2 parameters returning a tuple into a function with 1 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From1[F ~func(C, T0) func() (R, error), T0, C, R any](f F) func(T0) ReaderIOEither[C, error, R] {
@@ -32,6 +38,12 @@ func Eitherize1[F ~func(C, T0) (R, error), T0, C, R any](f F) func(T0) ReaderIOE
 	return G.Eitherize1[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize1 converts a function with 2 parameters returning a [ReaderIOEither[C, error, R]] into a function with 1 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize1[F ~func(T0) ReaderIOEither[C, error, R], T0, C, R any](f F) func(C, T0) (R, error) {
+	return G.Uneitherize1[ReaderIOEither[C, error, R], func(C, T0) (R, error)](f)
+}
+
 // From2 converts a function with 3 parameters returning a tuple into a function with 2 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From2[F ~func(C, T0, T1) func() (R, error), T0, T1, C, R any](f F) func(T0, T1) ReaderIOEither[C, error, R] {
@@ -44,6 +56,12 @@ func Eitherize2[F ~func(C, T0, T1) (R, error), T0, T1, C, R any](f F) func(T0, T
 	return G.Eitherize2[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize2 converts a function with 3 parameters returning a [ReaderIOEither[C, error, R]] into a function with 2 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize2[F ~func(T0, T1) ReaderIOEither[C, error, R], T0, T1, C, R any](f F) func(C, T0, T1) (R, error) {
+	return G.Uneitherize2[ReaderIOEither[C, error, R], func(C, T0, T1) (R, error)](f)
+}
+
 // From3 converts a function with 4 parameters returning a tuple into a function with 3 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From3[F ~func(C, T0, T1, T2) func() (R, error), T0, T1, T2, C, R any](f F) func(T0, T1, T2) ReaderIOEither[C, error, R] {
@@ -56,6 +74,12 @@ func Eitherize3[F ~func(C, T0, T1, T2) (R, error), T0, T1, T2, C, R any](f F) fu
 	return G.Eitherize3[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize3 converts a function with 4 parameters returning a [ReaderIOEither[C, error, R]] into a function with 3 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize3[F ~func(T0, T1, T2) ReaderIOEither[C, error, R], T0, T1, T2, C, R any](f F) func(C, T0, T1, T2) (R, error) {
+	return G.Uneitherize3[ReaderIOEither[C, error, R], func(C, T0, T1, T2) (R, error)](f)
+}
+
 // From4 converts a function with 5 parameters returning a tuple into a function with 4 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From4[F ~func(C, T0, T1, T2, T3) func() (R, error), T0, T1, T2, T3, C, R any](f F) func(T0, T1, T2, T3) ReaderIOEither[C, error, R] {
@@ -68,6 +92,12 @@ func Eitherize4[F ~func(C, T0, T1, T2, T3) (R, error), T0, T1, T2, T3, C, R any]
 	return G.Eitherize4[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize4 converts a function with 5 parameters returning a [ReaderIOEither[C, error, R]] into a function with 4 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize4[F ~func(T0, T1, T2, T3) ReaderIOEither[C, error, R], T0, T1, T2, T3, C, R any](f F) func(C, T0, T1, T2, T3) (R, error) {
+	return G.Uneitherize4[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3) (R, error)](f)
+}
+
 // From5 converts a function with 6 parameters returning a tuple into a function with 5 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From5[F ~func(C, T0, T1, T2, T3, T4) func() (R, error), T0, T1, T2, T3, T4, C, R any](f F) func(T0, T1, T2, T3, T4) ReaderIOEither[C, error, R] {
@@ -80,6 +110,12 @@ func Eitherize5[F ~func(C, T0, T1, T2, T3, T4) (R, error), T0, T1, T2, T3, T4, C
 	return G.Eitherize5[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize5 converts a function with 6 parameters returning a [ReaderIOEither[C, error, R]] into a function with 5 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize5[F ~func(T0, T1, T2, T3, T4) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, C, R any](f F) func(C, T0, T1, T2, T3, T4) (R, error) {
+	return G.Uneitherize5[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4) (R, error)](f)
+}
+
 // From6 converts a function with 7 parameters returning a tuple into a function with 6 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From6[F ~func(C, T0, T1, T2, T3, T4, T5) func() (R, error), T0, T1, T2, T3, T4, T5, C, R any](f F) func(T0, T1, T2, T3, T4, T5) ReaderIOEither[C, error, R] {
@@ -92,6 +128,12 @@ func Eitherize6[F ~func(C, T0, T1, T2, T3, T4, T5) (R, error), T0, T1, T2, T3, T
 	return G.Eitherize6[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize6 converts a function with 7 parameters returning a [ReaderIOEither[C, error, R]] into a function with 6 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize6[F ~func(T0, T1, T2, T3, T4, T5) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5) (R, error) {
+	return G.Uneitherize6[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5) (R, error)](f)
+}
+
 // From7 converts a function with 8 parameters returning a tuple into a function with 7 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From7[F ~func(C, T0, T1, T2, T3, T4, T5, T6) func() (R, error), T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) ReaderIOEither[C, error, R] {
@@ -104,6 +146,12 @@ func Eitherize7[F ~func(C, T0, T1, T2, T3, T4, T5, T6) (R, error), T0, T1, T2, T
 	return G.Eitherize7[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize7 converts a function with 8 parameters returning a [ReaderIOEither[C, error, R]] into a function with 7 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize7[F ~func(T0, T1, T2, T3, T4, T5, T6) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5, T6) (R, error) {
+	return G.Uneitherize7[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6) (R, error)](f)
+}
+
 // From8 converts a function with 9 parameters returning a tuple into a function with 8 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From8[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) func() (R, error), T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) ReaderIOEither[C, error, R] {
@@ -116,6 +164,12 @@ func Eitherize8[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R, error), T0, T1, T
 	return G.Eitherize8[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize8 converts a function with 9 parameters returning a [ReaderIOEither[C, error, R]] into a function with 8 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize8[F ~func(T0, T1, T2, T3, T4, T5, T6, T7) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R, error) {
+	return G.Uneitherize8[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R, error)](f)
+}
+
 // From9 converts a function with 10 parameters returning a tuple into a function with 9 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From9[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) func() (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) ReaderIOEither[C, error, R] {
@@ -128,6 +182,12 @@ func Eitherize9[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), T0, T
 	return G.Eitherize9[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize9 converts a function with 10 parameters returning a [ReaderIOEither[C, error, R]] into a function with 9 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize9[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error) {
+	return G.Uneitherize9[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error)](f)
+}
+
 // From10 converts a function with 11 parameters returning a tuple into a function with 10 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From10[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) func() (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ReaderIOEither[C, error, R] {
@@ -139,3 +199,9 @@ func From10[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) func() (R, error)
 func Eitherize10[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ReaderIOEither[C, error, R] {
 	return G.Eitherize10[ReaderIOEither[C, error, R]](f)
 }
+
+// Uneitherize10 converts a function with 11 parameters returning a [ReaderIOEither[C, error, R]] into a function with 10 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize10[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error) {
+	return G.Uneitherize10[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error)](f)
+}

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-05-24 17:26:07.2835624 +0200 CEST m=+0.011499301
 package generic
 
 import (
@@ -26,6 +26,14 @@ func Eitherize0[GRA ~func(C) GIOA, F ~func(C) (R, error), GIOA ~func() E.Either[
 	})
 }
 
+// Uneitherize0 converts a function with 0 parameters returning a [GRA] into a function with 0 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize0[GRA ~func(C) GIOA, F ~func(C) (R, error), GIOA ~func() E.Either[error, R], C, R any](f func() GRA) F {
+	return func(c C) (R, error) {
+		return E.UnwrapError(f()(c)())
+	}
+}
+
 // From1 converts a function with 2 parameters returning a tuple into a function with 1 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From1[GRA ~func(C) GIOA, F ~func(C, T0) func() (R, error), GIOA ~func() E.Either[error, R], T0, C, R any](f F) func(T0) GRA {
@@ -44,6 +52,14 @@ func Eitherize1[GRA ~func(C) GIOA, F ~func(C, T0) (R, error), GIOA ~func() E.Eit
 	})
 }
 
+// Uneitherize1 converts a function with 1 parameters returning a [GRA] into a function with 1 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize1[GRA ~func(C) GIOA, F ~func(C, T0) (R, error), GIOA ~func() E.Either[error, R], T0, C, R any](f func(T0) GRA) F {
+	return func(c C, t0 T0) (R, error) {
+		return E.UnwrapError(f(t0)(c)())
+	}
+}
+
 // From2 converts a function with 3 parameters returning a tuple into a function with 2 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From2[GRA ~func(C) GIOA, F ~func(C, T0, T1) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, C, R any](f F) func(T0, T1) GRA {
@@ -62,6 +78,14 @@ func Eitherize2[GRA ~func(C) GIOA, F ~func(C, T0, T1) (R, error), GIOA ~func() E
 	})
 }
 
+// Uneitherize2 converts a function with 2 parameters returning a [GRA] into a function with 2 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize2[GRA ~func(C) GIOA, F ~func(C, T0, T1) (R, error), GIOA ~func() E.Either[error, R], T0, T1, C, R any](f func(T0, T1) GRA) F {
+	return func(c C, t0 T0, t1 T1) (R, error) {
+		return E.UnwrapError(f(t0, t1)(c)())
+	}
+}
+
 // From3 converts a function with 4 parameters returning a tuple into a function with 3 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From3[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, C, R any](f F) func(T0, T1, T2) GRA {
@@ -80,6 +104,14 @@ func Eitherize3[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2) (R, error), GIOA ~func
 	})
 }
 
+// Uneitherize3 converts a function with 3 parameters returning a [GRA] into a function with 3 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize3[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, C, R any](f func(T0, T1, T2) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2)(c)())
+	}
+}
+
 // From4 converts a function with 5 parameters returning a tuple into a function with 4 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From4[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, C, R any](f F) func(T0, T1, T2, T3) GRA {
@@ -98,6 +130,14 @@ func Eitherize4[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3) (R, error), GIOA ~
 	})
 }
 
+// Uneitherize4 converts a function with 4 parameters returning a [GRA] into a function with 4 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize4[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, C, R any](f func(T0, T1, T2, T3) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3)(c)())
+	}
+}
+
 // From5 converts a function with 6 parameters returning a tuple into a function with 5 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From5[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, C, R any](f F) func(T0, T1, T2, T3, T4) GRA {
@@ -116,6 +156,14 @@ func Eitherize5[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4) (R, error), GI
 	})
 }
 
+// Uneitherize5 converts a function with 5 parameters returning a [GRA] into a function with 5 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize5[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, C, R any](f func(T0, T1, T2, T3, T4) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4)(c)())
+	}
+}
+
 // From6 converts a function with 7 parameters returning a tuple into a function with 6 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From6[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, C, R any](f F) func(T0, T1, T2, T3, T4, T5) GRA {
@@ -134,6 +182,14 @@ func Eitherize6[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5) (R, error)
 	})
 }
 
+// Uneitherize6 converts a function with 6 parameters returning a [GRA] into a function with 6 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize6[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, C, R any](f func(T0, T1, T2, T3, T4, T5) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5)(c)())
+	}
+}
+
 // From7 converts a function with 8 parameters returning a tuple into a function with 7 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From7[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) GRA {
@@ -152,6 +208,14 @@ func Eitherize7[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6) (R, er
 	})
 }
 
+// Uneitherize7 converts a function with 7 parameters returning a [GRA] into a function with 7 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize7[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, C, R any](f func(T0, T1, T2, T3, T4, T5, T6) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6)(c)())
+	}
+}
+
 // From8 converts a function with 9 parameters returning a tuple into a function with 8 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From8[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) GRA {
@@ -170,6 +234,14 @@ func Eitherize8[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R
 	})
 }
 
+// Uneitherize8 converts a function with 8 parameters returning a [GRA] into a function with 8 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize8[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7)(c)())
+	}
+}
+
 // From9 converts a function with 10 parameters returning a tuple into a function with 9 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From9[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) GRA {
@@ -188,6 +260,14 @@ func Eitherize9[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8
 	})
 }
 
+// Uneitherize9 converts a function with 9 parameters returning a [GRA] into a function with 9 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize9[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8)(c)())
+	}
+}
+
 // From10 converts a function with 11 parameters returning a tuple into a function with 10 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From10[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) GRA {
@@ -205,3 +285,11 @@ func Eitherize10[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T
 		}
 	})
 }
+
+// Uneitherize10 converts a function with 10 parameters returning a [GRA] into a function with 10 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize10[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)(c)())
+	}
+}

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

renovate.json

@@ -25,6 +25,15 @@
             ],
             "automerge": true,
             "groupName": "go dependencies"
+        },
+        {
+            "matchPackageNames": [
+                "conventional-changelog-conventionalcommits"
+            ],
+            "matchUpdateTypes": [
+                "major"
+            ],
+            "enabled": false
         }
     ]
 }

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