Merge pull request #51 from IBM/cleue-rioe-tests

fix: add RIOE testcases

cli/tuple.go

@@ -338,7 +338,7 @@ func generateUntupled(f *os.File, i int) {
 
 func generateTupled(f *os.File, i int) {
 	// Create the optionize version
-	fmt.Fprintf(f, "\n// Tupled%d converts a function with %d parameters returning into a function taking a Tuple%d\n// The inverse function is [Untupled%d]\n", i, i, i, i)
+	fmt.Fprintf(f, "\n// Tupled%d converts a function with %d parameters into a function taking a Tuple%d\n// The inverse function is [Untupled%d]\n", i, i, i, i)
 	fmt.Fprintf(f, "func Tupled%d[F ~func(", i)
 	for j := 0; j < i; j++ {
 		if j > 0 {

context/readerioeither/file/file.go

@@ -25,25 +25,31 @@ import (
 	F "github.com/IBM/fp-go/function"
 	"github.com/IBM/fp-go/internal/file"
 	IOE "github.com/IBM/fp-go/ioeither"
+	IOEF "github.com/IBM/fp-go/ioeither/file"
 )
 
 var (
-	openIOE = IOE.Eitherize1(os.Open)
 	// Open opens a file for reading within the given context
 	Open = F.Flow3(
-		openIOE,
+		IOEF.Open,
 		RIOE.FromIOEither[*os.File],
 		RIOE.WithContext[*os.File],
 	)
+
+	// Remove removes a file by name
+	Remove = F.Flow2(
+		IOEF.Remove,
+		RIOE.FromIOEither[string],
+	)
 )
 
 // Close closes an object
 func Close[C io.Closer](c C) RIOE.ReaderIOEither[any] {
-	return RIOE.FromIOEither(func() ET.Either[error, any] {
-		return ET.TryCatchError(func() (any, error) {
-			return c, c.Close()
-		})
-	})
+	return F.Pipe2(
+		c,
+		IOEF.Close[C],
+		RIOE.FromIOEither[any],
+	)
 }
 
 // ReadFile reads a file in the scope of a context

context/readerioeither/file/tempfile.go

@@ -0,0 +1,53 @@
+// 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 file
+
+import (
+	"os"
+
+	RIOE "github.com/IBM/fp-go/context/readerioeither"
+	FL "github.com/IBM/fp-go/file"
+	F "github.com/IBM/fp-go/function"
+	IO "github.com/IBM/fp-go/io"
+	IOF "github.com/IBM/fp-go/io/file"
+	IOEF "github.com/IBM/fp-go/ioeither/file"
+)
+
+var (
+	// onCreateTempFile creates a temp file with sensible defaults
+	onCreateTempFile = CreateTemp("", "*")
+	// destroy handler
+	onReleaseTempFile = F.Flow4(
+		IOF.Close[*os.File],
+		IO.Map(FL.GetName),
+		RIOE.FromIO[string],
+		RIOE.Chain(Remove),
+	)
+)
+
+// CreateTemp created a temp file with proper parametrization
+func CreateTemp(dir, pattern string) RIOE.ReaderIOEither[*os.File] {
+	return F.Pipe2(
+		IOEF.CreateTemp(dir, pattern),
+		RIOE.FromIOEither[*os.File],
+		RIOE.WithContext[*os.File],
+	)
+}
+
+// WithTempFile creates a temporary file, then invokes a callback to create a resource based on the file, then close and remove the temp file
+func WithTempFile[A any](f func(*os.File) RIOE.ReaderIOEither[A]) RIOE.ReaderIOEither[A] {
+	return RIOE.WithResource[A](onCreateTempFile, onReleaseTempFile)(f)
+}

context/readerioeither/file/tempfile_test.go

@@ -0,0 +1,47 @@
+// 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 file
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	RIOE "github.com/IBM/fp-go/context/readerioeither"
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestWithTempFile(t *testing.T) {
+
+	res := WithTempFile(onWriteAll[*os.File]([]byte("Carsten")))
+
+	assert.Equal(t, E.Of[error]([]byte("Carsten")), res(context.Background())())
+}
+
+func TestWithTempFileOnClosedFile(t *testing.T) {
+
+	res := WithTempFile(func(f *os.File) RIOE.ReaderIOEither[[]byte] {
+		return F.Pipe2(
+			f,
+			onWriteAll[*os.File]([]byte("Carsten")),
+			RIOE.ChainFirst(F.Constant1[[]byte](Close(f))),
+		)
+	})
+
+	assert.Equal(t, E.Of[error]([]byte("Carsten")), res(context.Background())())
+}

context/readerioeither/file/write.go

@@ -0,0 +1,57 @@
+// 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 file
+
+import (
+	"context"
+	"io"
+
+	RIOE "github.com/IBM/fp-go/context/readerioeither"
+	F "github.com/IBM/fp-go/function"
+)
+
+func onWriteAll[W io.Writer](data []byte) func(w W) RIOE.ReaderIOEither[[]byte] {
+	return func(w W) RIOE.ReaderIOEither[[]byte] {
+		return F.Pipe1(
+			RIOE.TryCatch(func(ctx context.Context) func() ([]byte, error) {
+				return func() ([]byte, error) {
+					_, err := w.Write(data)
+					return data, err
+				}
+			}),
+			RIOE.WithContext[[]byte],
+		)
+	}
+}
+
+// WriteAll uses a generator function to create a stream, writes data to it and closes it
+func WriteAll[W io.WriteCloser](data []byte) func(acquire RIOE.ReaderIOEither[W]) RIOE.ReaderIOEither[[]byte] {
+	onWrite := onWriteAll[W](data)
+	return func(onCreate RIOE.ReaderIOEither[W]) RIOE.ReaderIOEither[[]byte] {
+		return RIOE.WithResource[[]byte](
+			onCreate,
+			Close[W])(
+			onWrite,
+		)
+	}
+}
+
+// Write uses a generator function to create a stream, writes data to it and closes it
+func Write[R any, W io.WriteCloser](acquire RIOE.ReaderIOEither[W]) func(use func(W) RIOE.ReaderIOEither[R]) RIOE.ReaderIOEither[R] {
+	return RIOE.WithResource[R](
+		acquire,
+		Close[W])
+}

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

@@ -100,6 +100,28 @@ func Map[
 	return RIE.Map[GRA, GRB](f)
 }
 
+func MonadMapTo[
+	GRA ~func(context.Context) GIOA,
+	GRB ~func(context.Context) GIOB,
+
+	GIOA ~func() E.Either[error, A],
+	GIOB ~func() E.Either[error, B],
+
+	A, B any](fa GRA, b B) GRB {
+	return RIE.MonadMapTo[GRA, GRB](fa, b)
+}
+
+func MapTo[
+	GRA ~func(context.Context) GIOA,
+	GRB ~func(context.Context) GIOB,
+
+	GIOA ~func() E.Either[error, A],
+	GIOB ~func() E.Either[error, B],
+
+	A, B any](b B) func(GRA) GRB {
+	return RIE.MapTo[GRA, GRB](b)
+}
+
 func MonadChain[
 	GRA ~func(context.Context) GIOA,
 	GRB ~func(context.Context) GIOB,
@@ -543,3 +565,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"
 )
 
@@ -60,6 +61,14 @@ func Map[A, B any](f func(A) B) func(ReaderIOEither[A]) ReaderIOEither[B] {
 	return G.Map[ReaderIOEither[A], ReaderIOEither[B]](f)
 }
 
+func MonadMapTo[A, B any](fa ReaderIOEither[A], b B) ReaderIOEither[B] {
+	return G.MonadMapTo[ReaderIOEither[A], ReaderIOEither[B]](fa, b)
+}
+
+func MapTo[A, B any](b B) func(ReaderIOEither[A]) ReaderIOEither[B] {
+	return G.MapTo[ReaderIOEither[A], ReaderIOEither[B]](b)
+}
+
 func MonadChain[A, B any](ma ReaderIOEither[A], f func(A) ReaderIOEither[B]) ReaderIOEither[B] {
 	return G.MonadChain(ma, f)
 }
@@ -146,6 +155,10 @@ func FromIO[A any](t IO.IO[A]) ReaderIOEither[A] {
 	return G.FromIO[ReaderIOEither[A]](t)
 }
 
+func FromLazy[A any](t L.Lazy[A]) ReaderIOEither[A] {
+	return G.FromIO[ReaderIOEither[A]](t)
+}
+
 // Never returns a 'ReaderIOEither' that never returns, except if its context gets canceled
 func Never[A any]() ReaderIOEither[A] {
 	return G.Never[ReaderIOEither[A]]()
@@ -182,7 +195,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 +203,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/reader_test.go

@@ -162,3 +162,125 @@ func TestRegularApply(t *testing.T) {
 	res := applied(context.Background())()
 	assert.Equal(t, E.Of[error]("CARSTEN"), res)
 }
+
+func TestWithResourceNoErrors(t *testing.T) {
+	var countAcquire, countBody, countRelease int
+
+	acquire := FromLazy(func() int {
+		countAcquire++
+		return countAcquire
+	})
+
+	release := func(int) ReaderIOEither[int] {
+		return FromLazy(func() int {
+			countRelease++
+			return countRelease
+		})
+	}
+
+	body := func(int) ReaderIOEither[int] {
+		return FromLazy(func() int {
+			countBody++
+			return countBody
+		})
+	}
+
+	resRIOE := WithResource[int](acquire, release)(body)
+
+	res := resRIOE(context.Background())()
+
+	assert.Equal(t, 1, countAcquire)
+	assert.Equal(t, 1, countBody)
+	assert.Equal(t, 1, countRelease)
+	assert.Equal(t, E.Of[error](1), res)
+}
+
+func TestWithResourceErrorInBody(t *testing.T) {
+	var countAcquire, countBody, countRelease int
+
+	acquire := FromLazy(func() int {
+		countAcquire++
+		return countAcquire
+	})
+
+	release := func(int) ReaderIOEither[int] {
+		return FromLazy(func() int {
+			countRelease++
+			return countRelease
+		})
+	}
+
+	err := fmt.Errorf("error in body")
+	body := func(int) ReaderIOEither[int] {
+		return Left[int](err)
+	}
+
+	resRIOE := WithResource[int](acquire, release)(body)
+
+	res := resRIOE(context.Background())()
+
+	assert.Equal(t, 1, countAcquire)
+	assert.Equal(t, 0, countBody)
+	assert.Equal(t, 1, countRelease)
+	assert.Equal(t, E.Left[int](err), res)
+}
+
+func TestWithResourceErrorInAcquire(t *testing.T) {
+	var countAcquire, countBody, countRelease int
+
+	err := fmt.Errorf("error in acquire")
+	acquire := Left[int](err)
+
+	release := func(int) ReaderIOEither[int] {
+		return FromLazy(func() int {
+			countRelease++
+			return countRelease
+		})
+	}
+
+	body := func(int) ReaderIOEither[int] {
+		return FromLazy(func() int {
+			countBody++
+			return countBody
+		})
+	}
+
+	resRIOE := WithResource[int](acquire, release)(body)
+
+	res := resRIOE(context.Background())()
+
+	assert.Equal(t, 0, countAcquire)
+	assert.Equal(t, 0, countBody)
+	assert.Equal(t, 0, countRelease)
+	assert.Equal(t, E.Left[int](err), res)
+}
+
+func TestWithResourceErrorInRelease(t *testing.T) {
+	var countAcquire, countBody, countRelease int
+
+	acquire := FromLazy(func() int {
+		countAcquire++
+		return countAcquire
+	})
+
+	err := fmt.Errorf("error in release")
+	release := func(int) ReaderIOEither[int] {
+		return Left[int](err)
+	}
+
+	body := func(int) ReaderIOEither[int] {
+		return FromLazy(func() int {
+			countBody++
+			return countBody
+		})
+	}
+
+	resRIOE := WithResource[int](acquire, release)(body)
+
+	res := resRIOE(context.Background())()
+
+	assert.Equal(t, 1, countAcquire)
+	assert.Equal(t, 1, countBody)
+	assert.Equal(t, 0, countRelease)
+	assert.Equal(t, E.Left[int](err), res)
+}

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

either/exec/exec.go

@@ -27,7 +27,7 @@ import (
 var (
 	// Command executes a command
 	// use this version if the command does not produce any side effect, i.e. if the output is uniquely determined by by the input
-	// typically you'd rather use the IOEither version of the command
+	// typically you'd rather use the [IOEither] version of the command
 	Command = F.Curry3(command)
 )
 

exec/exec.go

@@ -20,11 +20,14 @@ import (
 )
 
 type (
-	// command output
+	// CommandOutput represents the output of executing a command. The first field in the [Tuple2] is
+	// stdout, the second one is stderr. Use [StdOut] and [StdErr] to access these fields
 	CommandOutput = T.Tuple2[[]byte, []byte]
 )
 
 var (
+	// StdOut returns the field of a [CommandOutput] representing `stdout`
 	StdOut = T.First[[]byte, []byte]
+	// StdErr returns the field of a [CommandOutput] representing `stderr`
 	StdErr = T.Second[[]byte, []byte]
 )

function/bind.go

@@ -26,6 +26,7 @@ func Bind2nd[T1, T2, R any](f func(T1, T2) R, t2 T2) func(T1) R {
 	}
 }
 
+// SK function (SKI combinator calculus).
 func SK[T1, T2 any](_ T1, t2 T2) T2 {
 	return t2
 }

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

function/function.go

@@ -62,6 +62,7 @@ func First[T1, T2 any](t1 T1, _ T2) T1 {
 }
 
 // Second returns the second out of two input values
+// Identical to [SK]
 func Second[T1, T2 any](_ T1, t2 T2) T2 {
 	return t2
 }

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

@@ -16,6 +16,7 @@
 package file
 
 import (
+	"io"
 	"os"
 
 	IOE "github.com/IBM/fp-go/ioeither"
@@ -45,3 +46,10 @@ func Remove(name string) IOE.IOEither[error, string] {
 		return name, os.Remove(name)
 	})
 }
+
+// Close closes an object
+func Close[C io.Closer](c C) IOE.IOEither[error, any] {
+	return IOE.TryCatchError(func() (any, error) {
+		return c, c.Close()
+	})
+}

ioeither/file/readall.go

@@ -31,7 +31,7 @@ func onReadAll[R io.Reader](r R) IOE.IOEither[error, []byte] {
 func ReadAll[R io.ReadCloser](acquire IOE.IOEither[error, R]) IOE.IOEither[error, []byte] {
 	return IOE.WithResource[[]byte](
 		acquire,
-		onClose[R])(
+		Close[R])(
 		onReadAll[R],
 	)
 }

ioeither/file/tempfile_test.go

@@ -38,7 +38,7 @@ func TestWithTempFileOnClosedFile(t *testing.T) {
 		return F.Pipe2(
 			f,
 			onWriteAll[*os.File]([]byte("Carsten")),
-			IOE.ChainFirst(F.Constant1[[]byte](onClose(f))),
+			IOE.ChainFirst(F.Constant1[[]byte](Close(f))),
 		)
 	})
 

ioeither/file/write.go

@@ -36,7 +36,7 @@ func WriteAll[W io.WriteCloser](data []byte) func(acquire IOE.IOEither[error, W]
 	return func(onCreate IOE.IOEither[error, W]) IOE.IOEither[error, []byte] {
 		return IOE.WithResource[[]byte](
 			onCreate,
-			onClose[W])(
+			Close[W])(
 			onWrite,
 		)
 	}
@@ -46,5 +46,5 @@ func WriteAll[W io.WriteCloser](data []byte) func(acquire IOE.IOEither[error, W]
 func Write[R any, W io.WriteCloser](acquire IOE.IOEither[error, W]) func(use func(W) IOE.IOEither[error, R]) IOE.IOEither[error, R] {
 	return IOE.WithResource[R](
 		acquire,
-		onClose[W])
+		Close[W])
 }

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"
 )
 
@@ -74,10 +75,20 @@ func ChainIOK[E, A, B any](f func(A) I.IO[B]) func(IOEither[E, A]) IOEither[E, B
 	return G.ChainIOK[IOEither[E, A], IOEither[E, B]](f)
 }
 
+func ChainLazyK[E, A, B any](f func(A) L.Lazy[B]) func(IOEither[E, A]) IOEither[E, B] {
+	return G.ChainIOK[IOEither[E, A], IOEither[E, B]](f)
+}
+
+// FromIO creates an [IOEither] from an [IO] instance, invoking [IO] for each invocation of [IOEither]
 func FromIO[E, A any](mr I.IO[A]) IOEither[E, A] {
 	return G.FromIO[IOEither[E, A]](mr)
 }
 
+// FromLazy creates an [IOEither] from a [Lazy] instance, invoking [Lazy] for each invocation of [IOEither]
+func FromLazy[E, A any](mr L.Lazy[A]) IOEither[E, A] {
+	return G.FromIO[IOEither[E, A]](mr)
+}
+
 func MonadMap[E, A, B any](fa IOEither[E, A], f func(A) B) IOEither[E, B] {
 	return G.MonadMap[IOEither[E, A], IOEither[E, B]](fa, f)
 }
@@ -166,27 +177,27 @@ func MonadChainTo[E, A, B any](fa IOEither[E, A], fb IOEither[E, B]) IOEither[E,
 	return G.MonadChainTo(fa, fb)
 }
 
-// ChainTo composes to the second monad ignoring the return value of the first
+// ChainTo composes to the second [IOEither] monad ignoring the return value of the first
 func ChainTo[E, A, B any](fb IOEither[E, B]) func(IOEither[E, A]) IOEither[E, B] {
 	return G.ChainTo[IOEither[E, A]](fb)
 }
 
-// MonadChainFirst runs the monad returned by the function but returns the result of the original monad
+// MonadChainFirst runs the [IOEither] monad returned by the function but returns the result of the original monad
 func MonadChainFirst[E, A, B any](ma IOEither[E, A], f func(A) IOEither[E, B]) IOEither[E, A] {
 	return G.MonadChainFirst(ma, f)
 }
 
-// ChainFirst runs the monad returned by the function but returns the result of the original monad
+// ChainFirst runs the [IOEither] monad returned by the function but returns the result of the original monad
 func ChainFirst[E, A, B any](f func(A) IOEither[E, B]) func(IOEither[E, A]) IOEither[E, A] {
 	return G.ChainFirst[IOEither[E, A]](f)
 }
 
-// MonadChainFirstIOK runs the monad returned by the function but returns the result of the original monad
+// MonadChainFirstIOK runs [IO] the monad returned by the function but returns the result of the original monad
 func MonadChainFirstIOK[E, A, B any](ma IOEither[E, A], f func(A) I.IO[B]) IOEither[E, A] {
 	return G.MonadChainFirstIOK(ma, f)
 }
 
-// ChainFirsIOKt runs the monad returned by the function but returns the result of the original monad
+// ChainFirstIOK runs the [IO] monad returned by the function but returns the result of the original monad
 func ChainFirstIOK[E, A, B any](f func(A) I.IO[B]) func(IOEither[E, A]) IOEither[E, A] {
 	return G.ChainFirstIOK[IOEither[E, A]](f)
 }
@@ -207,6 +218,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)
 }

iooption/generic/iooption.go

@@ -18,6 +18,7 @@ package generic
 import (
 	"time"
 
+	ET "github.com/IBM/fp-go/either"
 	F "github.com/IBM/fp-go/function"
 	FI "github.com/IBM/fp-go/internal/fromio"
 	"github.com/IBM/fp-go/internal/optiont"
@@ -55,6 +56,21 @@ func FromOption[GA ~func() O.Option[A], A any](o O.Option[A]) GA {
 	return IO.Of[GA](o)
 }
 
+func FromEither[GA ~func() O.Option[A], E, A any](e ET.Either[E, A]) GA {
+	return F.Pipe2(
+		e,
+		ET.ToOption[E, A],
+		FromOption[GA],
+	)
+}
+
+func FromIOEither[GA ~func() O.Option[A], GEA ~func() ET.Either[E, A], E, A any](ioe GEA) GA {
+	return F.Pipe1(
+		ioe,
+		IO.Map[GEA, GA](ET.ToOption[E, A]),
+	)
+}
+
 func MonadMap[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](fa GA, f func(A) B) GB {
 	return optiont.MonadMap(IO.MonadMap[GA, GB, O.Option[A], O.Option[B]], fa, f)
 }

iooption/iooption.go

@@ -16,7 +16,9 @@
 package iooption
 
 import (
+	ET "github.com/IBM/fp-go/either"
 	I "github.com/IBM/fp-go/io"
+	IOE "github.com/IBM/fp-go/ioeither"
 	G "github.com/IBM/fp-go/iooption/generic"
 	O "github.com/IBM/fp-go/option"
 )
@@ -117,7 +119,7 @@ func Memoize[A any](ma IOOption[A]) IOOption[A] {
 	return G.Memoize(ma)
 }
 
-// Fold convers an IOOption into an IO
+// Fold convers an [IOOption] into an [IO]
 func Fold[A, B any](onNone func() I.IO[B], onSome func(A) I.IO[B]) func(IOOption[A]) I.IO[B] {
 	return G.Fold[IOOption[A]](onNone, onSome)
 }
@@ -126,3 +128,13 @@ func Fold[A, B any](onNone func() I.IO[B], onSome func(A) I.IO[B]) func(IOOption
 func Defer[A any](gen func() IOOption[A]) IOOption[A] {
 	return G.Defer[IOOption[A]](gen)
 }
+
+// FromIOEither converts an [IOEither] into an [IOOption]
+func FromIOEither[E, A any](ioe IOE.IOEither[E, A]) IOOption[A] {
+	return G.FromIOEither[IOOption[A]](ioe)
+}
+
+// FromEither converts an [Either] into an [IOOption]
+func FromEither[E, A any](e ET.Either[E, A]) IOOption[A] {
+	return G.FromEither[IOOption[A]](e)
+}

iterator/stateless/benchmark_test.go

@@ -0,0 +1,65 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package stateless
+
+import (
+	"testing"
+
+	F "github.com/IBM/fp-go/function"
+)
+
+func BenchmarkMulti(b *testing.B) {
+	// run the Fib function b.N times
+	for n := 0; n < b.N; n++ {
+		single()
+	}
+}
+
+func single() int64 {
+
+	length := 10000
+	nums := make([]int, 0, length)
+	for i := 0; i < length; i++ {
+		nums = append(nums, i+1)
+	}
+
+	return F.Pipe6(
+		nums,
+		FromArray[int],
+		Filter(func(n int) bool {
+			return n%2 == 0
+		}),
+		Map(func(t int) int64 {
+			return int64(t)
+		}),
+		Filter(func(t int64) bool {
+			n := t
+			for n/10 != 0 {
+				if n%10 == 4 {
+					return false
+				}
+				n = n / 10
+			}
+			return true
+		}),
+		Map(func(t int64) int {
+			return int(t)
+		}),
+		Reduce(func(n int64, r int) int64 {
+			return n + int64(r)
+		}, int64(0)),
+	)
+}

iterator/stateless/generic/iterator.go

@@ -82,6 +82,7 @@ func Map[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU,
 			m,
 		)
 	}
+
 	m = O.Map(T.Map2(recurse, f))
 
 	return recurse

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

samples/http/http_test.go

@@ -74,9 +74,7 @@ func TestMultipleHttpRequests(t *testing.T) {
 	assert.Equal(t, E.Of[error](count), result())
 }
 
-// TestHeterogeneousHttpRequests shows how to execute multiple HTTP requests in parallel when
-// the response structure of these requests is different. We use [R.TraverseTuple2] to account for the different types
-func TestHeterogeneousHttpRequests(t *testing.T) {
+func heterogeneousHttpRequests() R.ReaderIOEither[T.Tuple2[PostItem, CatFact]] {
 	// prepare the http client
 	client := H.MakeClient(HTTP.DefaultClient)
 	// readSinglePost sends a GET request and parses the response as [PostItem]
@@ -84,7 +82,7 @@ func TestHeterogeneousHttpRequests(t *testing.T) {
 	// readSingleCatFact sends a GET request and parses the response as [CatFact]
 	readSingleCatFact := H.ReadJson[CatFact](client)
 
-	data := F.Pipe3(
+	return F.Pipe3(
 		T.MakeTuple2("https://jsonplaceholder.typicode.com/posts/1", "https://catfact.ninja/fact"),
 		T.Map2(H.MakeGetRequest, H.MakeGetRequest),
 		R.TraverseTuple2(
@@ -94,7 +92,21 @@ func TestHeterogeneousHttpRequests(t *testing.T) {
 		R.ChainFirstIOK(IO.Logf[T.Tuple2[PostItem, CatFact]]("Log Result: %v")),
 	)
 
+}
+
+// TestHeterogeneousHttpRequests shows how to execute multiple HTTP requests in parallel when
+// the response structure of these requests is different. We use [R.TraverseTuple2] to account for the different types
+func TestHeterogeneousHttpRequests(t *testing.T) {
+	data := heterogeneousHttpRequests()
+
 	result := data(context.Background())
 
 	fmt.Println(result())
 }
+
+// BenchmarkHeterogeneousHttpRequests shows how to execute multiple HTTP requests in parallel when
+// the response structure of these requests is different. We use [R.TraverseTuple2] to account for the different types
+func BenchmarkHeterogeneousHttpRequests(b *testing.B) {
+
+	heterogeneousHttpRequests()(context.Background())
+}

samples/tuples/option_test.go

@@ -0,0 +1,59 @@
+// 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 tuples
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+
+	F "github.com/IBM/fp-go/function"
+	IOE "github.com/IBM/fp-go/ioeither"
+	IOEF "github.com/IBM/fp-go/ioeither/file"
+	IOEG "github.com/IBM/fp-go/ioeither/generic"
+	IOO "github.com/IBM/fp-go/iooption"
+)
+
+func TestIOEitherToOption1(t *testing.T) {
+	tmpDir := t.TempDir()
+	content := []byte("abc")
+
+	resIOO := F.Pipe2(
+		content,
+		IOEF.WriteFile(filepath.Join(tmpDir, "test.txt"), os.ModePerm),
+		IOEG.Fold[IOE.IOEither[error, []byte]](
+			IOO.Of[error],
+			F.Ignore1of1[[]byte](IOO.None[error]),
+		),
+	)
+
+	fmt.Println(resIOO())
+}
+
+func TestIOEitherToOption2(t *testing.T) {
+	tmpDir := t.TempDir()
+	content := []byte("abc")
+
+	resIOO := F.Pipe3(
+		content,
+		IOEF.WriteFile(filepath.Join(tmpDir, "test.txt"), os.ModePerm),
+		IOE.Swap[error, []byte],
+		IOO.FromIOEither[[]byte, error],
+	)
+
+	fmt.Println(resIOO())
+}

samples/tuples/samples/data.txt

@@ -0,0 +1 @@
+abc

samples/tuples/tuple_test.go

@@ -0,0 +1,130 @@
+// 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 tuples
+
+import (
+	"bytes"
+	"io"
+	"strings"
+	"testing"
+
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	IOE "github.com/IBM/fp-go/ioeither"
+	IOEF "github.com/IBM/fp-go/ioeither/file"
+	T "github.com/IBM/fp-go/tuple"
+	"github.com/stretchr/testify/assert"
+)
+
+func sampleConvertDocx(r io.Reader) (string, map[string]string, error) {
+	content, err := io.ReadAll(r)
+	return string(content), map[string]string{}, err
+}
+
+func TestSampleConvertDocx1(t *testing.T) {
+	// this conversion approach has the disadvantage that it exhausts the reader
+	// so we cannot invoke the resulting IOEither multiple times
+	convertDocx := func(r io.Reader) IOE.IOEither[error, T.Tuple2[string, map[string]string]] {
+		return IOE.TryCatchError(func() (T.Tuple2[string, map[string]string], error) {
+			text, meta, err := sampleConvertDocx(r)
+			return T.MakeTuple2(text, meta), err
+		})
+	}
+
+	rdr := strings.NewReader("abc")
+	resIOE := convertDocx(rdr)
+
+	resE := resIOE()
+
+	assert.True(t, E.IsRight(resE))
+}
+
+func TestSampleConvertDocx2(t *testing.T) {
+	// this approach assumes that `sampleConvertDocx` does not have any side effects
+	// other than reading from a `Reader`. As a consequence it can be a pure function itself.
+	// The disadvantage is that its input has to exist in memory which is probably not a good
+	// idea for large inputs
+	convertDocx := func(data []byte) E.Either[error, T.Tuple2[string, map[string]string]] {
+		return E.TryCatchError(func() (T.Tuple2[string, map[string]string], error) {
+			text, meta, err := sampleConvertDocx(bytes.NewReader(data))
+			return T.MakeTuple2(text, meta), err
+		})
+	}
+
+	resE := convertDocx([]byte("abc"))
+
+	assert.True(t, E.IsRight(resE))
+}
+
+// onClose closes a closeable resource
+func onClose[R io.Closer](r R) IOE.IOEither[error, R] {
+	return IOE.TryCatchError(func() (R, error) {
+		return r, r.Close()
+	})
+}
+
+// convertDocx3 takes an `acquire` function that creates an instance or a [ReaderCloser] whenever the resulting [IOEither] is invoked. Since
+// we return a [Closer] the instance will be closed after use, automatically. This design makes sure that the resulting [IOEither] can be invoked
+// as many times as necessary
+func convertDocx3[R io.ReadCloser](acquire IOE.IOEither[error, R]) IOE.IOEither[error, T.Tuple2[string, map[string]string]] {
+	return IOE.WithResource[T.Tuple2[string, map[string]string]](
+		acquire,
+		onClose[R])(
+		func(r R) IOE.IOEither[error, T.Tuple2[string, map[string]string]] {
+			return IOE.TryCatchError(func() (T.Tuple2[string, map[string]string], error) {
+				text, meta, err := sampleConvertDocx(r)
+				return T.MakeTuple2(text, meta), err
+			})
+		},
+	)
+}
+
+// convertDocx4 takes an `acquire` function that creates an instance or a [Reader] whenever the resulting [IOEither] is invoked.
+// This design makes sure that the resulting [IOEither] can be invoked
+// as many times as necessary
+func convertDocx4[R io.Reader](acquire IOE.IOEither[error, R]) IOE.IOEither[error, T.Tuple2[string, map[string]string]] {
+	return F.Pipe1(
+		acquire,
+		IOE.Chain(func(r R) IOE.IOEither[error, T.Tuple2[string, map[string]string]] {
+			return IOE.TryCatchError(func() (T.Tuple2[string, map[string]string], error) {
+				text, meta, err := sampleConvertDocx(r)
+				return T.MakeTuple2(text, meta), err
+			})
+		}),
+	)
+}
+
+func TestSampleConvertDocx3(t *testing.T) {
+	// IOEither that creates the reader
+	acquire := IOEF.Open("./samples/data.txt")
+
+	resIOE := convertDocx3(acquire)
+	resE := resIOE()
+
+	assert.True(t, E.IsRight(resE))
+}
+
+func TestSampleConvertDocx4(t *testing.T) {
+	// IOEither that creates the reader
+	acquire := IOE.FromIO[error](func() *strings.Reader {
+		return strings.NewReader("abc")
+	})
+
+	resIOE := convertDocx4(acquire)
+	resE := resIOE()
+
+	assert.True(t, E.IsRight(resE))
+}

semigroup/alt.go

@@ -13,17 +13,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package file
+package semigroup
 
-import (
-	"io"
+func AltSemigroup[HKTA any](
+	falt func(HKTA, func() HKTA) HKTA,
 
-	IOE "github.com/IBM/fp-go/ioeither"
-)
+) Semigroup[HKTA] {
 
-// onClose closes a closeable resource
-func onClose[R io.Closer](r R) IOE.IOEither[error, R] {
-	return IOE.TryCatchError(func() (R, error) {
-		return r, r.Close()
-	})
+	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 .\...

tuple/tuple.go

@@ -21,10 +21,12 @@ func Of[T1 any](t T1) Tuple1[T1] {
 	return MakeTuple1(t)
 }
 
+// First returns the first element of a [Tuple2]
 func First[T1, T2 any](t Tuple2[T1, T2]) T1 {
 	return t.F1
 }
 
+// Second returns the second element of a [Tuple2]
 func Second[T1, T2 any](t Tuple2[T1, T2]) T2 {
 	return t.F2
 }