fix: initial implementation of types

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

array/generic/array.go

@@ -105,6 +105,10 @@ func MonadMap[GA ~[]A, GB ~[]B, A, B any](as GA, f func(a A) B) GB {
 	return array.MonadMap[GA, GB](as, f)
 }
 
+func Map[GA ~[]A, GB ~[]B, A, B any](f func(a A) B) func(GA) GB {
+	return F.Bind2nd(MonadMap[GA, GB, A, B], f)
+}
+
 func Size[GA ~[]A, A any](as GA) int {
 	return len(as)
 }

context/readerioeither/gen.go

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

function/binds.go

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

identity/gen.go

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

internal/bindt/bind.go

@@ -35,7 +35,7 @@ func Bind[SET ~func(B) func(S1) S2, FCT ~func(S1) HKTB, S1, S2, B, HKTS1, HKTS2,
 				F.Bind1st(F.Flow2[SET, func(func(S1) S2) S2], s),
 				mmap,
 			)), f),
-		T.Ap[HKTB, HKTS2],
+		T.Tupled2(I.MonadAp[HKTS2, HKTB]),
 	))
 }
 
@@ -59,3 +59,17 @@ func ApS[
 		I.Ap[HKTS2, HKTS1S2](mmap(s)(fb)),
 	)
 }
+
+func Let[SET ~func(B) func(S1) S2, FCT ~func(S1) B, S1, S2, B, HKTS1, HKTS2 any](
+	mmap func(func(S1) S2) func(HKTS1) HKTS2,
+	s SET,
+	f FCT,
+) func(HKTS1) HKTS2 {
+	return mmap(F.Flow3(
+		T.Replicate2[S1],
+		T.Map2(F.Flow2(
+			I.Ap[S2, S1],
+			F.Bind1st(F.Flow2[SET, func(func(S1) S2) S2], s)), f),
+		T.Tupled2(I.MonadAp[S2, B]),
+	))
+}

io/gen.go

@@ -4,373 +4,372 @@
 
 package io
 
-
 import (
-	G "github.com/IBM/fp-go/io/generic"	
+	G "github.com/IBM/fp-go/io/generic"
 	T "github.com/IBM/fp-go/tuple"
 )
 
 // SequenceT1 converts 1 [IO[T]] into a [IO[T.Tuple1[T1]]]
 func SequenceT1[T1 any](
-  t1 IO[T1],
+	t1 IO[T1],
 ) IO[T.Tuple1[T1]] {
-  return G.SequenceT1[
+	return G.SequenceT1[
-    IO[T.Tuple1[T1]],
+		IO[T.Tuple1[T1]],
-    IO[T1],
+		IO[T1],
-  ](t1)
+	](t1)
 }
 
 // SequenceTuple1 converts a [T.Tuple1[IO[T]]] into a [IO[T.Tuple1[T1]]]
 func SequenceTuple1[T1 any](t T.Tuple1[IO[T1]]) IO[T.Tuple1[T1]] {
-  return G.SequenceTuple1[
+	return G.SequenceTuple1[
-    IO[T.Tuple1[T1]],
+		IO[T.Tuple1[T1]],
-    IO[T1],
+		IO[T1],
-  ](t)
+	](t)
 }
 
 // TraverseTuple1 converts a [T.Tuple1[IO[T]]] into a [IO[T.Tuple1[T1]]]
 func TraverseTuple1[F1 ~func(A1) IO[T1], A1, T1 any](f1 F1) func(T.Tuple1[A1]) IO[T.Tuple1[T1]] {
-  return G.TraverseTuple1[IO[T.Tuple1[T1]]](f1)
+	return G.TraverseTuple1[IO[T.Tuple1[T1]]](f1)
 }
 
 // SequenceT2 converts 2 [IO[T]] into a [IO[T.Tuple2[T1, T2]]]
 func SequenceT2[T1, T2 any](
-  t1 IO[T1],
+	t1 IO[T1],
-  t2 IO[T2],
+	t2 IO[T2],
 ) IO[T.Tuple2[T1, T2]] {
-  return G.SequenceT2[
+	return G.SequenceT2[
-    IO[T.Tuple2[T1, T2]],
+		IO[T.Tuple2[T1, T2]],
-    IO[T1],
+		IO[T1],
-    IO[T2],
+		IO[T2],
-  ](t1, t2)
+	](t1, t2)
 }
 
 // SequenceTuple2 converts a [T.Tuple2[IO[T]]] into a [IO[T.Tuple2[T1, T2]]]
 func SequenceTuple2[T1, T2 any](t T.Tuple2[IO[T1], IO[T2]]) IO[T.Tuple2[T1, T2]] {
-  return G.SequenceTuple2[
+	return G.SequenceTuple2[
-    IO[T.Tuple2[T1, T2]],
+		IO[T.Tuple2[T1, T2]],
-    IO[T1],
+		IO[T1],
-    IO[T2],
+		IO[T2],
-  ](t)
+	](t)
 }
 
 // TraverseTuple2 converts a [T.Tuple2[IO[T]]] into a [IO[T.Tuple2[T1, T2]]]
 func TraverseTuple2[F1 ~func(A1) IO[T1], F2 ~func(A2) IO[T2], A1, A2, T1, T2 any](f1 F1, f2 F2) func(T.Tuple2[A1, A2]) IO[T.Tuple2[T1, T2]] {
-  return G.TraverseTuple2[IO[T.Tuple2[T1, T2]]](f1, f2)
+	return G.TraverseTuple2[IO[T.Tuple2[T1, T2]]](f1, f2)
 }
 
 // SequenceT3 converts 3 [IO[T]] into a [IO[T.Tuple3[T1, T2, T3]]]
 func SequenceT3[T1, T2, T3 any](
-  t1 IO[T1],
+	t1 IO[T1],
-  t2 IO[T2],
+	t2 IO[T2],
-  t3 IO[T3],
+	t3 IO[T3],
 ) IO[T.Tuple3[T1, T2, T3]] {
-  return G.SequenceT3[
+	return G.SequenceT3[
-    IO[T.Tuple3[T1, T2, T3]],
+		IO[T.Tuple3[T1, T2, T3]],
-    IO[T1],
+		IO[T1],
-    IO[T2],
+		IO[T2],
-    IO[T3],
+		IO[T3],
-  ](t1, t2, t3)
+	](t1, t2, t3)
 }
 
 // SequenceTuple3 converts a [T.Tuple3[IO[T]]] into a [IO[T.Tuple3[T1, T2, T3]]]
 func SequenceTuple3[T1, T2, T3 any](t T.Tuple3[IO[T1], IO[T2], IO[T3]]) IO[T.Tuple3[T1, T2, T3]] {
-  return G.SequenceTuple3[
+	return G.SequenceTuple3[
-    IO[T.Tuple3[T1, T2, T3]],
+		IO[T.Tuple3[T1, T2, T3]],
-    IO[T1],
+		IO[T1],
-    IO[T2],
+		IO[T2],
-    IO[T3],
+		IO[T3],
-  ](t)
+	](t)
 }
 
 // TraverseTuple3 converts a [T.Tuple3[IO[T]]] into a [IO[T.Tuple3[T1, T2, T3]]]
 func TraverseTuple3[F1 ~func(A1) IO[T1], F2 ~func(A2) IO[T2], F3 ~func(A3) IO[T3], A1, A2, A3, T1, T2, T3 any](f1 F1, f2 F2, f3 F3) func(T.Tuple3[A1, A2, A3]) IO[T.Tuple3[T1, T2, T3]] {
-  return G.TraverseTuple3[IO[T.Tuple3[T1, T2, T3]]](f1, f2, f3)
+	return G.TraverseTuple3[IO[T.Tuple3[T1, T2, T3]]](f1, f2, f3)
 }
 
 // SequenceT4 converts 4 [IO[T]] into a [IO[T.Tuple4[T1, T2, T3, T4]]]
 func SequenceT4[T1, T2, T3, T4 any](
-  t1 IO[T1],
+	t1 IO[T1],
-  t2 IO[T2],
+	t2 IO[T2],
-  t3 IO[T3],
+	t3 IO[T3],
-  t4 IO[T4],
+	t4 IO[T4],
 ) IO[T.Tuple4[T1, T2, T3, T4]] {
-  return G.SequenceT4[
+	return G.SequenceT4[
-    IO[T.Tuple4[T1, T2, T3, T4]],
+		IO[T.Tuple4[T1, T2, T3, T4]],
-    IO[T1],
+		IO[T1],
-    IO[T2],
+		IO[T2],
-    IO[T3],
+		IO[T3],
-    IO[T4],
+		IO[T4],
-  ](t1, t2, t3, t4)
+	](t1, t2, t3, t4)
 }
 
 // SequenceTuple4 converts a [T.Tuple4[IO[T]]] into a [IO[T.Tuple4[T1, T2, T3, T4]]]
 func SequenceTuple4[T1, T2, T3, T4 any](t T.Tuple4[IO[T1], IO[T2], IO[T3], IO[T4]]) IO[T.Tuple4[T1, T2, T3, T4]] {
-  return G.SequenceTuple4[
+	return G.SequenceTuple4[
-    IO[T.Tuple4[T1, T2, T3, T4]],
+		IO[T.Tuple4[T1, T2, T3, T4]],
-    IO[T1],
+		IO[T1],
-    IO[T2],
+		IO[T2],
-    IO[T3],
+		IO[T3],
-    IO[T4],
+		IO[T4],
-  ](t)
+	](t)
 }
 
 // TraverseTuple4 converts a [T.Tuple4[IO[T]]] into a [IO[T.Tuple4[T1, T2, T3, T4]]]
 func TraverseTuple4[F1 ~func(A1) IO[T1], F2 ~func(A2) IO[T2], F3 ~func(A3) IO[T3], F4 ~func(A4) IO[T4], A1, A2, A3, A4, T1, T2, T3, T4 any](f1 F1, f2 F2, f3 F3, f4 F4) func(T.Tuple4[A1, A2, A3, A4]) IO[T.Tuple4[T1, T2, T3, T4]] {
-  return G.TraverseTuple4[IO[T.Tuple4[T1, T2, T3, T4]]](f1, f2, f3, f4)
+	return G.TraverseTuple4[IO[T.Tuple4[T1, T2, T3, T4]]](f1, f2, f3, f4)
 }
 
 // SequenceT5 converts 5 [IO[T]] into a [IO[T.Tuple5[T1, T2, T3, T4, T5]]]
 func SequenceT5[T1, T2, T3, T4, T5 any](
-  t1 IO[T1],
+	t1 IO[T1],
-  t2 IO[T2],
+	t2 IO[T2],
-  t3 IO[T3],
+	t3 IO[T3],
-  t4 IO[T4],
+	t4 IO[T4],
-  t5 IO[T5],
+	t5 IO[T5],
 ) IO[T.Tuple5[T1, T2, T3, T4, T5]] {
-  return G.SequenceT5[
+	return G.SequenceT5[
-    IO[T.Tuple5[T1, T2, T3, T4, T5]],
+		IO[T.Tuple5[T1, T2, T3, T4, T5]],
-    IO[T1],
+		IO[T1],
-    IO[T2],
+		IO[T2],
-    IO[T3],
+		IO[T3],
-    IO[T4],
+		IO[T4],
-    IO[T5],
+		IO[T5],
-  ](t1, t2, t3, t4, t5)
+	](t1, t2, t3, t4, t5)
 }
 
 // SequenceTuple5 converts a [T.Tuple5[IO[T]]] into a [IO[T.Tuple5[T1, T2, T3, T4, T5]]]
 func SequenceTuple5[T1, T2, T3, T4, T5 any](t T.Tuple5[IO[T1], IO[T2], IO[T3], IO[T4], IO[T5]]) IO[T.Tuple5[T1, T2, T3, T4, T5]] {
-  return G.SequenceTuple5[
+	return G.SequenceTuple5[
-    IO[T.Tuple5[T1, T2, T3, T4, T5]],
+		IO[T.Tuple5[T1, T2, T3, T4, T5]],
-    IO[T1],
+		IO[T1],
-    IO[T2],
+		IO[T2],
-    IO[T3],
+		IO[T3],
-    IO[T4],
+		IO[T4],
-    IO[T5],
+		IO[T5],
-  ](t)
+	](t)
 }
 
 // TraverseTuple5 converts a [T.Tuple5[IO[T]]] into a [IO[T.Tuple5[T1, T2, T3, T4, T5]]]
 func TraverseTuple5[F1 ~func(A1) IO[T1], F2 ~func(A2) IO[T2], F3 ~func(A3) IO[T3], F4 ~func(A4) IO[T4], F5 ~func(A5) IO[T5], A1, A2, A3, A4, A5, T1, T2, T3, T4, T5 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) func(T.Tuple5[A1, A2, A3, A4, A5]) IO[T.Tuple5[T1, T2, T3, T4, T5]] {
-  return G.TraverseTuple5[IO[T.Tuple5[T1, T2, T3, T4, T5]]](f1, f2, f3, f4, f5)
+	return G.TraverseTuple5[IO[T.Tuple5[T1, T2, T3, T4, T5]]](f1, f2, f3, f4, f5)
 }
 
 // SequenceT6 converts 6 [IO[T]] into a [IO[T.Tuple6[T1, T2, T3, T4, T5, T6]]]
 func SequenceT6[T1, T2, T3, T4, T5, T6 any](
-  t1 IO[T1],
+	t1 IO[T1],
-  t2 IO[T2],
+	t2 IO[T2],
-  t3 IO[T3],
+	t3 IO[T3],
-  t4 IO[T4],
+	t4 IO[T4],
-  t5 IO[T5],
+	t5 IO[T5],
-  t6 IO[T6],
+	t6 IO[T6],
 ) IO[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-  return G.SequenceT6[
+	return G.SequenceT6[
-    IO[T.Tuple6[T1, T2, T3, T4, T5, T6]],
+		IO[T.Tuple6[T1, T2, T3, T4, T5, T6]],
-    IO[T1],
+		IO[T1],
-    IO[T2],
+		IO[T2],
-    IO[T3],
+		IO[T3],
-    IO[T4],
+		IO[T4],
-    IO[T5],
+		IO[T5],
-    IO[T6],
+		IO[T6],
-  ](t1, t2, t3, t4, t5, t6)
+	](t1, t2, t3, t4, t5, t6)
 }
 
 // SequenceTuple6 converts a [T.Tuple6[IO[T]]] into a [IO[T.Tuple6[T1, T2, T3, T4, T5, T6]]]
 func SequenceTuple6[T1, T2, T3, T4, T5, T6 any](t T.Tuple6[IO[T1], IO[T2], IO[T3], IO[T4], IO[T5], IO[T6]]) IO[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-  return G.SequenceTuple6[
+	return G.SequenceTuple6[
-    IO[T.Tuple6[T1, T2, T3, T4, T5, T6]],
+		IO[T.Tuple6[T1, T2, T3, T4, T5, T6]],
-    IO[T1],
+		IO[T1],
-    IO[T2],
+		IO[T2],
-    IO[T3],
+		IO[T3],
-    IO[T4],
+		IO[T4],
-    IO[T5],
+		IO[T5],
-    IO[T6],
+		IO[T6],
-  ](t)
+	](t)
 }
 
 // TraverseTuple6 converts a [T.Tuple6[IO[T]]] into a [IO[T.Tuple6[T1, T2, T3, T4, T5, T6]]]
 func TraverseTuple6[F1 ~func(A1) IO[T1], F2 ~func(A2) IO[T2], F3 ~func(A3) IO[T3], F4 ~func(A4) IO[T4], F5 ~func(A5) IO[T5], F6 ~func(A6) IO[T6], A1, A2, A3, A4, A5, A6, T1, T2, T3, T4, T5, T6 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) func(T.Tuple6[A1, A2, A3, A4, A5, A6]) IO[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-  return G.TraverseTuple6[IO[T.Tuple6[T1, T2, T3, T4, T5, T6]]](f1, f2, f3, f4, f5, f6)
+	return G.TraverseTuple6[IO[T.Tuple6[T1, T2, T3, T4, T5, T6]]](f1, f2, f3, f4, f5, f6)
 }
 
 // SequenceT7 converts 7 [IO[T]] into a [IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
 func SequenceT7[T1, T2, T3, T4, T5, T6, T7 any](
-  t1 IO[T1],
+	t1 IO[T1],
-  t2 IO[T2],
+	t2 IO[T2],
-  t3 IO[T3],
+	t3 IO[T3],
-  t4 IO[T4],
+	t4 IO[T4],
-  t5 IO[T5],
+	t5 IO[T5],
-  t6 IO[T6],
+	t6 IO[T6],
-  t7 IO[T7],
+	t7 IO[T7],
 ) IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-  return G.SequenceT7[
+	return G.SequenceT7[
-    IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+		IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
-    IO[T1],
+		IO[T1],
-    IO[T2],
+		IO[T2],
-    IO[T3],
+		IO[T3],
-    IO[T4],
+		IO[T4],
-    IO[T5],
+		IO[T5],
-    IO[T6],
+		IO[T6],
-    IO[T7],
+		IO[T7],
-  ](t1, t2, t3, t4, t5, t6, t7)
+	](t1, t2, t3, t4, t5, t6, t7)
 }
 
 // SequenceTuple7 converts a [T.Tuple7[IO[T]]] into a [IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
 func SequenceTuple7[T1, T2, T3, T4, T5, T6, T7 any](t T.Tuple7[IO[T1], IO[T2], IO[T3], IO[T4], IO[T5], IO[T6], IO[T7]]) IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-  return G.SequenceTuple7[
+	return G.SequenceTuple7[
-    IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+		IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
-    IO[T1],
+		IO[T1],
-    IO[T2],
+		IO[T2],
-    IO[T3],
+		IO[T3],
-    IO[T4],
+		IO[T4],
-    IO[T5],
+		IO[T5],
-    IO[T6],
+		IO[T6],
-    IO[T7],
+		IO[T7],
-  ](t)
+	](t)
 }
 
 // TraverseTuple7 converts a [T.Tuple7[IO[T]]] into a [IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
 func TraverseTuple7[F1 ~func(A1) IO[T1], F2 ~func(A2) IO[T2], F3 ~func(A3) IO[T3], F4 ~func(A4) IO[T4], F5 ~func(A5) IO[T5], F6 ~func(A6) IO[T6], F7 ~func(A7) IO[T7], A1, A2, A3, A4, A5, A6, A7, T1, T2, T3, T4, T5, T6, T7 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) func(T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-  return G.TraverseTuple7[IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](f1, f2, f3, f4, f5, f6, f7)
+	return G.TraverseTuple7[IO[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](f1, f2, f3, f4, f5, f6, f7)
 }
 
 // SequenceT8 converts 8 [IO[T]] into a [IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
 func SequenceT8[T1, T2, T3, T4, T5, T6, T7, T8 any](
-  t1 IO[T1],
+	t1 IO[T1],
-  t2 IO[T2],
+	t2 IO[T2],
-  t3 IO[T3],
+	t3 IO[T3],
-  t4 IO[T4],
+	t4 IO[T4],
-  t5 IO[T5],
+	t5 IO[T5],
-  t6 IO[T6],
+	t6 IO[T6],
-  t7 IO[T7],
+	t7 IO[T7],
-  t8 IO[T8],
+	t8 IO[T8],
 ) IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-  return G.SequenceT8[
+	return G.SequenceT8[
-    IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+		IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
-    IO[T1],
+		IO[T1],
-    IO[T2],
+		IO[T2],
-    IO[T3],
+		IO[T3],
-    IO[T4],
+		IO[T4],
-    IO[T5],
+		IO[T5],
-    IO[T6],
+		IO[T6],
-    IO[T7],
+		IO[T7],
-    IO[T8],
+		IO[T8],
-  ](t1, t2, t3, t4, t5, t6, t7, t8)
+	](t1, t2, t3, t4, t5, t6, t7, t8)
 }
 
 // SequenceTuple8 converts a [T.Tuple8[IO[T]]] into a [IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
 func SequenceTuple8[T1, T2, T3, T4, T5, T6, T7, T8 any](t T.Tuple8[IO[T1], IO[T2], IO[T3], IO[T4], IO[T5], IO[T6], IO[T7], IO[T8]]) IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-  return G.SequenceTuple8[
+	return G.SequenceTuple8[
-    IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+		IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
-    IO[T1],
+		IO[T1],
-    IO[T2],
+		IO[T2],
-    IO[T3],
+		IO[T3],
-    IO[T4],
+		IO[T4],
-    IO[T5],
+		IO[T5],
-    IO[T6],
+		IO[T6],
-    IO[T7],
+		IO[T7],
-    IO[T8],
+		IO[T8],
-  ](t)
+	](t)
 }
 
 // TraverseTuple8 converts a [T.Tuple8[IO[T]]] into a [IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
 func TraverseTuple8[F1 ~func(A1) IO[T1], F2 ~func(A2) IO[T2], F3 ~func(A3) IO[T3], F4 ~func(A4) IO[T4], F5 ~func(A5) IO[T5], F6 ~func(A6) IO[T6], F7 ~func(A7) IO[T7], F8 ~func(A8) IO[T8], A1, A2, A3, A4, A5, A6, A7, A8, T1, T2, T3, T4, T5, T6, T7, T8 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) func(T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-  return G.TraverseTuple8[IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](f1, f2, f3, f4, f5, f6, f7, f8)
+	return G.TraverseTuple8[IO[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](f1, f2, f3, f4, f5, f6, f7, f8)
 }
 
 // SequenceT9 converts 9 [IO[T]] into a [IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
 func SequenceT9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
-  t1 IO[T1],
+	t1 IO[T1],
-  t2 IO[T2],
+	t2 IO[T2],
-  t3 IO[T3],
+	t3 IO[T3],
-  t4 IO[T4],
+	t4 IO[T4],
-  t5 IO[T5],
+	t5 IO[T5],
-  t6 IO[T6],
+	t6 IO[T6],
-  t7 IO[T7],
+	t7 IO[T7],
-  t8 IO[T8],
+	t8 IO[T8],
-  t9 IO[T9],
+	t9 IO[T9],
 ) IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-  return G.SequenceT9[
+	return G.SequenceT9[
-    IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+		IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
-    IO[T1],
+		IO[T1],
-    IO[T2],
+		IO[T2],
-    IO[T3],
+		IO[T3],
-    IO[T4],
+		IO[T4],
-    IO[T5],
+		IO[T5],
-    IO[T6],
+		IO[T6],
-    IO[T7],
+		IO[T7],
-    IO[T8],
+		IO[T8],
-    IO[T9],
+		IO[T9],
-  ](t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	](t1, t2, t3, t4, t5, t6, t7, t8, t9)
 }
 
 // SequenceTuple9 converts a [T.Tuple9[IO[T]]] into a [IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
 func SequenceTuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t T.Tuple9[IO[T1], IO[T2], IO[T3], IO[T4], IO[T5], IO[T6], IO[T7], IO[T8], IO[T9]]) IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-  return G.SequenceTuple9[
+	return G.SequenceTuple9[
-    IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+		IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
-    IO[T1],
+		IO[T1],
-    IO[T2],
+		IO[T2],
-    IO[T3],
+		IO[T3],
-    IO[T4],
+		IO[T4],
-    IO[T5],
+		IO[T5],
-    IO[T6],
+		IO[T6],
-    IO[T7],
+		IO[T7],
-    IO[T8],
+		IO[T8],
-    IO[T9],
+		IO[T9],
-  ](t)
+	](t)
 }
 
 // TraverseTuple9 converts a [T.Tuple9[IO[T]]] into a [IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
 func TraverseTuple9[F1 ~func(A1) IO[T1], F2 ~func(A2) IO[T2], F3 ~func(A3) IO[T3], F4 ~func(A4) IO[T4], F5 ~func(A5) IO[T5], F6 ~func(A6) IO[T6], F7 ~func(A7) IO[T7], F8 ~func(A8) IO[T8], F9 ~func(A9) IO[T9], A1, A2, A3, A4, A5, A6, A7, A8, A9, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) func(T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-  return G.TraverseTuple9[IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](f1, f2, f3, f4, f5, f6, f7, f8, f9)
+	return G.TraverseTuple9[IO[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](f1, f2, f3, f4, f5, f6, f7, f8, f9)
 }
 
 // SequenceT10 converts 10 [IO[T]] into a [IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
 func SequenceT10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](
-  t1 IO[T1],
+	t1 IO[T1],
-  t2 IO[T2],
+	t2 IO[T2],
-  t3 IO[T3],
+	t3 IO[T3],
-  t4 IO[T4],
+	t4 IO[T4],
-  t5 IO[T5],
+	t5 IO[T5],
-  t6 IO[T6],
+	t6 IO[T6],
-  t7 IO[T7],
+	t7 IO[T7],
-  t8 IO[T8],
+	t8 IO[T8],
-  t9 IO[T9],
+	t9 IO[T9],
-  t10 IO[T10],
+	t10 IO[T10],
 ) IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-  return G.SequenceT10[
+	return G.SequenceT10[
-    IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+		IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
-    IO[T1],
+		IO[T1],
-    IO[T2],
+		IO[T2],
-    IO[T3],
+		IO[T3],
-    IO[T4],
+		IO[T4],
-    IO[T5],
+		IO[T5],
-    IO[T6],
+		IO[T6],
-    IO[T7],
+		IO[T7],
-    IO[T8],
+		IO[T8],
-    IO[T9],
+		IO[T9],
-    IO[T10],
+		IO[T10],
-  ](t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
+	](t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
 }
 
 // SequenceTuple10 converts a [T.Tuple10[IO[T]]] into a [IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
 func SequenceTuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t T.Tuple10[IO[T1], IO[T2], IO[T3], IO[T4], IO[T5], IO[T6], IO[T7], IO[T8], IO[T9], IO[T10]]) IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-  return G.SequenceTuple10[
+	return G.SequenceTuple10[
-    IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+		IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
-    IO[T1],
+		IO[T1],
-    IO[T2],
+		IO[T2],
-    IO[T3],
+		IO[T3],
-    IO[T4],
+		IO[T4],
-    IO[T5],
+		IO[T5],
-    IO[T6],
+		IO[T6],
-    IO[T7],
+		IO[T7],
-    IO[T8],
+		IO[T8],
-    IO[T9],
+		IO[T9],
-    IO[T10],
+		IO[T10],
-  ](t)
+	](t)
 }
 
 // TraverseTuple10 converts a [T.Tuple10[IO[T]]] into a [IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
 func TraverseTuple10[F1 ~func(A1) IO[T1], F2 ~func(A2) IO[T2], F3 ~func(A3) IO[T3], F4 ~func(A4) IO[T4], F5 ~func(A5) IO[T5], F6 ~func(A6) IO[T6], F7 ~func(A7) IO[T7], F8 ~func(A8) IO[T8], F9 ~func(A9) IO[T9], F10 ~func(A10) IO[T10], A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) func(T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-  return G.TraverseTuple10[IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)
+	return G.TraverseTuple10[IO[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)
 }

io/generic/ap.go

@@ -64,6 +64,28 @@ func MonadApFirst[GA ~func() A, GB ~func() B, GBA ~func() func(B) A, A, B any](f
 	)
 }
 
+// MonadApFirstPar combines two effectful actions, keeping only the result of the first.
+func MonadApFirstPar[GA ~func() A, GB ~func() B, GBA ~func() func(B) A, A, B any](first GA, second GB) GA {
+	return G.MonadApFirst(
+		MonadApPar[GB, GA, GBA, B, A],
+		MonadMap[GA, GBA, A, func(B) A],
+
+		first,
+		second,
+	)
+}
+
+// MonadApFirstSeq combines two effectful actions, keeping only the result of the first.
+func MonadApFirstSeq[GA ~func() A, GB ~func() B, GBA ~func() func(B) A, A, B any](first GA, second GB) GA {
+	return G.MonadApFirst(
+		MonadApSeq[GB, GA, GBA, B, A],
+		MonadMap[GA, GBA, A, func(B) A],
+
+		first,
+		second,
+	)
+}
+
 // ApFirst combines two effectful actions, keeping only the result of the first.
 func ApFirst[GA ~func() A, GB ~func() B, GBA ~func() func(B) A, A, B any](second GB) func(GA) GA {
 	return G.ApFirst(
@@ -74,6 +96,26 @@ func ApFirst[GA ~func() A, GB ~func() B, GBA ~func() func(B) A, A, B any](second
 	)
 }
 
+// ApFirstPar combines two effectful actions, keeping only the result of the first.
+func ApFirstPar[GA ~func() A, GB ~func() B, GBA ~func() func(B) A, A, B any](second GB) func(GA) GA {
+	return G.ApFirst(
+		MonadApPar[GB, GA, GBA, B, A],
+		MonadMap[GA, GBA, A, func(B) A],
+
+		second,
+	)
+}
+
+// ApFirstSeq combines two effectful actions, keeping only the result of the first.
+func ApFirstSeq[GA ~func() A, GB ~func() B, GBA ~func() func(B) A, A, B any](second GB) func(GA) GA {
+	return G.ApFirst(
+		MonadApSeq[GB, GA, GBA, B, A],
+		MonadMap[GA, GBA, A, func(B) A],
+
+		second,
+	)
+}
+
 // MonadApSecond combines two effectful actions, keeping only the result of the second.
 func MonadApSecond[GA ~func() A, GB ~func() B, GBB ~func() func(B) B, A, B any](first GA, second GB) GB {
 	return G.MonadApSecond(

ioeither/bind.go

@@ -35,3 +35,10 @@ func ApS[
 ](s func(A) func(S1) S2, fa IOEither[E, A]) func(IOEither[E, S1]) IOEither[E, S2] {
 	return G.ApS[IOEither[E, S1], IOEither[E, S2], IOEither[E, A], IOEither[E, func(S1) S2]](s, fa)
 }
+
+func Let[E, A, S1, S2 any](
+	s func(A) func(S1) S2,
+	f func(S1) A,
+) func(IOEither[E, S1]) IOEither[E, S2] {
+	return G.Let[IOEither[E, S1], IOEither[E, S2]](s, f)
+}

ioeither/gen.go

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

ioeither/generic/bind.go

@@ -65,3 +65,15 @@ func ApS[
 		fb,
 	)
 }
+
+func Let[
+	GS1 ~func() ET.Either[E, S1],
+	GS2 ~func() ET.Either[E, S2],
+	SET ~func(B) func(S1) S2,
+	FCT ~func(S1) B,
+	E, S1, S2, B any](
+	s SET,
+	f FCT,
+) func(GS1) GS2 {
+	return G.Let[SET, FCT, S1, S2, B, GS1, GS2](Map[GS1, GS2, E, S1, S2], s, f)
+}

iooption/gen.go

@@ -4,373 +4,372 @@
 
 package iooption
 
-
 import (
-	G "github.com/IBM/fp-go/iooption/generic"	
+	G "github.com/IBM/fp-go/iooption/generic"
 	T "github.com/IBM/fp-go/tuple"
 )
 
 // SequenceT1 converts 1 [IOOption[T]] into a [IOOption[T.Tuple1[T1]]]
 func SequenceT1[T1 any](
-  t1 IOOption[T1],
+	t1 IOOption[T1],
 ) IOOption[T.Tuple1[T1]] {
-  return G.SequenceT1[
+	return G.SequenceT1[
-    IOOption[T.Tuple1[T1]],
+		IOOption[T.Tuple1[T1]],
-    IOOption[T1],
+		IOOption[T1],
-  ](t1)
+	](t1)
 }
 
 // SequenceTuple1 converts a [T.Tuple1[IOOption[T]]] into a [IOOption[T.Tuple1[T1]]]
 func SequenceTuple1[T1 any](t T.Tuple1[IOOption[T1]]) IOOption[T.Tuple1[T1]] {
-  return G.SequenceTuple1[
+	return G.SequenceTuple1[
-    IOOption[T.Tuple1[T1]],
+		IOOption[T.Tuple1[T1]],
-    IOOption[T1],
+		IOOption[T1],
-  ](t)
+	](t)
 }
 
 // TraverseTuple1 converts a [T.Tuple1[IOOption[T]]] into a [IOOption[T.Tuple1[T1]]]
 func TraverseTuple1[F1 ~func(A1) IOOption[T1], A1, T1 any](f1 F1) func(T.Tuple1[A1]) IOOption[T.Tuple1[T1]] {
-  return G.TraverseTuple1[IOOption[T.Tuple1[T1]]](f1)
+	return G.TraverseTuple1[IOOption[T.Tuple1[T1]]](f1)
 }
 
 // SequenceT2 converts 2 [IOOption[T]] into a [IOOption[T.Tuple2[T1, T2]]]
 func SequenceT2[T1, T2 any](
-  t1 IOOption[T1],
+	t1 IOOption[T1],
-  t2 IOOption[T2],
+	t2 IOOption[T2],
 ) IOOption[T.Tuple2[T1, T2]] {
-  return G.SequenceT2[
+	return G.SequenceT2[
-    IOOption[T.Tuple2[T1, T2]],
+		IOOption[T.Tuple2[T1, T2]],
-    IOOption[T1],
+		IOOption[T1],
-    IOOption[T2],
+		IOOption[T2],
-  ](t1, t2)
+	](t1, t2)
 }
 
 // SequenceTuple2 converts a [T.Tuple2[IOOption[T]]] into a [IOOption[T.Tuple2[T1, T2]]]
 func SequenceTuple2[T1, T2 any](t T.Tuple2[IOOption[T1], IOOption[T2]]) IOOption[T.Tuple2[T1, T2]] {
-  return G.SequenceTuple2[
+	return G.SequenceTuple2[
-    IOOption[T.Tuple2[T1, T2]],
+		IOOption[T.Tuple2[T1, T2]],
-    IOOption[T1],
+		IOOption[T1],
-    IOOption[T2],
+		IOOption[T2],
-  ](t)
+	](t)
 }
 
 // TraverseTuple2 converts a [T.Tuple2[IOOption[T]]] into a [IOOption[T.Tuple2[T1, T2]]]
 func TraverseTuple2[F1 ~func(A1) IOOption[T1], F2 ~func(A2) IOOption[T2], A1, A2, T1, T2 any](f1 F1, f2 F2) func(T.Tuple2[A1, A2]) IOOption[T.Tuple2[T1, T2]] {
-  return G.TraverseTuple2[IOOption[T.Tuple2[T1, T2]]](f1, f2)
+	return G.TraverseTuple2[IOOption[T.Tuple2[T1, T2]]](f1, f2)
 }
 
 // SequenceT3 converts 3 [IOOption[T]] into a [IOOption[T.Tuple3[T1, T2, T3]]]
 func SequenceT3[T1, T2, T3 any](
-  t1 IOOption[T1],
+	t1 IOOption[T1],
-  t2 IOOption[T2],
+	t2 IOOption[T2],
-  t3 IOOption[T3],
+	t3 IOOption[T3],
 ) IOOption[T.Tuple3[T1, T2, T3]] {
-  return G.SequenceT3[
+	return G.SequenceT3[
-    IOOption[T.Tuple3[T1, T2, T3]],
+		IOOption[T.Tuple3[T1, T2, T3]],
-    IOOption[T1],
+		IOOption[T1],
-    IOOption[T2],
+		IOOption[T2],
-    IOOption[T3],
+		IOOption[T3],
-  ](t1, t2, t3)
+	](t1, t2, t3)
 }
 
 // SequenceTuple3 converts a [T.Tuple3[IOOption[T]]] into a [IOOption[T.Tuple3[T1, T2, T3]]]
 func SequenceTuple3[T1, T2, T3 any](t T.Tuple3[IOOption[T1], IOOption[T2], IOOption[T3]]) IOOption[T.Tuple3[T1, T2, T3]] {
-  return G.SequenceTuple3[
+	return G.SequenceTuple3[
-    IOOption[T.Tuple3[T1, T2, T3]],
+		IOOption[T.Tuple3[T1, T2, T3]],
-    IOOption[T1],
+		IOOption[T1],
-    IOOption[T2],
+		IOOption[T2],
-    IOOption[T3],
+		IOOption[T3],
-  ](t)
+	](t)
 }
 
 // TraverseTuple3 converts a [T.Tuple3[IOOption[T]]] into a [IOOption[T.Tuple3[T1, T2, T3]]]
 func TraverseTuple3[F1 ~func(A1) IOOption[T1], F2 ~func(A2) IOOption[T2], F3 ~func(A3) IOOption[T3], A1, A2, A3, T1, T2, T3 any](f1 F1, f2 F2, f3 F3) func(T.Tuple3[A1, A2, A3]) IOOption[T.Tuple3[T1, T2, T3]] {
-  return G.TraverseTuple3[IOOption[T.Tuple3[T1, T2, T3]]](f1, f2, f3)
+	return G.TraverseTuple3[IOOption[T.Tuple3[T1, T2, T3]]](f1, f2, f3)
 }
 
 // SequenceT4 converts 4 [IOOption[T]] into a [IOOption[T.Tuple4[T1, T2, T3, T4]]]
 func SequenceT4[T1, T2, T3, T4 any](
-  t1 IOOption[T1],
+	t1 IOOption[T1],
-  t2 IOOption[T2],
+	t2 IOOption[T2],
-  t3 IOOption[T3],
+	t3 IOOption[T3],
-  t4 IOOption[T4],
+	t4 IOOption[T4],
 ) IOOption[T.Tuple4[T1, T2, T3, T4]] {
-  return G.SequenceT4[
+	return G.SequenceT4[
-    IOOption[T.Tuple4[T1, T2, T3, T4]],
+		IOOption[T.Tuple4[T1, T2, T3, T4]],
-    IOOption[T1],
+		IOOption[T1],
-    IOOption[T2],
+		IOOption[T2],
-    IOOption[T3],
+		IOOption[T3],
-    IOOption[T4],
+		IOOption[T4],
-  ](t1, t2, t3, t4)
+	](t1, t2, t3, t4)
 }
 
 // SequenceTuple4 converts a [T.Tuple4[IOOption[T]]] into a [IOOption[T.Tuple4[T1, T2, T3, T4]]]
 func SequenceTuple4[T1, T2, T3, T4 any](t T.Tuple4[IOOption[T1], IOOption[T2], IOOption[T3], IOOption[T4]]) IOOption[T.Tuple4[T1, T2, T3, T4]] {
-  return G.SequenceTuple4[
+	return G.SequenceTuple4[
-    IOOption[T.Tuple4[T1, T2, T3, T4]],
+		IOOption[T.Tuple4[T1, T2, T3, T4]],
-    IOOption[T1],
+		IOOption[T1],
-    IOOption[T2],
+		IOOption[T2],
-    IOOption[T3],
+		IOOption[T3],
-    IOOption[T4],
+		IOOption[T4],
-  ](t)
+	](t)
 }
 
 // TraverseTuple4 converts a [T.Tuple4[IOOption[T]]] into a [IOOption[T.Tuple4[T1, T2, T3, T4]]]
 func TraverseTuple4[F1 ~func(A1) IOOption[T1], F2 ~func(A2) IOOption[T2], F3 ~func(A3) IOOption[T3], F4 ~func(A4) IOOption[T4], A1, A2, A3, A4, T1, T2, T3, T4 any](f1 F1, f2 F2, f3 F3, f4 F4) func(T.Tuple4[A1, A2, A3, A4]) IOOption[T.Tuple4[T1, T2, T3, T4]] {
-  return G.TraverseTuple4[IOOption[T.Tuple4[T1, T2, T3, T4]]](f1, f2, f3, f4)
+	return G.TraverseTuple4[IOOption[T.Tuple4[T1, T2, T3, T4]]](f1, f2, f3, f4)
 }
 
 // SequenceT5 converts 5 [IOOption[T]] into a [IOOption[T.Tuple5[T1, T2, T3, T4, T5]]]
 func SequenceT5[T1, T2, T3, T4, T5 any](
-  t1 IOOption[T1],
+	t1 IOOption[T1],
-  t2 IOOption[T2],
+	t2 IOOption[T2],
-  t3 IOOption[T3],
+	t3 IOOption[T3],
-  t4 IOOption[T4],
+	t4 IOOption[T4],
-  t5 IOOption[T5],
+	t5 IOOption[T5],
 ) IOOption[T.Tuple5[T1, T2, T3, T4, T5]] {
-  return G.SequenceT5[
+	return G.SequenceT5[
-    IOOption[T.Tuple5[T1, T2, T3, T4, T5]],
+		IOOption[T.Tuple5[T1, T2, T3, T4, T5]],
-    IOOption[T1],
+		IOOption[T1],
-    IOOption[T2],
+		IOOption[T2],
-    IOOption[T3],
+		IOOption[T3],
-    IOOption[T4],
+		IOOption[T4],
-    IOOption[T5],
+		IOOption[T5],
-  ](t1, t2, t3, t4, t5)
+	](t1, t2, t3, t4, t5)
 }
 
 // SequenceTuple5 converts a [T.Tuple5[IOOption[T]]] into a [IOOption[T.Tuple5[T1, T2, T3, T4, T5]]]
 func SequenceTuple5[T1, T2, T3, T4, T5 any](t T.Tuple5[IOOption[T1], IOOption[T2], IOOption[T3], IOOption[T4], IOOption[T5]]) IOOption[T.Tuple5[T1, T2, T3, T4, T5]] {
-  return G.SequenceTuple5[
+	return G.SequenceTuple5[
-    IOOption[T.Tuple5[T1, T2, T3, T4, T5]],
+		IOOption[T.Tuple5[T1, T2, T3, T4, T5]],
-    IOOption[T1],
+		IOOption[T1],
-    IOOption[T2],
+		IOOption[T2],
-    IOOption[T3],
+		IOOption[T3],
-    IOOption[T4],
+		IOOption[T4],
-    IOOption[T5],
+		IOOption[T5],
-  ](t)
+	](t)
 }
 
 // TraverseTuple5 converts a [T.Tuple5[IOOption[T]]] into a [IOOption[T.Tuple5[T1, T2, T3, T4, T5]]]
 func TraverseTuple5[F1 ~func(A1) IOOption[T1], F2 ~func(A2) IOOption[T2], F3 ~func(A3) IOOption[T3], F4 ~func(A4) IOOption[T4], F5 ~func(A5) IOOption[T5], A1, A2, A3, A4, A5, T1, T2, T3, T4, T5 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) func(T.Tuple5[A1, A2, A3, A4, A5]) IOOption[T.Tuple5[T1, T2, T3, T4, T5]] {
-  return G.TraverseTuple5[IOOption[T.Tuple5[T1, T2, T3, T4, T5]]](f1, f2, f3, f4, f5)
+	return G.TraverseTuple5[IOOption[T.Tuple5[T1, T2, T3, T4, T5]]](f1, f2, f3, f4, f5)
 }
 
 // SequenceT6 converts 6 [IOOption[T]] into a [IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]]]
 func SequenceT6[T1, T2, T3, T4, T5, T6 any](
-  t1 IOOption[T1],
+	t1 IOOption[T1],
-  t2 IOOption[T2],
+	t2 IOOption[T2],
-  t3 IOOption[T3],
+	t3 IOOption[T3],
-  t4 IOOption[T4],
+	t4 IOOption[T4],
-  t5 IOOption[T5],
+	t5 IOOption[T5],
-  t6 IOOption[T6],
+	t6 IOOption[T6],
 ) IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-  return G.SequenceT6[
+	return G.SequenceT6[
-    IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]],
+		IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]],
-    IOOption[T1],
+		IOOption[T1],
-    IOOption[T2],
+		IOOption[T2],
-    IOOption[T3],
+		IOOption[T3],
-    IOOption[T4],
+		IOOption[T4],
-    IOOption[T5],
+		IOOption[T5],
-    IOOption[T6],
+		IOOption[T6],
-  ](t1, t2, t3, t4, t5, t6)
+	](t1, t2, t3, t4, t5, t6)
 }
 
 // SequenceTuple6 converts a [T.Tuple6[IOOption[T]]] into a [IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]]]
 func SequenceTuple6[T1, T2, T3, T4, T5, T6 any](t T.Tuple6[IOOption[T1], IOOption[T2], IOOption[T3], IOOption[T4], IOOption[T5], IOOption[T6]]) IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-  return G.SequenceTuple6[
+	return G.SequenceTuple6[
-    IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]],
+		IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]],
-    IOOption[T1],
+		IOOption[T1],
-    IOOption[T2],
+		IOOption[T2],
-    IOOption[T3],
+		IOOption[T3],
-    IOOption[T4],
+		IOOption[T4],
-    IOOption[T5],
+		IOOption[T5],
-    IOOption[T6],
+		IOOption[T6],
-  ](t)
+	](t)
 }
 
 // TraverseTuple6 converts a [T.Tuple6[IOOption[T]]] into a [IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]]]
 func TraverseTuple6[F1 ~func(A1) IOOption[T1], F2 ~func(A2) IOOption[T2], F3 ~func(A3) IOOption[T3], F4 ~func(A4) IOOption[T4], F5 ~func(A5) IOOption[T5], F6 ~func(A6) IOOption[T6], A1, A2, A3, A4, A5, A6, T1, T2, T3, T4, T5, T6 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) func(T.Tuple6[A1, A2, A3, A4, A5, A6]) IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
-  return G.TraverseTuple6[IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]]](f1, f2, f3, f4, f5, f6)
+	return G.TraverseTuple6[IOOption[T.Tuple6[T1, T2, T3, T4, T5, T6]]](f1, f2, f3, f4, f5, f6)
 }
 
 // SequenceT7 converts 7 [IOOption[T]] into a [IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
 func SequenceT7[T1, T2, T3, T4, T5, T6, T7 any](
-  t1 IOOption[T1],
+	t1 IOOption[T1],
-  t2 IOOption[T2],
+	t2 IOOption[T2],
-  t3 IOOption[T3],
+	t3 IOOption[T3],
-  t4 IOOption[T4],
+	t4 IOOption[T4],
-  t5 IOOption[T5],
+	t5 IOOption[T5],
-  t6 IOOption[T6],
+	t6 IOOption[T6],
-  t7 IOOption[T7],
+	t7 IOOption[T7],
 ) IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-  return G.SequenceT7[
+	return G.SequenceT7[
-    IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+		IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
-    IOOption[T1],
+		IOOption[T1],
-    IOOption[T2],
+		IOOption[T2],
-    IOOption[T3],
+		IOOption[T3],
-    IOOption[T4],
+		IOOption[T4],
-    IOOption[T5],
+		IOOption[T5],
-    IOOption[T6],
+		IOOption[T6],
-    IOOption[T7],
+		IOOption[T7],
-  ](t1, t2, t3, t4, t5, t6, t7)
+	](t1, t2, t3, t4, t5, t6, t7)
 }
 
 // SequenceTuple7 converts a [T.Tuple7[IOOption[T]]] into a [IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
 func SequenceTuple7[T1, T2, T3, T4, T5, T6, T7 any](t T.Tuple7[IOOption[T1], IOOption[T2], IOOption[T3], IOOption[T4], IOOption[T5], IOOption[T6], IOOption[T7]]) IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-  return G.SequenceTuple7[
+	return G.SequenceTuple7[
-    IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+		IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
-    IOOption[T1],
+		IOOption[T1],
-    IOOption[T2],
+		IOOption[T2],
-    IOOption[T3],
+		IOOption[T3],
-    IOOption[T4],
+		IOOption[T4],
-    IOOption[T5],
+		IOOption[T5],
-    IOOption[T6],
+		IOOption[T6],
-    IOOption[T7],
+		IOOption[T7],
-  ](t)
+	](t)
 }
 
 // TraverseTuple7 converts a [T.Tuple7[IOOption[T]]] into a [IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
 func TraverseTuple7[F1 ~func(A1) IOOption[T1], F2 ~func(A2) IOOption[T2], F3 ~func(A3) IOOption[T3], F4 ~func(A4) IOOption[T4], F5 ~func(A5) IOOption[T5], F6 ~func(A6) IOOption[T6], F7 ~func(A7) IOOption[T7], A1, A2, A3, A4, A5, A6, A7, T1, T2, T3, T4, T5, T6, T7 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) func(T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-  return G.TraverseTuple7[IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](f1, f2, f3, f4, f5, f6, f7)
+	return G.TraverseTuple7[IOOption[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](f1, f2, f3, f4, f5, f6, f7)
 }
 
 // SequenceT8 converts 8 [IOOption[T]] into a [IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
 func SequenceT8[T1, T2, T3, T4, T5, T6, T7, T8 any](
-  t1 IOOption[T1],
+	t1 IOOption[T1],
-  t2 IOOption[T2],
+	t2 IOOption[T2],
-  t3 IOOption[T3],
+	t3 IOOption[T3],
-  t4 IOOption[T4],
+	t4 IOOption[T4],
-  t5 IOOption[T5],
+	t5 IOOption[T5],
-  t6 IOOption[T6],
+	t6 IOOption[T6],
-  t7 IOOption[T7],
+	t7 IOOption[T7],
-  t8 IOOption[T8],
+	t8 IOOption[T8],
 ) IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-  return G.SequenceT8[
+	return G.SequenceT8[
-    IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+		IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
-    IOOption[T1],
+		IOOption[T1],
-    IOOption[T2],
+		IOOption[T2],
-    IOOption[T3],
+		IOOption[T3],
-    IOOption[T4],
+		IOOption[T4],
-    IOOption[T5],
+		IOOption[T5],
-    IOOption[T6],
+		IOOption[T6],
-    IOOption[T7],
+		IOOption[T7],
-    IOOption[T8],
+		IOOption[T8],
-  ](t1, t2, t3, t4, t5, t6, t7, t8)
+	](t1, t2, t3, t4, t5, t6, t7, t8)
 }
 
 // SequenceTuple8 converts a [T.Tuple8[IOOption[T]]] into a [IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
 func SequenceTuple8[T1, T2, T3, T4, T5, T6, T7, T8 any](t T.Tuple8[IOOption[T1], IOOption[T2], IOOption[T3], IOOption[T4], IOOption[T5], IOOption[T6], IOOption[T7], IOOption[T8]]) IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-  return G.SequenceTuple8[
+	return G.SequenceTuple8[
-    IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+		IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
-    IOOption[T1],
+		IOOption[T1],
-    IOOption[T2],
+		IOOption[T2],
-    IOOption[T3],
+		IOOption[T3],
-    IOOption[T4],
+		IOOption[T4],
-    IOOption[T5],
+		IOOption[T5],
-    IOOption[T6],
+		IOOption[T6],
-    IOOption[T7],
+		IOOption[T7],
-    IOOption[T8],
+		IOOption[T8],
-  ](t)
+	](t)
 }
 
 // TraverseTuple8 converts a [T.Tuple8[IOOption[T]]] into a [IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
 func TraverseTuple8[F1 ~func(A1) IOOption[T1], F2 ~func(A2) IOOption[T2], F3 ~func(A3) IOOption[T3], F4 ~func(A4) IOOption[T4], F5 ~func(A5) IOOption[T5], F6 ~func(A6) IOOption[T6], F7 ~func(A7) IOOption[T7], F8 ~func(A8) IOOption[T8], A1, A2, A3, A4, A5, A6, A7, A8, T1, T2, T3, T4, T5, T6, T7, T8 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) func(T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-  return G.TraverseTuple8[IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](f1, f2, f3, f4, f5, f6, f7, f8)
+	return G.TraverseTuple8[IOOption[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](f1, f2, f3, f4, f5, f6, f7, f8)
 }
 
 // SequenceT9 converts 9 [IOOption[T]] into a [IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
 func SequenceT9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
-  t1 IOOption[T1],
+	t1 IOOption[T1],
-  t2 IOOption[T2],
+	t2 IOOption[T2],
-  t3 IOOption[T3],
+	t3 IOOption[T3],
-  t4 IOOption[T4],
+	t4 IOOption[T4],
-  t5 IOOption[T5],
+	t5 IOOption[T5],
-  t6 IOOption[T6],
+	t6 IOOption[T6],
-  t7 IOOption[T7],
+	t7 IOOption[T7],
-  t8 IOOption[T8],
+	t8 IOOption[T8],
-  t9 IOOption[T9],
+	t9 IOOption[T9],
 ) IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-  return G.SequenceT9[
+	return G.SequenceT9[
-    IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+		IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
-    IOOption[T1],
+		IOOption[T1],
-    IOOption[T2],
+		IOOption[T2],
-    IOOption[T3],
+		IOOption[T3],
-    IOOption[T4],
+		IOOption[T4],
-    IOOption[T5],
+		IOOption[T5],
-    IOOption[T6],
+		IOOption[T6],
-    IOOption[T7],
+		IOOption[T7],
-    IOOption[T8],
+		IOOption[T8],
-    IOOption[T9],
+		IOOption[T9],
-  ](t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	](t1, t2, t3, t4, t5, t6, t7, t8, t9)
 }
 
 // SequenceTuple9 converts a [T.Tuple9[IOOption[T]]] into a [IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
 func SequenceTuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t T.Tuple9[IOOption[T1], IOOption[T2], IOOption[T3], IOOption[T4], IOOption[T5], IOOption[T6], IOOption[T7], IOOption[T8], IOOption[T9]]) IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-  return G.SequenceTuple9[
+	return G.SequenceTuple9[
-    IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+		IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
-    IOOption[T1],
+		IOOption[T1],
-    IOOption[T2],
+		IOOption[T2],
-    IOOption[T3],
+		IOOption[T3],
-    IOOption[T4],
+		IOOption[T4],
-    IOOption[T5],
+		IOOption[T5],
-    IOOption[T6],
+		IOOption[T6],
-    IOOption[T7],
+		IOOption[T7],
-    IOOption[T8],
+		IOOption[T8],
-    IOOption[T9],
+		IOOption[T9],
-  ](t)
+	](t)
 }
 
 // TraverseTuple9 converts a [T.Tuple9[IOOption[T]]] into a [IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
 func TraverseTuple9[F1 ~func(A1) IOOption[T1], F2 ~func(A2) IOOption[T2], F3 ~func(A3) IOOption[T3], F4 ~func(A4) IOOption[T4], F5 ~func(A5) IOOption[T5], F6 ~func(A6) IOOption[T6], F7 ~func(A7) IOOption[T7], F8 ~func(A8) IOOption[T8], F9 ~func(A9) IOOption[T9], A1, A2, A3, A4, A5, A6, A7, A8, A9, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) func(T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-  return G.TraverseTuple9[IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](f1, f2, f3, f4, f5, f6, f7, f8, f9)
+	return G.TraverseTuple9[IOOption[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](f1, f2, f3, f4, f5, f6, f7, f8, f9)
 }
 
 // SequenceT10 converts 10 [IOOption[T]] into a [IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
 func SequenceT10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](
-  t1 IOOption[T1],
+	t1 IOOption[T1],
-  t2 IOOption[T2],
+	t2 IOOption[T2],
-  t3 IOOption[T3],
+	t3 IOOption[T3],
-  t4 IOOption[T4],
+	t4 IOOption[T4],
-  t5 IOOption[T5],
+	t5 IOOption[T5],
-  t6 IOOption[T6],
+	t6 IOOption[T6],
-  t7 IOOption[T7],
+	t7 IOOption[T7],
-  t8 IOOption[T8],
+	t8 IOOption[T8],
-  t9 IOOption[T9],
+	t9 IOOption[T9],
-  t10 IOOption[T10],
+	t10 IOOption[T10],
 ) IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-  return G.SequenceT10[
+	return G.SequenceT10[
-    IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+		IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
-    IOOption[T1],
+		IOOption[T1],
-    IOOption[T2],
+		IOOption[T2],
-    IOOption[T3],
+		IOOption[T3],
-    IOOption[T4],
+		IOOption[T4],
-    IOOption[T5],
+		IOOption[T5],
-    IOOption[T6],
+		IOOption[T6],
-    IOOption[T7],
+		IOOption[T7],
-    IOOption[T8],
+		IOOption[T8],
-    IOOption[T9],
+		IOOption[T9],
-    IOOption[T10],
+		IOOption[T10],
-  ](t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
+	](t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
 }
 
 // SequenceTuple10 converts a [T.Tuple10[IOOption[T]]] into a [IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
 func SequenceTuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t T.Tuple10[IOOption[T1], IOOption[T2], IOOption[T3], IOOption[T4], IOOption[T5], IOOption[T6], IOOption[T7], IOOption[T8], IOOption[T9], IOOption[T10]]) IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-  return G.SequenceTuple10[
+	return G.SequenceTuple10[
-    IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+		IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
-    IOOption[T1],
+		IOOption[T1],
-    IOOption[T2],
+		IOOption[T2],
-    IOOption[T3],
+		IOOption[T3],
-    IOOption[T4],
+		IOOption[T4],
-    IOOption[T5],
+		IOOption[T5],
-    IOOption[T6],
+		IOOption[T6],
-    IOOption[T7],
+		IOOption[T7],
-    IOOption[T8],
+		IOOption[T8],
-    IOOption[T9],
+		IOOption[T9],
-    IOOption[T10],
+		IOOption[T10],
-  ](t)
+	](t)
 }
 
 // TraverseTuple10 converts a [T.Tuple10[IOOption[T]]] into a [IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
 func TraverseTuple10[F1 ~func(A1) IOOption[T1], F2 ~func(A2) IOOption[T2], F3 ~func(A3) IOOption[T3], F4 ~func(A4) IOOption[T4], F5 ~func(A5) IOOption[T5], F6 ~func(A6) IOOption[T6], F7 ~func(A7) IOOption[T7], F8 ~func(A8) IOOption[T8], F9 ~func(A9) IOOption[T9], F10 ~func(A10) IOOption[T10], A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) func(T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-  return G.TraverseTuple10[IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)
+	return G.TraverseTuple10[IOOption[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)
 }

lazy/lazy.go

@@ -72,11 +72,11 @@ func Chain[A, B any](f func(A) Lazy[B]) func(Lazy[A]) Lazy[B] {
 }
 
 func MonadAp[B, A any](mab Lazy[func(A) B], ma Lazy[A]) Lazy[B] {
-	return G.MonadAp[Lazy[A], Lazy[B]](mab, ma)
+	return G.MonadApSeq[Lazy[A], Lazy[B]](mab, ma)
 }
 
 func Ap[B, A any](ma Lazy[A]) func(Lazy[func(A) B]) Lazy[B] {
-	return G.Ap[Lazy[B], Lazy[func(A) B], Lazy[A]](ma)
+	return G.ApSeq[Lazy[B], Lazy[func(A) B], Lazy[A]](ma)
 }
 
 func Flatten[A any](mma Lazy[Lazy[A]]) Lazy[A] {

reader/gen.go

@@ -4,73 +4,72 @@
 
 package reader
 
-
 import (
-	G "github.com/IBM/fp-go/reader/generic"	
+	G "github.com/IBM/fp-go/reader/generic"
 )
 
 // From0 converts a function with 1 parameters returning a [R] into a function with 0 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From0[F ~func(C) R, C, R any](f F) func() Reader[C, R] {
-  return G.From0[Reader[C, R]](f)
+	return G.From0[Reader[C, R]](f)
 }
 
 // From1 converts a function with 2 parameters returning a [R] into a function with 1 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From1[F ~func(C, T0) R, T0, C, R any](f F) func(T0) Reader[C, R] {
-  return G.From1[Reader[C, R]](f)
+	return G.From1[Reader[C, R]](f)
 }
 
 // From2 converts a function with 3 parameters returning a [R] into a function with 2 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From2[F ~func(C, T0, T1) R, T0, T1, C, R any](f F) func(T0, T1) Reader[C, R] {
-  return G.From2[Reader[C, R]](f)
+	return G.From2[Reader[C, R]](f)
 }
 
 // From3 converts a function with 4 parameters returning a [R] into a function with 3 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From3[F ~func(C, T0, T1, T2) R, T0, T1, T2, C, R any](f F) func(T0, T1, T2) Reader[C, R] {
-  return G.From3[Reader[C, R]](f)
+	return G.From3[Reader[C, R]](f)
 }
 
 // From4 converts a function with 5 parameters returning a [R] into a function with 4 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From4[F ~func(C, T0, T1, T2, T3) R, T0, T1, T2, T3, C, R any](f F) func(T0, T1, T2, T3) Reader[C, R] {
-  return G.From4[Reader[C, R]](f)
+	return G.From4[Reader[C, R]](f)
 }
 
 // From5 converts a function with 6 parameters returning a [R] into a function with 5 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From5[F ~func(C, T0, T1, T2, T3, T4) R, T0, T1, T2, T3, T4, C, R any](f F) func(T0, T1, T2, T3, T4) Reader[C, R] {
-  return G.From5[Reader[C, R]](f)
+	return G.From5[Reader[C, R]](f)
 }
 
 // From6 converts a function with 7 parameters returning a [R] into a function with 6 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From6[F ~func(C, T0, T1, T2, T3, T4, T5) R, T0, T1, T2, T3, T4, T5, C, R any](f F) func(T0, T1, T2, T3, T4, T5) Reader[C, R] {
-  return G.From6[Reader[C, R]](f)
+	return G.From6[Reader[C, R]](f)
 }
 
 // From7 converts a function with 8 parameters returning a [R] into a function with 7 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From7[F ~func(C, T0, T1, T2, T3, T4, T5, T6) R, T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) Reader[C, R] {
-  return G.From7[Reader[C, R]](f)
+	return G.From7[Reader[C, R]](f)
 }
 
 // From8 converts a function with 9 parameters returning a [R] into a function with 8 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From8[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) R, T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) Reader[C, R] {
-  return G.From8[Reader[C, R]](f)
+	return G.From8[Reader[C, R]](f)
 }
 
 // From9 converts a function with 10 parameters returning a [R] into a function with 9 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From9[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) R, T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) Reader[C, R] {
-  return G.From9[Reader[C, R]](f)
+	return G.From9[Reader[C, R]](f)
 }
 
 // From10 converts a function with 11 parameters returning a [R] into a function with 10 parameters returning a [Reader[C, R]]
 // The first parameter is considered to be the context [C] of the reader
 func From10[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) Reader[C, R] {
-  return G.From10[Reader[C, R]](f)
+	return G.From10[Reader[C, R]](f)
 }

reader/generic/gen.go

@@ -3,113 +3,112 @@
 // 2023-08-17 22:59:18.5047315 +0200 CEST m=+0.221271401
 package generic
 
-
 // From0 converts a function with 1 parameters returning a [R] into a function with 0 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From0[GRA ~func(C) R, F ~func(C) R, C, R any](f F) func() GRA {
-  return func() GRA {
+	return func() GRA {
-    return MakeReader[GRA](func(r C) R {
+		return MakeReader[GRA](func(r C) R {
-      return f(r)
+			return f(r)
-    })
+		})
-  }
+	}
 }
 
 // From1 converts a function with 2 parameters returning a [R] into a function with 1 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From1[GRA ~func(C) R, F ~func(C, T0) R, T0, C, R any](f F) func(T0) GRA {
-  return func(t0 T0) GRA {
+	return func(t0 T0) GRA {
-    return MakeReader[GRA](func(r C) R {
+		return MakeReader[GRA](func(r C) R {
-      return f(r, t0)
+			return f(r, t0)
-    })
+		})
-  }
+	}
 }
 
 // From2 converts a function with 3 parameters returning a [R] into a function with 2 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From2[GRA ~func(C) R, F ~func(C, T0, T1) R, T0, T1, C, R any](f F) func(T0, T1) GRA {
-  return func(t0 T0, t1 T1) GRA {
+	return func(t0 T0, t1 T1) GRA {
-    return MakeReader[GRA](func(r C) R {
+		return MakeReader[GRA](func(r C) R {
-      return f(r, t0, t1)
+			return f(r, t0, t1)
-    })
+		})
-  }
+	}
 }
 
 // From3 converts a function with 4 parameters returning a [R] into a function with 3 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From3[GRA ~func(C) R, F ~func(C, T0, T1, T2) R, T0, T1, T2, C, R any](f F) func(T0, T1, T2) GRA {
-  return func(t0 T0, t1 T1, t2 T2) GRA {
+	return func(t0 T0, t1 T1, t2 T2) GRA {
-    return MakeReader[GRA](func(r C) R {
+		return MakeReader[GRA](func(r C) R {
-      return f(r, t0, t1, t2)
+			return f(r, t0, t1, t2)
-    })
+		})
-  }
+	}
 }
 
 // From4 converts a function with 5 parameters returning a [R] into a function with 4 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From4[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3) R, T0, T1, T2, T3, C, R any](f F) func(T0, T1, T2, T3) GRA {
-  return func(t0 T0, t1 T1, t2 T2, t3 T3) GRA {
+	return func(t0 T0, t1 T1, t2 T2, t3 T3) GRA {
-    return MakeReader[GRA](func(r C) R {
+		return MakeReader[GRA](func(r C) R {
-      return f(r, t0, t1, t2, t3)
+			return f(r, t0, t1, t2, t3)
-    })
+		})
-  }
+	}
 }
 
 // From5 converts a function with 6 parameters returning a [R] into a function with 5 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From5[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3, T4) R, T0, T1, T2, T3, T4, C, R any](f F) func(T0, T1, T2, T3, T4) GRA {
-  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) GRA {
+	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) GRA {
-    return MakeReader[GRA](func(r C) R {
+		return MakeReader[GRA](func(r C) R {
-      return f(r, t0, t1, t2, t3, t4)
+			return f(r, t0, t1, t2, t3, t4)
-    })
+		})
-  }
+	}
 }
 
 // From6 converts a function with 7 parameters returning a [R] into a function with 6 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From6[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3, T4, T5) R, T0, T1, T2, T3, T4, T5, C, R any](f F) func(T0, T1, T2, T3, T4, T5) GRA {
-  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) GRA {
+	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) GRA {
-    return MakeReader[GRA](func(r C) R {
+		return MakeReader[GRA](func(r C) R {
-      return f(r, t0, t1, t2, t3, t4, t5)
+			return f(r, t0, t1, t2, t3, t4, t5)
-    })
+		})
-  }
+	}
 }
 
 // From7 converts a function with 8 parameters returning a [R] into a function with 7 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From7[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3, T4, T5, T6) R, T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) GRA {
-  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) GRA {
+	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) GRA {
-    return MakeReader[GRA](func(r C) R {
+		return MakeReader[GRA](func(r C) R {
-      return f(r, t0, t1, t2, t3, t4, t5, t6)
+			return f(r, t0, t1, t2, t3, t4, t5, t6)
-    })
+		})
-  }
+	}
 }
 
 // From8 converts a function with 9 parameters returning a [R] into a function with 8 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From8[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) R, T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) GRA {
-  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) GRA {
+	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) GRA {
-    return MakeReader[GRA](func(r C) R {
+		return MakeReader[GRA](func(r C) R {
-      return f(r, t0, t1, t2, t3, t4, t5, t6, t7)
+			return f(r, t0, t1, t2, t3, t4, t5, t6, t7)
-    })
+		})
-  }
+	}
 }
 
 // From9 converts a function with 10 parameters returning a [R] into a function with 9 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From9[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) R, T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) GRA {
-  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) GRA {
+	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) GRA {
-    return MakeReader[GRA](func(r C) R {
+		return MakeReader[GRA](func(r C) R {
-      return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8)
+			return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8)
-    })
+		})
-  }
+	}
 }
 
 // From10 converts a function with 11 parameters returning a [R] into a function with 10 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From10[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) GRA {
-  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) GRA {
+	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) GRA {
-    return MakeReader[GRA](func(r C) R {
+		return MakeReader[GRA](func(r C) R {
-      return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+			return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
-    })
+		})
-  }
+	}
 }

readerioeither/gen.go

@@ -4,139 +4,138 @@
 
 package readerioeither
 
-
 import (
-	G "github.com/IBM/fp-go/readerioeither/generic"	
+	G "github.com/IBM/fp-go/readerioeither/generic"
 )
 
 // From0 converts a function with 1 parameters returning a tuple into a function with 0 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From0[F ~func(C) func() (R, error), C, R any](f F) func() ReaderIOEither[C, error, R] {
-  return G.From0[ReaderIOEither[C, error, R]](f)
+	return G.From0[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize0 converts a function with 1 parameters returning a tuple into a function with 0 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize0[F ~func(C) (R, error), C, R any](f F) func() ReaderIOEither[C, error, R] {
-  return G.Eitherize0[ReaderIOEither[C, error, R]](f)
+	return G.Eitherize0[ReaderIOEither[C, error, R]](f)
 }
 
 // From1 converts a function with 2 parameters returning a tuple into a function with 1 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From1[F ~func(C, T0) func() (R, error), T0, C, R any](f F) func(T0) ReaderIOEither[C, error, R] {
-  return G.From1[ReaderIOEither[C, error, R]](f)
+	return G.From1[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize1 converts a function with 2 parameters returning a tuple into a function with 1 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize1[F ~func(C, T0) (R, error), T0, C, R any](f F) func(T0) ReaderIOEither[C, error, R] {
-  return G.Eitherize1[ReaderIOEither[C, error, R]](f)
+	return G.Eitherize1[ReaderIOEither[C, error, R]](f)
 }
 
 // From2 converts a function with 3 parameters returning a tuple into a function with 2 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From2[F ~func(C, T0, T1) func() (R, error), T0, T1, C, R any](f F) func(T0, T1) ReaderIOEither[C, error, R] {
-  return G.From2[ReaderIOEither[C, error, R]](f)
+	return G.From2[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize2 converts a function with 3 parameters returning a tuple into a function with 2 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize2[F ~func(C, T0, T1) (R, error), T0, T1, C, R any](f F) func(T0, T1) ReaderIOEither[C, error, R] {
-  return G.Eitherize2[ReaderIOEither[C, error, R]](f)
+	return G.Eitherize2[ReaderIOEither[C, error, R]](f)
 }
 
 // From3 converts a function with 4 parameters returning a tuple into a function with 3 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From3[F ~func(C, T0, T1, T2) func() (R, error), T0, T1, T2, C, R any](f F) func(T0, T1, T2) ReaderIOEither[C, error, R] {
-  return G.From3[ReaderIOEither[C, error, R]](f)
+	return G.From3[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize3 converts a function with 4 parameters returning a tuple into a function with 3 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize3[F ~func(C, T0, T1, T2) (R, error), T0, T1, T2, C, R any](f F) func(T0, T1, T2) ReaderIOEither[C, error, R] {
-  return G.Eitherize3[ReaderIOEither[C, error, R]](f)
+	return G.Eitherize3[ReaderIOEither[C, error, R]](f)
 }
 
 // From4 converts a function with 5 parameters returning a tuple into a function with 4 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From4[F ~func(C, T0, T1, T2, T3) func() (R, error), T0, T1, T2, T3, C, R any](f F) func(T0, T1, T2, T3) ReaderIOEither[C, error, R] {
-  return G.From4[ReaderIOEither[C, error, R]](f)
+	return G.From4[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize4 converts a function with 5 parameters returning a tuple into a function with 4 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize4[F ~func(C, T0, T1, T2, T3) (R, error), T0, T1, T2, T3, C, R any](f F) func(T0, T1, T2, T3) ReaderIOEither[C, error, R] {
-  return G.Eitherize4[ReaderIOEither[C, error, R]](f)
+	return G.Eitherize4[ReaderIOEither[C, error, R]](f)
 }
 
 // From5 converts a function with 6 parameters returning a tuple into a function with 5 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From5[F ~func(C, T0, T1, T2, T3, T4) func() (R, error), T0, T1, T2, T3, T4, C, R any](f F) func(T0, T1, T2, T3, T4) ReaderIOEither[C, error, R] {
-  return G.From5[ReaderIOEither[C, error, R]](f)
+	return G.From5[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize5 converts a function with 6 parameters returning a tuple into a function with 5 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize5[F ~func(C, T0, T1, T2, T3, T4) (R, error), T0, T1, T2, T3, T4, C, R any](f F) func(T0, T1, T2, T3, T4) ReaderIOEither[C, error, R] {
-  return G.Eitherize5[ReaderIOEither[C, error, R]](f)
+	return G.Eitherize5[ReaderIOEither[C, error, R]](f)
 }
 
 // From6 converts a function with 7 parameters returning a tuple into a function with 6 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From6[F ~func(C, T0, T1, T2, T3, T4, T5) func() (R, error), T0, T1, T2, T3, T4, T5, C, R any](f F) func(T0, T1, T2, T3, T4, T5) ReaderIOEither[C, error, R] {
-  return G.From6[ReaderIOEither[C, error, R]](f)
+	return G.From6[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize6 converts a function with 7 parameters returning a tuple into a function with 6 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize6[F ~func(C, T0, T1, T2, T3, T4, T5) (R, error), T0, T1, T2, T3, T4, T5, C, R any](f F) func(T0, T1, T2, T3, T4, T5) ReaderIOEither[C, error, R] {
-  return G.Eitherize6[ReaderIOEither[C, error, R]](f)
+	return G.Eitherize6[ReaderIOEither[C, error, R]](f)
 }
 
 // From7 converts a function with 8 parameters returning a tuple into a function with 7 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From7[F ~func(C, T0, T1, T2, T3, T4, T5, T6) func() (R, error), T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) ReaderIOEither[C, error, R] {
-  return G.From7[ReaderIOEither[C, error, R]](f)
+	return G.From7[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize7 converts a function with 8 parameters returning a tuple into a function with 7 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize7[F ~func(C, T0, T1, T2, T3, T4, T5, T6) (R, error), T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) ReaderIOEither[C, error, R] {
-  return G.Eitherize7[ReaderIOEither[C, error, R]](f)
+	return G.Eitherize7[ReaderIOEither[C, error, R]](f)
 }
 
 // From8 converts a function with 9 parameters returning a tuple into a function with 8 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From8[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) func() (R, error), T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) ReaderIOEither[C, error, R] {
-  return G.From8[ReaderIOEither[C, error, R]](f)
+	return G.From8[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize8 converts a function with 9 parameters returning a tuple into a function with 8 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize8[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) ReaderIOEither[C, error, R] {
-  return G.Eitherize8[ReaderIOEither[C, error, R]](f)
+	return G.Eitherize8[ReaderIOEither[C, error, R]](f)
 }
 
 // From9 converts a function with 10 parameters returning a tuple into a function with 9 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From9[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) func() (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) ReaderIOEither[C, error, R] {
-  return G.From9[ReaderIOEither[C, error, R]](f)
+	return G.From9[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize9 converts a function with 10 parameters returning a tuple into a function with 9 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize9[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) ReaderIOEither[C, error, R] {
-  return G.Eitherize9[ReaderIOEither[C, error, R]](f)
+	return G.Eitherize9[ReaderIOEither[C, error, R]](f)
 }
 
 // From10 converts a function with 11 parameters returning a tuple into a function with 10 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From10[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) func() (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ReaderIOEither[C, error, R] {
-  return G.From10[ReaderIOEither[C, error, R]](f)
+	return G.From10[ReaderIOEither[C, error, R]](f)
 }
 
 // Eitherize10 converts a function with 11 parameters returning a tuple into a function with 10 parameters returning a [ReaderIOEither[C, error, R]]
 // The first parameter is considered to be the context [C].
 func Eitherize10[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ReaderIOEither[C, error, R] {
-  return G.Eitherize10[ReaderIOEither[C, error, R]](f)
+	return G.Eitherize10[ReaderIOEither[C, error, R]](f)
 }

readerioeither/generic/gen.go

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

tuple/tuple.go

@@ -44,8 +44,3 @@ func BiMap[E, G, A, B any](mapSnd func(E) G, mapFst func(A) B) func(Tuple2[A, E]
 		return MakeTuple2(mapFst(First(t)), mapSnd(Second(t)))
 	}
 }
-
-// Ap implements the applicative for a tuple carrying the function in its first parameter and the value in its second
-func Ap[A, B any](t Tuple2[func(A) B, A]) B {
-	return t.F1(t.F2)
-}

types/pathreporter.go

@@ -0,0 +1,39 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+	AR "github.com/IBM/fp-go/array/generic"
+	E "github.com/IBM/fp-go/either"
+)
+
+func getMessage(val *ValidationError) string {
+	return val.Message
+}
+
+func pathNoErrors() []string {
+	return AR.Of[[]string]("No Errors!")
+}
+
+func PathReporter[A any](val E.Either[Errors, A]) []string {
+	return E.MonadFold(
+		val,
+		AR.Map[Errors, []string](getMessage),
+		func(_ A) []string {
+			return pathNoErrors()
+		},
+	)
+}

types/types.go

@@ -0,0 +1,138 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+	"fmt"
+
+	AR "github.com/IBM/fp-go/array/generic"
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/option"
+)
+
+type (
+	ValidationError struct {
+		Context Context
+		Message string
+	}
+
+	ContextEntry struct {
+		Key string
+	}
+
+	Errors []*ValidationError
+
+	Context []*ContextEntry
+
+	Encoder[A, O any] interface {
+		Encode(A) O
+	}
+
+	Decoder[I, A any] interface {
+		Validate(I, Context) E.Either[Errors, A]
+		Decode(I) E.Either[Errors, A]
+	}
+
+	Type[A, O, I any] struct {
+		validate func(I, Context) E.Either[Errors, A]
+		encode   func(A) O
+		is       func(any) option.Option[A]
+	}
+)
+
+func (t *Type[A, O, I]) Validate(i I, c Context) E.Either[Errors, A] {
+	return t.validate(i, c)
+}
+
+func (t *Type[A, O, I]) Decode(i I) E.Either[Errors, A] {
+	return t.validate(i, AR.Of[Context](&ContextEntry{}))
+}
+
+func (t *Type[A, O, I]) Encode(a A) O {
+	return t.encode(a)
+}
+
+func (t *Type[A, O, I]) Is(a any) option.Option[A] {
+	return t.is(a)
+}
+
+func (t *Type[A, O, I]) AsEncoder() Encoder[A, O] {
+	return t
+}
+
+func (t *Type[A, O, I]) AsDecoder() Decoder[I, A] {
+	return t
+}
+
+func (val *ValidationError) Error() string {
+	return val.Message
+}
+
+func Pipe[O, I, A, B any](ab Type[B, A, A]) func(a Type[A, O, I]) Type[B, O, I] {
+	return func(a Type[A, O, I]) Type[B, O, I] {
+		return Type[B, O, I]{
+			is: ab.Is,
+			validate: func(i I, c Context) E.Either[Errors, B] {
+				return F.Pipe1(
+					a.Validate(i, c),
+					E.Chain(F.Bind2nd(ab.Validate, c)),
+				)
+			},
+			encode: F.Flow2(
+				ab.Encode,
+				a.Encode,
+			),
+		}
+	}
+}
+
+func Success[A any](value A) E.Either[Errors, A] {
+	return E.Of[Errors](value)
+}
+
+func Failures[A any](err Errors) E.Either[Errors, A] {
+	return E.Left[A](err)
+}
+
+func Failure[A any](c Context, message string) E.Either[Errors, A] {
+	return Failures[A](AR.Of[Errors](&ValidationError{Context: c, Message: message}))
+}
+
+func makeCanonicalType[A any]() Type[A, A, any] {
+	is := option.ToType[A]
+
+	return Type[A, A, any]{
+		is: is,
+		validate: func(u any, c Context) E.Either[Errors, A] {
+			return F.Pipe2(
+				u,
+				is,
+				option.Fold(
+					func() E.Either[Errors, A] {
+						return Failure[A](c, fmt.Sprintf("source is of type %T", u))
+					},
+					Success[A],
+				),
+			)
+		},
+		encode: F.Identity[A],
+	}
+}
+
+var String = makeCanonicalType[string]()
+var Int = makeCanonicalType[int]()
+var Bool = makeCanonicalType[bool]()