fix: add automation for TraverseTuple and SequenceTuple

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

cli/apply.go

@@ -10,10 +10,10 @@ import (
 	C "github.com/urfave/cli/v2"
 )
 
-func generateSequenceT(f *os.File, i int) {
+func generateTraverseTuple(f *os.File, i int) {
-	fmt.Fprintf(f, "\n// SequenceT%d is a utility function used to implement the sequence operation for higher kinded types based only on map and ap.\n", i)
+	fmt.Fprintf(f, "\n// TraverseTuple%d is a utility function used to implement the sequence operation for higher kinded types based only on map and ap.\n", i)
-	fmt.Fprintf(f, "// The function takes %d higher higher kinded types and returns a higher kinded type of a [Tuple%d] with the resolved values.\n", i, i)
+	fmt.Fprintf(f, "// The function takes a [Tuple%d] of base types and %d functions that transform these based types into higher higher kinded types. It returns a higher kinded type of a [Tuple%d] with the resolved values.\n", i, i, i)
-	fmt.Fprintf(f, "func SequenceT%d[\n", i)
+	fmt.Fprintf(f, "func TraverseTuple%d[\n", i)
 	// map as the starting point
 	fmt.Fprintf(f, "  MAP ~func(")
 	for j := 0; j < i; j++ {
@@ -24,7 +24,115 @@ func generateSequenceT(f *os.File, i int) {
 	}
 	fmt.Fprintf(f, " ")
 	fmt.Fprintf(f, "T.")
-	writeTupleType(f, i)
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, ") func(HKT_T1)")
+	if i > 1 {
+		fmt.Fprintf(f, " HKT_F")
+		for k := 1; k < i; k++ {
+			fmt.Fprintf(f, "_T%d", k+1)
+		}
+	} else {
+		fmt.Fprintf(f, " HKT_TUPLE%d", i)
+	}
+	fmt.Fprintf(f, ",\n")
+	// the applicatives
+	for j := 1; j < i; j++ {
+		fmt.Fprintf(f, "  AP%d ~func(", j)
+		fmt.Fprintf(f, "HKT_T%d) func(", j+1)
+		fmt.Fprintf(f, "HKT_F")
+		for k := j; k < i; k++ {
+			fmt.Fprintf(f, "_T%d", k+1)
+		}
+		fmt.Fprintf(f, ")")
+		if j+1 < i {
+			fmt.Fprintf(f, " HKT_F")
+			for k := j + 1; k < i; k++ {
+				fmt.Fprintf(f, "_T%d", k+1)
+			}
+		} else {
+			fmt.Fprintf(f, " HKT_TUPLE%d", i)
+		}
+		fmt.Fprintf(f, ",\n")
+	}
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, "  F%d ~func(A%d) HKT_T%d,\n", j+1, j+1, j+1)
+	}
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, "  A%d, T%d,\n", j+1, j+1)
+	}
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, "  HKT_T%d, // HKT[T%d]\n", j+1, j+1)
+	}
+	for j := 1; j < i; j++ {
+		fmt.Fprintf(f, "  HKT_F")
+		for k := j; k < i; k++ {
+			fmt.Fprintf(f, "_T%d", k+1)
+		}
+		fmt.Fprintf(f, ", // HKT[")
+		for k := j; k < i; k++ {
+			fmt.Fprintf(f, "func(T%d) ", k+1)
+		}
+		fmt.Fprintf(f, "T.")
+		writeTupleType(f, "T", i)
+		fmt.Fprintf(f, "]\n")
+	}
+	fmt.Fprintf(f, "  HKT_TUPLE%d any, // HKT[", i)
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, "]\n")
+	fmt.Fprintf(f, "](\n")
+
+	// the callbacks
+	fmt.Fprintf(f, "  fmap MAP,\n")
+	for j := 1; j < i; j++ {
+		fmt.Fprintf(f, "  fap%d AP%d,\n", j, j)
+	}
+	// the transformer functions
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, "  f%d F%d,\n", j, j)
+	}
+	// the parameters
+	fmt.Fprintf(f, "  t T.Tuple%d[", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "A%d", j+1)
+	}
+	fmt.Fprintf(f, "],\n")
+	fmt.Fprintf(f, ") HKT_TUPLE%d {\n", i)
+
+	fmt.Fprintf(f, "  return F.Pipe%d(\n", i)
+	fmt.Fprintf(f, "    f1(t.F1),\n")
+	fmt.Fprintf(f, "    fmap(tupleConstructor%d[", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j+1)
+	}
+	fmt.Fprintf(f, "]()),\n")
+	for j := 1; j < i; j++ {
+		fmt.Fprintf(f, "    fap%d(f%d(t.F%d)),\n", j, j+1, j+1)
+	}
+	fmt.Fprintf(f, ")\n")
+	fmt.Fprintf(f, "}\n")
+}
+
+func generateSequenceTuple(f *os.File, i int) {
+	fmt.Fprintf(f, "\n// SequenceTuple%d is a utility function used to implement the sequence operation for higher kinded types based only on map and ap.\n", i)
+	fmt.Fprintf(f, "// The function takes a [Tuple%d] of higher higher kinded types and returns a higher kinded type of a [Tuple%d] with the resolved values.\n", i, i)
+	fmt.Fprintf(f, "func SequenceTuple%d[\n", i)
+	// map as the starting point
+	fmt.Fprintf(f, "  MAP ~func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, " ")
+		}
+		fmt.Fprintf(f, "func(T%d)", j+1)
+	}
+	fmt.Fprintf(f, " ")
+	fmt.Fprintf(f, "T.")
+	writeTupleType(f, "T", i)
 	fmt.Fprintf(f, ") func(HKT_T1)")
 	if i > 1 {
 		fmt.Fprintf(f, " HKT_F")
@@ -71,11 +179,113 @@ func generateSequenceT(f *os.File, i int) {
 			fmt.Fprintf(f, "func(T%d) ", k+1)
 		}
 		fmt.Fprintf(f, "T.")
-		writeTupleType(f, i)
+		writeTupleType(f, "T", i)
 		fmt.Fprintf(f, "]\n")
 	}
 	fmt.Fprintf(f, "  HKT_TUPLE%d any, // HKT[", i)
-	writeTupleType(f, i)
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, "]\n")
+	fmt.Fprintf(f, "](\n")
+
+	// the callbacks
+	fmt.Fprintf(f, "  fmap MAP,\n")
+	for j := 1; j < i; j++ {
+		fmt.Fprintf(f, "  fap%d AP%d,\n", j, j)
+	}
+	// the parameters
+	fmt.Fprintf(f, "  t T.Tuple%d[", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "HKT_T%d", j+1)
+	}
+	fmt.Fprintf(f, "],\n")
+	fmt.Fprintf(f, ") HKT_TUPLE%d {\n", i)
+
+	fmt.Fprintf(f, "  return F.Pipe%d(\n", i)
+	fmt.Fprintf(f, "    t.F1,\n")
+	fmt.Fprintf(f, "    fmap(tupleConstructor%d[", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j+1)
+	}
+	fmt.Fprintf(f, "]()),\n")
+	for j := 1; j < i; j++ {
+		fmt.Fprintf(f, "    fap%d(t.F%d),\n", j, j+1)
+	}
+	fmt.Fprintf(f, ")\n")
+	fmt.Fprintf(f, "}\n")
+}
+
+func generateSequenceT(f *os.File, i int) {
+	fmt.Fprintf(f, "\n// SequenceT%d is a utility function used to implement the sequence operation for higher kinded types based only on map and ap.\n", i)
+	fmt.Fprintf(f, "// The function takes %d higher higher kinded types and returns a higher kinded type of a [Tuple%d] with the resolved values.\n", i, i)
+	fmt.Fprintf(f, "func SequenceT%d[\n", i)
+	// map as the starting point
+	fmt.Fprintf(f, "  MAP ~func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, " ")
+		}
+		fmt.Fprintf(f, "func(T%d)", j+1)
+	}
+	fmt.Fprintf(f, " ")
+	fmt.Fprintf(f, "T.")
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, ") func(HKT_T1)")
+	if i > 1 {
+		fmt.Fprintf(f, " HKT_F")
+		for k := 1; k < i; k++ {
+			fmt.Fprintf(f, "_T%d", k+1)
+		}
+	} else {
+		fmt.Fprintf(f, " HKT_TUPLE%d", i)
+	}
+	fmt.Fprintf(f, ",\n")
+	// the applicatives
+	for j := 1; j < i; j++ {
+		fmt.Fprintf(f, "  AP%d ~func(", j)
+		fmt.Fprintf(f, "HKT_T%d) func(", j+1)
+		fmt.Fprintf(f, "HKT_F")
+		for k := j; k < i; k++ {
+			fmt.Fprintf(f, "_T%d", k+1)
+		}
+		fmt.Fprintf(f, ")")
+		if j+1 < i {
+			fmt.Fprintf(f, " HKT_F")
+			for k := j + 1; k < i; k++ {
+				fmt.Fprintf(f, "_T%d", k+1)
+			}
+		} else {
+			fmt.Fprintf(f, " HKT_TUPLE%d", i)
+		}
+		fmt.Fprintf(f, ",\n")
+	}
+
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, "  T%d,\n", j+1)
+	}
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, "  HKT_T%d, // HKT[T%d]\n", j+1, j+1)
+	}
+	for j := 1; j < i; j++ {
+		fmt.Fprintf(f, "  HKT_F")
+		for k := j; k < i; k++ {
+			fmt.Fprintf(f, "_T%d", k+1)
+		}
+		fmt.Fprintf(f, ", // HKT[")
+		for k := j; k < i; k++ {
+			fmt.Fprintf(f, "func(T%d) ", k+1)
+		}
+		fmt.Fprintf(f, "T.")
+		writeTupleType(f, "T", i)
+		fmt.Fprintf(f, "]\n")
+	}
+	fmt.Fprintf(f, "  HKT_TUPLE%d any, // HKT[", i)
+	writeTupleType(f, "T", i)
 	fmt.Fprintf(f, "]\n")
 	fmt.Fprintf(f, "](\n")
 
@@ -180,6 +390,10 @@ import (
 		generateTupleConstructor(f, i)
 		// sequenceT
 		generateSequenceT(f, i)
+		// sequenceTuple
+		generateSequenceTuple(f, i)
+		// traverseTuple
+		generateTraverseTuple(f, i)
 	}
 
 	return nil

cli/either.go

@@ -10,6 +10,65 @@ import (
 	C "github.com/urfave/cli/v2"
 )
 
+func eitherHKT(typeE string) func(typeA string) string {
+	return func(typeA string) string {
+		return fmt.Sprintf("Either[%s, %s]", typeE, typeA)
+	}
+}
+
+func generateEitherTraverseTuple(f *os.File, i int) {
+	generateTraverseTuple1(eitherHKT("E"), "E")(f, i)
+}
+
+func generateEitherSequenceTuple(f *os.File, i int) {
+	generateSequenceTuple1(eitherHKT("E"), "E")(f, i)
+}
+
+func generateEitherSequenceT(f *os.File, i int) {
+
+	tuple := tupleType(i)
+
+	fmt.Fprintf(f, "\n// SequenceT%d converts %d parameters of [Either[E, T]] into an [Either] of a [Tuple%d].\n", i, i, i)
+	fmt.Fprintf(f, "func SequenceT%d[E", i)
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j+1)
+	}
+	fmt.Fprintf(f, " any](")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "t%d Either[E, T%d]", j+1, j+1)
+	}
+	fmt.Fprintf(f, ") Either[E, %s] {\n", tuple)
+	fmt.Fprintf(f, "  return A.SequenceT%d(\n", i)
+	// map
+	fmt.Fprintf(f, "    Map[E, T1,")
+	for j := 1; j < i; j++ {
+		fmt.Fprintf(f, " func(T%d)", j+1)
+	}
+	fmt.Fprintf(f, " %s],\n", tuple)
+	// applicatives
+	for j := 1; j < i; j++ {
+		fmt.Fprintf(f, "    Ap[")
+		for k := j + 1; k < i; k++ {
+			if k > j+1 {
+				fmt.Fprintf(f, " ")
+			}
+			fmt.Fprintf(f, "func(T%d)", k+1)
+		}
+		if j < i-1 {
+			fmt.Fprintf(f, " ")
+		}
+		fmt.Fprintf(f, "%s, E, T%d],\n", tuple, j+1)
+	}
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, "    t%d,\n", j+1)
+	}
+	fmt.Fprintf(f, "  )\n")
+	fmt.Fprintf(f, "}\n")
+}
+
 func generateUneitherize(f *os.File, i int) {
 	// Create the optionize version
 	fmt.Fprintf(f, "\n// Uneitherize%d converts a function with %d parameters returning an Either into a function with %d parameters returning a tuple\n// The inverse function is [Eitherize%d]\n", i, i, i, i)
@@ -121,6 +180,13 @@ func generateEitherHelpers(filename string, count int) error {
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 
+	fmt.Fprintf(f, `
+import (
+	A "github.com/ibm/fp-go/internal/apply"
+	T "github.com/ibm/fp-go/tuple"
+)
+`)
+
 	// zero level functions
 
 	// optionize
@@ -133,6 +199,12 @@ func generateEitherHelpers(filename string, count int) error {
 		generateEitherize(f, i)
 		// unoptionize
 		generateUneitherize(f, i)
+		// sequenceT
+		generateEitherSequenceT(f, i)
+		// sequenceTuple
+		generateEitherSequenceTuple(f, i)
+		// traverseTuple
+		generateEitherTraverseTuple(f, i)
 	}
 
 	return nil

cli/monad.go

@@ -125,3 +125,152 @@ func monadGenerateSequenceTGeneric(
 
 	}
 }
+
+func generateTraverseTuple1(
+	hkt func(string) string,
+	infix string) func(f *os.File, i int) {
+
+	return func(f *os.File, i int) {
+		tuple := tupleType(i)
+
+		fmt.Fprintf(f, "\n// TraverseTuple%d converts a [Tuple%d] of [A] via transformation functions transforming [A] to [%s] into a [%s].\n", i, i, hkt("A"), hkt(fmt.Sprintf("Tuple%d", i)))
+		fmt.Fprintf(f, "func TraverseTuple%d[", i)
+		// functions
+		for j := 0; j < i; j++ {
+			if j > 0 {
+				fmt.Fprintf(f, ", ")
+			}
+			fmt.Fprintf(f, "F%d ~func(A%d) %s", j+1, j+1, hkt(fmt.Sprintf("T%d", j+1)))
+		}
+		if infix != "" {
+			fmt.Fprintf(f, ", %s", infix)
+		}
+		// types
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(f, ", A%d, T%d", j+1, j+1)
+		}
+		fmt.Fprintf(f, " any](")
+		for j := 0; j < i; j++ {
+			if j > 0 {
+				fmt.Fprintf(f, ", ")
+			}
+			fmt.Fprintf(f, "f%d F%d", j+1, j+1)
+		}
+		fmt.Fprintf(f, ") func (T.Tuple%d[", i)
+		for j := 0; j < i; j++ {
+			if j > 0 {
+				fmt.Fprintf(f, ", ")
+			}
+			fmt.Fprintf(f, "A%d", j+1)
+		}
+		fmt.Fprintf(f, "]) %s {\n", hkt(tuple))
+		fmt.Fprintf(f, "  return func(t T.Tuple%d[", i)
+		for j := 0; j < i; j++ {
+			if j > 0 {
+				fmt.Fprintf(f, ", ")
+			}
+			fmt.Fprintf(f, "A%d", j+1)
+		}
+		fmt.Fprintf(f, "]) %s {\n", hkt(tuple))
+		fmt.Fprintf(f, "    return A.TraverseTuple%d(\n", i)
+		// map
+		fmt.Fprintf(f, "      Map[")
+		if infix != "" {
+			fmt.Fprintf(f, "%s, T1,", infix)
+		} else {
+			fmt.Fprintf(f, "T1,")
+		}
+		for j := 1; j < i; j++ {
+			fmt.Fprintf(f, " func(T%d)", j+1)
+		}
+		fmt.Fprintf(f, " %s],\n", tuple)
+		// applicatives
+		for j := 1; j < i; j++ {
+			fmt.Fprintf(f, "      Ap[")
+			for k := j + 1; k < i; k++ {
+				if k > j+1 {
+					fmt.Fprintf(f, " ")
+				}
+				fmt.Fprintf(f, "func(T%d)", k+1)
+			}
+			if j < i-1 {
+				fmt.Fprintf(f, " ")
+			}
+			fmt.Fprintf(f, "%s", tuple)
+			if infix != "" {
+				fmt.Fprintf(f, ", %s", infix)
+			}
+			fmt.Fprintf(f, ", T%d],\n", j+1)
+		}
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(f, "      f%d,\n", j+1)
+		}
+		fmt.Fprintf(f, "      t,\n")
+		fmt.Fprintf(f, "    )\n")
+		fmt.Fprintf(f, "  }\n")
+		fmt.Fprintf(f, "}\n")
+	}
+}
+
+func generateSequenceTuple1(
+	hkt func(string) string,
+	infix string) func(f *os.File, i int) {
+
+	return func(f *os.File, i int) {
+
+		tuple := tupleType(i)
+
+		fmt.Fprintf(f, "\n// SequenceTuple%d converts a [Tuple%d] of [%s] into an [%s].\n", i, i, hkt("T"), hkt(fmt.Sprintf("Tuple%d", i)))
+		fmt.Fprintf(f, "func SequenceTuple%d[", i)
+		if infix != "" {
+			fmt.Fprintf(f, "%s", infix)
+		}
+		for j := 0; j < i; j++ {
+			if infix != "" || j > 0 {
+				fmt.Fprintf(f, ", ")
+			}
+			fmt.Fprintf(f, "T%d", j+1)
+		}
+		fmt.Fprintf(f, " any](t T.Tuple%d[", i)
+		for j := 0; j < i; j++ {
+			if j > 0 {
+				fmt.Fprintf(f, ", ")
+			}
+			fmt.Fprintf(f, "%s", hkt(fmt.Sprintf("T%d", j+1)))
+		}
+		fmt.Fprintf(f, "]) %s {\n", hkt(tuple))
+		fmt.Fprintf(f, "  return A.SequenceTuple%d(\n", i)
+		// map
+		fmt.Fprintf(f, "    Map[")
+		if infix != "" {
+			fmt.Fprintf(f, "%s, T1,", infix)
+		} else {
+			fmt.Fprintf(f, "T1,")
+		}
+		for j := 1; j < i; j++ {
+			fmt.Fprintf(f, " func(T%d)", j+1)
+		}
+		fmt.Fprintf(f, " %s],\n", tuple)
+		// applicatives
+		for j := 1; j < i; j++ {
+			fmt.Fprintf(f, "    Ap[")
+			for k := j + 1; k < i; k++ {
+				if k > j+1 {
+					fmt.Fprintf(f, " ")
+				}
+				fmt.Fprintf(f, "func(T%d)", k+1)
+			}
+			if j < i-1 {
+				fmt.Fprintf(f, " ")
+			}
+			fmt.Fprintf(f, "%s", tuple)
+			if infix != "" {
+				fmt.Fprintf(f, ", %s", infix)
+			}
+			fmt.Fprintf(f, ", T%d],\n", j+1)
+		}
+		fmt.Fprintf(f, "    t,\n")
+		fmt.Fprintf(f, "  )\n")
+		fmt.Fprintf(f, "}\n")
+	}
+}

cli/option.go

@@ -10,6 +10,18 @@ import (
 	C "github.com/urfave/cli/v2"
 )
 
+func optionHKT(typeA string) string {
+	return fmt.Sprintf("Option[%s]", typeA)
+}
+
+func generateOptionTraverseTuple(f *os.File, i int) {
+	generateTraverseTuple1(optionHKT, "")(f, i)
+}
+
+func generateOptionSequenceTuple(f *os.File, i int) {
+	generateSequenceTuple1(optionHKT, "")(f, i)
+}
+
 func generateOptionize(f *os.File, i int) {
 	// Create the optionize version
 	fmt.Fprintf(f, "\n// Optionize%d converts a function with %d parameters returning a tuple of a return value R and a boolean into a function with %d parameters returning an Option[R]\n", i, i, i)
@@ -121,6 +133,13 @@ func generateOptionHelpers(filename string, count int) error {
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 
+	fmt.Fprintf(f, `
+import (
+	A "github.com/ibm/fp-go/internal/apply"
+	T "github.com/ibm/fp-go/tuple"
+)
+`)
+
 	// print out some helpers
 	fmt.Fprintf(f, `// optionize converts a nullary function to an option
 func optionize[R any](f func() (R, bool)) Option[R] {
@@ -143,6 +162,10 @@ func optionize[R any](f func() (R, bool)) Option[R] {
 		generateOptionize(f, i)
 		// unoptionize
 		generateUnoptionize(f, i)
+		// sequenceTuple
+		generateOptionSequenceTuple(f, i)
+		// traverseTuple
+		generateOptionTraverseTuple(f, i)
 	}
 
 	return nil

cli/tuple.go

@@ -10,17 +10,84 @@ import (
 	C "github.com/urfave/cli/v2"
 )
 
-func writeTupleType(f *os.File, i int) {
+func writeTupleType(f *os.File, symbol string, i int) {
 	fmt.Fprintf(f, "Tuple%d[", i)
 	for j := 1; j <= i; j++ {
 		if j > 1 {
 			fmt.Fprintf(f, ", ")
 		}
-		fmt.Fprintf(f, "T%d", j)
+		fmt.Fprintf(f, "%s%d", symbol, j)
 	}
 	fmt.Fprintf(f, "]")
 }
 
+func generateReplicate(f *os.File, i int) {
+	// Create the optionize version
+	fmt.Fprintf(f, "\n// Replicate%d creates a [Tuple%d] with all fields set to the input value `t`\n", i, i)
+	fmt.Fprintf(f, "func Replicate%d[T any](t T) Tuple%d[", i, i)
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T")
+	}
+	fmt.Fprintf(f, "] {\n")
+	// execute the mapping
+	fmt.Fprintf(f, "  return MakeTuple%d(", i)
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "t")
+	}
+	fmt.Fprintf(f, ")\n")
+	fmt.Fprintf(f, "}\n")
+}
+
+func generateMap(f *os.File, i int) {
+	// Create the optionize version
+	fmt.Fprintf(f, "\n// Map%d maps each value of a [Tuple%d] via a mapping function\n", i, i)
+	fmt.Fprintf(f, "func Map%d[", i)
+	// function prototypes
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "F%d ~func(T%d) R%d", j, j, j)
+	}
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, ", T%d, R%d", j, j)
+	}
+	fmt.Fprintf(f, " any](")
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "f%d F%d", j, j)
+	}
+	fmt.Fprintf(f, ") func(")
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, ") ")
+	writeTupleType(f, "R", i)
+	fmt.Fprintf(f, " {\n")
+
+	fmt.Fprintf(f, " return func(t ")
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, ") ")
+	writeTupleType(f, "R", i)
+	fmt.Fprintf(f, " {\n")
+
+	// execute the mapping
+	fmt.Fprintf(f, "    return MakeTuple%d(\n", i)
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, "      f%d(t.F%d),\n", j, j)
+	}
+	fmt.Fprintf(f, "    )\n")
+
+	fmt.Fprintf(f, " }\n")
+	fmt.Fprintf(f, "}\n")
+}
+
 func generateMonoid(f *os.File, i int) {
 	// Create the optionize version
 	fmt.Fprintf(f, "\n// Monoid%d creates a [Monoid] for a [Tuple%d] based on %d monoids for the contained types\n", i, i, i)
@@ -39,13 +106,13 @@ func generateMonoid(f *os.File, i int) {
 		fmt.Fprintf(f, "m%d M.Monoid[T%d]", j, j)
 	}
 	fmt.Fprintf(f, ") M.Monoid[")
-	writeTupleType(f, i)
+	writeTupleType(f, "T", i)
 	fmt.Fprintf(f, "] {\n")
 
 	fmt.Fprintf(f, "  return M.MakeMonoid(func(l, r ")
-	writeTupleType(f, i)
+	writeTupleType(f, "T", i)
 	fmt.Fprintf(f, ") ")
-	writeTupleType(f, i)
+	writeTupleType(f, "T", i)
 	fmt.Fprintf(f, "{\n")
 
 	fmt.Fprintf(f, "    return MakeTuple%d(", i)
@@ -86,11 +153,11 @@ func generateOrd(f *os.File, i int) {
 		fmt.Fprintf(f, "o%d O.Ord[T%d]", j, j)
 	}
 	fmt.Fprintf(f, ") O.Ord[")
-	writeTupleType(f, i)
+	writeTupleType(f, "T", i)
 	fmt.Fprintf(f, "] {\n")
 
 	fmt.Fprintf(f, "  return O.MakeOrd(func(l, r ")
-	writeTupleType(f, i)
+	writeTupleType(f, "T", i)
 	fmt.Fprintf(f, ") int {\n")
 
 	for j := 1; j <= i; j++ {
@@ -98,7 +165,7 @@ func generateOrd(f *os.File, i int) {
 	}
 	fmt.Fprintf(f, "    return 0\n")
 	fmt.Fprintf(f, "  }, func(l, r ")
-	writeTupleType(f, i)
+	writeTupleType(f, "T", i)
 	fmt.Fprintf(f, ") bool {\n")
 	fmt.Fprintf(f, "    return ")
 	for j := 1; j <= i; j++ {
@@ -148,7 +215,7 @@ func generateMakeTupleType(f *os.File, i int) {
 		fmt.Fprintf(f, "t%d T%d", j, j)
 	}
 	fmt.Fprintf(f, ") ")
-	writeTupleType(f, i)
+	writeTupleType(f, "T", i)
 	fmt.Fprintf(f, " {\n")
 	fmt.Fprintf(f, "  return Tuple%d[", i)
 	for j := 1; j <= i; j++ {
@@ -300,6 +367,10 @@ import (
 		generateMonoid(f, i)
 		// generate order
 		generateOrd(f, i)
+		// generate map
+		generateMap(f, i)
+		// generate replicate
+		generateReplicate(f, i)
 	}
 
 	return nil

either/doc.go

@@ -1,3 +1,3 @@
 package either
 
-//go:generate go run .. either --count 10 --filename eitherize.go
+//go:generate go run .. either --count 10 --filename gen.go

either/eitherize.go

@@ -1,202 +0,0 @@
-// Code generated by go generate; DO NOT EDIT.
-// This file was generated by robots at
-// 2023-07-14 13:19:40.5850892 +0200 CEST m=+0.008180901
-package either
-
-// Eitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning an Either
-// The inverse function is [Uneitherize0]
-func Eitherize0[F ~func() (R, error), R any](f F) func() Either[error, R] {
-	return func() Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f()
-		})
-	}
-}
-
-// Uneitherize0 converts a function with 0 parameters returning an Either into a function with 0 parameters returning a tuple
-// The inverse function is [Eitherize0]
-func Uneitherize0[F ~func() Either[error, R], R any](f F) func() (R, error) {
-	return func() (R, error) {
-		return UnwrapError(f())
-	}
-}
-
-// Eitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning an Either
-// The inverse function is [Uneitherize1]
-func Eitherize1[F ~func(T0) (R, error), T0, R any](f F) func(T0) Either[error, R] {
-	return func(t0 T0) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0)
-		})
-	}
-}
-
-// Uneitherize1 converts a function with 1 parameters returning an Either into a function with 1 parameters returning a tuple
-// The inverse function is [Eitherize1]
-func Uneitherize1[F ~func(T0) Either[error, R], T0, R any](f F) func(T0) (R, error) {
-	return func(t0 T0) (R, error) {
-		return UnwrapError(f(t0))
-	}
-}
-
-// Eitherize2 converts a function with 2 parameters returning a tuple into a function with 2 parameters returning an Either
-// The inverse function is [Uneitherize2]
-func Eitherize2[F ~func(T0, T1) (R, error), T0, T1, R any](f F) func(T0, T1) Either[error, R] {
-	return func(t0 T0, t1 T1) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1)
-		})
-	}
-}
-
-// Uneitherize2 converts a function with 2 parameters returning an Either into a function with 2 parameters returning a tuple
-// The inverse function is [Eitherize2]
-func Uneitherize2[F ~func(T0, T1) Either[error, R], T0, T1, R any](f F) func(T0, T1) (R, error) {
-	return func(t0 T0, t1 T1) (R, error) {
-		return UnwrapError(f(t0, t1))
-	}
-}
-
-// Eitherize3 converts a function with 3 parameters returning a tuple into a function with 3 parameters returning an Either
-// The inverse function is [Uneitherize3]
-func Eitherize3[F ~func(T0, T1, T2) (R, error), T0, T1, T2, R any](f F) func(T0, T1, T2) Either[error, R] {
-	return func(t0 T0, t1 T1, t2 T2) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2)
-		})
-	}
-}
-
-// Uneitherize3 converts a function with 3 parameters returning an Either into a function with 3 parameters returning a tuple
-// The inverse function is [Eitherize3]
-func Uneitherize3[F ~func(T0, T1, T2) Either[error, R], T0, T1, T2, R any](f F) func(T0, T1, T2) (R, error) {
-	return func(t0 T0, t1 T1, t2 T2) (R, error) {
-		return UnwrapError(f(t0, t1, t2))
-	}
-}
-
-// Eitherize4 converts a function with 4 parameters returning a tuple into a function with 4 parameters returning an Either
-// The inverse function is [Uneitherize4]
-func Eitherize4[F ~func(T0, T1, T2, T3) (R, error), T0, T1, T2, T3, R any](f F) func(T0, T1, T2, T3) Either[error, R] {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3)
-		})
-	}
-}
-
-// Uneitherize4 converts a function with 4 parameters returning an Either into a function with 4 parameters returning a tuple
-// The inverse function is [Eitherize4]
-func Uneitherize4[F ~func(T0, T1, T2, T3) Either[error, R], T0, T1, T2, T3, R any](f F) func(T0, T1, T2, T3) (R, error) {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3) (R, error) {
-		return UnwrapError(f(t0, t1, t2, t3))
-	}
-}
-
-// Eitherize5 converts a function with 5 parameters returning a tuple into a function with 5 parameters returning an Either
-// The inverse function is [Uneitherize5]
-func Eitherize5[F ~func(T0, T1, T2, T3, T4) (R, error), T0, T1, T2, T3, T4, R any](f F) func(T0, T1, T2, T3, T4) Either[error, R] {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3, t4)
-		})
-	}
-}
-
-// Uneitherize5 converts a function with 5 parameters returning an Either into a function with 5 parameters returning a tuple
-// The inverse function is [Eitherize5]
-func Uneitherize5[F ~func(T0, T1, T2, T3, T4) Either[error, R], T0, T1, T2, T3, T4, R any](f F) func(T0, T1, T2, T3, T4) (R, error) {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) (R, error) {
-		return UnwrapError(f(t0, t1, t2, t3, t4))
-	}
-}
-
-// Eitherize6 converts a function with 6 parameters returning a tuple into a function with 6 parameters returning an Either
-// The inverse function is [Uneitherize6]
-func Eitherize6[F ~func(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) Either[error, R] {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3, t4, t5)
-		})
-	}
-}
-
-// Uneitherize6 converts a function with 6 parameters returning an Either into a function with 6 parameters returning a tuple
-// The inverse function is [Eitherize6]
-func Uneitherize6[F ~func(T0, T1, T2, T3, T4, T5) Either[error, R], T0, T1, T2, T3, T4, T5, R any](f F) func(T0, T1, T2, T3, T4, T5) (R, error) {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R, error) {
-		return UnwrapError(f(t0, t1, t2, t3, t4, t5))
-	}
-}
-
-// Eitherize7 converts a function with 7 parameters returning a tuple into a function with 7 parameters returning an Either
-// The inverse function is [Uneitherize7]
-func Eitherize7[F ~func(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) Either[error, R] {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3, t4, t5, t6)
-		})
-	}
-}
-
-// Uneitherize7 converts a function with 7 parameters returning an Either into a function with 7 parameters returning a tuple
-// The inverse function is [Eitherize7]
-func Uneitherize7[F ~func(T0, T1, T2, T3, T4, T5, T6) Either[error, R], T0, T1, T2, T3, T4, T5, T6, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) (R, error) {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R, error) {
-		return UnwrapError(f(t0, t1, t2, t3, t4, t5, t6))
-	}
-}
-
-// Eitherize8 converts a function with 8 parameters returning a tuple into a function with 8 parameters returning an Either
-// The inverse function is [Uneitherize8]
-func Eitherize8[F ~func(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) Either[error, R] {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3, t4, t5, t6, t7)
-		})
-	}
-}
-
-// Uneitherize8 converts a function with 8 parameters returning an Either into a function with 8 parameters returning a tuple
-// The inverse function is [Eitherize8]
-func Uneitherize8[F ~func(T0, T1, T2, T3, T4, T5, T6, T7) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) (R, error) {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R, error) {
-		return UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7))
-	}
-}
-
-// Eitherize9 converts a function with 9 parameters returning a tuple into a function with 9 parameters returning an Either
-// The inverse function is [Uneitherize9]
-func Eitherize9[F ~func(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) Either[error, R] {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3, t4, t5, t6, t7, t8)
-		})
-	}
-}
-
-// Uneitherize9 converts a function with 9 parameters returning an Either into a function with 9 parameters returning a tuple
-// The inverse function is [Eitherize9]
-func Uneitherize9[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error) {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R, error) {
-		return UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8))
-	}
-}
-
-// Eitherize10 converts a function with 10 parameters returning a tuple into a function with 10 parameters returning an Either
-// The inverse function is [Uneitherize10]
-func Eitherize10[F ~func(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) Either[error, R] {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
-		})
-	}
-}
-
-// Uneitherize10 converts a function with 10 parameters returning an Either into a function with 10 parameters returning a tuple
-// The inverse function is [Eitherize10]
-func Uneitherize10[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) Either[error, R], 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) (R, error) {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R, error) {
-		return UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9))
-	}
-}

either/gen.go

@@ -0,0 +1,703 @@
+// Code generated by go generate; DO NOT EDIT.
+// This file was generated by robots at
+// 2023-07-17 13:22:56.8771166 +0200 CEST m=+0.010453601
+package either
+
+
+import (
+	A "github.com/ibm/fp-go/internal/apply"
+	T "github.com/ibm/fp-go/tuple"
+)
+
+// Eitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning an Either
+// The inverse function is [Uneitherize0]
+func Eitherize0[F ~func() (R, error), R any](f F) func() Either[error, R] {
+  return func() Either[error, R] {
+    return TryCatchError(func() (R, error) {
+      return f()
+    })
+  }
+}
+
+// Uneitherize0 converts a function with 0 parameters returning an Either into a function with 0 parameters returning a tuple
+// The inverse function is [Eitherize0]
+func Uneitherize0[F ~func() Either[error, R], R any](f F) func() (R, error) {
+  return func() (R, error) {
+    return UnwrapError(f())
+  }
+}
+
+// Eitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning an Either
+// The inverse function is [Uneitherize1]
+func Eitherize1[F ~func(T0) (R, error), T0, R any](f F) func(T0) Either[error, R] {
+  return func(t0 T0) Either[error, R] {
+    return TryCatchError(func() (R, error) {
+      return f(t0)
+    })
+  }
+}
+
+// Uneitherize1 converts a function with 1 parameters returning an Either into a function with 1 parameters returning a tuple
+// The inverse function is [Eitherize1]
+func Uneitherize1[F ~func(T0) Either[error, R], T0, R any](f F) func(T0) (R, error) {
+  return func(t0 T0) (R, error) {
+    return UnwrapError(f(t0))
+  }
+}
+
+// SequenceT1 converts 1 parameters of [Either[E, T]] into an [Either] of a [Tuple1].
+func SequenceT1[E, T1 any](t1 Either[E, T1]) Either[E, T.Tuple1[T1]] {
+  return A.SequenceT1(
+    Map[E, T1, T.Tuple1[T1]],
+    t1,
+  )
+}
+
+// SequenceTuple1 converts a [Tuple1] of [Either[E, T]] into an [Either[E, Tuple1]].
+func SequenceTuple1[E, T1 any](t T.Tuple1[Either[E, T1]]) Either[E, T.Tuple1[T1]] {
+  return A.SequenceTuple1(
+    Map[E, T1, T.Tuple1[T1]],
+    t,
+  )
+}
+
+// TraverseTuple1 converts a [Tuple1] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple1]].
+func TraverseTuple1[F1 ~func(A1) Either[E, T1], E, A1, T1 any](f1 F1) func (T.Tuple1[A1]) Either[E, T.Tuple1[T1]] {
+  return func(t T.Tuple1[A1]) Either[E, T.Tuple1[T1]] {
+    return A.TraverseTuple1(
+      Map[E, T1, T.Tuple1[T1]],
+      f1,
+      t,
+    )
+  }
+}
+
+// Eitherize2 converts a function with 2 parameters returning a tuple into a function with 2 parameters returning an Either
+// The inverse function is [Uneitherize2]
+func Eitherize2[F ~func(T0, T1) (R, error), T0, T1, R any](f F) func(T0, T1) Either[error, R] {
+  return func(t0 T0, t1 T1) Either[error, R] {
+    return TryCatchError(func() (R, error) {
+      return f(t0, t1)
+    })
+  }
+}
+
+// Uneitherize2 converts a function with 2 parameters returning an Either into a function with 2 parameters returning a tuple
+// The inverse function is [Eitherize2]
+func Uneitherize2[F ~func(T0, T1) Either[error, R], T0, T1, R any](f F) func(T0, T1) (R, error) {
+  return func(t0 T0, t1 T1) (R, error) {
+    return UnwrapError(f(t0, t1))
+  }
+}
+
+// SequenceT2 converts 2 parameters of [Either[E, T]] into an [Either] of a [Tuple2].
+func SequenceT2[E, T1, T2 any](t1 Either[E, T1], t2 Either[E, T2]) Either[E, T.Tuple2[T1, T2]] {
+  return A.SequenceT2(
+    Map[E, T1, func(T2) T.Tuple2[T1, T2]],
+    Ap[T.Tuple2[T1, T2], E, T2],
+    t1,
+    t2,
+  )
+}
+
+// SequenceTuple2 converts a [Tuple2] of [Either[E, T]] into an [Either[E, Tuple2]].
+func SequenceTuple2[E, T1, T2 any](t T.Tuple2[Either[E, T1], Either[E, T2]]) Either[E, T.Tuple2[T1, T2]] {
+  return A.SequenceTuple2(
+    Map[E, T1, func(T2) T.Tuple2[T1, T2]],
+    Ap[T.Tuple2[T1, T2], E, T2],
+    t,
+  )
+}
+
+// TraverseTuple2 converts a [Tuple2] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple2]].
+func TraverseTuple2[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], E, A1, T1, A2, T2 any](f1 F1, f2 F2) func (T.Tuple2[A1, A2]) Either[E, T.Tuple2[T1, T2]] {
+  return func(t T.Tuple2[A1, A2]) Either[E, T.Tuple2[T1, T2]] {
+    return A.TraverseTuple2(
+      Map[E, T1, func(T2) T.Tuple2[T1, T2]],
+      Ap[T.Tuple2[T1, T2], E, T2],
+      f1,
+      f2,
+      t,
+    )
+  }
+}
+
+// Eitherize3 converts a function with 3 parameters returning a tuple into a function with 3 parameters returning an Either
+// The inverse function is [Uneitherize3]
+func Eitherize3[F ~func(T0, T1, T2) (R, error), T0, T1, T2, R any](f F) func(T0, T1, T2) Either[error, R] {
+  return func(t0 T0, t1 T1, t2 T2) Either[error, R] {
+    return TryCatchError(func() (R, error) {
+      return f(t0, t1, t2)
+    })
+  }
+}
+
+// Uneitherize3 converts a function with 3 parameters returning an Either into a function with 3 parameters returning a tuple
+// The inverse function is [Eitherize3]
+func Uneitherize3[F ~func(T0, T1, T2) Either[error, R], T0, T1, T2, R any](f F) func(T0, T1, T2) (R, error) {
+  return func(t0 T0, t1 T1, t2 T2) (R, error) {
+    return UnwrapError(f(t0, t1, t2))
+  }
+}
+
+// SequenceT3 converts 3 parameters of [Either[E, T]] into an [Either] of a [Tuple3].
+func SequenceT3[E, T1, T2, T3 any](t1 Either[E, T1], t2 Either[E, T2], t3 Either[E, T3]) Either[E, T.Tuple3[T1, T2, T3]] {
+  return A.SequenceT3(
+    Map[E, T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
+    Ap[func(T3) T.Tuple3[T1, T2, T3], E, T2],
+    Ap[T.Tuple3[T1, T2, T3], E, T3],
+    t1,
+    t2,
+    t3,
+  )
+}
+
+// SequenceTuple3 converts a [Tuple3] of [Either[E, T]] into an [Either[E, Tuple3]].
+func SequenceTuple3[E, T1, T2, T3 any](t T.Tuple3[Either[E, T1], Either[E, T2], Either[E, T3]]) Either[E, T.Tuple3[T1, T2, T3]] {
+  return A.SequenceTuple3(
+    Map[E, T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
+    Ap[func(T3) T.Tuple3[T1, T2, T3], E, T2],
+    Ap[T.Tuple3[T1, T2, T3], E, T3],
+    t,
+  )
+}
+
+// TraverseTuple3 converts a [Tuple3] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple3]].
+func TraverseTuple3[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], E, A1, T1, A2, T2, A3, T3 any](f1 F1, f2 F2, f3 F3) func (T.Tuple3[A1, A2, A3]) Either[E, T.Tuple3[T1, T2, T3]] {
+  return func(t T.Tuple3[A1, A2, A3]) Either[E, T.Tuple3[T1, T2, T3]] {
+    return A.TraverseTuple3(
+      Map[E, T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
+      Ap[func(T3) T.Tuple3[T1, T2, T3], E, T2],
+      Ap[T.Tuple3[T1, T2, T3], E, T3],
+      f1,
+      f2,
+      f3,
+      t,
+    )
+  }
+}
+
+// Eitherize4 converts a function with 4 parameters returning a tuple into a function with 4 parameters returning an Either
+// The inverse function is [Uneitherize4]
+func Eitherize4[F ~func(T0, T1, T2, T3) (R, error), T0, T1, T2, T3, R any](f F) func(T0, T1, T2, T3) Either[error, R] {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3) Either[error, R] {
+    return TryCatchError(func() (R, error) {
+      return f(t0, t1, t2, t3)
+    })
+  }
+}
+
+// Uneitherize4 converts a function with 4 parameters returning an Either into a function with 4 parameters returning a tuple
+// The inverse function is [Eitherize4]
+func Uneitherize4[F ~func(T0, T1, T2, T3) Either[error, R], T0, T1, T2, T3, R any](f F) func(T0, T1, T2, T3) (R, error) {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3) (R, error) {
+    return UnwrapError(f(t0, t1, t2, t3))
+  }
+}
+
+// SequenceT4 converts 4 parameters of [Either[E, T]] into an [Either] of a [Tuple4].
+func SequenceT4[E, T1, T2, T3, T4 any](t1 Either[E, T1], t2 Either[E, T2], t3 Either[E, T3], t4 Either[E, T4]) Either[E, T.Tuple4[T1, T2, T3, T4]] {
+  return A.SequenceT4(
+    Map[E, T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
+    Ap[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], E, T2],
+    Ap[func(T4) T.Tuple4[T1, T2, T3, T4], E, T3],
+    Ap[T.Tuple4[T1, T2, T3, T4], E, T4],
+    t1,
+    t2,
+    t3,
+    t4,
+  )
+}
+
+// SequenceTuple4 converts a [Tuple4] of [Either[E, T]] into an [Either[E, Tuple4]].
+func SequenceTuple4[E, T1, T2, T3, T4 any](t T.Tuple4[Either[E, T1], Either[E, T2], Either[E, T3], Either[E, T4]]) Either[E, T.Tuple4[T1, T2, T3, T4]] {
+  return A.SequenceTuple4(
+    Map[E, T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
+    Ap[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], E, T2],
+    Ap[func(T4) T.Tuple4[T1, T2, T3, T4], E, T3],
+    Ap[T.Tuple4[T1, T2, T3, T4], E, T4],
+    t,
+  )
+}
+
+// TraverseTuple4 converts a [Tuple4] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple4]].
+func TraverseTuple4[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], E, A1, T1, A2, T2, A3, T3, A4, T4 any](f1 F1, f2 F2, f3 F3, f4 F4) func (T.Tuple4[A1, A2, A3, A4]) Either[E, T.Tuple4[T1, T2, T3, T4]] {
+  return func(t T.Tuple4[A1, A2, A3, A4]) Either[E, T.Tuple4[T1, T2, T3, T4]] {
+    return A.TraverseTuple4(
+      Map[E, T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
+      Ap[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], E, T2],
+      Ap[func(T4) T.Tuple4[T1, T2, T3, T4], E, T3],
+      Ap[T.Tuple4[T1, T2, T3, T4], E, T4],
+      f1,
+      f2,
+      f3,
+      f4,
+      t,
+    )
+  }
+}
+
+// Eitherize5 converts a function with 5 parameters returning a tuple into a function with 5 parameters returning an Either
+// The inverse function is [Uneitherize5]
+func Eitherize5[F ~func(T0, T1, T2, T3, T4) (R, error), T0, T1, T2, T3, T4, R any](f F) func(T0, T1, T2, T3, T4) Either[error, R] {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) Either[error, R] {
+    return TryCatchError(func() (R, error) {
+      return f(t0, t1, t2, t3, t4)
+    })
+  }
+}
+
+// Uneitherize5 converts a function with 5 parameters returning an Either into a function with 5 parameters returning a tuple
+// The inverse function is [Eitherize5]
+func Uneitherize5[F ~func(T0, T1, T2, T3, T4) Either[error, R], T0, T1, T2, T3, T4, R any](f F) func(T0, T1, T2, T3, T4) (R, error) {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) (R, error) {
+    return UnwrapError(f(t0, t1, t2, t3, t4))
+  }
+}
+
+// SequenceT5 converts 5 parameters of [Either[E, T]] into an [Either] of a [Tuple5].
+func SequenceT5[E, T1, T2, T3, T4, T5 any](t1 Either[E, T1], t2 Either[E, T2], t3 Either[E, T3], t4 Either[E, T4], t5 Either[E, T5]) Either[E, T.Tuple5[T1, T2, T3, T4, T5]] {
+  return A.SequenceT5(
+    Map[E, 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], E, T2],
+    Ap[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], E, T3],
+    Ap[func(T5) T.Tuple5[T1, T2, T3, T4, T5], E, T4],
+    Ap[T.Tuple5[T1, T2, T3, T4, T5], E, T5],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+  )
+}
+
+// SequenceTuple5 converts a [Tuple5] of [Either[E, T]] into an [Either[E, Tuple5]].
+func SequenceTuple5[E, T1, T2, T3, T4, T5 any](t T.Tuple5[Either[E, T1], Either[E, T2], Either[E, T3], Either[E, T4], Either[E, T5]]) Either[E, T.Tuple5[T1, T2, T3, T4, T5]] {
+  return A.SequenceTuple5(
+    Map[E, 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], E, T2],
+    Ap[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], E, T3],
+    Ap[func(T5) T.Tuple5[T1, T2, T3, T4, T5], E, T4],
+    Ap[T.Tuple5[T1, T2, T3, T4, T5], E, T5],
+    t,
+  )
+}
+
+// TraverseTuple5 converts a [Tuple5] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple5]].
+func TraverseTuple5[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], E, 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]) Either[E, T.Tuple5[T1, T2, T3, T4, T5]] {
+  return func(t T.Tuple5[A1, A2, A3, A4, A5]) Either[E, T.Tuple5[T1, T2, T3, T4, T5]] {
+    return A.TraverseTuple5(
+      Map[E, 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], E, T2],
+      Ap[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], E, T3],
+      Ap[func(T5) T.Tuple5[T1, T2, T3, T4, T5], E, T4],
+      Ap[T.Tuple5[T1, T2, T3, T4, T5], E, T5],
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      t,
+    )
+  }
+}
+
+// Eitherize6 converts a function with 6 parameters returning a tuple into a function with 6 parameters returning an Either
+// The inverse function is [Uneitherize6]
+func Eitherize6[F ~func(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) Either[error, R] {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) Either[error, R] {
+    return TryCatchError(func() (R, error) {
+      return f(t0, t1, t2, t3, t4, t5)
+    })
+  }
+}
+
+// Uneitherize6 converts a function with 6 parameters returning an Either into a function with 6 parameters returning a tuple
+// The inverse function is [Eitherize6]
+func Uneitherize6[F ~func(T0, T1, T2, T3, T4, T5) Either[error, R], T0, T1, T2, T3, T4, T5, R any](f F) func(T0, T1, T2, T3, T4, T5) (R, error) {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R, error) {
+    return UnwrapError(f(t0, t1, t2, t3, t4, t5))
+  }
+}
+
+// SequenceT6 converts 6 parameters of [Either[E, T]] into an [Either] of a [Tuple6].
+func SequenceT6[E, T1, T2, T3, T4, T5, T6 any](t1 Either[E, T1], t2 Either[E, T2], t3 Either[E, T3], t4 Either[E, T4], t5 Either[E, T5], t6 Either[E, T6]) Either[E, T.Tuple6[T1, T2, T3, T4, T5, T6]] {
+  return A.SequenceT6(
+    Map[E, 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], E, T2],
+    Ap[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], E, T3],
+    Ap[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], E, T4],
+    Ap[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], E, T5],
+    Ap[T.Tuple6[T1, T2, T3, T4, T5, T6], E, T6],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+  )
+}
+
+// SequenceTuple6 converts a [Tuple6] of [Either[E, T]] into an [Either[E, Tuple6]].
+func SequenceTuple6[E, T1, T2, T3, T4, T5, T6 any](t T.Tuple6[Either[E, T1], Either[E, T2], Either[E, T3], Either[E, T4], Either[E, T5], Either[E, T6]]) Either[E, T.Tuple6[T1, T2, T3, T4, T5, T6]] {
+  return A.SequenceTuple6(
+    Map[E, 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], E, T2],
+    Ap[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], E, T3],
+    Ap[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], E, T4],
+    Ap[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], E, T5],
+    Ap[T.Tuple6[T1, T2, T3, T4, T5, T6], E, T6],
+    t,
+  )
+}
+
+// TraverseTuple6 converts a [Tuple6] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple6]].
+func TraverseTuple6[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], E, 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]) Either[E, T.Tuple6[T1, T2, T3, T4, T5, T6]] {
+  return func(t T.Tuple6[A1, A2, A3, A4, A5, A6]) Either[E, T.Tuple6[T1, T2, T3, T4, T5, T6]] {
+    return A.TraverseTuple6(
+      Map[E, 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], E, T2],
+      Ap[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], E, T3],
+      Ap[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], E, T4],
+      Ap[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], E, T5],
+      Ap[T.Tuple6[T1, T2, T3, T4, T5, T6], E, T6],
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      t,
+    )
+  }
+}
+
+// Eitherize7 converts a function with 7 parameters returning a tuple into a function with 7 parameters returning an Either
+// The inverse function is [Uneitherize7]
+func Eitherize7[F ~func(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) Either[error, R] {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) Either[error, R] {
+    return TryCatchError(func() (R, error) {
+      return f(t0, t1, t2, t3, t4, t5, t6)
+    })
+  }
+}
+
+// Uneitherize7 converts a function with 7 parameters returning an Either into a function with 7 parameters returning a tuple
+// The inverse function is [Eitherize7]
+func Uneitherize7[F ~func(T0, T1, T2, T3, T4, T5, T6) Either[error, R], T0, T1, T2, T3, T4, T5, T6, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) (R, error) {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R, error) {
+    return UnwrapError(f(t0, t1, t2, t3, t4, t5, t6))
+  }
+}
+
+// SequenceT7 converts 7 parameters of [Either[E, T]] into an [Either] of a [Tuple7].
+func SequenceT7[E, T1, T2, T3, T4, T5, T6, T7 any](t1 Either[E, T1], t2 Either[E, T2], t3 Either[E, T3], t4 Either[E, T4], t5 Either[E, T5], t6 Either[E, T6], t7 Either[E, T7]) Either[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
+  return A.SequenceT7(
+    Map[E, 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], E, T2],
+    Ap[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], E, T3],
+    Ap[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], E, T4],
+    Ap[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], E, T5],
+    Ap[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], E, T6],
+    Ap[T.Tuple7[T1, T2, T3, T4, T5, T6, T7], E, T7],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+  )
+}
+
+// SequenceTuple7 converts a [Tuple7] of [Either[E, T]] into an [Either[E, Tuple7]].
+func SequenceTuple7[E, T1, T2, T3, T4, T5, T6, T7 any](t T.Tuple7[Either[E, T1], Either[E, T2], Either[E, T3], Either[E, T4], Either[E, T5], Either[E, T6], Either[E, T7]]) Either[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
+  return A.SequenceTuple7(
+    Map[E, 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], E, T2],
+    Ap[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], E, T3],
+    Ap[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], E, T4],
+    Ap[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], E, T5],
+    Ap[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], E, T6],
+    Ap[T.Tuple7[T1, T2, T3, T4, T5, T6, T7], E, T7],
+    t,
+  )
+}
+
+// TraverseTuple7 converts a [Tuple7] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple7]].
+func TraverseTuple7[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], E, 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]) Either[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
+  return func(t T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) Either[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
+    return A.TraverseTuple7(
+      Map[E, 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], E, T2],
+      Ap[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], E, T3],
+      Ap[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], E, T4],
+      Ap[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], E, T5],
+      Ap[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], E, T6],
+      Ap[T.Tuple7[T1, T2, T3, T4, T5, T6, T7], E, T7],
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      t,
+    )
+  }
+}
+
+// Eitherize8 converts a function with 8 parameters returning a tuple into a function with 8 parameters returning an Either
+// The inverse function is [Uneitherize8]
+func Eitherize8[F ~func(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) Either[error, R] {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) Either[error, R] {
+    return TryCatchError(func() (R, error) {
+      return f(t0, t1, t2, t3, t4, t5, t6, t7)
+    })
+  }
+}
+
+// Uneitherize8 converts a function with 8 parameters returning an Either into a function with 8 parameters returning a tuple
+// The inverse function is [Eitherize8]
+func Uneitherize8[F ~func(T0, T1, T2, T3, T4, T5, T6, T7) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) (R, error) {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R, error) {
+    return UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7))
+  }
+}
+
+// SequenceT8 converts 8 parameters of [Either[E, T]] into an [Either] of a [Tuple8].
+func SequenceT8[E, T1, T2, T3, T4, T5, T6, T7, T8 any](t1 Either[E, T1], t2 Either[E, T2], t3 Either[E, T3], t4 Either[E, T4], t5 Either[E, T5], t6 Either[E, T6], t7 Either[E, T7], t8 Either[E, T8]) Either[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
+  return A.SequenceT8(
+    Map[E, 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], E, T2],
+    Ap[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], E, T3],
+    Ap[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], E, T4],
+    Ap[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], E, T5],
+    Ap[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], E, T6],
+    Ap[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], E, T7],
+    Ap[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], E, T8],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+    t8,
+  )
+}
+
+// SequenceTuple8 converts a [Tuple8] of [Either[E, T]] into an [Either[E, Tuple8]].
+func SequenceTuple8[E, T1, T2, T3, T4, T5, T6, T7, T8 any](t T.Tuple8[Either[E, T1], Either[E, T2], Either[E, T3], Either[E, T4], Either[E, T5], Either[E, T6], Either[E, T7], Either[E, T8]]) Either[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
+  return A.SequenceTuple8(
+    Map[E, 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], E, T2],
+    Ap[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], E, T3],
+    Ap[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], E, T4],
+    Ap[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], E, T5],
+    Ap[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], E, T6],
+    Ap[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], E, T7],
+    Ap[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], E, T8],
+    t,
+  )
+}
+
+// TraverseTuple8 converts a [Tuple8] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple8]].
+func TraverseTuple8[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], E, 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]) Either[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
+  return func(t T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) Either[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
+    return A.TraverseTuple8(
+      Map[E, 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], E, T2],
+      Ap[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], E, T3],
+      Ap[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], E, T4],
+      Ap[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], E, T5],
+      Ap[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], E, T6],
+      Ap[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], E, T7],
+      Ap[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], E, T8],
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      t,
+    )
+  }
+}
+
+// Eitherize9 converts a function with 9 parameters returning a tuple into a function with 9 parameters returning an Either
+// The inverse function is [Uneitherize9]
+func Eitherize9[F ~func(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) Either[error, R] {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) Either[error, R] {
+    return TryCatchError(func() (R, error) {
+      return f(t0, t1, t2, t3, t4, t5, t6, t7, t8)
+    })
+  }
+}
+
+// Uneitherize9 converts a function with 9 parameters returning an Either into a function with 9 parameters returning a tuple
+// The inverse function is [Eitherize9]
+func Uneitherize9[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error) {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R, error) {
+    return UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8))
+  }
+}
+
+// SequenceT9 converts 9 parameters of [Either[E, T]] into an [Either] of a [Tuple9].
+func SequenceT9[E, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t1 Either[E, T1], t2 Either[E, T2], t3 Either[E, T3], t4 Either[E, T4], t5 Either[E, T5], t6 Either[E, T6], t7 Either[E, T7], t8 Either[E, T8], t9 Either[E, T9]) Either[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
+  return A.SequenceT9(
+    Map[E, 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], E, 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], E, T3],
+    Ap[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], E, T4],
+    Ap[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], E, T5],
+    Ap[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], E, T6],
+    Ap[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], E, T7],
+    Ap[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], E, T8],
+    Ap[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], E, T9],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+    t8,
+    t9,
+  )
+}
+
+// SequenceTuple9 converts a [Tuple9] of [Either[E, T]] into an [Either[E, Tuple9]].
+func SequenceTuple9[E, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t T.Tuple9[Either[E, T1], Either[E, T2], Either[E, T3], Either[E, T4], Either[E, T5], Either[E, T6], Either[E, T7], Either[E, T8], Either[E, T9]]) Either[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
+  return A.SequenceTuple9(
+    Map[E, 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], E, 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], E, T3],
+    Ap[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], E, T4],
+    Ap[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], E, T5],
+    Ap[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], E, T6],
+    Ap[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], E, T7],
+    Ap[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], E, T8],
+    Ap[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], E, T9],
+    t,
+  )
+}
+
+// TraverseTuple9 converts a [Tuple9] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple9]].
+func TraverseTuple9[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], F9 ~func(A9) Either[E, T9], E, 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]) Either[E, 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]) Either[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
+    return A.TraverseTuple9(
+      Map[E, 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], E, 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], E, T3],
+      Ap[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], E, T4],
+      Ap[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], E, T5],
+      Ap[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], E, T6],
+      Ap[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], E, T7],
+      Ap[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], E, T8],
+      Ap[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], E, T9],
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      t,
+    )
+  }
+}
+
+// Eitherize10 converts a function with 10 parameters returning a tuple into a function with 10 parameters returning an Either
+// The inverse function is [Uneitherize10]
+func Eitherize10[F ~func(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) Either[error, R] {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) Either[error, R] {
+    return TryCatchError(func() (R, error) {
+      return f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+    })
+  }
+}
+
+// Uneitherize10 converts a function with 10 parameters returning an Either into a function with 10 parameters returning a tuple
+// The inverse function is [Eitherize10]
+func Uneitherize10[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) Either[error, R], 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) (R, error) {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R, error) {
+    return UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9))
+  }
+}
+
+// SequenceT10 converts 10 parameters of [Either[E, T]] into an [Either] of a [Tuple10].
+func SequenceT10[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t1 Either[E, T1], t2 Either[E, T2], t3 Either[E, T3], t4 Either[E, T4], t5 Either[E, T5], t6 Either[E, T6], t7 Either[E, T7], t8 Either[E, T8], t9 Either[E, T9], t10 Either[E, T10]) Either[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
+  return A.SequenceT10(
+    Map[E, 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], E, 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], E, 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], E, T4],
+    Ap[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], E, T5],
+    Ap[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], E, T6],
+    Ap[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], E, T7],
+    Ap[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], E, T8],
+    Ap[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], E, T9],
+    Ap[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], E, T10],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+    t8,
+    t9,
+    t10,
+  )
+}
+
+// SequenceTuple10 converts a [Tuple10] of [Either[E, T]] into an [Either[E, Tuple10]].
+func SequenceTuple10[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t T.Tuple10[Either[E, T1], Either[E, T2], Either[E, T3], Either[E, T4], Either[E, T5], Either[E, T6], Either[E, T7], Either[E, T8], Either[E, T9], Either[E, T10]]) Either[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
+  return A.SequenceTuple10(
+    Map[E, 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], E, 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], E, 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], E, T4],
+    Ap[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], E, T5],
+    Ap[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], E, T6],
+    Ap[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], E, T7],
+    Ap[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], E, T8],
+    Ap[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], E, T9],
+    Ap[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], E, T10],
+    t,
+  )
+}
+
+// TraverseTuple10 converts a [Tuple10] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple10]].
+func TraverseTuple10[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], F9 ~func(A9) Either[E, T9], F10 ~func(A10) Either[E, T10], E, 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]) Either[E, 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]) Either[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
+    return A.TraverseTuple10(
+      Map[E, 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], E, 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], E, 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], E, T4],
+      Ap[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], E, T5],
+      Ap[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], E, T6],
+      Ap[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], E, T7],
+      Ap[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], E, T8],
+      Ap[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], E, T9],
+      Ap[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], E, T10],
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      t,
+    )
+  }
+}

either/sequence.go

@@ -1,45 +0,0 @@
-package either
-
-import (
-	"github.com/ibm/fp-go/internal/apply"
-	T "github.com/ibm/fp-go/tuple"
-)
-
-// SequenceT converts n inputs of higher kinded types into a higher kinded types of n strongly typed values, represented as a tuple
-
-func SequenceT1[E, A any](a Either[E, A]) Either[E, T.Tuple1[A]] {
-	return apply.SequenceT1(
-		Map[E, A, T.Tuple1[A]],
-		a,
-	)
-}
-
-func SequenceT2[E, A, B any](a Either[E, A], b Either[E, B]) Either[E, T.Tuple2[A, B]] {
-	return apply.SequenceT2(
-		Map[E, A, func(B) T.Tuple2[A, B]],
-		Ap[T.Tuple2[A, B], E, B],
-
-		a, b,
-	)
-}
-
-func SequenceT3[E, A, B, C any](a Either[E, A], b Either[E, B], c Either[E, C]) Either[E, T.Tuple3[A, B, C]] {
-	return apply.SequenceT3(
-		Map[E, A, func(B) func(C) T.Tuple3[A, B, C]],
-		Ap[func(C) T.Tuple3[A, B, C], E, B],
-		Ap[T.Tuple3[A, B, C], E, C],
-
-		a, b, c,
-	)
-}
-
-func SequenceT4[E, A, B, C, D any](a Either[E, A], b Either[E, B], c Either[E, C], d Either[E, D]) Either[E, T.Tuple4[A, B, C, D]] {
-	return apply.SequenceT4(
-		Map[E, A, func(B) func(C) func(D) T.Tuple4[A, B, C, D]],
-		Ap[func(C) func(D) T.Tuple4[A, B, C, D], E, B],
-		Ap[func(D) T.Tuple4[A, B, C, D], E, C],
-		Ap[T.Tuple4[A, B, C, D], E, D],
-
-		a, b, c, d,
-	)
-}

function/binds.go

@@ -1,8 +1,7 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-14 13:19:42.9896471 +0200 CEST m=+0.009694501
+// 2023-07-17 13:23:07.340967 +0200 CEST m=+0.009883801
 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.
@@ -21,7 +20,6 @@ func Ignore1of1[T1 any, F ~func() R, R any](f F) func(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.
@@ -74,7 +72,6 @@ func Ignore12of2[T1, T2 any, F ~func() R, R any](f F) func(T1, 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.
@@ -195,7 +192,6 @@ func Ignore123of3[T1, T2, T3 any, F ~func() R, R any](f F) func(T1, T2, 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.

function/gen.go

@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-14 13:19:41.7019184 +0200 CEST m=+0.010131401
+// 2023-07-17 13:22:59.4952853 +0200 CEST m=+0.226069901
 package function
 
 // Pipe0 takes an initial value t0 and successively applies 0 functions where the input of a function is the return value of the previous function
@@ -15,14 +15,12 @@ func Variadic0[V, R any](f func([]V) R) func(...V) R {
     return f(v)
   }
 }
-
 // Unvariadic0 converts a function taking 0 parameters and a final variadic argument into a function with 0 parameters but a final slice argument
 func Unvariadic0[V, R any](f func(...V) R) func([]V) R {
   return func(v []V) R {
     return f(v...)
   }
 }
-
 // Pipe1 takes an initial value t0 and successively applies 1 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe1[F1 ~func(T0) T1, T0, T1 any](t0 T0, f1 F1) T1 {
@@ -67,14 +65,12 @@ func Variadic1[T1, V, R any](f func(T1, []V) R) func(T1, ...V) R {
     return f(t1, v)
   }
 }
-
 // Unvariadic1 converts a function taking 1 parameters and a final variadic argument into a function with 1 parameters but a final slice argument
 func Unvariadic1[T1, V, R any](f func(T1, ...V) R) func(T1, []V) R {
   return func(t1 T1, v []V) R {
     return f(t1, v...)
   }
 }
-
 // Pipe2 takes an initial value t0 and successively applies 2 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe2[F1 ~func(T0) T1, F2 ~func(T1) T2, T0, T1, T2 any](t0 T0, f1 F1, f2 F2) T2 {
@@ -122,14 +118,12 @@ func Variadic2[T1, T2, V, R any](f func(T1, T2, []V) R) func(T1, T2, ...V) R {
     return f(t1, t2, v)
   }
 }
-
 // Unvariadic2 converts a function taking 2 parameters and a final variadic argument into a function with 2 parameters but a final slice argument
 func Unvariadic2[T1, T2, V, R any](f func(T1, T2, ...V) R) func(T1, T2, []V) R {
   return func(t1 T1, t2 T2, v []V) R {
     return f(t1, t2, v...)
   }
 }
-
 // Pipe3 takes an initial value t0 and successively applies 3 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe3[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, T0, T1, T2, T3 any](t0 T0, f1 F1, f2 F2, f3 F3) T3 {
@@ -180,14 +174,12 @@ func Variadic3[T1, T2, T3, V, R any](f func(T1, T2, T3, []V) R) func(T1, T2, T3,
     return f(t1, t2, t3, v)
   }
 }
-
 // Unvariadic3 converts a function taking 3 parameters and a final variadic argument into a function with 3 parameters but a final slice argument
 func Unvariadic3[T1, T2, T3, V, R any](f func(T1, T2, T3, ...V) R) func(T1, T2, T3, []V) R {
   return func(t1 T1, t2 T2, t3 T3, v []V) R {
     return f(t1, t2, t3, v...)
   }
 }
-
 // Pipe4 takes an initial value t0 and successively applies 4 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe4[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, T0, T1, T2, T3, T4 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4) T4 {
@@ -241,14 +233,12 @@ func Variadic4[T1, T2, T3, T4, V, R any](f func(T1, T2, T3, T4, []V) R) func(T1,
     return f(t1, t2, t3, t4, v)
   }
 }
-
 // Unvariadic4 converts a function taking 4 parameters and a final variadic argument into a function with 4 parameters but a final slice argument
 func Unvariadic4[T1, T2, T3, T4, V, R any](f func(T1, T2, T3, T4, ...V) R) func(T1, T2, T3, T4, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, v []V) R {
     return f(t1, t2, t3, t4, v...)
   }
 }
-
 // Pipe5 takes an initial value t0 and successively applies 5 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe5[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, T0, T1, T2, T3, T4, T5 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) T5 {
@@ -305,14 +295,12 @@ func Variadic5[T1, T2, T3, T4, T5, V, R any](f func(T1, T2, T3, T4, T5, []V) R)
     return f(t1, t2, t3, t4, t5, v)
   }
 }
-
 // Unvariadic5 converts a function taking 5 parameters and a final variadic argument into a function with 5 parameters but a final slice argument
 func Unvariadic5[T1, T2, T3, T4, T5, V, R any](f func(T1, T2, T3, T4, T5, ...V) R) func(T1, T2, T3, T4, T5, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, v []V) R {
     return f(t1, t2, t3, t4, t5, v...)
   }
 }
-
 // Pipe6 takes an initial value t0 and successively applies 6 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe6[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, T0, T1, T2, T3, T4, T5, T6 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) T6 {
@@ -372,14 +360,12 @@ func Variadic6[T1, T2, T3, T4, T5, T6, V, R any](f func(T1, T2, T3, T4, T5, T6,
     return f(t1, t2, t3, t4, t5, t6, v)
   }
 }
-
 // Unvariadic6 converts a function taking 6 parameters and a final variadic argument into a function with 6 parameters but a final slice argument
 func Unvariadic6[T1, T2, T3, T4, T5, T6, V, R any](f func(T1, T2, T3, T4, T5, T6, ...V) R) func(T1, T2, T3, T4, T5, T6, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, v...)
   }
 }
-
 // Pipe7 takes an initial value t0 and successively applies 7 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe7[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, T0, T1, T2, T3, T4, T5, T6, T7 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) T7 {
@@ -442,14 +428,12 @@ func Variadic7[T1, T2, T3, T4, T5, T6, T7, V, R any](f func(T1, T2, T3, T4, T5,
     return f(t1, t2, t3, t4, t5, t6, t7, v)
   }
 }
-
 // Unvariadic7 converts a function taking 7 parameters and a final variadic argument into a function with 7 parameters but a final slice argument
 func Unvariadic7[T1, T2, T3, T4, T5, T6, T7, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, v...)
   }
 }
-
 // Pipe8 takes an initial value t0 and successively applies 8 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe8[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, T0, T1, T2, T3, T4, T5, T6, T7, T8 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) T8 {
@@ -515,14 +499,12 @@ func Variadic8[T1, T2, T3, T4, T5, T6, T7, T8, V, R any](f func(T1, T2, T3, T4,
     return f(t1, t2, t3, t4, t5, t6, t7, t8, v)
   }
 }
-
 // Unvariadic8 converts a function taking 8 parameters and a final variadic argument into a function with 8 parameters but a final slice argument
 func Unvariadic8[T1, T2, T3, T4, T5, T6, T7, T8, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, v...)
   }
 }
-
 // Pipe9 takes an initial value t0 and successively applies 9 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe9[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) T9 {
@@ -591,14 +573,12 @@ func Variadic9[T1, T2, T3, T4, T5, T6, T7, T8, T9, V, R any](f func(T1, T2, T3,
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, v)
   }
 }
-
 // Unvariadic9 converts a function taking 9 parameters and a final variadic argument into a function with 9 parameters but a final slice argument
 func Unvariadic9[T1, T2, T3, T4, T5, T6, T7, T8, T9, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, v...)
   }
 }
-
 // Pipe10 takes an initial value t0 and successively applies 10 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe10[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) T10 {
@@ -670,14 +650,12 @@ func Variadic10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, V, R any](f func(T1, T2
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, v)
   }
 }
-
 // Unvariadic10 converts a function taking 10 parameters and a final variadic argument into a function with 10 parameters but a final slice argument
 func Unvariadic10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, v...)
   }
 }
-
 // Pipe11 takes an initial value t0 and successively applies 11 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe11[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11) T11 {
@@ -752,14 +730,12 @@ func Variadic11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, V, R any](f func(T
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, v)
   }
 }
-
 // Unvariadic11 converts a function taking 11 parameters and a final variadic argument into a function with 11 parameters but a final slice argument
 func Unvariadic11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, v...)
   }
 }
-
 // Pipe12 takes an initial value t0 and successively applies 12 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe12[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12) T12 {
@@ -837,14 +813,12 @@ func Variadic12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, V, R any](f f
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, v)
   }
 }
-
 // Unvariadic12 converts a function taking 12 parameters and a final variadic argument into a function with 12 parameters but a final slice argument
 func Unvariadic12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, v...)
   }
 }
-
 // Pipe13 takes an initial value t0 and successively applies 13 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe13[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13) T13 {
@@ -925,14 +899,12 @@ func Variadic13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, V, R any
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, v)
   }
 }
-
 // Unvariadic13 converts a function taking 13 parameters and a final variadic argument into a function with 13 parameters but a final slice argument
 func Unvariadic13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, v...)
   }
 }
-
 // Pipe14 takes an initial value t0 and successively applies 14 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe14[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14) T14 {
@@ -1016,14 +988,12 @@ func Variadic14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, V,
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, v)
   }
 }
-
 // Unvariadic14 converts a function taking 14 parameters and a final variadic argument into a function with 14 parameters but a final slice argument
 func Unvariadic14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, v...)
   }
 }
-
 // Pipe15 takes an initial value t0 and successively applies 15 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe15[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15) T15 {
@@ -1110,14 +1080,12 @@ func Variadic15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, v)
   }
 }
-
 // Unvariadic15 converts a function taking 15 parameters and a final variadic argument into a function with 15 parameters but a final slice argument
 func Unvariadic15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, t15 T15, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, v...)
   }
 }
-
 // Pipe16 takes an initial value t0 and successively applies 16 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe16[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16) T16 {
@@ -1207,14 +1175,12 @@ func Variadic16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, v)
   }
 }
-
 // Unvariadic16 converts a function taking 16 parameters and a final variadic argument into a function with 16 parameters but a final slice argument
 func Unvariadic16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, t15 T15, t16 T16, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, v...)
   }
 }
-
 // Pipe17 takes an initial value t0 and successively applies 17 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe17[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17) T17 {
@@ -1307,14 +1273,12 @@ func Variadic17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, v)
   }
 }
-
 // Unvariadic17 converts a function taking 17 parameters and a final variadic argument into a function with 17 parameters but a final slice argument
 func Unvariadic17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, t15 T15, t16 T16, t17 T17, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, v...)
   }
 }
-
 // Pipe18 takes an initial value t0 and successively applies 18 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe18[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18) T18 {
@@ -1410,14 +1374,12 @@ func Variadic18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, v)
   }
 }
-
 // Unvariadic18 converts a function taking 18 parameters and a final variadic argument into a function with 18 parameters but a final slice argument
 func Unvariadic18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, t15 T15, t16 T16, t17 T17, t18 T18, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, v...)
   }
 }
-
 // Pipe19 takes an initial value t0 and successively applies 19 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe19[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, F19 ~func(T18) T19, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18, f19 F19) T19 {
@@ -1516,14 +1478,12 @@ func Variadic19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, v)
   }
 }
-
 // Unvariadic19 converts a function taking 19 parameters and a final variadic argument into a function with 19 parameters but a final slice argument
 func Unvariadic19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, t15 T15, t16 T16, t17 T17, t18 T18, t19 T19, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, v...)
   }
 }
-
 // Pipe20 takes an initial value t0 and successively applies 20 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe20[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, F19 ~func(T18) T19, F20 ~func(T19) T20, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18, f19 F19, f20 F20) T20 {
@@ -1625,7 +1585,6 @@ func Variadic20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, v)
   }
 }
-
 // Unvariadic20 converts a function taking 20 parameters and a final variadic argument into a function with 20 parameters but a final slice argument
 func Unvariadic20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, t15 T15, t16 T16, t17 T17, t18 T18, t19 T19, t20 T20, v []V) R {

option/doc.go

@@ -1,3 +1,3 @@
 package option
 
-//go:generate go run .. option --count 10 --filename optionize.go
+//go:generate go run .. option --count 10 --filename gen.go

option/gen.go

@@ -0,0 +1,518 @@
+// Code generated by go generate; DO NOT EDIT.
+// This file was generated by robots at
+// 2023-07-17 13:23:13.386184 +0200 CEST m=+0.015046301
+package option
+
+
+import (
+	A "github.com/ibm/fp-go/internal/apply"
+	T "github.com/ibm/fp-go/tuple"
+)
+// optionize converts a nullary function to an option
+func optionize[R any](f func() (R, bool)) Option[R] {
+	if r, ok := f(); ok {
+		return Some(r)
+	}
+	return None[R]()
+}
+
+// Optionize0 converts a function with 0 parameters returning a tuple of a return value R and a boolean into a function with 0 parameters returning an Option[R]
+func Optionize0[F ~func() (R, bool), R any](f F) func() Option[R] {
+  return func() Option[R] {
+    return optionize(func() (R, bool) {
+      return f()
+    })
+  }
+}
+
+// Unoptionize0 converts a function with 0 parameters returning a tuple of a return value R and a boolean into a function with 0 parameters returning an Option[R]
+func Unoptionize0[F ~func() Option[R], R any](f F) func() (R, bool) {
+  return func() (R, bool) {
+    return Unwrap(f())
+  }
+}
+
+// Optionize1 converts a function with 1 parameters returning a tuple of a return value R and a boolean into a function with 1 parameters returning an Option[R]
+func Optionize1[F ~func(T0) (R, bool), T0, R any](f F) func(T0) Option[R] {
+  return func(t0 T0) Option[R] {
+    return optionize(func() (R, bool) {
+      return f(t0)
+    })
+  }
+}
+
+// Unoptionize1 converts a function with 1 parameters returning a tuple of a return value R and a boolean into a function with 1 parameters returning an Option[R]
+func Unoptionize1[F ~func(T0) Option[R], T0, R any](f F) func(T0) (R, bool) {
+  return func(t0 T0) (R, bool) {
+    return Unwrap(f(t0))
+  }
+}
+
+// SequenceTuple1 converts a [Tuple1] of [Option[T]] into an [Option[Tuple1]].
+func SequenceTuple1[T1 any](t T.Tuple1[Option[T1]]) Option[T.Tuple1[T1]] {
+  return A.SequenceTuple1(
+    Map[T1, T.Tuple1[T1]],
+    t,
+  )
+}
+
+// TraverseTuple1 converts a [Tuple1] of [A] via transformation functions transforming [A] to [Option[A]] into a [Option[Tuple1]].
+func TraverseTuple1[F1 ~func(A1) Option[T1], A1, T1 any](f1 F1) func (T.Tuple1[A1]) Option[T.Tuple1[T1]] {
+  return func(t T.Tuple1[A1]) Option[T.Tuple1[T1]] {
+    return A.TraverseTuple1(
+      Map[T1, T.Tuple1[T1]],
+      f1,
+      t,
+    )
+  }
+}
+
+// Optionize2 converts a function with 2 parameters returning a tuple of a return value R and a boolean into a function with 2 parameters returning an Option[R]
+func Optionize2[F ~func(T0, T1) (R, bool), T0, T1, R any](f F) func(T0, T1) Option[R] {
+  return func(t0 T0, t1 T1) Option[R] {
+    return optionize(func() (R, bool) {
+      return f(t0, t1)
+    })
+  }
+}
+
+// Unoptionize2 converts a function with 2 parameters returning a tuple of a return value R and a boolean into a function with 2 parameters returning an Option[R]
+func Unoptionize2[F ~func(T0, T1) Option[R], T0, T1, R any](f F) func(T0, T1) (R, bool) {
+  return func(t0 T0, t1 T1) (R, bool) {
+    return Unwrap(f(t0, t1))
+  }
+}
+
+// SequenceTuple2 converts a [Tuple2] of [Option[T]] into an [Option[Tuple2]].
+func SequenceTuple2[T1, T2 any](t T.Tuple2[Option[T1], Option[T2]]) Option[T.Tuple2[T1, T2]] {
+  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 [Option[A]] into a [Option[Tuple2]].
+func TraverseTuple2[F1 ~func(A1) Option[T1], F2 ~func(A2) Option[T2], A1, T1, A2, T2 any](f1 F1, f2 F2) func (T.Tuple2[A1, A2]) Option[T.Tuple2[T1, T2]] {
+  return func(t T.Tuple2[A1, A2]) Option[T.Tuple2[T1, T2]] {
+    return A.TraverseTuple2(
+      Map[T1, func(T2) T.Tuple2[T1, T2]],
+      Ap[T.Tuple2[T1, T2], T2],
+      f1,
+      f2,
+      t,
+    )
+  }
+}
+
+// Optionize3 converts a function with 3 parameters returning a tuple of a return value R and a boolean into a function with 3 parameters returning an Option[R]
+func Optionize3[F ~func(T0, T1, T2) (R, bool), T0, T1, T2, R any](f F) func(T0, T1, T2) Option[R] {
+  return func(t0 T0, t1 T1, t2 T2) Option[R] {
+    return optionize(func() (R, bool) {
+      return f(t0, t1, t2)
+    })
+  }
+}
+
+// Unoptionize3 converts a function with 3 parameters returning a tuple of a return value R and a boolean into a function with 3 parameters returning an Option[R]
+func Unoptionize3[F ~func(T0, T1, T2) Option[R], T0, T1, T2, R any](f F) func(T0, T1, T2) (R, bool) {
+  return func(t0 T0, t1 T1, t2 T2) (R, bool) {
+    return Unwrap(f(t0, t1, t2))
+  }
+}
+
+// SequenceTuple3 converts a [Tuple3] of [Option[T]] into an [Option[Tuple3]].
+func SequenceTuple3[T1, T2, T3 any](t T.Tuple3[Option[T1], Option[T2], Option[T3]]) Option[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,
+  )
+}
+
+// TraverseTuple3 converts a [Tuple3] of [A] via transformation functions transforming [A] to [Option[A]] into a [Option[Tuple3]].
+func TraverseTuple3[F1 ~func(A1) Option[T1], F2 ~func(A2) Option[T2], F3 ~func(A3) Option[T3], A1, T1, A2, T2, A3, T3 any](f1 F1, f2 F2, f3 F3) func (T.Tuple3[A1, A2, A3]) Option[T.Tuple3[T1, T2, T3]] {
+  return func(t T.Tuple3[A1, A2, A3]) Option[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,
+    )
+  }
+}
+
+// Optionize4 converts a function with 4 parameters returning a tuple of a return value R and a boolean into a function with 4 parameters returning an Option[R]
+func Optionize4[F ~func(T0, T1, T2, T3) (R, bool), T0, T1, T2, T3, R any](f F) func(T0, T1, T2, T3) Option[R] {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3) Option[R] {
+    return optionize(func() (R, bool) {
+      return f(t0, t1, t2, t3)
+    })
+  }
+}
+
+// Unoptionize4 converts a function with 4 parameters returning a tuple of a return value R and a boolean into a function with 4 parameters returning an Option[R]
+func Unoptionize4[F ~func(T0, T1, T2, T3) Option[R], T0, T1, T2, T3, R any](f F) func(T0, T1, T2, T3) (R, bool) {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3) (R, bool) {
+    return Unwrap(f(t0, t1, t2, t3))
+  }
+}
+
+// SequenceTuple4 converts a [Tuple4] of [Option[T]] into an [Option[Tuple4]].
+func SequenceTuple4[T1, T2, T3, T4 any](t T.Tuple4[Option[T1], Option[T2], Option[T3], Option[T4]]) Option[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,
+  )
+}
+
+// TraverseTuple4 converts a [Tuple4] of [A] via transformation functions transforming [A] to [Option[A]] into a [Option[Tuple4]].
+func TraverseTuple4[F1 ~func(A1) Option[T1], F2 ~func(A2) Option[T2], F3 ~func(A3) Option[T3], F4 ~func(A4) Option[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]) Option[T.Tuple4[T1, T2, T3, T4]] {
+  return func(t T.Tuple4[A1, A2, A3, A4]) Option[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,
+    )
+  }
+}
+
+// Optionize5 converts a function with 5 parameters returning a tuple of a return value R and a boolean into a function with 5 parameters returning an Option[R]
+func Optionize5[F ~func(T0, T1, T2, T3, T4) (R, bool), T0, T1, T2, T3, T4, R any](f F) func(T0, T1, T2, T3, T4) Option[R] {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) Option[R] {
+    return optionize(func() (R, bool) {
+      return f(t0, t1, t2, t3, t4)
+    })
+  }
+}
+
+// Unoptionize5 converts a function with 5 parameters returning a tuple of a return value R and a boolean into a function with 5 parameters returning an Option[R]
+func Unoptionize5[F ~func(T0, T1, T2, T3, T4) Option[R], T0, T1, T2, T3, T4, R any](f F) func(T0, T1, T2, T3, T4) (R, bool) {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) (R, bool) {
+    return Unwrap(f(t0, t1, t2, t3, t4))
+  }
+}
+
+// SequenceTuple5 converts a [Tuple5] of [Option[T]] into an [Option[Tuple5]].
+func SequenceTuple5[T1, T2, T3, T4, T5 any](t T.Tuple5[Option[T1], Option[T2], Option[T3], Option[T4], Option[T5]]) Option[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,
+  )
+}
+
+// TraverseTuple5 converts a [Tuple5] of [A] via transformation functions transforming [A] to [Option[A]] into a [Option[Tuple5]].
+func TraverseTuple5[F1 ~func(A1) Option[T1], F2 ~func(A2) Option[T2], F3 ~func(A3) Option[T3], F4 ~func(A4) Option[T4], F5 ~func(A5) Option[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]) Option[T.Tuple5[T1, T2, T3, T4, T5]] {
+  return func(t T.Tuple5[A1, A2, A3, A4, A5]) Option[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,
+    )
+  }
+}
+
+// Optionize6 converts a function with 6 parameters returning a tuple of a return value R and a boolean into a function with 6 parameters returning an Option[R]
+func Optionize6[F ~func(T0, T1, T2, T3, T4, T5) (R, bool), T0, T1, T2, T3, T4, T5, R any](f F) func(T0, T1, T2, T3, T4, T5) Option[R] {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) Option[R] {
+    return optionize(func() (R, bool) {
+      return f(t0, t1, t2, t3, t4, t5)
+    })
+  }
+}
+
+// Unoptionize6 converts a function with 6 parameters returning a tuple of a return value R and a boolean into a function with 6 parameters returning an Option[R]
+func Unoptionize6[F ~func(T0, T1, T2, T3, T4, T5) Option[R], T0, T1, T2, T3, T4, T5, R any](f F) func(T0, T1, T2, T3, T4, T5) (R, bool) {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R, bool) {
+    return Unwrap(f(t0, t1, t2, t3, t4, t5))
+  }
+}
+
+// SequenceTuple6 converts a [Tuple6] of [Option[T]] into an [Option[Tuple6]].
+func SequenceTuple6[T1, T2, T3, T4, T5, T6 any](t T.Tuple6[Option[T1], Option[T2], Option[T3], Option[T4], Option[T5], Option[T6]]) Option[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,
+  )
+}
+
+// TraverseTuple6 converts a [Tuple6] of [A] via transformation functions transforming [A] to [Option[A]] into a [Option[Tuple6]].
+func TraverseTuple6[F1 ~func(A1) Option[T1], F2 ~func(A2) Option[T2], F3 ~func(A3) Option[T3], F4 ~func(A4) Option[T4], F5 ~func(A5) Option[T5], F6 ~func(A6) Option[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]) Option[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
+  return func(t T.Tuple6[A1, A2, A3, A4, A5, A6]) Option[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,
+    )
+  }
+}
+
+// Optionize7 converts a function with 7 parameters returning a tuple of a return value R and a boolean into a function with 7 parameters returning an Option[R]
+func Optionize7[F ~func(T0, T1, T2, T3, T4, T5, T6) (R, bool), T0, T1, T2, T3, T4, T5, T6, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) Option[R] {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) Option[R] {
+    return optionize(func() (R, bool) {
+      return f(t0, t1, t2, t3, t4, t5, t6)
+    })
+  }
+}
+
+// Unoptionize7 converts a function with 7 parameters returning a tuple of a return value R and a boolean into a function with 7 parameters returning an Option[R]
+func Unoptionize7[F ~func(T0, T1, T2, T3, T4, T5, T6) Option[R], T0, T1, T2, T3, T4, T5, T6, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) (R, bool) {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R, bool) {
+    return Unwrap(f(t0, t1, t2, t3, t4, t5, t6))
+  }
+}
+
+// SequenceTuple7 converts a [Tuple7] of [Option[T]] into an [Option[Tuple7]].
+func SequenceTuple7[T1, T2, T3, T4, T5, T6, T7 any](t T.Tuple7[Option[T1], Option[T2], Option[T3], Option[T4], Option[T5], Option[T6], Option[T7]]) Option[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,
+  )
+}
+
+// TraverseTuple7 converts a [Tuple7] of [A] via transformation functions transforming [A] to [Option[A]] into a [Option[Tuple7]].
+func TraverseTuple7[F1 ~func(A1) Option[T1], F2 ~func(A2) Option[T2], F3 ~func(A3) Option[T3], F4 ~func(A4) Option[T4], F5 ~func(A5) Option[T5], F6 ~func(A6) Option[T6], F7 ~func(A7) Option[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]) Option[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
+  return func(t T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) Option[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,
+    )
+  }
+}
+
+// Optionize8 converts a function with 8 parameters returning a tuple of a return value R and a boolean into a function with 8 parameters returning an Option[R]
+func Optionize8[F ~func(T0, T1, T2, T3, T4, T5, T6, T7) (R, bool), T0, T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) Option[R] {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) Option[R] {
+    return optionize(func() (R, bool) {
+      return f(t0, t1, t2, t3, t4, t5, t6, t7)
+    })
+  }
+}
+
+// Unoptionize8 converts a function with 8 parameters returning a tuple of a return value R and a boolean into a function with 8 parameters returning an Option[R]
+func Unoptionize8[F ~func(T0, T1, T2, T3, T4, T5, T6, T7) Option[R], T0, T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) (R, bool) {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R, bool) {
+    return Unwrap(f(t0, t1, t2, t3, t4, t5, t6, t7))
+  }
+}
+
+// SequenceTuple8 converts a [Tuple8] of [Option[T]] into an [Option[Tuple8]].
+func SequenceTuple8[T1, T2, T3, T4, T5, T6, T7, T8 any](t T.Tuple8[Option[T1], Option[T2], Option[T3], Option[T4], Option[T5], Option[T6], Option[T7], Option[T8]]) Option[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,
+  )
+}
+
+// TraverseTuple8 converts a [Tuple8] of [A] via transformation functions transforming [A] to [Option[A]] into a [Option[Tuple8]].
+func TraverseTuple8[F1 ~func(A1) Option[T1], F2 ~func(A2) Option[T2], F3 ~func(A3) Option[T3], F4 ~func(A4) Option[T4], F5 ~func(A5) Option[T5], F6 ~func(A6) Option[T6], F7 ~func(A7) Option[T7], F8 ~func(A8) Option[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]) Option[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
+  return func(t T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) Option[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,
+    )
+  }
+}
+
+// Optionize9 converts a function with 9 parameters returning a tuple of a return value R and a boolean into a function with 9 parameters returning an Option[R]
+func Optionize9[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, bool), T0, T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) Option[R] {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) Option[R] {
+    return optionize(func() (R, bool) {
+      return f(t0, t1, t2, t3, t4, t5, t6, t7, t8)
+    })
+  }
+}
+
+// Unoptionize9 converts a function with 9 parameters returning a tuple of a return value R and a boolean into a function with 9 parameters returning an Option[R]
+func Unoptionize9[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) Option[R], T0, T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, bool) {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R, bool) {
+    return Unwrap(f(t0, t1, t2, t3, t4, t5, t6, t7, t8))
+  }
+}
+
+// SequenceTuple9 converts a [Tuple9] of [Option[T]] into an [Option[Tuple9]].
+func SequenceTuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t T.Tuple9[Option[T1], Option[T2], Option[T3], Option[T4], Option[T5], Option[T6], Option[T7], Option[T8], Option[T9]]) Option[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,
+  )
+}
+
+// TraverseTuple9 converts a [Tuple9] of [A] via transformation functions transforming [A] to [Option[A]] into a [Option[Tuple9]].
+func TraverseTuple9[F1 ~func(A1) Option[T1], F2 ~func(A2) Option[T2], F3 ~func(A3) Option[T3], F4 ~func(A4) Option[T4], F5 ~func(A5) Option[T5], F6 ~func(A6) Option[T6], F7 ~func(A7) Option[T7], F8 ~func(A8) Option[T8], F9 ~func(A9) Option[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]) Option[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]) Option[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,
+    )
+  }
+}
+
+// Optionize10 converts a function with 10 parameters returning a tuple of a return value R and a boolean into a function with 10 parameters returning an Option[R]
+func Optionize10[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, bool), 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) Option[R] {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) Option[R] {
+    return optionize(func() (R, bool) {
+      return f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+    })
+  }
+}
+
+// Unoptionize10 converts a function with 10 parameters returning a tuple of a return value R and a boolean into a function with 10 parameters returning an Option[R]
+func Unoptionize10[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) Option[R], 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) (R, bool) {
+  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R, bool) {
+    return Unwrap(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9))
+  }
+}
+
+// SequenceTuple10 converts a [Tuple10] of [Option[T]] into an [Option[Tuple10]].
+func SequenceTuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t T.Tuple10[Option[T1], Option[T2], Option[T3], Option[T4], Option[T5], Option[T6], Option[T7], Option[T8], Option[T9], Option[T10]]) Option[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,
+  )
+}
+
+// TraverseTuple10 converts a [Tuple10] of [A] via transformation functions transforming [A] to [Option[A]] into a [Option[Tuple10]].
+func TraverseTuple10[F1 ~func(A1) Option[T1], F2 ~func(A2) Option[T2], F3 ~func(A3) Option[T3], F4 ~func(A4) Option[T4], F5 ~func(A5) Option[T5], F6 ~func(A6) Option[T6], F7 ~func(A7) Option[T7], F8 ~func(A8) Option[T8], F9 ~func(A9) Option[T9], F10 ~func(A10) Option[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]) Option[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]) Option[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,
+    )
+  }
+}

option/optionize.go

@@ -1,188 +0,0 @@
-// Code generated by go generate; DO NOT EDIT.
-// This file was generated by robots at
-// 2023-07-14 13:19:45.9328857 +0200 CEST m=+0.012986701
-package option
-
-// optionize converts a nullary function to an option
-func optionize[R any](f func() (R, bool)) Option[R] {
-	if r, ok := f(); ok {
-		return Some(r)
-	}
-	return None[R]()
-}
-
-// Optionize0 converts a function with 0 parameters returning a tuple of a return value R and a boolean into a function with 0 parameters returning an Option[R]
-func Optionize0[F ~func() (R, bool), R any](f F) func() Option[R] {
-	return func() Option[R] {
-		return optionize(func() (R, bool) {
-			return f()
-		})
-	}
-}
-
-// Unoptionize0 converts a function with 0 parameters returning a tuple of a return value R and a boolean into a function with 0 parameters returning an Option[R]
-func Unoptionize0[F ~func() Option[R], R any](f F) func() (R, bool) {
-	return func() (R, bool) {
-		return Unwrap(f())
-	}
-}
-
-// Optionize1 converts a function with 1 parameters returning a tuple of a return value R and a boolean into a function with 1 parameters returning an Option[R]
-func Optionize1[F ~func(T0) (R, bool), T0, R any](f F) func(T0) Option[R] {
-	return func(t0 T0) Option[R] {
-		return optionize(func() (R, bool) {
-			return f(t0)
-		})
-	}
-}
-
-// Unoptionize1 converts a function with 1 parameters returning a tuple of a return value R and a boolean into a function with 1 parameters returning an Option[R]
-func Unoptionize1[F ~func(T0) Option[R], T0, R any](f F) func(T0) (R, bool) {
-	return func(t0 T0) (R, bool) {
-		return Unwrap(f(t0))
-	}
-}
-
-// Optionize2 converts a function with 2 parameters returning a tuple of a return value R and a boolean into a function with 2 parameters returning an Option[R]
-func Optionize2[F ~func(T0, T1) (R, bool), T0, T1, R any](f F) func(T0, T1) Option[R] {
-	return func(t0 T0, t1 T1) Option[R] {
-		return optionize(func() (R, bool) {
-			return f(t0, t1)
-		})
-	}
-}
-
-// Unoptionize2 converts a function with 2 parameters returning a tuple of a return value R and a boolean into a function with 2 parameters returning an Option[R]
-func Unoptionize2[F ~func(T0, T1) Option[R], T0, T1, R any](f F) func(T0, T1) (R, bool) {
-	return func(t0 T0, t1 T1) (R, bool) {
-		return Unwrap(f(t0, t1))
-	}
-}
-
-// Optionize3 converts a function with 3 parameters returning a tuple of a return value R and a boolean into a function with 3 parameters returning an Option[R]
-func Optionize3[F ~func(T0, T1, T2) (R, bool), T0, T1, T2, R any](f F) func(T0, T1, T2) Option[R] {
-	return func(t0 T0, t1 T1, t2 T2) Option[R] {
-		return optionize(func() (R, bool) {
-			return f(t0, t1, t2)
-		})
-	}
-}
-
-// Unoptionize3 converts a function with 3 parameters returning a tuple of a return value R and a boolean into a function with 3 parameters returning an Option[R]
-func Unoptionize3[F ~func(T0, T1, T2) Option[R], T0, T1, T2, R any](f F) func(T0, T1, T2) (R, bool) {
-	return func(t0 T0, t1 T1, t2 T2) (R, bool) {
-		return Unwrap(f(t0, t1, t2))
-	}
-}
-
-// Optionize4 converts a function with 4 parameters returning a tuple of a return value R and a boolean into a function with 4 parameters returning an Option[R]
-func Optionize4[F ~func(T0, T1, T2, T3) (R, bool), T0, T1, T2, T3, R any](f F) func(T0, T1, T2, T3) Option[R] {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3) Option[R] {
-		return optionize(func() (R, bool) {
-			return f(t0, t1, t2, t3)
-		})
-	}
-}
-
-// Unoptionize4 converts a function with 4 parameters returning a tuple of a return value R and a boolean into a function with 4 parameters returning an Option[R]
-func Unoptionize4[F ~func(T0, T1, T2, T3) Option[R], T0, T1, T2, T3, R any](f F) func(T0, T1, T2, T3) (R, bool) {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3) (R, bool) {
-		return Unwrap(f(t0, t1, t2, t3))
-	}
-}
-
-// Optionize5 converts a function with 5 parameters returning a tuple of a return value R and a boolean into a function with 5 parameters returning an Option[R]
-func Optionize5[F ~func(T0, T1, T2, T3, T4) (R, bool), T0, T1, T2, T3, T4, R any](f F) func(T0, T1, T2, T3, T4) Option[R] {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) Option[R] {
-		return optionize(func() (R, bool) {
-			return f(t0, t1, t2, t3, t4)
-		})
-	}
-}
-
-// Unoptionize5 converts a function with 5 parameters returning a tuple of a return value R and a boolean into a function with 5 parameters returning an Option[R]
-func Unoptionize5[F ~func(T0, T1, T2, T3, T4) Option[R], T0, T1, T2, T3, T4, R any](f F) func(T0, T1, T2, T3, T4) (R, bool) {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) (R, bool) {
-		return Unwrap(f(t0, t1, t2, t3, t4))
-	}
-}
-
-// Optionize6 converts a function with 6 parameters returning a tuple of a return value R and a boolean into a function with 6 parameters returning an Option[R]
-func Optionize6[F ~func(T0, T1, T2, T3, T4, T5) (R, bool), T0, T1, T2, T3, T4, T5, R any](f F) func(T0, T1, T2, T3, T4, T5) Option[R] {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) Option[R] {
-		return optionize(func() (R, bool) {
-			return f(t0, t1, t2, t3, t4, t5)
-		})
-	}
-}
-
-// Unoptionize6 converts a function with 6 parameters returning a tuple of a return value R and a boolean into a function with 6 parameters returning an Option[R]
-func Unoptionize6[F ~func(T0, T1, T2, T3, T4, T5) Option[R], T0, T1, T2, T3, T4, T5, R any](f F) func(T0, T1, T2, T3, T4, T5) (R, bool) {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R, bool) {
-		return Unwrap(f(t0, t1, t2, t3, t4, t5))
-	}
-}
-
-// Optionize7 converts a function with 7 parameters returning a tuple of a return value R and a boolean into a function with 7 parameters returning an Option[R]
-func Optionize7[F ~func(T0, T1, T2, T3, T4, T5, T6) (R, bool), T0, T1, T2, T3, T4, T5, T6, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) Option[R] {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) Option[R] {
-		return optionize(func() (R, bool) {
-			return f(t0, t1, t2, t3, t4, t5, t6)
-		})
-	}
-}
-
-// Unoptionize7 converts a function with 7 parameters returning a tuple of a return value R and a boolean into a function with 7 parameters returning an Option[R]
-func Unoptionize7[F ~func(T0, T1, T2, T3, T4, T5, T6) Option[R], T0, T1, T2, T3, T4, T5, T6, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) (R, bool) {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R, bool) {
-		return Unwrap(f(t0, t1, t2, t3, t4, t5, t6))
-	}
-}
-
-// Optionize8 converts a function with 8 parameters returning a tuple of a return value R and a boolean into a function with 8 parameters returning an Option[R]
-func Optionize8[F ~func(T0, T1, T2, T3, T4, T5, T6, T7) (R, bool), T0, T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) Option[R] {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) Option[R] {
-		return optionize(func() (R, bool) {
-			return f(t0, t1, t2, t3, t4, t5, t6, t7)
-		})
-	}
-}
-
-// Unoptionize8 converts a function with 8 parameters returning a tuple of a return value R and a boolean into a function with 8 parameters returning an Option[R]
-func Unoptionize8[F ~func(T0, T1, T2, T3, T4, T5, T6, T7) Option[R], T0, T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) (R, bool) {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R, bool) {
-		return Unwrap(f(t0, t1, t2, t3, t4, t5, t6, t7))
-	}
-}
-
-// Optionize9 converts a function with 9 parameters returning a tuple of a return value R and a boolean into a function with 9 parameters returning an Option[R]
-func Optionize9[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, bool), T0, T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) Option[R] {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) Option[R] {
-		return optionize(func() (R, bool) {
-			return f(t0, t1, t2, t3, t4, t5, t6, t7, t8)
-		})
-	}
-}
-
-// Unoptionize9 converts a function with 9 parameters returning a tuple of a return value R and a boolean into a function with 9 parameters returning an Option[R]
-func Unoptionize9[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) Option[R], T0, T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, bool) {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R, bool) {
-		return Unwrap(f(t0, t1, t2, t3, t4, t5, t6, t7, t8))
-	}
-}
-
-// Optionize10 converts a function with 10 parameters returning a tuple of a return value R and a boolean into a function with 10 parameters returning an Option[R]
-func Optionize10[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, bool), 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) Option[R] {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) Option[R] {
-		return optionize(func() (R, bool) {
-			return f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
-		})
-	}
-}
-
-// Unoptionize10 converts a function with 10 parameters returning a tuple of a return value R and a boolean into a function with 10 parameters returning an Option[R]
-func Unoptionize10[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) Option[R], 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) (R, bool) {
-	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R, bool) {
-		return Unwrap(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9))
-	}
-}

tuple/gen.go

@@ -1,8 +1,9 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-14 13:19:47.4331101 +0200 CEST m=+0.011802301
+// 2023-07-17 13:23:15.4992602 +0200 CEST m=+0.068393801
 package tuple
 
+
 import (
 	M "github.com/ibm/fp-go/monoid"
 	O "github.com/ibm/fp-go/ord"
@@ -126,7 +127,7 @@ func Untupled1[F ~func(Tuple1[T1]) R, T1, R any](f F) func(T1) R {
 
 // Monoid1 creates a [Monoid] for a [Tuple1] based on 1 monoids for the contained types
 func Monoid1[T1 any](m1 M.Monoid[T1]) M.Monoid[Tuple1[T1]] {
-	return M.MakeMonoid(func(l, r Tuple1[T1]) Tuple1[T1] {
+  return M.MakeMonoid(func(l, r Tuple1[T1]) Tuple1[T1]{
     return MakeTuple1(m1.Concat(l.F1, r.F1))
   }, MakeTuple1(m1.Empty()))
 }
@@ -134,15 +135,27 @@ func Monoid1[T1 any](m1 M.Monoid[T1]) M.Monoid[Tuple1[T1]] {
 // Ord1 creates n [Ord] for a [Tuple1] based on 1 [Ord]s for the contained types
 func Ord1[T1 any](o1 O.Ord[T1]) O.Ord[Tuple1[T1]] {
   return O.MakeOrd(func(l, r Tuple1[T1]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
-			return c
-		}
     return 0
   }, func(l, r Tuple1[T1]) bool {
     return o1.Equals(l.F1, r.F1)
   })
 }
 
+// Map1 maps each value of a [Tuple1] via a mapping function
+func Map1[F1 ~func(T1) R1, T1, R1 any](f1 F1) func(Tuple1[T1]) Tuple1[R1] {
+ return func(t Tuple1[T1]) Tuple1[R1] {
+    return MakeTuple1(
+      f1(t.F1),
+    )
+ }
+}
+
+// Replicate1 creates a [Tuple1] with all fields set to the input value `t`
+func Replicate1[T any](t T) Tuple1[T] {
+  return MakeTuple1(t)
+}
+
 // MakeTuple2 is a function that converts its 2 parameters into a [Tuple2]
 func MakeTuple2[T1, T2 any](t1 T1, t2 T2) Tuple2[T1, T2] {
   return Tuple2[T1, T2]{t1, t2}
@@ -166,7 +179,7 @@ func Untupled2[F ~func(Tuple2[T1, T2]) R, T1, T2, R any](f F) func(T1, T2) R {
 
 // Monoid2 creates a [Monoid] for a [Tuple2] based on 2 monoids for the contained types
 func Monoid2[T1, T2 any](m1 M.Monoid[T1], m2 M.Monoid[T2]) M.Monoid[Tuple2[T1, T2]] {
-	return M.MakeMonoid(func(l, r Tuple2[T1, T2]) Tuple2[T1, T2] {
+  return M.MakeMonoid(func(l, r Tuple2[T1, T2]) Tuple2[T1, T2]{
     return MakeTuple2(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2))
   }, MakeTuple2(m1.Empty(), m2.Empty()))
 }
@@ -174,18 +187,29 @@ func Monoid2[T1, T2 any](m1 M.Monoid[T1], m2 M.Monoid[T2]) M.Monoid[Tuple2[T1, T
 // Ord2 creates n [Ord] for a [Tuple2] based on 2 [Ord]s for the contained types
 func Ord2[T1, T2 any](o1 O.Ord[T1], o2 O.Ord[T2]) O.Ord[Tuple2[T1, T2]] {
   return O.MakeOrd(func(l, r Tuple2[T1, T2]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
-			return c
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
-		}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
     return 0
   }, func(l, r Tuple2[T1, T2]) bool {
     return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2)
   })
 }
 
+// Map2 maps each value of a [Tuple2] via a mapping function
+func Map2[F1 ~func(T1) R1, F2 ~func(T2) R2, T1, R1, T2, R2 any](f1 F1, f2 F2) func(Tuple2[T1, T2]) Tuple2[R1, R2] {
+ return func(t Tuple2[T1, T2]) Tuple2[R1, R2] {
+    return MakeTuple2(
+      f1(t.F1),
+      f2(t.F2),
+    )
+ }
+}
+
+// Replicate2 creates a [Tuple2] with all fields set to the input value `t`
+func Replicate2[T any](t T) Tuple2[T, T] {
+  return MakeTuple2(t, t)
+}
+
 // MakeTuple3 is a function that converts its 3 parameters into a [Tuple3]
 func MakeTuple3[T1, T2, T3 any](t1 T1, t2 T2, t3 T3) Tuple3[T1, T2, T3] {
   return Tuple3[T1, T2, T3]{t1, t2, t3}
@@ -209,7 +233,7 @@ func Untupled3[F ~func(Tuple3[T1, T2, T3]) R, T1, T2, T3, R any](f F) func(T1, T
 
 // Monoid3 creates a [Monoid] for a [Tuple3] based on 3 monoids for the contained types
 func Monoid3[T1, T2, T3 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3]) M.Monoid[Tuple3[T1, T2, T3]] {
-	return M.MakeMonoid(func(l, r Tuple3[T1, T2, T3]) Tuple3[T1, T2, T3] {
+  return M.MakeMonoid(func(l, r Tuple3[T1, T2, T3]) Tuple3[T1, T2, T3]{
     return MakeTuple3(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3))
   }, MakeTuple3(m1.Empty(), m2.Empty(), m3.Empty()))
 }
@@ -217,21 +241,31 @@ func Monoid3[T1, T2, T3 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3])
 // Ord3 creates n [Ord] for a [Tuple3] based on 3 [Ord]s for the contained types
 func Ord3[T1, T2, T3 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3]) O.Ord[Tuple3[T1, T2, T3]] {
   return O.MakeOrd(func(l, r Tuple3[T1, T2, T3]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
-			return c
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
-		}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
     return 0
   }, func(l, r Tuple3[T1, T2, T3]) bool {
     return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3)
   })
 }
 
+// Map3 maps each value of a [Tuple3] via a mapping function
+func Map3[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, T1, R1, T2, R2, T3, R3 any](f1 F1, f2 F2, f3 F3) func(Tuple3[T1, T2, T3]) Tuple3[R1, R2, R3] {
+ return func(t Tuple3[T1, T2, T3]) Tuple3[R1, R2, R3] {
+    return MakeTuple3(
+      f1(t.F1),
+      f2(t.F2),
+      f3(t.F3),
+    )
+ }
+}
+
+// Replicate3 creates a [Tuple3] with all fields set to the input value `t`
+func Replicate3[T any](t T) Tuple3[T, T, T] {
+  return MakeTuple3(t, t, t)
+}
+
 // MakeTuple4 is a function that converts its 4 parameters into a [Tuple4]
 func MakeTuple4[T1, T2, T3, T4 any](t1 T1, t2 T2, t3 T3, t4 T4) Tuple4[T1, T2, T3, T4] {
   return Tuple4[T1, T2, T3, T4]{t1, t2, t3, t4}
@@ -255,7 +289,7 @@ func Untupled4[F ~func(Tuple4[T1, T2, T3, T4]) R, T1, T2, T3, T4, R any](f F) fu
 
 // Monoid4 creates a [Monoid] for a [Tuple4] based on 4 monoids for the contained types
 func Monoid4[T1, T2, T3, T4 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4]) M.Monoid[Tuple4[T1, T2, T3, T4]] {
-	return M.MakeMonoid(func(l, r Tuple4[T1, T2, T3, T4]) Tuple4[T1, T2, T3, T4] {
+  return M.MakeMonoid(func(l, r Tuple4[T1, T2, T3, T4]) Tuple4[T1, T2, T3, T4]{
     return MakeTuple4(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4))
   }, MakeTuple4(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty()))
 }
@@ -263,24 +297,33 @@ func Monoid4[T1, T2, T3, T4 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T
 // Ord4 creates n [Ord] for a [Tuple4] based on 4 [Ord]s for the contained types
 func Ord4[T1, T2, T3, T4 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4]) O.Ord[Tuple4[T1, T2, T3, T4]] {
   return O.MakeOrd(func(l, r Tuple4[T1, T2, T3, T4]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
-			return c
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
-		}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
-			return c
-		}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
     return 0
   }, func(l, r Tuple4[T1, T2, T3, T4]) bool {
     return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4)
   })
 }
 
+// Map4 maps each value of a [Tuple4] via a mapping function
+func Map4[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, T1, R1, T2, R2, T3, R3, T4, R4 any](f1 F1, f2 F2, f3 F3, f4 F4) func(Tuple4[T1, T2, T3, T4]) Tuple4[R1, R2, R3, R4] {
+ return func(t Tuple4[T1, T2, T3, T4]) Tuple4[R1, R2, R3, R4] {
+    return MakeTuple4(
+      f1(t.F1),
+      f2(t.F2),
+      f3(t.F3),
+      f4(t.F4),
+    )
+ }
+}
+
+// Replicate4 creates a [Tuple4] with all fields set to the input value `t`
+func Replicate4[T any](t T) Tuple4[T, T, T, T] {
+  return MakeTuple4(t, t, t, t)
+}
+
 // MakeTuple5 is a function that converts its 5 parameters into a [Tuple5]
 func MakeTuple5[T1, T2, T3, T4, T5 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) Tuple5[T1, T2, T3, T4, T5] {
   return Tuple5[T1, T2, T3, T4, T5]{t1, t2, t3, t4, t5}
@@ -304,7 +347,7 @@ func Untupled5[F ~func(Tuple5[T1, T2, T3, T4, T5]) R, T1, T2, T3, T4, T5, R any]
 
 // Monoid5 creates a [Monoid] for a [Tuple5] based on 5 monoids for the contained types
 func Monoid5[T1, T2, T3, T4, T5 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5]) M.Monoid[Tuple5[T1, T2, T3, T4, T5]] {
-	return M.MakeMonoid(func(l, r Tuple5[T1, T2, T3, T4, T5]) Tuple5[T1, T2, T3, T4, T5] {
+  return M.MakeMonoid(func(l, r Tuple5[T1, T2, T3, T4, T5]) Tuple5[T1, T2, T3, T4, T5]{
     return MakeTuple5(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5))
   }, MakeTuple5(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty()))
 }
@@ -312,27 +355,35 @@ func Monoid5[T1, T2, T3, T4, T5 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Mono
 // Ord5 creates n [Ord] for a [Tuple5] based on 5 [Ord]s for the contained types
 func Ord5[T1, T2, T3, T4, T5 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5]) O.Ord[Tuple5[T1, T2, T3, T4, T5]] {
   return O.MakeOrd(func(l, r Tuple5[T1, T2, T3, T4, T5]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
-			return c
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
-		}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
-			return c
+    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
-		}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
-		if c := o5.Compare(l.F5, r.F5); c != 0 {
-			return c
-		}
     return 0
   }, func(l, r Tuple5[T1, T2, T3, T4, T5]) bool {
     return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5)
   })
 }
 
+// Map5 maps each value of a [Tuple5] via a mapping function
+func Map5[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) func(Tuple5[T1, T2, T3, T4, T5]) Tuple5[R1, R2, R3, R4, R5] {
+ return func(t Tuple5[T1, T2, T3, T4, T5]) Tuple5[R1, R2, R3, R4, R5] {
+    return MakeTuple5(
+      f1(t.F1),
+      f2(t.F2),
+      f3(t.F3),
+      f4(t.F4),
+      f5(t.F5),
+    )
+ }
+}
+
+// Replicate5 creates a [Tuple5] with all fields set to the input value `t`
+func Replicate5[T any](t T) Tuple5[T, T, T, T, T] {
+  return MakeTuple5(t, t, t, t, t)
+}
+
 // MakeTuple6 is a function that converts its 6 parameters into a [Tuple6]
 func MakeTuple6[T1, T2, T3, T4, T5, T6 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) Tuple6[T1, T2, T3, T4, T5, T6] {
   return Tuple6[T1, T2, T3, T4, T5, T6]{t1, t2, t3, t4, t5, t6}
@@ -356,7 +407,7 @@ func Untupled6[F ~func(Tuple6[T1, T2, T3, T4, T5, T6]) R, T1, T2, T3, T4, T5, T6
 
 // Monoid6 creates a [Monoid] for a [Tuple6] based on 6 monoids for the contained types
 func Monoid6[T1, T2, T3, T4, T5, T6 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6]) M.Monoid[Tuple6[T1, T2, T3, T4, T5, T6]] {
-	return M.MakeMonoid(func(l, r Tuple6[T1, T2, T3, T4, T5, T6]) Tuple6[T1, T2, T3, T4, T5, T6] {
+  return M.MakeMonoid(func(l, r Tuple6[T1, T2, T3, T4, T5, T6]) Tuple6[T1, T2, T3, T4, T5, T6]{
     return MakeTuple6(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6))
   }, MakeTuple6(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty()))
 }
@@ -364,30 +415,37 @@ func Monoid6[T1, T2, T3, T4, T5, T6 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.
 // Ord6 creates n [Ord] for a [Tuple6] based on 6 [Ord]s for the contained types
 func Ord6[T1, T2, T3, T4, T5, T6 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6]) O.Ord[Tuple6[T1, T2, T3, T4, T5, T6]] {
   return O.MakeOrd(func(l, r Tuple6[T1, T2, T3, T4, T5, T6]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
-			return c
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
-		}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
-			return c
+    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
-		}
+    if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
-		if c := o5.Compare(l.F5, r.F5); c != 0 {
-			return c
-		}
-		if c := o6.Compare(l.F6, r.F6); c != 0 {
-			return c
-		}
     return 0
   }, func(l, r Tuple6[T1, T2, T3, T4, T5, T6]) bool {
     return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6)
   })
 }
 
+// Map6 maps each value of a [Tuple6] via a mapping function
+func Map6[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) func(Tuple6[T1, T2, T3, T4, T5, T6]) Tuple6[R1, R2, R3, R4, R5, R6] {
+ return func(t Tuple6[T1, T2, T3, T4, T5, T6]) Tuple6[R1, R2, R3, R4, R5, R6] {
+    return MakeTuple6(
+      f1(t.F1),
+      f2(t.F2),
+      f3(t.F3),
+      f4(t.F4),
+      f5(t.F5),
+      f6(t.F6),
+    )
+ }
+}
+
+// Replicate6 creates a [Tuple6] with all fields set to the input value `t`
+func Replicate6[T any](t T) Tuple6[T, T, T, T, T, T] {
+  return MakeTuple6(t, t, t, t, t, t)
+}
+
 // MakeTuple7 is a function that converts its 7 parameters into a [Tuple7]
 func MakeTuple7[T1, T2, T3, T4, T5, T6, T7 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) Tuple7[T1, T2, T3, T4, T5, T6, T7] {
   return Tuple7[T1, T2, T3, T4, T5, T6, T7]{t1, t2, t3, t4, t5, t6, t7}
@@ -411,7 +469,7 @@ func Untupled7[F ~func(Tuple7[T1, T2, T3, T4, T5, T6, T7]) R, T1, T2, T3, T4, T5
 
 // Monoid7 creates a [Monoid] for a [Tuple7] based on 7 monoids for the contained types
 func Monoid7[T1, T2, T3, T4, T5, T6, T7 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7]) M.Monoid[Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-	return M.MakeMonoid(func(l, r Tuple7[T1, T2, T3, T4, T5, T6, T7]) Tuple7[T1, T2, T3, T4, T5, T6, T7] {
+  return M.MakeMonoid(func(l, r Tuple7[T1, T2, T3, T4, T5, T6, T7]) Tuple7[T1, T2, T3, T4, T5, T6, T7]{
     return MakeTuple7(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7))
   }, MakeTuple7(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty()))
 }
@@ -419,33 +477,39 @@ func Monoid7[T1, T2, T3, T4, T5, T6, T7 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m
 // Ord7 creates n [Ord] for a [Tuple7] based on 7 [Ord]s for the contained types
 func Ord7[T1, T2, T3, T4, T5, T6, T7 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7]) O.Ord[Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
   return O.MakeOrd(func(l, r Tuple7[T1, T2, T3, T4, T5, T6, T7]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
-			return c
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
-		}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
-			return c
+    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
-		}
+    if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
+    if c:= o7.Compare(l.F7, r.F7); c != 0 {return c}
-			return c
-		}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
-		if c := o5.Compare(l.F5, r.F5); c != 0 {
-			return c
-		}
-		if c := o6.Compare(l.F6, r.F6); c != 0 {
-			return c
-		}
-		if c := o7.Compare(l.F7, r.F7); c != 0 {
-			return c
-		}
     return 0
   }, func(l, r Tuple7[T1, T2, T3, T4, T5, T6, T7]) bool {
     return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7)
   })
 }
 
+// Map7 maps each value of a [Tuple7] via a mapping function
+func Map7[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, F7 ~func(T7) R7, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6, T7, R7 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) func(Tuple7[T1, T2, T3, T4, T5, T6, T7]) Tuple7[R1, R2, R3, R4, R5, R6, R7] {
+ return func(t Tuple7[T1, T2, T3, T4, T5, T6, T7]) Tuple7[R1, R2, R3, R4, R5, R6, R7] {
+    return MakeTuple7(
+      f1(t.F1),
+      f2(t.F2),
+      f3(t.F3),
+      f4(t.F4),
+      f5(t.F5),
+      f6(t.F6),
+      f7(t.F7),
+    )
+ }
+}
+
+// Replicate7 creates a [Tuple7] with all fields set to the input value `t`
+func Replicate7[T any](t T) Tuple7[T, T, T, T, T, T, T] {
+  return MakeTuple7(t, t, t, t, t, t, t)
+}
+
 // MakeTuple8 is a function that converts its 8 parameters into a [Tuple8]
 func MakeTuple8[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) Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
   return Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]{t1, t2, t3, t4, t5, t6, t7, t8}
@@ -469,7 +533,7 @@ func Untupled8[F ~func(Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) R, T1, T2, T3, T4
 
 // Monoid8 creates a [Monoid] for a [Tuple8] based on 8 monoids for the contained types
 func Monoid8[T1, T2, T3, T4, T5, T6, T7, T8 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7], m8 M.Monoid[T8]) M.Monoid[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-	return M.MakeMonoid(func(l, r Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
+  return M.MakeMonoid(func(l, r Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]{
     return MakeTuple8(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7), m8.Concat(l.F8, r.F8))
   }, MakeTuple8(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty(), m8.Empty()))
 }
@@ -477,36 +541,41 @@ func Monoid8[T1, T2, T3, T4, T5, T6, T7, T8 any](m1 M.Monoid[T1], m2 M.Monoid[T2
 // Ord8 creates n [Ord] for a [Tuple8] based on 8 [Ord]s for the contained types
 func Ord8[T1, T2, T3, T4, T5, T6, T7, T8 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7], o8 O.Ord[T8]) O.Ord[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
   return O.MakeOrd(func(l, r Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
-			return c
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
-		}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
-			return c
+    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
-		}
+    if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
+    if c:= o7.Compare(l.F7, r.F7); c != 0 {return c}
-			return c
+    if c:= o8.Compare(l.F8, r.F8); c != 0 {return c}
-		}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
-		if c := o5.Compare(l.F5, r.F5); c != 0 {
-			return c
-		}
-		if c := o6.Compare(l.F6, r.F6); c != 0 {
-			return c
-		}
-		if c := o7.Compare(l.F7, r.F7); c != 0 {
-			return c
-		}
-		if c := o8.Compare(l.F8, r.F8); c != 0 {
-			return c
-		}
     return 0
   }, func(l, r Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) bool {
     return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7) && o8.Equals(l.F8, r.F8)
   })
 }
 
+// Map8 maps each value of a [Tuple8] via a mapping function
+func Map8[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, F7 ~func(T7) R7, F8 ~func(T8) R8, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6, T7, R7, T8, R8 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) func(Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) Tuple8[R1, R2, R3, R4, R5, R6, R7, R8] {
+ return func(t Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) Tuple8[R1, R2, R3, R4, R5, R6, R7, R8] {
+    return MakeTuple8(
+      f1(t.F1),
+      f2(t.F2),
+      f3(t.F3),
+      f4(t.F4),
+      f5(t.F5),
+      f6(t.F6),
+      f7(t.F7),
+      f8(t.F8),
+    )
+ }
+}
+
+// Replicate8 creates a [Tuple8] with all fields set to the input value `t`
+func Replicate8[T any](t T) Tuple8[T, T, T, T, T, T, T, T] {
+  return MakeTuple8(t, t, t, t, t, t, t, t)
+}
+
 // MakeTuple9 is a function that converts its 9 parameters into a [Tuple9]
 func MakeTuple9[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) Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
   return Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]{t1, t2, t3, t4, t5, t6, t7, t8, t9}
@@ -530,7 +599,7 @@ func Untupled9[F ~func(Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) R, T1, T2, T3
 
 // Monoid9 creates a [Monoid] for a [Tuple9] based on 9 monoids for the contained types
 func Monoid9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7], m8 M.Monoid[T8], m9 M.Monoid[T9]) M.Monoid[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-	return M.MakeMonoid(func(l, r Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
+  return M.MakeMonoid(func(l, r Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]{
     return MakeTuple9(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7), m8.Concat(l.F8, r.F8), m9.Concat(l.F9, r.F9))
   }, MakeTuple9(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty(), m8.Empty(), m9.Empty()))
 }
@@ -538,39 +607,43 @@ func Monoid9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](m1 M.Monoid[T1], m2 M.Monoi
 // Ord9 creates n [Ord] for a [Tuple9] based on 9 [Ord]s for the contained types
 func Ord9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7], o8 O.Ord[T8], o9 O.Ord[T9]) O.Ord[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
   return O.MakeOrd(func(l, r Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
-			return c
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
-		}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
-			return c
+    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
-		}
+    if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
+    if c:= o7.Compare(l.F7, r.F7); c != 0 {return c}
-			return c
+    if c:= o8.Compare(l.F8, r.F8); c != 0 {return c}
-		}
+    if c:= o9.Compare(l.F9, r.F9); c != 0 {return c}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
-		if c := o5.Compare(l.F5, r.F5); c != 0 {
-			return c
-		}
-		if c := o6.Compare(l.F6, r.F6); c != 0 {
-			return c
-		}
-		if c := o7.Compare(l.F7, r.F7); c != 0 {
-			return c
-		}
-		if c := o8.Compare(l.F8, r.F8); c != 0 {
-			return c
-		}
-		if c := o9.Compare(l.F9, r.F9); c != 0 {
-			return c
-		}
     return 0
   }, func(l, r Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) bool {
     return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7) && o8.Equals(l.F8, r.F8) && o9.Equals(l.F9, r.F9)
   })
 }
 
+// Map9 maps each value of a [Tuple9] via a mapping function
+func Map9[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, F7 ~func(T7) R7, F8 ~func(T8) R8, F9 ~func(T9) R9, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6, T7, R7, T8, R8, T9, R9 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) func(Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) Tuple9[R1, R2, R3, R4, R5, R6, R7, R8, R9] {
+ return func(t Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) Tuple9[R1, R2, R3, R4, R5, R6, R7, R8, R9] {
+    return MakeTuple9(
+      f1(t.F1),
+      f2(t.F2),
+      f3(t.F3),
+      f4(t.F4),
+      f5(t.F5),
+      f6(t.F6),
+      f7(t.F7),
+      f8(t.F8),
+      f9(t.F9),
+    )
+ }
+}
+
+// Replicate9 creates a [Tuple9] with all fields set to the input value `t`
+func Replicate9[T any](t T) Tuple9[T, T, T, T, T, T, T, T, T] {
+  return MakeTuple9(t, t, t, t, t, t, t, t, t)
+}
+
 // MakeTuple10 is a function that converts its 10 parameters into a [Tuple10]
 func MakeTuple10[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) Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
   return Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10}
@@ -594,7 +667,7 @@ func Untupled10[F ~func(Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) R, T1,
 
 // Monoid10 creates a [Monoid] for a [Tuple10] based on 10 monoids for the contained types
 func Monoid10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7], m8 M.Monoid[T8], m9 M.Monoid[T9], m10 M.Monoid[T10]) M.Monoid[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-	return M.MakeMonoid(func(l, r Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
+  return M.MakeMonoid(func(l, r Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]{
     return MakeTuple10(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7), m8.Concat(l.F8, r.F8), m9.Concat(l.F9, r.F9), m10.Concat(l.F10, r.F10))
   }, MakeTuple10(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty(), m8.Empty(), m9.Empty(), m10.Empty()))
 }
@@ -602,38 +675,41 @@ func Monoid10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](m1 M.Monoid[T1], m2 M
 // Ord10 creates n [Ord] for a [Tuple10] based on 10 [Ord]s for the contained types
 func Ord10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7], o8 O.Ord[T8], o9 O.Ord[T9], o10 O.Ord[T10]) O.Ord[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
   return O.MakeOrd(func(l, r Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
-			return c
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
-		}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
-			return c
+    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
-		}
+    if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
+    if c:= o7.Compare(l.F7, r.F7); c != 0 {return c}
-			return c
+    if c:= o8.Compare(l.F8, r.F8); c != 0 {return c}
-		}
+    if c:= o9.Compare(l.F9, r.F9); c != 0 {return c}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
+    if c:= o10.Compare(l.F10, r.F10); c != 0 {return c}
-			return c
-		}
-		if c := o5.Compare(l.F5, r.F5); c != 0 {
-			return c
-		}
-		if c := o6.Compare(l.F6, r.F6); c != 0 {
-			return c
-		}
-		if c := o7.Compare(l.F7, r.F7); c != 0 {
-			return c
-		}
-		if c := o8.Compare(l.F8, r.F8); c != 0 {
-			return c
-		}
-		if c := o9.Compare(l.F9, r.F9); c != 0 {
-			return c
-		}
-		if c := o10.Compare(l.F10, r.F10); c != 0 {
-			return c
-		}
     return 0
   }, func(l, r Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) bool {
     return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7) && o8.Equals(l.F8, r.F8) && o9.Equals(l.F9, r.F9) && o10.Equals(l.F10, r.F10)
   })
 }
+
+// Map10 maps each value of a [Tuple10] via a mapping function
+func Map10[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, F7 ~func(T7) R7, F8 ~func(T8) R8, F9 ~func(T9) R9, F10 ~func(T10) R10, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6, T7, R7, T8, R8, T9, R9, T10, R10 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) func(Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) Tuple10[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10] {
+ return func(t Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) Tuple10[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10] {
+    return MakeTuple10(
+      f1(t.F1),
+      f2(t.F2),
+      f3(t.F3),
+      f4(t.F4),
+      f5(t.F5),
+      f6(t.F6),
+      f7(t.F7),
+      f8(t.F8),
+      f9(t.F9),
+      f10(t.F10),
+    )
+ }
+}
+
+// Replicate10 creates a [Tuple10] with all fields set to the input value `t`
+func Replicate10[T any](t T) Tuple10[T, T, T, T, T, T, T, T, T, T] {
+  return MakeTuple10(t, t, t, t, t, t, t, t, t, t)
+}