Merge pull request #44 from IBM/cleue-add-apply-monoid

fix: add missing alt methods and semigroup

context/readerioeither/gen.go

@@ -4,7 +4,6 @@ package readerioeither
 // This file was generated by robots at
 // 2023-09-12 13:44:14.1022311 +0200 CEST m=+0.017763401
 
-
 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)
 }

context/readerioeither/generic/monoid.go

@@ -0,0 +1,56 @@
+//   Copyright (c) 2023 IBM Corp.
+//   All rights reserved.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package generic
+
+import (
+	"context"
+
+	ET "github.com/IBM/fp-go/either"
+	M "github.com/IBM/fp-go/monoid"
+)
+
+func ApplicativeMonoid[GRA ~func(context.Context) GIOA, GRFA ~func(context.Context) GIOFA, GIOA ~func() ET.Either[error, A], GIOFA ~func() ET.Either[error, func(A) A], A any](
+	m M.Monoid[A],
+) M.Monoid[GRA] {
+	return M.ApplicativeMonoid(
+		Of[GRA],
+		MonadMap[GRA, GRFA],
+		MonadAp[GRA, GRA, GRFA],
+		m,
+	)
+}
+
+func ApplicativeMonoidSeq[GRA ~func(context.Context) GIOA, GRFA ~func(context.Context) GIOFA, GIOA ~func() ET.Either[error, A], GIOFA ~func() ET.Either[error, func(A) A], A any](
+	m M.Monoid[A],
+) M.Monoid[GRA] {
+	return M.ApplicativeMonoid(
+		Of[GRA],
+		MonadMap[GRA, GRFA],
+		MonadApSeq[GRA, GRA, GRFA],
+		m,
+	)
+}
+
+func ApplicativeMonoidPar[GRA ~func(context.Context) GIOA, GRFA ~func(context.Context) GIOFA, GIOA ~func() ET.Either[error, A], GIOFA ~func() ET.Either[error, func(A) A], A any](
+	m M.Monoid[A],
+) M.Monoid[GRA] {
+	return M.ApplicativeMonoid(
+		Of[GRA],
+		MonadMap[GRA, GRFA],
+		MonadApPar[GRA, GRA, GRFA],
+		m,
+	)
+}

context/readerioeither/generic/reader.go

@@ -543,3 +543,11 @@ func TryCatch[
 	A any](f func(context.Context) func() (A, error)) GRA {
 	return RIE.TryCatch[GRA](f, ER.IdentityError)
 }
+
+func MonadAlt[LAZY ~func() GEA, GEA ~func(context.Context) GIOA, GIOA ~func() E.Either[error, A], A any](first GEA, second LAZY) GEA {
+	return RIE.MonadAlt(first, second)
+}
+
+func Alt[LAZY ~func() GEA, GEA ~func(context.Context) GIOA, GIOA ~func() E.Either[error, A], A any](second LAZY) func(GEA) GEA {
+	return RIE.Alt(second)
+}

context/readerioeither/generic/semigroup.go

@@ -0,0 +1,29 @@
+//   Copyright (c) 2023 IBM Corp.
+//   All rights reserved.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package generic
+
+import (
+	"context"
+
+	ET "github.com/IBM/fp-go/either"
+	S "github.com/IBM/fp-go/semigroup"
+)
+
+func AltSemigroup[GRA ~func(context.Context) GIOA, GIOA ~func() ET.Either[error, A], A any]() S.Semigroup[GRA] {
+	return S.AltSemigroup(
+		MonadAlt[func() GRA],
+	)
+}

context/readerioeither/monoid.go

@@ -0,0 +1,36 @@
+//   Copyright (c) 2023 IBM Corp.
+//   All rights reserved.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package readerioeither
+
+import (
+	G "github.com/IBM/fp-go/context/readerioeither/generic"
+	M "github.com/IBM/fp-go/monoid"
+)
+
+// ApplicativeMonoid returns a [Monoid] that concatenates [ReaderIOEither] instances via their applicative
+func ApplicativeMonoid[A any](m M.Monoid[A]) M.Monoid[ReaderIOEither[A]] {
+	return G.ApplicativeMonoid[ReaderIOEither[A], ReaderIOEither[func(A) A]](m)
+}
+
+// ApplicativeMonoidSeq returns a [Monoid] that concatenates [ReaderIOEither] instances via their applicative
+func ApplicativeMonoidSeq[A any](m M.Monoid[A]) M.Monoid[ReaderIOEither[A]] {
+	return G.ApplicativeMonoidSeq[ReaderIOEither[A], ReaderIOEither[func(A) A]](m)
+}
+
+// ApplicativeMonoidPar returns a [Monoid] that concatenates [ReaderIOEither] instances via their applicative
+func ApplicativeMonoidPar[A any](m M.Monoid[A]) M.Monoid[ReaderIOEither[A]] {
+	return G.ApplicativeMonoidPar[ReaderIOEither[A], ReaderIOEither[func(A) A]](m)
+}

context/readerioeither/reader.go

@@ -25,6 +25,7 @@ import (
 	ET "github.com/IBM/fp-go/either"
 	IO "github.com/IBM/fp-go/io"
 	IOE "github.com/IBM/fp-go/ioeither"
+	L "github.com/IBM/fp-go/lazy"
 	O "github.com/IBM/fp-go/option"
 )
 
@@ -182,7 +183,7 @@ func Timer(delay time.Duration) ReaderIOEither[time.Time] {
 }
 
 // Defer creates an IO by creating a brand new IO via a generator function, each time
-func Defer[A any](gen func() ReaderIOEither[A]) ReaderIOEither[A] {
+func Defer[A any](gen L.Lazy[ReaderIOEither[A]]) ReaderIOEither[A] {
 	return G.Defer[ReaderIOEither[A]](gen)
 }
 
@@ -190,3 +191,13 @@ func Defer[A any](gen func() ReaderIOEither[A]) ReaderIOEither[A] {
 func TryCatch[A any](f func(context.Context) func() (A, error)) ReaderIOEither[A] {
 	return G.TryCatch[ReaderIOEither[A]](f)
 }
+
+// MonadAlt identifies an associative operation on a type constructor
+func MonadAlt[A any](first ReaderIOEither[A], second L.Lazy[ReaderIOEither[A]]) ReaderIOEither[A] {
+	return G.MonadAlt(first, second)
+}
+
+// Alt identifies an associative operation on a type constructor
+func Alt[A any](second L.Lazy[ReaderIOEither[A]]) func(ReaderIOEither[A]) ReaderIOEither[A] {
+	return G.Alt(second)
+}

context/readerioeither/semigroup.go

@@ -0,0 +1,26 @@
+//   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 readerioeither
+
+import (
+	G "github.com/IBM/fp-go/context/readerioeither/generic"
+	S "github.com/IBM/fp-go/semigroup"
+)
+
+// AltSemigroup is a [Semigroup] that tries the first item and then the second one using an alternative
+func AltSemigroup[A any]() S.Semigroup[ReaderIOEither[A]] {
+	return G.AltSemigroup[ReaderIOEither[A]]()
+}

coverage.bat

@@ -0,0 +1,2 @@
+@echo off
+go tool cover -html=build/cover.out -o build/cover.html

either/apply.go

@@ -24,6 +24,7 @@ func ApplySemigroup[E, A any](s S.Semigroup[A]) S.Semigroup[Either[E, A]] {
 	return S.ApplySemigroup(MonadMap[E, A, func(A) A], MonadAp[A, E, A], s)
 }
 
+// ApplicativeMonoid returns a [Monoid] that concatenates [Either] instances via their applicative
 func ApplicativeMonoid[E, A any](m M.Monoid[A]) M.Monoid[Either[E, A]] {
 	return M.ApplicativeMonoid(Of[E, A], MonadMap[E, A, func(A) A], MonadAp[A, E, A], m)
 }

function/binds.go

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

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

internal/eithert/either.go

@@ -22,6 +22,16 @@ import (
 	FC "github.com/IBM/fp-go/internal/functor"
 )
 
+func MonadAlt[LAZY ~func() HKTFA, E, A, HKTFA any](
+	fof func(ET.Either[E, A]) HKTFA,
+	fchain func(HKTFA, func(ET.Either[E, A]) HKTFA) HKTFA,
+
+	first HKTFA,
+	second LAZY) HKTFA {
+
+	return fchain(first, ET.Fold(F.Ignore1of1[E](second), F.Flow2(ET.Of[E, A], fof)))
+}
+
 // HKTFA = HKT<F, Either<E, A>>
 // HKTFB = HKT<F, Either<E, B>>
 func MonadMap[E, A, B, HKTFA, HKTFB any](fmap func(HKTFA, func(ET.Either[E, A]) ET.Either[E, B]) HKTFB, fa HKTFA, f func(A) B) HKTFB {

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

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

ioeither/generic/ioeither.go

@@ -290,3 +290,17 @@ func FromImpure[GA ~func() ET.Either[E, any], IMP ~func(), E any](f IMP) GA {
 func Defer[GEA ~func() ET.Either[E, A], E, A any](gen func() GEA) GEA {
 	return IO.Defer[GEA](gen)
 }
+
+func MonadAlt[LAZY ~func() GIOA, GIOA ~func() ET.Either[E, A], E, A any](first GIOA, second LAZY) GIOA {
+	return eithert.MonadAlt(
+		IO.Of[GIOA],
+		IO.MonadChain[GIOA, GIOA],
+
+		first,
+		second,
+	)
+}
+
+func Alt[LAZY ~func() GIOA, GIOA ~func() ET.Either[E, A], E, A any](second LAZY) func(GIOA) GIOA {
+	return F.Bind2nd(MonadAlt[LAZY], second)
+}

ioeither/generic/monoid.go

@@ -0,0 +1,54 @@
+//   Copyright (c) 2023 IBM Corp.
+//   All rights reserved.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package generic
+
+import (
+	ET "github.com/IBM/fp-go/either"
+	M "github.com/IBM/fp-go/monoid"
+)
+
+func ApplicativeMonoid[GEA ~func() ET.Either[E, A], GEFA ~func() ET.Either[E, func(A) A], E, A any](
+	m M.Monoid[A],
+) M.Monoid[GEA] {
+	return M.ApplicativeMonoid(
+		MonadOf[GEA],
+		MonadMap[GEA, GEFA],
+		MonadAp[GEA, GEFA, GEA],
+		m,
+	)
+}
+
+func ApplicativeMonoidSeq[GEA ~func() ET.Either[E, A], GEFA ~func() ET.Either[E, func(A) A], E, A any](
+	m M.Monoid[A],
+) M.Monoid[GEA] {
+	return M.ApplicativeMonoid(
+		MonadOf[GEA],
+		MonadMap[GEA, GEFA],
+		MonadApSeq[GEA, GEFA, GEA],
+		m,
+	)
+}
+
+func ApplicativeMonoidPar[GEA ~func() ET.Either[E, A], GEFA ~func() ET.Either[E, func(A) A], E, A any](
+	m M.Monoid[A],
+) M.Monoid[GEA] {
+	return M.ApplicativeMonoid(
+		MonadOf[GEA],
+		MonadMap[GEA, GEFA],
+		MonadApPar[GEA, GEFA, GEA],
+		m,
+	)
+}

ioeither/generic/semigroup.go

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

ioeither/ioeither.go

@@ -19,6 +19,7 @@ import (
 	ET "github.com/IBM/fp-go/either"
 	I "github.com/IBM/fp-go/io"
 	G "github.com/IBM/fp-go/ioeither/generic"
+	L "github.com/IBM/fp-go/lazy"
 	O "github.com/IBM/fp-go/option"
 )
 
@@ -207,6 +208,16 @@ func FromImpure[E any](f func()) IOEither[E, any] {
 }
 
 // Defer creates an IO by creating a brand new IO via a generator function, each time
-func Defer[E, A any](gen func() IOEither[E, A]) IOEither[E, A] {
+func Defer[E, A any](gen L.Lazy[IOEither[E, A]]) IOEither[E, A] {
 	return G.Defer[IOEither[E, A]](gen)
 }
+
+// MonadAlt identifies an associative operation on a type constructor
+func MonadAlt[E, A any](first IOEither[E, A], second L.Lazy[IOEither[E, A]]) IOEither[E, A] {
+	return G.MonadAlt(first, second)
+}
+
+// Alt identifies an associative operation on a type constructor
+func Alt[E, A any](second L.Lazy[IOEither[E, A]]) func(IOEither[E, A]) IOEither[E, A] {
+	return G.Alt(second)
+}

ioeither/monoid.go

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

ioeither/monoid_test.go

@@ -0,0 +1,42 @@
+//   Copyright (c) 2023 IBM Corp.
+//   All rights reserved.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package ioeither
+
+import (
+	"fmt"
+	"testing"
+
+	E "github.com/IBM/fp-go/either"
+	S "github.com/IBM/fp-go/string"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestApplicativeMonoid(t *testing.T) {
+	m := ApplicativeMonoid[error](S.Monoid)
+
+	// good cases
+	assert.Equal(t, E.Of[error]("ab"), m.Concat(Of[error]("a"), Of[error]("b"))())
+	assert.Equal(t, E.Of[error]("a"), m.Concat(Of[error]("a"), m.Empty())())
+	assert.Equal(t, E.Of[error]("b"), m.Concat(m.Empty(), Of[error]("b"))())
+
+	// bad cases
+	e1 := fmt.Errorf("e1")
+	e2 := fmt.Errorf("e1")
+
+	assert.Equal(t, E.Left[string](e1), m.Concat(Left[string](e1), Of[error]("b"))())
+	assert.Equal(t, E.Left[string](e1), m.Concat(Left[string](e1), Left[string](e2))())
+	assert.Equal(t, E.Left[string](e2), m.Concat(Of[error]("a"), Left[string](e2))())
+}

ioeither/semigroup.go

@@ -0,0 +1,26 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ioeither
+
+import (
+	G "github.com/IBM/fp-go/ioeither/generic"
+	S "github.com/IBM/fp-go/semigroup"
+)
+
+// AltSemigroup is a [Semigroup] that tries the first item and then the second one using an alternative
+func AltSemigroup[E, A any]() S.Semigroup[IOEither[E, A]] {
+	return G.AltSemigroup[IOEither[E, A]]()
+}

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

monoid/alt.go

@@ -0,0 +1,58 @@
+// 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 monoid
+
+import (
+	S "github.com/IBM/fp-go/semigroup"
+)
+
+func AlternativeMonoid[A, HKTA, HKTFA any](
+	fof func(A) HKTA,
+
+	fmap func(HKTA, func(A) func(A) A) HKTFA,
+	fap func(HKTFA, HKTA) HKTA,
+
+	falt func(HKTA, func() HKTA) HKTA,
+
+	m Monoid[A],
+
+) Monoid[HKTA] {
+
+	sg := ApplicativeMonoid(fof, fmap, fap, m)
+
+	return MakeMonoid(
+		func(first, second HKTA) HKTA {
+			snd := func() HKTA { return second }
+
+			return falt(sg.Concat(first, second), func() HKTA {
+				return falt(first, snd)
+			})
+		},
+		sg.Empty(),
+	)
+}
+
+func AltMonoid[HKTA any](
+	fzero func() HKTA,
+	falt func(HKTA, func() HKTA) HKTA,
+
+) Monoid[HKTA] {
+
+	return MakeMonoid(
+		S.AltSemigroup(falt).Concat,
+		fzero(),
+	)
+}

monoid/apply.go

@@ -20,15 +20,15 @@ import (
 )
 
 func ApplicativeMonoid[A, HKTA, HKTFA any](
-	_of func(A) HKTA,
-	_map func(HKTA, func(A) func(A) A) HKTFA,
-	_ap func(HKTFA, HKTA) HKTA,
+	fof func(A) HKTA,
+	fmap func(HKTA, func(A) func(A) A) HKTFA,
+	fap func(HKTFA, HKTA) HKTA,
 
 	m Monoid[A],
 ) Monoid[HKTA] {
 
 	return MakeMonoid(
-		S.ApplySemigroup[A](_map, _ap, m).Concat,
-		_of(m.Empty()),
+		S.ApplySemigroup[A](fmap, fap, m).Concat,
+		fof(m.Empty()),
 	)
 }

option/apply.go

@@ -24,6 +24,7 @@ func ApplySemigroup[A any](s S.Semigroup[A]) S.Semigroup[Option[A]] {
 	return S.ApplySemigroup(MonadMap[A, func(A) A], MonadAp[A, A], s)
 }
 
+// ApplicativeMonoid returns a [Monoid] that concatenates [Option] instances via their applicative
 func ApplicativeMonoid[A any](m M.Monoid[A]) M.Monoid[Option[A]] {
 	return M.ApplicativeMonoid(Of[A], MonadMap[A, func(A) A], MonadAp[A, A], m)
 }

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

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

readerioeither/generic/reader.go

@@ -35,6 +35,20 @@ func MakeReader[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](f
 	return f
 }
 
+func MonadAlt[LAZY ~func() GEA, GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](first GEA, second LAZY) GEA {
+	return eithert.MonadAlt(
+		G.Of[GEA],
+		G.MonadChain[GEA, GEA],
+
+		first,
+		second,
+	)
+}
+
+func Alt[LAZY ~func() GEA, GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](second LAZY) func(GEA) GEA {
+	return F.Bind2nd(MonadAlt[LAZY], second)
+}
+
 func MonadMap[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], R, E, A, B any](fa GEA, f func(A) B) GEB {
 	return eithert.MonadMap(G.MonadMap[GEA, GEB, GIOA, GIOB, R, ET.Either[E, A], ET.Either[E, B]], fa, f)
 }

readerioeither/reader.go

@@ -19,6 +19,7 @@ import (
 	ET "github.com/IBM/fp-go/either"
 	"github.com/IBM/fp-go/io"
 	IOE "github.com/IBM/fp-go/ioeither"
+	L "github.com/IBM/fp-go/lazy"
 	O "github.com/IBM/fp-go/option"
 	RD "github.com/IBM/fp-go/reader"
 	RE "github.com/IBM/fp-go/readereither"
@@ -245,7 +246,7 @@ func Swap[R, E, A any](val ReaderIOEither[R, E, A]) ReaderIOEither[R, A, E] {
 }
 
 // Defer creates an IO by creating a brand new IO via a generator function, each time
-func Defer[R, E, A any](gen func() ReaderIOEither[R, E, A]) ReaderIOEither[R, E, A] {
+func Defer[R, E, A any](gen L.Lazy[ReaderIOEither[R, E, A]]) ReaderIOEither[R, E, A] {
 	return G.Defer[ReaderIOEither[R, E, A]](gen)
 }
 
@@ -253,3 +254,13 @@ func Defer[R, E, A any](gen func() ReaderIOEither[R, E, A]) ReaderIOEither[R, E,
 func TryCatch[R, E, A any](f func(R) func() (A, error), onThrow func(error) E) ReaderIOEither[R, E, A] {
 	return G.TryCatch[ReaderIOEither[R, E, A]](f, onThrow)
 }
+
+// MonadAlt identifies an associative operation on a type constructor.
+func MonadAlt[R, E, A any](first ReaderIOEither[R, E, A], second L.Lazy[ReaderIOEither[R, E, A]]) ReaderIOEither[R, E, A] {
+	return G.MonadAlt(first, second)
+}
+
+// Alt identifies an associative operation on a type constructor.
+func Alt[R, E, A any](second L.Lazy[ReaderIOEither[R, E, A]]) func(ReaderIOEither[R, E, A]) ReaderIOEither[R, E, A] {
+	return G.Alt(second)
+}

semigroup/alt.go

@@ -0,0 +1,28 @@
+// 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 semigroup
+
+func AltSemigroup[HKTA any](
+	falt func(HKTA, func() HKTA) HKTA,
+
+) Semigroup[HKTA] {
+
+	return MakeSemigroup(
+		func(first, second HKTA) HKTA {
+			return falt(first, func() HKTA { return second })
+		},
+	)
+}

semigroup/apply.go

@@ -25,14 +25,14 @@ HKTA = HKT<A>
 HKTFA = HKT<func(A)A>
 */
 func ApplySemigroup[A, HKTA, HKTFA any](
-	_map func(HKTA, func(A) func(A) A) HKTFA,
-	_ap func(HKTFA, HKTA) HKTA,
+	fmap func(HKTA, func(A) func(A) A) HKTFA,
+	fap func(HKTFA, HKTA) HKTA,
 
 	s Semigroup[A],
 ) Semigroup[HKTA] {
 
 	cb := F.Curry2(s.Concat)
 	return MakeSemigroup(func(first HKTA, second HKTA) HKTA {
-		return _ap(_map(first, cb), second)
+		return fap(fmap(first, cb), second)
 	})
 }

test.bat

@@ -0,0 +1,3 @@
+@echo off
+mkdir build 2> NUL
+gotip test .\... && go1.20.1 test .\... && go test -v -coverprofile build/cover.out -coverpkg=./... -covermode=atomic .\...