fix: merge

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

array/generic/array.go

@@ -187,6 +187,14 @@ func IsEmpty[AS ~[]A, A any](as AS) bool {
 	return array.IsEmpty(as)
 }
 
+func IsNil[GA ~[]A, A any](as GA) bool {
+	return array.IsNil(as)
+}
+
+func IsNonNil[GA ~[]A, A any](as GA) bool {
+	return array.IsNonNil(as)
+}
+
 func Match[AS ~[]A, A, B any](onEmpty func() B, onNonEmpty func(AS) B) func(AS) B {
 	return func(as AS) B {
 		if IsEmpty(as) {

cli/pipe.go

@@ -25,6 +25,40 @@ import (
 	C "github.com/urfave/cli/v2"
 )
 
+func generateUnsliced(f *os.File, i int) {
+	// Create the optionize version
+	fmt.Fprintf(f, "\n// Unsliced%d converts a function taking a slice parameter into a function with %d parameters\n", i, i)
+	fmt.Fprintf(f, "func Unsliced%d[F ~func([]T) R, T, R any](f F) func(", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T")
+	}
+	fmt.Fprintf(f, ") R {\n")
+	fmt.Fprintf(f, "  return func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "t%d", j+1)
+	}
+	if i > 0 {
+		fmt.Fprintf(f, " T")
+	}
+	fmt.Fprintf(f, ") R {\n")
+	fmt.Fprintf(f, "    return f([]T{")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "t%d", j+1)
+	}
+	fmt.Fprintln(f, "})")
+	fmt.Fprintln(f, "  }")
+	fmt.Fprintln(f, "}")
+}
+
 func generateVariadic(f *os.File, i int) {
 	// Create the nullary version
 	fmt.Fprintf(f, "\n// Variadic%d converts a function taking %d parameters and a final slice into a function with %d parameters but a final variadic argument\n", i, i, i)
@@ -83,7 +117,7 @@ func generateVariadic(f *os.File, i int) {
 	fmt.Fprintf(f, "v)\n")
 	fmt.Fprintf(f, "  }\n")
 
-	fmt.Fprintf(f, "}")
+	fmt.Fprintf(f, "}\n")
 }
 
 func generateUnvariadic(f *os.File, i int) {
@@ -144,7 +178,7 @@ func generateUnvariadic(f *os.File, i int) {
 	fmt.Fprintf(f, "v...)\n")
 	fmt.Fprintf(f, "  }\n")
 
-	fmt.Fprintf(f, "}")
+	fmt.Fprintf(f, "}\n")
 }
 
 func generateNullary(f *os.File, i int) {
@@ -347,6 +381,8 @@ func generatePipeHelpers(filename string, count int) error {
 	generateVariadic(f, 0)
 	// unvariadic
 	generateUnvariadic(f, 0)
+	// unsliced
+	generateUnsliced(f, 0)
 
 	for i := 1; i <= count; i++ {
 
@@ -364,6 +400,8 @@ func generatePipeHelpers(filename string, count int) error {
 		generateVariadic(f, i)
 		// unvariadic
 		generateUnvariadic(f, i)
+		// unsliced
+		generateUnsliced(f, i)
 	}
 
 	return nil

context/reader/array.go

@@ -24,6 +24,11 @@ func TraverseArray[A, B any](f func(A) Reader[B]) func([]A) Reader[[]B] {
 	return R.TraverseArray[Reader[B], Reader[[]B], []A](f)
 }
 
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[A, B any](f func(int, A) Reader[B]) func([]A) Reader[[]B] {
+	return R.TraverseArrayWithIndex[Reader[B], Reader[[]B], []A](f)
+}
+
 // SequenceArray converts a homogeneous sequence of either into an either of sequence
 func SequenceArray[A any](ma []Reader[A]) Reader[[]A] {
 	return R.SequenceArray[Reader[A], Reader[[]A]](ma)

context/readereither/array.go

@@ -24,6 +24,11 @@ func TraverseArray[A, B any](f func(A) ReaderEither[B]) func([]A) ReaderEither[[
 	return RE.TraverseArray[ReaderEither[B], ReaderEither[[]B], []A](f)
 }
 
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[A, B any](f func(int, A) ReaderEither[B]) func([]A) ReaderEither[[]B] {
+	return RE.TraverseArrayWithIndex[ReaderEither[B], ReaderEither[[]B], []A](f)
+}
+
 // SequenceArray converts a homogeneous sequence of either into an either of sequence
 func SequenceArray[A any](ma []ReaderEither[A]) ReaderEither[[]A] {
 	return RE.SequenceArray[ReaderEither[A], ReaderEither[[]A]](ma)

context/readerio/array.go

@@ -25,6 +25,11 @@ func TraverseArray[A, B any](f func(A) ReaderIO[B]) func([]A) ReaderIO[[]B] {
 	return R.TraverseArray[ReaderIO[B], ReaderIO[[]B], IO.IO[B], IO.IO[[]B], []A](f)
 }
 
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[A, B any](f func(int, A) ReaderIO[B]) func([]A) ReaderIO[[]B] {
+	return R.TraverseArrayWithIndex[ReaderIO[B], ReaderIO[[]B], IO.IO[B], IO.IO[[]B], []A](f)
+}
+
 // SequenceArray converts a homogeneous sequence of either into an either of sequence
 func SequenceArray[A any](ma []ReaderIO[A]) ReaderIO[[]A] {
 	return R.SequenceArray[ReaderIO[A], ReaderIO[[]A]](ma)

context/readerioeither/gen.go

@@ -2,7 +2,8 @@ package readerioeither
 
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-08-17 22:58:56.457404 +0200 CEST m=+0.024265101
+// 2023-09-12 13:44:14.1022311 +0200 CEST m=+0.017763401
+
 
 import (
 	"context"
@@ -14,515 +15,515 @@ import (
 // Eitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize0]
 func Eitherize0[F ~func(context.Context) (R, error), R any](f F) func() ReaderIOEither[R] {
-	return G.Eitherize0[ReaderIOEither[R]](f)
+  return G.Eitherize0[ReaderIOEither[R]](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)
+  return G.Eitherize1[ReaderIOEither[R]](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)
+  return G.SequenceT1[ReaderIOEither[T.Tuple1[T1]]](t1)
 }
 
 // SequenceSeqT1 converts 1 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple1].
 func SequenceSeqT1[T1 any](t1 ReaderIOEither[T1]) ReaderIOEither[T.Tuple1[T1]] {
-	return G.SequenceSeqT1[ReaderIOEither[T.Tuple1[T1]]](t1)
+  return G.SequenceSeqT1[ReaderIOEither[T.Tuple1[T1]]](t1)
 }
 
 // SequenceParT1 converts 1 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple1].
 func SequenceParT1[T1 any](t1 ReaderIOEither[T1]) ReaderIOEither[T.Tuple1[T1]] {
-	return G.SequenceParT1[ReaderIOEither[T.Tuple1[T1]]](t1)
+  return G.SequenceParT1[ReaderIOEither[T.Tuple1[T1]]](t1)
 }
 
 // SequenceTuple1 converts a [T.Tuple1] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple1].
 func SequenceTuple1[T1 any](t T.Tuple1[ReaderIOEither[T1]]) ReaderIOEither[T.Tuple1[T1]] {
-	return G.SequenceTuple1[ReaderIOEither[T.Tuple1[T1]]](t)
+  return G.SequenceTuple1[ReaderIOEither[T.Tuple1[T1]]](t)
 }
 
 // SequenceSeqTuple1 converts a [T.Tuple1] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple1].
 func SequenceSeqTuple1[T1 any](t T.Tuple1[ReaderIOEither[T1]]) ReaderIOEither[T.Tuple1[T1]] {
-	return G.SequenceSeqTuple1[ReaderIOEither[T.Tuple1[T1]]](t)
+  return G.SequenceSeqTuple1[ReaderIOEither[T.Tuple1[T1]]](t)
 }
 
 // SequenceParTuple1 converts a [T.Tuple1] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple1].
 func SequenceParTuple1[T1 any](t T.Tuple1[ReaderIOEither[T1]]) ReaderIOEither[T.Tuple1[T1]] {
-	return G.SequenceParTuple1[ReaderIOEither[T.Tuple1[T1]]](t)
+  return G.SequenceParTuple1[ReaderIOEither[T.Tuple1[T1]]](t)
 }
 
 // TraverseTuple1 converts a [T.Tuple1] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple1].
 func TraverseTuple1[F1 ~func(A1) ReaderIOEither[T1], A1, T1 any](f1 F1) func(T.Tuple1[A1]) ReaderIOEither[T.Tuple1[T1]] {
-	return G.TraverseTuple1[ReaderIOEither[T.Tuple1[T1]]](f1)
+  return G.TraverseTuple1[ReaderIOEither[T.Tuple1[T1]]](f1)
 }
 
 // TraverseSeqTuple1 converts a [T.Tuple1] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple1].
 func TraverseSeqTuple1[F1 ~func(A1) ReaderIOEither[T1], A1, T1 any](f1 F1) func(T.Tuple1[A1]) ReaderIOEither[T.Tuple1[T1]] {
-	return G.TraverseSeqTuple1[ReaderIOEither[T.Tuple1[T1]]](f1)
+  return G.TraverseSeqTuple1[ReaderIOEither[T.Tuple1[T1]]](f1)
 }
 
 // TraverseParTuple1 converts a [T.Tuple1] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple1].
 func TraverseParTuple1[F1 ~func(A1) ReaderIOEither[T1], A1, T1 any](f1 F1) func(T.Tuple1[A1]) ReaderIOEither[T.Tuple1[T1]] {
-	return G.TraverseParTuple1[ReaderIOEither[T.Tuple1[T1]]](f1)
+  return G.TraverseParTuple1[ReaderIOEither[T.Tuple1[T1]]](f1)
 }
 
 // Eitherize2 converts a function with 2 parameters returning a tuple into a function with 2 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize2]
 func Eitherize2[F ~func(context.Context, T0, T1) (R, error), T0, T1, R any](f F) func(T0, T1) ReaderIOEither[R] {
-	return G.Eitherize2[ReaderIOEither[R]](f)
+  return G.Eitherize2[ReaderIOEither[R]](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)
+  return G.SequenceT2[ReaderIOEither[T.Tuple2[T1, T2]]](t1, t2)
 }
 
 // SequenceSeqT2 converts 2 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple2].
 func SequenceSeqT2[T1, T2 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2]) ReaderIOEither[T.Tuple2[T1, T2]] {
-	return G.SequenceSeqT2[ReaderIOEither[T.Tuple2[T1, T2]]](t1, t2)
+  return G.SequenceSeqT2[ReaderIOEither[T.Tuple2[T1, T2]]](t1, t2)
 }
 
 // SequenceParT2 converts 2 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple2].
 func SequenceParT2[T1, T2 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2]) ReaderIOEither[T.Tuple2[T1, T2]] {
-	return G.SequenceParT2[ReaderIOEither[T.Tuple2[T1, T2]]](t1, t2)
+  return G.SequenceParT2[ReaderIOEither[T.Tuple2[T1, T2]]](t1, t2)
 }
 
 // SequenceTuple2 converts a [T.Tuple2] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple2].
 func SequenceTuple2[T1, T2 any](t T.Tuple2[ReaderIOEither[T1], ReaderIOEither[T2]]) ReaderIOEither[T.Tuple2[T1, T2]] {
-	return G.SequenceTuple2[ReaderIOEither[T.Tuple2[T1, T2]]](t)
+  return G.SequenceTuple2[ReaderIOEither[T.Tuple2[T1, T2]]](t)
 }
 
 // SequenceSeqTuple2 converts a [T.Tuple2] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple2].
 func SequenceSeqTuple2[T1, T2 any](t T.Tuple2[ReaderIOEither[T1], ReaderIOEither[T2]]) ReaderIOEither[T.Tuple2[T1, T2]] {
-	return G.SequenceSeqTuple2[ReaderIOEither[T.Tuple2[T1, T2]]](t)
+  return G.SequenceSeqTuple2[ReaderIOEither[T.Tuple2[T1, T2]]](t)
 }
 
 // SequenceParTuple2 converts a [T.Tuple2] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple2].
 func SequenceParTuple2[T1, T2 any](t T.Tuple2[ReaderIOEither[T1], ReaderIOEither[T2]]) ReaderIOEither[T.Tuple2[T1, T2]] {
-	return G.SequenceParTuple2[ReaderIOEither[T.Tuple2[T1, T2]]](t)
+  return G.SequenceParTuple2[ReaderIOEither[T.Tuple2[T1, T2]]](t)
 }
 
 // TraverseTuple2 converts a [T.Tuple2] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple2].
 func TraverseTuple2[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], A1, T1, A2, T2 any](f1 F1, f2 F2) func(T.Tuple2[A1, A2]) ReaderIOEither[T.Tuple2[T1, T2]] {
-	return G.TraverseTuple2[ReaderIOEither[T.Tuple2[T1, T2]]](f1, f2)
+  return G.TraverseTuple2[ReaderIOEither[T.Tuple2[T1, T2]]](f1, f2)
 }
 
 // TraverseSeqTuple2 converts a [T.Tuple2] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple2].
 func TraverseSeqTuple2[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], A1, T1, A2, T2 any](f1 F1, f2 F2) func(T.Tuple2[A1, A2]) ReaderIOEither[T.Tuple2[T1, T2]] {
-	return G.TraverseSeqTuple2[ReaderIOEither[T.Tuple2[T1, T2]]](f1, f2)
+  return G.TraverseSeqTuple2[ReaderIOEither[T.Tuple2[T1, T2]]](f1, f2)
 }
 
 // TraverseParTuple2 converts a [T.Tuple2] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple2].
 func TraverseParTuple2[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], A1, T1, A2, T2 any](f1 F1, f2 F2) func(T.Tuple2[A1, A2]) ReaderIOEither[T.Tuple2[T1, T2]] {
-	return G.TraverseParTuple2[ReaderIOEither[T.Tuple2[T1, T2]]](f1, f2)
+  return G.TraverseParTuple2[ReaderIOEither[T.Tuple2[T1, T2]]](f1, f2)
 }
 
 // Eitherize3 converts a function with 3 parameters returning a tuple into a function with 3 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize3]
 func Eitherize3[F ~func(context.Context, T0, T1, T2) (R, error), T0, T1, T2, R any](f F) func(T0, T1, T2) ReaderIOEither[R] {
-	return G.Eitherize3[ReaderIOEither[R]](f)
+  return G.Eitherize3[ReaderIOEither[R]](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)
+  return G.SequenceT3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](t1, t2, t3)
 }
 
 // SequenceSeqT3 converts 3 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple3].
 func SequenceSeqT3[T1, T2, T3 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3]) ReaderIOEither[T.Tuple3[T1, T2, T3]] {
-	return G.SequenceSeqT3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](t1, t2, t3)
+  return G.SequenceSeqT3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](t1, t2, t3)
 }
 
 // SequenceParT3 converts 3 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple3].
 func SequenceParT3[T1, T2, T3 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3]) ReaderIOEither[T.Tuple3[T1, T2, T3]] {
-	return G.SequenceParT3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](t1, t2, t3)
+  return G.SequenceParT3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](t1, t2, t3)
 }
 
 // SequenceTuple3 converts a [T.Tuple3] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple3].
 func SequenceTuple3[T1, T2, T3 any](t T.Tuple3[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3]]) ReaderIOEither[T.Tuple3[T1, T2, T3]] {
-	return G.SequenceTuple3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](t)
+  return G.SequenceTuple3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](t)
 }
 
 // SequenceSeqTuple3 converts a [T.Tuple3] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple3].
 func SequenceSeqTuple3[T1, T2, T3 any](t T.Tuple3[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3]]) ReaderIOEither[T.Tuple3[T1, T2, T3]] {
-	return G.SequenceSeqTuple3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](t)
+  return G.SequenceSeqTuple3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](t)
 }
 
 // SequenceParTuple3 converts a [T.Tuple3] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple3].
 func SequenceParTuple3[T1, T2, T3 any](t T.Tuple3[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3]]) ReaderIOEither[T.Tuple3[T1, T2, T3]] {
-	return G.SequenceParTuple3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](t)
+  return G.SequenceParTuple3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](t)
 }
 
 // TraverseTuple3 converts a [T.Tuple3] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple3].
 func TraverseTuple3[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], A1, T1, A2, T2, A3, T3 any](f1 F1, f2 F2, f3 F3) func(T.Tuple3[A1, A2, A3]) ReaderIOEither[T.Tuple3[T1, T2, T3]] {
-	return G.TraverseTuple3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](f1, f2, f3)
+  return G.TraverseTuple3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](f1, f2, f3)
 }
 
 // TraverseSeqTuple3 converts a [T.Tuple3] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple3].
 func TraverseSeqTuple3[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], A1, T1, A2, T2, A3, T3 any](f1 F1, f2 F2, f3 F3) func(T.Tuple3[A1, A2, A3]) ReaderIOEither[T.Tuple3[T1, T2, T3]] {
-	return G.TraverseSeqTuple3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](f1, f2, f3)
+  return G.TraverseSeqTuple3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](f1, f2, f3)
 }
 
 // TraverseParTuple3 converts a [T.Tuple3] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple3].
 func TraverseParTuple3[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], A1, T1, A2, T2, A3, T3 any](f1 F1, f2 F2, f3 F3) func(T.Tuple3[A1, A2, A3]) ReaderIOEither[T.Tuple3[T1, T2, T3]] {
-	return G.TraverseParTuple3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](f1, f2, f3)
+  return G.TraverseParTuple3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](f1, f2, f3)
 }
 
 // Eitherize4 converts a function with 4 parameters returning a tuple into a function with 4 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize4]
 func Eitherize4[F ~func(context.Context, T0, T1, T2, T3) (R, error), T0, T1, T2, T3, R any](f F) func(T0, T1, T2, T3) ReaderIOEither[R] {
-	return G.Eitherize4[ReaderIOEither[R]](f)
+  return G.Eitherize4[ReaderIOEither[R]](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)
+  return G.SequenceT4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](t1, t2, t3, t4)
 }
 
 // SequenceSeqT4 converts 4 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple4].
 func SequenceSeqT4[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.SequenceSeqT4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](t1, t2, t3, t4)
+  return G.SequenceSeqT4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](t1, t2, t3, t4)
 }
 
 // SequenceParT4 converts 4 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple4].
 func SequenceParT4[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.SequenceParT4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](t1, t2, t3, t4)
+  return G.SequenceParT4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](t1, t2, t3, t4)
 }
 
 // SequenceTuple4 converts a [T.Tuple4] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple4].
 func SequenceTuple4[T1, T2, T3, T4 any](t T.Tuple4[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4]]) ReaderIOEither[T.Tuple4[T1, T2, T3, T4]] {
-	return G.SequenceTuple4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](t)
+  return G.SequenceTuple4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](t)
 }
 
 // SequenceSeqTuple4 converts a [T.Tuple4] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple4].
 func SequenceSeqTuple4[T1, T2, T3, T4 any](t T.Tuple4[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4]]) ReaderIOEither[T.Tuple4[T1, T2, T3, T4]] {
-	return G.SequenceSeqTuple4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](t)
+  return G.SequenceSeqTuple4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](t)
 }
 
 // SequenceParTuple4 converts a [T.Tuple4] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple4].
 func SequenceParTuple4[T1, T2, T3, T4 any](t T.Tuple4[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4]]) ReaderIOEither[T.Tuple4[T1, T2, T3, T4]] {
-	return G.SequenceParTuple4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](t)
+  return G.SequenceParTuple4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](t)
 }
 
 // TraverseTuple4 converts a [T.Tuple4] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple4].
 func TraverseTuple4[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], A1, T1, A2, T2, A3, T3, A4, T4 any](f1 F1, f2 F2, f3 F3, f4 F4) func(T.Tuple4[A1, A2, A3, A4]) ReaderIOEither[T.Tuple4[T1, T2, T3, T4]] {
-	return G.TraverseTuple4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](f1, f2, f3, f4)
+  return G.TraverseTuple4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](f1, f2, f3, f4)
 }
 
 // TraverseSeqTuple4 converts a [T.Tuple4] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple4].
 func TraverseSeqTuple4[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], A1, T1, A2, T2, A3, T3, A4, T4 any](f1 F1, f2 F2, f3 F3, f4 F4) func(T.Tuple4[A1, A2, A3, A4]) ReaderIOEither[T.Tuple4[T1, T2, T3, T4]] {
-	return G.TraverseSeqTuple4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](f1, f2, f3, f4)
+  return G.TraverseSeqTuple4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](f1, f2, f3, f4)
 }
 
 // TraverseParTuple4 converts a [T.Tuple4] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple4].
 func TraverseParTuple4[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], A1, T1, A2, T2, A3, T3, A4, T4 any](f1 F1, f2 F2, f3 F3, f4 F4) func(T.Tuple4[A1, A2, A3, A4]) ReaderIOEither[T.Tuple4[T1, T2, T3, T4]] {
-	return G.TraverseParTuple4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](f1, f2, f3, f4)
+  return G.TraverseParTuple4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](f1, f2, f3, f4)
 }
 
 // Eitherize5 converts a function with 5 parameters returning a tuple into a function with 5 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize5]
 func Eitherize5[F ~func(context.Context, T0, T1, T2, T3, T4) (R, error), T0, T1, T2, T3, T4, R any](f F) func(T0, T1, T2, T3, T4) ReaderIOEither[R] {
-	return G.Eitherize5[ReaderIOEither[R]](f)
+  return G.Eitherize5[ReaderIOEither[R]](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)
+  return G.SequenceT5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](t1, t2, t3, t4, t5)
 }
 
 // SequenceSeqT5 converts 5 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple5].
 func SequenceSeqT5[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.SequenceSeqT5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](t1, t2, t3, t4, t5)
+  return G.SequenceSeqT5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](t1, t2, t3, t4, t5)
 }
 
 // SequenceParT5 converts 5 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple5].
 func SequenceParT5[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.SequenceParT5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](t1, t2, t3, t4, t5)
+  return G.SequenceParT5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](t1, t2, t3, t4, t5)
 }
 
 // SequenceTuple5 converts a [T.Tuple5] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple5].
 func SequenceTuple5[T1, T2, T3, T4, T5 any](t T.Tuple5[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4], ReaderIOEither[T5]]) ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]] {
-	return G.SequenceTuple5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](t)
+  return G.SequenceTuple5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](t)
 }
 
 // SequenceSeqTuple5 converts a [T.Tuple5] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple5].
 func SequenceSeqTuple5[T1, T2, T3, T4, T5 any](t T.Tuple5[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4], ReaderIOEither[T5]]) ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]] {
-	return G.SequenceSeqTuple5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](t)
+  return G.SequenceSeqTuple5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](t)
 }
 
 // SequenceParTuple5 converts a [T.Tuple5] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple5].
 func SequenceParTuple5[T1, T2, T3, T4, T5 any](t T.Tuple5[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4], ReaderIOEither[T5]]) ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]] {
-	return G.SequenceParTuple5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](t)
+  return G.SequenceParTuple5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](t)
 }
 
 // TraverseTuple5 converts a [T.Tuple5] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple5].
 func TraverseTuple5[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], F5 ~func(A5) ReaderIOEither[T5], A1, T1, A2, T2, A3, T3, A4, T4, A5, T5 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) func(T.Tuple5[A1, A2, A3, A4, A5]) ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]] {
-	return G.TraverseTuple5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](f1, f2, f3, f4, f5)
+  return G.TraverseTuple5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](f1, f2, f3, f4, f5)
 }
 
 // TraverseSeqTuple5 converts a [T.Tuple5] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple5].
 func TraverseSeqTuple5[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], F5 ~func(A5) ReaderIOEither[T5], A1, T1, A2, T2, A3, T3, A4, T4, A5, T5 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) func(T.Tuple5[A1, A2, A3, A4, A5]) ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]] {
-	return G.TraverseSeqTuple5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](f1, f2, f3, f4, f5)
+  return G.TraverseSeqTuple5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](f1, f2, f3, f4, f5)
 }
 
 // TraverseParTuple5 converts a [T.Tuple5] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple5].
 func TraverseParTuple5[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], F5 ~func(A5) ReaderIOEither[T5], A1, T1, A2, T2, A3, T3, A4, T4, A5, T5 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) func(T.Tuple5[A1, A2, A3, A4, A5]) ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]] {
-	return G.TraverseParTuple5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](f1, f2, f3, f4, f5)
+  return G.TraverseParTuple5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](f1, f2, f3, f4, f5)
 }
 
 // Eitherize6 converts a function with 6 parameters returning a tuple into a function with 6 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize6]
 func Eitherize6[F ~func(context.Context, T0, T1, T2, T3, T4, T5) (R, error), T0, T1, T2, T3, T4, T5, R any](f F) func(T0, T1, T2, T3, T4, T5) ReaderIOEither[R] {
-	return G.Eitherize6[ReaderIOEither[R]](f)
+  return G.Eitherize6[ReaderIOEither[R]](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)
+  return G.SequenceT6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](t1, t2, t3, t4, t5, t6)
 }
 
 // SequenceSeqT6 converts 6 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple6].
 func SequenceSeqT6[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.SequenceSeqT6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](t1, t2, t3, t4, t5, t6)
+  return G.SequenceSeqT6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](t1, t2, t3, t4, t5, t6)
 }
 
 // SequenceParT6 converts 6 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple6].
 func SequenceParT6[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.SequenceParT6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](t1, t2, t3, t4, t5, t6)
+  return G.SequenceParT6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](t1, t2, t3, t4, t5, t6)
 }
 
 // SequenceTuple6 converts a [T.Tuple6] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple6].
 func SequenceTuple6[T1, T2, T3, T4, T5, T6 any](t T.Tuple6[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4], ReaderIOEither[T5], ReaderIOEither[T6]]) ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-	return G.SequenceTuple6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](t)
+  return G.SequenceTuple6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](t)
 }
 
 // SequenceSeqTuple6 converts a [T.Tuple6] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple6].
 func SequenceSeqTuple6[T1, T2, T3, T4, T5, T6 any](t T.Tuple6[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4], ReaderIOEither[T5], ReaderIOEither[T6]]) ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-	return G.SequenceSeqTuple6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](t)
+  return G.SequenceSeqTuple6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](t)
 }
 
 // SequenceParTuple6 converts a [T.Tuple6] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple6].
 func SequenceParTuple6[T1, T2, T3, T4, T5, T6 any](t T.Tuple6[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4], ReaderIOEither[T5], ReaderIOEither[T6]]) ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-	return G.SequenceParTuple6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](t)
+  return G.SequenceParTuple6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](t)
 }
 
 // TraverseTuple6 converts a [T.Tuple6] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple6].
 func TraverseTuple6[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], F5 ~func(A5) ReaderIOEither[T5], F6 ~func(A6) ReaderIOEither[T6], A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) func(T.Tuple6[A1, A2, A3, A4, A5, A6]) ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-	return G.TraverseTuple6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](f1, f2, f3, f4, f5, f6)
+  return G.TraverseTuple6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](f1, f2, f3, f4, f5, f6)
 }
 
 // TraverseSeqTuple6 converts a [T.Tuple6] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple6].
 func TraverseSeqTuple6[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], F5 ~func(A5) ReaderIOEither[T5], F6 ~func(A6) ReaderIOEither[T6], A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) func(T.Tuple6[A1, A2, A3, A4, A5, A6]) ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-	return G.TraverseSeqTuple6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](f1, f2, f3, f4, f5, f6)
+  return G.TraverseSeqTuple6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](f1, f2, f3, f4, f5, f6)
 }
 
 // TraverseParTuple6 converts a [T.Tuple6] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple6].
 func TraverseParTuple6[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], F5 ~func(A5) ReaderIOEither[T5], F6 ~func(A6) ReaderIOEither[T6], A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) func(T.Tuple6[A1, A2, A3, A4, A5, A6]) ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-	return G.TraverseParTuple6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](f1, f2, f3, f4, f5, f6)
+  return G.TraverseParTuple6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](f1, f2, f3, f4, f5, f6)
 }
 
 // Eitherize7 converts a function with 7 parameters returning a tuple into a function with 7 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize7]
 func Eitherize7[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6) (R, error), T0, T1, T2, T3, T4, T5, T6, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) ReaderIOEither[R] {
-	return G.Eitherize7[ReaderIOEither[R]](f)
+  return G.Eitherize7[ReaderIOEither[R]](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)
+  return G.SequenceT7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](t1, t2, t3, t4, t5, t6, t7)
 }
 
 // SequenceSeqT7 converts 7 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple7].
 func SequenceSeqT7[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.SequenceSeqT7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](t1, t2, t3, t4, t5, t6, t7)
+  return G.SequenceSeqT7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](t1, t2, t3, t4, t5, t6, t7)
 }
 
 // SequenceParT7 converts 7 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple7].
 func SequenceParT7[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.SequenceParT7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](t1, t2, t3, t4, t5, t6, t7)
+  return G.SequenceParT7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](t1, t2, t3, t4, t5, t6, t7)
 }
 
 // SequenceTuple7 converts a [T.Tuple7] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple7].
 func SequenceTuple7[T1, T2, T3, T4, T5, T6, T7 any](t T.Tuple7[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4], ReaderIOEither[T5], ReaderIOEither[T6], ReaderIOEither[T7]]) ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-	return G.SequenceTuple7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](t)
+  return G.SequenceTuple7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](t)
 }
 
 // SequenceSeqTuple7 converts a [T.Tuple7] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple7].
 func SequenceSeqTuple7[T1, T2, T3, T4, T5, T6, T7 any](t T.Tuple7[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4], ReaderIOEither[T5], ReaderIOEither[T6], ReaderIOEither[T7]]) ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-	return G.SequenceSeqTuple7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](t)
+  return G.SequenceSeqTuple7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](t)
 }
 
 // SequenceParTuple7 converts a [T.Tuple7] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple7].
 func SequenceParTuple7[T1, T2, T3, T4, T5, T6, T7 any](t T.Tuple7[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4], ReaderIOEither[T5], ReaderIOEither[T6], ReaderIOEither[T7]]) ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-	return G.SequenceParTuple7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](t)
+  return G.SequenceParTuple7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](t)
 }
 
 // TraverseTuple7 converts a [T.Tuple7] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple7].
 func TraverseTuple7[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], F5 ~func(A5) ReaderIOEither[T5], F6 ~func(A6) ReaderIOEither[T6], F7 ~func(A7) ReaderIOEither[T7], A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) func(T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-	return G.TraverseTuple7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](f1, f2, f3, f4, f5, f6, f7)
+  return G.TraverseTuple7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](f1, f2, f3, f4, f5, f6, f7)
 }
 
 // TraverseSeqTuple7 converts a [T.Tuple7] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple7].
 func TraverseSeqTuple7[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], F5 ~func(A5) ReaderIOEither[T5], F6 ~func(A6) ReaderIOEither[T6], F7 ~func(A7) ReaderIOEither[T7], A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) func(T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-	return G.TraverseSeqTuple7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](f1, f2, f3, f4, f5, f6, f7)
+  return G.TraverseSeqTuple7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](f1, f2, f3, f4, f5, f6, f7)
 }
 
 // TraverseParTuple7 converts a [T.Tuple7] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple7].
 func TraverseParTuple7[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], F5 ~func(A5) ReaderIOEither[T5], F6 ~func(A6) ReaderIOEither[T6], F7 ~func(A7) ReaderIOEither[T7], A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) func(T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-	return G.TraverseParTuple7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](f1, f2, f3, f4, f5, f6, f7)
+  return G.TraverseParTuple7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](f1, f2, f3, f4, f5, f6, f7)
 }
 
 // Eitherize8 converts a function with 8 parameters returning a tuple into a function with 8 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize8]
 func Eitherize8[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) ReaderIOEither[R] {
-	return G.Eitherize8[ReaderIOEither[R]](f)
+  return G.Eitherize8[ReaderIOEither[R]](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)
+  return G.SequenceT8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](t1, t2, t3, t4, t5, t6, t7, t8)
 }
 
 // SequenceSeqT8 converts 8 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple8].
 func SequenceSeqT8[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.SequenceSeqT8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](t1, t2, t3, t4, t5, t6, t7, t8)
+  return G.SequenceSeqT8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](t1, t2, t3, t4, t5, t6, t7, t8)
 }
 
 // SequenceParT8 converts 8 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple8].
 func SequenceParT8[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.SequenceParT8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](t1, t2, t3, t4, t5, t6, t7, t8)
+  return G.SequenceParT8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](t1, t2, t3, t4, t5, t6, t7, t8)
 }
 
 // SequenceTuple8 converts a [T.Tuple8] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple8].
 func SequenceTuple8[T1, T2, T3, T4, T5, T6, T7, T8 any](t T.Tuple8[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4], ReaderIOEither[T5], ReaderIOEither[T6], ReaderIOEither[T7], ReaderIOEither[T8]]) ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-	return G.SequenceTuple8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](t)
+  return G.SequenceTuple8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](t)
 }
 
 // SequenceSeqTuple8 converts a [T.Tuple8] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple8].
 func SequenceSeqTuple8[T1, T2, T3, T4, T5, T6, T7, T8 any](t T.Tuple8[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4], ReaderIOEither[T5], ReaderIOEither[T6], ReaderIOEither[T7], ReaderIOEither[T8]]) ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-	return G.SequenceSeqTuple8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](t)
+  return G.SequenceSeqTuple8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](t)
 }
 
 // SequenceParTuple8 converts a [T.Tuple8] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple8].
 func SequenceParTuple8[T1, T2, T3, T4, T5, T6, T7, T8 any](t T.Tuple8[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4], ReaderIOEither[T5], ReaderIOEither[T6], ReaderIOEither[T7], ReaderIOEither[T8]]) ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-	return G.SequenceParTuple8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](t)
+  return G.SequenceParTuple8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](t)
 }
 
 // TraverseTuple8 converts a [T.Tuple8] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple8].
 func TraverseTuple8[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], F5 ~func(A5) ReaderIOEither[T5], F6 ~func(A6) ReaderIOEither[T6], F7 ~func(A7) ReaderIOEither[T7], F8 ~func(A8) ReaderIOEither[T8], A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) func(T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-	return G.TraverseTuple8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](f1, f2, f3, f4, f5, f6, f7, f8)
+  return G.TraverseTuple8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](f1, f2, f3, f4, f5, f6, f7, f8)
 }
 
 // TraverseSeqTuple8 converts a [T.Tuple8] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple8].
 func TraverseSeqTuple8[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], F5 ~func(A5) ReaderIOEither[T5], F6 ~func(A6) ReaderIOEither[T6], F7 ~func(A7) ReaderIOEither[T7], F8 ~func(A8) ReaderIOEither[T8], A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) func(T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-	return G.TraverseSeqTuple8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](f1, f2, f3, f4, f5, f6, f7, f8)
+  return G.TraverseSeqTuple8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](f1, f2, f3, f4, f5, f6, f7, f8)
 }
 
 // TraverseParTuple8 converts a [T.Tuple8] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple8].
 func TraverseParTuple8[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], F5 ~func(A5) ReaderIOEither[T5], F6 ~func(A6) ReaderIOEither[T6], F7 ~func(A7) ReaderIOEither[T7], F8 ~func(A8) ReaderIOEither[T8], A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) func(T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-	return G.TraverseParTuple8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](f1, f2, f3, f4, f5, f6, f7, f8)
+  return G.TraverseParTuple8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](f1, f2, f3, f4, f5, f6, f7, f8)
 }
 
 // Eitherize9 converts a function with 9 parameters returning a tuple into a function with 9 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize9]
 func Eitherize9[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) ReaderIOEither[R] {
-	return G.Eitherize9[ReaderIOEither[R]](f)
+  return G.Eitherize9[ReaderIOEither[R]](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)
+  return G.SequenceT9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](t1, t2, t3, t4, t5, t6, t7, t8, t9)
 }
 
 // SequenceSeqT9 converts 9 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple9].
 func SequenceSeqT9[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.SequenceSeqT9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](t1, t2, t3, t4, t5, t6, t7, t8, t9)
+  return G.SequenceSeqT9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](t1, t2, t3, t4, t5, t6, t7, t8, t9)
 }
 
 // SequenceParT9 converts 9 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple9].
 func SequenceParT9[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.SequenceParT9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](t1, t2, t3, t4, t5, t6, t7, t8, t9)
+  return G.SequenceParT9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](t1, t2, t3, t4, t5, t6, t7, t8, t9)
 }
 
 // SequenceTuple9 converts a [T.Tuple9] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple9].
 func SequenceTuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t T.Tuple9[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4], ReaderIOEither[T5], ReaderIOEither[T6], ReaderIOEither[T7], ReaderIOEither[T8], ReaderIOEither[T9]]) ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-	return G.SequenceTuple9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](t)
+  return G.SequenceTuple9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](t)
 }
 
 // SequenceSeqTuple9 converts a [T.Tuple9] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple9].
 func SequenceSeqTuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t T.Tuple9[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4], ReaderIOEither[T5], ReaderIOEither[T6], ReaderIOEither[T7], ReaderIOEither[T8], ReaderIOEither[T9]]) ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-	return G.SequenceSeqTuple9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](t)
+  return G.SequenceSeqTuple9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](t)
 }
 
 // SequenceParTuple9 converts a [T.Tuple9] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple9].
 func SequenceParTuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t T.Tuple9[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4], ReaderIOEither[T5], ReaderIOEither[T6], ReaderIOEither[T7], ReaderIOEither[T8], ReaderIOEither[T9]]) ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-	return G.SequenceParTuple9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](t)
+  return G.SequenceParTuple9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](t)
 }
 
 // TraverseTuple9 converts a [T.Tuple9] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple9].
 func TraverseTuple9[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], F5 ~func(A5) ReaderIOEither[T5], F6 ~func(A6) ReaderIOEither[T6], F7 ~func(A7) ReaderIOEither[T7], F8 ~func(A8) ReaderIOEither[T8], F9 ~func(A9) ReaderIOEither[T9], A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) func(T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-	return G.TraverseTuple9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](f1, f2, f3, f4, f5, f6, f7, f8, f9)
+  return G.TraverseTuple9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](f1, f2, f3, f4, f5, f6, f7, f8, f9)
 }
 
 // TraverseSeqTuple9 converts a [T.Tuple9] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple9].
 func TraverseSeqTuple9[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], F5 ~func(A5) ReaderIOEither[T5], F6 ~func(A6) ReaderIOEither[T6], F7 ~func(A7) ReaderIOEither[T7], F8 ~func(A8) ReaderIOEither[T8], F9 ~func(A9) ReaderIOEither[T9], A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) func(T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-	return G.TraverseSeqTuple9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](f1, f2, f3, f4, f5, f6, f7, f8, f9)
+  return G.TraverseSeqTuple9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](f1, f2, f3, f4, f5, f6, f7, f8, f9)
 }
 
 // TraverseParTuple9 converts a [T.Tuple9] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple9].
 func TraverseParTuple9[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], F5 ~func(A5) ReaderIOEither[T5], F6 ~func(A6) ReaderIOEither[T6], F7 ~func(A7) ReaderIOEither[T7], F8 ~func(A8) ReaderIOEither[T8], F9 ~func(A9) ReaderIOEither[T9], A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) func(T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-	return G.TraverseParTuple9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](f1, f2, f3, f4, f5, f6, f7, f8, f9)
+  return G.TraverseParTuple9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](f1, f2, f3, f4, f5, f6, f7, f8, f9)
 }
 
 // Eitherize10 converts a function with 10 parameters returning a tuple into a function with 10 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize10]
 func Eitherize10[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ReaderIOEither[R] {
-	return G.Eitherize10[ReaderIOEither[R]](f)
+  return G.Eitherize10[ReaderIOEither[R]](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)
+  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)
 }
 
 // SequenceSeqT10 converts 10 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple10].
 func SequenceSeqT10[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.SequenceSeqT10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
+  return G.SequenceSeqT10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
 }
 
 // SequenceParT10 converts 10 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple10].
 func SequenceParT10[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.SequenceParT10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
+  return G.SequenceParT10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
 }
 
 // SequenceTuple10 converts a [T.Tuple10] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple10].
 func SequenceTuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t T.Tuple10[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4], ReaderIOEither[T5], ReaderIOEither[T6], ReaderIOEither[T7], ReaderIOEither[T8], ReaderIOEither[T9], ReaderIOEither[T10]]) ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-	return G.SequenceTuple10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](t)
+  return G.SequenceTuple10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](t)
 }
 
 // SequenceSeqTuple10 converts a [T.Tuple10] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple10].
 func SequenceSeqTuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t T.Tuple10[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4], ReaderIOEither[T5], ReaderIOEither[T6], ReaderIOEither[T7], ReaderIOEither[T8], ReaderIOEither[T9], ReaderIOEither[T10]]) ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-	return G.SequenceSeqTuple10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](t)
+  return G.SequenceSeqTuple10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](t)
 }
 
 // SequenceParTuple10 converts a [T.Tuple10] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple10].
 func SequenceParTuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t T.Tuple10[ReaderIOEither[T1], ReaderIOEither[T2], ReaderIOEither[T3], ReaderIOEither[T4], ReaderIOEither[T5], ReaderIOEither[T6], ReaderIOEither[T7], ReaderIOEither[T8], ReaderIOEither[T9], ReaderIOEither[T10]]) ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-	return G.SequenceParTuple10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](t)
+  return G.SequenceParTuple10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](t)
 }
 
 // TraverseTuple10 converts a [T.Tuple10] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple10].
 func TraverseTuple10[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], F5 ~func(A5) ReaderIOEither[T5], F6 ~func(A6) ReaderIOEither[T6], F7 ~func(A7) ReaderIOEither[T7], F8 ~func(A8) ReaderIOEither[T8], F9 ~func(A9) ReaderIOEither[T9], F10 ~func(A10) ReaderIOEither[T10], A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) func(T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-	return G.TraverseTuple10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)
+  return G.TraverseTuple10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)
 }
 
 // TraverseSeqTuple10 converts a [T.Tuple10] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple10].
 func TraverseSeqTuple10[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], F5 ~func(A5) ReaderIOEither[T5], F6 ~func(A6) ReaderIOEither[T6], F7 ~func(A7) ReaderIOEither[T7], F8 ~func(A8) ReaderIOEither[T8], F9 ~func(A9) ReaderIOEither[T9], F10 ~func(A10) ReaderIOEither[T10], A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) func(T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-	return G.TraverseSeqTuple10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)
+  return G.TraverseSeqTuple10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)
 }
 
 // TraverseParTuple10 converts a [T.Tuple10] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple10].
 func TraverseParTuple10[F1 ~func(A1) ReaderIOEither[T1], F2 ~func(A2) ReaderIOEither[T2], F3 ~func(A3) ReaderIOEither[T3], F4 ~func(A4) ReaderIOEither[T4], F5 ~func(A5) ReaderIOEither[T5], F6 ~func(A6) ReaderIOEither[T6], F7 ~func(A7) ReaderIOEither[T7], F8 ~func(A8) ReaderIOEither[T8], F9 ~func(A9) ReaderIOEither[T9], F10 ~func(A10) ReaderIOEither[T10], A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) func(T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-	return G.TraverseParTuple10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)
+  return G.TraverseParTuple10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)
 }

context/readerioeither/generic/traverse.go

@@ -62,6 +62,25 @@ func TraverseArray[
 	)
 }
 
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[
+	AS ~[]A,
+	GRBS ~func(context.Context) GIOBS,
+	GRB ~func(context.Context) GIOB,
+	GIOBS ~func() E.Either[error, BS],
+	GIOB ~func() E.Either[error, B],
+	BS ~[]B,
+	A, B any](f func(int, A) GRB) func(AS) GRBS {
+
+	return RA.TraverseWithIndex[AS](
+		Of[GRBS, GIOBS, BS],
+		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
+		Ap[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		f,
+	)
+}
+
 // SequenceArray converts a homogeneous sequence of either into an either of sequence
 func SequenceArray[
 	AS ~[]A,
@@ -115,6 +134,26 @@ func TraverseRecord[K comparable,
 	)
 }
 
+// TraverseRecordWithIndex transforms a record
+func TraverseRecordWithIndex[K comparable,
+	AS ~map[K]A,
+	GRBS ~func(context.Context) GIOBS,
+	GRB ~func(context.Context) GIOB,
+	GIOBS ~func() E.Either[error, BS],
+	GIOB ~func() E.Either[error, B],
+	BS ~map[K]B,
+
+	A, B any](f func(K, A) GRB) func(AS) GRBS {
+
+	return RR.TraverseWithIndex[AS](
+		Of[GRBS, GIOBS, BS],
+		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
+		Ap[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		f,
+	)
+}
+
 // SequenceRecord converts a homogeneous sequence of either into an either of sequence
 func SequenceRecord[K comparable,
 	AS ~map[K]A,

context/readerioeither/traverse.go

@@ -24,6 +24,11 @@ func TraverseArray[A, B any](f func(A) ReaderIOEither[B]) func([]A) ReaderIOEith
 	return G.TraverseArray[[]A, ReaderIOEither[[]B]](f)
 }
 
+// TraverseArrayWithIndex uses transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]]
+func TraverseArrayWithIndex[A, B any](f func(int, A) ReaderIOEither[B]) func([]A) ReaderIOEither[[]B] {
+	return G.TraverseArrayWithIndex[[]A, ReaderIOEither[[]B]](f)
+}
+
 // SequenceArray converts a homogeneous sequence of either into an either of sequence
 func SequenceArray[A any](ma []ReaderIOEither[A]) ReaderIOEither[[]A] {
 	return G.SequenceArray[[]A, []ReaderIOEither[A], ReaderIOEither[[]A]](ma)
@@ -34,6 +39,11 @@ func TraverseRecord[K comparable, A, B any](f func(A) ReaderIOEither[B]) func(ma
 	return G.TraverseRecord[K, map[K]A, ReaderIOEither[map[K]B]](f)
 }
 
+// TraverseRecordWithIndex uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
+func TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) ReaderIOEither[B]) func(map[K]A) ReaderIOEither[map[K]B] {
+	return G.TraverseRecordWithIndex[K, map[K]A, ReaderIOEither[map[K]B]](f)
+}
+
 // SequenceRecord converts a homogeneous sequence of either into an either of sequence
 func SequenceRecord[K comparable, A any](ma map[K]ReaderIOEither[A]) ReaderIOEither[map[K]A] {
 	return G.SequenceRecord[K, map[K]A, map[K]ReaderIOEither[A], ReaderIOEither[map[K]A]](ma)

either/array.go

@@ -20,7 +20,7 @@ import (
 	RA "github.com/IBM/fp-go/internal/array"
 )
 
-// TraverseArray transforms an array
+// TraverseArrayG transforms an array
 func TraverseArrayG[GA ~[]A, GB ~[]B, E, A, B any](f func(A) Either[E, B]) func(GA) Either[E, GB] {
 	return RA.Traverse[GA](
 		Of[E, GB],
@@ -36,6 +36,22 @@ func TraverseArray[E, A, B any](f func(A) Either[E, B]) func([]A) Either[E, []B]
 	return TraverseArrayG[[]A, []B](f)
 }
 
+// TraverseArrayWithIndexG transforms an array
+func TraverseArrayWithIndexG[GA ~[]A, GB ~[]B, E, A, B any](f func(int, A) Either[E, B]) func(GA) Either[E, GB] {
+	return RA.TraverseWithIndex[GA](
+		Of[E, GB],
+		Map[E, GB, func(B) GB],
+		Ap[GB, E, B],
+
+		f,
+	)
+}
+
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[E, A, B any](f func(int, A) Either[E, B]) func([]A) Either[E, []B] {
+	return TraverseArrayWithIndexG[[]A, []B](f)
+}
+
 func SequenceArrayG[GA ~[]A, GOA ~[]Either[E, A], E, A any](ma GOA) Either[E, GA] {
 	return TraverseArrayG[GOA, GA](F.Identity[Either[E, A]])(ma)
 }
@@ -44,3 +60,15 @@ func SequenceArrayG[GA ~[]A, GOA ~[]Either[E, A], E, A any](ma GOA) Either[E, GA
 func SequenceArray[E, A any](ma []Either[E, A]) Either[E, []A] {
 	return SequenceArrayG[[]A](ma)
 }
+
+// CompactArrayG discards the none values and keeps the some values
+func CompactArrayG[A1 ~[]Either[E, A], A2 ~[]A, E, A any](fa A1) A2 {
+	return RA.Reduce(fa, func(out A2, value Either[E, A]) A2 {
+		return MonadFold(value, F.Constant1[E](out), F.Bind1st(RA.Append[A2, A], out))
+	}, make(A2, len(fa)))
+}
+
+// CompactArray discards the none values and keeps the some values
+func CompactArray[E, A any](fa []Either[E, A]) []A {
+	return CompactArrayG[[]Either[E, A], []A](fa)
+}

either/either.go

@@ -91,11 +91,11 @@ func MonadChainTo[E, A, B any](ma Either[E, A], mb Either[E, B]) Either[E, B] {
 	return mb
 }
 
-func MonadChainOptionK[E, A, B any](onNone func() E, ma Either[E, A], f func(A) O.Option[B]) Either[E, B] {
+func MonadChainOptionK[A, B, E any](onNone func() E, ma Either[E, A], f func(A) O.Option[B]) Either[E, B] {
 	return MonadChain(ma, F.Flow2(f, FromOption[E, B](onNone)))
 }
 
-func ChainOptionK[E, A, B any](onNone func() E) func(func(A) O.Option[B]) func(Either[E, A]) Either[E, B] {
+func ChainOptionK[A, B, E any](onNone func() E) func(func(A) O.Option[B]) func(Either[E, A]) Either[E, B] {
 	from := FromOption[E, B](onNone)
 	return func(f func(A) O.Option[B]) func(Either[E, A]) Either[E, B] {
 		return Chain(F.Flow2(f, from))
@@ -209,7 +209,7 @@ func OrElse[E, A any](onLeft func(e E) Either[E, A]) func(Either[E, A]) Either[E
 	return Fold(onLeft, Of[E, A])
 }
 
-func ToType[E, A any](onError func(any) E) func(any) Either[E, A] {
+func ToType[A, E any](onError func(any) E) func(any) Either[E, A] {
 	return func(value any) Either[E, A] {
 		return F.Pipe2(
 			value,

either/either_test.go

@@ -100,7 +100,7 @@ func TestChainFirst(t *testing.T) {
 }
 
 func TestChainOptionK(t *testing.T) {
-	f := ChainOptionK[string, int, int](F.Constant("a"))(func(n int) O.Option[int] {
+	f := ChainOptionK[int, int](F.Constant("a"))(func(n int) O.Option[int] {
 		if n > 0 {
 			return O.Some(n)
 		}

either/record.go

@@ -20,7 +20,7 @@ import (
 	RR "github.com/IBM/fp-go/internal/record"
 )
 
-// TraverseRecord transforms a record of options into an option of a record
+// TraverseRecordG transforms a record of options into an option of a record
 func TraverseRecordG[GA ~map[K]A, GB ~map[K]B, K comparable, E, A, B any](f func(A) Either[E, B]) func(GA) Either[E, GB] {
 	return RR.Traverse[GA](
 		Of[E, GB],
@@ -35,6 +35,21 @@ func TraverseRecord[K comparable, E, A, B any](f func(A) Either[E, B]) func(map[
 	return TraverseRecordG[map[K]A, map[K]B](f)
 }
 
+// TraverseRecordWithIndexG transforms a record of options into an option of a record
+func TraverseRecordWithIndexG[GA ~map[K]A, GB ~map[K]B, K comparable, E, A, B any](f func(K, A) Either[E, B]) func(GA) Either[E, GB] {
+	return RR.TraverseWithIndex[GA](
+		Of[E, GB],
+		Map[E, GB, func(B) GB],
+		Ap[GB, E, B],
+		f,
+	)
+}
+
+// TraverseRecordWithIndex transforms a record of eithers into an either of a record
+func TraverseRecordWithIndex[K comparable, E, A, B any](f func(K, A) Either[E, B]) func(map[K]A) Either[E, map[K]B] {
+	return TraverseRecordWithIndexG[map[K]A, map[K]B](f)
+}
+
 func SequenceRecordG[GA ~map[K]A, GOA ~map[K]Either[E, A], K comparable, E, A any](ma GOA) Either[E, GA] {
 	return TraverseRecordG[GOA, GA](F.Identity[Either[E, A]])(ma)
 }
@@ -43,3 +58,24 @@ func SequenceRecordG[GA ~map[K]A, GOA ~map[K]Either[E, A], K comparable, E, A an
 func SequenceRecord[K comparable, E, A any](ma map[K]Either[E, A]) Either[E, map[K]A] {
 	return SequenceRecordG[map[K]A](ma)
 }
+
+func upsertAtReadWrite[M ~map[K]V, K comparable, V any](r M, k K, v V) M {
+	r[k] = v
+	return r
+}
+
+// CompactRecordG discards the noe values and keeps the some values
+func CompactRecordG[M1 ~map[K]Either[E, A], M2 ~map[K]A, K comparable, E, A any](m M1) M2 {
+	out := make(M2)
+	onLeft := F.Constant1[E](out)
+	return RR.ReduceWithIndex(m, func(key K, _ M2, value Either[E, A]) M2 {
+		return MonadFold(value, onLeft, func(v A) M2 {
+			return upsertAtReadWrite(out, key, v)
+		})
+	}, out)
+}
+
+// CompactRecord discards all none values and keeps the somes
+func CompactRecord[K comparable, E, A any](m map[K]Either[E, A]) map[K]A {
+	return CompactRecordG[map[K]Either[E, A], map[K]A](m)
+}

either/record_test.go

@@ -0,0 +1,37 @@
+// 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 either
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCompactRecord(t *testing.T) {
+	// make the map
+	m := make(map[string]Either[string, int])
+	m["foo"] = Left[int]("error")
+	m["bar"] = Right[string](1)
+	// compact it
+	m1 := CompactRecord(m)
+	// check expected
+	exp := map[string]int{
+		"bar": 1,
+	}
+
+	assert.Equal(t, exp, m1)
+}

either/traverse.go

@@ -27,13 +27,13 @@ HKTRB = HKT<Either[B]>
 HKTA = HKT<A>
 HKTB = HKT<B>
 */
-func traverse[E, A, B, HKTA, HKTB, HKTRB any](
-	_of func(Either[E, B]) HKTRB,
-	_map func(HKTB, func(B) Either[E, B]) HKTRB,
+func traverse[E, A, B, HKTB, HKTRB any](
+	mof func(Either[E, B]) HKTRB,
+	mmap func(func(B) Either[E, B]) func(HKTB) HKTRB,
 ) func(Either[E, A], func(A) HKTB) HKTRB {
 
-	left := F.Flow2(Left[B, E], _of)
-	right := F.Bind2nd(_map, Right[E, B])
+	left := F.Flow2(Left[B, E], mof)
+	right := mmap(Right[E, B])
 
 	return func(ta Either[E, A], f func(A) HKTB) HKTRB {
 		return MonadFold(ta,
@@ -43,27 +43,21 @@ func traverse[E, A, B, HKTA, HKTB, HKTRB any](
 	}
 }
 
-func Traverse[E, A, B, HKTA, HKTB, HKTRB any](
-	_of func(Either[E, B]) HKTRB,
-	_map func(HKTB, func(B) Either[E, B]) HKTRB,
+// Traverse converts an [Either] of some higher kinded type into the higher kinded type of an [Either]
+func Traverse[A, E, B, HKTB, HKTRB any](
+	mof func(Either[E, B]) HKTRB,
+	mmap func(func(B) Either[E, B]) func(HKTB) HKTRB,
 ) func(func(A) HKTB) func(Either[E, A]) HKTRB {
-	delegate := traverse[E, A, B, HKTA](_of, _map)
+	delegate := traverse[E, A, B](mof, mmap)
 	return func(f func(A) HKTB) func(Either[E, A]) HKTRB {
 		return F.Bind2nd(delegate, f)
 	}
 }
 
-/*
-*
-We need to pass the members of the applicative explicitly, because golang does neither support higher kinded types nor template methods on structs or interfaces
-
-HKTRA = HKT<Either[A]>
-HKTA = HKT<A>
-HKTB = HKT<B>
-*/
+// Sequence converts an [Either] of some higher kinded type into the higher kinded type of an [Either]
 func Sequence[E, A, HKTA, HKTRA any](
-	_of func(Either[E, A]) HKTRA,
-	_map func(HKTA, func(A) Either[E, A]) HKTRA,
+	mof func(Either[E, A]) HKTRA,
+	mmap func(func(A) Either[E, A]) func(HKTA) HKTRA,
 ) func(Either[E, HKTA]) HKTRA {
-	return Fold(F.Flow2(Left[A, E], _of), F.Bind2nd(_map, Right[E, A]))
+	return Fold(F.Flow2(Left[A, E], mof), mmap(Right[E, A]))
 }

either/traverse_test.go

@@ -30,9 +30,9 @@ func TestTraverse(t *testing.T) {
 		}
 		return O.None[int]()
 	}
-	trav := Traverse[string, int, int, O.Option[Either[string, int]]](
+	trav := Traverse[int](
 		O.Of[Either[string, int]],
-		O.MonadMap[int, Either[string, int]],
+		O.Map[int, Either[string, int]],
 	)(f)
 
 	assert.Equal(t, O.Of(Left[int]("a")), F.Pipe1(Left[int]("a"), trav))
@@ -44,7 +44,7 @@ func TestSequence(t *testing.T) {
 
 	seq := Sequence(
 		O.Of[Either[string, int]],
-		O.MonadMap[int, Either[string, int]],
+		O.Map[int, Either[string, int]],
 	)
 
 	assert.Equal(t, O.Of(Right[string](1)), seq(Right[string](O.Of(1))))

function/binds.go

@@ -1,455 +1,451 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-08-17 22:59:01.9404821 +0200 CEST m=+0.161366801
+// 2023-09-12 13:44:23.4226437 +0200 CEST m=+0.011841001
 
 package function
-
 // Combinations for a total of 1 arguments
 
 // Bind1of1 takes a function with 1 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
 // The return value of is a function with the remaining 0 parameters at positions [] of the original function.
 func Bind1of1[F ~func(T1) R, T1, R any](f F) func(T1) func() R {
-	return func(t1 T1) func() R {
-		return func() R {
-			return f(t1)
-		}
-	}
+  return func(t1 T1) func() R {
+    return func() R {
+      return f(t1)
+    }
+  }
 }
 
 // Ignore1of1 takes a function with 0 parameters and returns a new function with 1 parameters that will ignore the values at positions [1] and pass the remaining 0 parameters to the original function
 func Ignore1of1[T1 any, F ~func() R, R any](f F) func(T1) R {
-	return func(t1 T1) R {
-		return f()
-	}
+  return func(t1 T1) R {
+      return f()
+  }
 }
-
 // Combinations for a total of 2 arguments
 
 // Bind1of2 takes a function with 2 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
 // The return value of is a function with the remaining 1 parameters at positions [2] of the original function.
 func Bind1of2[F ~func(T1, T2) R, T1, T2, R any](f F) func(T1) func(T2) R {
-	return func(t1 T1) func(T2) R {
-		return func(t2 T2) R {
-			return f(t1, t2)
-		}
-	}
+  return func(t1 T1) func(T2) R {
+    return func(t2 T2) R {
+      return f(t1, t2)
+    }
+  }
 }
 
 // Ignore1of2 takes a function with 1 parameters and returns a new function with 2 parameters that will ignore the values at positions [1] and pass the remaining 1 parameters to the original function
 func Ignore1of2[T1 any, F ~func(T2) R, T2, R any](f F) func(T1, T2) R {
-	return func(t1 T1, t2 T2) R {
-		return f(t2)
-	}
+  return func(t1 T1, t2 T2) R {
+      return f(t2)
+  }
 }
 
 // Bind2of2 takes a function with 2 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [2] of the original function.
 // The return value of is a function with the remaining 1 parameters at positions [1] of the original function.
 func Bind2of2[F ~func(T1, T2) R, T1, T2, R any](f F) func(T2) func(T1) R {
-	return func(t2 T2) func(T1) R {
-		return func(t1 T1) R {
-			return f(t1, t2)
-		}
-	}
+  return func(t2 T2) func(T1) R {
+    return func(t1 T1) R {
+      return f(t1, t2)
+    }
+  }
 }
 
 // Ignore2of2 takes a function with 1 parameters and returns a new function with 2 parameters that will ignore the values at positions [2] and pass the remaining 1 parameters to the original function
 func Ignore2of2[T2 any, F ~func(T1) R, T1, R any](f F) func(T1, T2) R {
-	return func(t1 T1, t2 T2) R {
-		return f(t1)
-	}
+  return func(t1 T1, t2 T2) R {
+      return f(t1)
+  }
 }
 
 // Bind12of2 takes a function with 2 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [1, 2] of the original function.
 // The return value of is a function with the remaining 0 parameters at positions [] of the original function.
 func Bind12of2[F ~func(T1, T2) R, T1, T2, R any](f F) func(T1, T2) func() R {
-	return func(t1 T1, t2 T2) func() R {
-		return func() R {
-			return f(t1, t2)
-		}
-	}
+  return func(t1 T1, t2 T2) func() R {
+    return func() R {
+      return f(t1, t2)
+    }
+  }
 }
 
 // Ignore12of2 takes a function with 0 parameters and returns a new function with 2 parameters that will ignore the values at positions [1, 2] and pass the remaining 0 parameters to the original function
 func Ignore12of2[T1, T2 any, F ~func() R, R any](f F) func(T1, T2) R {
-	return func(t1 T1, t2 T2) R {
-		return f()
-	}
+  return func(t1 T1, t2 T2) R {
+      return f()
+  }
 }
-
 // Combinations for a total of 3 arguments
 
 // Bind1of3 takes a function with 3 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
 // The return value of is a function with the remaining 2 parameters at positions [2, 3] of the original function.
 func Bind1of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T1) func(T2, T3) R {
-	return func(t1 T1) func(T2, T3) R {
-		return func(t2 T2, t3 T3) R {
-			return f(t1, t2, t3)
-		}
-	}
+  return func(t1 T1) func(T2, T3) R {
+    return func(t2 T2, t3 T3) R {
+      return f(t1, t2, t3)
+    }
+  }
 }
 
 // Ignore1of3 takes a function with 2 parameters and returns a new function with 3 parameters that will ignore the values at positions [1] and pass the remaining 2 parameters to the original function
 func Ignore1of3[T1 any, F ~func(T2, T3) R, T2, T3, R any](f F) func(T1, T2, T3) R {
-	return func(t1 T1, t2 T2, t3 T3) R {
-		return f(t2, t3)
-	}
+  return func(t1 T1, t2 T2, t3 T3) R {
+      return f(t2, t3)
+  }
 }
 
 // Bind2of3 takes a function with 3 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [2] of the original function.
 // The return value of is a function with the remaining 2 parameters at positions [1, 3] of the original function.
 func Bind2of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T2) func(T1, T3) R {
-	return func(t2 T2) func(T1, T3) R {
-		return func(t1 T1, t3 T3) R {
-			return f(t1, t2, t3)
-		}
-	}
+  return func(t2 T2) func(T1, T3) R {
+    return func(t1 T1, t3 T3) R {
+      return f(t1, t2, t3)
+    }
+  }
 }
 
 // Ignore2of3 takes a function with 2 parameters and returns a new function with 3 parameters that will ignore the values at positions [2] and pass the remaining 2 parameters to the original function
 func Ignore2of3[T2 any, F ~func(T1, T3) R, T1, T3, R any](f F) func(T1, T2, T3) R {
-	return func(t1 T1, t2 T2, t3 T3) R {
-		return f(t1, t3)
-	}
+  return func(t1 T1, t2 T2, t3 T3) R {
+      return f(t1, t3)
+  }
 }
 
 // Bind3of3 takes a function with 3 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [3] of the original function.
 // The return value of is a function with the remaining 2 parameters at positions [1, 2] of the original function.
 func Bind3of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T3) func(T1, T2) R {
-	return func(t3 T3) func(T1, T2) R {
-		return func(t1 T1, t2 T2) R {
-			return f(t1, t2, t3)
-		}
-	}
+  return func(t3 T3) func(T1, T2) R {
+    return func(t1 T1, t2 T2) R {
+      return f(t1, t2, t3)
+    }
+  }
 }
 
 // Ignore3of3 takes a function with 2 parameters and returns a new function with 3 parameters that will ignore the values at positions [3] and pass the remaining 2 parameters to the original function
 func Ignore3of3[T3 any, F ~func(T1, T2) R, T1, T2, R any](f F) func(T1, T2, T3) R {
-	return func(t1 T1, t2 T2, t3 T3) R {
-		return f(t1, t2)
-	}
+  return func(t1 T1, t2 T2, t3 T3) R {
+      return f(t1, t2)
+  }
 }
 
 // Bind12of3 takes a function with 3 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [1, 2] of the original function.
 // The return value of is a function with the remaining 1 parameters at positions [3] of the original function.
 func Bind12of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T1, T2) func(T3) R {
-	return func(t1 T1, t2 T2) func(T3) R {
-		return func(t3 T3) R {
-			return f(t1, t2, t3)
-		}
-	}
+  return func(t1 T1, t2 T2) func(T3) R {
+    return func(t3 T3) R {
+      return f(t1, t2, t3)
+    }
+  }
 }
 
 // Ignore12of3 takes a function with 1 parameters and returns a new function with 3 parameters that will ignore the values at positions [1, 2] and pass the remaining 1 parameters to the original function
 func Ignore12of3[T1, T2 any, F ~func(T3) R, T3, R any](f F) func(T1, T2, T3) R {
-	return func(t1 T1, t2 T2, t3 T3) R {
-		return f(t3)
-	}
+  return func(t1 T1, t2 T2, t3 T3) R {
+      return f(t3)
+  }
 }
 
 // Bind13of3 takes a function with 3 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [1, 3] of the original function.
 // The return value of is a function with the remaining 1 parameters at positions [2] of the original function.
 func Bind13of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T1, T3) func(T2) R {
-	return func(t1 T1, t3 T3) func(T2) R {
-		return func(t2 T2) R {
-			return f(t1, t2, t3)
-		}
-	}
+  return func(t1 T1, t3 T3) func(T2) R {
+    return func(t2 T2) R {
+      return f(t1, t2, t3)
+    }
+  }
 }
 
 // Ignore13of3 takes a function with 1 parameters and returns a new function with 3 parameters that will ignore the values at positions [1, 3] and pass the remaining 1 parameters to the original function
 func Ignore13of3[T1, T3 any, F ~func(T2) R, T2, R any](f F) func(T1, T2, T3) R {
-	return func(t1 T1, t2 T2, t3 T3) R {
-		return f(t2)
-	}
+  return func(t1 T1, t2 T2, t3 T3) R {
+      return f(t2)
+  }
 }
 
 // Bind23of3 takes a function with 3 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [2, 3] of the original function.
 // The return value of is a function with the remaining 1 parameters at positions [1] of the original function.
 func Bind23of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T2, T3) func(T1) R {
-	return func(t2 T2, t3 T3) func(T1) R {
-		return func(t1 T1) R {
-			return f(t1, t2, t3)
-		}
-	}
+  return func(t2 T2, t3 T3) func(T1) R {
+    return func(t1 T1) R {
+      return f(t1, t2, t3)
+    }
+  }
 }
 
 // Ignore23of3 takes a function with 1 parameters and returns a new function with 3 parameters that will ignore the values at positions [2, 3] and pass the remaining 1 parameters to the original function
 func Ignore23of3[T2, T3 any, F ~func(T1) R, T1, R any](f F) func(T1, T2, T3) R {
-	return func(t1 T1, t2 T2, t3 T3) R {
-		return f(t1)
-	}
+  return func(t1 T1, t2 T2, t3 T3) R {
+      return f(t1)
+  }
 }
 
 // Bind123of3 takes a function with 3 parameters and returns a new function with 3 parameters that will bind these parameters to the positions [1, 2, 3] of the original function.
 // The return value of is a function with the remaining 0 parameters at positions [] of the original function.
 func Bind123of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T1, T2, T3) func() R {
-	return func(t1 T1, t2 T2, t3 T3) func() R {
-		return func() R {
-			return f(t1, t2, t3)
-		}
-	}
+  return func(t1 T1, t2 T2, t3 T3) func() R {
+    return func() R {
+      return f(t1, t2, t3)
+    }
+  }
 }
 
 // Ignore123of3 takes a function with 0 parameters and returns a new function with 3 parameters that will ignore the values at positions [1, 2, 3] and pass the remaining 0 parameters to the original function
 func Ignore123of3[T1, T2, T3 any, F ~func() R, R any](f F) func(T1, T2, T3) R {
-	return func(t1 T1, t2 T2, t3 T3) R {
-		return f()
-	}
+  return func(t1 T1, t2 T2, t3 T3) R {
+      return f()
+  }
 }
-
 // Combinations for a total of 4 arguments
 
 // Bind1of4 takes a function with 4 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
 // The return value of is a function with the remaining 3 parameters at positions [2, 3, 4] of the original function.
 func Bind1of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1) func(T2, T3, T4) R {
-	return func(t1 T1) func(T2, T3, T4) R {
-		return func(t2 T2, t3 T3, t4 T4) R {
-			return f(t1, t2, t3, t4)
-		}
-	}
+  return func(t1 T1) func(T2, T3, T4) R {
+    return func(t2 T2, t3 T3, t4 T4) R {
+      return f(t1, t2, t3, t4)
+    }
+  }
 }
 
 // Ignore1of4 takes a function with 3 parameters and returns a new function with 4 parameters that will ignore the values at positions [1] and pass the remaining 3 parameters to the original function
 func Ignore1of4[T1 any, F ~func(T2, T3, T4) R, T2, T3, T4, R any](f F) func(T1, T2, T3, T4) R {
-	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-		return f(t2, t3, t4)
-	}
+  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+      return f(t2, t3, t4)
+  }
 }
 
 // Bind2of4 takes a function with 4 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [2] of the original function.
 // The return value of is a function with the remaining 3 parameters at positions [1, 3, 4] of the original function.
 func Bind2of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T2) func(T1, T3, T4) R {
-	return func(t2 T2) func(T1, T3, T4) R {
-		return func(t1 T1, t3 T3, t4 T4) R {
-			return f(t1, t2, t3, t4)
-		}
-	}
+  return func(t2 T2) func(T1, T3, T4) R {
+    return func(t1 T1, t3 T3, t4 T4) R {
+      return f(t1, t2, t3, t4)
+    }
+  }
 }
 
 // Ignore2of4 takes a function with 3 parameters and returns a new function with 4 parameters that will ignore the values at positions [2] and pass the remaining 3 parameters to the original function
 func Ignore2of4[T2 any, F ~func(T1, T3, T4) R, T1, T3, T4, R any](f F) func(T1, T2, T3, T4) R {
-	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-		return f(t1, t3, t4)
-	}
+  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+      return f(t1, t3, t4)
+  }
 }
 
 // Bind3of4 takes a function with 4 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [3] of the original function.
 // The return value of is a function with the remaining 3 parameters at positions [1, 2, 4] of the original function.
 func Bind3of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T3) func(T1, T2, T4) R {
-	return func(t3 T3) func(T1, T2, T4) R {
-		return func(t1 T1, t2 T2, t4 T4) R {
-			return f(t1, t2, t3, t4)
-		}
-	}
+  return func(t3 T3) func(T1, T2, T4) R {
+    return func(t1 T1, t2 T2, t4 T4) R {
+      return f(t1, t2, t3, t4)
+    }
+  }
 }
 
 // Ignore3of4 takes a function with 3 parameters and returns a new function with 4 parameters that will ignore the values at positions [3] and pass the remaining 3 parameters to the original function
 func Ignore3of4[T3 any, F ~func(T1, T2, T4) R, T1, T2, T4, R any](f F) func(T1, T2, T3, T4) R {
-	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-		return f(t1, t2, t4)
-	}
+  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+      return f(t1, t2, t4)
+  }
 }
 
 // Bind4of4 takes a function with 4 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [4] of the original function.
 // The return value of is a function with the remaining 3 parameters at positions [1, 2, 3] of the original function.
 func Bind4of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T4) func(T1, T2, T3) R {
-	return func(t4 T4) func(T1, T2, T3) R {
-		return func(t1 T1, t2 T2, t3 T3) R {
-			return f(t1, t2, t3, t4)
-		}
-	}
+  return func(t4 T4) func(T1, T2, T3) R {
+    return func(t1 T1, t2 T2, t3 T3) R {
+      return f(t1, t2, t3, t4)
+    }
+  }
 }
 
 // Ignore4of4 takes a function with 3 parameters and returns a new function with 4 parameters that will ignore the values at positions [4] and pass the remaining 3 parameters to the original function
 func Ignore4of4[T4 any, F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T1, T2, T3, T4) R {
-	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-		return f(t1, t2, t3)
-	}
+  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+      return f(t1, t2, t3)
+  }
 }
 
 // Bind12of4 takes a function with 4 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [1, 2] of the original function.
 // The return value of is a function with the remaining 2 parameters at positions [3, 4] of the original function.
 func Bind12of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T2) func(T3, T4) R {
-	return func(t1 T1, t2 T2) func(T3, T4) R {
-		return func(t3 T3, t4 T4) R {
-			return f(t1, t2, t3, t4)
-		}
-	}
+  return func(t1 T1, t2 T2) func(T3, T4) R {
+    return func(t3 T3, t4 T4) R {
+      return f(t1, t2, t3, t4)
+    }
+  }
 }
 
 // Ignore12of4 takes a function with 2 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 2] and pass the remaining 2 parameters to the original function
 func Ignore12of4[T1, T2 any, F ~func(T3, T4) R, T3, T4, R any](f F) func(T1, T2, T3, T4) R {
-	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-		return f(t3, t4)
-	}
+  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+      return f(t3, t4)
+  }
 }
 
 // Bind13of4 takes a function with 4 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [1, 3] of the original function.
 // The return value of is a function with the remaining 2 parameters at positions [2, 4] of the original function.
 func Bind13of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T3) func(T2, T4) R {
-	return func(t1 T1, t3 T3) func(T2, T4) R {
-		return func(t2 T2, t4 T4) R {
-			return f(t1, t2, t3, t4)
-		}
-	}
+  return func(t1 T1, t3 T3) func(T2, T4) R {
+    return func(t2 T2, t4 T4) R {
+      return f(t1, t2, t3, t4)
+    }
+  }
 }
 
 // Ignore13of4 takes a function with 2 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 3] and pass the remaining 2 parameters to the original function
 func Ignore13of4[T1, T3 any, F ~func(T2, T4) R, T2, T4, R any](f F) func(T1, T2, T3, T4) R {
-	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-		return f(t2, t4)
-	}
+  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+      return f(t2, t4)
+  }
 }
 
 // Bind14of4 takes a function with 4 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [1, 4] of the original function.
 // The return value of is a function with the remaining 2 parameters at positions [2, 3] of the original function.
 func Bind14of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T4) func(T2, T3) R {
-	return func(t1 T1, t4 T4) func(T2, T3) R {
-		return func(t2 T2, t3 T3) R {
-			return f(t1, t2, t3, t4)
-		}
-	}
+  return func(t1 T1, t4 T4) func(T2, T3) R {
+    return func(t2 T2, t3 T3) R {
+      return f(t1, t2, t3, t4)
+    }
+  }
 }
 
 // Ignore14of4 takes a function with 2 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 4] and pass the remaining 2 parameters to the original function
 func Ignore14of4[T1, T4 any, F ~func(T2, T3) R, T2, T3, R any](f F) func(T1, T2, T3, T4) R {
-	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-		return f(t2, t3)
-	}
+  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+      return f(t2, t3)
+  }
 }
 
 // Bind23of4 takes a function with 4 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [2, 3] of the original function.
 // The return value of is a function with the remaining 2 parameters at positions [1, 4] of the original function.
 func Bind23of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T2, T3) func(T1, T4) R {
-	return func(t2 T2, t3 T3) func(T1, T4) R {
-		return func(t1 T1, t4 T4) R {
-			return f(t1, t2, t3, t4)
-		}
-	}
+  return func(t2 T2, t3 T3) func(T1, T4) R {
+    return func(t1 T1, t4 T4) R {
+      return f(t1, t2, t3, t4)
+    }
+  }
 }
 
 // Ignore23of4 takes a function with 2 parameters and returns a new function with 4 parameters that will ignore the values at positions [2, 3] and pass the remaining 2 parameters to the original function
 func Ignore23of4[T2, T3 any, F ~func(T1, T4) R, T1, T4, R any](f F) func(T1, T2, T3, T4) R {
-	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-		return f(t1, t4)
-	}
+  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+      return f(t1, t4)
+  }
 }
 
 // Bind24of4 takes a function with 4 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [2, 4] of the original function.
 // The return value of is a function with the remaining 2 parameters at positions [1, 3] of the original function.
 func Bind24of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T2, T4) func(T1, T3) R {
-	return func(t2 T2, t4 T4) func(T1, T3) R {
-		return func(t1 T1, t3 T3) R {
-			return f(t1, t2, t3, t4)
-		}
-	}
+  return func(t2 T2, t4 T4) func(T1, T3) R {
+    return func(t1 T1, t3 T3) R {
+      return f(t1, t2, t3, t4)
+    }
+  }
 }
 
 // Ignore24of4 takes a function with 2 parameters and returns a new function with 4 parameters that will ignore the values at positions [2, 4] and pass the remaining 2 parameters to the original function
 func Ignore24of4[T2, T4 any, F ~func(T1, T3) R, T1, T3, R any](f F) func(T1, T2, T3, T4) R {
-	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-		return f(t1, t3)
-	}
+  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+      return f(t1, t3)
+  }
 }
 
 // Bind34of4 takes a function with 4 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [3, 4] of the original function.
 // The return value of is a function with the remaining 2 parameters at positions [1, 2] of the original function.
 func Bind34of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T3, T4) func(T1, T2) R {
-	return func(t3 T3, t4 T4) func(T1, T2) R {
-		return func(t1 T1, t2 T2) R {
-			return f(t1, t2, t3, t4)
-		}
-	}
+  return func(t3 T3, t4 T4) func(T1, T2) R {
+    return func(t1 T1, t2 T2) R {
+      return f(t1, t2, t3, t4)
+    }
+  }
 }
 
 // Ignore34of4 takes a function with 2 parameters and returns a new function with 4 parameters that will ignore the values at positions [3, 4] and pass the remaining 2 parameters to the original function
 func Ignore34of4[T3, T4 any, F ~func(T1, T2) R, T1, T2, R any](f F) func(T1, T2, T3, T4) R {
-	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-		return f(t1, t2)
-	}
+  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+      return f(t1, t2)
+  }
 }
 
 // Bind123of4 takes a function with 4 parameters and returns a new function with 3 parameters that will bind these parameters to the positions [1, 2, 3] of the original function.
 // The return value of is a function with the remaining 1 parameters at positions [4] of the original function.
 func Bind123of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T2, T3) func(T4) R {
-	return func(t1 T1, t2 T2, t3 T3) func(T4) R {
-		return func(t4 T4) R {
-			return f(t1, t2, t3, t4)
-		}
-	}
+  return func(t1 T1, t2 T2, t3 T3) func(T4) R {
+    return func(t4 T4) R {
+      return f(t1, t2, t3, t4)
+    }
+  }
 }
 
 // Ignore123of4 takes a function with 1 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 2, 3] and pass the remaining 1 parameters to the original function
 func Ignore123of4[T1, T2, T3 any, F ~func(T4) R, T4, R any](f F) func(T1, T2, T3, T4) R {
-	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-		return f(t4)
-	}
+  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+      return f(t4)
+  }
 }
 
 // Bind124of4 takes a function with 4 parameters and returns a new function with 3 parameters that will bind these parameters to the positions [1, 2, 4] of the original function.
 // The return value of is a function with the remaining 1 parameters at positions [3] of the original function.
 func Bind124of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T2, T4) func(T3) R {
-	return func(t1 T1, t2 T2, t4 T4) func(T3) R {
-		return func(t3 T3) R {
-			return f(t1, t2, t3, t4)
-		}
-	}
+  return func(t1 T1, t2 T2, t4 T4) func(T3) R {
+    return func(t3 T3) R {
+      return f(t1, t2, t3, t4)
+    }
+  }
 }
 
 // Ignore124of4 takes a function with 1 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 2, 4] and pass the remaining 1 parameters to the original function
 func Ignore124of4[T1, T2, T4 any, F ~func(T3) R, T3, R any](f F) func(T1, T2, T3, T4) R {
-	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-		return f(t3)
-	}
+  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+      return f(t3)
+  }
 }
 
 // Bind134of4 takes a function with 4 parameters and returns a new function with 3 parameters that will bind these parameters to the positions [1, 3, 4] of the original function.
 // The return value of is a function with the remaining 1 parameters at positions [2] of the original function.
 func Bind134of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T3, T4) func(T2) R {
-	return func(t1 T1, t3 T3, t4 T4) func(T2) R {
-		return func(t2 T2) R {
-			return f(t1, t2, t3, t4)
-		}
-	}
+  return func(t1 T1, t3 T3, t4 T4) func(T2) R {
+    return func(t2 T2) R {
+      return f(t1, t2, t3, t4)
+    }
+  }
 }
 
 // Ignore134of4 takes a function with 1 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 3, 4] and pass the remaining 1 parameters to the original function
 func Ignore134of4[T1, T3, T4 any, F ~func(T2) R, T2, R any](f F) func(T1, T2, T3, T4) R {
-	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-		return f(t2)
-	}
+  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+      return f(t2)
+  }
 }
 
 // Bind234of4 takes a function with 4 parameters and returns a new function with 3 parameters that will bind these parameters to the positions [2, 3, 4] of the original function.
 // The return value of is a function with the remaining 1 parameters at positions [1] of the original function.
 func Bind234of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T2, T3, T4) func(T1) R {
-	return func(t2 T2, t3 T3, t4 T4) func(T1) R {
-		return func(t1 T1) R {
-			return f(t1, t2, t3, t4)
-		}
-	}
+  return func(t2 T2, t3 T3, t4 T4) func(T1) R {
+    return func(t1 T1) R {
+      return f(t1, t2, t3, t4)
+    }
+  }
 }
 
 // Ignore234of4 takes a function with 1 parameters and returns a new function with 4 parameters that will ignore the values at positions [2, 3, 4] and pass the remaining 1 parameters to the original function
 func Ignore234of4[T2, T3, T4 any, F ~func(T1) R, T1, R any](f F) func(T1, T2, T3, T4) R {
-	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-		return f(t1)
-	}
+  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+      return f(t1)
+  }
 }
 
 // Bind1234of4 takes a function with 4 parameters and returns a new function with 4 parameters that will bind these parameters to the positions [1, 2, 3, 4] of the original function.
 // The return value of is a function with the remaining 0 parameters at positions [] of the original function.
 func Bind1234of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T2, T3, T4) func() R {
-	return func(t1 T1, t2 T2, t3 T3, t4 T4) func() R {
-		return func() R {
-			return f(t1, t2, t3, t4)
-		}
-	}
+  return func(t1 T1, t2 T2, t3 T3, t4 T4) func() R {
+    return func() R {
+      return f(t1, t2, t3, t4)
+    }
+  }
 }
 
 // Ignore1234of4 takes a function with 0 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 2, 3, 4] and pass the remaining 0 parameters to the original function
 func Ignore1234of4[T1, T2, T3, T4 any, F ~func() R, R any](f F) func(T1, T2, T3, T4) R {
-	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-		return f()
-	}
+  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+      return f()
+  }
 }

function/cache.go

@@ -19,12 +19,12 @@ import (
 	G "github.com/IBM/fp-go/function/generic"
 )
 
-// Cache converts a unary function into a unary function that caches the value depending on the parameter
-func Cache[K comparable, T any](f func(K) T) func(K) T {
-	return G.Cache(f)
+// Memoize converts a unary function into a unary function that caches the value depending on the parameter
+func Memoize[K comparable, T any](f func(K) T) func(K) T {
+	return G.Memoize(f)
 }
 
-// ContramapCache converts a unary function into a unary function that caches the value depending on the parameter
-func ContramapCache[A any, K comparable, T any](kf func(A) K) func(func(A) T) func(A) T {
-	return G.ContramapCache[func(A) T](kf)
+// ContramapMemoize converts a unary function into a unary function that caches the value depending on the parameter
+func ContramapMemoize[A any, K comparable, T any](kf func(A) K) func(func(A) T) func(A) T {
+	return G.ContramapMemoize[func(A) T](kf)
 }

function/cache_test.go

@@ -29,7 +29,7 @@ func TestCache(t *testing.T) {
 		return n
 	}
 
-	cached := Cache(withSideEffect)
+	cached := Memoize(withSideEffect)
 
 	assert.Equal(t, 0, count)
 

function/generic/cache.go

@@ -21,13 +21,13 @@ import (
 	L "github.com/IBM/fp-go/internal/lazy"
 )
 
-// Cache converts a unary function into a unary function that caches the value depending on the parameter
-func Cache[F ~func(K) T, K comparable, T any](f F) F {
-	return ContramapCache[F](func(k K) K { return k })(f)
+// Memoize converts a unary function into a unary function that caches the value depending on the parameter
+func Memoize[F ~func(K) T, K comparable, T any](f F) F {
+	return ContramapMemoize[F](func(k K) K { return k })(f)
 }
 
-// ContramapCache converts a unary function into a unary function that caches the value depending on the parameter
-func ContramapCache[F ~func(A) T, KF func(A) K, A any, K comparable, T any](kf KF) func(F) F {
+// ContramapMemoize converts a unary function into a unary function that caches the value depending on the parameter
+func ContramapMemoize[F ~func(A) T, KF func(A) K, A any, K comparable, T any](kf KF) func(F) F {
 	return CacheCallback[F](kf, getOrCreate[K, T]())
 }
 

function/unvariadic_test.go

@@ -0,0 +1,45 @@
+// 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 function
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func fromLibrary(data ...string) string {
+	return strings.Join(data, "-")
+}
+
+func TestUnvariadic(t *testing.T) {
+
+	res := Pipe1(
+		[]string{"A", "B"},
+		Unvariadic0(fromLibrary),
+	)
+
+	assert.Equal(t, "A-B", res)
+}
+
+func TestVariadicArity(t *testing.T) {
+
+	f := Unsliced2(Unvariadic0(fromLibrary))
+
+	res := f("A", "B")
+	assert.Equal(t, "A-B", res)
+}

identity/gen.go

@@ -1,9 +1,10 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-08-17 22:59:06.2987136 +0200 CEST m=+0.049156901
+// 2023-09-12 13:44:24.9409324 +0200 CEST m=+0.008573601
 
 package identity
 
+
 import (
 	A "github.com/IBM/fp-go/internal/apply"
 	T "github.com/IBM/fp-go/tuple"
@@ -11,495 +12,495 @@ import (
 
 // SequenceT1 converts 1 parameters of [T] into a [Tuple1].
 func SequenceT1[T1 any](t1 T1) T.Tuple1[T1] {
-	return A.SequenceT1(
-		Map[T1, T.Tuple1[T1]],
-		t1,
-	)
+  return A.SequenceT1(
+    Map[T1, T.Tuple1[T1]],
+    t1,
+  )
 }
 
 // SequenceTuple1 converts a [Tuple1] of [T] into an [Tuple1].
 func SequenceTuple1[T1 any](t T.Tuple1[T1]) T.Tuple1[T1] {
-	return A.SequenceTuple1(
-		Map[T1, T.Tuple1[T1]],
-		t,
-	)
+  return A.SequenceTuple1(
+    Map[T1, T.Tuple1[T1]],
+    t,
+  )
 }
 
 // TraverseTuple1 converts a [Tuple1] of [A] via transformation functions transforming [A] to [A] into a [Tuple1].
-func TraverseTuple1[F1 ~func(A1) T1, A1, T1 any](f1 F1) func(T.Tuple1[A1]) T.Tuple1[T1] {
-	return func(t T.Tuple1[A1]) T.Tuple1[T1] {
-		return A.TraverseTuple1(
-			Map[T1, T.Tuple1[T1]],
-			f1,
-			t,
-		)
-	}
+func TraverseTuple1[F1 ~func(A1) T1, A1, T1 any](f1 F1) func (T.Tuple1[A1]) T.Tuple1[T1] {
+  return func(t T.Tuple1[A1]) T.Tuple1[T1] {
+    return A.TraverseTuple1(
+      Map[T1, T.Tuple1[T1]],
+      f1,
+      t,
+    )
+  }
 }
 
 // SequenceT2 converts 2 parameters of [T] into a [Tuple2].
 func SequenceT2[T1, T2 any](t1 T1, t2 T2) T.Tuple2[T1, T2] {
-	return A.SequenceT2(
-		Map[T1, func(T2) T.Tuple2[T1, T2]],
-		Ap[T.Tuple2[T1, T2], T2],
-		t1,
-		t2,
-	)
+  return A.SequenceT2(
+    Map[T1, func(T2) T.Tuple2[T1, T2]],
+    Ap[T.Tuple2[T1, T2], T2],
+    t1,
+    t2,
+  )
 }
 
 // SequenceTuple2 converts a [Tuple2] of [T] into an [Tuple2].
 func SequenceTuple2[T1, T2 any](t T.Tuple2[T1, T2]) T.Tuple2[T1, T2] {
-	return A.SequenceTuple2(
-		Map[T1, func(T2) T.Tuple2[T1, T2]],
-		Ap[T.Tuple2[T1, T2], T2],
-		t,
-	)
+  return A.SequenceTuple2(
+    Map[T1, func(T2) T.Tuple2[T1, T2]],
+    Ap[T.Tuple2[T1, T2], T2],
+    t,
+  )
 }
 
 // TraverseTuple2 converts a [Tuple2] of [A] via transformation functions transforming [A] to [A] into a [Tuple2].
-func TraverseTuple2[F1 ~func(A1) T1, F2 ~func(A2) T2, A1, T1, A2, T2 any](f1 F1, f2 F2) func(T.Tuple2[A1, A2]) T.Tuple2[T1, T2] {
-	return func(t T.Tuple2[A1, A2]) T.Tuple2[T1, T2] {
-		return A.TraverseTuple2(
-			Map[T1, func(T2) T.Tuple2[T1, T2]],
-			Ap[T.Tuple2[T1, T2], T2],
-			f1,
-			f2,
-			t,
-		)
-	}
+func TraverseTuple2[F1 ~func(A1) T1, F2 ~func(A2) T2, A1, T1, A2, T2 any](f1 F1, f2 F2) func (T.Tuple2[A1, A2]) T.Tuple2[T1, T2] {
+  return func(t T.Tuple2[A1, A2]) T.Tuple2[T1, T2] {
+    return A.TraverseTuple2(
+      Map[T1, func(T2) T.Tuple2[T1, T2]],
+      Ap[T.Tuple2[T1, T2], T2],
+      f1,
+      f2,
+      t,
+    )
+  }
 }
 
 // SequenceT3 converts 3 parameters of [T] into a [Tuple3].
 func SequenceT3[T1, T2, T3 any](t1 T1, t2 T2, t3 T3) T.Tuple3[T1, T2, T3] {
-	return A.SequenceT3(
-		Map[T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
-		Ap[func(T3) T.Tuple3[T1, T2, T3], T2],
-		Ap[T.Tuple3[T1, T2, T3], T3],
-		t1,
-		t2,
-		t3,
-	)
+  return A.SequenceT3(
+    Map[T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
+    Ap[func(T3) T.Tuple3[T1, T2, T3], T2],
+    Ap[T.Tuple3[T1, T2, T3], T3],
+    t1,
+    t2,
+    t3,
+  )
 }
 
 // SequenceTuple3 converts a [Tuple3] of [T] into an [Tuple3].
 func SequenceTuple3[T1, T2, T3 any](t T.Tuple3[T1, T2, T3]) T.Tuple3[T1, T2, T3] {
-	return A.SequenceTuple3(
-		Map[T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
-		Ap[func(T3) T.Tuple3[T1, T2, T3], T2],
-		Ap[T.Tuple3[T1, T2, T3], T3],
-		t,
-	)
+  return A.SequenceTuple3(
+    Map[T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
+    Ap[func(T3) T.Tuple3[T1, T2, T3], T2],
+    Ap[T.Tuple3[T1, T2, T3], T3],
+    t,
+  )
 }
 
 // TraverseTuple3 converts a [Tuple3] of [A] via transformation functions transforming [A] to [A] into a [Tuple3].
-func TraverseTuple3[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, A1, T1, A2, T2, A3, T3 any](f1 F1, f2 F2, f3 F3) func(T.Tuple3[A1, A2, A3]) T.Tuple3[T1, T2, T3] {
-	return func(t T.Tuple3[A1, A2, A3]) T.Tuple3[T1, T2, T3] {
-		return A.TraverseTuple3(
-			Map[T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
-			Ap[func(T3) T.Tuple3[T1, T2, T3], T2],
-			Ap[T.Tuple3[T1, T2, T3], T3],
-			f1,
-			f2,
-			f3,
-			t,
-		)
-	}
+func TraverseTuple3[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, A1, T1, A2, T2, A3, T3 any](f1 F1, f2 F2, f3 F3) func (T.Tuple3[A1, A2, A3]) T.Tuple3[T1, T2, T3] {
+  return func(t T.Tuple3[A1, A2, A3]) T.Tuple3[T1, T2, T3] {
+    return A.TraverseTuple3(
+      Map[T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
+      Ap[func(T3) T.Tuple3[T1, T2, T3], T2],
+      Ap[T.Tuple3[T1, T2, T3], T3],
+      f1,
+      f2,
+      f3,
+      t,
+    )
+  }
 }
 
 // SequenceT4 converts 4 parameters of [T] into a [Tuple4].
 func SequenceT4[T1, T2, T3, T4 any](t1 T1, t2 T2, t3 T3, t4 T4) T.Tuple4[T1, T2, T3, T4] {
-	return A.SequenceT4(
-		Map[T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
-		Ap[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], T2],
-		Ap[func(T4) T.Tuple4[T1, T2, T3, T4], T3],
-		Ap[T.Tuple4[T1, T2, T3, T4], T4],
-		t1,
-		t2,
-		t3,
-		t4,
-	)
+  return A.SequenceT4(
+    Map[T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
+    Ap[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], T2],
+    Ap[func(T4) T.Tuple4[T1, T2, T3, T4], T3],
+    Ap[T.Tuple4[T1, T2, T3, T4], T4],
+    t1,
+    t2,
+    t3,
+    t4,
+  )
 }
 
 // SequenceTuple4 converts a [Tuple4] of [T] into an [Tuple4].
 func SequenceTuple4[T1, T2, T3, T4 any](t T.Tuple4[T1, T2, T3, T4]) T.Tuple4[T1, T2, T3, T4] {
-	return A.SequenceTuple4(
-		Map[T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
-		Ap[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], T2],
-		Ap[func(T4) T.Tuple4[T1, T2, T3, T4], T3],
-		Ap[T.Tuple4[T1, T2, T3, T4], T4],
-		t,
-	)
+  return A.SequenceTuple4(
+    Map[T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
+    Ap[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], T2],
+    Ap[func(T4) T.Tuple4[T1, T2, T3, T4], T3],
+    Ap[T.Tuple4[T1, T2, T3, T4], T4],
+    t,
+  )
 }
 
 // TraverseTuple4 converts a [Tuple4] of [A] via transformation functions transforming [A] to [A] into a [Tuple4].
-func TraverseTuple4[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, A1, T1, A2, T2, A3, T3, A4, T4 any](f1 F1, f2 F2, f3 F3, f4 F4) func(T.Tuple4[A1, A2, A3, A4]) T.Tuple4[T1, T2, T3, T4] {
-	return func(t T.Tuple4[A1, A2, A3, A4]) T.Tuple4[T1, T2, T3, T4] {
-		return A.TraverseTuple4(
-			Map[T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
-			Ap[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], T2],
-			Ap[func(T4) T.Tuple4[T1, T2, T3, T4], T3],
-			Ap[T.Tuple4[T1, T2, T3, T4], T4],
-			f1,
-			f2,
-			f3,
-			f4,
-			t,
-		)
-	}
+func TraverseTuple4[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, A1, T1, A2, T2, A3, T3, A4, T4 any](f1 F1, f2 F2, f3 F3, f4 F4) func (T.Tuple4[A1, A2, A3, A4]) T.Tuple4[T1, T2, T3, T4] {
+  return func(t T.Tuple4[A1, A2, A3, A4]) T.Tuple4[T1, T2, T3, T4] {
+    return A.TraverseTuple4(
+      Map[T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
+      Ap[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], T2],
+      Ap[func(T4) T.Tuple4[T1, T2, T3, T4], T3],
+      Ap[T.Tuple4[T1, T2, T3, T4], T4],
+      f1,
+      f2,
+      f3,
+      f4,
+      t,
+    )
+  }
 }
 
 // SequenceT5 converts 5 parameters of [T] into a [Tuple5].
 func SequenceT5[T1, T2, T3, T4, T5 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) T.Tuple5[T1, T2, T3, T4, T5] {
-	return A.SequenceT5(
-		Map[T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
-		Ap[func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T2],
-		Ap[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T3],
-		Ap[func(T5) T.Tuple5[T1, T2, T3, T4, T5], T4],
-		Ap[T.Tuple5[T1, T2, T3, T4, T5], T5],
-		t1,
-		t2,
-		t3,
-		t4,
-		t5,
-	)
+  return A.SequenceT5(
+    Map[T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
+    Ap[func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T2],
+    Ap[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T3],
+    Ap[func(T5) T.Tuple5[T1, T2, T3, T4, T5], T4],
+    Ap[T.Tuple5[T1, T2, T3, T4, T5], T5],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+  )
 }
 
 // SequenceTuple5 converts a [Tuple5] of [T] into an [Tuple5].
 func SequenceTuple5[T1, T2, T3, T4, T5 any](t T.Tuple5[T1, T2, T3, T4, T5]) T.Tuple5[T1, T2, T3, T4, T5] {
-	return A.SequenceTuple5(
-		Map[T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
-		Ap[func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T2],
-		Ap[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T3],
-		Ap[func(T5) T.Tuple5[T1, T2, T3, T4, T5], T4],
-		Ap[T.Tuple5[T1, T2, T3, T4, T5], T5],
-		t,
-	)
+  return A.SequenceTuple5(
+    Map[T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
+    Ap[func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T2],
+    Ap[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T3],
+    Ap[func(T5) T.Tuple5[T1, T2, T3, T4, T5], T4],
+    Ap[T.Tuple5[T1, T2, T3, T4, T5], T5],
+    t,
+  )
 }
 
 // TraverseTuple5 converts a [Tuple5] of [A] via transformation functions transforming [A] to [A] into a [Tuple5].
-func TraverseTuple5[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) func(T.Tuple5[A1, A2, A3, A4, A5]) T.Tuple5[T1, T2, T3, T4, T5] {
-	return func(t T.Tuple5[A1, A2, A3, A4, A5]) T.Tuple5[T1, T2, T3, T4, T5] {
-		return A.TraverseTuple5(
-			Map[T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
-			Ap[func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T2],
-			Ap[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T3],
-			Ap[func(T5) T.Tuple5[T1, T2, T3, T4, T5], T4],
-			Ap[T.Tuple5[T1, T2, T3, T4, T5], T5],
-			f1,
-			f2,
-			f3,
-			f4,
-			f5,
-			t,
-		)
-	}
+func TraverseTuple5[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) func (T.Tuple5[A1, A2, A3, A4, A5]) T.Tuple5[T1, T2, T3, T4, T5] {
+  return func(t T.Tuple5[A1, A2, A3, A4, A5]) T.Tuple5[T1, T2, T3, T4, T5] {
+    return A.TraverseTuple5(
+      Map[T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
+      Ap[func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T2],
+      Ap[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T3],
+      Ap[func(T5) T.Tuple5[T1, T2, T3, T4, T5], T4],
+      Ap[T.Tuple5[T1, T2, T3, T4, T5], T5],
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      t,
+    )
+  }
 }
 
 // SequenceT6 converts 6 parameters of [T] into a [Tuple6].
 func SequenceT6[T1, T2, T3, T4, T5, T6 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) T.Tuple6[T1, T2, T3, T4, T5, T6] {
-	return A.SequenceT6(
-		Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
-		Ap[func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T2],
-		Ap[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T3],
-		Ap[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T4],
-		Ap[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T5],
-		Ap[T.Tuple6[T1, T2, T3, T4, T5, T6], T6],
-		t1,
-		t2,
-		t3,
-		t4,
-		t5,
-		t6,
-	)
+  return A.SequenceT6(
+    Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
+    Ap[func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T2],
+    Ap[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T3],
+    Ap[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T4],
+    Ap[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T5],
+    Ap[T.Tuple6[T1, T2, T3, T4, T5, T6], T6],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+  )
 }
 
 // SequenceTuple6 converts a [Tuple6] of [T] into an [Tuple6].
 func SequenceTuple6[T1, T2, T3, T4, T5, T6 any](t T.Tuple6[T1, T2, T3, T4, T5, T6]) T.Tuple6[T1, T2, T3, T4, T5, T6] {
-	return A.SequenceTuple6(
-		Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
-		Ap[func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T2],
-		Ap[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T3],
-		Ap[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T4],
-		Ap[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T5],
-		Ap[T.Tuple6[T1, T2, T3, T4, T5, T6], T6],
-		t,
-	)
+  return A.SequenceTuple6(
+    Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
+    Ap[func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T2],
+    Ap[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T3],
+    Ap[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T4],
+    Ap[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T5],
+    Ap[T.Tuple6[T1, T2, T3, T4, T5, T6], T6],
+    t,
+  )
 }
 
 // TraverseTuple6 converts a [Tuple6] of [A] via transformation functions transforming [A] to [A] into a [Tuple6].
-func TraverseTuple6[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) func(T.Tuple6[A1, A2, A3, A4, A5, A6]) T.Tuple6[T1, T2, T3, T4, T5, T6] {
-	return func(t T.Tuple6[A1, A2, A3, A4, A5, A6]) T.Tuple6[T1, T2, T3, T4, T5, T6] {
-		return A.TraverseTuple6(
-			Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
-			Ap[func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T2],
-			Ap[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T3],
-			Ap[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T4],
-			Ap[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T5],
-			Ap[T.Tuple6[T1, T2, T3, T4, T5, T6], T6],
-			f1,
-			f2,
-			f3,
-			f4,
-			f5,
-			f6,
-			t,
-		)
-	}
+func TraverseTuple6[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) func (T.Tuple6[A1, A2, A3, A4, A5, A6]) T.Tuple6[T1, T2, T3, T4, T5, T6] {
+  return func(t T.Tuple6[A1, A2, A3, A4, A5, A6]) T.Tuple6[T1, T2, T3, T4, T5, T6] {
+    return A.TraverseTuple6(
+      Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
+      Ap[func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T2],
+      Ap[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T3],
+      Ap[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T4],
+      Ap[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T5],
+      Ap[T.Tuple6[T1, T2, T3, T4, T5, T6], T6],
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      t,
+    )
+  }
 }
 
 // SequenceT7 converts 7 parameters of [T] into a [Tuple7].
 func SequenceT7[T1, T2, T3, T4, T5, T6, T7 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7] {
-	return A.SequenceT7(
-		Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
-		Ap[func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T2],
-		Ap[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T3],
-		Ap[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T4],
-		Ap[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T5],
-		Ap[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T6],
-		Ap[T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T7],
-		t1,
-		t2,
-		t3,
-		t4,
-		t5,
-		t6,
-		t7,
-	)
+  return A.SequenceT7(
+    Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+    Ap[func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T2],
+    Ap[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T3],
+    Ap[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T4],
+    Ap[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T5],
+    Ap[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T6],
+    Ap[T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T7],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+  )
 }
 
 // SequenceTuple7 converts a [Tuple7] of [T] into an [Tuple7].
 func SequenceTuple7[T1, T2, T3, T4, T5, T6, T7 any](t T.Tuple7[T1, T2, T3, T4, T5, T6, T7]) T.Tuple7[T1, T2, T3, T4, T5, T6, T7] {
-	return A.SequenceTuple7(
-		Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
-		Ap[func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T2],
-		Ap[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T3],
-		Ap[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T4],
-		Ap[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T5],
-		Ap[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T6],
-		Ap[T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T7],
-		t,
-	)
+  return A.SequenceTuple7(
+    Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+    Ap[func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T2],
+    Ap[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T3],
+    Ap[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T4],
+    Ap[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T5],
+    Ap[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T6],
+    Ap[T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T7],
+    t,
+  )
 }
 
 // TraverseTuple7 converts a [Tuple7] of [A] via transformation functions transforming [A] to [A] into a [Tuple7].
-func TraverseTuple7[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, F7 ~func(A7) T7, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) func(T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) T.Tuple7[T1, T2, T3, T4, T5, T6, T7] {
-	return func(t T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) T.Tuple7[T1, T2, T3, T4, T5, T6, T7] {
-		return A.TraverseTuple7(
-			Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
-			Ap[func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T2],
-			Ap[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T3],
-			Ap[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T4],
-			Ap[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T5],
-			Ap[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T6],
-			Ap[T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T7],
-			f1,
-			f2,
-			f3,
-			f4,
-			f5,
-			f6,
-			f7,
-			t,
-		)
-	}
+func TraverseTuple7[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, F7 ~func(A7) T7, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) func (T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) T.Tuple7[T1, T2, T3, T4, T5, T6, T7] {
+  return func(t T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) T.Tuple7[T1, T2, T3, T4, T5, T6, T7] {
+    return A.TraverseTuple7(
+      Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+      Ap[func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T2],
+      Ap[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T3],
+      Ap[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T4],
+      Ap[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T5],
+      Ap[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T6],
+      Ap[T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T7],
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      t,
+    )
+  }
 }
 
 // SequenceT8 converts 8 parameters of [T] into a [Tuple8].
 func SequenceT8[T1, T2, T3, T4, T5, T6, T7, T8 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
-	return A.SequenceT8(
-		Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
-		Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T2],
-		Ap[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T3],
-		Ap[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T4],
-		Ap[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T5],
-		Ap[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T6],
-		Ap[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T7],
-		Ap[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T8],
-		t1,
-		t2,
-		t3,
-		t4,
-		t5,
-		t6,
-		t7,
-		t8,
-	)
+  return A.SequenceT8(
+    Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+    Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T2],
+    Ap[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T3],
+    Ap[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T4],
+    Ap[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T5],
+    Ap[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T6],
+    Ap[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T7],
+    Ap[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T8],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+    t8,
+  )
 }
 
 // SequenceTuple8 converts a [Tuple8] of [T] into an [Tuple8].
 func SequenceTuple8[T1, T2, T3, T4, T5, T6, T7, T8 any](t T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
-	return A.SequenceTuple8(
-		Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
-		Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T2],
-		Ap[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T3],
-		Ap[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T4],
-		Ap[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T5],
-		Ap[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T6],
-		Ap[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T7],
-		Ap[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T8],
-		t,
-	)
+  return A.SequenceTuple8(
+    Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+    Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T2],
+    Ap[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T3],
+    Ap[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T4],
+    Ap[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T5],
+    Ap[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T6],
+    Ap[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T7],
+    Ap[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T8],
+    t,
+  )
 }
 
 // TraverseTuple8 converts a [Tuple8] of [A] via transformation functions transforming [A] to [A] into a [Tuple8].
-func TraverseTuple8[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, F7 ~func(A7) T7, F8 ~func(A8) T8, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) func(T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
-	return func(t T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
-		return A.TraverseTuple8(
-			Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
-			Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T2],
-			Ap[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T3],
-			Ap[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T4],
-			Ap[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T5],
-			Ap[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T6],
-			Ap[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T7],
-			Ap[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T8],
-			f1,
-			f2,
-			f3,
-			f4,
-			f5,
-			f6,
-			f7,
-			f8,
-			t,
-		)
-	}
+func TraverseTuple8[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, F7 ~func(A7) T7, F8 ~func(A8) T8, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) func (T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
+  return func(t T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
+    return A.TraverseTuple8(
+      Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+      Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T2],
+      Ap[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T3],
+      Ap[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T4],
+      Ap[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T5],
+      Ap[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T6],
+      Ap[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T7],
+      Ap[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T8],
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      t,
+    )
+  }
 }
 
 // SequenceT9 converts 9 parameters of [T] into a [Tuple9].
 func SequenceT9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
-	return A.SequenceT9(
-		Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
-		Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T2],
-		Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T3],
-		Ap[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T4],
-		Ap[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T5],
-		Ap[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T6],
-		Ap[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T7],
-		Ap[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T8],
-		Ap[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T9],
-		t1,
-		t2,
-		t3,
-		t4,
-		t5,
-		t6,
-		t7,
-		t8,
-		t9,
-	)
+  return A.SequenceT9(
+    Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+    Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T2],
+    Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T3],
+    Ap[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T4],
+    Ap[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T5],
+    Ap[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T6],
+    Ap[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T7],
+    Ap[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T8],
+    Ap[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T9],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+    t8,
+    t9,
+  )
 }
 
 // SequenceTuple9 converts a [Tuple9] of [T] into an [Tuple9].
 func SequenceTuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
-	return A.SequenceTuple9(
-		Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
-		Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T2],
-		Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T3],
-		Ap[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T4],
-		Ap[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T5],
-		Ap[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T6],
-		Ap[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T7],
-		Ap[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T8],
-		Ap[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T9],
-		t,
-	)
+  return A.SequenceTuple9(
+    Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+    Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T2],
+    Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T3],
+    Ap[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T4],
+    Ap[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T5],
+    Ap[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T6],
+    Ap[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T7],
+    Ap[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T8],
+    Ap[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T9],
+    t,
+  )
 }
 
 // TraverseTuple9 converts a [Tuple9] of [A] via transformation functions transforming [A] to [A] into a [Tuple9].
-func TraverseTuple9[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, F7 ~func(A7) T7, F8 ~func(A8) T8, F9 ~func(A9) T9, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) func(T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
-	return func(t T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
-		return A.TraverseTuple9(
-			Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
-			Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T2],
-			Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T3],
-			Ap[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T4],
-			Ap[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T5],
-			Ap[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T6],
-			Ap[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T7],
-			Ap[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T8],
-			Ap[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T9],
-			f1,
-			f2,
-			f3,
-			f4,
-			f5,
-			f6,
-			f7,
-			f8,
-			f9,
-			t,
-		)
-	}
+func TraverseTuple9[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, F7 ~func(A7) T7, F8 ~func(A8) T8, F9 ~func(A9) T9, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) func (T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
+  return func(t T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
+    return A.TraverseTuple9(
+      Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+      Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T2],
+      Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T3],
+      Ap[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T4],
+      Ap[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T5],
+      Ap[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T6],
+      Ap[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T7],
+      Ap[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T8],
+      Ap[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T9],
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      t,
+    )
+  }
 }
 
 // SequenceT10 converts 10 parameters of [T] into a [Tuple10].
 func SequenceT10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
-	return A.SequenceT10(
-		Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
-		Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T2],
-		Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T3],
-		Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T4],
-		Ap[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T5],
-		Ap[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T6],
-		Ap[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T7],
-		Ap[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T8],
-		Ap[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T9],
-		Ap[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T10],
-		t1,
-		t2,
-		t3,
-		t4,
-		t5,
-		t6,
-		t7,
-		t8,
-		t9,
-		t10,
-	)
+  return A.SequenceT10(
+    Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+    Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T2],
+    Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T3],
+    Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T4],
+    Ap[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T5],
+    Ap[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T6],
+    Ap[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T7],
+    Ap[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T8],
+    Ap[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T9],
+    Ap[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T10],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+    t8,
+    t9,
+    t10,
+  )
 }
 
 // SequenceTuple10 converts a [Tuple10] of [T] into an [Tuple10].
 func SequenceTuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
-	return A.SequenceTuple10(
-		Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
-		Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T2],
-		Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T3],
-		Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T4],
-		Ap[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T5],
-		Ap[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T6],
-		Ap[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T7],
-		Ap[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T8],
-		Ap[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T9],
-		Ap[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T10],
-		t,
-	)
+  return A.SequenceTuple10(
+    Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+    Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T2],
+    Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T3],
+    Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T4],
+    Ap[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T5],
+    Ap[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T6],
+    Ap[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T7],
+    Ap[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T8],
+    Ap[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T9],
+    Ap[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T10],
+    t,
+  )
 }
 
 // TraverseTuple10 converts a [Tuple10] of [A] via transformation functions transforming [A] to [A] into a [Tuple10].
-func TraverseTuple10[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, F7 ~func(A7) T7, F8 ~func(A8) T8, F9 ~func(A9) T9, F10 ~func(A10) T10, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) func(T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
-	return func(t T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
-		return A.TraverseTuple10(
-			Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
-			Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T2],
-			Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T3],
-			Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T4],
-			Ap[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T5],
-			Ap[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T6],
-			Ap[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T7],
-			Ap[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T8],
-			Ap[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T9],
-			Ap[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T10],
-			f1,
-			f2,
-			f3,
-			f4,
-			f5,
-			f6,
-			f7,
-			f8,
-			f9,
-			f10,
-			t,
-		)
-	}
+func TraverseTuple10[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, F7 ~func(A7) T7, F8 ~func(A8) T8, F9 ~func(A9) T9, F10 ~func(A10) T10, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) func (T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
+  return func(t T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
+    return A.TraverseTuple10(
+      Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+      Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T2],
+      Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T3],
+      Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T4],
+      Ap[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T5],
+      Ap[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T6],
+      Ap[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T7],
+      Ap[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T8],
+      Ap[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T9],
+      Ap[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T10],
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      t,
+    )
+  }
 }

internal/array/traverse.go

@@ -37,6 +37,24 @@ func MonadTraverse[GA ~[]A, GB ~[]B, A, B, HKTB, HKTAB, HKTRB any](
 	return MonadTraverseReduce(fof, fmap, fap, ta, f, Append[GB, B], Empty[GB]())
 }
 
+/*
+*
+We need to pass the members of the applicative explicitly, because golang does neither support higher kinded types nor template methods on structs or interfaces
+
+HKTRB = HKT<GB>
+HKTB = HKT<B>
+HKTAB = HKT<func(A)B>
+*/
+func MonadTraverseWithIndex[GA ~[]A, GB ~[]B, A, B, HKTB, HKTAB, HKTRB any](
+	fof func(GB) HKTRB,
+	fmap func(func(GB) func(B) GB) func(HKTRB) HKTAB,
+	fap func(HKTB) func(HKTAB) HKTRB,
+
+	ta GA,
+	f func(int, A) HKTB) HKTRB {
+	return MonadTraverseReduceWithIndex(fof, fmap, fap, ta, f, Append[GB, B], Empty[GB]())
+}
+
 func Traverse[GA ~[]A, GB ~[]B, A, B, HKTB, HKTAB, HKTRB any](
 	fof func(GB) HKTRB,
 	fmap func(func(GB) func(B) GB) func(HKTRB) HKTAB,
@@ -49,6 +67,18 @@ func Traverse[GA ~[]A, GB ~[]B, A, B, HKTB, HKTAB, HKTRB any](
 	}
 }
 
+func TraverseWithIndex[GA ~[]A, GB ~[]B, A, B, HKTB, HKTAB, HKTRB any](
+	fof func(GB) HKTRB,
+	fmap func(func(GB) func(B) GB) func(HKTRB) HKTAB,
+	fap func(HKTB) func(HKTAB) HKTRB,
+
+	f func(int, A) HKTB) func(GA) HKTRB {
+
+	return func(ma GA) HKTRB {
+		return MonadTraverseWithIndex(fof, fmap, fap, ma, f)
+	}
+}
+
 func MonadTraverseReduce[GA ~[]A, GB, A, B, HKTB, HKTAB, HKTRB any](
 	fof func(GB) HKTRB,
 	fmap func(func(GB) func(B) GB) func(HKTRB) HKTAB,
@@ -71,6 +101,28 @@ func MonadTraverseReduce[GA ~[]A, GB, A, B, HKTB, HKTAB, HKTRB any](
 	}, fof(initial))
 }
 
+func MonadTraverseReduceWithIndex[GA ~[]A, GB, A, B, HKTB, HKTAB, HKTRB any](
+	fof func(GB) HKTRB,
+	fmap func(func(GB) func(B) GB) func(HKTRB) HKTAB,
+	fap func(HKTB) func(HKTAB) HKTRB,
+
+	ta GA,
+
+	transform func(int, A) HKTB,
+	reduce func(GB, B) GB,
+	initial GB,
+) HKTRB {
+	mmap := fmap(F.Curry2(reduce))
+
+	return ReduceWithIndex(ta, func(idx int, r HKTRB, a A) HKTRB {
+		return F.Pipe2(
+			r,
+			mmap,
+			fap(transform(idx, a)),
+		)
+	}, fof(initial))
+}
+
 func TraverseReduce[GA ~[]A, GB, A, B, HKTB, HKTAB, HKTRB any](
 	fof func(GB) HKTRB,
 	fmap func(func(GB) func(B) GB) func(HKTRB) HKTAB,
@@ -84,3 +136,17 @@ func TraverseReduce[GA ~[]A, GB, A, B, HKTB, HKTAB, HKTRB any](
 		return MonadTraverseReduce(fof, fmap, fap, ta, transform, reduce, initial)
 	}
 }
+
+func TraverseReduceWithIndex[GA ~[]A, GB, A, B, HKTB, HKTAB, HKTRB any](
+	fof func(GB) HKTRB,
+	fmap func(func(GB) func(B) GB) func(HKTRB) HKTAB,
+	fap func(HKTB) func(HKTAB) HKTRB,
+
+	transform func(int, A) HKTB,
+	reduce func(GB, B) GB,
+	initial GB,
+) func(GA) HKTRB {
+	return func(ta GA) HKTRB {
+		return MonadTraverseReduceWithIndex(fof, fmap, fap, ta, transform, reduce, initial)
+	}
+}

io/gen.go

@@ -1,375 +1,376 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-08-17 22:59:10.1040409 +0200 CEST m=+0.089470201
+// 2023-09-12 13:44:27.9813739 +0200 CEST m=+0.011088001
 
 package io
 
+
 import (
-	G "github.com/IBM/fp-go/io/generic"
+	G "github.com/IBM/fp-go/io/generic"	
 	T "github.com/IBM/fp-go/tuple"
 )
 
 // SequenceT1 converts 1 [IO[T]] into a [IO[T.Tuple1[T1]]]
 func SequenceT1[T1 any](
-	t1 IO[T1],
+  t1 IO[T1],
 ) IO[T.Tuple1[T1]] {
-	return G.SequenceT1[
-		IO[T.Tuple1[T1]],
-		IO[T1],
-	](t1)
+  return G.SequenceT1[
+    IO[T.Tuple1[T1]],
+    IO[T1],
+  ](t1)
 }
 
 // SequenceTuple1 converts a [T.Tuple1[IO[T]]] into a [IO[T.Tuple1[T1]]]
 func SequenceTuple1[T1 any](t T.Tuple1[IO[T1]]) IO[T.Tuple1[T1]] {
-	return G.SequenceTuple1[
-		IO[T.Tuple1[T1]],
-		IO[T1],
-	](t)
+  return G.SequenceTuple1[
+    IO[T.Tuple1[T1]],
+    IO[T1],
+  ](t)
 }
 
 // TraverseTuple1 converts a [T.Tuple1[IO[T]]] into a [IO[T.Tuple1[T1]]]
 func TraverseTuple1[F1 ~func(A1) IO[T1], A1, T1 any](f1 F1) func(T.Tuple1[A1]) IO[T.Tuple1[T1]] {
-	return G.TraverseTuple1[IO[T.Tuple1[T1]]](f1)
+  return G.TraverseTuple1[IO[T.Tuple1[T1]]](f1)
 }
 
 // SequenceT2 converts 2 [IO[T]] into a [IO[T.Tuple2[T1, T2]]]
 func SequenceT2[T1, T2 any](
-	t1 IO[T1],
-	t2 IO[T2],
+  t1 IO[T1],
+  t2 IO[T2],
 ) IO[T.Tuple2[T1, T2]] {
-	return G.SequenceT2[
-		IO[T.Tuple2[T1, T2]],
-		IO[T1],
-		IO[T2],
-	](t1, t2)
+  return G.SequenceT2[
+    IO[T.Tuple2[T1, T2]],
+    IO[T1],
+    IO[T2],
+  ](t1, t2)
 }
 
 // SequenceTuple2 converts a [T.Tuple2[IO[T]]] into a [IO[T.Tuple2[T1, T2]]]
 func SequenceTuple2[T1, T2 any](t T.Tuple2[IO[T1], IO[T2]]) IO[T.Tuple2[T1, T2]] {
-	return G.SequenceTuple2[
-		IO[T.Tuple2[T1, T2]],
-		IO[T1],
-		IO[T2],
-	](t)
+  return G.SequenceTuple2[
+    IO[T.Tuple2[T1, T2]],
+    IO[T1],
+    IO[T2],
+  ](t)
 }
 
 // TraverseTuple2 converts a [T.Tuple2[IO[T]]] into a [IO[T.Tuple2[T1, T2]]]
 func TraverseTuple2[F1 ~func(A1) IO[T1], F2 ~func(A2) IO[T2], A1, A2, T1, T2 any](f1 F1, f2 F2) func(T.Tuple2[A1, A2]) IO[T.Tuple2[T1, T2]] {
-	return G.TraverseTuple2[IO[T.Tuple2[T1, T2]]](f1, f2)
+  return G.TraverseTuple2[IO[T.Tuple2[T1, T2]]](f1, f2)
 }
 
 // SequenceT3 converts 3 [IO[T]] into a [IO[T.Tuple3[T1, T2, T3]]]
 func SequenceT3[T1, T2, T3 any](
-	t1 IO[T1],
-	t2 IO[T2],
-	t3 IO[T3],
+  t1 IO[T1],
+  t2 IO[T2],
+  t3 IO[T3],
 ) IO[T.Tuple3[T1, T2, T3]] {
-	return G.SequenceT3[
-		IO[T.Tuple3[T1, T2, T3]],
-		IO[T1],
-		IO[T2],
-		IO[T3],
-	](t1, t2, t3)
+  return G.SequenceT3[
+    IO[T.Tuple3[T1, T2, T3]],
+    IO[T1],
+    IO[T2],
+    IO[T3],
+  ](t1, t2, t3)
 }
 
 // SequenceTuple3 converts a [T.Tuple3[IO[T]]] into a [IO[T.Tuple3[T1, T2, T3]]]
 func SequenceTuple3[T1, T2, T3 any](t T.Tuple3[IO[T1], IO[T2], IO[T3]]) IO[T.Tuple3[T1, T2, T3]] {
-	return G.SequenceTuple3[
-		IO[T.Tuple3[T1, T2, T3]],
-		IO[T1],
-		IO[T2],
-		IO[T3],
-	](t)
+  return G.SequenceTuple3[
+    IO[T.Tuple3[T1, T2, T3]],
+    IO[T1],
+    IO[T2],
+    IO[T3],
+  ](t)
 }
 
 // TraverseTuple3 converts a [T.Tuple3[IO[T]]] into a [IO[T.Tuple3[T1, T2, T3]]]
 func TraverseTuple3[F1 ~func(A1) IO[T1], F2 ~func(A2) IO[T2], F3 ~func(A3) IO[T3], A1, A2, A3, T1, T2, T3 any](f1 F1, f2 F2, f3 F3) func(T.Tuple3[A1, A2, A3]) IO[T.Tuple3[T1, T2, T3]] {
-	return G.TraverseTuple3[IO[T.Tuple3[T1, T2, T3]]](f1, f2, f3)
+  return G.TraverseTuple3[IO[T.Tuple3[T1, T2, T3]]](f1, f2, f3)
 }
 
 // SequenceT4 converts 4 [IO[T]] into a [IO[T.Tuple4[T1, T2, T3, T4]]]
 func SequenceT4[T1, T2, T3, T4 any](
-	t1 IO[T1],
-	t2 IO[T2],
-	t3 IO[T3],
-	t4 IO[T4],
+  t1 IO[T1],
+  t2 IO[T2],
+  t3 IO[T3],
+  t4 IO[T4],
 ) IO[T.Tuple4[T1, T2, T3, T4]] {
-	return G.SequenceT4[
-		IO[T.Tuple4[T1, T2, T3, T4]],
-		IO[T1],
-		IO[T2],
-		IO[T3],
-		IO[T4],
-	](t1, t2, t3, t4)
+  return G.SequenceT4[
+    IO[T.Tuple4[T1, T2, T3, T4]],
+    IO[T1],
+    IO[T2],
+    IO[T3],
+    IO[T4],
+  ](t1, t2, t3, t4)
 }
 
 // SequenceTuple4 converts a [T.Tuple4[IO[T]]] into a [IO[T.Tuple4[T1, T2, T3, T4]]]
 func SequenceTuple4[T1, T2, T3, T4 any](t T.Tuple4[IO[T1], IO[T2], IO[T3], IO[T4]]) IO[T.Tuple4[T1, T2, T3, T4]] {
-	return G.SequenceTuple4[
-		IO[T.Tuple4[T1, T2, T3, T4]],
-		IO[T1],
-		IO[T2],
-		IO[T3],
-		IO[T4],
-	](t)
+  return G.SequenceTuple4[
+    IO[T.Tuple4[T1, T2, T3, T4]],
+    IO[T1],
+    IO[T2],
+    IO[T3],
+    IO[T4],
+  ](t)
 }
 
 // TraverseTuple4 converts a [T.Tuple4[IO[T]]] into a [IO[T.Tuple4[T1, T2, T3, T4]]]
 func TraverseTuple4[F1 ~func(A1) IO[T1], F2 ~func(A2) IO[T2], F3 ~func(A3) IO[T3], F4 ~func(A4) IO[T4], A1, A2, A3, A4, T1, T2, T3, T4 any](f1 F1, f2 F2, f3 F3, f4 F4) func(T.Tuple4[A1, A2, A3, A4]) IO[T.Tuple4[T1, T2, T3, T4]] {
-	return G.TraverseTuple4[IO[T.Tuple4[T1, T2, T3, T4]]](f1, f2, f3, f4)
+  return G.TraverseTuple4[IO[T.Tuple4[T1, T2, T3, T4]]](f1, f2, f3, f4)
 }
 
 // SequenceT5 converts 5 [IO[T]] into a [IO[T.Tuple5[T1, T2, T3, T4, T5]]]
 func SequenceT5[T1, T2, T3, T4, T5 any](
-	t1 IO[T1],
-	t2 IO[T2],
-	t3 IO[T3],
-	t4 IO[T4],
-	t5 IO[T5],
+  t1 IO[T1],
+  t2 IO[T2],
+  t3 IO[T3],
+  t4 IO[T4],
+  t5 IO[T5],
 ) IO[T.Tuple5[T1, T2, T3, T4, T5]] {
-	return G.SequenceT5[
-		IO[T.Tuple5[T1, T2, T3, T4, T5]],
-		IO[T1],
-		IO[T2],
-		IO[T3],
-		IO[T4],
-		IO[T5],
-	](t1, t2, t3, t4, t5)
+  return G.SequenceT5[
+    IO[T.Tuple5[T1, T2, T3, T4, T5]],
+    IO[T1],
+    IO[T2],
+    IO[T3],
+    IO[T4],
+    IO[T5],
+  ](t1, t2, t3, t4, t5)
 }
 
 // SequenceTuple5 converts a [T.Tuple5[IO[T]]] into a [IO[T.Tuple5[T1, T2, T3, T4, T5]]]
 func SequenceTuple5[T1, T2, T3, T4, T5 any](t T.Tuple5[IO[T1], IO[T2], IO[T3], IO[T4], IO[T5]]) IO[T.Tuple5[T1, T2, T3, T4, T5]] {
-	return G.SequenceTuple5[
-		IO[T.Tuple5[T1, T2, T3, T4, T5]],
-		IO[T1],
-		IO[T2],
-		IO[T3],
-		IO[T4],
-		IO[T5],
-	](t)
+  return G.SequenceTuple5[
+    IO[T.Tuple5[T1, T2, T3, T4, T5]],
+    IO[T1],
+    IO[T2],
+    IO[T3],
+    IO[T4],
+    IO[T5],
+  ](t)
 }
 
 // TraverseTuple5 converts a [T.Tuple5[IO[T]]] into a [IO[T.Tuple5[T1, T2, T3, T4, T5]]]
 func TraverseTuple5[F1 ~func(A1) IO[T1], F2 ~func(A2) IO[T2], F3 ~func(A3) IO[T3], F4 ~func(A4) IO[T4], F5 ~func(A5) IO[T5], A1, A2, A3, A4, A5, T1, T2, T3, T4, T5 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) func(T.Tuple5[A1, A2, A3, A4, A5]) IO[T.Tuple5[T1, T2, T3, T4, T5]] {
-	return G.TraverseTuple5[IO[T.Tuple5[T1, T2, T3, T4, T5]]](f1, f2, f3, f4, f5)
+  return G.TraverseTuple5[IO[T.Tuple5[T1, T2, T3, T4, T5]]](f1, f2, f3, f4, f5)
 }
 
 // SequenceT6 converts 6 [IO[T]] into a [IO[T.Tuple6[T1, T2, T3, T4, T5, T6]]]
 func SequenceT6[T1, T2, T3, T4, T5, T6 any](
-	t1 IO[T1],
-	t2 IO[T2],
-	t3 IO[T3],
-	t4 IO[T4],
-	t5 IO[T5],
-	t6 IO[T6],
+  t1 IO[T1],
+  t2 IO[T2],
+  t3 IO[T3],
+  t4 IO[T4],
+  t5 IO[T5],
+  t6 IO[T6],
 ) IO[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-	return G.SequenceT6[
-		IO[T.Tuple6[T1, T2, T3, T4, T5, T6]],
-		IO[T1],
-		IO[T2],
-		IO[T3],
-		IO[T4],
-		IO[T5],
-		IO[T6],
-	](t1, t2, t3, t4, t5, t6)
+  return G.SequenceT6[
+    IO[T.Tuple6[T1, T2, T3, T4, T5, T6]],
+    IO[T1],
+    IO[T2],
+    IO[T3],
+    IO[T4],
+    IO[T5],
+    IO[T6],
+  ](t1, t2, t3, t4, t5, t6)
 }
 
 // SequenceTuple6 converts a [T.Tuple6[IO[T]]] into a [IO[T.Tuple6[T1, T2, T3, T4, T5, T6]]]
 func SequenceTuple6[T1, T2, T3, T4, T5, T6 any](t T.Tuple6[IO[T1], IO[T2], IO[T3], IO[T4], IO[T5], IO[T6]]) IO[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-	return G.SequenceTuple6[
-		IO[T.Tuple6[T1, T2, T3, T4, T5, T6]],
-		IO[T1],
-		IO[T2],
-		IO[T3],
-		IO[T4],
-		IO[T5],
-		IO[T6],
-	](t)
+  return G.SequenceTuple6[
+    IO[T.Tuple6[T1, T2, T3, T4, T5, T6]],
+    IO[T1],
+    IO[T2],
+    IO[T3],
+    IO[T4],
+    IO[T5],
+    IO[T6],
+  ](t)
 }
 
 // TraverseTuple6 converts a [T.Tuple6[IO[T]]] into a [IO[T.Tuple6[T1, T2, T3, T4, T5, T6]]]
 func TraverseTuple6[F1 ~func(A1) IO[T1], F2 ~func(A2) IO[T2], F3 ~func(A3) IO[T3], F4 ~func(A4) IO[T4], F5 ~func(A5) IO[T5], F6 ~func(A6) IO[T6], A1, A2, A3, A4, A5, A6, T1, T2, T3, T4, T5, T6 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) func(T.Tuple6[A1, A2, A3, A4, A5, A6]) IO[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-	return G.TraverseTuple6[IO[T.Tuple6[T1, T2, T3, T4, T5, T6]]](f1, f2, f3, f4, f5, f6)
+  return G.TraverseTuple6[IO[T.Tuple6[T1, T2, T3, T4, T5, T6]]](f1, f2, f3, f4, f5, f6)
 }
 
 // SequenceT7 converts 7 [IO[T]] into a [IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
 func SequenceT7[T1, T2, T3, T4, T5, T6, T7 any](
-	t1 IO[T1],
-	t2 IO[T2],
-	t3 IO[T3],
-	t4 IO[T4],
-	t5 IO[T5],
-	t6 IO[T6],
-	t7 IO[T7],
+  t1 IO[T1],
+  t2 IO[T2],
+  t3 IO[T3],
+  t4 IO[T4],
+  t5 IO[T5],
+  t6 IO[T6],
+  t7 IO[T7],
 ) IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-	return G.SequenceT7[
-		IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
-		IO[T1],
-		IO[T2],
-		IO[T3],
-		IO[T4],
-		IO[T5],
-		IO[T6],
-		IO[T7],
-	](t1, t2, t3, t4, t5, t6, t7)
+  return G.SequenceT7[
+    IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+    IO[T1],
+    IO[T2],
+    IO[T3],
+    IO[T4],
+    IO[T5],
+    IO[T6],
+    IO[T7],
+  ](t1, t2, t3, t4, t5, t6, t7)
 }
 
 // SequenceTuple7 converts a [T.Tuple7[IO[T]]] into a [IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
 func SequenceTuple7[T1, T2, T3, T4, T5, T6, T7 any](t T.Tuple7[IO[T1], IO[T2], IO[T3], IO[T4], IO[T5], IO[T6], IO[T7]]) IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-	return G.SequenceTuple7[
-		IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
-		IO[T1],
-		IO[T2],
-		IO[T3],
-		IO[T4],
-		IO[T5],
-		IO[T6],
-		IO[T7],
-	](t)
+  return G.SequenceTuple7[
+    IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+    IO[T1],
+    IO[T2],
+    IO[T3],
+    IO[T4],
+    IO[T5],
+    IO[T6],
+    IO[T7],
+  ](t)
 }
 
 // TraverseTuple7 converts a [T.Tuple7[IO[T]]] into a [IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
 func TraverseTuple7[F1 ~func(A1) IO[T1], F2 ~func(A2) IO[T2], F3 ~func(A3) IO[T3], F4 ~func(A4) IO[T4], F5 ~func(A5) IO[T5], F6 ~func(A6) IO[T6], F7 ~func(A7) IO[T7], A1, A2, A3, A4, A5, A6, A7, T1, T2, T3, T4, T5, T6, T7 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) func(T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-	return G.TraverseTuple7[IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](f1, f2, f3, f4, f5, f6, f7)
+  return G.TraverseTuple7[IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](f1, f2, f3, f4, f5, f6, f7)
 }
 
 // SequenceT8 converts 8 [IO[T]] into a [IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
 func SequenceT8[T1, T2, T3, T4, T5, T6, T7, T8 any](
-	t1 IO[T1],
-	t2 IO[T2],
-	t3 IO[T3],
-	t4 IO[T4],
-	t5 IO[T5],
-	t6 IO[T6],
-	t7 IO[T7],
-	t8 IO[T8],
+  t1 IO[T1],
+  t2 IO[T2],
+  t3 IO[T3],
+  t4 IO[T4],
+  t5 IO[T5],
+  t6 IO[T6],
+  t7 IO[T7],
+  t8 IO[T8],
 ) IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-	return G.SequenceT8[
-		IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
-		IO[T1],
-		IO[T2],
-		IO[T3],
-		IO[T4],
-		IO[T5],
-		IO[T6],
-		IO[T7],
-		IO[T8],
-	](t1, t2, t3, t4, t5, t6, t7, t8)
+  return G.SequenceT8[
+    IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+    IO[T1],
+    IO[T2],
+    IO[T3],
+    IO[T4],
+    IO[T5],
+    IO[T6],
+    IO[T7],
+    IO[T8],
+  ](t1, t2, t3, t4, t5, t6, t7, t8)
 }
 
 // SequenceTuple8 converts a [T.Tuple8[IO[T]]] into a [IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
 func SequenceTuple8[T1, T2, T3, T4, T5, T6, T7, T8 any](t T.Tuple8[IO[T1], IO[T2], IO[T3], IO[T4], IO[T5], IO[T6], IO[T7], IO[T8]]) IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-	return G.SequenceTuple8[
-		IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
-		IO[T1],
-		IO[T2],
-		IO[T3],
-		IO[T4],
-		IO[T5],
-		IO[T6],
-		IO[T7],
-		IO[T8],
-	](t)
+  return G.SequenceTuple8[
+    IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+    IO[T1],
+    IO[T2],
+    IO[T3],
+    IO[T4],
+    IO[T5],
+    IO[T6],
+    IO[T7],
+    IO[T8],
+  ](t)
 }
 
 // TraverseTuple8 converts a [T.Tuple8[IO[T]]] into a [IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
 func TraverseTuple8[F1 ~func(A1) IO[T1], F2 ~func(A2) IO[T2], F3 ~func(A3) IO[T3], F4 ~func(A4) IO[T4], F5 ~func(A5) IO[T5], F6 ~func(A6) IO[T6], F7 ~func(A7) IO[T7], F8 ~func(A8) IO[T8], A1, A2, A3, A4, A5, A6, A7, A8, T1, T2, T3, T4, T5, T6, T7, T8 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) func(T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-	return G.TraverseTuple8[IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](f1, f2, f3, f4, f5, f6, f7, f8)
+  return G.TraverseTuple8[IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](f1, f2, f3, f4, f5, f6, f7, f8)
 }
 
 // SequenceT9 converts 9 [IO[T]] into a [IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
 func SequenceT9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
-	t1 IO[T1],
-	t2 IO[T2],
-	t3 IO[T3],
-	t4 IO[T4],
-	t5 IO[T5],
-	t6 IO[T6],
-	t7 IO[T7],
-	t8 IO[T8],
-	t9 IO[T9],
+  t1 IO[T1],
+  t2 IO[T2],
+  t3 IO[T3],
+  t4 IO[T4],
+  t5 IO[T5],
+  t6 IO[T6],
+  t7 IO[T7],
+  t8 IO[T8],
+  t9 IO[T9],
 ) IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-	return G.SequenceT9[
-		IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
-		IO[T1],
-		IO[T2],
-		IO[T3],
-		IO[T4],
-		IO[T5],
-		IO[T6],
-		IO[T7],
-		IO[T8],
-		IO[T9],
-	](t1, t2, t3, t4, t5, t6, t7, t8, t9)
+  return G.SequenceT9[
+    IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+    IO[T1],
+    IO[T2],
+    IO[T3],
+    IO[T4],
+    IO[T5],
+    IO[T6],
+    IO[T7],
+    IO[T8],
+    IO[T9],
+  ](t1, t2, t3, t4, t5, t6, t7, t8, t9)
 }
 
 // SequenceTuple9 converts a [T.Tuple9[IO[T]]] into a [IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
 func SequenceTuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t T.Tuple9[IO[T1], IO[T2], IO[T3], IO[T4], IO[T5], IO[T6], IO[T7], IO[T8], IO[T9]]) IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-	return G.SequenceTuple9[
-		IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
-		IO[T1],
-		IO[T2],
-		IO[T3],
-		IO[T4],
-		IO[T5],
-		IO[T6],
-		IO[T7],
-		IO[T8],
-		IO[T9],
-	](t)
+  return G.SequenceTuple9[
+    IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+    IO[T1],
+    IO[T2],
+    IO[T3],
+    IO[T4],
+    IO[T5],
+    IO[T6],
+    IO[T7],
+    IO[T8],
+    IO[T9],
+  ](t)
 }
 
 // TraverseTuple9 converts a [T.Tuple9[IO[T]]] into a [IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
 func TraverseTuple9[F1 ~func(A1) IO[T1], F2 ~func(A2) IO[T2], F3 ~func(A3) IO[T3], F4 ~func(A4) IO[T4], F5 ~func(A5) IO[T5], F6 ~func(A6) IO[T6], F7 ~func(A7) IO[T7], F8 ~func(A8) IO[T8], F9 ~func(A9) IO[T9], A1, A2, A3, A4, A5, A6, A7, A8, A9, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) func(T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-	return G.TraverseTuple9[IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](f1, f2, f3, f4, f5, f6, f7, f8, f9)
+  return G.TraverseTuple9[IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](f1, f2, f3, f4, f5, f6, f7, f8, f9)
 }
 
 // SequenceT10 converts 10 [IO[T]] into a [IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
 func SequenceT10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](
-	t1 IO[T1],
-	t2 IO[T2],
-	t3 IO[T3],
-	t4 IO[T4],
-	t5 IO[T5],
-	t6 IO[T6],
-	t7 IO[T7],
-	t8 IO[T8],
-	t9 IO[T9],
-	t10 IO[T10],
+  t1 IO[T1],
+  t2 IO[T2],
+  t3 IO[T3],
+  t4 IO[T4],
+  t5 IO[T5],
+  t6 IO[T6],
+  t7 IO[T7],
+  t8 IO[T8],
+  t9 IO[T9],
+  t10 IO[T10],
 ) IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-	return G.SequenceT10[
-		IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
-		IO[T1],
-		IO[T2],
-		IO[T3],
-		IO[T4],
-		IO[T5],
-		IO[T6],
-		IO[T7],
-		IO[T8],
-		IO[T9],
-		IO[T10],
-	](t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
+  return G.SequenceT10[
+    IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+    IO[T1],
+    IO[T2],
+    IO[T3],
+    IO[T4],
+    IO[T5],
+    IO[T6],
+    IO[T7],
+    IO[T8],
+    IO[T9],
+    IO[T10],
+  ](t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
 }
 
 // SequenceTuple10 converts a [T.Tuple10[IO[T]]] into a [IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
 func SequenceTuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t T.Tuple10[IO[T1], IO[T2], IO[T3], IO[T4], IO[T5], IO[T6], IO[T7], IO[T8], IO[T9], IO[T10]]) IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-	return G.SequenceTuple10[
-		IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
-		IO[T1],
-		IO[T2],
-		IO[T3],
-		IO[T4],
-		IO[T5],
-		IO[T6],
-		IO[T7],
-		IO[T8],
-		IO[T9],
-		IO[T10],
-	](t)
+  return G.SequenceTuple10[
+    IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+    IO[T1],
+    IO[T2],
+    IO[T3],
+    IO[T4],
+    IO[T5],
+    IO[T6],
+    IO[T7],
+    IO[T8],
+    IO[T9],
+    IO[T10],
+  ](t)
 }
 
 // TraverseTuple10 converts a [T.Tuple10[IO[T]]] into a [IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
 func TraverseTuple10[F1 ~func(A1) IO[T1], F2 ~func(A2) IO[T2], F3 ~func(A3) IO[T3], F4 ~func(A4) IO[T4], F5 ~func(A5) IO[T5], F6 ~func(A6) IO[T6], F7 ~func(A7) IO[T7], F8 ~func(A8) IO[T8], F9 ~func(A9) IO[T9], F10 ~func(A10) IO[T10], A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) func(T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-	return G.TraverseTuple10[IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)
+  return G.TraverseTuple10[IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)
 }

io/generic/traverse.go

@@ -42,6 +42,16 @@ func TraverseArray[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B any](
 	)
 }
 
+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],
+		Map[GBS, func() func(B) BBS, BBS, func(B) BBS],
+		Ap[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])
 }
@@ -66,6 +76,16 @@ func TraverseRecord[GB ~func() B, GBS ~func() MB, MA ~map[K]A, MB ~map[K]B, K co
 	)
 }
 
+// TraverseRecordWithIndex transforms a record using an IO transform an IO of a record
+func TraverseRecordWithIndex[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],
+		Ap[GBS, func() func(B) MB, GB],
+		f,
+	)
+}
+
 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[GA, GAS](tas, F.Identity[GA])
 }

io/traverse.go

@@ -29,6 +29,12 @@ func TraverseArray[A, B any](f func(A) IO[B]) func([]A) IO[[]B] {
 	return G.TraverseArray[IO[B], IO[[]B], []A](f)
 }
 
+// TraverseArrayWithIndex applies a function returning an [IO] to all elements in an array and the
+// transforms this into an [IO] of that array
+func TraverseArrayWithIndex[A, B any](f func(int, A) IO[B]) func([]A) IO[[]B] {
+	return G.TraverseArrayWithIndex[IO[B], IO[[]B], []A](f)
+}
+
 // SequenceArray converts an array of [IO] to an [IO] of an array
 func SequenceArray[A any](tas []IO[A]) IO[[]A] {
 	return G.SequenceArray[IO[A], IO[[]A]](tas)
@@ -38,12 +44,18 @@ func MonadTraverseRecord[K comparable, A, B any](tas map[K]A, f func(A) IO[B]) I
 	return G.MonadTraverseRecord[IO[B], IO[map[K]B]](tas, f)
 }
 
-// TraverseArray applies a function returning an [IO] to all elements in a record and the
+// TraverseRecord applies a function returning an [IO] to all elements in a record and the
 // transforms this into an [IO] of that record
 func TraverseRecord[K comparable, A, B any](f func(A) IO[B]) func(map[K]A) IO[map[K]B] {
 	return G.TraverseRecord[IO[B], IO[map[K]B], map[K]A](f)
 }
 
+// TraverseRecordWithIndex applies a function returning an [IO] to all elements in a record and the
+// transforms this into an [IO] of that record
+func TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) IO[B]) func(map[K]A) IO[map[K]B] {
+	return G.TraverseRecordWithIndex[IO[B], IO[map[K]B], map[K]A](f)
+}
+
 // SequenceRecord converts a record of [IO] to an [IO] of a record
 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)

ioeither/gen.go

@@ -1,485 +1,486 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-08-17 22:59:12.0033119 +0200 CEST m=+0.096740401
+// 2023-09-12 13:44:29.4935658 +0200 CEST m=+0.015377401
 
 package ioeither
 
+
 import (
-	G "github.com/IBM/fp-go/ioeither/generic"
+	G "github.com/IBM/fp-go/ioeither/generic"	
 	T "github.com/IBM/fp-go/tuple"
 )
 
 // Eitherize0 converts a function with 1 parameters returning a tuple into a function with 0 parameters returning a [IOEither[error, R]]
 func Eitherize0[F ~func() (R, error), R any](f F) func() IOEither[error, R] {
-	return G.Eitherize0[IOEither[error, R]](f)
+  return G.Eitherize0[IOEither[error, R]](f)
 }
 
 // Uneitherize0 converts a function with 1 parameters returning a tuple into a function with 0 parameters returning a [IOEither[error, R]]
 func Uneitherize0[F ~func() IOEither[error, R], R any](f F) func() (R, error) {
-	return G.Uneitherize0[IOEither[error, R]](f)
+  return G.Uneitherize0[IOEither[error, R]](f)
 }
 
 // Eitherize1 converts a function with 2 parameters returning a tuple into a function with 1 parameters returning a [IOEither[error, R]]
 func Eitherize1[F ~func(T1) (R, error), T1, R any](f F) func(T1) IOEither[error, R] {
-	return G.Eitherize1[IOEither[error, R]](f)
+  return G.Eitherize1[IOEither[error, R]](f)
 }
 
 // Uneitherize1 converts a function with 2 parameters returning a tuple into a function with 1 parameters returning a [IOEither[error, R]]
 func Uneitherize1[F ~func(T1) IOEither[error, R], T1, R any](f F) func(T1) (R, error) {
-	return G.Uneitherize1[IOEither[error, R]](f)
+  return G.Uneitherize1[IOEither[error, R]](f)
 }
 
 // SequenceT1 converts 1 [IOEither[E, T]] into a [IOEither[E, T.Tuple1[T1]]]
 func SequenceT1[E, T1 any](
-	t1 IOEither[E, T1],
+  t1 IOEither[E, T1],
 ) IOEither[E, T.Tuple1[T1]] {
-	return G.SequenceT1[
-		IOEither[E, T.Tuple1[T1]],
-		IOEither[E, T1],
-	](t1)
+  return G.SequenceT1[
+    IOEither[E, T.Tuple1[T1]],
+    IOEither[E, T1],
+  ](t1)
 }
 
 // SequenceTuple1 converts a [T.Tuple1[IOEither[E, T]]] into a [IOEither[E, T.Tuple1[T1]]]
 func SequenceTuple1[E, T1 any](t T.Tuple1[IOEither[E, T1]]) IOEither[E, T.Tuple1[T1]] {
-	return G.SequenceTuple1[
-		IOEither[E, T.Tuple1[T1]],
-		IOEither[E, T1],
-	](t)
+  return G.SequenceTuple1[
+    IOEither[E, T.Tuple1[T1]],
+    IOEither[E, T1],
+  ](t)
 }
 
 // TraverseTuple1 converts a [T.Tuple1[IOEither[E, T]]] into a [IOEither[E, T.Tuple1[T1]]]
 func TraverseTuple1[F1 ~func(A1) IOEither[E, T1], E, A1, T1 any](f1 F1) func(T.Tuple1[A1]) IOEither[E, T.Tuple1[T1]] {
-	return G.TraverseTuple1[IOEither[E, T.Tuple1[T1]]](f1)
+  return G.TraverseTuple1[IOEither[E, T.Tuple1[T1]]](f1)
 }
 
 // Eitherize2 converts a function with 3 parameters returning a tuple into a function with 2 parameters returning a [IOEither[error, R]]
 func Eitherize2[F ~func(T1, T2) (R, error), T1, T2, R any](f F) func(T1, T2) IOEither[error, R] {
-	return G.Eitherize2[IOEither[error, R]](f)
+  return G.Eitherize2[IOEither[error, R]](f)
 }
 
 // Uneitherize2 converts a function with 3 parameters returning a tuple into a function with 2 parameters returning a [IOEither[error, R]]
 func Uneitherize2[F ~func(T1, T2) IOEither[error, R], T1, T2, R any](f F) func(T1, T2) (R, error) {
-	return G.Uneitherize2[IOEither[error, R]](f)
+  return G.Uneitherize2[IOEither[error, R]](f)
 }
 
 // SequenceT2 converts 2 [IOEither[E, T]] into a [IOEither[E, T.Tuple2[T1, T2]]]
 func SequenceT2[E, T1, T2 any](
-	t1 IOEither[E, T1],
-	t2 IOEither[E, T2],
+  t1 IOEither[E, T1],
+  t2 IOEither[E, T2],
 ) IOEither[E, T.Tuple2[T1, T2]] {
-	return G.SequenceT2[
-		IOEither[E, T.Tuple2[T1, T2]],
-		IOEither[E, T1],
-		IOEither[E, T2],
-	](t1, t2)
+  return G.SequenceT2[
+    IOEither[E, T.Tuple2[T1, T2]],
+    IOEither[E, T1],
+    IOEither[E, T2],
+  ](t1, t2)
 }
 
 // SequenceTuple2 converts a [T.Tuple2[IOEither[E, T]]] into a [IOEither[E, T.Tuple2[T1, T2]]]
 func SequenceTuple2[E, T1, T2 any](t T.Tuple2[IOEither[E, T1], IOEither[E, T2]]) IOEither[E, T.Tuple2[T1, T2]] {
-	return G.SequenceTuple2[
-		IOEither[E, T.Tuple2[T1, T2]],
-		IOEither[E, T1],
-		IOEither[E, T2],
-	](t)
+  return G.SequenceTuple2[
+    IOEither[E, T.Tuple2[T1, T2]],
+    IOEither[E, T1],
+    IOEither[E, T2],
+  ](t)
 }
 
 // TraverseTuple2 converts a [T.Tuple2[IOEither[E, T]]] into a [IOEither[E, T.Tuple2[T1, T2]]]
 func TraverseTuple2[F1 ~func(A1) IOEither[E, T1], F2 ~func(A2) IOEither[E, T2], E, A1, A2, T1, T2 any](f1 F1, f2 F2) func(T.Tuple2[A1, A2]) IOEither[E, T.Tuple2[T1, T2]] {
-	return G.TraverseTuple2[IOEither[E, T.Tuple2[T1, T2]]](f1, f2)
+  return G.TraverseTuple2[IOEither[E, T.Tuple2[T1, T2]]](f1, f2)
 }
 
 // Eitherize3 converts a function with 4 parameters returning a tuple into a function with 3 parameters returning a [IOEither[error, R]]
 func Eitherize3[F ~func(T1, T2, T3) (R, error), T1, T2, T3, R any](f F) func(T1, T2, T3) IOEither[error, R] {
-	return G.Eitherize3[IOEither[error, R]](f)
+  return G.Eitherize3[IOEither[error, R]](f)
 }
 
 // Uneitherize3 converts a function with 4 parameters returning a tuple into a function with 3 parameters returning a [IOEither[error, R]]
 func Uneitherize3[F ~func(T1, T2, T3) IOEither[error, R], T1, T2, T3, R any](f F) func(T1, T2, T3) (R, error) {
-	return G.Uneitherize3[IOEither[error, R]](f)
+  return G.Uneitherize3[IOEither[error, R]](f)
 }
 
 // SequenceT3 converts 3 [IOEither[E, T]] into a [IOEither[E, T.Tuple3[T1, T2, T3]]]
 func SequenceT3[E, T1, T2, T3 any](
-	t1 IOEither[E, T1],
-	t2 IOEither[E, T2],
-	t3 IOEither[E, T3],
+  t1 IOEither[E, T1],
+  t2 IOEither[E, T2],
+  t3 IOEither[E, T3],
 ) IOEither[E, T.Tuple3[T1, T2, T3]] {
-	return G.SequenceT3[
-		IOEither[E, T.Tuple3[T1, T2, T3]],
-		IOEither[E, T1],
-		IOEither[E, T2],
-		IOEither[E, T3],
-	](t1, t2, t3)
+  return G.SequenceT3[
+    IOEither[E, T.Tuple3[T1, T2, T3]],
+    IOEither[E, T1],
+    IOEither[E, T2],
+    IOEither[E, T3],
+  ](t1, t2, t3)
 }
 
 // SequenceTuple3 converts a [T.Tuple3[IOEither[E, T]]] into a [IOEither[E, T.Tuple3[T1, T2, T3]]]
 func SequenceTuple3[E, T1, T2, T3 any](t T.Tuple3[IOEither[E, T1], IOEither[E, T2], IOEither[E, T3]]) IOEither[E, T.Tuple3[T1, T2, T3]] {
-	return G.SequenceTuple3[
-		IOEither[E, T.Tuple3[T1, T2, T3]],
-		IOEither[E, T1],
-		IOEither[E, T2],
-		IOEither[E, T3],
-	](t)
+  return G.SequenceTuple3[
+    IOEither[E, T.Tuple3[T1, T2, T3]],
+    IOEither[E, T1],
+    IOEither[E, T2],
+    IOEither[E, T3],
+  ](t)
 }
 
 // TraverseTuple3 converts a [T.Tuple3[IOEither[E, T]]] into a [IOEither[E, T.Tuple3[T1, T2, T3]]]
 func TraverseTuple3[F1 ~func(A1) IOEither[E, T1], F2 ~func(A2) IOEither[E, T2], F3 ~func(A3) IOEither[E, T3], E, A1, A2, A3, T1, T2, T3 any](f1 F1, f2 F2, f3 F3) func(T.Tuple3[A1, A2, A3]) IOEither[E, T.Tuple3[T1, T2, T3]] {
-	return G.TraverseTuple3[IOEither[E, T.Tuple3[T1, T2, T3]]](f1, f2, f3)
+  return G.TraverseTuple3[IOEither[E, T.Tuple3[T1, T2, T3]]](f1, f2, f3)
 }
 
 // Eitherize4 converts a function with 5 parameters returning a tuple into a function with 4 parameters returning a [IOEither[error, R]]
 func Eitherize4[F ~func(T1, T2, T3, T4) (R, error), T1, T2, T3, T4, R any](f F) func(T1, T2, T3, T4) IOEither[error, R] {
-	return G.Eitherize4[IOEither[error, R]](f)
+  return G.Eitherize4[IOEither[error, R]](f)
 }
 
 // Uneitherize4 converts a function with 5 parameters returning a tuple into a function with 4 parameters returning a [IOEither[error, R]]
 func Uneitherize4[F ~func(T1, T2, T3, T4) IOEither[error, R], T1, T2, T3, T4, R any](f F) func(T1, T2, T3, T4) (R, error) {
-	return G.Uneitherize4[IOEither[error, R]](f)
+  return G.Uneitherize4[IOEither[error, R]](f)
 }
 
 // SequenceT4 converts 4 [IOEither[E, T]] into a [IOEither[E, T.Tuple4[T1, T2, T3, T4]]]
 func SequenceT4[E, T1, T2, T3, T4 any](
-	t1 IOEither[E, T1],
-	t2 IOEither[E, T2],
-	t3 IOEither[E, T3],
-	t4 IOEither[E, T4],
+  t1 IOEither[E, T1],
+  t2 IOEither[E, T2],
+  t3 IOEither[E, T3],
+  t4 IOEither[E, T4],
 ) IOEither[E, T.Tuple4[T1, T2, T3, T4]] {
-	return G.SequenceT4[
-		IOEither[E, T.Tuple4[T1, T2, T3, T4]],
-		IOEither[E, T1],
-		IOEither[E, T2],
-		IOEither[E, T3],
-		IOEither[E, T4],
-	](t1, t2, t3, t4)
+  return G.SequenceT4[
+    IOEither[E, T.Tuple4[T1, T2, T3, T4]],
+    IOEither[E, T1],
+    IOEither[E, T2],
+    IOEither[E, T3],
+    IOEither[E, T4],
+  ](t1, t2, t3, t4)
 }
 
 // SequenceTuple4 converts a [T.Tuple4[IOEither[E, T]]] into a [IOEither[E, T.Tuple4[T1, T2, T3, T4]]]
 func SequenceTuple4[E, T1, T2, T3, T4 any](t T.Tuple4[IOEither[E, T1], IOEither[E, T2], IOEither[E, T3], IOEither[E, T4]]) IOEither[E, T.Tuple4[T1, T2, T3, T4]] {
-	return G.SequenceTuple4[
-		IOEither[E, T.Tuple4[T1, T2, T3, T4]],
-		IOEither[E, T1],
-		IOEither[E, T2],
-		IOEither[E, T3],
-		IOEither[E, T4],
-	](t)
+  return G.SequenceTuple4[
+    IOEither[E, T.Tuple4[T1, T2, T3, T4]],
+    IOEither[E, T1],
+    IOEither[E, T2],
+    IOEither[E, T3],
+    IOEither[E, T4],
+  ](t)
 }
 
 // TraverseTuple4 converts a [T.Tuple4[IOEither[E, T]]] into a [IOEither[E, T.Tuple4[T1, T2, T3, T4]]]
 func TraverseTuple4[F1 ~func(A1) IOEither[E, T1], F2 ~func(A2) IOEither[E, T2], F3 ~func(A3) IOEither[E, T3], F4 ~func(A4) IOEither[E, T4], E, A1, A2, A3, A4, T1, T2, T3, T4 any](f1 F1, f2 F2, f3 F3, f4 F4) func(T.Tuple4[A1, A2, A3, A4]) IOEither[E, T.Tuple4[T1, T2, T3, T4]] {
-	return G.TraverseTuple4[IOEither[E, T.Tuple4[T1, T2, T3, T4]]](f1, f2, f3, f4)
+  return G.TraverseTuple4[IOEither[E, T.Tuple4[T1, T2, T3, T4]]](f1, f2, f3, f4)
 }
 
 // Eitherize5 converts a function with 6 parameters returning a tuple into a function with 5 parameters returning a [IOEither[error, R]]
 func Eitherize5[F ~func(T1, T2, T3, T4, T5) (R, error), T1, T2, T3, T4, T5, R any](f F) func(T1, T2, T3, T4, T5) IOEither[error, R] {
-	return G.Eitherize5[IOEither[error, R]](f)
+  return G.Eitherize5[IOEither[error, R]](f)
 }
 
 // Uneitherize5 converts a function with 6 parameters returning a tuple into a function with 5 parameters returning a [IOEither[error, R]]
 func Uneitherize5[F ~func(T1, T2, T3, T4, T5) IOEither[error, R], T1, T2, T3, T4, T5, R any](f F) func(T1, T2, T3, T4, T5) (R, error) {
-	return G.Uneitherize5[IOEither[error, R]](f)
+  return G.Uneitherize5[IOEither[error, R]](f)
 }
 
 // SequenceT5 converts 5 [IOEither[E, T]] into a [IOEither[E, T.Tuple5[T1, T2, T3, T4, T5]]]
 func SequenceT5[E, T1, T2, T3, T4, T5 any](
-	t1 IOEither[E, T1],
-	t2 IOEither[E, T2],
-	t3 IOEither[E, T3],
-	t4 IOEither[E, T4],
-	t5 IOEither[E, T5],
+  t1 IOEither[E, T1],
+  t2 IOEither[E, T2],
+  t3 IOEither[E, T3],
+  t4 IOEither[E, T4],
+  t5 IOEither[E, T5],
 ) IOEither[E, T.Tuple5[T1, T2, T3, T4, T5]] {
-	return G.SequenceT5[
-		IOEither[E, T.Tuple5[T1, T2, T3, T4, T5]],
-		IOEither[E, T1],
-		IOEither[E, T2],
-		IOEither[E, T3],
-		IOEither[E, T4],
-		IOEither[E, T5],
-	](t1, t2, t3, t4, t5)
+  return G.SequenceT5[
+    IOEither[E, T.Tuple5[T1, T2, T3, T4, T5]],
+    IOEither[E, T1],
+    IOEither[E, T2],
+    IOEither[E, T3],
+    IOEither[E, T4],
+    IOEither[E, T5],
+  ](t1, t2, t3, t4, t5)
 }
 
 // SequenceTuple5 converts a [T.Tuple5[IOEither[E, T]]] into a [IOEither[E, T.Tuple5[T1, T2, T3, T4, T5]]]
 func SequenceTuple5[E, T1, T2, T3, T4, T5 any](t T.Tuple5[IOEither[E, T1], IOEither[E, T2], IOEither[E, T3], IOEither[E, T4], IOEither[E, T5]]) IOEither[E, T.Tuple5[T1, T2, T3, T4, T5]] {
-	return G.SequenceTuple5[
-		IOEither[E, T.Tuple5[T1, T2, T3, T4, T5]],
-		IOEither[E, T1],
-		IOEither[E, T2],
-		IOEither[E, T3],
-		IOEither[E, T4],
-		IOEither[E, T5],
-	](t)
+  return G.SequenceTuple5[
+    IOEither[E, T.Tuple5[T1, T2, T3, T4, T5]],
+    IOEither[E, T1],
+    IOEither[E, T2],
+    IOEither[E, T3],
+    IOEither[E, T4],
+    IOEither[E, T5],
+  ](t)
 }
 
 // TraverseTuple5 converts a [T.Tuple5[IOEither[E, T]]] into a [IOEither[E, T.Tuple5[T1, T2, T3, T4, T5]]]
 func TraverseTuple5[F1 ~func(A1) IOEither[E, T1], F2 ~func(A2) IOEither[E, T2], F3 ~func(A3) IOEither[E, T3], F4 ~func(A4) IOEither[E, T4], F5 ~func(A5) IOEither[E, T5], E, A1, A2, A3, A4, A5, T1, T2, T3, T4, T5 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) func(T.Tuple5[A1, A2, A3, A4, A5]) IOEither[E, T.Tuple5[T1, T2, T3, T4, T5]] {
-	return G.TraverseTuple5[IOEither[E, T.Tuple5[T1, T2, T3, T4, T5]]](f1, f2, f3, f4, f5)
+  return G.TraverseTuple5[IOEither[E, T.Tuple5[T1, T2, T3, T4, T5]]](f1, f2, f3, f4, f5)
 }
 
 // Eitherize6 converts a function with 7 parameters returning a tuple into a function with 6 parameters returning a [IOEither[error, R]]
 func Eitherize6[F ~func(T1, T2, T3, T4, T5, T6) (R, error), T1, T2, T3, T4, T5, T6, R any](f F) func(T1, T2, T3, T4, T5, T6) IOEither[error, R] {
-	return G.Eitherize6[IOEither[error, R]](f)
+  return G.Eitherize6[IOEither[error, R]](f)
 }
 
 // Uneitherize6 converts a function with 7 parameters returning a tuple into a function with 6 parameters returning a [IOEither[error, R]]
 func Uneitherize6[F ~func(T1, T2, T3, T4, T5, T6) IOEither[error, R], T1, T2, T3, T4, T5, T6, R any](f F) func(T1, T2, T3, T4, T5, T6) (R, error) {
-	return G.Uneitherize6[IOEither[error, R]](f)
+  return G.Uneitherize6[IOEither[error, R]](f)
 }
 
 // SequenceT6 converts 6 [IOEither[E, T]] into a [IOEither[E, T.Tuple6[T1, T2, T3, T4, T5, T6]]]
 func SequenceT6[E, T1, T2, T3, T4, T5, T6 any](
-	t1 IOEither[E, T1],
-	t2 IOEither[E, T2],
-	t3 IOEither[E, T3],
-	t4 IOEither[E, T4],
-	t5 IOEither[E, T5],
-	t6 IOEither[E, T6],
+  t1 IOEither[E, T1],
+  t2 IOEither[E, T2],
+  t3 IOEither[E, T3],
+  t4 IOEither[E, T4],
+  t5 IOEither[E, T5],
+  t6 IOEither[E, T6],
 ) IOEither[E, T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-	return G.SequenceT6[
-		IOEither[E, T.Tuple6[T1, T2, T3, T4, T5, T6]],
-		IOEither[E, T1],
-		IOEither[E, T2],
-		IOEither[E, T3],
-		IOEither[E, T4],
-		IOEither[E, T5],
-		IOEither[E, T6],
-	](t1, t2, t3, t4, t5, t6)
+  return G.SequenceT6[
+    IOEither[E, T.Tuple6[T1, T2, T3, T4, T5, T6]],
+    IOEither[E, T1],
+    IOEither[E, T2],
+    IOEither[E, T3],
+    IOEither[E, T4],
+    IOEither[E, T5],
+    IOEither[E, T6],
+  ](t1, t2, t3, t4, t5, t6)
 }
 
 // SequenceTuple6 converts a [T.Tuple6[IOEither[E, T]]] into a [IOEither[E, T.Tuple6[T1, T2, T3, T4, T5, T6]]]
 func SequenceTuple6[E, T1, T2, T3, T4, T5, T6 any](t T.Tuple6[IOEither[E, T1], IOEither[E, T2], IOEither[E, T3], IOEither[E, T4], IOEither[E, T5], IOEither[E, T6]]) IOEither[E, T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-	return G.SequenceTuple6[
-		IOEither[E, T.Tuple6[T1, T2, T3, T4, T5, T6]],
-		IOEither[E, T1],
-		IOEither[E, T2],
-		IOEither[E, T3],
-		IOEither[E, T4],
-		IOEither[E, T5],
-		IOEither[E, T6],
-	](t)
+  return G.SequenceTuple6[
+    IOEither[E, T.Tuple6[T1, T2, T3, T4, T5, T6]],
+    IOEither[E, T1],
+    IOEither[E, T2],
+    IOEither[E, T3],
+    IOEither[E, T4],
+    IOEither[E, T5],
+    IOEither[E, T6],
+  ](t)
 }
 
 // TraverseTuple6 converts a [T.Tuple6[IOEither[E, T]]] into a [IOEither[E, T.Tuple6[T1, T2, T3, T4, T5, T6]]]
 func TraverseTuple6[F1 ~func(A1) IOEither[E, T1], F2 ~func(A2) IOEither[E, T2], F3 ~func(A3) IOEither[E, T3], F4 ~func(A4) IOEither[E, T4], F5 ~func(A5) IOEither[E, T5], F6 ~func(A6) IOEither[E, T6], E, A1, A2, A3, A4, A5, A6, T1, T2, T3, T4, T5, T6 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) func(T.Tuple6[A1, A2, A3, A4, A5, A6]) IOEither[E, T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-	return G.TraverseTuple6[IOEither[E, T.Tuple6[T1, T2, T3, T4, T5, T6]]](f1, f2, f3, f4, f5, f6)
+  return G.TraverseTuple6[IOEither[E, T.Tuple6[T1, T2, T3, T4, T5, T6]]](f1, f2, f3, f4, f5, f6)
 }
 
 // Eitherize7 converts a function with 8 parameters returning a tuple into a function with 7 parameters returning a [IOEither[error, R]]
 func Eitherize7[F ~func(T1, T2, T3, T4, T5, T6, T7) (R, error), T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T1, T2, T3, T4, T5, T6, T7) IOEither[error, R] {
-	return G.Eitherize7[IOEither[error, R]](f)
+  return G.Eitherize7[IOEither[error, R]](f)
 }
 
 // Uneitherize7 converts a function with 8 parameters returning a tuple into a function with 7 parameters returning a [IOEither[error, R]]
 func Uneitherize7[F ~func(T1, T2, T3, T4, T5, T6, T7) IOEither[error, R], T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T1, T2, T3, T4, T5, T6, T7) (R, error) {
-	return G.Uneitherize7[IOEither[error, R]](f)
+  return G.Uneitherize7[IOEither[error, R]](f)
 }
 
 // SequenceT7 converts 7 [IOEither[E, T]] into a [IOEither[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
 func SequenceT7[E, T1, T2, T3, T4, T5, T6, T7 any](
-	t1 IOEither[E, T1],
-	t2 IOEither[E, T2],
-	t3 IOEither[E, T3],
-	t4 IOEither[E, T4],
-	t5 IOEither[E, T5],
-	t6 IOEither[E, T6],
-	t7 IOEither[E, T7],
+  t1 IOEither[E, T1],
+  t2 IOEither[E, T2],
+  t3 IOEither[E, T3],
+  t4 IOEither[E, T4],
+  t5 IOEither[E, T5],
+  t6 IOEither[E, T6],
+  t7 IOEither[E, T7],
 ) IOEither[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-	return G.SequenceT7[
-		IOEither[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
-		IOEither[E, T1],
-		IOEither[E, T2],
-		IOEither[E, T3],
-		IOEither[E, T4],
-		IOEither[E, T5],
-		IOEither[E, T6],
-		IOEither[E, T7],
-	](t1, t2, t3, t4, t5, t6, t7)
+  return G.SequenceT7[
+    IOEither[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+    IOEither[E, T1],
+    IOEither[E, T2],
+    IOEither[E, T3],
+    IOEither[E, T4],
+    IOEither[E, T5],
+    IOEither[E, T6],
+    IOEither[E, T7],
+  ](t1, t2, t3, t4, t5, t6, t7)
 }
 
 // SequenceTuple7 converts a [T.Tuple7[IOEither[E, T]]] into a [IOEither[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
 func SequenceTuple7[E, T1, T2, T3, T4, T5, T6, T7 any](t T.Tuple7[IOEither[E, T1], IOEither[E, T2], IOEither[E, T3], IOEither[E, T4], IOEither[E, T5], IOEither[E, T6], IOEither[E, T7]]) IOEither[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-	return G.SequenceTuple7[
-		IOEither[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
-		IOEither[E, T1],
-		IOEither[E, T2],
-		IOEither[E, T3],
-		IOEither[E, T4],
-		IOEither[E, T5],
-		IOEither[E, T6],
-		IOEither[E, T7],
-	](t)
+  return G.SequenceTuple7[
+    IOEither[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+    IOEither[E, T1],
+    IOEither[E, T2],
+    IOEither[E, T3],
+    IOEither[E, T4],
+    IOEither[E, T5],
+    IOEither[E, T6],
+    IOEither[E, T7],
+  ](t)
 }
 
 // TraverseTuple7 converts a [T.Tuple7[IOEither[E, T]]] into a [IOEither[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
 func TraverseTuple7[F1 ~func(A1) IOEither[E, T1], F2 ~func(A2) IOEither[E, T2], F3 ~func(A3) IOEither[E, T3], F4 ~func(A4) IOEither[E, T4], F5 ~func(A5) IOEither[E, T5], F6 ~func(A6) IOEither[E, T6], F7 ~func(A7) IOEither[E, T7], E, A1, A2, A3, A4, A5, A6, A7, T1, T2, T3, T4, T5, T6, T7 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) func(T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) IOEither[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-	return G.TraverseTuple7[IOEither[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](f1, f2, f3, f4, f5, f6, f7)
+  return G.TraverseTuple7[IOEither[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](f1, f2, f3, f4, f5, f6, f7)
 }
 
 // Eitherize8 converts a function with 9 parameters returning a tuple into a function with 8 parameters returning a [IOEither[error, R]]
 func Eitherize8[F ~func(T1, T2, T3, T4, T5, T6, T7, T8) (R, error), T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8) IOEither[error, R] {
-	return G.Eitherize8[IOEither[error, R]](f)
+  return G.Eitherize8[IOEither[error, R]](f)
 }
 
 // Uneitherize8 converts a function with 9 parameters returning a tuple into a function with 8 parameters returning a [IOEither[error, R]]
 func Uneitherize8[F ~func(T1, T2, T3, T4, T5, T6, T7, T8) IOEither[error, R], T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8) (R, error) {
-	return G.Uneitherize8[IOEither[error, R]](f)
+  return G.Uneitherize8[IOEither[error, R]](f)
 }
 
 // SequenceT8 converts 8 [IOEither[E, T]] into a [IOEither[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
 func SequenceT8[E, T1, T2, T3, T4, T5, T6, T7, T8 any](
-	t1 IOEither[E, T1],
-	t2 IOEither[E, T2],
-	t3 IOEither[E, T3],
-	t4 IOEither[E, T4],
-	t5 IOEither[E, T5],
-	t6 IOEither[E, T6],
-	t7 IOEither[E, T7],
-	t8 IOEither[E, T8],
+  t1 IOEither[E, T1],
+  t2 IOEither[E, T2],
+  t3 IOEither[E, T3],
+  t4 IOEither[E, T4],
+  t5 IOEither[E, T5],
+  t6 IOEither[E, T6],
+  t7 IOEither[E, T7],
+  t8 IOEither[E, T8],
 ) IOEither[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-	return G.SequenceT8[
-		IOEither[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
-		IOEither[E, T1],
-		IOEither[E, T2],
-		IOEither[E, T3],
-		IOEither[E, T4],
-		IOEither[E, T5],
-		IOEither[E, T6],
-		IOEither[E, T7],
-		IOEither[E, T8],
-	](t1, t2, t3, t4, t5, t6, t7, t8)
+  return G.SequenceT8[
+    IOEither[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+    IOEither[E, T1],
+    IOEither[E, T2],
+    IOEither[E, T3],
+    IOEither[E, T4],
+    IOEither[E, T5],
+    IOEither[E, T6],
+    IOEither[E, T7],
+    IOEither[E, T8],
+  ](t1, t2, t3, t4, t5, t6, t7, t8)
 }
 
 // SequenceTuple8 converts a [T.Tuple8[IOEither[E, T]]] into a [IOEither[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
 func SequenceTuple8[E, T1, T2, T3, T4, T5, T6, T7, T8 any](t T.Tuple8[IOEither[E, T1], IOEither[E, T2], IOEither[E, T3], IOEither[E, T4], IOEither[E, T5], IOEither[E, T6], IOEither[E, T7], IOEither[E, T8]]) IOEither[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-	return G.SequenceTuple8[
-		IOEither[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
-		IOEither[E, T1],
-		IOEither[E, T2],
-		IOEither[E, T3],
-		IOEither[E, T4],
-		IOEither[E, T5],
-		IOEither[E, T6],
-		IOEither[E, T7],
-		IOEither[E, T8],
-	](t)
+  return G.SequenceTuple8[
+    IOEither[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+    IOEither[E, T1],
+    IOEither[E, T2],
+    IOEither[E, T3],
+    IOEither[E, T4],
+    IOEither[E, T5],
+    IOEither[E, T6],
+    IOEither[E, T7],
+    IOEither[E, T8],
+  ](t)
 }
 
 // TraverseTuple8 converts a [T.Tuple8[IOEither[E, T]]] into a [IOEither[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
 func TraverseTuple8[F1 ~func(A1) IOEither[E, T1], F2 ~func(A2) IOEither[E, T2], F3 ~func(A3) IOEither[E, T3], F4 ~func(A4) IOEither[E, T4], F5 ~func(A5) IOEither[E, T5], F6 ~func(A6) IOEither[E, T6], F7 ~func(A7) IOEither[E, T7], F8 ~func(A8) IOEither[E, T8], E, A1, A2, A3, A4, A5, A6, A7, A8, T1, T2, T3, T4, T5, T6, T7, T8 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) func(T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) IOEither[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-	return G.TraverseTuple8[IOEither[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](f1, f2, f3, f4, f5, f6, f7, f8)
+  return G.TraverseTuple8[IOEither[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](f1, f2, f3, f4, f5, f6, f7, f8)
 }
 
 // Eitherize9 converts a function with 10 parameters returning a tuple into a function with 9 parameters returning a [IOEither[error, R]]
 func Eitherize9[F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9) IOEither[error, R] {
-	return G.Eitherize9[IOEither[error, R]](f)
+  return G.Eitherize9[IOEither[error, R]](f)
 }
 
 // Uneitherize9 converts a function with 10 parameters returning a tuple into a function with 9 parameters returning a [IOEither[error, R]]
 func Uneitherize9[F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9) IOEither[error, R], T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error) {
-	return G.Uneitherize9[IOEither[error, R]](f)
+  return G.Uneitherize9[IOEither[error, R]](f)
 }
 
 // SequenceT9 converts 9 [IOEither[E, T]] into a [IOEither[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
 func SequenceT9[E, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
-	t1 IOEither[E, T1],
-	t2 IOEither[E, T2],
-	t3 IOEither[E, T3],
-	t4 IOEither[E, T4],
-	t5 IOEither[E, T5],
-	t6 IOEither[E, T6],
-	t7 IOEither[E, T7],
-	t8 IOEither[E, T8],
-	t9 IOEither[E, T9],
+  t1 IOEither[E, T1],
+  t2 IOEither[E, T2],
+  t3 IOEither[E, T3],
+  t4 IOEither[E, T4],
+  t5 IOEither[E, T5],
+  t6 IOEither[E, T6],
+  t7 IOEither[E, T7],
+  t8 IOEither[E, T8],
+  t9 IOEither[E, T9],
 ) IOEither[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-	return G.SequenceT9[
-		IOEither[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
-		IOEither[E, T1],
-		IOEither[E, T2],
-		IOEither[E, T3],
-		IOEither[E, T4],
-		IOEither[E, T5],
-		IOEither[E, T6],
-		IOEither[E, T7],
-		IOEither[E, T8],
-		IOEither[E, T9],
-	](t1, t2, t3, t4, t5, t6, t7, t8, t9)
+  return G.SequenceT9[
+    IOEither[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+    IOEither[E, T1],
+    IOEither[E, T2],
+    IOEither[E, T3],
+    IOEither[E, T4],
+    IOEither[E, T5],
+    IOEither[E, T6],
+    IOEither[E, T7],
+    IOEither[E, T8],
+    IOEither[E, T9],
+  ](t1, t2, t3, t4, t5, t6, t7, t8, t9)
 }
 
 // SequenceTuple9 converts a [T.Tuple9[IOEither[E, T]]] into a [IOEither[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
 func SequenceTuple9[E, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t T.Tuple9[IOEither[E, T1], IOEither[E, T2], IOEither[E, T3], IOEither[E, T4], IOEither[E, T5], IOEither[E, T6], IOEither[E, T7], IOEither[E, T8], IOEither[E, T9]]) IOEither[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-	return G.SequenceTuple9[
-		IOEither[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
-		IOEither[E, T1],
-		IOEither[E, T2],
-		IOEither[E, T3],
-		IOEither[E, T4],
-		IOEither[E, T5],
-		IOEither[E, T6],
-		IOEither[E, T7],
-		IOEither[E, T8],
-		IOEither[E, T9],
-	](t)
+  return G.SequenceTuple9[
+    IOEither[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+    IOEither[E, T1],
+    IOEither[E, T2],
+    IOEither[E, T3],
+    IOEither[E, T4],
+    IOEither[E, T5],
+    IOEither[E, T6],
+    IOEither[E, T7],
+    IOEither[E, T8],
+    IOEither[E, T9],
+  ](t)
 }
 
 // TraverseTuple9 converts a [T.Tuple9[IOEither[E, T]]] into a [IOEither[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
 func TraverseTuple9[F1 ~func(A1) IOEither[E, T1], F2 ~func(A2) IOEither[E, T2], F3 ~func(A3) IOEither[E, T3], F4 ~func(A4) IOEither[E, T4], F5 ~func(A5) IOEither[E, T5], F6 ~func(A6) IOEither[E, T6], F7 ~func(A7) IOEither[E, T7], F8 ~func(A8) IOEither[E, T8], F9 ~func(A9) IOEither[E, T9], E, A1, A2, A3, A4, A5, A6, A7, A8, A9, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) func(T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) IOEither[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-	return G.TraverseTuple9[IOEither[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](f1, f2, f3, f4, f5, f6, f7, f8, f9)
+  return G.TraverseTuple9[IOEither[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](f1, f2, f3, f4, f5, f6, f7, f8, f9)
 }
 
 // Eitherize10 converts a function with 11 parameters returning a tuple into a function with 10 parameters returning a [IOEither[error, R]]
 func Eitherize10[F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) (R, error), T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) IOEither[error, R] {
-	return G.Eitherize10[IOEither[error, R]](f)
+  return G.Eitherize10[IOEither[error, R]](f)
 }
 
 // Uneitherize10 converts a function with 11 parameters returning a tuple into a function with 10 parameters returning a [IOEither[error, R]]
 func Uneitherize10[F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) IOEither[error, R], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) (R, error) {
-	return G.Uneitherize10[IOEither[error, R]](f)
+  return G.Uneitherize10[IOEither[error, R]](f)
 }
 
 // SequenceT10 converts 10 [IOEither[E, T]] into a [IOEither[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
 func SequenceT10[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](
-	t1 IOEither[E, T1],
-	t2 IOEither[E, T2],
-	t3 IOEither[E, T3],
-	t4 IOEither[E, T4],
-	t5 IOEither[E, T5],
-	t6 IOEither[E, T6],
-	t7 IOEither[E, T7],
-	t8 IOEither[E, T8],
-	t9 IOEither[E, T9],
-	t10 IOEither[E, T10],
+  t1 IOEither[E, T1],
+  t2 IOEither[E, T2],
+  t3 IOEither[E, T3],
+  t4 IOEither[E, T4],
+  t5 IOEither[E, T5],
+  t6 IOEither[E, T6],
+  t7 IOEither[E, T7],
+  t8 IOEither[E, T8],
+  t9 IOEither[E, T9],
+  t10 IOEither[E, T10],
 ) IOEither[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-	return G.SequenceT10[
-		IOEither[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
-		IOEither[E, T1],
-		IOEither[E, T2],
-		IOEither[E, T3],
-		IOEither[E, T4],
-		IOEither[E, T5],
-		IOEither[E, T6],
-		IOEither[E, T7],
-		IOEither[E, T8],
-		IOEither[E, T9],
-		IOEither[E, T10],
-	](t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
+  return G.SequenceT10[
+    IOEither[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+    IOEither[E, T1],
+    IOEither[E, T2],
+    IOEither[E, T3],
+    IOEither[E, T4],
+    IOEither[E, T5],
+    IOEither[E, T6],
+    IOEither[E, T7],
+    IOEither[E, T8],
+    IOEither[E, T9],
+    IOEither[E, T10],
+  ](t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
 }
 
 // SequenceTuple10 converts a [T.Tuple10[IOEither[E, T]]] into a [IOEither[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
 func SequenceTuple10[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t T.Tuple10[IOEither[E, T1], IOEither[E, T2], IOEither[E, T3], IOEither[E, T4], IOEither[E, T5], IOEither[E, T6], IOEither[E, T7], IOEither[E, T8], IOEither[E, T9], IOEither[E, T10]]) IOEither[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-	return G.SequenceTuple10[
-		IOEither[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
-		IOEither[E, T1],
-		IOEither[E, T2],
-		IOEither[E, T3],
-		IOEither[E, T4],
-		IOEither[E, T5],
-		IOEither[E, T6],
-		IOEither[E, T7],
-		IOEither[E, T8],
-		IOEither[E, T9],
-		IOEither[E, T10],
-	](t)
+  return G.SequenceTuple10[
+    IOEither[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+    IOEither[E, T1],
+    IOEither[E, T2],
+    IOEither[E, T3],
+    IOEither[E, T4],
+    IOEither[E, T5],
+    IOEither[E, T6],
+    IOEither[E, T7],
+    IOEither[E, T8],
+    IOEither[E, T9],
+    IOEither[E, T10],
+  ](t)
 }
 
 // TraverseTuple10 converts a [T.Tuple10[IOEither[E, T]]] into a [IOEither[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
 func TraverseTuple10[F1 ~func(A1) IOEither[E, T1], F2 ~func(A2) IOEither[E, T2], F3 ~func(A3) IOEither[E, T3], F4 ~func(A4) IOEither[E, T4], F5 ~func(A5) IOEither[E, T5], F6 ~func(A6) IOEither[E, T6], F7 ~func(A7) IOEither[E, T7], F8 ~func(A8) IOEither[E, T8], F9 ~func(A9) IOEither[E, T9], F10 ~func(A10) IOEither[E, T10], E, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) func(T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) IOEither[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-	return G.TraverseTuple10[IOEither[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)
+  return G.TraverseTuple10[IOEither[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)
 }

ioeither/generic/traverse.go

@@ -45,6 +45,29 @@ func TraverseArray[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AA
 	)
 }
 
+// MonadTraverseArrayWithIndex transforms an array
+func MonadTraverseArrayWithIndex[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](tas AAS, f func(int, A) GB) GBS {
+	return RA.MonadTraverseWithIndex[AAS](
+		Of[GBS, E, BBS],
+		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
+		Ap[GBS, func() ET.Either[E, func(B) BBS], GB],
+
+		tas,
+		f,
+	)
+}
+
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](f func(int, A) GB) func(AAS) GBS {
+	return RA.TraverseWithIndex[AAS](
+		Of[GBS, E, BBS],
+		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
+		Ap[GBS, func() ET.Either[E, func(B) BBS], GB],
+
+		f,
+	)
+}
+
 // SequenceArray converts a homogeneous sequence of either into an either of sequence
 func SequenceArray[GA ~func() ET.Either[E, A], GAS ~func() ET.Either[E, AAS], AAS ~[]A, GAAS ~[]GA, E, A any](tas GAAS) GAS {
 	return MonadTraverseArray[GA, GAS](tas, F.Identity[GA])
@@ -73,6 +96,17 @@ func TraverseRecord[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], A
 	)
 }
 
+// TraverseRecordWithIndex transforms an array
+func TraverseRecordWithIndex[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, E, A, B any](f func(K, A) GB) func(AAS) GBS {
+	return RR.TraverseWithIndex[AAS](
+		Of[GBS, E, BBS],
+		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
+		Ap[GBS, func() ET.Either[E, func(B) BBS], GB],
+
+		f,
+	)
+}
+
 // SequenceRecord converts a homogeneous sequence of either into an either of sequence
 func SequenceRecord[GA ~func() ET.Either[E, A], GAS ~func() ET.Either[E, AAS], AAS ~map[K]A, GAAS ~map[K]GA, K comparable, E, A any](tas GAAS) GAS {
 	return MonadTraverseRecord[GA, GAS](tas, F.Identity[GA])

ioeither/traverse.go

@@ -24,6 +24,11 @@ func TraverseArray[E, A, B any](f func(A) IOEither[E, B]) func([]A) IOEither[E,
 	return G.TraverseArray[IOEither[E, B], IOEither[E, []B], []A](f)
 }
 
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[E, A, B any](f func(int, A) IOEither[E, B]) func([]A) IOEither[E, []B] {
+	return G.TraverseArrayWithIndex[IOEither[E, B], IOEither[E, []B], []A](f)
+}
+
 // SequenceArray converts a homogeneous sequence of either into an either of sequence
 func SequenceArray[E, A any](ma []IOEither[E, A]) IOEither[E, []A] {
 	return G.SequenceArray[IOEither[E, A], IOEither[E, []A]](ma)
@@ -34,6 +39,11 @@ func TraverseRecord[K comparable, E, A, B any](f func(A) IOEither[E, B]) func(ma
 	return G.TraverseRecord[IOEither[E, B], IOEither[E, map[K]B], map[K]A](f)
 }
 
+// TraverseRecordWithIndex transforms a record
+func TraverseRecordWithIndex[K comparable, E, A, B any](f func(K, A) IOEither[E, B]) func(map[K]A) IOEither[E, map[K]B] {
+	return G.TraverseRecordWithIndex[IOEither[E, B], IOEither[E, map[K]B], map[K]A](f)
+}
+
 // SequenceRecord converts a homogeneous sequence of either into an either of sequence
 func SequenceRecord[K comparable, E, A any](ma map[K]IOEither[E, A]) IOEither[E, map[K]A] {
 	return G.SequenceRecord[IOEither[E, A], IOEither[E, map[K]A]](ma)

ioeither/traverse_test.go

@@ -0,0 +1,37 @@
+// 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 (
+	"fmt"
+	"testing"
+
+	A "github.com/IBM/fp-go/array"
+	E "github.com/IBM/fp-go/either"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestTraverseArray(t *testing.T) {
+
+	src := A.From("A", "B")
+
+	trfrm := TraverseArrayWithIndex(func(idx int, data string) IOEither[error, string] {
+		return Of[error](fmt.Sprintf("idx: %d, data: %s", idx, data))
+	})
+
+	assert.Equal(t, E.Of[error](A.From("idx: 0, data: A", "idx: 1, data: B")), trfrm(src)())
+
+}

iooption/array.go

@@ -24,6 +24,11 @@ func TraverseArray[A, B any](f func(A) IOOption[B]) func([]A) IOOption[[]B] {
 	return G.TraverseArray[IOOption[B], IOOption[[]B], []A](f)
 }
 
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[A, B any](f func(int, A) IOOption[B]) func([]A) IOOption[[]B] {
+	return G.TraverseArrayWithIndex[IOOption[B], IOOption[[]B], []A](f)
+}
+
 // SequenceArray converts a homogeneous sequence of either into an either of sequence
 func SequenceArray[A any](ma []IOOption[A]) IOOption[[]A] {
 	return G.SequenceArray[IOOption[A], IOOption[[]A], []IOOption[A], []A, A](ma)

iooption/gen.go

@@ -1,375 +1,376 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-08-17 22:59:14.0582736 +0200 CEST m=+0.248503201
+// 2023-09-12 13:44:32.1514823 +0200 CEST m=+0.098931001
 
 package iooption
 
+
 import (
-	G "github.com/IBM/fp-go/iooption/generic"
+	G "github.com/IBM/fp-go/iooption/generic"	
 	T "github.com/IBM/fp-go/tuple"
 )
 
 // SequenceT1 converts 1 [IOOption[T]] into a [IOOption[T.Tuple1[T1]]]
 func SequenceT1[T1 any](
-	t1 IOOption[T1],
+  t1 IOOption[T1],
 ) IOOption[T.Tuple1[T1]] {
-	return G.SequenceT1[
-		IOOption[T.Tuple1[T1]],
-		IOOption[T1],
-	](t1)
+  return G.SequenceT1[
+    IOOption[T.Tuple1[T1]],
+    IOOption[T1],
+  ](t1)
 }
 
 // SequenceTuple1 converts a [T.Tuple1[IOOption[T]]] into a [IOOption[T.Tuple1[T1]]]
 func SequenceTuple1[T1 any](t T.Tuple1[IOOption[T1]]) IOOption[T.Tuple1[T1]] {
-	return G.SequenceTuple1[
-		IOOption[T.Tuple1[T1]],
-		IOOption[T1],
-	](t)
+  return G.SequenceTuple1[
+    IOOption[T.Tuple1[T1]],
+    IOOption[T1],
+  ](t)
 }
 
 // TraverseTuple1 converts a [T.Tuple1[IOOption[T]]] into a [IOOption[T.Tuple1[T1]]]
 func TraverseTuple1[F1 ~func(A1) IOOption[T1], A1, T1 any](f1 F1) func(T.Tuple1[A1]) IOOption[T.Tuple1[T1]] {
-	return G.TraverseTuple1[IOOption[T.Tuple1[T1]]](f1)
+  return G.TraverseTuple1[IOOption[T.Tuple1[T1]]](f1)
 }
 
 // SequenceT2 converts 2 [IOOption[T]] into a [IOOption[T.Tuple2[T1, T2]]]
 func SequenceT2[T1, T2 any](
-	t1 IOOption[T1],
-	t2 IOOption[T2],
+  t1 IOOption[T1],
+  t2 IOOption[T2],
 ) IOOption[T.Tuple2[T1, T2]] {
-	return G.SequenceT2[
-		IOOption[T.Tuple2[T1, T2]],
-		IOOption[T1],
-		IOOption[T2],
-	](t1, t2)
+  return G.SequenceT2[
+    IOOption[T.Tuple2[T1, T2]],
+    IOOption[T1],
+    IOOption[T2],
+  ](t1, t2)
 }
 
 // SequenceTuple2 converts a [T.Tuple2[IOOption[T]]] into a [IOOption[T.Tuple2[T1, T2]]]
 func SequenceTuple2[T1, T2 any](t T.Tuple2[IOOption[T1], IOOption[T2]]) IOOption[T.Tuple2[T1, T2]] {
-	return G.SequenceTuple2[
-		IOOption[T.Tuple2[T1, T2]],
-		IOOption[T1],
-		IOOption[T2],
-	](t)
+  return G.SequenceTuple2[
+    IOOption[T.Tuple2[T1, T2]],
+    IOOption[T1],
+    IOOption[T2],
+  ](t)
 }
 
 // TraverseTuple2 converts a [T.Tuple2[IOOption[T]]] into a [IOOption[T.Tuple2[T1, T2]]]
 func TraverseTuple2[F1 ~func(A1) IOOption[T1], F2 ~func(A2) IOOption[T2], A1, A2, T1, T2 any](f1 F1, f2 F2) func(T.Tuple2[A1, A2]) IOOption[T.Tuple2[T1, T2]] {
-	return G.TraverseTuple2[IOOption[T.Tuple2[T1, T2]]](f1, f2)
+  return G.TraverseTuple2[IOOption[T.Tuple2[T1, T2]]](f1, f2)
 }
 
 // SequenceT3 converts 3 [IOOption[T]] into a [IOOption[T.Tuple3[T1, T2, T3]]]
 func SequenceT3[T1, T2, T3 any](
-	t1 IOOption[T1],
-	t2 IOOption[T2],
-	t3 IOOption[T3],
+  t1 IOOption[T1],
+  t2 IOOption[T2],
+  t3 IOOption[T3],
 ) IOOption[T.Tuple3[T1, T2, T3]] {
-	return G.SequenceT3[
-		IOOption[T.Tuple3[T1, T2, T3]],
-		IOOption[T1],
-		IOOption[T2],
-		IOOption[T3],
-	](t1, t2, t3)
+  return G.SequenceT3[
+    IOOption[T.Tuple3[T1, T2, T3]],
+    IOOption[T1],
+    IOOption[T2],
+    IOOption[T3],
+  ](t1, t2, t3)
 }
 
 // SequenceTuple3 converts a [T.Tuple3[IOOption[T]]] into a [IOOption[T.Tuple3[T1, T2, T3]]]
 func SequenceTuple3[T1, T2, T3 any](t T.Tuple3[IOOption[T1], IOOption[T2], IOOption[T3]]) IOOption[T.Tuple3[T1, T2, T3]] {
-	return G.SequenceTuple3[
-		IOOption[T.Tuple3[T1, T2, T3]],
-		IOOption[T1],
-		IOOption[T2],
-		IOOption[T3],
-	](t)
+  return G.SequenceTuple3[
+    IOOption[T.Tuple3[T1, T2, T3]],
+    IOOption[T1],
+    IOOption[T2],
+    IOOption[T3],
+  ](t)
 }
 
 // TraverseTuple3 converts a [T.Tuple3[IOOption[T]]] into a [IOOption[T.Tuple3[T1, T2, T3]]]
 func TraverseTuple3[F1 ~func(A1) IOOption[T1], F2 ~func(A2) IOOption[T2], F3 ~func(A3) IOOption[T3], A1, A2, A3, T1, T2, T3 any](f1 F1, f2 F2, f3 F3) func(T.Tuple3[A1, A2, A3]) IOOption[T.Tuple3[T1, T2, T3]] {
-	return G.TraverseTuple3[IOOption[T.Tuple3[T1, T2, T3]]](f1, f2, f3)
+  return G.TraverseTuple3[IOOption[T.Tuple3[T1, T2, T3]]](f1, f2, f3)
 }
 
 // SequenceT4 converts 4 [IOOption[T]] into a [IOOption[T.Tuple4[T1, T2, T3, T4]]]
 func SequenceT4[T1, T2, T3, T4 any](
-	t1 IOOption[T1],
-	t2 IOOption[T2],
-	t3 IOOption[T3],
-	t4 IOOption[T4],
+  t1 IOOption[T1],
+  t2 IOOption[T2],
+  t3 IOOption[T3],
+  t4 IOOption[T4],
 ) IOOption[T.Tuple4[T1, T2, T3, T4]] {
-	return G.SequenceT4[
-		IOOption[T.Tuple4[T1, T2, T3, T4]],
-		IOOption[T1],
-		IOOption[T2],
-		IOOption[T3],
-		IOOption[T4],
-	](t1, t2, t3, t4)
+  return G.SequenceT4[
+    IOOption[T.Tuple4[T1, T2, T3, T4]],
+    IOOption[T1],
+    IOOption[T2],
+    IOOption[T3],
+    IOOption[T4],
+  ](t1, t2, t3, t4)
 }
 
 // SequenceTuple4 converts a [T.Tuple4[IOOption[T]]] into a [IOOption[T.Tuple4[T1, T2, T3, T4]]]
 func SequenceTuple4[T1, T2, T3, T4 any](t T.Tuple4[IOOption[T1], IOOption[T2], IOOption[T3], IOOption[T4]]) IOOption[T.Tuple4[T1, T2, T3, T4]] {
-	return G.SequenceTuple4[
-		IOOption[T.Tuple4[T1, T2, T3, T4]],
-		IOOption[T1],
-		IOOption[T2],
-		IOOption[T3],
-		IOOption[T4],
-	](t)
+  return G.SequenceTuple4[
+    IOOption[T.Tuple4[T1, T2, T3, T4]],
+    IOOption[T1],
+    IOOption[T2],
+    IOOption[T3],
+    IOOption[T4],
+  ](t)
 }
 
 // TraverseTuple4 converts a [T.Tuple4[IOOption[T]]] into a [IOOption[T.Tuple4[T1, T2, T3, T4]]]
 func TraverseTuple4[F1 ~func(A1) IOOption[T1], F2 ~func(A2) IOOption[T2], F3 ~func(A3) IOOption[T3], F4 ~func(A4) IOOption[T4], A1, A2, A3, A4, T1, T2, T3, T4 any](f1 F1, f2 F2, f3 F3, f4 F4) func(T.Tuple4[A1, A2, A3, A4]) IOOption[T.Tuple4[T1, T2, T3, T4]] {
-	return G.TraverseTuple4[IOOption[T.Tuple4[T1, T2, T3, T4]]](f1, f2, f3, f4)
+  return G.TraverseTuple4[IOOption[T.Tuple4[T1, T2, T3, T4]]](f1, f2, f3, f4)
 }
 
 // SequenceT5 converts 5 [IOOption[T]] into a [IOOption[T.Tuple5[T1, T2, T3, T4, T5]]]
 func SequenceT5[T1, T2, T3, T4, T5 any](
-	t1 IOOption[T1],
-	t2 IOOption[T2],
-	t3 IOOption[T3],
-	t4 IOOption[T4],
-	t5 IOOption[T5],
+  t1 IOOption[T1],
+  t2 IOOption[T2],
+  t3 IOOption[T3],
+  t4 IOOption[T4],
+  t5 IOOption[T5],
 ) IOOption[T.Tuple5[T1, T2, T3, T4, T5]] {
-	return G.SequenceT5[
-		IOOption[T.Tuple5[T1, T2, T3, T4, T5]],
-		IOOption[T1],
-		IOOption[T2],
-		IOOption[T3],
-		IOOption[T4],
-		IOOption[T5],
-	](t1, t2, t3, t4, t5)
+  return G.SequenceT5[
+    IOOption[T.Tuple5[T1, T2, T3, T4, T5]],
+    IOOption[T1],
+    IOOption[T2],
+    IOOption[T3],
+    IOOption[T4],
+    IOOption[T5],
+  ](t1, t2, t3, t4, t5)
 }
 
 // SequenceTuple5 converts a [T.Tuple5[IOOption[T]]] into a [IOOption[T.Tuple5[T1, T2, T3, T4, T5]]]
 func SequenceTuple5[T1, T2, T3, T4, T5 any](t T.Tuple5[IOOption[T1], IOOption[T2], IOOption[T3], IOOption[T4], IOOption[T5]]) IOOption[T.Tuple5[T1, T2, T3, T4, T5]] {
-	return G.SequenceTuple5[
-		IOOption[T.Tuple5[T1, T2, T3, T4, T5]],
-		IOOption[T1],
-		IOOption[T2],
-		IOOption[T3],
-		IOOption[T4],
-		IOOption[T5],
-	](t)
+  return G.SequenceTuple5[
+    IOOption[T.Tuple5[T1, T2, T3, T4, T5]],
+    IOOption[T1],
+    IOOption[T2],
+    IOOption[T3],
+    IOOption[T4],
+    IOOption[T5],
+  ](t)
 }
 
 // TraverseTuple5 converts a [T.Tuple5[IOOption[T]]] into a [IOOption[T.Tuple5[T1, T2, T3, T4, T5]]]
 func TraverseTuple5[F1 ~func(A1) IOOption[T1], F2 ~func(A2) IOOption[T2], F3 ~func(A3) IOOption[T3], F4 ~func(A4) IOOption[T4], F5 ~func(A5) IOOption[T5], A1, A2, A3, A4, A5, T1, T2, T3, T4, T5 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) func(T.Tuple5[A1, A2, A3, A4, A5]) IOOption[T.Tuple5[T1, T2, T3, T4, T5]] {
-	return G.TraverseTuple5[IOOption[T.Tuple5[T1, T2, T3, T4, T5]]](f1, f2, f3, f4, f5)
+  return G.TraverseTuple5[IOOption[T.Tuple5[T1, T2, T3, T4, T5]]](f1, f2, f3, f4, f5)
 }
 
 // SequenceT6 converts 6 [IOOption[T]] into a [IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]]]
 func SequenceT6[T1, T2, T3, T4, T5, T6 any](
-	t1 IOOption[T1],
-	t2 IOOption[T2],
-	t3 IOOption[T3],
-	t4 IOOption[T4],
-	t5 IOOption[T5],
-	t6 IOOption[T6],
+  t1 IOOption[T1],
+  t2 IOOption[T2],
+  t3 IOOption[T3],
+  t4 IOOption[T4],
+  t5 IOOption[T5],
+  t6 IOOption[T6],
 ) IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-	return G.SequenceT6[
-		IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]],
-		IOOption[T1],
-		IOOption[T2],
-		IOOption[T3],
-		IOOption[T4],
-		IOOption[T5],
-		IOOption[T6],
-	](t1, t2, t3, t4, t5, t6)
+  return G.SequenceT6[
+    IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]],
+    IOOption[T1],
+    IOOption[T2],
+    IOOption[T3],
+    IOOption[T4],
+    IOOption[T5],
+    IOOption[T6],
+  ](t1, t2, t3, t4, t5, t6)
 }
 
 // SequenceTuple6 converts a [T.Tuple6[IOOption[T]]] into a [IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]]]
 func SequenceTuple6[T1, T2, T3, T4, T5, T6 any](t T.Tuple6[IOOption[T1], IOOption[T2], IOOption[T3], IOOption[T4], IOOption[T5], IOOption[T6]]) IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-	return G.SequenceTuple6[
-		IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]],
-		IOOption[T1],
-		IOOption[T2],
-		IOOption[T3],
-		IOOption[T4],
-		IOOption[T5],
-		IOOption[T6],
-	](t)
+  return G.SequenceTuple6[
+    IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]],
+    IOOption[T1],
+    IOOption[T2],
+    IOOption[T3],
+    IOOption[T4],
+    IOOption[T5],
+    IOOption[T6],
+  ](t)
 }
 
 // TraverseTuple6 converts a [T.Tuple6[IOOption[T]]] into a [IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]]]
 func TraverseTuple6[F1 ~func(A1) IOOption[T1], F2 ~func(A2) IOOption[T2], F3 ~func(A3) IOOption[T3], F4 ~func(A4) IOOption[T4], F5 ~func(A5) IOOption[T5], F6 ~func(A6) IOOption[T6], A1, A2, A3, A4, A5, A6, T1, T2, T3, T4, T5, T6 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) func(T.Tuple6[A1, A2, A3, A4, A5, A6]) IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-	return G.TraverseTuple6[IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]]](f1, f2, f3, f4, f5, f6)
+  return G.TraverseTuple6[IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]]](f1, f2, f3, f4, f5, f6)
 }
 
 // SequenceT7 converts 7 [IOOption[T]] into a [IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
 func SequenceT7[T1, T2, T3, T4, T5, T6, T7 any](
-	t1 IOOption[T1],
-	t2 IOOption[T2],
-	t3 IOOption[T3],
-	t4 IOOption[T4],
-	t5 IOOption[T5],
-	t6 IOOption[T6],
-	t7 IOOption[T7],
+  t1 IOOption[T1],
+  t2 IOOption[T2],
+  t3 IOOption[T3],
+  t4 IOOption[T4],
+  t5 IOOption[T5],
+  t6 IOOption[T6],
+  t7 IOOption[T7],
 ) IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-	return G.SequenceT7[
-		IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
-		IOOption[T1],
-		IOOption[T2],
-		IOOption[T3],
-		IOOption[T4],
-		IOOption[T5],
-		IOOption[T6],
-		IOOption[T7],
-	](t1, t2, t3, t4, t5, t6, t7)
+  return G.SequenceT7[
+    IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+    IOOption[T1],
+    IOOption[T2],
+    IOOption[T3],
+    IOOption[T4],
+    IOOption[T5],
+    IOOption[T6],
+    IOOption[T7],
+  ](t1, t2, t3, t4, t5, t6, t7)
 }
 
 // SequenceTuple7 converts a [T.Tuple7[IOOption[T]]] into a [IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
 func SequenceTuple7[T1, T2, T3, T4, T5, T6, T7 any](t T.Tuple7[IOOption[T1], IOOption[T2], IOOption[T3], IOOption[T4], IOOption[T5], IOOption[T6], IOOption[T7]]) IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-	return G.SequenceTuple7[
-		IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
-		IOOption[T1],
-		IOOption[T2],
-		IOOption[T3],
-		IOOption[T4],
-		IOOption[T5],
-		IOOption[T6],
-		IOOption[T7],
-	](t)
+  return G.SequenceTuple7[
+    IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+    IOOption[T1],
+    IOOption[T2],
+    IOOption[T3],
+    IOOption[T4],
+    IOOption[T5],
+    IOOption[T6],
+    IOOption[T7],
+  ](t)
 }
 
 // TraverseTuple7 converts a [T.Tuple7[IOOption[T]]] into a [IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
 func TraverseTuple7[F1 ~func(A1) IOOption[T1], F2 ~func(A2) IOOption[T2], F3 ~func(A3) IOOption[T3], F4 ~func(A4) IOOption[T4], F5 ~func(A5) IOOption[T5], F6 ~func(A6) IOOption[T6], F7 ~func(A7) IOOption[T7], A1, A2, A3, A4, A5, A6, A7, T1, T2, T3, T4, T5, T6, T7 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) func(T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-	return G.TraverseTuple7[IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](f1, f2, f3, f4, f5, f6, f7)
+  return G.TraverseTuple7[IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](f1, f2, f3, f4, f5, f6, f7)
 }
 
 // SequenceT8 converts 8 [IOOption[T]] into a [IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
 func SequenceT8[T1, T2, T3, T4, T5, T6, T7, T8 any](
-	t1 IOOption[T1],
-	t2 IOOption[T2],
-	t3 IOOption[T3],
-	t4 IOOption[T4],
-	t5 IOOption[T5],
-	t6 IOOption[T6],
-	t7 IOOption[T7],
-	t8 IOOption[T8],
+  t1 IOOption[T1],
+  t2 IOOption[T2],
+  t3 IOOption[T3],
+  t4 IOOption[T4],
+  t5 IOOption[T5],
+  t6 IOOption[T6],
+  t7 IOOption[T7],
+  t8 IOOption[T8],
 ) IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-	return G.SequenceT8[
-		IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
-		IOOption[T1],
-		IOOption[T2],
-		IOOption[T3],
-		IOOption[T4],
-		IOOption[T5],
-		IOOption[T6],
-		IOOption[T7],
-		IOOption[T8],
-	](t1, t2, t3, t4, t5, t6, t7, t8)
+  return G.SequenceT8[
+    IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+    IOOption[T1],
+    IOOption[T2],
+    IOOption[T3],
+    IOOption[T4],
+    IOOption[T5],
+    IOOption[T6],
+    IOOption[T7],
+    IOOption[T8],
+  ](t1, t2, t3, t4, t5, t6, t7, t8)
 }
 
 // SequenceTuple8 converts a [T.Tuple8[IOOption[T]]] into a [IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
 func SequenceTuple8[T1, T2, T3, T4, T5, T6, T7, T8 any](t T.Tuple8[IOOption[T1], IOOption[T2], IOOption[T3], IOOption[T4], IOOption[T5], IOOption[T6], IOOption[T7], IOOption[T8]]) IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-	return G.SequenceTuple8[
-		IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
-		IOOption[T1],
-		IOOption[T2],
-		IOOption[T3],
-		IOOption[T4],
-		IOOption[T5],
-		IOOption[T6],
-		IOOption[T7],
-		IOOption[T8],
-	](t)
+  return G.SequenceTuple8[
+    IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+    IOOption[T1],
+    IOOption[T2],
+    IOOption[T3],
+    IOOption[T4],
+    IOOption[T5],
+    IOOption[T6],
+    IOOption[T7],
+    IOOption[T8],
+  ](t)
 }
 
 // TraverseTuple8 converts a [T.Tuple8[IOOption[T]]] into a [IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
 func TraverseTuple8[F1 ~func(A1) IOOption[T1], F2 ~func(A2) IOOption[T2], F3 ~func(A3) IOOption[T3], F4 ~func(A4) IOOption[T4], F5 ~func(A5) IOOption[T5], F6 ~func(A6) IOOption[T6], F7 ~func(A7) IOOption[T7], F8 ~func(A8) IOOption[T8], A1, A2, A3, A4, A5, A6, A7, A8, T1, T2, T3, T4, T5, T6, T7, T8 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) func(T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-	return G.TraverseTuple8[IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](f1, f2, f3, f4, f5, f6, f7, f8)
+  return G.TraverseTuple8[IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](f1, f2, f3, f4, f5, f6, f7, f8)
 }
 
 // SequenceT9 converts 9 [IOOption[T]] into a [IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
 func SequenceT9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
-	t1 IOOption[T1],
-	t2 IOOption[T2],
-	t3 IOOption[T3],
-	t4 IOOption[T4],
-	t5 IOOption[T5],
-	t6 IOOption[T6],
-	t7 IOOption[T7],
-	t8 IOOption[T8],
-	t9 IOOption[T9],
+  t1 IOOption[T1],
+  t2 IOOption[T2],
+  t3 IOOption[T3],
+  t4 IOOption[T4],
+  t5 IOOption[T5],
+  t6 IOOption[T6],
+  t7 IOOption[T7],
+  t8 IOOption[T8],
+  t9 IOOption[T9],
 ) IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-	return G.SequenceT9[
-		IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
-		IOOption[T1],
-		IOOption[T2],
-		IOOption[T3],
-		IOOption[T4],
-		IOOption[T5],
-		IOOption[T6],
-		IOOption[T7],
-		IOOption[T8],
-		IOOption[T9],
-	](t1, t2, t3, t4, t5, t6, t7, t8, t9)
+  return G.SequenceT9[
+    IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+    IOOption[T1],
+    IOOption[T2],
+    IOOption[T3],
+    IOOption[T4],
+    IOOption[T5],
+    IOOption[T6],
+    IOOption[T7],
+    IOOption[T8],
+    IOOption[T9],
+  ](t1, t2, t3, t4, t5, t6, t7, t8, t9)
 }
 
 // SequenceTuple9 converts a [T.Tuple9[IOOption[T]]] into a [IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
 func SequenceTuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t T.Tuple9[IOOption[T1], IOOption[T2], IOOption[T3], IOOption[T4], IOOption[T5], IOOption[T6], IOOption[T7], IOOption[T8], IOOption[T9]]) IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-	return G.SequenceTuple9[
-		IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
-		IOOption[T1],
-		IOOption[T2],
-		IOOption[T3],
-		IOOption[T4],
-		IOOption[T5],
-		IOOption[T6],
-		IOOption[T7],
-		IOOption[T8],
-		IOOption[T9],
-	](t)
+  return G.SequenceTuple9[
+    IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+    IOOption[T1],
+    IOOption[T2],
+    IOOption[T3],
+    IOOption[T4],
+    IOOption[T5],
+    IOOption[T6],
+    IOOption[T7],
+    IOOption[T8],
+    IOOption[T9],
+  ](t)
 }
 
 // TraverseTuple9 converts a [T.Tuple9[IOOption[T]]] into a [IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
 func TraverseTuple9[F1 ~func(A1) IOOption[T1], F2 ~func(A2) IOOption[T2], F3 ~func(A3) IOOption[T3], F4 ~func(A4) IOOption[T4], F5 ~func(A5) IOOption[T5], F6 ~func(A6) IOOption[T6], F7 ~func(A7) IOOption[T7], F8 ~func(A8) IOOption[T8], F9 ~func(A9) IOOption[T9], A1, A2, A3, A4, A5, A6, A7, A8, A9, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) func(T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-	return G.TraverseTuple9[IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](f1, f2, f3, f4, f5, f6, f7, f8, f9)
+  return G.TraverseTuple9[IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](f1, f2, f3, f4, f5, f6, f7, f8, f9)
 }
 
 // SequenceT10 converts 10 [IOOption[T]] into a [IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
 func SequenceT10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](
-	t1 IOOption[T1],
-	t2 IOOption[T2],
-	t3 IOOption[T3],
-	t4 IOOption[T4],
-	t5 IOOption[T5],
-	t6 IOOption[T6],
-	t7 IOOption[T7],
-	t8 IOOption[T8],
-	t9 IOOption[T9],
-	t10 IOOption[T10],
+  t1 IOOption[T1],
+  t2 IOOption[T2],
+  t3 IOOption[T3],
+  t4 IOOption[T4],
+  t5 IOOption[T5],
+  t6 IOOption[T6],
+  t7 IOOption[T7],
+  t8 IOOption[T8],
+  t9 IOOption[T9],
+  t10 IOOption[T10],
 ) IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-	return G.SequenceT10[
-		IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
-		IOOption[T1],
-		IOOption[T2],
-		IOOption[T3],
-		IOOption[T4],
-		IOOption[T5],
-		IOOption[T6],
-		IOOption[T7],
-		IOOption[T8],
-		IOOption[T9],
-		IOOption[T10],
-	](t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
+  return G.SequenceT10[
+    IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+    IOOption[T1],
+    IOOption[T2],
+    IOOption[T3],
+    IOOption[T4],
+    IOOption[T5],
+    IOOption[T6],
+    IOOption[T7],
+    IOOption[T8],
+    IOOption[T9],
+    IOOption[T10],
+  ](t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
 }
 
 // SequenceTuple10 converts a [T.Tuple10[IOOption[T]]] into a [IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
 func SequenceTuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t T.Tuple10[IOOption[T1], IOOption[T2], IOOption[T3], IOOption[T4], IOOption[T5], IOOption[T6], IOOption[T7], IOOption[T8], IOOption[T9], IOOption[T10]]) IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-	return G.SequenceTuple10[
-		IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
-		IOOption[T1],
-		IOOption[T2],
-		IOOption[T3],
-		IOOption[T4],
-		IOOption[T5],
-		IOOption[T6],
-		IOOption[T7],
-		IOOption[T8],
-		IOOption[T9],
-		IOOption[T10],
-	](t)
+  return G.SequenceTuple10[
+    IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+    IOOption[T1],
+    IOOption[T2],
+    IOOption[T3],
+    IOOption[T4],
+    IOOption[T5],
+    IOOption[T6],
+    IOOption[T7],
+    IOOption[T8],
+    IOOption[T9],
+    IOOption[T10],
+  ](t)
 }
 
 // TraverseTuple10 converts a [T.Tuple10[IOOption[T]]] into a [IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
 func TraverseTuple10[F1 ~func(A1) IOOption[T1], F2 ~func(A2) IOOption[T2], F3 ~func(A3) IOOption[T3], F4 ~func(A4) IOOption[T4], F5 ~func(A5) IOOption[T5], F6 ~func(A6) IOOption[T6], F7 ~func(A7) IOOption[T7], F8 ~func(A8) IOOption[T8], F9 ~func(A9) IOOption[T9], F10 ~func(A10) IOOption[T10], A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) func(T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-	return G.TraverseTuple10[IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)
+  return G.TraverseTuple10[IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)
 }

iooption/generic/traverse.go

@@ -28,6 +28,13 @@ func TraverseArray[TB ~func() O.Option[B], TBS ~func() O.Option[GB], GA ~[]A, GB
 	)
 }
 
+func TraverseArrayWithIndex[TB ~func() O.Option[B], TBS ~func() O.Option[GB], GA ~[]A, GB ~[]B, A, B any](f func(int, A) TB) func(GA) TBS {
+	return F.Flow2(
+		I.TraverseArrayWithIndex[TB, func() []O.Option[B], GA](f),
+		I.Map[func() []O.Option[B], TBS](O.SequenceArrayG[GB, []O.Option[B], B]),
+	)
+}
+
 func SequenceArray[TB ~func() O.Option[B], TBS ~func() O.Option[GB], GA ~[]TB, GB ~[]B, A, B any](ma GA) TBS {
 	return TraverseArray[TB, TBS, GA](F.Identity[TB])(ma)
 }

lazy/traverse.go

@@ -29,6 +29,12 @@ func TraverseArray[A, B any](f func(A) Lazy[B]) func([]A) Lazy[[]B] {
 	return G.TraverseArray[Lazy[B], Lazy[[]B], []A](f)
 }
 
+// TraverseArrayWithIndex applies a function returning an [IO] to all elements in an array and the
+// transforms this into an [IO] of that array
+func TraverseArrayWithIndex[A, B any](f func(int, A) Lazy[B]) func([]A) Lazy[[]B] {
+	return G.TraverseArrayWithIndex[Lazy[B], Lazy[[]B], []A](f)
+}
+
 // SequenceArray converts an array of [IO] to an [IO] of an array
 func SequenceArray[A any](tas []Lazy[A]) Lazy[[]A] {
 	return G.SequenceArray[Lazy[A], Lazy[[]A]](tas)
@@ -38,12 +44,18 @@ func MonadTraverseRecord[K comparable, A, B any](tas map[K]A, f func(A) Lazy[B])
 	return G.MonadTraverseRecord[Lazy[B], Lazy[map[K]B]](tas, f)
 }
 
-// TraverseArray applies a function returning an [IO] to all elements in a record and the
+// TraverseRecord applies a function returning an [IO] to all elements in a record and the
 // transforms this into an [IO] of that record
 func TraverseRecord[K comparable, A, B any](f func(A) Lazy[B]) func(map[K]A) Lazy[map[K]B] {
 	return G.TraverseRecord[Lazy[B], Lazy[map[K]B], map[K]A](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 TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) Lazy[B]) func(map[K]A) Lazy[map[K]B] {
+	return G.TraverseRecordWithIndex[Lazy[B], Lazy[map[K]B], map[K]A](f)
+}
+
 // SequenceRecord converts a record of [IO] to an [IO] of a record
 func SequenceRecord[K comparable, A any](tas map[K]Lazy[A]) Lazy[map[K]A] {
 	return G.SequenceRecord[Lazy[A], Lazy[map[K]A]](tas)

optics/iso/iso.go

@@ -67,7 +67,7 @@ func Modify[S, A any](f func(A) A) func(Iso[S, A]) func(S) S {
 }
 
 // Wrap wraps the value
-func Unwrap[S, A any](s S) func(Iso[S, A]) A {
+func Unwrap[A, S any](s S) func(Iso[S, A]) A {
 	return func(sa Iso[S, A]) A {
 		return sa.Get(s)
 	}
@@ -81,8 +81,8 @@ func Wrap[S, A any](a A) func(Iso[S, A]) S {
 }
 
 // From wraps the value
-func To[S, A any](s S) func(Iso[S, A]) A {
-	return Unwrap[S, A](s)
+func To[A, S any](s S) func(Iso[S, A]) A {
+	return Unwrap[A, S](s)
 }
 
 // To unwraps the value

optics/lens/lens.go

@@ -121,7 +121,7 @@ func Compose[S, A, B any](ab Lens[A, B]) func(Lens[S, A]) Lens[S, B] {
 // the getter returns an `Option[B]` because the container `A` could already be an option
 // if the setter is invoked with `Some[B]` then the value of `B` will be set, potentially on a default value of `A` if `A` did not exist
 // if the setter is invoked with `None[B]` then the container `A` is reset to `None[A]` because this is the only way to remove `B`
-func ComposeOption[S, A, B any](defaultA A) func(ab Lens[A, B]) func(Lens[S, O.Option[A]]) Lens[S, O.Option[B]] {
+func ComposeOption[S, B, A any](defaultA A) func(ab Lens[A, B]) func(Lens[S, O.Option[A]]) Lens[S, O.Option[B]] {
 	defa := F.Constant(defaultA)
 	return func(ab Lens[A, B]) func(Lens[S, O.Option[A]]) Lens[S, O.Option[B]] {
 		foldab := O.Fold(O.None[B], F.Flow2(ab.Get, O.Some[B]))
@@ -172,7 +172,7 @@ func ComposeOption[S, A, B any](defaultA A) func(ab Lens[A, B]) func(Lens[S, O.O
 // if the setter is called with `Some[B]` and `A` does not exist, the default of 'A' is updated with `B`
 // if the setter is called with `None[B]` and `A` does not exist this is the identity operation on 'S'
 // if the setter is called with `None[B]` and `A` does exist, 'B' is removed from 'A'
-func ComposeOptions[S, A, B any](defaultA A) func(ab Lens[A, O.Option[B]]) func(Lens[S, O.Option[A]]) Lens[S, O.Option[B]] {
+func ComposeOptions[S, B, A any](defaultA A) func(ab Lens[A, O.Option[B]]) func(Lens[S, O.Option[A]]) Lens[S, O.Option[B]] {
 	defa := F.Constant(defaultA)
 	noops := F.Constant(F.Identity[S])
 	noneb := O.None[B]()

optics/lens/lens_test.go

@@ -209,7 +209,7 @@ func TestComposeOption(t *testing.T) {
 	// compose lenses
 	lens := F.Pipe1(
 		inner,
-		ComposeOption[Outer, *Inner, int](defaultInner)(value),
+		ComposeOption[Outer, int](defaultInner)(value),
 	)
 	outer1 := Outer{inner: &Inner{Value: 1, Foo: "a"}}
 	// the checks
@@ -235,7 +235,7 @@ func TestComposeOptions(t *testing.T) {
 	// compose lenses
 	lens := F.Pipe1(
 		inner,
-		ComposeOptions[OuterOpt, *InnerOpt, *int](defaultInner)(value),
+		ComposeOptions[OuterOpt, *int](defaultInner)(value),
 	)
 	// additional settings
 	defaultValue2 := 2

optics/lens/record/generic/record.go

@@ -24,7 +24,7 @@ import (
 )
 
 // AtRecord returns a lens that focusses on a value in a record
-func AtRecord[M ~map[K]V, K comparable, V any](key K) L.Lens[M, O.Option[V]] {
+func AtRecord[M ~map[K]V, V any, K comparable](key K) L.Lens[M, O.Option[V]] {
 	addKey := F.Bind1of2(RR.UpsertAt[M, K, V])(key)
 	delKey := F.Bind1of1(RR.DeleteAt[M, K, V])(key)
 	fold := O.Fold(
@@ -44,6 +44,6 @@ func AtRecord[M ~map[K]V, K comparable, V any](key K) L.Lens[M, O.Option[V]] {
 }
 
 // AtKey returns a `Lens` focused on a required key of a `ReadonlyRecord`
-func AtKey[M ~map[K]V, S any, K comparable, V any](key K) func(sa L.Lens[S, M]) L.Lens[S, O.Option[V]] {
+func AtKey[M ~map[K]V, S any, V any, K comparable](key K) func(sa L.Lens[S, M]) L.Lens[S, O.Option[V]] {
 	return L.Compose[S](AtRecord[M](key))
 }

optics/lens/record/record.go

@@ -22,11 +22,11 @@ import (
 )
 
 // AtRecord returns a lens that focusses on a value in a record
-func AtRecord[K comparable, V any](key K) L.Lens[map[K]V, O.Option[V]] {
+func AtRecord[V any, K comparable](key K) L.Lens[map[K]V, O.Option[V]] {
 	return G.AtRecord[map[K]V](key)
 }
 
 // AtKey returns a `Lens` focused on a required key of a `ReadonlyRecord`
-func AtKey[S any, K comparable, V any](key K) func(sa L.Lens[S, map[K]V]) L.Lens[S, O.Option[V]] {
+func AtKey[S any, V any, K comparable](key K) func(sa L.Lens[S, map[K]V]) L.Lens[S, O.Option[V]] {
 	return G.AtKey[map[K]V, S](key)
 }

optics/lens/record/record_test.go

@@ -31,7 +31,7 @@ type (
 func TestAtKey(t *testing.T) {
 	sa := F.Pipe1(
 		L.Id[S](),
-		AtKey[S, string, int]("a"),
+		AtKey[S, int]("a"),
 	)
 
 	assert.Equal(t, O.Some(1), sa.Get(S{"a": 1}))

optics/lens/testing/laws_test.go

@@ -198,7 +198,7 @@ func TestOuterLensLaws(t *testing.T) {
 	eqValue := EQT.Eq[int]()
 	eqOptValue := O.Eq(eqValue)
 	// lens to access a value from outer
-	valueFromOuter := L.ComposeOption[*Outer, *Inner, int](&defaultInner)(valueLens)(outerLens)
+	valueFromOuter := L.ComposeOption[*Outer, int](&defaultInner)(valueLens)(outerLens)
 	// try to access the value, this should get an option
 	assert.True(t, eqOptValue.Equals(valueFromOuter.Get(&emptyOuter), O.None[int]()))
 	// update the object
@@ -234,7 +234,7 @@ func TestOuterOptLensLaws(t *testing.T) {
 	valueFromOuter := F.Pipe3(
 		valueOptLens,
 		LI.Compose[*InnerOpt](intIso),
-		L.ComposeOptions[*OuterOpt, *InnerOpt, int](&defaultInnerOpt),
+		L.ComposeOptions[*OuterOpt, int](&defaultInnerOpt),
 		I.Ap[L.Lens[*OuterOpt, O.Option[int]]](outerOptLens),
 	)
 

option/array.go

@@ -36,6 +36,22 @@ func TraverseArray[A, B any](f func(A) Option[B]) func([]A) Option[[]B] {
 	return TraverseArrayG[[]A, []B](f)
 }
 
+// TraverseArrayWithIndexG transforms an array
+func TraverseArrayWithIndexG[GA ~[]A, GB ~[]B, A, B any](f func(int, A) Option[B]) func(GA) Option[GB] {
+	return RA.TraverseWithIndex[GA](
+		Of[GB],
+		Map[GB, func(B) GB],
+		Ap[GB, B],
+
+		f,
+	)
+}
+
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[A, B any](f func(int, A) Option[B]) func([]A) Option[[]B] {
+	return TraverseArrayWithIndexG[[]A, []B](f)
+}
+
 func SequenceArrayG[GA ~[]A, GOA ~[]Option[A], A any](ma GOA) Option[GA] {
 	return TraverseArrayG[GOA, GA](F.Identity[Option[A]])(ma)
 }
@@ -44,3 +60,15 @@ func SequenceArrayG[GA ~[]A, GOA ~[]Option[A], A any](ma GOA) Option[GA] {
 func SequenceArray[A any](ma []Option[A]) Option[[]A] {
 	return SequenceArrayG[[]A](ma)
 }
+
+// CompactArrayG discards the none values and keeps the some values
+func CompactArrayG[A1 ~[]Option[A], A2 ~[]A, A any](fa A1) A2 {
+	return RA.Reduce(fa, func(out A2, value Option[A]) A2 {
+		return MonadFold(value, F.Constant(out), F.Bind1st(RA.Append[A2, A], out))
+	}, make(A2, len(fa)))
+}
+
+// CompactArray discards the none values and keeps the some values
+func CompactArray[A any](fa []Option[A]) []A {
+	return CompactArrayG[[]Option[A], []A](fa)
+}

option/record.go

@@ -20,7 +20,7 @@ import (
 	RR "github.com/IBM/fp-go/internal/record"
 )
 
-// TraverseRecord transforms a record of options into an option of a record
+// TraverseRecordG transforms a record of options into an option of a record
 func TraverseRecordG[GA ~map[K]A, GB ~map[K]B, K comparable, A, B any](f func(A) Option[B]) func(GA) Option[GB] {
 	return RR.Traverse[GA](
 		Of[GB],
@@ -36,6 +36,22 @@ func TraverseRecord[K comparable, A, B any](f func(A) Option[B]) func(map[K]A) O
 	return TraverseRecordG[map[K]A, map[K]B](f)
 }
 
+// TraverseRecordWithIndexG transforms a record of options into an option of a record
+func TraverseRecordWithIndexG[GA ~map[K]A, GB ~map[K]B, K comparable, A, B any](f func(K, A) Option[B]) func(GA) Option[GB] {
+	return RR.TraverseWithIndex[GA](
+		Of[GB],
+		Map[GB, func(B) GB],
+		Ap[GB, B],
+
+		f,
+	)
+}
+
+// TraverseRecordWithIndex transforms a record of options into an option of a record
+func TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) Option[B]) func(map[K]A) Option[map[K]B] {
+	return TraverseRecordWithIndexG[map[K]A, map[K]B](f)
+}
+
 func SequenceRecordG[GA ~map[K]A, GOA ~map[K]Option[A], K comparable, A any](ma GOA) Option[GA] {
 	return TraverseRecordG[GOA, GA](F.Identity[Option[A]])(ma)
 }
@@ -44,3 +60,21 @@ func SequenceRecordG[GA ~map[K]A, GOA ~map[K]Option[A], K comparable, A any](ma
 func SequenceRecord[K comparable, A any](ma map[K]Option[A]) Option[map[K]A] {
 	return SequenceRecordG[map[K]A](ma)
 }
+
+func upsertAtReadWrite[M ~map[K]V, K comparable, V any](r M, k K, v V) M {
+	r[k] = v
+	return r
+}
+
+// CompactRecordG discards the noe values and keeps the some values
+func CompactRecordG[M1 ~map[K]Option[A], M2 ~map[K]A, K comparable, A any](m M1) M2 {
+	bnd := F.Bind12of3(upsertAtReadWrite[M2])
+	return RR.ReduceWithIndex(m, func(key K, m M2, value Option[A]) M2 {
+		return MonadFold(value, F.Constant(m), bnd(m, key))
+	}, make(M2))
+}
+
+// CompactRecord discards the noe values and keeps the some values
+func CompactRecord[K comparable, A any](m map[K]Option[A]) map[K]A {
+	return CompactRecordG[map[K]Option[A], map[K]A](m)
+}

option/record_test.go

@@ -30,3 +30,18 @@ func TestSequenceRecord(t *testing.T) {
 		"b": Of("B"),
 	}))
 }
+
+func TestCompactRecord(t *testing.T) {
+	// make the map
+	m := make(map[string]Option[int])
+	m["foo"] = None[int]()
+	m["bar"] = Some(1)
+	// compact it
+	m1 := CompactRecord(m)
+	// check expected
+	exp := map[string]int{
+		"bar": 1,
+	}
+
+	assert.Equal(t, exp, m1)
+}

option/sequence.go

@@ -19,13 +19,22 @@ import (
 	F "github.com/IBM/fp-go/function"
 )
 
-// HKTA = HKT<A>
-// HKTOA = HKT<Option<A>>
-//
-// Sequence converts an option of some higher kinded type into the higher kinded type of an option
+// Sequence converts an [Option] of some higher kinded type into the higher kinded type of an [Option]
 func Sequence[A, HKTA, HKTOA any](
-	_of func(Option[A]) HKTOA,
-	_map func(HKTA, func(A) Option[A]) HKTOA,
+	mof func(Option[A]) HKTOA,
+	mmap func(func(A) Option[A]) func(HKTA) HKTOA,
 ) func(Option[HKTA]) HKTOA {
-	return Fold(F.Nullary2(None[A], _of), F.Bind2nd(_map, Some[A]))
+	return Fold(F.Nullary2(None[A], mof), mmap(Some[A]))
+}
+
+// Traverse converts an [Option] of some higher kinded type into the higher kinded type of an [Option]
+func Traverse[A, B, HKTB, HKTOB any](
+	mof func(Option[B]) HKTOB,
+	mmap func(func(B) Option[B]) func(HKTB) HKTOB,
+) func(func(A) HKTB) func(Option[A]) HKTOB {
+	onNone := F.Nullary2(None[B], mof)
+	onSome := mmap(Some[B])
+	return func(f func(A) HKTB) func(Option[A]) HKTOB {
+		return Fold(onNone, F.Flow2(f, onSome))
+	}
 }

option/testing/laws.go

@@ -23,7 +23,7 @@ import (
 	O "github.com/IBM/fp-go/option"
 )
 
-// AssertLaws asserts the apply monad laws for the `Either` monad
+// AssertLaws asserts the apply monad laws for the [Option] monad
 func AssertLaws[A, B, C any](t *testing.T,
 	eqa EQ.Eq[A],
 	eqb EQ.Eq[B],

reader/array.go

@@ -24,6 +24,11 @@ func TraverseArray[R, A, B any](f func(A) Reader[R, B]) func([]A) Reader[R, []B]
 	return G.TraverseArray[Reader[R, B], Reader[R, []B], []A](f)
 }
 
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[R, A, B any](f func(int, A) Reader[R, B]) func([]A) Reader[R, []B] {
+	return G.TraverseArrayWithIndex[Reader[R, B], Reader[R, []B], []A](f)
+}
+
 // SequenceArray converts a homogeneous sequence of either into an either of sequence
 func SequenceArray[R, A any](ma []Reader[R, A]) Reader[R, []A] {
 	return G.SequenceArray[Reader[R, A], Reader[R, []A]](ma)

reader/gen.go

@@ -1,75 +1,76 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-08-17 22:59:18.4448291 +0200 CEST m=+0.161369001
+// 2023-09-12 13:44:36.1655251 +0200 CEST m=+0.010000501
 
 package reader
 
+
 import (
-	G "github.com/IBM/fp-go/reader/generic"
+	G "github.com/IBM/fp-go/reader/generic"	
 )
 
 // From0 converts a function with 1 parameters returning a [R] into a function with 0 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From0[F ~func(C) R, C, R any](f F) func() Reader[C, R] {
-	return G.From0[Reader[C, R]](f)
+  return G.From0[Reader[C, R]](f)
 }
 
 // From1 converts a function with 2 parameters returning a [R] into a function with 1 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From1[F ~func(C, T0) R, T0, C, R any](f F) func(T0) Reader[C, R] {
-	return G.From1[Reader[C, R]](f)
+  return G.From1[Reader[C, R]](f)
 }
 
 // From2 converts a function with 3 parameters returning a [R] into a function with 2 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From2[F ~func(C, T0, T1) R, T0, T1, C, R any](f F) func(T0, T1) Reader[C, R] {
-	return G.From2[Reader[C, R]](f)
+  return G.From2[Reader[C, R]](f)
 }
 
 // From3 converts a function with 4 parameters returning a [R] into a function with 3 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From3[F ~func(C, T0, T1, T2) R, T0, T1, T2, C, R any](f F) func(T0, T1, T2) Reader[C, R] {
-	return G.From3[Reader[C, R]](f)
+  return G.From3[Reader[C, R]](f)
 }
 
 // From4 converts a function with 5 parameters returning a [R] into a function with 4 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From4[F ~func(C, T0, T1, T2, T3) R, T0, T1, T2, T3, C, R any](f F) func(T0, T1, T2, T3) Reader[C, R] {
-	return G.From4[Reader[C, R]](f)
+  return G.From4[Reader[C, R]](f)
 }
 
 // From5 converts a function with 6 parameters returning a [R] into a function with 5 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From5[F ~func(C, T0, T1, T2, T3, T4) R, T0, T1, T2, T3, T4, C, R any](f F) func(T0, T1, T2, T3, T4) Reader[C, R] {
-	return G.From5[Reader[C, R]](f)
+  return G.From5[Reader[C, R]](f)
 }
 
 // From6 converts a function with 7 parameters returning a [R] into a function with 6 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From6[F ~func(C, T0, T1, T2, T3, T4, T5) R, T0, T1, T2, T3, T4, T5, C, R any](f F) func(T0, T1, T2, T3, T4, T5) Reader[C, R] {
-	return G.From6[Reader[C, R]](f)
+  return G.From6[Reader[C, R]](f)
 }
 
 // From7 converts a function with 8 parameters returning a [R] into a function with 7 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From7[F ~func(C, T0, T1, T2, T3, T4, T5, T6) R, T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) Reader[C, R] {
-	return G.From7[Reader[C, R]](f)
+  return G.From7[Reader[C, R]](f)
 }
 
 // From8 converts a function with 9 parameters returning a [R] into a function with 8 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From8[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) R, T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) Reader[C, R] {
-	return G.From8[Reader[C, R]](f)
+  return G.From8[Reader[C, R]](f)
 }
 
 // From9 converts a function with 10 parameters returning a [R] into a function with 9 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From9[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) 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) Reader[C, R] {
-	return G.From9[Reader[C, R]](f)
+  return G.From9[Reader[C, R]](f)
 }
 
 // From10 converts a function with 11 parameters returning a [R] into a function with 10 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From10[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) 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) Reader[C, R] {
-	return G.From10[Reader[C, R]](f)
+  return G.From10[Reader[C, R]](f)
 }

reader/generic/array.go

@@ -40,6 +40,16 @@ func TraverseArray[GB ~func(R) B, GBS ~func(R) BBS, AAS ~[]A, BBS ~[]B, R, A, B
 	)
 }
 
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[GB ~func(R) B, GBS ~func(R) BBS, AAS ~[]A, BBS ~[]B, R, A, B any](f func(int, A) GB) func(AAS) GBS {
+	return RA.TraverseWithIndex[AAS](
+		Of[GBS, R, BBS],
+		Map[GBS, func(R) func(B) BBS, R, BBS, func(B) BBS],
+		Ap[GB, GBS, func(R) func(B) BBS, R, B, BBS],
+		f,
+	)
+}
+
 // SequenceArray converts a homogeneous sequence of either into an either of sequence
 func SequenceArray[GA ~func(R) A, GAS ~func(R) AAS, AAS ~[]A, GAAS ~[]GA, R, A any](ma GAAS) GAS {
 	return MonadTraverseArray[GA, GAS](ma, F.Identity[GA])

reader/generic/gen.go

@@ -1,114 +1,115 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-08-17 22:59:18.5047315 +0200 CEST m=+0.221271401
+// 2023-09-12 13:44:36.166526 +0200 CEST m=+0.011001401
 package generic
 
+
 // From0 converts a function with 1 parameters returning a [R] into a function with 0 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From0[GRA ~func(C) R, F ~func(C) R, C, R any](f F) func() GRA {
-	return func() GRA {
-		return MakeReader[GRA](func(r C) R {
-			return f(r)
-		})
-	}
+  return func() GRA {
+    return MakeReader[GRA](func(r C) R {
+      return f(r)
+    })
+  }
 }
 
 // From1 converts a function with 2 parameters returning a [R] into a function with 1 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From1[GRA ~func(C) R, F ~func(C, T0) R, T0, C, R any](f F) func(T0) GRA {
-	return func(t0 T0) GRA {
-		return MakeReader[GRA](func(r C) R {
-			return f(r, t0)
-		})
-	}
+  return func(t0 T0) GRA {
+    return MakeReader[GRA](func(r C) R {
+      return f(r, t0)
+    })
+  }
 }
 
 // From2 converts a function with 3 parameters returning a [R] into a function with 2 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From2[GRA ~func(C) R, F ~func(C, T0, T1) R, T0, T1, C, R any](f F) func(T0, T1) GRA {
-	return func(t0 T0, t1 T1) GRA {
-		return MakeReader[GRA](func(r C) R {
-			return f(r, t0, t1)
-		})
-	}
+  return func(t0 T0, t1 T1) GRA {
+    return MakeReader[GRA](func(r C) R {
+      return f(r, t0, t1)
+    })
+  }
 }
 
 // From3 converts a function with 4 parameters returning a [R] into a function with 3 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From3[GRA ~func(C) R, F ~func(C, T0, T1, T2) R, T0, T1, T2, C, R any](f F) func(T0, T1, T2) GRA {
-	return func(t0 T0, t1 T1, t2 T2) GRA {
-		return MakeReader[GRA](func(r C) R {
-			return f(r, t0, t1, t2)
-		})
-	}
+  return func(t0 T0, t1 T1, t2 T2) GRA {
+    return MakeReader[GRA](func(r C) R {
+      return f(r, t0, t1, t2)
+    })
+  }
 }
 
 // From4 converts a function with 5 parameters returning a [R] into a function with 4 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From4[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3) R, T0, T1, T2, T3, C, R any](f F) func(T0, T1, T2, T3) GRA {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3) GRA {
-		return MakeReader[GRA](func(r C) R {
-			return f(r, t0, t1, t2, t3)
-		})
-	}
+  return func(t0 T0, t1 T1, t2 T2, t3 T3) GRA {
+    return MakeReader[GRA](func(r C) R {
+      return f(r, t0, t1, t2, t3)
+    })
+  }
 }
 
 // From5 converts a function with 6 parameters returning a [R] into a function with 5 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From5[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3, T4) R, T0, T1, T2, T3, T4, C, R any](f F) func(T0, T1, T2, T3, T4) GRA {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) GRA {
-		return MakeReader[GRA](func(r C) R {
-			return f(r, t0, t1, t2, t3, t4)
-		})
-	}
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) GRA {
+    return MakeReader[GRA](func(r C) R {
+      return f(r, t0, t1, t2, t3, t4)
+    })
+  }
 }
 
 // From6 converts a function with 7 parameters returning a [R] into a function with 6 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From6[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3, T4, T5) R, T0, T1, T2, T3, T4, T5, C, R any](f F) func(T0, T1, T2, T3, T4, T5) GRA {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) GRA {
-		return MakeReader[GRA](func(r C) R {
-			return f(r, t0, t1, t2, t3, t4, t5)
-		})
-	}
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) GRA {
+    return MakeReader[GRA](func(r C) R {
+      return f(r, t0, t1, t2, t3, t4, t5)
+    })
+  }
 }
 
 // From7 converts a function with 8 parameters returning a [R] into a function with 7 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From7[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3, T4, T5, T6) R, T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) GRA {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) GRA {
-		return MakeReader[GRA](func(r C) R {
-			return f(r, t0, t1, t2, t3, t4, t5, t6)
-		})
-	}
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) GRA {
+    return MakeReader[GRA](func(r C) R {
+      return f(r, t0, t1, t2, t3, t4, t5, t6)
+    })
+  }
 }
 
 // From8 converts a function with 9 parameters returning a [R] into a function with 8 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From8[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) R, T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) GRA {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) GRA {
-		return MakeReader[GRA](func(r C) R {
-			return f(r, t0, t1, t2, t3, t4, t5, t6, t7)
-		})
-	}
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) GRA {
+    return MakeReader[GRA](func(r C) R {
+      return f(r, t0, t1, t2, t3, t4, t5, t6, t7)
+    })
+  }
 }
 
 // From9 converts a function with 10 parameters returning a [R] into a function with 9 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From9[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) 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 {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) GRA {
-		return MakeReader[GRA](func(r C) R {
-			return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8)
-		})
-	}
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) GRA {
+    return MakeReader[GRA](func(r C) R {
+      return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8)
+    })
+  }
 }
 
 // From10 converts a function with 11 parameters returning a [R] into a function with 10 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From10[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) 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 {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) GRA {
-		return MakeReader[GRA](func(r C) R {
-			return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
-		})
-	}
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) GRA {
+    return MakeReader[GRA](func(r C) R {
+      return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+    })
+  }
 }

readereither/array.go

@@ -24,6 +24,11 @@ func TraverseArray[E, L, A, B any](f func(A) ReaderEither[E, L, B]) func([]A) Re
 	return G.TraverseArray[ReaderEither[E, L, B], ReaderEither[E, L, []B], []A](f)
 }
 
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[E, L, A, B any](f func(int, A) ReaderEither[E, L, B]) func([]A) ReaderEither[E, L, []B] {
+	return G.TraverseArrayWithIndex[ReaderEither[E, L, B], ReaderEither[E, L, []B], []A](f)
+}
+
 // SequenceArray converts a homogeneous sequence of either into an either of sequence
 func SequenceArray[E, L, A any](ma []ReaderEither[E, L, A]) ReaderEither[E, L, []A] {
 	return G.SequenceArray[ReaderEither[E, L, A], ReaderEither[E, L, []A]](ma)

readereither/generic/array.go

@@ -43,6 +43,17 @@ func TraverseArray[GB ~func(E) ET.Either[L, B], GBS ~func(E) ET.Either[L, BBS],
 	)
 }
 
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[GB ~func(E) ET.Either[L, B], GBS ~func(E) ET.Either[L, BBS], AAS ~[]A, BBS ~[]B, L, E, A, B any](f func(int, A) GB) func(AAS) GBS {
+	return RA.TraverseWithIndex[AAS](
+		Of[GBS, L, E, BBS],
+		Map[GBS, func(E) ET.Either[L, func(B) BBS], L, E, BBS, func(B) BBS],
+		Ap[GB, GBS, func(E) ET.Either[L, func(B) BBS], L, E, B, BBS],
+
+		f,
+	)
+}
+
 // SequenceArray converts a homogeneous sequence of either into an either of sequence
 func SequenceArray[GA ~func(E) ET.Either[L, A], GAS ~func(E) ET.Either[L, AAS], AAS ~[]A, GAAS ~[]GA, L, E, A any](ma GAAS) GAS {
 	return MonadTraverseArray[GA, GAS](ma, F.Identity[GA])

readereither/reader.go

@@ -32,7 +32,7 @@ func FromEither[E, L, A any](e ET.Either[L, A]) ReaderEither[E, L, A] {
 	return G.FromEither[ReaderEither[E, L, A]](e)
 }
 
-func RightReader[E, L, A any](r R.Reader[E, A]) ReaderEither[E, L, A] {
+func RightReader[L, E, A any](r R.Reader[E, A]) ReaderEither[E, L, A] {
 	return G.RightReader[R.Reader[E, A], ReaderEither[E, L, A]](r)
 }
 
@@ -76,7 +76,7 @@ func MonadAp[E, L, A, B any](fab ReaderEither[E, L, func(A) B], fa ReaderEither[
 	return G.MonadAp[ReaderEither[E, L, A], ReaderEither[E, L, B], ReaderEither[E, L, func(A) B]](fab, fa)
 }
 
-func Ap[E, L, A, B any](fa ReaderEither[E, L, A]) func(ReaderEither[E, L, func(A) B]) ReaderEither[E, L, B] {
+func Ap[B, E, L, A any](fa ReaderEither[E, L, A]) func(ReaderEither[E, L, func(A) B]) ReaderEither[E, L, B] {
 	return G.Ap[ReaderEither[E, L, A], ReaderEither[E, L, B], ReaderEither[E, L, func(A) B]](fa)
 }
 
@@ -96,7 +96,7 @@ func OrElse[E, L1, A, L2 any](onLeft func(L1) ReaderEither[E, L2, A]) func(Reade
 	return G.OrElse[ReaderEither[E, L1, A]](onLeft)
 }
 
-func OrLeft[L1, E, L2, A any](onLeft func(L1) R.Reader[E, L2]) func(ReaderEither[E, L1, A]) ReaderEither[E, L2, A] {
+func OrLeft[A, L1, E, L2 any](onLeft func(L1) R.Reader[E, L2]) func(ReaderEither[E, L1, A]) ReaderEither[E, L2, A] {
 	return G.OrLeft[ReaderEither[E, L1, A], ReaderEither[E, L2, A]](onLeft)
 }
 
@@ -104,19 +104,19 @@ func Ask[E, L any]() ReaderEither[E, L, E] {
 	return G.Ask[ReaderEither[E, L, E]]()
 }
 
-func Asks[E, L, A any](r R.Reader[E, A]) ReaderEither[E, L, A] {
+func Asks[L, E, A any](r R.Reader[E, A]) ReaderEither[E, L, A] {
 	return G.Asks[R.Reader[E, A], ReaderEither[E, L, A]](r)
 }
 
-func MonadChainEitherK[E, L, A, B any](ma ReaderEither[E, L, A], f func(A) ET.Either[L, B]) ReaderEither[E, L, B] {
+func MonadChainEitherK[A, B, L, E any](ma ReaderEither[E, L, A], f func(A) ET.Either[L, B]) ReaderEither[E, L, B] {
 	return G.MonadChainEitherK[ReaderEither[E, L, A], ReaderEither[E, L, B]](ma, f)
 }
 
-func ChainEitherK[E, L, A, B any](f func(A) ET.Either[L, B]) func(ma ReaderEither[E, L, A]) ReaderEither[E, L, B] {
+func ChainEitherK[A, B, L, E any](f func(A) ET.Either[L, B]) func(ma ReaderEither[E, L, A]) ReaderEither[E, L, B] {
 	return G.ChainEitherK[ReaderEither[E, L, A], ReaderEither[E, L, B]](f)
 }
 
-func ChainOptionK[E, L, A, B any](onNone func() L) func(func(A) O.Option[B]) func(ReaderEither[E, L, A]) ReaderEither[E, L, B] {
+func ChainOptionK[E, A, B, L any](onNone func() L) func(func(A) O.Option[B]) func(ReaderEither[E, L, A]) ReaderEither[E, L, B] {
 	return G.ChainOptionK[ReaderEither[E, L, A], ReaderEither[E, L, B]](onNone)
 }
 
@@ -135,11 +135,11 @@ func BiMap[E, E1, E2, A, B any](f func(E1) E2, g func(A) B) func(ReaderEither[E,
 
 // Local changes the value of the local context during the execution of the action `ma` (similar to `Contravariant`'s
 // `contramap`).
-func Local[R2, R1, E, A any](f func(R2) R1) func(ReaderEither[R1, E, A]) ReaderEither[R2, E, A] {
+func Local[E, A, R2, R1 any](f func(R2) R1) func(ReaderEither[R1, E, A]) ReaderEither[R2, E, A] {
 	return G.Local[ReaderEither[R1, E, A], ReaderEither[R2, E, A]](f)
 }
 
 // Read applies a context to a reader to obtain its value
-func Read[E, E1, A any](e E) func(ReaderEither[E, E1, A]) ET.Either[E1, A] {
+func Read[E1, A, E any](e E) func(ReaderEither[E, E1, A]) ET.Either[E1, A] {
 	return G.Read[ReaderEither[E, E1, A]](e)
 }

readereither/reader_test.go

@@ -42,7 +42,7 @@ func TestMap(t *testing.T) {
 func TestAp(t *testing.T) {
 	g := F.Pipe1(
 		Of[MyContext, error](utils.Double),
-		Ap[MyContext, error, int, int](Of[MyContext, error](1)),
+		Ap[int](Of[MyContext, error](1)),
 	)
 	assert.Equal(t, ET.Of[error](2), g(defaultContext))
 

readerio/array.go

@@ -25,6 +25,11 @@ func TraverseArray[R, A, B any](f func(A) ReaderIO[R, B]) func([]A) ReaderIO[R,
 	return G.TraverseArray[ReaderIO[R, B], ReaderIO[R, []B], IO.IO[B], IO.IO[[]B], []A](f)
 }
 
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[R, A, B any](f func(int, A) ReaderIO[R, B]) func([]A) ReaderIO[R, []B] {
+	return G.TraverseArrayWithIndex[ReaderIO[R, B], ReaderIO[R, []B], IO.IO[B], IO.IO[[]B], []A](f)
+}
+
 // SequenceArray converts a homogeneous sequence of Readers into a Reader of sequence
 func SequenceArray[R, A any](ma []ReaderIO[R, A]) ReaderIO[R, []A] {
 	return G.SequenceArray[ReaderIO[R, A], ReaderIO[R, []A]](ma)

readerio/generic/array.go

@@ -42,6 +42,17 @@ func TraverseArray[GB ~func(E) GIOB, GBS ~func(E) GIOBS, GIOB ~func() B, GIOBS ~
 	)
 }
 
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[GB ~func(E) GIOB, GBS ~func(E) GIOBS, GIOB ~func() B, GIOBS ~func() BBS, AAS ~[]A, BBS ~[]B, E, A, B any](f func(int, A) GB) func(AAS) GBS {
+	return RA.TraverseWithIndex[AAS](
+		Of[GBS, GIOBS, E, BBS],
+		Map[GBS, func(E) func() func(B) BBS, GIOBS, func() func(B) BBS, E, BBS, func(B) BBS],
+		Ap[GB, GBS, func(E) func() func(B) BBS, GIOB, GIOBS, func() func(B) BBS, E, B, BBS],
+
+		f,
+	)
+}
+
 // SequenceArray converts a homogeneous sequence of either into an either of sequence
 func SequenceArray[GA ~func(E) GIOA, GAS ~func(E) GIOAS, GIOA ~func() A, GIOAS ~func() AAS, AAS ~[]A, GAAS ~[]GA, E, A any](ma GAAS) GAS {
 	return MonadTraverseArray[GA, GAS](ma, F.Identity[GA])

readerioeither/gen.go

@@ -1,141 +1,142 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-08-17 22:59:21.3704716 +0200 CEST m=+0.110126101
+// 2023-09-12 13:44:37.5566477 +0200 CEST m=+0.009011201
 
 package readerioeither
 
+
 import (
-	G "github.com/IBM/fp-go/readerioeither/generic"
+	G "github.com/IBM/fp-go/readerioeither/generic"	
 )
 
 // From0 converts a function with 1 parameters returning a tuple into a function with 0 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From0[F ~func(C) func() (R, error), C, R any](f F) func() ReaderIOEither[C, error, R] {
-	return G.From0[ReaderIOEither[C, error, R]](f)
+  return G.From0[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize0 converts a function with 1 parameters returning a tuple into a function with 0 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize0[F ~func(C) (R, error), C, R any](f F) func() ReaderIOEither[C, error, R] {
-	return G.Eitherize0[ReaderIOEither[C, error, R]](f)
+  return G.Eitherize0[ReaderIOEither[C, error, R]](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] {
-	return G.From1[ReaderIOEither[C, error, R]](f)
+  return G.From1[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize1 converts a function with 2 parameters returning a tuple into a function with 1 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize1[F ~func(C, T0) (R, error), T0, C, R any](f F) func(T0) ReaderIOEither[C, error, R] {
-	return G.Eitherize1[ReaderIOEither[C, error, R]](f)
+  return G.Eitherize1[ReaderIOEither[C, error, R]](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] {
-	return G.From2[ReaderIOEither[C, error, R]](f)
+  return G.From2[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize2 converts a function with 3 parameters returning a tuple into a function with 2 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize2[F ~func(C, T0, T1) (R, error), T0, T1, C, R any](f F) func(T0, T1) ReaderIOEither[C, error, R] {
-	return G.Eitherize2[ReaderIOEither[C, error, R]](f)
+  return G.Eitherize2[ReaderIOEither[C, error, R]](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] {
-	return G.From3[ReaderIOEither[C, error, R]](f)
+  return G.From3[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize3 converts a function with 4 parameters returning a tuple into a function with 3 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize3[F ~func(C, T0, T1, T2) (R, error), T0, T1, T2, C, R any](f F) func(T0, T1, T2) ReaderIOEither[C, error, R] {
-	return G.Eitherize3[ReaderIOEither[C, error, R]](f)
+  return G.Eitherize3[ReaderIOEither[C, error, R]](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] {
-	return G.From4[ReaderIOEither[C, error, R]](f)
+  return G.From4[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize4 converts a function with 5 parameters returning a tuple into a function with 4 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize4[F ~func(C, T0, T1, T2, T3) (R, error), T0, T1, T2, T3, C, R any](f F) func(T0, T1, T2, T3) ReaderIOEither[C, error, R] {
-	return G.Eitherize4[ReaderIOEither[C, error, R]](f)
+  return G.Eitherize4[ReaderIOEither[C, error, R]](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] {
-	return G.From5[ReaderIOEither[C, error, R]](f)
+  return G.From5[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize5 converts a function with 6 parameters returning a tuple into a function with 5 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize5[F ~func(C, T0, T1, T2, T3, T4) (R, error), T0, T1, T2, T3, T4, C, R any](f F) func(T0, T1, T2, T3, T4) ReaderIOEither[C, error, R] {
-	return G.Eitherize5[ReaderIOEither[C, error, R]](f)
+  return G.Eitherize5[ReaderIOEither[C, error, R]](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] {
-	return G.From6[ReaderIOEither[C, error, R]](f)
+  return G.From6[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize6 converts a function with 7 parameters returning a tuple into a function with 6 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize6[F ~func(C, T0, T1, T2, T3, T4, T5) (R, error), T0, T1, T2, T3, T4, T5, C, R any](f F) func(T0, T1, T2, T3, T4, T5) ReaderIOEither[C, error, R] {
-	return G.Eitherize6[ReaderIOEither[C, error, R]](f)
+  return G.Eitherize6[ReaderIOEither[C, error, R]](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] {
-	return G.From7[ReaderIOEither[C, error, R]](f)
+  return G.From7[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize7 converts a function with 8 parameters returning a tuple into a function with 7 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize7[F ~func(C, T0, T1, T2, T3, T4, T5, T6) (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] {
-	return G.Eitherize7[ReaderIOEither[C, error, R]](f)
+  return G.Eitherize7[ReaderIOEither[C, error, R]](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] {
-	return G.From8[ReaderIOEither[C, error, R]](f)
+  return G.From8[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize8 converts a function with 9 parameters returning a tuple into a function with 8 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize8[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) (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] {
-	return G.Eitherize8[ReaderIOEither[C, error, R]](f)
+  return G.Eitherize8[ReaderIOEither[C, error, R]](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] {
-	return G.From9[ReaderIOEither[C, error, R]](f)
+  return G.From9[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize9 converts a function with 10 parameters returning a tuple into a function with 9 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize9[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) (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] {
-	return G.Eitherize9[ReaderIOEither[C, error, R]](f)
+  return G.Eitherize9[ReaderIOEither[C, error, R]](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] {
-	return G.From10[ReaderIOEither[C, error, R]](f)
+  return G.From10[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize10 converts a function with 11 parameters returning a tuple into a function with 10 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 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)
+  return G.Eitherize10[ReaderIOEither[C, error, R]](f)
 }

readerioeither/generic/gen.go

@@ -1,8 +1,9 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-08-17 22:59:21.3811525 +0200 CEST m=+0.120807001
+// 2023-09-12 13:44:37.5566477 +0200 CEST m=+0.009011201
 package generic
 
+
 import (
 	E "github.com/IBM/fp-go/either"
 	RD "github.com/IBM/fp-go/reader/generic"
@@ -11,197 +12,186 @@ import (
 // From0 converts a function with 1 parameters returning a tuple into a function with 0 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From0[GRA ~func(C) GIOA, F ~func(C) func() (R, error), GIOA ~func() E.Either[error, R], C, R any](f F) func() GRA {
-	return RD.From0[GRA](func(r C) GIOA {
-		return E.Eitherize0(f(r))
-	})
+  return RD.From0[GRA](func(r C) GIOA {
+    return E.Eitherize0(f(r))
+  })
 }
 
 // Eitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func Eitherize0[GRA ~func(C) GIOA, F ~func(C) (R, error), GIOA ~func() E.Either[error, R], C, R any](f F) func() GRA {
-	return From0[GRA](func(r C) func() (R, error) {
-		return func() (R, error) {
-			return f(r)
-		}
-	})
+  return From0[GRA](func(r C) func() (R, error) {
+    return func() (R, error) {
+      return f(r)
+    }})
 }
 
 // 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 {
-	return RD.From1[GRA](func(r C, t0 T0) GIOA {
-		return E.Eitherize0(f(r, t0))
-	})
+  return RD.From1[GRA](func(r C, t0 T0) GIOA {
+    return E.Eitherize0(f(r, t0))
+  })
 }
 
 // Eitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func Eitherize1[GRA ~func(C) GIOA, F ~func(C, T0) (R, error), GIOA ~func() E.Either[error, R], T0, C, R any](f F) func(T0) GRA {
-	return From1[GRA](func(r C, t0 T0) func() (R, error) {
-		return func() (R, error) {
-			return f(r, t0)
-		}
-	})
+  return From1[GRA](func(r C, t0 T0) func() (R, error) {
+    return func() (R, error) {
+      return f(r, t0)
+    }})
 }
 
 // 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 {
-	return RD.From2[GRA](func(r C, t0 T0, t1 T1) GIOA {
-		return E.Eitherize0(f(r, t0, t1))
-	})
+  return RD.From2[GRA](func(r C, t0 T0, t1 T1) GIOA {
+    return E.Eitherize0(f(r, t0, t1))
+  })
 }
 
 // Eitherize2 converts a function with 2 parameters returning a tuple into a function with 2 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func Eitherize2[GRA ~func(C) GIOA, F ~func(C, T0, T1) (R, error), GIOA ~func() E.Either[error, R], T0, T1, C, R any](f F) func(T0, T1) GRA {
-	return From2[GRA](func(r C, t0 T0, t1 T1) func() (R, error) {
-		return func() (R, error) {
-			return f(r, t0, t1)
-		}
-	})
+  return From2[GRA](func(r C, t0 T0, t1 T1) func() (R, error) {
+    return func() (R, error) {
+      return f(r, t0, t1)
+    }})
 }
 
 // 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 {
-	return RD.From3[GRA](func(r C, t0 T0, t1 T1, t2 T2) GIOA {
-		return E.Eitherize0(f(r, t0, t1, t2))
-	})
+  return RD.From3[GRA](func(r C, t0 T0, t1 T1, t2 T2) GIOA {
+    return E.Eitherize0(f(r, t0, t1, t2))
+  })
 }
 
 // Eitherize3 converts a function with 3 parameters returning a tuple into a function with 3 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func Eitherize3[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 F) func(T0, T1, T2) GRA {
-	return From3[GRA](func(r C, t0 T0, t1 T1, t2 T2) func() (R, error) {
-		return func() (R, error) {
-			return f(r, t0, t1, t2)
-		}
-	})
+  return From3[GRA](func(r C, t0 T0, t1 T1, t2 T2) func() (R, error) {
+    return func() (R, error) {
+      return f(r, t0, t1, t2)
+    }})
 }
 
 // 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 {
-	return RD.From4[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3) GIOA {
-		return E.Eitherize0(f(r, t0, t1, t2, t3))
-	})
+  return RD.From4[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3) GIOA {
+    return E.Eitherize0(f(r, t0, t1, t2, t3))
+  })
 }
 
 // Eitherize4 converts a function with 4 parameters returning a tuple into a function with 4 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func Eitherize4[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 F) func(T0, T1, T2, T3) GRA {
-	return From4[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3) func() (R, error) {
-		return func() (R, error) {
-			return f(r, t0, t1, t2, t3)
-		}
-	})
+  return From4[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3) func() (R, error) {
+    return func() (R, error) {
+      return f(r, t0, t1, t2, t3)
+    }})
 }
 
 // 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 {
-	return RD.From5[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) GIOA {
-		return E.Eitherize0(f(r, t0, t1, t2, t3, t4))
-	})
+  return RD.From5[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) GIOA {
+    return E.Eitherize0(f(r, t0, t1, t2, t3, t4))
+  })
 }
 
 // Eitherize5 converts a function with 5 parameters returning a tuple into a function with 5 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func Eitherize5[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 F) func(T0, T1, T2, T3, T4) GRA {
-	return From5[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) func() (R, error) {
-		return func() (R, error) {
-			return f(r, t0, t1, t2, t3, t4)
-		}
-	})
+  return From5[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) func() (R, error) {
+    return func() (R, error) {
+      return f(r, t0, t1, t2, t3, t4)
+    }})
 }
 
 // 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 {
-	return RD.From6[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) GIOA {
-		return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5))
-	})
+  return RD.From6[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) GIOA {
+    return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5))
+  })
 }
 
 // Eitherize6 converts a function with 6 parameters returning a tuple into a function with 6 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func Eitherize6[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 F) func(T0, T1, T2, T3, T4, T5) GRA {
-	return From6[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) func() (R, error) {
-		return func() (R, error) {
-			return f(r, t0, t1, t2, t3, t4, t5)
-		}
-	})
+  return From6[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) func() (R, error) {
+    return func() (R, error) {
+      return f(r, t0, t1, t2, t3, t4, t5)
+    }})
 }
 
 // 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 {
-	return RD.From7[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) GIOA {
-		return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6))
-	})
+  return RD.From7[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) GIOA {
+    return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6))
+  })
 }
 
 // Eitherize7 converts a function with 7 parameters returning a tuple into a function with 7 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func Eitherize7[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 F) func(T0, T1, T2, T3, T4, T5, T6) GRA {
-	return From7[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) func() (R, error) {
-		return func() (R, error) {
-			return f(r, t0, t1, t2, t3, t4, t5, t6)
-		}
-	})
+  return From7[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) func() (R, error) {
+    return func() (R, error) {
+      return f(r, t0, t1, t2, t3, t4, t5, t6)
+    }})
 }
 
 // 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 {
-	return RD.From8[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) GIOA {
-		return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6, t7))
-	})
+  return RD.From8[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) GIOA {
+    return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6, t7))
+  })
 }
 
 // Eitherize8 converts a function with 8 parameters returning a tuple into a function with 8 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func Eitherize8[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 F) func(T0, T1, T2, T3, T4, T5, T6, T7) GRA {
-	return From8[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) func() (R, error) {
-		return func() (R, error) {
-			return f(r, t0, t1, t2, t3, t4, t5, t6, t7)
-		}
-	})
+  return From8[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) func() (R, error) {
+    return func() (R, error) {
+      return f(r, t0, t1, t2, t3, t4, t5, t6, t7)
+    }})
 }
 
 // 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 {
-	return RD.From9[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) GIOA {
-		return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8))
-	})
+  return RD.From9[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) GIOA {
+    return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8))
+  })
 }
 
 // Eitherize9 converts a function with 9 parameters returning a tuple into a function with 9 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func Eitherize9[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 F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) GRA {
-	return From9[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) func() (R, error) {
-		return func() (R, error) {
-			return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8)
-		}
-	})
+  return From9[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) func() (R, error) {
+    return func() (R, error) {
+      return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8)
+    }})
 }
 
 // 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 {
-	return RD.From10[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) GIOA {
-		return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9))
-	})
+  return RD.From10[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) GIOA {
+    return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9))
+  })
 }
 
 // Eitherize10 converts a function with 10 parameters returning a tuple into a function with 10 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func Eitherize10[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 F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) GRA {
-	return From10[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) func() (R, error) {
-		return func() (R, error) {
-			return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
-		}
-	})
+  return From10[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) func() (R, error) {
+    return func() (R, error) {
+      return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+    }})
 }

readerioeither/generic/traverse.go

@@ -44,6 +44,17 @@ func TraverseArray[GB ~func(E) GIOB, GBS ~func(E) GIOBS, GIOB ~func() ET.Either[
 	)
 }
 
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[GB ~func(E) GIOB, GBS ~func(E) GIOBS, GIOB ~func() ET.Either[L, B], GIOBS ~func() ET.Either[L, BBS], AAS ~[]A, BBS ~[]B, E, L, A, B any](f func(int, A) GB) func(AAS) GBS {
+	return RA.TraverseWithIndex[AAS](
+		Of[GBS, GIOBS, E, L, BBS],
+		Map[GBS, func(E) func() ET.Either[L, func(B) BBS], GIOBS, func() ET.Either[L, func(B) BBS], E, L, BBS, func(B) BBS],
+		Ap[GB, GBS, func(E) func() ET.Either[L, func(B) BBS], GIOB, GIOBS, func() ET.Either[L, func(B) BBS], E, L, B, BBS],
+
+		f,
+	)
+}
+
 // SequenceArray converts a homogeneous sequence of either into an either of sequence
 func SequenceArray[GA ~func(E) GIOA, GAS ~func(E) GIOAS, GIOA ~func() ET.Either[L, A], GIOAS ~func() ET.Either[L, AAS], AAS ~[]A, GAAS ~[]GA, E, L, A any](ma GAAS) GAS {
 	return MonadTraverseArray[GA, GAS](ma, F.Identity[GA])
@@ -61,7 +72,7 @@ func MonadTraverseRecord[GB ~func(C) GIOB, GBS ~func(C) GIOBS, GIOB ~func() ET.E
 	)
 }
 
-// TraverseRecord transforms an array
+// TraverseRecord transforms a record
 func TraverseRecord[GB ~func(C) GIOB, GBS ~func(C) GIOBS, GIOB ~func() ET.Either[E, B], GIOBS ~func() ET.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, C, E, A, B any](f func(A) GB) func(AAS) GBS {
 	return RR.Traverse[AAS](
 		Of[GBS, GIOBS, C, E, BBS],
@@ -72,6 +83,17 @@ func TraverseRecord[GB ~func(C) GIOB, GBS ~func(C) GIOBS, GIOB ~func() ET.Either
 	)
 }
 
+// TraverseRecordWithIndex transforms a record
+func TraverseRecordWithIndex[GB ~func(C) GIOB, GBS ~func(C) GIOBS, GIOB ~func() ET.Either[E, B], GIOBS ~func() ET.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, C, E, A, B any](f func(K, A) GB) func(AAS) GBS {
+	return RR.TraverseWithIndex[AAS](
+		Of[GBS, GIOBS, C, E, BBS],
+		Map[GBS, func(C) func() ET.Either[E, func(B) BBS], GIOBS, func() ET.Either[E, func(B) BBS], C, E, BBS, func(B) BBS],
+		Ap[GB, GBS, func(C) func() ET.Either[E, func(B) BBS], GIOB, GIOBS, func() ET.Either[E, func(B) BBS], C, E, B, BBS],
+
+		f,
+	)
+}
+
 // SequenceRecord converts a homogeneous sequence of either into an either of sequence
 func SequenceRecord[GA ~func(C) GIOA, GAS ~func(C) GIOAS, GIOA ~func() ET.Either[E, A], GIOAS ~func() ET.Either[E, AAS], AAS ~map[K]A, GAAS ~map[K]GA, K comparable, C, E, A any](tas GAAS) GAS {
 	return MonadTraverseRecord[GA, GAS](tas, F.Identity[GA])

readerioeither/reader.go

@@ -93,7 +93,7 @@ func MonadChainReaderK[R, E, A, B any](ma ReaderIOEither[R, E, A], f func(A) RD.
 	return G.MonadChainReaderK[ReaderIOEither[R, E, A], ReaderIOEither[R, E, B]](ma, f)
 }
 
-func ChainReaderK[R, E, A, B any](f func(A) RD.Reader[R, B]) func(ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B] {
+func ChainReaderK[E, R, A, B any](f func(A) RD.Reader[R, B]) func(ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B] {
 	return G.ChainReaderK[ReaderIOEither[R, E, A], ReaderIOEither[R, E, B]](f)
 }
 
@@ -121,7 +121,7 @@ func ChainFirstIOK[R, E, A, B any](f func(A) io.IO[B]) func(ma ReaderIOEither[R,
 	return G.ChainFirstIOK[ReaderIOEither[R, E, A]](f)
 }
 
-func ChainOptionK[R, E, A, B any](onNone func() E) func(func(A) O.Option[B]) func(ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B] {
+func ChainOptionK[R, A, B, E any](onNone func() E) func(func(A) O.Option[B]) func(ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B] {
 	return G.ChainOptionK[ReaderIOEither[R, E, A], ReaderIOEither[R, E, B]](onNone)
 }
 
@@ -149,7 +149,7 @@ func Left[R, A, E any](e E) ReaderIOEither[R, E, A] {
 	return G.Left[ReaderIOEither[R, E, A]](e)
 }
 
-func ThrowError[R, E, A any](e E) ReaderIOEither[R, E, A] {
+func ThrowError[R, A, E any](e E) ReaderIOEither[R, E, A] {
 	return G.ThrowError[ReaderIOEither[R, E, A]](e)
 }
 
@@ -166,7 +166,7 @@ func FromEither[R, E, A any](t ET.Either[E, A]) ReaderIOEither[R, E, A] {
 	return G.FromEither[ReaderIOEither[R, E, A]](t)
 }
 
-func RightReader[R, E, A any](ma RD.Reader[R, A]) ReaderIOEither[R, E, A] {
+func RightReader[E, R, A any](ma RD.Reader[R, A]) ReaderIOEither[R, E, A] {
 	return G.RightReader[RD.Reader[R, A], ReaderIOEither[R, E, A]](ma)
 }
 
@@ -174,7 +174,7 @@ func LeftReader[A, R, E any](ma RD.Reader[R, E]) ReaderIOEither[R, E, A] {
 	return G.LeftReader[RD.Reader[R, E], ReaderIOEither[R, E, A]](ma)
 }
 
-func FromReader[R, E, A any](ma RD.Reader[R, A]) ReaderIOEither[R, E, A] {
+func FromReader[E, R, A any](ma RD.Reader[R, A]) ReaderIOEither[R, E, A] {
 	return G.FromReader[RD.Reader[R, A], ReaderIOEither[R, E, A]](ma)
 }
 
@@ -202,11 +202,11 @@ func Ask[R, E any]() ReaderIOEither[R, E, R] {
 	return G.Ask[ReaderIOEither[R, E, R]]()
 }
 
-func Asks[R, E, A any](r RD.Reader[R, A]) ReaderIOEither[R, E, A] {
+func Asks[E, R, A any](r RD.Reader[R, A]) ReaderIOEither[R, E, A] {
 	return G.Asks[RD.Reader[R, A], ReaderIOEither[R, E, A]](r)
 }
 
-func FromOption[R, E, A any](onNone func() E) func(O.Option[A]) ReaderIOEither[R, E, A] {
+func FromOption[R, A, E any](onNone func() E) func(O.Option[A]) ReaderIOEither[R, E, A] {
 	return G.FromOption[ReaderIOEither[R, E, A]](onNone)
 }
 
@@ -226,7 +226,7 @@ func OrElse[R, E1, A, E2 any](onLeft func(E1) ReaderIOEither[R, E2, A]) func(Rea
 	return G.OrElse[ReaderIOEither[R, E1, A]](onLeft)
 }
 
-func OrLeft[E1, R, E2, A any](onLeft func(E1) RIO.ReaderIO[R, E2]) func(ReaderIOEither[R, E1, A]) ReaderIOEither[R, E2, A] {
+func OrLeft[A, E1, R, E2 any](onLeft func(E1) RIO.ReaderIO[R, E2]) func(ReaderIOEither[R, E1, A]) ReaderIOEither[R, E2, A] {
 	return G.OrLeft[ReaderIOEither[R, E1, A], RIO.ReaderIO[R, E2], ReaderIOEither[R, E2, A]](onLeft)
 }
 

readerioeither/reader_test.go

@@ -39,7 +39,7 @@ func TestMap(t *testing.T) {
 }
 
 func TestOrLeft(t *testing.T) {
-	f := OrLeft[string, context.Context, string, int](func(s string) RIO.ReaderIO[context.Context, string] {
+	f := OrLeft[int](func(s string) RIO.ReaderIO[context.Context, string] {
 		return RIO.Of[context.Context](s + "!")
 	})
 
@@ -70,7 +70,7 @@ func TestChainReaderK(t *testing.T) {
 
 	g := F.Pipe1(
 		Of[context.Context, error](1),
-		ChainReaderK[context.Context, error](func(v int) R.Reader[context.Context, string] {
+		ChainReaderK[error](func(v int) R.Reader[context.Context, string] {
 			return R.Of[context.Context](fmt.Sprintf("%d", v))
 		}),
 	)

readerioeither/traverse.go

@@ -25,6 +25,11 @@ func TraverseArray[R, E, A, B any](f func(A) ReaderIOEither[R, E, B]) func([]A)
 	return G.TraverseArray[ReaderIOEither[R, E, B], ReaderIOEither[R, E, []B], IOE.IOEither[E, B], IOE.IOEither[E, []B], []A](f)
 }
 
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[R, E, A, B any](f func(int, A) ReaderIOEither[R, E, B]) func([]A) ReaderIOEither[R, E, []B] {
+	return G.TraverseArrayWithIndex[ReaderIOEither[R, E, B], ReaderIOEither[R, E, []B], IOE.IOEither[E, B], IOE.IOEither[E, []B], []A](f)
+}
+
 // SequenceArray converts a homogeneous sequence of Readers into a Reader of a sequence
 func SequenceArray[R, E, A any](ma []ReaderIOEither[R, E, A]) ReaderIOEither[R, E, []A] {
 	return G.SequenceArray[ReaderIOEither[R, E, A], ReaderIOEither[R, E, []A]](ma)
@@ -35,6 +40,11 @@ func TraverseRecord[R any, K comparable, E, A, B any](f func(A) ReaderIOEither[R
 	return G.TraverseRecord[ReaderIOEither[R, E, B], ReaderIOEither[R, E, map[K]B], IOE.IOEither[E, B], IOE.IOEither[E, map[K]B], map[K]A](f)
 }
 
+// TraverseRecordWithIndex transforms an array
+func TraverseRecordWithIndex[R any, K comparable, E, A, B any](f func(K, A) ReaderIOEither[R, E, B]) func(map[K]A) ReaderIOEither[R, E, map[K]B] {
+	return G.TraverseRecordWithIndex[ReaderIOEither[R, E, B], ReaderIOEither[R, E, map[K]B], IOE.IOEither[E, B], IOE.IOEither[E, map[K]B], map[K]A](f)
+}
+
 // SequenceRecord converts a homogeneous sequence of Readers into a Reader of a sequence
 func SequenceRecord[R any, K comparable, E, A any](ma map[K]ReaderIOEither[R, E, A]) ReaderIOEither[R, E, map[K]A] {
 	return G.SequenceRecord[ReaderIOEither[R, E, A], ReaderIOEither[R, E, map[K]A]](ma)

record/generic/record.go

@@ -186,6 +186,13 @@ func MapRefWithIndex[M ~map[K]V, N ~map[K]R, K comparable, V, R any](f func(K, *
 	return F.Bind2nd(MonadMapRefWithIndex[M, N, K, V, R], f)
 }
 
+func MonadLookup[M ~map[K]V, K comparable, V any](m M, k K) O.Option[V] {
+	if val, ok := m[k]; ok {
+		return O.Some(val)
+	}
+	return O.None[V]()
+}
+
 func Lookup[M ~map[K]V, K comparable, V any](k K) func(M) O.Option[V] {
 	n := O.None[V]()
 	return func(m M) O.Option[V] {

record/record.go

@@ -102,6 +102,11 @@ func Lookup[V any, K comparable](k K) func(map[K]V) O.Option[V] {
 	return G.Lookup[map[K]V](k)
 }
 
+// MonadLookup returns the entry for a key in a map if it exists
+func MonadLookup[V any, K comparable](m map[K]V, k K) O.Option[V] {
+	return G.MonadLookup[map[K]V](m, k)
+}
+
 // Has tests if a key is contained in a map
 func Has[K comparable, V any](k K, r map[K]V) bool {
 	return G.Has(k, r)

samples/mostly-adequate/chapter09_monadiconions_test.go

@@ -18,10 +18,14 @@ package mostlyadequate
 import (
 	"fmt"
 	"path"
+	"regexp"
 
 	A "github.com/IBM/fp-go/array"
+	E "github.com/IBM/fp-go/either"
+	"github.com/IBM/fp-go/errors"
 	F "github.com/IBM/fp-go/function"
 	"github.com/IBM/fp-go/io"
+	IOE "github.com/IBM/fp-go/ioeither"
 	O "github.com/IBM/fp-go/option"
 	S "github.com/IBM/fp-go/string"
 )
@@ -104,6 +108,21 @@ var (
 
 	// pureLog :: String -> IO ()
 	pureLog = io.Logf[string]("%s")
+
+	// addToMailingList :: Email -> IOEither([Email])
+	addToMailingList = F.Flow2(
+		A.Of[string],
+		IOE.Of[error, []string],
+	)
+
+	// validateEmail :: Email -> Either error Email
+	validateEmail = E.FromPredicate(Matches(regexp.MustCompile(`\S+@\S+\.\S+`)), errors.OnSome[string]("email %s is invalid"))
+
+	// emailBlast :: [Email] -> IO ()
+	emailBlast = F.Flow2(
+		A.Intercalate(S.Monoid)(","),
+		IOE.Of[error, string],
+	)
 )
 
 func Example_street() {
@@ -147,3 +166,21 @@ func Example_solution09B() {
 	// Output:
 	// ch09.md
 }
+
+func Example_solution09C() {
+
+	// // joinMailingList :: Email -> Either String (IO ())
+	joinMailingList := F.Flow4(
+		validateEmail,
+		IOE.FromEither[error, string],
+		IOE.Chain(addToMailingList),
+		IOE.Chain(emailBlast),
+	)
+
+	fmt.Println(joinMailingList("sleepy@grandpa.net")())
+	fmt.Println(joinMailingList("notanemail")())
+
+	// Output:
+	// Right[<nil>, string](sleepy@grandpa.net)
+	// Left[*errors.errorString, string](email notanemail is invalid)
+}

samples/mostly-adequate/chapter10_applicativefunctor_test.go

@@ -23,16 +23,65 @@ import (
 	R "github.com/IBM/fp-go/context/readerioeither"
 	H "github.com/IBM/fp-go/context/readerioeither/http"
 	F "github.com/IBM/fp-go/function"
+	IOO "github.com/IBM/fp-go/iooption"
+	N "github.com/IBM/fp-go/number"
+	O "github.com/IBM/fp-go/option"
+	M "github.com/IBM/fp-go/record"
+	T "github.com/IBM/fp-go/tuple"
 )
 
-type PostItem struct {
-	UserId uint   `json:"userId"`
-	Id     uint   `json:"id"`
-	Title  string `json:"title"`
-	Body   string `json:"body"`
+type (
+	PostItem struct {
+		UserId uint   `json:"userId"`
+		Id     uint   `json:"id"`
+		Title  string `json:"title"`
+		Body   string `json:"body"`
+	}
+
+	Player struct {
+		Id   int
+		Name string
+	}
+
+	LocalStorage = map[string]Player
+)
+
+var (
+	playerAlbert = Player{
+		Id:   1,
+		Name: "Albert",
+	}
+	playerTheresa = Player{
+		Id:   2,
+		Name: "Theresa",
+	}
+	localStorage = LocalStorage{
+		"player1": playerAlbert,
+		"player2": playerTheresa,
+	}
+
+	// getFromCache :: String -> IO User
+	getFromCache = func(name string) IOO.IOOption[Player] {
+		return func() O.Option[Player] {
+			return M.MonadLookup(localStorage, name)
+		}
+	}
+
+	// game :: User -> User -> String
+	game = F.Curry2(func(a, b Player) string {
+		return fmt.Sprintf("%s vs %s", a.Name, b.Name)
+	})
+)
+
+func (player Player) getName() string {
+	return player.Name
 }
 
-func getTitle(item PostItem) string {
+func (player Player) getId() int {
+	return player.Id
+}
+
+func (item PostItem) getTitle() string {
 	return item.Title
 }
 
@@ -55,7 +104,7 @@ func Example_renderPage() {
 		idxToUrl,
 		H.MakeGetRequest,
 		H.ReadJson[PostItem](client),
-		R.Map(getTitle),
+		R.Map(PostItem.getTitle),
 	)
 
 	res := F.Pipe2(
@@ -71,3 +120,64 @@ func Example_renderPage() {
 	// Right[<nil>, string](<div>Destinations: [qui est esse], Events: [ea molestias quasi exercitationem repellat qui ipsa sit aut]</div>)
 
 }
+
+func Example_solution10A() {
+	safeAdd := F.Curry2(func(a, b O.Option[int]) O.Option[int] {
+		return F.Pipe3(
+			N.Add[int],
+			O.Of[func(int) func(int) int],
+			O.Ap[func(int) int](a),
+			O.Ap[int](b),
+		)
+	})
+
+	fmt.Println(safeAdd(O.Of(2))(O.Of(3)))
+	fmt.Println(safeAdd(O.None[int]())(O.Of(3)))
+	fmt.Println(safeAdd(O.Of(2))(O.None[int]()))
+
+	// Output:
+	// Some[int](5)
+	// None[int]
+	// None[int]
+}
+
+func Example_solution10B() {
+
+	safeAdd := F.Curry2(T.Untupled2(F.Flow2(
+		O.SequenceTuple2[int, int],
+		O.Map(T.Tupled2(N.MonoidSum[int]().Concat)),
+	)))
+
+	fmt.Println(safeAdd(O.Of(2))(O.Of(3)))
+	fmt.Println(safeAdd(O.None[int]())(O.Of(3)))
+	fmt.Println(safeAdd(O.Of(2))(O.None[int]()))
+
+	// Output:
+	// Some[int](5)
+	// None[int]
+	// None[int]
+}
+
+func Example_solution10C() {
+	// startGame :: IO String
+	startGame := F.Pipe2(
+		IOO.Of(game),
+		IOO.Ap[func(Player) string](getFromCache("player1")),
+		IOO.Ap[string](getFromCache("player2")),
+	)
+
+	startGameTupled := F.Pipe2(
+		T.MakeTuple2("player1", "player2"),
+		IOO.TraverseTuple2(getFromCache, getFromCache),
+		IOO.Map(T.Tupled2(func(a, b Player) string {
+			return fmt.Sprintf("%s vs %s", a.Name, b.Name)
+		})),
+	)
+
+	fmt.Println(startGame())
+	fmt.Println(startGameTupled())
+
+	// Output:
+	// Some[string](Albert vs Theresa)
+	// Some[string](Albert vs Theresa)
+}

samples/mostly-adequate/chapter11_transformagain_test.go

@@ -0,0 +1,89 @@
+// 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 mostlyadequate
+
+import (
+	"fmt"
+	"regexp"
+
+	A "github.com/IBM/fp-go/array"
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	IOE "github.com/IBM/fp-go/ioeither"
+	S "github.com/IBM/fp-go/string"
+)
+
+func findUserById(id int) IOE.IOEither[error, Chapter08User] {
+	switch id {
+	case 1:
+		return IOE.Of[error](albert08)
+	case 2:
+		return IOE.Of[error](gary08)
+	case 3:
+		return IOE.Of[error](theresa08)
+	default:
+		return IOE.Left[Chapter08User](fmt.Errorf("user %d not found", id))
+	}
+}
+
+func Example_solution11A() {
+	// eitherToMaybe :: Either b a -> Maybe a
+	eitherToMaybe := E.ToOption[error, string]
+
+	fmt.Println(eitherToMaybe(E.Of[error]("one eyed willy")))
+	fmt.Println(eitherToMaybe(E.Left[string](fmt.Errorf("some error"))))
+
+	// Output:
+	// Some[string](one eyed willy)
+	// None[string]
+}
+
+func Example_solution11B() {
+	findByNameId := F.Flow2(
+		findUserById,
+		IOE.Map[error](Chapter08User.getName),
+	)
+
+	fmt.Println(findByNameId(1)())
+	fmt.Println(findByNameId(2)())
+	fmt.Println(findByNameId(3)())
+	fmt.Println(findByNameId(4)())
+
+	// Output:
+	// Right[<nil>, string](Albert)
+	// Right[<nil>, string](Gary)
+	// Right[<nil>, string](Theresa)
+	// Left[*errors.errorString, string](user 4 not found)
+}
+
+func Example_solution11C() {
+	// strToList :: String -> [Char
+	strToList := Split(regexp.MustCompile(``))
+
+	// listToStr :: [Char] -> String
+	listToStr := A.Intercalate(S.Monoid)("")
+
+	sortLetters := F.Flow3(
+		strToList,
+		A.Sort(S.Ord),
+		listToStr,
+	)
+
+	fmt.Println(sortLetters("sortme"))
+
+	// Output:
+	// emorst
+}

samples/mostly-adequate/chapter12_traversing_test.go

@@ -0,0 +1,98 @@
+// 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 mostlyadequate
+
+import (
+	"fmt"
+
+	A "github.com/IBM/fp-go/array"
+	E "github.com/IBM/fp-go/either"
+	"github.com/IBM/fp-go/errors"
+	F "github.com/IBM/fp-go/function"
+	IOE "github.com/IBM/fp-go/ioeither"
+	O "github.com/IBM/fp-go/option"
+	P "github.com/IBM/fp-go/predicate"
+	S "github.com/IBM/fp-go/string"
+)
+
+var (
+	// httpGet :: Route -> Task Error JSON
+	httpGet = F.Flow2(
+		S.Format[string]("json for %s"),
+		IOE.Of[error, string],
+	)
+
+	// routes :: Map Route Route
+	routes = map[string]string{
+		"/":      "/",
+		"/about": "/about",
+	}
+
+	// validate :: Player -> Either error Player
+	validatePlayer = E.FromPredicate(P.ContraMap(Player.getName)(S.IsNonEmpty), F.Flow2(Player.getId, errors.OnSome[int]("player %d must have a name")))
+
+	// readfile :: String -> String -> Task Error String
+	readfile = F.Curry2(func(encoding, file string) IOE.IOEither[error, string] {
+		return IOE.Of[error](fmt.Sprintf("content of %s (%s)", file, encoding))
+	})
+
+	//   readdir :: String -> Task Error [String]
+	readdir = IOE.Of[error](A.From("file1", "file2", "file3"))
+)
+
+func Example_solution12A() {
+	// getJsons :: Map Route Route -> Task Error (Map Route JSON)
+	getJsons := IOE.TraverseRecord[string](httpGet)
+
+	fmt.Println(getJsons(routes)())
+
+	// Output:
+	// Right[<nil>, map[string]string](map[/:json for / /about:json for /about])
+}
+
+func Example_solution12B() {
+	// startGame :: [Player] -> [Either Error String]
+	startGame := F.Flow2(
+		E.TraverseArray(validatePlayer),
+		E.MapTo[error, []Player]("Game started"),
+	)
+
+	fmt.Println(startGame(A.From(playerAlbert, playerTheresa)))
+	fmt.Println(startGame(A.From(playerAlbert, Player{Id: 4})))
+
+	// Output:
+	// Right[<nil>, string](Game started)
+	// Left[*errors.errorString, string](player 4 must have a name)
+}
+
+func Example_solution12C() {
+	traverseO := O.Traverse[string](
+		IOE.Of[error, O.Option[string]],
+		IOE.Map[error, string, O.Option[string]],
+	)
+
+	// readFirst :: String -> Task Error (Maybe String)
+	readFirst := F.Pipe2(
+		readdir,
+		IOE.Map[error](A.Head[string]),
+		IOE.Chain(traverseO(readfile("utf-8"))),
+	)
+
+	fmt.Println(readFirst())
+
+	// Output:
+	// Right[<nil>, option.Option[string]](Some[string](content of file1 (utf-8)))
+}

string/generic/string.go

@@ -0,0 +1,41 @@
+// 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
+
+// ToBytes converts the string to bytes
+func ToBytes[T ~string](s T) []byte {
+	return []byte(s)
+}
+
+// ToRunes converts the string to runes
+func ToRunes[T ~string](s T) []rune {
+	return []rune(s)
+}
+
+// IsEmpty tests if the string is empty
+func IsEmpty[T ~string](s T) bool {
+	return len(s) == 0
+}
+
+// IsNonEmpty tests if the string is not empty
+func IsNonEmpty[T ~string](s T) bool {
+	return len(s) > 0
+}
+
+// Size returns the size of the string
+func Size[T ~string](s T) int {
+	return len(s)
+}