fix: add WithTempFile

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

README.md

@@ -1,6 +1,6 @@
 # Functional programming library for golang
 
-**🚧 Work in progress! 🚧** Despite major version 1 because of https://github.com/semantic-release/semantic-release/issues/1507. Trying to not make breaking changes, but devil is in the details. 
+**🚧 Work in progress! 🚧** Despite major version 1 because of <https://github.com/semantic-release/semantic-release/issues/1507>. Trying to not make breaking changes, but devil is in the details.
 
 ![logo](resources/images/logo.png)
 
@@ -12,7 +12,7 @@ This library is strongly influenced by the awesome [fp-ts](https://github.com/gc
 go get github.com/IBM/fp-go
 ```
 
-Refer to the [samples](./samples/). 
+Refer to the [samples](./samples/).
 
 ## Design Goal
 
@@ -65,7 +65,7 @@ This library aims to provide a set of data types and functions that make it easy
 
 #### 🧘🏽 Moderation is a virtue
 
-✔️ The library does not implement its own goroutines and also does not require any expensive synchronization primitives. Coordination of IO operations is implemented via atomic counters without additional primitives. 
+✔️ The library does not implement its own goroutines and also does not require any expensive synchronization primitives. Coordination of IO operations is implemented via atomic counters without additional primitives.
 
 #### 🧘🏽 Maintainability counts
 
@@ -73,6 +73,40 @@ This library aims to provide a set of data types and functions that make it easy
 
 The library itself also comprises many small functions, but it's admittedly harder to maintain than code that uses it. However this asymmetry is intended because it offloads complexity from users into a central component.
 
+## Comparation to Idiomatic Go
+
+In this section we discuss how the functional APIs differ from idiomatic go function signatures and how to convert back and forth.
+
+### Pure functions
+
+Pure functions are functions that take input parameters and that compute an output without changing any global state and without mutating the input parameters. They will always return the same output for the same input.
+
+#### Without Errors
+
+If your pure function does not return an error, the idiomatic signature is just fine and no changes are required.
+
+#### With Errors
+
+If your pure function can return an error, then it will have a `(T, error)` return value in idiomatic go. In functional style the return value is [Either[error, T]](https://pkg.go.dev/github.com/IBM/fp-go/either) because function composition is easier with such a return type. Use the `EitherizeXXX` methods in ["github.com/IBM/fp-go/either"](https://pkg.go.dev/github.com/IBM/fp-go/either) to convert from idiomatic to functional style and `UneitherizeXXX` to convert from functional to idiomatic style.
+
+### Effectful functions
+
+An effectful function (or function with a side effect) is one that changes data outside the scope of the function or that does not always produce the same output for the same input (because it depends on some external, mutable state). There is no special way in idiomatic go to identify such a function other than documentation. In functional style we represent them as functions that do not take an input but that produce an output. The base type for these functions is [IO[T]](https://pkg.go.dev/github.com/IBM/fp-go/io) because in many cases such functions represent `I/O` operations.
+
+#### Without Errors
+
+If your effectful function does not return an error, the functional signature is [IO[T]](https://pkg.go.dev/github.com/IBM/fp-go/io)
+
+#### With Errors
+
+If your effectful function can return an error, the functional signature is [IOEither[error, T]](https://pkg.go.dev/github.com/IBM/fp-go/ioeither). Use `EitherizeXXX` from ["github.com/IBM/fp-go/ioeither"](https://pkg.go.dev/github.com/IBM/fp-go/ioeither) to convert an idiomatic go function to functional style.
+
+### Go Context
+
+Functions that take a [context](https://pkg.go.dev/context) are per definition effectful because they depend on the context parameter that is designed to be mutable (it can e.g. be used to cancel a running operation). Furthermore in idiomatic go the parameter is typically passed as the first parameter to a function.
+
+In functional style we isolate the [context](https://pkg.go.dev/context) and represent the nature of the effectful function as an [IOEither[error, T]](https://pkg.go.dev/github.com/IBM/fp-go/ioeither). The resulting type is [ReaderIOEither[T]](https://pkg.go.dev/github.com/IBM/fp-go/context/readerioeither), a function taking a [context](https://pkg.go.dev/context) that returns a function without parameters returning an [Either[error, T]](https://pkg.go.dev/github.com/IBM/fp-go/either). Use the `EitherizeXXX` methods from ["github.com/IBM/fp-go/context/readerioeither"](https://pkg.go.dev/github.com/IBM/fp-go/context/readerioeither) to convert an idiomatic go function with a [context](https://pkg.go.dev/context) to functional style.
+
 ## Implementation Notes
 
 ### Generics

array/array.go

@@ -144,7 +144,7 @@ func Append[A any](as []A, a A) []A {
 }
 
 func IsEmpty[A any](as []A) bool {
-	return array.IsEmpty(as)
+	return G.IsEmpty(as)
 }
 
 func IsNonEmpty[A any](as []A) bool {
@@ -181,12 +181,11 @@ func Ap[B, A any](fa []A) func([]func(A) B) []B {
 }
 
 func Match[A, B any](onEmpty func() B, onNonEmpty func([]A) B) func([]A) B {
-	return func(as []A) B {
-		if IsEmpty(as) {
-			return onEmpty()
-		}
-		return onNonEmpty(as)
-	}
+	return G.Match[[]A](onEmpty, onNonEmpty)
+}
+
+func MatchLeft[A, B any](onEmpty func() B, onNonEmpty func(A, []A) B) func([]A) B {
+	return G.MatchLeft[[]A](onEmpty, onNonEmpty)
 }
 
 func Tail[A any](as []A) O.Option[[]A] {
@@ -231,7 +230,7 @@ func Intersperse[A any](middle A) func([]A) []A {
 }
 
 func Intercalate[A any](m M.Monoid[A]) func(A) func([]A) A {
-	concatAll := ConcatAll[A](m)(m.Empty())
+	concatAll := ConcatAll[A](m)
 	return func(middle A) func([]A) A {
 		return Match(m.Empty, F.Flow2(Intersperse(middle), concatAll))
 	}
@@ -281,3 +280,11 @@ func IsNonNil[A any](as []A) bool {
 func ConstNil[A any]() []A {
 	return array.ConstNil[[]A]()
 }
+
+func SliceRight[A any](start int) func([]A) []A {
+	return G.SliceRight[[]A](start)
+}
+
+func Copy[A any](b []A) []A {
+	return G.Copy(b)
+}

array/generic/array.go

@@ -158,3 +158,43 @@ func MonadAp[BS ~[]B, ABS ~[]func(A) B, AS ~[]A, B, A any](fab ABS, fa AS) BS {
 func Ap[BS ~[]B, ABS ~[]func(A) B, AS ~[]A, B, A any](fa AS) func(ABS) BS {
 	return F.Bind2nd(MonadAp[BS, ABS, AS], fa)
 }
+
+func IsEmpty[AS ~[]A, A any](as AS) bool {
+	return array.IsEmpty(as)
+}
+
+func Match[AS ~[]A, A, B any](onEmpty func() B, onNonEmpty func(AS) B) func(AS) B {
+	return func(as AS) B {
+		if IsEmpty(as) {
+			return onEmpty()
+		}
+		return onNonEmpty(as)
+	}
+}
+
+func MatchLeft[AS ~[]A, A, B any](onEmpty func() B, onNonEmpty func(A, AS) B) func(AS) B {
+	return func(as AS) B {
+		if IsEmpty(as) {
+			return onEmpty()
+		}
+		return onNonEmpty(as[0], as[1:])
+	}
+}
+
+func Slice[AS ~[]A, A any](start int, end int) func(AS) AS {
+	return func(a AS) AS {
+		return a[start:end]
+	}
+}
+
+func SliceRight[AS ~[]A, A any](start int) func(AS) AS {
+	return func(a AS) AS {
+		return a[start:]
+	}
+}
+
+func Copy[AS ~[]A, A any](b AS) AS {
+	buf := make(AS, len(b))
+	copy(buf, b)
+	return buf
+}

array/magma.go

@@ -16,10 +16,9 @@
 package array
 
 import (
-	F "github.com/IBM/fp-go/function"
-	M "github.com/IBM/fp-go/magma"
+	M "github.com/IBM/fp-go/monoid"
 )
 
-func ConcatAll[A any](m M.Magma[A]) func(A) func([]A) A {
-	return F.Bind1st(Reduce[A, A], m.Concat)
+func ConcatAll[A any](m M.Monoid[A]) func([]A) A {
+	return Reduce(m.Concat, m.Empty())
 }

array/magma_test.go

@@ -20,16 +20,16 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	M "github.com/IBM/fp-go/magma"
+	M "github.com/IBM/fp-go/monoid"
 )
 
-var subInt = M.MakeMagma(func(first int, second int) int {
+var subInt = M.MakeMonoid(func(first int, second int) int {
 	return first - second
-})
+}, 0)
 
 func TestConcatAll(t *testing.T) {
 
-	var subAll = ConcatAll(subInt)(0)
+	var subAll = ConcatAll(subInt)
 
 	assert.Equal(t, subAll([]int{1, 2, 3}), -6)
 

bounded/bounded.go

@@ -0,0 +1,64 @@
+// 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 bounded
+
+import (
+	O "github.com/IBM/fp-go/ord"
+)
+
+type Bounded[T any] interface {
+	O.Ord[T]
+	Top() T
+	Bottom() T
+}
+
+type bounded[T any] struct {
+	c func(x, y T) int
+	e func(x, y T) bool
+	t T
+	b T
+}
+
+func (self bounded[T]) Equals(x, y T) bool {
+	return self.e(x, y)
+}
+
+func (self bounded[T]) Compare(x, y T) int {
+	return self.c(x, y)
+}
+
+func (self bounded[T]) Top() T {
+	return self.t
+}
+
+func (self bounded[T]) Bottom() T {
+	return self.b
+}
+
+// MakeBounded creates an instance of a bounded type
+func MakeBounded[T any](o O.Ord[T], t, b T) Bounded[T] {
+	return bounded[T]{c: o.Compare, e: o.Equals, t: t, b: b}
+}
+
+// Clamp returns a function that clamps against the bounds defined in the bounded type
+func Clamp[T any](b Bounded[T]) func(T) T {
+	return O.Clamp[T](b)(b.Bottom(), b.Top())
+}
+
+// Reverse reverses the ordering and swaps the bounds
+func Reverse[T any](b Bounded[T]) Bounded[T] {
+	return MakeBounded(O.Reverse[T](b), b.Bottom(), b.Top())
+}

bytes/bytes.go

@@ -18,3 +18,7 @@ package bytes
 func ToString(a []byte) string {
 	return string(a)
 }
+
+func Size(as []byte) int {
+	return len(as)
+}

cli/commands.go

@@ -31,5 +31,8 @@ func Commands() []*C.Command {
 		ContextReaderIOEitherCommand(),
 		ReaderIOEitherCommand(),
 		ReaderCommand(),
+		IOEitherCommand(),
+		IOCommand(),
+		IOOptionCommand(),
 	}
 }

cli/io.go

@@ -0,0 +1,136 @@
+// 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 cli
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"time"
+
+	A "github.com/IBM/fp-go/array"
+	C "github.com/urfave/cli/v2"
+)
+
+func nonGenericIO(param string) string {
+	return fmt.Sprintf("IO[%s]", param)
+}
+
+func genericIO(param string) string {
+	return fmt.Sprintf("func() %s", param)
+}
+
+var extrasIO = A.Empty[string]()
+
+func generateIOSequenceT(f, fg *os.File, i int) {
+	generateGenericSequenceT(nonGenericIO, genericIO, extrasIO)(f, fg, i)
+}
+
+func generateIOSequenceTuple(f, fg *os.File, i int) {
+	generateGenericSequenceTuple(nonGenericIO, genericIO, extrasIO)(f, fg, i)
+}
+
+func generateIOTraverseTuple(f, fg *os.File, i int) {
+	generateGenericTraverseTuple(nonGenericIO, genericIO, extrasIO)(f, fg, i)
+}
+
+func generateIOHelpers(filename string, count int) error {
+	dir, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+	absDir, err := filepath.Abs(dir)
+	if err != nil {
+		return err
+	}
+	pkg := filepath.Base(absDir)
+	f, err := os.Create(filepath.Clean(filename))
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	// construct subdirectory
+	genFilename := filepath.Join("generic", filename)
+	err = os.MkdirAll("generic", os.ModePerm)
+	if err != nil {
+		return err
+	}
+	fg, err := os.Create(filepath.Clean(genFilename))
+	if err != nil {
+		return err
+	}
+	defer fg.Close()
+
+	// log
+	log.Printf("Generating code in [%s] for package [%s] with [%d] repetitions ...", filename, pkg, count)
+
+	// some header
+	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
+	fmt.Fprintln(f, "// This file was generated by robots at")
+	fmt.Fprintf(f, "// %s\n", time.Now())
+
+	fmt.Fprintf(f, "package %s\n\n", pkg)
+
+	fmt.Fprintf(f, `
+import (
+	G "github.com/IBM/fp-go/%s/generic"	
+	T "github.com/IBM/fp-go/tuple"
+)
+`, pkg)
+
+	// some header
+	fmt.Fprintln(fg, "// Code generated by go generate; DO NOT EDIT.")
+	fmt.Fprintln(fg, "// This file was generated by robots at")
+	fmt.Fprintf(fg, "// %s\n", time.Now())
+
+	fmt.Fprintf(fg, "package generic\n\n")
+
+	fmt.Fprintf(fg, `
+import (
+	T "github.com/IBM/fp-go/tuple"
+	A "github.com/IBM/fp-go/internal/apply"
+)
+`)
+
+	for i := 1; i <= count; i++ {
+		// sequenceT
+		generateIOSequenceT(f, fg, i)
+		// sequenceTuple
+		generateIOSequenceTuple(f, fg, i)
+		// traverseTuple
+		generateIOTraverseTuple(f, fg, i)
+	}
+
+	return nil
+}
+
+func IOCommand() *C.Command {
+	return &C.Command{
+		Name:  "io",
+		Usage: "generate code for IO",
+		Flags: []C.Flag{
+			flagCount,
+			flagFilename,
+		},
+		Action: func(ctx *C.Context) error {
+			return generateIOHelpers(
+				ctx.String(keyFilename),
+				ctx.Int(keyCount),
+			)
+		},
+	}
+}

cli/ioeither.go

@@ -0,0 +1,282 @@
+// 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 cli
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"time"
+
+	A "github.com/IBM/fp-go/array"
+	C "github.com/urfave/cli/v2"
+)
+
+// [GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GTAB ~func() ET.Either[E, T.Tuple2[A, B]], E, A, B any](a GA, b GB) GTAB {
+
+func nonGenericIOEither(param string) string {
+	return fmt.Sprintf("IOEither[E, %s]", param)
+}
+
+func genericIOEither(param string) string {
+	return fmt.Sprintf("func() ET.Either[E, %s]", param)
+}
+
+var extrasIOEither = A.From("E")
+
+func generateIOEitherSequenceT(f, fg *os.File, i int) {
+	generateGenericSequenceT(nonGenericIOEither, genericIOEither, extrasIOEither)(f, fg, i)
+}
+
+func generateIOEitherSequenceTuple(f, fg *os.File, i int) {
+	generateGenericSequenceTuple(nonGenericIOEither, genericIOEither, extrasIOEither)(f, fg, i)
+}
+
+func generateIOEitherTraverseTuple(f, fg *os.File, i int) {
+	generateGenericTraverseTuple(nonGenericIOEither, genericIOEither, extrasIOEither)(f, fg, i)
+}
+
+func generateIOEitherUneitherize(f, fg *os.File, i int) {
+	// non generic version
+	fmt.Fprintf(f, "\n// Uneitherize%d converts a function with %d parameters returning a tuple into a function with %d parameters returning a [IOEither[error, R]]\n", i, i+1, i)
+	fmt.Fprintf(f, "func Uneitherize%d[F ~func(", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j+1)
+	}
+	fmt.Fprintf(f, ") IOEither[error, R]")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j+1)
+	}
+	fmt.Fprintf(f, ", R any](f F) func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j+1)
+	}
+	fmt.Fprintf(f, ") (R, error) {\n")
+	fmt.Fprintf(f, "  return G.Uneitherize%d[IOEither[error, R]](f)\n", i)
+	fmt.Fprintln(f, "}")
+
+	// generic version
+	fmt.Fprintf(fg, "\n// Uneitherize%d converts a function with %d parameters returning a tuple into a function with %d parameters returning a [GIOA]\n", i, i, i)
+	fmt.Fprintf(fg, "func Uneitherize%d[GIOA ~func() ET.Either[error, R], GTA ~func(", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "T%d", j+1)
+	}
+	fmt.Fprintf(fg, ") GIOA")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", T%d", j+1)
+	}
+	fmt.Fprintf(fg, ", R any](f GTA) func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "T%d", j+1)
+	}
+	fmt.Fprintf(fg, ") (R, error) {\n")
+	fmt.Fprintf(fg, "  return func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "t%d T%d", j+1, j+1)
+	}
+	fmt.Fprintf(fg, ") (R, error) {\n")
+	fmt.Fprintf(fg, "    return ET.Unwrap(f(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "t%d", j+1)
+	}
+	fmt.Fprintf(fg, ")())\n")
+	fmt.Fprintf(fg, "  }\n")
+	fmt.Fprintf(fg, "}\n")
+}
+
+func generateIOEitherEitherize(f, fg *os.File, i int) {
+	// non generic version
+	fmt.Fprintf(f, "\n// Eitherize%d converts a function with %d parameters returning a tuple into a function with %d parameters returning a [IOEither[error, R]]\n", i, i+1, i)
+	fmt.Fprintf(f, "func Eitherize%d[F ~func(", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j+1)
+	}
+	fmt.Fprintf(f, ") (R, error)")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j+1)
+	}
+	fmt.Fprintf(f, ", R any](f F) func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j+1)
+	}
+	fmt.Fprintf(f, ") IOEither[error, R] {\n")
+	fmt.Fprintf(f, "  return G.Eitherize%d[IOEither[error, R]](f)\n", i)
+	fmt.Fprintln(f, "}")
+
+	// generic version
+	fmt.Fprintf(fg, "\n// Eitherize%d converts a function with %d parameters returning a tuple into a function with %d parameters returning a [GIOA]\n", i, i, i)
+	fmt.Fprintf(fg, "func Eitherize%d[GIOA ~func() ET.Either[error, R], F ~func(", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "T%d", j+1)
+	}
+	fmt.Fprintf(fg, ") (R, error)")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", T%d", j+1)
+	}
+	fmt.Fprintf(fg, ", R any](f F) func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "T%d", j+1)
+	}
+	fmt.Fprintf(fg, ") GIOA {\n")
+	fmt.Fprintf(fg, "  e := ET.Eitherize%d(f)\n", i)
+	fmt.Fprintf(fg, "  return func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "t%d T%d", j+1, j+1)
+	}
+	fmt.Fprintf(fg, ") GIOA {\n")
+	fmt.Fprintf(fg, "    return func() ET.Either[error, R] {\n")
+	fmt.Fprintf(fg, "      return e(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "t%d", j+1)
+	}
+	fmt.Fprintf(fg, ")\n")
+	fmt.Fprintf(fg, "    }}\n")
+	fmt.Fprintf(fg, "}\n")
+}
+
+func generateIOEitherHelpers(filename string, count int) error {
+	dir, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+	absDir, err := filepath.Abs(dir)
+	if err != nil {
+		return err
+	}
+	pkg := filepath.Base(absDir)
+	f, err := os.Create(filepath.Clean(filename))
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	// construct subdirectory
+	genFilename := filepath.Join("generic", filename)
+	err = os.MkdirAll("generic", os.ModePerm)
+	if err != nil {
+		return err
+	}
+	fg, err := os.Create(filepath.Clean(genFilename))
+	if err != nil {
+		return err
+	}
+	defer fg.Close()
+
+	// log
+	log.Printf("Generating code in [%s] for package [%s] with [%d] repetitions ...", filename, pkg, count)
+
+	// some header
+	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
+	fmt.Fprintln(f, "// This file was generated by robots at")
+	fmt.Fprintf(f, "// %s\n", time.Now())
+
+	fmt.Fprintf(f, "package %s\n\n", pkg)
+
+	fmt.Fprintf(f, `
+import (
+	G "github.com/IBM/fp-go/%s/generic"	
+	T "github.com/IBM/fp-go/tuple"
+)
+`, pkg)
+
+	// some header
+	fmt.Fprintln(fg, "// Code generated by go generate; DO NOT EDIT.")
+	fmt.Fprintln(fg, "// This file was generated by robots at")
+	fmt.Fprintf(fg, "// %s\n", time.Now())
+
+	fmt.Fprintf(fg, "package generic\n\n")
+
+	fmt.Fprintf(fg, `
+import (
+	ET "github.com/IBM/fp-go/either"
+	T "github.com/IBM/fp-go/tuple"
+	A "github.com/IBM/fp-go/internal/apply"
+)
+`)
+
+	// eitherize
+	generateIOEitherEitherize(f, fg, 0)
+	// uneitherize
+	generateIOEitherUneitherize(f, fg, 0)
+
+	for i := 1; i <= count; i++ {
+		// eitherize
+		generateIOEitherEitherize(f, fg, i)
+		// uneitherize
+		generateIOEitherUneitherize(f, fg, i)
+		// sequenceT
+		generateIOEitherSequenceT(f, fg, i)
+		// sequenceTuple
+		generateIOEitherSequenceTuple(f, fg, i)
+		// traverseTuple
+		generateIOEitherTraverseTuple(f, fg, i)
+	}
+
+	return nil
+}
+
+func IOEitherCommand() *C.Command {
+	return &C.Command{
+		Name:  "ioeither",
+		Usage: "generate code for IOEither",
+		Flags: []C.Flag{
+			flagCount,
+			flagFilename,
+		},
+		Action: func(ctx *C.Context) error {
+			return generateIOEitherHelpers(
+				ctx.String(keyFilename),
+				ctx.Int(keyCount),
+			)
+		},
+	}
+}

cli/iooption.go

@@ -0,0 +1,137 @@
+// 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 cli
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"time"
+
+	A "github.com/IBM/fp-go/array"
+	C "github.com/urfave/cli/v2"
+)
+
+func nonGenericIOOption(param string) string {
+	return fmt.Sprintf("IOOption[%s]", param)
+}
+
+func genericIOOption(param string) string {
+	return fmt.Sprintf("func() O.Option[%s]", param)
+}
+
+var extrasIOOption = A.Empty[string]()
+
+func generateIOOptionSequenceT(f, fg *os.File, i int) {
+	generateGenericSequenceT(nonGenericIOOption, genericIOOption, extrasIOOption)(f, fg, i)
+}
+
+func generateIOOptionSequenceTuple(f, fg *os.File, i int) {
+	generateGenericSequenceTuple(nonGenericIOOption, genericIOOption, extrasIOOption)(f, fg, i)
+}
+
+func generateIOOptionTraverseTuple(f, fg *os.File, i int) {
+	generateGenericTraverseTuple(nonGenericIOOption, genericIOOption, extrasIOOption)(f, fg, i)
+}
+
+func generateIOOptionHelpers(filename string, count int) error {
+	dir, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+	absDir, err := filepath.Abs(dir)
+	if err != nil {
+		return err
+	}
+	pkg := filepath.Base(absDir)
+	f, err := os.Create(filepath.Clean(filename))
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	// construct subdirectory
+	genFilename := filepath.Join("generic", filename)
+	err = os.MkdirAll("generic", os.ModePerm)
+	if err != nil {
+		return err
+	}
+	fg, err := os.Create(filepath.Clean(genFilename))
+	if err != nil {
+		return err
+	}
+	defer fg.Close()
+
+	// log
+	log.Printf("Generating code in [%s] for package [%s] with [%d] repetitions ...", filename, pkg, count)
+
+	// some header
+	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
+	fmt.Fprintln(f, "// This file was generated by robots at")
+	fmt.Fprintf(f, "// %s\n", time.Now())
+
+	fmt.Fprintf(f, "package %s\n\n", pkg)
+
+	fmt.Fprintf(f, `
+import (
+	G "github.com/IBM/fp-go/%s/generic"	
+	T "github.com/IBM/fp-go/tuple"
+)
+`, pkg)
+
+	// some header
+	fmt.Fprintln(fg, "// Code generated by go generate; DO NOT EDIT.")
+	fmt.Fprintln(fg, "// This file was generated by robots at")
+	fmt.Fprintf(fg, "// %s\n", time.Now())
+
+	fmt.Fprintf(fg, "package generic\n\n")
+
+	fmt.Fprintf(fg, `
+import (
+	T "github.com/IBM/fp-go/tuple"
+	O "github.com/IBM/fp-go/option"
+	A "github.com/IBM/fp-go/internal/apply"
+)
+`)
+
+	for i := 1; i <= count; i++ {
+		// sequenceT
+		generateIOOptionSequenceT(f, fg, i)
+		// sequenceTuple
+		generateIOOptionSequenceTuple(f, fg, i)
+		// traverseTuple
+		generateIOOptionTraverseTuple(f, fg, i)
+	}
+
+	return nil
+}
+
+func IOOptionCommand() *C.Command {
+	return &C.Command{
+		Name:  "iooption",
+		Usage: "generate code for IOOption",
+		Flags: []C.Flag{
+			flagCount,
+			flagFilename,
+		},
+		Action: func(ctx *C.Context) error {
+			return generateIOOptionHelpers(
+				ctx.String(keyFilename),
+				ctx.Int(keyCount),
+			)
+		},
+	}
+}

cli/monad2.go

@@ -0,0 +1,284 @@
+// 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 cli
+
+import (
+	"fmt"
+	"os"
+
+	A "github.com/IBM/fp-go/array"
+	F "github.com/IBM/fp-go/function"
+	N "github.com/IBM/fp-go/number"
+	S "github.com/IBM/fp-go/string"
+)
+
+var (
+	concStrgs     = A.Monoid[string]().Concat
+	intercalStrgs = A.Intercalate(S.Monoid)
+	concAllStrgs  = A.ConcatAll(A.Monoid[string]())
+)
+
+func joinAll(middle string) func(all ...[]string) string {
+	ic := intercalStrgs(middle)
+	return func(all ...[]string) string {
+		return ic(concAllStrgs(all))
+	}
+}
+
+func generateGenericSequenceT(
+	nonGenericType func(string) string,
+	genericType func(string) string,
+	extra []string,
+) func(f, fg *os.File, i int) {
+	return func(f, fg *os.File, i int) {
+		// tuple
+		tuple := tupleType("T")(i)
+		// all types T
+		typesT := A.MakeBy(i, F.Flow2(
+			N.Inc[int],
+			S.Format[int]("T%d"),
+		))
+		// non generic version
+		fmt.Fprintf(f, "\n// SequenceT%d converts %d [%s] into a [%s]\n", i, i, nonGenericType("T"), nonGenericType(tuple))
+		fmt.Fprintf(f, "func SequenceT%d[%s any](\n", i, joinAll(", ")(extra, typesT))
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(f, "  t%d %s,\n", j+1, nonGenericType(fmt.Sprintf("T%d", j+1)))
+		}
+		fmt.Fprintf(f, ") %s {\n", nonGenericType(tuple))
+		fmt.Fprintf(f, "  return G.SequenceT%d[\n", i)
+		fmt.Fprintf(f, "    %s,\n", nonGenericType(tuple))
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(f, "    %s,\n", nonGenericType(fmt.Sprintf("T%d", j+1)))
+		}
+		fmt.Fprintf(f, "  ](")
+		for j := 0; j < i; j++ {
+			if j > 0 {
+				fmt.Fprintf(f, ", ")
+			}
+			fmt.Fprintf(f, "t%d", j+1)
+		}
+		fmt.Fprintf(f, ")\n")
+		fmt.Fprintf(f, "}\n")
+
+		// generic version
+		fmt.Fprintf(fg, "\n// SequenceT%d converts %d [%s] into a [%s]\n", i, i, genericType("T"), genericType(tuple))
+		fmt.Fprintf(fg, "func SequenceT%d[\n", i)
+		fmt.Fprintf(fg, "  G_TUPLE%d ~%s,\n", i, genericType(tuple))
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(fg, "  G_T%d ~%s, \n", j+1, genericType(fmt.Sprintf("T%d", j+1)))
+		}
+		fmt.Fprintf(fg, "  %s any](\n", joinAll(", ")(extra, typesT))
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(fg, "  t%d G_T%d,\n", j+1, j+1)
+		}
+		fmt.Fprintf(fg, ")  G_TUPLE%d {\n", i)
+		fmt.Fprintf(fg, "  return A.SequenceT%d(\n", i)
+		// map call
+		var cio string
+		cb := generateNestedCallbacks(1, i)
+		if i > 1 {
+			cio = genericType(cb)
+		} else {
+			cio = fmt.Sprintf("G_TUPLE%d", i)
+		}
+		fmt.Fprintf(fg, "    Map[%s],\n", joinAll(", ")(A.From("G_T1", cio), extra, A.From("T1", cb)))
+		// the apply calls
+		for j := 1; j < i; j++ {
+			if j < i-1 {
+				cb := generateNestedCallbacks(j+1, i)
+				cio = genericType(cb)
+			} else {
+				cio = fmt.Sprintf("G_TUPLE%d", i)
+			}
+			fmt.Fprintf(fg, "    Ap[%s, %s, G_T%d],\n", cio, genericType(generateNestedCallbacks(j, i)), j+1)
+		}
+		// function parameters
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(fg, "    t%d,\n", j+1)
+		}
+
+		fmt.Fprintf(fg, "  )\n")
+		fmt.Fprintf(fg, "}\n")
+	}
+}
+
+func generateGenericSequenceTuple(
+	nonGenericType func(string) string,
+	genericType func(string) string,
+	extra []string,
+) func(f, fg *os.File, i int) {
+	return func(f, fg *os.File, i int) {
+		// tuple
+		tuple := tupleType("T")(i)
+		// all types T
+		typesT := A.MakeBy(i, F.Flow2(
+			N.Inc[int],
+			S.Format[int]("T%d"),
+		))
+		// non generic version
+		fmt.Fprintf(f, "\n// SequenceTuple%d converts a [T.Tuple%d[%s]] into a [%s]\n", i, i, nonGenericType("T"), nonGenericType(tuple))
+		fmt.Fprintf(f, "func SequenceTuple%d[%s any](t T.Tuple%d[", i, joinAll(", ")(extra, typesT), i)
+		for j := 0; j < i; j++ {
+			if j > 0 {
+				fmt.Fprintf(f, ", ")
+			}
+			fmt.Fprintf(f, "%s", nonGenericType(fmt.Sprintf("T%d", j+1)))
+		}
+		fmt.Fprintf(f, "]) %s {\n", nonGenericType(tuple))
+		fmt.Fprintf(f, "  return G.SequenceTuple%d[\n", i)
+		fmt.Fprintf(f, "    %s,\n", nonGenericType(tuple))
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(f, "    %s,\n", nonGenericType(fmt.Sprintf("T%d", j+1)))
+		}
+		fmt.Fprintf(f, "  ](t)\n")
+		fmt.Fprintf(f, "}\n")
+
+		// generic version
+		fmt.Fprintf(fg, "\n// SequenceTuple%d converts a [T.Tuple%d[%s]] into a [%s]\n", i, i, genericType("T"), genericType(tuple))
+		fmt.Fprintf(fg, "func SequenceTuple%d[\n", i)
+		fmt.Fprintf(fg, "  G_TUPLE%d ~%s,\n", i, genericType(tuple))
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(fg, "  G_T%d ~%s, \n", j+1, genericType(fmt.Sprintf("T%d", j+1)))
+		}
+		fmt.Fprintf(fg, "  %s any](t T.Tuple%d[", joinAll(", ")(extra, typesT), i)
+		for j := 0; j < i; j++ {
+			if j > 0 {
+				fmt.Fprintf(fg, ", ")
+			}
+			fmt.Fprintf(fg, "G_T%d", j+1)
+		}
+		fmt.Fprintf(fg, "])  G_TUPLE%d {\n", i)
+		fmt.Fprintf(fg, "  return A.SequenceTuple%d(\n", i)
+		// map call
+		var cio string
+		cb := generateNestedCallbacks(1, i)
+		if i > 1 {
+			cio = genericType(cb)
+		} else {
+			cio = fmt.Sprintf("G_TUPLE%d", i)
+		}
+		fmt.Fprintf(fg, "    Map[%s],\n", joinAll(", ")(A.From("G_T1", cio), extra, A.From("T1", cb)))
+		// the apply calls
+		for j := 1; j < i; j++ {
+			if j < i-1 {
+				cb := generateNestedCallbacks(j+1, i)
+				cio = genericType(cb)
+			} else {
+				cio = fmt.Sprintf("G_TUPLE%d", i)
+			}
+			fmt.Fprintf(fg, "    Ap[%s, %s, G_T%d],\n", cio, genericType(generateNestedCallbacks(j, i)), j+1)
+		}
+		// function parameters
+		fmt.Fprintf(fg, "    t)\n")
+		fmt.Fprintf(fg, "}\n")
+	}
+}
+
+func generateGenericTraverseTuple(
+	nonGenericType func(string) string,
+	genericType func(string) string,
+	extra []string,
+) func(f, fg *os.File, i int) {
+	return func(f, fg *os.File, i int) {
+		// tuple
+		tupleT := tupleType("T")(i)
+		tupleA := tupleType("A")(i)
+		// all types T
+		typesT := A.MakeBy(i, F.Flow2(
+			N.Inc[int],
+			S.Format[int]("T%d"),
+		))
+		// all types A
+		typesA := A.MakeBy(i, F.Flow2(
+			N.Inc[int],
+			S.Format[int]("A%d"),
+		))
+		// all function types
+		typesF := A.MakeBy(i, F.Flow2(
+			N.Inc[int],
+			func(j int) string {
+				return fmt.Sprintf("F%d ~func(A%d) %s", j, j, nonGenericType(fmt.Sprintf("T%d", j)))
+			},
+		))
+		// non generic version
+		fmt.Fprintf(f, "\n// TraverseTuple%d converts a [T.Tuple%d[%s]] into a [%s]\n", i, i, nonGenericType("T"), nonGenericType(tupleT))
+		fmt.Fprintf(f, "func TraverseTuple%d[%s any](", i, joinAll(", ")(typesF, extra, typesA, typesT))
+		for j := 0; j < i; j++ {
+			if j > 0 {
+				fmt.Fprintf(f, ", ")
+			}
+			fmt.Fprintf(f, "f%d F%d", j+1, j+1)
+		}
+		fmt.Fprintf(f, ") func(%s) %s {\n", tupleA, nonGenericType(tupleT))
+		fmt.Fprintf(f, "  return G.TraverseTuple%d[%s](", i, nonGenericType(tupleT))
+		for j := 0; j < i; j++ {
+			if j > 0 {
+				fmt.Fprintf(f, ", ")
+			}
+			fmt.Fprintf(f, "f%d", j+1)
+		}
+		fmt.Fprintf(f, ")\n")
+		fmt.Fprintf(f, "}\n")
+
+		// generic version
+		fmt.Fprintf(fg, "\n// TraverseTuple%d converts a [T.Tuple%d[%s]] into a [%s]\n", i, i, genericType("T"), genericType(tupleT))
+		fmt.Fprintf(fg, "func TraverseTuple%d[\n", i)
+		fmt.Fprintf(fg, "  G_TUPLE%d ~%s,\n", i, genericType(tupleT))
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(fg, "  F%d ~func(A%d) G_T%d,\n", j+1, j+1, j+1)
+		}
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(fg, "  G_T%d ~%s, \n", j+1, genericType(fmt.Sprintf("T%d", j+1)))
+		}
+		fmt.Fprintf(fg, "  %s any](", joinAll(", ")(extra, typesA, typesT))
+		for j := 0; j < i; j++ {
+			if j > 0 {
+				fmt.Fprintf(fg, ", ")
+			}
+			fmt.Fprintf(fg, "f%d F%d", j+1, j+1)
+		}
+		fmt.Fprintf(fg, ") func(%s) G_TUPLE%d {\n", tupleA, i)
+		fmt.Fprintf(fg, "  return func(t %s) G_TUPLE%d {\n", tupleA, i)
+		fmt.Fprintf(fg, "    return A.TraverseTuple%d(\n", i)
+		// map call
+		var cio string
+		cb := generateNestedCallbacks(1, i)
+		if i > 1 {
+			cio = genericType(cb)
+		} else {
+			cio = fmt.Sprintf("G_TUPLE%d", i)
+		}
+		fmt.Fprintf(fg, "    Map[%s],\n", joinAll(", ")(A.From("G_T1", cio), extra, A.From("T1", cb)))
+		// the apply calls
+		for j := 1; j < i; j++ {
+			if j < i-1 {
+				cb := generateNestedCallbacks(j+1, i)
+				cio = genericType(cb)
+			} else {
+				cio = fmt.Sprintf("G_TUPLE%d", i)
+			}
+			fmt.Fprintf(fg, "    Ap[%s, %s, G_T%d],\n", cio, genericType(generateNestedCallbacks(j, i)), j+1)
+		}
+		// function parameters
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(fg, "    f%d,\n", j+1)
+		}
+		// tuple parameter
+		fmt.Fprintf(fg, "    t)\n")
+		fmt.Fprintf(fg, "   }\n")
+		fmt.Fprintf(fg, "}\n")
+	}
+}

cli/tuple.go

@@ -361,8 +361,10 @@ func generateTupleHelpers(filename string, count int) error {
 
 	fmt.Fprintf(f, `
 import (
+	"fmt"
+	"encoding/json"
 	M "github.com/IBM/fp-go/monoid"
-	O "github.com/IBM/fp-go/ord"
+	O "github.com/IBM/fp-go/ord"	
 )
 `)
 
@@ -386,11 +388,203 @@ import (
 		generateMap(f, i)
 		// generate replicate
 		generateReplicate(f, i)
+		// generate tuple functions such as string and fmt
+		generateTupleString(f, i)
+		// generate json support
+		generateTupleMarshal(f, i)
+		// generate json support
+		generateTupleUnmarshal(f, i)
+		// generate toArray
+		generateToArray(f, i)
+		// generate fromArray
+		generateFromArray(f, i)
 	}
 
 	return nil
 }
 
+func generateTupleMarshal(f *os.File, i int) {
+	// Create the stringify version
+	fmt.Fprintf(f, "\n// MarshalJSON marshals the [Tuple%d] into a JSON array\n", i)
+	fmt.Fprintf(f, "func (t ")
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, ") MarshalJSON() ([]byte, error) {\n")
+	fmt.Fprintf(f, "  return json.Marshal([]any{")
+	// function prototypes
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "t.F%d", j)
+	}
+	fmt.Fprintf(f, "})\n")
+	fmt.Fprintf(f, "}\n")
+}
+
+func generateTupleUnmarshal(f *os.File, i int) {
+	// Create the stringify version
+	fmt.Fprintf(f, "\n// UnmarshalJSON unmarshals a JSON array into a [Tuple%d]\n", i)
+	fmt.Fprintf(f, "func (t *")
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, ") UnmarshalJSON(data []byte) error {\n")
+	fmt.Fprintf(f, "  var tmp []json.RawMessage\n")
+	fmt.Fprintf(f, "  if err := json.Unmarshal(data, &tmp); err != nil {return err}\n")
+	fmt.Fprintf(f, "  l := len(tmp)\n")
+	// unmarshal fields
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, "  if l > %d {\n", j-1)
+		fmt.Fprintf(f, "  if err := json.Unmarshal(tmp[%d], &t.F%d); err != nil {return err}\n", j-1, j)
+	}
+	fmt.Fprintf(f, "  ")
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, "}")
+	}
+	fmt.Fprintf(f, "\n  return nil\n")
+	fmt.Fprintf(f, "}\n")
+}
+
+func generateToArray(f *os.File, i int) {
+	// Create the stringify version
+	fmt.Fprintf(f, "\n// ToArray converts the [Tuple%d] into an array of type [R] using %d transformation functions from [T] to [R]\n// The inverse function is [FromArray%d]\n", i, i, i)
+	fmt.Fprintf(f, "func ToArray%d[", i)
+	// function prototypes
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "F%d ~func(T%d) R", j, j)
+	}
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ", R any](")
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "f%d F%d", j, j)
+	}
+	fmt.Fprintf(f, ") func(t ")
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, ") []R {\n")
+	fmt.Fprintf(f, "  return func(t ")
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, ") []R {\n")
+	fmt.Fprintf(f, "    return []R{\n")
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, "      f%d(t.F%d),\n", j, j)
+	}
+	fmt.Fprintf(f, "    }\n")
+	fmt.Fprintf(f, "  }\n")
+	fmt.Fprintf(f, "}\n")
+}
+
+func generateFromArray(f *os.File, i int) {
+	// Create the stringify version
+	fmt.Fprintf(f, "\n// FromArray converts an array of [R] into a [Tuple%d] using %d functions from [R] to [T]\n// The inverse function is [ToArray%d]\n", i, i, i)
+	fmt.Fprintf(f, "func FromArray%d[", i)
+	// function prototypes
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "F%d ~func(R) T%d", j, j)
+	}
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ", R any](")
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "f%d F%d", j, j)
+	}
+	fmt.Fprintf(f, ") func(r []R) ")
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, " {\n")
+	fmt.Fprintf(f, "  return func(r []R) ")
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, " {\n")
+	fmt.Fprintf(f, "    return MakeTuple%d(\n", i)
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, "      f%d(r[%d]),\n", j, j-1)
+	}
+	fmt.Fprintf(f, "    )\n")
+	fmt.Fprintf(f, "  }\n")
+	fmt.Fprintf(f, "}\n")
+}
+
+func generateTupleString(f *os.File, i int) {
+	// Create the stringify version
+	fmt.Fprintf(f, "\n// String prints some debug info for the [Tuple%d]\n", i)
+	fmt.Fprintf(f, "func (t ")
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, ") String() string {\n")
+	// convert to string
+	fmt.Fprintf(f, "  return fmt.Sprintf(\"Tuple%d[", i)
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "%s", "%T")
+	}
+	fmt.Fprintf(f, "](")
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "%s", "%v")
+	}
+	fmt.Fprintf(f, ")\", ")
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "t.F%d", j)
+	}
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, ", t.F%d", j)
+	}
+	fmt.Fprintf(f, ")\n")
+	fmt.Fprintf(f, "}\n")
+}
+
+// func generateTupleJson(f *os.File, i int) {
+// 	// Create the stringify version
+// 	fmt.Fprintf(f, "\n// MarshalJSON converts the [Tuple%d] into a JSON byte stream\n", i)
+// 	fmt.Fprintf(f, "func (t ")
+// 	writeTupleType(f, "T", i)
+// 	fmt.Fprintf(f, ") MarshalJSON() ([]byte, error) {\n")
+// 	// convert to string
+// 	fmt.Fprintf(f, "  return fmt.Sprintf(\"Tuple%d[", i)
+// 	for j := 1; j <= i; j++ {
+// 		if j > 1 {
+// 			fmt.Fprintf(f, ", ")
+// 		}
+// 		fmt.Fprintf(f, "%s", "%T")
+// 	}
+// 	fmt.Fprintf(f, "](")
+// 	for j := 1; j <= i; j++ {
+// 		if j > 1 {
+// 			fmt.Fprintf(f, ", ")
+// 		}
+// 		fmt.Fprintf(f, "%s", "%v")
+// 	}
+// 	fmt.Fprintf(f, ")\", ")
+// 	for j := 1; j <= i; j++ {
+// 		if j > 1 {
+// 			fmt.Fprintf(f, ", ")
+// 		}
+// 		fmt.Fprintf(f, "t.F%d", j)
+// 	}
+// 	for j := 1; j <= i; j++ {
+// 		fmt.Fprintf(f, ", t.F%d", j)
+// 	}
+// 	fmt.Fprintf(f, ")\n")
+// 	fmt.Fprintf(f, "}\n")
+// }
+
 func TupleCommand() *C.Command {
 	return &C.Command{
 		Name:  "tuple",

constraints/constraints.go

@@ -34,3 +34,7 @@ type Integer interface {
 type Float interface {
 	~float32 | ~float64
 }
+
+type Complex interface {
+	~complex64 | ~complex128
+}

context/readerioeither/cancel.go

@@ -19,7 +19,7 @@ import (
 	G "github.com/IBM/fp-go/context/readerioeither/generic"
 )
 
-// WithContext wraps an existing ReaderIOEither and performs a context check for cancellation before delegating
+// WithContext wraps an existing [ReaderIOEither] and performs a context check for cancellation before delegating
 func WithContext[A any](ma ReaderIOEither[A]) ReaderIOEither[A] {
 	return G.WithContext(ma)
 }

context/readerioeither/data/file.txt

@@ -0,0 +1 @@
+Carsten

context/readerioeither/eq.go

@@ -23,7 +23,7 @@ import (
 	EQ "github.com/IBM/fp-go/eq"
 )
 
-// Eq implements the equals predicate for values contained in the IOEither monad
+// Eq implements the equals predicate for values contained in the [ReaderIOEither] monad
 func Eq[A any](eq EQ.Eq[ET.Either[error, A]]) func(context.Context) EQ.Eq[ReaderIOEither[A]] {
 	return G.Eq[ReaderIOEither[A]](eq)
 }

context/readerioeither/file/file.go

@@ -48,7 +48,7 @@ func Close[C io.Closer](c C) RIOE.ReaderIOEither[any] {
 
 // ReadFile reads a file in the scope of a context
 func ReadFile(path string) RIOE.ReaderIOEither[[]byte] {
-	return RIOE.WithResource[*os.File, []byte](Open(path), Close[*os.File])(func(r *os.File) RIOE.ReaderIOEither[[]byte] {
+	return RIOE.WithResource[[]byte](Open(path), Close[*os.File])(func(r *os.File) RIOE.ReaderIOEither[[]byte] {
 		return func(ctx context.Context) IOE.IOEither[error, []byte] {
 			return IOE.MakeIO(func() ET.Either[error, []byte] {
 				return file.ReadAll(ctx, r)

context/readerioeither/gen.go

@@ -17,7 +17,7 @@ package readerioeither
 
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-21 10:22:43.4901011 +0200 CEST m=+0.009264601
+// 2023-07-28 22:48:20.012425 +0200 CEST m=+0.019517901
 
 import (
 	"context"
@@ -29,515 +29,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/reader.go

@@ -220,7 +220,7 @@ func MonadApPar[
 			fabIOE := withCancelCauseFunc(cancelSub, cfab(ctxSub))
 			faIOE := withCancelCauseFunc(cancelSub, cfa(ctxSub))
 
-			return IOE.MonadApPar[GIOA, GIOB, GIOAB](fabIOE, faIOE)()
+			return IOE.MonadApPar[GIOB, GIOAB](fabIOE, faIOE)()
 		}
 	}
 }

context/readerioeither/resource.go

@@ -20,7 +20,7 @@ import (
 )
 
 // WithResource constructs a function that creates a resource, then operates on it and then releases the resource
-func WithResource[R, A, ANY any](onCreate ReaderIOEither[R], onRelease func(R) ReaderIOEither[ANY]) func(func(R) ReaderIOEither[A]) ReaderIOEither[A] {
+func WithResource[A, R, ANY any](onCreate ReaderIOEither[R], onRelease func(R) ReaderIOEither[ANY]) func(func(R) ReaderIOEither[A]) ReaderIOEither[A] {
 	// wraps the callback functions with a context check
 	return G.WithResource[ReaderIOEither[A]](onCreate, onRelease)
 }

context/readerioeither/resource_test.go

@@ -0,0 +1,79 @@
+// 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 (
+	"context"
+	"io"
+	"os"
+
+	B "github.com/IBM/fp-go/bytes"
+	F "github.com/IBM/fp-go/function"
+	IO "github.com/IBM/fp-go/io"
+	IOE "github.com/IBM/fp-go/ioeither"
+)
+
+var (
+	openFile = F.Flow3(
+		IOE.Eitherize1(os.Open),
+		FromIOEither[*os.File],
+		ChainFirstIOK(F.Flow2(
+			(*os.File).Name,
+			IO.Logf[string]("Opened file [%s]"),
+		)),
+	)
+)
+
+func closeFile(f *os.File) ReaderIOEither[string] {
+	return F.Pipe1(
+		TryCatch(func(_ context.Context) func() (string, error) {
+			return func() (string, error) {
+				return f.Name(), f.Close()
+			}
+		}),
+		ChainFirstIOK(IO.Logf[string]("Closed file [%s]")),
+	)
+}
+
+func ExampleWithResource() {
+
+	stringReader := WithResource[string](openFile("data/file.txt"), closeFile)
+
+	rdr := stringReader(func(f *os.File) ReaderIOEither[string] {
+		return F.Pipe2(
+			TryCatch(func(_ context.Context) func() ([]byte, error) {
+				return func() ([]byte, error) {
+					return io.ReadAll(f)
+				}
+			}),
+			ChainFirstIOK(F.Flow2(
+				B.Size,
+				IO.Logf[int]("Read content of length [%d]"),
+			)),
+			Map(B.ToString),
+		)
+	})
+
+	contentIOE := F.Pipe2(
+		context.Background(),
+		rdr,
+		IOE.ChainFirstIOK[error](IO.Printf[string]("Content: %s")),
+	)
+
+	contentIOE()
+
+	// Output: Content: Carsten
+}

context/readerioeither/type.go

@@ -21,5 +21,6 @@ import (
 	RE "github.com/IBM/fp-go/readerioeither"
 )
 
-// ReaderIOEither is a specialization of the Reader monad for the typical golang scenario
+// ReaderIOEither is a specialization of the [RE.ReaderIOEither] monad for the typical golang scenario in which the
+// left value is an [error] and the context is a [context.Context]
 type ReaderIOEither[A any] RE.ReaderIOEither[context.Context, error, A]

either/array.go

@@ -0,0 +1,46 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package either
+
+import (
+	F "github.com/IBM/fp-go/function"
+	RA "github.com/IBM/fp-go/internal/array"
+)
+
+// TraverseArray transforms an array
+func TraverseArrayG[GA ~[]A, GB ~[]B, E, A, B any](f func(A) Either[E, B]) func(GA) Either[E, GB] {
+	return RA.Traverse[GA](
+		Of[E, GB],
+		Map[E, GB, func(B) GB],
+		Ap[GB, E, B],
+
+		f,
+	)
+}
+
+// TraverseArray transforms an array
+func TraverseArray[E, A, B any](f func(A) Either[E, B]) func([]A) Either[E, []B] {
+	return TraverseArrayG[[]A, []B](f)
+}
+
+func SequenceArrayG[GA ~[]A, GOA ~[]Either[E, A], E, A any](ma GOA) Either[E, GA] {
+	return TraverseArrayG[GOA, GA](F.Identity[Either[E, A]])(ma)
+}
+
+// SequenceArray converts a homogeneous sequence of either into an either of sequence
+func SequenceArray[E, A any](ma []Either[E, A]) Either[E, []A] {
+	return SequenceArrayG[[]A](ma)
+}

erasure/erasure.go

@@ -0,0 +1,51 @@
+// 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 erasure
+
+import (
+	F "github.com/IBM/fp-go/function"
+)
+
+// Erase converts a variable of type T to an any by returning a pointer to that variable
+func Erase[T any](t T) any {
+	return &t
+}
+
+// Unerase converts an erased variable back to its original value
+func Unerase[T any](t any) T {
+	return *t.(*T)
+}
+
+// Erase0 converts a type safe function into an erased function
+func Erase0[T1 any](f func() T1) func() any {
+	return F.Nullary2(f, Erase[T1])
+}
+
+// Erase1 converts a type safe function into an erased function
+func Erase1[T1, T2 any](f func(T1) T2) func(any) any {
+	return F.Flow3(
+		Unerase[T1],
+		f,
+		Erase[T2],
+	)
+}
+
+// Erase2 converts a type safe function into an erased function
+func Erase2[T1, T2, T3 any](f func(T1, T2) T3) func(any, any) any {
+	return func(t1, t2 any) any {
+		return Erase(f(Unerase[T1](t1), Unerase[T2](t2)))
+	}
+}

erasure/erasure_test.go

@@ -0,0 +1,39 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package erasure
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+)
+
+func TestEither(t *testing.T) {
+
+	e1 := F.Pipe3(
+		E.Of[error](Erase("Carsten")),
+		E.Map[error](Erase1(strings.ToUpper)),
+		E.GetOrElse(func(e error) any {
+			return Erase("Error")
+		}),
+		Unerase[string],
+	)
+
+	fmt.Println(e1)
+}

file/getters.go

@@ -0,0 +1,23 @@
+// 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"
+
+// GetName is the getter for the `Name` property of [os.File]
+func GetName(f *os.File) string {
+	return f.Name()
+}

function/binds.go

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

identity/gen.go

@@ -15,9 +15,10 @@
 
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-21 10:22:53.6381914 +0200 CEST m=+0.019961301
+// 2023-07-28 22:48:46.7920356 +0200 CEST m=+0.045177201
 package identity
 
+
 import (
 	A "github.com/IBM/fp-go/internal/apply"
 	T "github.com/IBM/fp-go/tuple"
@@ -25,495 +26,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/optiont/option.go

@@ -0,0 +1,80 @@
+// 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 optiont
+
+import (
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/apply"
+	FC "github.com/IBM/fp-go/internal/functor"
+	O "github.com/IBM/fp-go/option"
+)
+
+func Of[A, HKTA any](fof func(O.Option[A]) HKTA, a A) HKTA {
+	return F.Pipe2(a, O.Of[A], fof)
+}
+
+func None[A, HKTA any](fof func(O.Option[A]) HKTA) HKTA {
+	return F.Pipe1(O.None[A](), fof)
+}
+
+func OfF[A, HKTA, HKTEA any](fmap func(HKTA, func(A) O.Option[A]) HKTEA, fa HKTA) HKTEA {
+	return fmap(fa, O.Of[A])
+}
+
+func MonadMap[A, B, HKTFA, HKTFB any](fmap func(HKTFA, func(O.Option[A]) O.Option[B]) HKTFB, fa HKTFA, f func(A) B) HKTFB {
+	// HKTGA = Either[E, A]
+	// HKTGB = Either[E, B]
+	return FC.MonadMap(fmap, O.MonadMap[A, B], fa, f)
+}
+
+func MonadChain[A, B, HKTFA, HKTFB any](
+	fchain func(HKTFA, func(O.Option[A]) HKTFB) HKTFB,
+	fof func(O.Option[B]) HKTFB,
+	ma HKTFA,
+	f func(A) HKTFB) HKTFB {
+	// dispatch to the even more generic implementation
+	return fchain(ma, O.Fold(F.Nullary2(O.None[B], fof), f))
+}
+
+func MonadAp[A, B, HKTFAB, HKTFGAB, HKTFA, HKTFB any](
+	fap func(HKTFGAB, HKTFA) HKTFB,
+	fmap func(HKTFAB, func(O.Option[func(A) B]) func(O.Option[A]) O.Option[B]) HKTFGAB,
+	fab HKTFAB,
+	fa HKTFA) HKTFB {
+	// HKTGA  = O.Option[A]
+	// HKTGB  = O.Option[B]
+	// HKTGAB = O.Option[func(a A) B]
+	return apply.MonadAp(fap, fmap, O.MonadAp[B, A], fab, fa)
+}
+
+func MatchE[A, HKTEA, HKTB any](mchain func(HKTEA, func(O.Option[A]) HKTB) HKTB, onNone func() HKTB, onSome func(A) HKTB) func(HKTEA) HKTB {
+	return F.Bind2nd(mchain, O.Fold(onNone, onSome))
+}
+
+func FromOptionK[A, B, HKTB any](
+	fof func(O.Option[B]) HKTB,
+	f func(A) O.Option[B]) func(A) HKTB {
+	return F.Flow2(f, fof)
+}
+
+func MonadChainOptionK[A, B, HKTA, HKTB any](
+	fchain func(HKTA, func(O.Option[A]) HKTB) HKTB,
+	fof func(O.Option[B]) HKTB,
+	ma HKTA,
+	f func(A) O.Option[B],
+) HKTB {
+	return MonadChain(fchain, fof, ma, FromOptionK(fof, f))
+}

internal/utils/utils.go

@@ -22,6 +22,14 @@ import (
 
 var Upper = strings.ToUpper
 
+func Inc(i int) int {
+	return i + 1
+}
+
+func Dec(i int) int {
+	return i - 1
+}
+
 func Sum(left, right int) int {
 	return left + right
 }

io/doc.go

@@ -0,0 +1,18 @@
+// 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 io
+
+//go:generate go run .. io --count 10 --filename gen.go

io/file/file.go

@@ -0,0 +1,39 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package file
+
+import (
+	"io"
+	"os"
+
+	IO "github.com/IBM/fp-go/io"
+)
+
+// Close closes a closeable resource and ignores a potential error
+func Close[R io.Closer](r R) IO.IO[R] {
+	return IO.MakeIO[R](func() R {
+		r.Close() // #nosec: G104
+		return r
+	})
+}
+
+// Remove removes a resource and ignores a potential error
+func Remove(name string) IO.IO[string] {
+	return IO.MakeIO[string](func() string {
+		os.Remove(name) // #nosec: G104
+		return name
+	})
+}

io/gen.go

@@ -0,0 +1,390 @@
+// 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.
+
+// Code generated by go generate; DO NOT EDIT.
+// This file was generated by robots at
+// 2023-07-28 22:48:57.7378739 +0200 CEST m=+0.063371401
+package io
+
+
+import (
+	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],
+) IO[T.Tuple1[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)
+}
+
+// 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)
+}
+
+// SequenceT2 converts 2 [IO[T]] into a [IO[T.Tuple2[T1, T2]]]
+func SequenceT2[T1, T2 any](
+  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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) IO[T.Tuple3[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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}

io/generic/gen.go

@@ -0,0 +1,845 @@
+// 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.
+
+// Code generated by go generate; DO NOT EDIT.
+// This file was generated by robots at
+// 2023-07-28 22:48:57.7499229 +0200 CEST m=+0.075420401
+package generic
+
+
+import (
+	T "github.com/IBM/fp-go/tuple"
+	A "github.com/IBM/fp-go/internal/apply"
+)
+
+// SequenceT1 converts 1 [func() T] into a [func() T.Tuple1[T1]]
+func SequenceT1[
+  G_TUPLE1 ~func() T.Tuple1[T1],
+  G_T1 ~func() T1, 
+  T1 any](
+  t1 G_T1,
+)  G_TUPLE1 {
+  return A.SequenceT1(
+    Map[G_T1, G_TUPLE1, T1,  T.Tuple1[T1]],
+    t1,
+  )
+}
+
+// SequenceTuple1 converts a [T.Tuple1[func() T]] into a [func() T.Tuple1[T1]]
+func SequenceTuple1[
+  G_TUPLE1 ~func() T.Tuple1[T1],
+  G_T1 ~func() T1, 
+  T1 any](t T.Tuple1[G_T1])  G_TUPLE1 {
+  return A.SequenceTuple1(
+    Map[G_T1, G_TUPLE1, T1,  T.Tuple1[T1]],
+    t)
+}
+
+// TraverseTuple1 converts a [T.Tuple1[func() T]] into a [func() T.Tuple1[T1]]
+func TraverseTuple1[
+  G_TUPLE1 ~func() T.Tuple1[T1],
+  F1 ~func(A1) G_T1,
+  G_T1 ~func() T1, 
+  A1, T1 any](f1 F1) func(T.Tuple1[A1]) G_TUPLE1 {
+  return func(t T.Tuple1[A1]) G_TUPLE1 {
+    return A.TraverseTuple1(
+    Map[G_T1, G_TUPLE1, T1,  T.Tuple1[T1]],
+    f1,
+    t)
+   }
+}
+
+// SequenceT2 converts 2 [func() T] into a [func() T.Tuple2[T1, T2]]
+func SequenceT2[
+  G_TUPLE2 ~func() T.Tuple2[T1, T2],
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  T1, T2 any](
+  t1 G_T1,
+  t2 G_T2,
+)  G_TUPLE2 {
+  return A.SequenceT2(
+    Map[G_T1, func() func(T2) T.Tuple2[T1, T2], T1, func(T2) T.Tuple2[T1, T2]],
+    Ap[G_TUPLE2, func() func(T2) T.Tuple2[T1, T2], G_T2],
+    t1,
+    t2,
+  )
+}
+
+// SequenceTuple2 converts a [T.Tuple2[func() T]] into a [func() T.Tuple2[T1, T2]]
+func SequenceTuple2[
+  G_TUPLE2 ~func() T.Tuple2[T1, T2],
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  T1, T2 any](t T.Tuple2[G_T1, G_T2])  G_TUPLE2 {
+  return A.SequenceTuple2(
+    Map[G_T1, func() func(T2) T.Tuple2[T1, T2], T1, func(T2) T.Tuple2[T1, T2]],
+    Ap[G_TUPLE2, func() func(T2) T.Tuple2[T1, T2], G_T2],
+    t)
+}
+
+// TraverseTuple2 converts a [T.Tuple2[func() T]] into a [func() T.Tuple2[T1, T2]]
+func TraverseTuple2[
+  G_TUPLE2 ~func() T.Tuple2[T1, T2],
+  F1 ~func(A1) G_T1,
+  F2 ~func(A2) G_T2,
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  A1, A2, T1, T2 any](f1 F1, f2 F2) func(T.Tuple2[A1, A2]) G_TUPLE2 {
+  return func(t T.Tuple2[A1, A2]) G_TUPLE2 {
+    return A.TraverseTuple2(
+    Map[G_T1, func() func(T2) T.Tuple2[T1, T2], T1, func(T2) T.Tuple2[T1, T2]],
+    Ap[G_TUPLE2, func() func(T2) T.Tuple2[T1, T2], G_T2],
+    f1,
+    f2,
+    t)
+   }
+}
+
+// SequenceT3 converts 3 [func() T] into a [func() T.Tuple3[T1, T2, T3]]
+func SequenceT3[
+  G_TUPLE3 ~func() T.Tuple3[T1, T2, T3],
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  T1, T2, T3 any](
+  t1 G_T1,
+  t2 G_T2,
+  t3 G_T3,
+)  G_TUPLE3 {
+  return A.SequenceT3(
+    Map[G_T1, func() func(T2) func(T3) T.Tuple3[T1, T2, T3], T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
+    Ap[func() func(T3) T.Tuple3[T1, T2, T3], func() func(T2) func(T3) T.Tuple3[T1, T2, T3], G_T2],
+    Ap[G_TUPLE3, func() func(T3) T.Tuple3[T1, T2, T3], G_T3],
+    t1,
+    t2,
+    t3,
+  )
+}
+
+// SequenceTuple3 converts a [T.Tuple3[func() T]] into a [func() T.Tuple3[T1, T2, T3]]
+func SequenceTuple3[
+  G_TUPLE3 ~func() T.Tuple3[T1, T2, T3],
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  T1, T2, T3 any](t T.Tuple3[G_T1, G_T2, G_T3])  G_TUPLE3 {
+  return A.SequenceTuple3(
+    Map[G_T1, func() func(T2) func(T3) T.Tuple3[T1, T2, T3], T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
+    Ap[func() func(T3) T.Tuple3[T1, T2, T3], func() func(T2) func(T3) T.Tuple3[T1, T2, T3], G_T2],
+    Ap[G_TUPLE3, func() func(T3) T.Tuple3[T1, T2, T3], G_T3],
+    t)
+}
+
+// TraverseTuple3 converts a [T.Tuple3[func() T]] into a [func() T.Tuple3[T1, T2, T3]]
+func TraverseTuple3[
+  G_TUPLE3 ~func() T.Tuple3[T1, T2, T3],
+  F1 ~func(A1) G_T1,
+  F2 ~func(A2) G_T2,
+  F3 ~func(A3) G_T3,
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  A1, A2, A3, T1, T2, T3 any](f1 F1, f2 F2, f3 F3) func(T.Tuple3[A1, A2, A3]) G_TUPLE3 {
+  return func(t T.Tuple3[A1, A2, A3]) G_TUPLE3 {
+    return A.TraverseTuple3(
+    Map[G_T1, func() func(T2) func(T3) T.Tuple3[T1, T2, T3], T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
+    Ap[func() func(T3) T.Tuple3[T1, T2, T3], func() func(T2) func(T3) T.Tuple3[T1, T2, T3], G_T2],
+    Ap[G_TUPLE3, func() func(T3) T.Tuple3[T1, T2, T3], G_T3],
+    f1,
+    f2,
+    f3,
+    t)
+   }
+}
+
+// SequenceT4 converts 4 [func() T] into a [func() T.Tuple4[T1, T2, T3, T4]]
+func SequenceT4[
+  G_TUPLE4 ~func() T.Tuple4[T1, T2, T3, T4],
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  T1, T2, T3, T4 any](
+  t1 G_T1,
+  t2 G_T2,
+  t3 G_T3,
+  t4 G_T4,
+)  G_TUPLE4 {
+  return A.SequenceT4(
+    Map[G_T1, func() func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
+    Ap[func() func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], func() func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], G_T2],
+    Ap[func() func(T4) T.Tuple4[T1, T2, T3, T4], func() func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], G_T3],
+    Ap[G_TUPLE4, func() func(T4) T.Tuple4[T1, T2, T3, T4], G_T4],
+    t1,
+    t2,
+    t3,
+    t4,
+  )
+}
+
+// SequenceTuple4 converts a [T.Tuple4[func() T]] into a [func() T.Tuple4[T1, T2, T3, T4]]
+func SequenceTuple4[
+  G_TUPLE4 ~func() T.Tuple4[T1, T2, T3, T4],
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  T1, T2, T3, T4 any](t T.Tuple4[G_T1, G_T2, G_T3, G_T4])  G_TUPLE4 {
+  return A.SequenceTuple4(
+    Map[G_T1, func() func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
+    Ap[func() func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], func() func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], G_T2],
+    Ap[func() func(T4) T.Tuple4[T1, T2, T3, T4], func() func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], G_T3],
+    Ap[G_TUPLE4, func() func(T4) T.Tuple4[T1, T2, T3, T4], G_T4],
+    t)
+}
+
+// TraverseTuple4 converts a [T.Tuple4[func() T]] into a [func() T.Tuple4[T1, T2, T3, T4]]
+func TraverseTuple4[
+  G_TUPLE4 ~func() T.Tuple4[T1, T2, T3, T4],
+  F1 ~func(A1) G_T1,
+  F2 ~func(A2) G_T2,
+  F3 ~func(A3) G_T3,
+  F4 ~func(A4) G_T4,
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() 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]) G_TUPLE4 {
+  return func(t T.Tuple4[A1, A2, A3, A4]) G_TUPLE4 {
+    return A.TraverseTuple4(
+    Map[G_T1, func() func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
+    Ap[func() func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], func() func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], G_T2],
+    Ap[func() func(T4) T.Tuple4[T1, T2, T3, T4], func() func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], G_T3],
+    Ap[G_TUPLE4, func() func(T4) T.Tuple4[T1, T2, T3, T4], G_T4],
+    f1,
+    f2,
+    f3,
+    f4,
+    t)
+   }
+}
+
+// SequenceT5 converts 5 [func() T] into a [func() T.Tuple5[T1, T2, T3, T4, T5]]
+func SequenceT5[
+  G_TUPLE5 ~func() T.Tuple5[T1, T2, T3, T4, T5],
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  G_T5 ~func() T5, 
+  T1, T2, T3, T4, T5 any](
+  t1 G_T1,
+  t2 G_T2,
+  t3 G_T3,
+  t4 G_T4,
+  t5 G_T5,
+)  G_TUPLE5 {
+  return A.SequenceT5(
+    Map[G_T1, func() func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
+    Ap[func() func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], func() func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], G_T2],
+    Ap[func() func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], func() func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], G_T3],
+    Ap[func() func(T5) T.Tuple5[T1, T2, T3, T4, T5], func() func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], G_T4],
+    Ap[G_TUPLE5, func() func(T5) T.Tuple5[T1, T2, T3, T4, T5], G_T5],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+  )
+}
+
+// SequenceTuple5 converts a [T.Tuple5[func() T]] into a [func() T.Tuple5[T1, T2, T3, T4, T5]]
+func SequenceTuple5[
+  G_TUPLE5 ~func() T.Tuple5[T1, T2, T3, T4, T5],
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  G_T5 ~func() T5, 
+  T1, T2, T3, T4, T5 any](t T.Tuple5[G_T1, G_T2, G_T3, G_T4, G_T5])  G_TUPLE5 {
+  return A.SequenceTuple5(
+    Map[G_T1, func() func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
+    Ap[func() func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], func() func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], G_T2],
+    Ap[func() func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], func() func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], G_T3],
+    Ap[func() func(T5) T.Tuple5[T1, T2, T3, T4, T5], func() func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], G_T4],
+    Ap[G_TUPLE5, func() func(T5) T.Tuple5[T1, T2, T3, T4, T5], G_T5],
+    t)
+}
+
+// TraverseTuple5 converts a [T.Tuple5[func() T]] into a [func() T.Tuple5[T1, T2, T3, T4, T5]]
+func TraverseTuple5[
+  G_TUPLE5 ~func() T.Tuple5[T1, T2, T3, T4, T5],
+  F1 ~func(A1) G_T1,
+  F2 ~func(A2) G_T2,
+  F3 ~func(A3) G_T3,
+  F4 ~func(A4) G_T4,
+  F5 ~func(A5) G_T5,
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  G_T5 ~func() 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]) G_TUPLE5 {
+  return func(t T.Tuple5[A1, A2, A3, A4, A5]) G_TUPLE5 {
+    return A.TraverseTuple5(
+    Map[G_T1, func() func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
+    Ap[func() func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], func() func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], G_T2],
+    Ap[func() func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], func() func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], G_T3],
+    Ap[func() func(T5) T.Tuple5[T1, T2, T3, T4, T5], func() func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], G_T4],
+    Ap[G_TUPLE5, func() func(T5) T.Tuple5[T1, T2, T3, T4, T5], G_T5],
+    f1,
+    f2,
+    f3,
+    f4,
+    f5,
+    t)
+   }
+}
+
+// SequenceT6 converts 6 [func() T] into a [func() T.Tuple6[T1, T2, T3, T4, T5, T6]]
+func SequenceT6[
+  G_TUPLE6 ~func() T.Tuple6[T1, T2, T3, T4, T5, T6],
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  G_T5 ~func() T5, 
+  G_T6 ~func() T6, 
+  T1, T2, T3, T4, T5, T6 any](
+  t1 G_T1,
+  t2 G_T2,
+  t3 G_T3,
+  t4 G_T4,
+  t5 G_T5,
+  t6 G_T6,
+)  G_TUPLE6 {
+  return A.SequenceT6(
+    Map[G_T1, func() func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
+    Ap[func() func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], func() func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], G_T2],
+    Ap[func() func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], func() func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], G_T3],
+    Ap[func() func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], func() func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], G_T4],
+    Ap[func() func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], func() func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], G_T5],
+    Ap[G_TUPLE6, func() func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], G_T6],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+  )
+}
+
+// SequenceTuple6 converts a [T.Tuple6[func() T]] into a [func() T.Tuple6[T1, T2, T3, T4, T5, T6]]
+func SequenceTuple6[
+  G_TUPLE6 ~func() T.Tuple6[T1, T2, T3, T4, T5, T6],
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  G_T5 ~func() T5, 
+  G_T6 ~func() T6, 
+  T1, T2, T3, T4, T5, T6 any](t T.Tuple6[G_T1, G_T2, G_T3, G_T4, G_T5, G_T6])  G_TUPLE6 {
+  return A.SequenceTuple6(
+    Map[G_T1, func() func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
+    Ap[func() func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], func() func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], G_T2],
+    Ap[func() func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], func() func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], G_T3],
+    Ap[func() func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], func() func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], G_T4],
+    Ap[func() func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], func() func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], G_T5],
+    Ap[G_TUPLE6, func() func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], G_T6],
+    t)
+}
+
+// TraverseTuple6 converts a [T.Tuple6[func() T]] into a [func() T.Tuple6[T1, T2, T3, T4, T5, T6]]
+func TraverseTuple6[
+  G_TUPLE6 ~func() T.Tuple6[T1, T2, T3, T4, T5, T6],
+  F1 ~func(A1) G_T1,
+  F2 ~func(A2) G_T2,
+  F3 ~func(A3) G_T3,
+  F4 ~func(A4) G_T4,
+  F5 ~func(A5) G_T5,
+  F6 ~func(A6) G_T6,
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  G_T5 ~func() T5, 
+  G_T6 ~func() 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]) G_TUPLE6 {
+  return func(t T.Tuple6[A1, A2, A3, A4, A5, A6]) G_TUPLE6 {
+    return A.TraverseTuple6(
+    Map[G_T1, func() func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
+    Ap[func() func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], func() func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], G_T2],
+    Ap[func() func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], func() func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], G_T3],
+    Ap[func() func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], func() func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], G_T4],
+    Ap[func() func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], func() func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], G_T5],
+    Ap[G_TUPLE6, func() func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], G_T6],
+    f1,
+    f2,
+    f3,
+    f4,
+    f5,
+    f6,
+    t)
+   }
+}
+
+// SequenceT7 converts 7 [func() T] into a [func() T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]
+func SequenceT7[
+  G_TUPLE7 ~func() T.Tuple7[T1, T2, T3, T4, T5, T6, T7],
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  G_T5 ~func() T5, 
+  G_T6 ~func() T6, 
+  G_T7 ~func() T7, 
+  T1, T2, T3, T4, T5, T6, T7 any](
+  t1 G_T1,
+  t2 G_T2,
+  t3 G_T3,
+  t4 G_T4,
+  t5 G_T5,
+  t6 G_T6,
+  t7 G_T7,
+)  G_TUPLE7 {
+  return A.SequenceT7(
+    Map[G_T1, func() func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+    Ap[func() func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], func() func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], G_T2],
+    Ap[func() func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], func() func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], G_T3],
+    Ap[func() func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], func() func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], G_T4],
+    Ap[func() func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], func() func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], G_T5],
+    Ap[func() func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], func() func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], G_T6],
+    Ap[G_TUPLE7, func() func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], G_T7],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+  )
+}
+
+// SequenceTuple7 converts a [T.Tuple7[func() T]] into a [func() T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]
+func SequenceTuple7[
+  G_TUPLE7 ~func() T.Tuple7[T1, T2, T3, T4, T5, T6, T7],
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  G_T5 ~func() T5, 
+  G_T6 ~func() T6, 
+  G_T7 ~func() T7, 
+  T1, T2, T3, T4, T5, T6, T7 any](t T.Tuple7[G_T1, G_T2, G_T3, G_T4, G_T5, G_T6, G_T7])  G_TUPLE7 {
+  return A.SequenceTuple7(
+    Map[G_T1, func() func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+    Ap[func() func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], func() func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], G_T2],
+    Ap[func() func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], func() func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], G_T3],
+    Ap[func() func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], func() func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], G_T4],
+    Ap[func() func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], func() func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], G_T5],
+    Ap[func() func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], func() func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], G_T6],
+    Ap[G_TUPLE7, func() func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], G_T7],
+    t)
+}
+
+// TraverseTuple7 converts a [T.Tuple7[func() T]] into a [func() T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]
+func TraverseTuple7[
+  G_TUPLE7 ~func() T.Tuple7[T1, T2, T3, T4, T5, T6, T7],
+  F1 ~func(A1) G_T1,
+  F2 ~func(A2) G_T2,
+  F3 ~func(A3) G_T3,
+  F4 ~func(A4) G_T4,
+  F5 ~func(A5) G_T5,
+  F6 ~func(A6) G_T6,
+  F7 ~func(A7) G_T7,
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  G_T5 ~func() T5, 
+  G_T6 ~func() T6, 
+  G_T7 ~func() 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]) G_TUPLE7 {
+  return func(t T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) G_TUPLE7 {
+    return A.TraverseTuple7(
+    Map[G_T1, func() func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+    Ap[func() func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], func() func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], G_T2],
+    Ap[func() func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], func() func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], G_T3],
+    Ap[func() func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], func() func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], G_T4],
+    Ap[func() func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], func() func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], G_T5],
+    Ap[func() func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], func() func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], G_T6],
+    Ap[G_TUPLE7, func() func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], G_T7],
+    f1,
+    f2,
+    f3,
+    f4,
+    f5,
+    f6,
+    f7,
+    t)
+   }
+}
+
+// SequenceT8 converts 8 [func() T] into a [func() T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]
+func SequenceT8[
+  G_TUPLE8 ~func() T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8],
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  G_T5 ~func() T5, 
+  G_T6 ~func() T6, 
+  G_T7 ~func() T7, 
+  G_T8 ~func() T8, 
+  T1, T2, T3, T4, T5, T6, T7, T8 any](
+  t1 G_T1,
+  t2 G_T2,
+  t3 G_T3,
+  t4 G_T4,
+  t5 G_T5,
+  t6 G_T6,
+  t7 G_T7,
+  t8 G_T8,
+)  G_TUPLE8 {
+  return A.SequenceT8(
+    Map[G_T1, func() func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], 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() func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], func() func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T2],
+    Ap[func() func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], func() func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T3],
+    Ap[func() func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], func() func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T4],
+    Ap[func() func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], func() func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T5],
+    Ap[func() func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], func() func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T6],
+    Ap[func() func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], func() func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T7],
+    Ap[G_TUPLE8, func() func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T8],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+    t8,
+  )
+}
+
+// SequenceTuple8 converts a [T.Tuple8[func() T]] into a [func() T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]
+func SequenceTuple8[
+  G_TUPLE8 ~func() T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8],
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  G_T5 ~func() T5, 
+  G_T6 ~func() T6, 
+  G_T7 ~func() T7, 
+  G_T8 ~func() T8, 
+  T1, T2, T3, T4, T5, T6, T7, T8 any](t T.Tuple8[G_T1, G_T2, G_T3, G_T4, G_T5, G_T6, G_T7, G_T8])  G_TUPLE8 {
+  return A.SequenceTuple8(
+    Map[G_T1, func() func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], 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() func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], func() func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T2],
+    Ap[func() func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], func() func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T3],
+    Ap[func() func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], func() func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T4],
+    Ap[func() func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], func() func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T5],
+    Ap[func() func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], func() func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T6],
+    Ap[func() func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], func() func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T7],
+    Ap[G_TUPLE8, func() func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T8],
+    t)
+}
+
+// TraverseTuple8 converts a [T.Tuple8[func() T]] into a [func() T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]
+func TraverseTuple8[
+  G_TUPLE8 ~func() T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8],
+  F1 ~func(A1) G_T1,
+  F2 ~func(A2) G_T2,
+  F3 ~func(A3) G_T3,
+  F4 ~func(A4) G_T4,
+  F5 ~func(A5) G_T5,
+  F6 ~func(A6) G_T6,
+  F7 ~func(A7) G_T7,
+  F8 ~func(A8) G_T8,
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  G_T5 ~func() T5, 
+  G_T6 ~func() T6, 
+  G_T7 ~func() T7, 
+  G_T8 ~func() 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]) G_TUPLE8 {
+  return func(t T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) G_TUPLE8 {
+    return A.TraverseTuple8(
+    Map[G_T1, func() func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], 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() func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], func() func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T2],
+    Ap[func() func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], func() func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T3],
+    Ap[func() func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], func() func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T4],
+    Ap[func() func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], func() func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T5],
+    Ap[func() func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], func() func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T6],
+    Ap[func() func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], func() func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T7],
+    Ap[G_TUPLE8, func() func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], G_T8],
+    f1,
+    f2,
+    f3,
+    f4,
+    f5,
+    f6,
+    f7,
+    f8,
+    t)
+   }
+}
+
+// SequenceT9 converts 9 [func() T] into a [func() T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]
+func SequenceT9[
+  G_TUPLE9 ~func() T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9],
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  G_T5 ~func() T5, 
+  G_T6 ~func() T6, 
+  G_T7 ~func() T7, 
+  G_T8 ~func() T8, 
+  G_T9 ~func() T9, 
+  T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+  t1 G_T1,
+  t2 G_T2,
+  t3 G_T3,
+  t4 G_T4,
+  t5 G_T5,
+  t6 G_T6,
+  t7 G_T7,
+  t8 G_T8,
+  t9 G_T9,
+)  G_TUPLE9 {
+  return A.SequenceT9(
+    Map[G_T1, func() 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], 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() 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], func() 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], G_T2],
+    Ap[func() func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], func() 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], G_T3],
+    Ap[func() func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], func() func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], G_T4],
+    Ap[func() func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], func() func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], G_T5],
+    Ap[func() func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], func() func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], G_T6],
+    Ap[func() func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], func() func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], G_T7],
+    Ap[func() func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], func() func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], G_T8],
+    Ap[G_TUPLE9, func() func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], G_T9],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+    t8,
+    t9,
+  )
+}
+
+// SequenceTuple9 converts a [T.Tuple9[func() T]] into a [func() T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]
+func SequenceTuple9[
+  G_TUPLE9 ~func() T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9],
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  G_T5 ~func() T5, 
+  G_T6 ~func() T6, 
+  G_T7 ~func() T7, 
+  G_T8 ~func() T8, 
+  G_T9 ~func() T9, 
+  T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t T.Tuple9[G_T1, G_T2, G_T3, G_T4, G_T5, G_T6, G_T7, G_T8, G_T9])  G_TUPLE9 {
+  return A.SequenceTuple9(
+    Map[G_T1, func() 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], 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() 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], func() 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], G_T2],
+    Ap[func() func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], func() 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], G_T3],
+    Ap[func() func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], func() func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], G_T4],
+    Ap[func() func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], func() func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], G_T5],
+    Ap[func() func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], func() func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], G_T6],
+    Ap[func() func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], func() func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], G_T7],
+    Ap[func() func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], func() func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], G_T8],
+    Ap[G_TUPLE9, func() func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], G_T9],
+    t)
+}
+
+// TraverseTuple9 converts a [T.Tuple9[func() T]] into a [func() T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]
+func TraverseTuple9[
+  G_TUPLE9 ~func() T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9],
+  F1 ~func(A1) G_T1,
+  F2 ~func(A2) G_T2,
+  F3 ~func(A3) G_T3,
+  F4 ~func(A4) G_T4,
+  F5 ~func(A5) G_T5,
+  F6 ~func(A6) G_T6,
+  F7 ~func(A7) G_T7,
+  F8 ~func(A8) G_T8,
+  F9 ~func(A9) G_T9,
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  G_T5 ~func() T5, 
+  G_T6 ~func() T6, 
+  G_T7 ~func() T7, 
+  G_T8 ~func() T8, 
+  G_T9 ~func() 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]) G_TUPLE9 {
+  return func(t T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) G_TUPLE9 {
+    return A.TraverseTuple9(
+    Map[G_T1, func() 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], 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() 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], func() 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], G_T2],
+    Ap[func() func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], func() 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], G_T3],
+    Ap[func() func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], func() func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], G_T4],
+    Ap[func() func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], func() func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], G_T5],
+    Ap[func() func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], func() func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], G_T6],
+    Ap[func() func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], func() func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], G_T7],
+    Ap[func() func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], func() func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], G_T8],
+    Ap[G_TUPLE9, func() func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], G_T9],
+    f1,
+    f2,
+    f3,
+    f4,
+    f5,
+    f6,
+    f7,
+    f8,
+    f9,
+    t)
+   }
+}
+
+// SequenceT10 converts 10 [func() T] into a [func() T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]
+func SequenceT10[
+  G_TUPLE10 ~func() T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10],
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  G_T5 ~func() T5, 
+  G_T6 ~func() T6, 
+  G_T7 ~func() T7, 
+  G_T8 ~func() T8, 
+  G_T9 ~func() T9, 
+  G_T10 ~func() T10, 
+  T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](
+  t1 G_T1,
+  t2 G_T2,
+  t3 G_T3,
+  t4 G_T4,
+  t5 G_T5,
+  t6 G_T6,
+  t7 G_T7,
+  t8 G_T8,
+  t9 G_T9,
+  t10 G_T10,
+)  G_TUPLE10 {
+  return A.SequenceT10(
+    Map[G_T1, func() 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], 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() 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], func() 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], G_T2],
+    Ap[func() 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], func() 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], G_T3],
+    Ap[func() func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], func() 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], G_T4],
+    Ap[func() func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], func() func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], G_T5],
+    Ap[func() func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], func() func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], G_T6],
+    Ap[func() func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], func() func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], G_T7],
+    Ap[func() func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], func() func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], G_T8],
+    Ap[func() func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], func() func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], G_T9],
+    Ap[G_TUPLE10, func() func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], G_T10],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+    t8,
+    t9,
+    t10,
+  )
+}
+
+// SequenceTuple10 converts a [T.Tuple10[func() T]] into a [func() T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]
+func SequenceTuple10[
+  G_TUPLE10 ~func() T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10],
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  G_T5 ~func() T5, 
+  G_T6 ~func() T6, 
+  G_T7 ~func() T7, 
+  G_T8 ~func() T8, 
+  G_T9 ~func() T9, 
+  G_T10 ~func() T10, 
+  T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t T.Tuple10[G_T1, G_T2, G_T3, G_T4, G_T5, G_T6, G_T7, G_T8, G_T9, G_T10])  G_TUPLE10 {
+  return A.SequenceTuple10(
+    Map[G_T1, func() 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], 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() 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], func() 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], G_T2],
+    Ap[func() 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], func() 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], G_T3],
+    Ap[func() func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], func() 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], G_T4],
+    Ap[func() func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], func() func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], G_T5],
+    Ap[func() func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], func() func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], G_T6],
+    Ap[func() func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], func() func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], G_T7],
+    Ap[func() func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], func() func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], G_T8],
+    Ap[func() func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], func() func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], G_T9],
+    Ap[G_TUPLE10, func() func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], G_T10],
+    t)
+}
+
+// TraverseTuple10 converts a [T.Tuple10[func() T]] into a [func() T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]
+func TraverseTuple10[
+  G_TUPLE10 ~func() T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10],
+  F1 ~func(A1) G_T1,
+  F2 ~func(A2) G_T2,
+  F3 ~func(A3) G_T3,
+  F4 ~func(A4) G_T4,
+  F5 ~func(A5) G_T5,
+  F6 ~func(A6) G_T6,
+  F7 ~func(A7) G_T7,
+  F8 ~func(A8) G_T8,
+  F9 ~func(A9) G_T9,
+  F10 ~func(A10) G_T10,
+  G_T1 ~func() T1, 
+  G_T2 ~func() T2, 
+  G_T3 ~func() T3, 
+  G_T4 ~func() T4, 
+  G_T5 ~func() T5, 
+  G_T6 ~func() T6, 
+  G_T7 ~func() T7, 
+  G_T8 ~func() T8, 
+  G_T9 ~func() T9, 
+  G_T10 ~func() 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]) G_TUPLE10 {
+  return func(t T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) G_TUPLE10 {
+    return A.TraverseTuple10(
+    Map[G_T1, func() 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], 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() 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], func() 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], G_T2],
+    Ap[func() 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], func() 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], G_T3],
+    Ap[func() func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], func() 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], G_T4],
+    Ap[func() func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], func() func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], G_T5],
+    Ap[func() func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], func() func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], G_T6],
+    Ap[func() func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], func() func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], G_T7],
+    Ap[func() func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], func() func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], G_T8],
+    Ap[func() func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], func() func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], G_T9],
+    Ap[G_TUPLE10, func() func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], G_T10],
+    f1,
+    f2,
+    f3,
+    f4,
+    f5,
+    f6,
+    f7,
+    f8,
+    f9,
+    f10,
+    t)
+   }
+}

io/generic/logging.go

@@ -16,6 +16,7 @@
 package generic
 
 import (
+	"fmt"
 	"log"
 
 	Logging "github.com/IBM/fp-go/logging"
@@ -39,3 +40,11 @@ func Logf[GA ~func() any, A any](prefix string) func(A) GA {
 		})
 	}
 }
+
+func Printf[GA ~func() any, A any](prefix string) func(A) GA {
+	return func(a A) GA {
+		return FromImpure[GA](func() {
+			fmt.Printf(prefix, a)
+		})
+	}
+}

io/generic/sequence.go

@@ -1,60 +0,0 @@
-// 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 (
-	"github.com/IBM/fp-go/internal/apply"
-	T "github.com/IBM/fp-go/tuple"
-)
-
-// SequenceT converts n inputs of higher kinded types into a higher kinded types of n strongly typed values, represented as a tuple
-
-func SequenceT1[GA ~func() A, GTA ~func() T.Tuple1[A], A any](a GA) GTA {
-	return apply.SequenceT1(
-		Map[GA, GTA, A, T.Tuple1[A]],
-		a,
-	)
-}
-
-func SequenceT2[GA ~func() A, GB ~func() B, GTAB ~func() T.Tuple2[A, B], A, B any](a GA, b GB) GTAB {
-	return apply.SequenceT2(
-		Map[GA, func() func(B) T.Tuple2[A, B], A, func(B) T.Tuple2[A, B]],
-		Ap[GTAB, func() func(B) T.Tuple2[A, B], GB],
-
-		a, b,
-	)
-}
-
-func SequenceT3[GA ~func() A, GB ~func() B, GC ~func() C, GTABC ~func() T.Tuple3[A, B, C], A, B, C any](a GA, b GB, c GC) GTABC {
-	return apply.SequenceT3(
-		Map[GA, func() func(B) func(C) T.Tuple3[A, B, C], A, func(B) func(C) T.Tuple3[A, B, C]],
-		Ap[func() func(C) T.Tuple3[A, B, C], func() func(B) func(C) T.Tuple3[A, B, C], GB],
-		Ap[GTABC, func() func(C) T.Tuple3[A, B, C], GC],
-
-		a, b, c,
-	)
-}
-
-func SequenceT4[GA ~func() A, GB ~func() B, GC ~func() C, GD ~func() D, GTABCD ~func() T.Tuple4[A, B, C, D], A, B, C, D any](a GA, b GB, c GC, d GD) GTABCD {
-	return apply.SequenceT4(
-		Map[GA, func() func(B) func(C) func(D) T.Tuple4[A, B, C, D], A, func(B) func(C) func(D) T.Tuple4[A, B, C, D]],
-		Ap[func() func(C) func(D) T.Tuple4[A, B, C, D], func() func(B) func(C) func(D) T.Tuple4[A, B, C, D], GB],
-		Ap[func() func(D) T.Tuple4[A, B, C, D], func() func(C) func(D) T.Tuple4[A, B, C, D], GC],
-		Ap[GTABCD, func() func(D) T.Tuple4[A, B, C, D], GD],
-
-		a, b, c, d,
-	)
-}

io/logging.go

@@ -31,3 +31,9 @@ func Logger[A any](loggers ...*log.Logger) func(string) func(A) IO[any] {
 func Logf[A any](prefix string) func(A) IO[any] {
 	return G.Logf[IO[any], A](prefix)
 }
+
+// Printf constructs a printer function that can be used with ChainXXXIOK
+// the string prefix contains the format string for the log value
+func Printf[A any](prefix string) func(A) IO[any] {
+	return G.Printf[IO[any], A](prefix)
+}

ioeither/ap.go

@@ -20,21 +20,21 @@ import (
 )
 
 // MonadApFirst combines two effectful actions, keeping only the result of the first.
-func MonadApFirst[E, A, B any](first IOEither[E, A], second IOEither[E, B]) IOEither[E, A] {
+func MonadApFirst[A, E, B any](first IOEither[E, A], second IOEither[E, B]) IOEither[E, A] {
 	return G.MonadApFirst[IOEither[E, A], IOEither[E, B], IOEither[E, func(B) A]](first, second)
 }
 
 // ApFirst combines two effectful actions, keeping only the result of the first.
-func ApFirst[E, A, B any](second IOEither[E, B]) func(IOEither[E, A]) IOEither[E, A] {
+func ApFirst[A, E, B any](second IOEither[E, B]) func(IOEither[E, A]) IOEither[E, A] {
 	return G.ApFirst[IOEither[E, A], IOEither[E, B], IOEither[E, func(B) A]](second)
 }
 
 // MonadApSecond combines two effectful actions, keeping only the result of the second.
-func MonadApSecond[E, A, B any](first IOEither[E, A], second IOEither[E, B]) IOEither[E, B] {
+func MonadApSecond[A, E, B any](first IOEither[E, A], second IOEither[E, B]) IOEither[E, B] {
 	return G.MonadApSecond[IOEither[E, A], IOEither[E, B], IOEither[E, func(B) B]](first, second)
 }
 
 // ApSecond combines two effectful actions, keeping only the result of the second.
-func ApSecond[E, A, B any](second IOEither[E, B]) func(IOEither[E, A]) IOEither[E, B] {
+func ApSecond[A, E, B any](second IOEither[E, B]) func(IOEither[E, A]) IOEither[E, B] {
 	return G.ApSecond[IOEither[E, A], IOEither[E, B], IOEither[E, func(B) B]](second)
 }

ioeither/doc.go

@@ -0,0 +1,18 @@
+// 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
+
+//go:generate go run .. ioeither --count 10 --filename gen.go

ioeither/file/close.go

@@ -21,6 +21,7 @@ import (
 	IOE "github.com/IBM/fp-go/ioeither"
 )
 
+// 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()

ioeither/file/file.go

@@ -24,14 +24,24 @@ import (
 var (
 	// Open opens a file for reading
 	Open = IOE.Eitherize1(os.Open)
+	// Create opens a file for writing
+	Create = IOE.Eitherize1(os.Create)
 	// ReadFile reads the context of a file
 	ReadFile = IOE.Eitherize1(os.ReadFile)
-	// WriteFile writes a data blob to a file
-	WriteFile = func(dstName string, perm os.FileMode) func([]byte) IOE.IOEither[error, []byte] {
-		return func(data []byte) IOE.IOEither[error, []byte] {
-			return IOE.TryCatchError(func() ([]byte, error) {
-				return data, os.WriteFile(dstName, data, perm)
-			})
-		}
-	}
 )
+
+// WriteFile writes a data blob to a file
+func WriteFile(dstName string, perm os.FileMode) func([]byte) IOE.IOEither[error, []byte] {
+	return func(data []byte) IOE.IOEither[error, []byte] {
+		return IOE.TryCatchError(func() ([]byte, error) {
+			return data, os.WriteFile(dstName, data, perm)
+		})
+	}
+}
+
+// Remove removes a file by name
+func Remove(name string) IOE.IOEither[error, string] {
+	return IOE.TryCatchError(func() (string, error) {
+		return name, os.Remove(name)
+	})
+}

ioeither/file/readall.go

@@ -29,7 +29,7 @@ func onReadAll[R io.Reader](r R) IOE.IOEither[error, []byte] {
 
 // ReadAll uses a generator function to create a stream, reads it and closes it
 func ReadAll[R io.ReadCloser](acquire IOE.IOEither[error, R]) IOE.IOEither[error, []byte] {
-	return IOE.WithResource[error, R, []byte](
+	return IOE.WithResource[[]byte](
 		acquire,
 		onClose[R])(
 		onReadAll[R],

ioeither/file/tempfile.go

@@ -0,0 +1,45 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package file
+
+import (
+	"os"
+
+	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"
+	IOE "github.com/IBM/fp-go/ioeither"
+)
+
+var (
+	// CreateTemp created a temp file with proper parametrization
+	CreateTemp = IOE.Eitherize2(os.CreateTemp)
+	// onCreateTempFile creates a temp file with sensible defaults
+	onCreateTempFile = CreateTemp("", "*")
+	// destroy handler
+	onReleaseTempFile = F.Flow4(
+		IOF.Close[*os.File],
+		IO.Map(FL.GetName),
+		IOE.FromIO[error, string],
+		IOE.Chain(Remove),
+	)
+)
+
+// 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) IOE.IOEither[error, A]) IOE.IOEither[error, A] {
+	return IOE.WithResource[A](onCreateTempFile, onReleaseTempFile)(f)
+}

ioeither/file/tempfile_test.go

@@ -0,0 +1,46 @@
+// 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"
+	"testing"
+
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	IOE "github.com/IBM/fp-go/ioeither"
+	"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())
+}
+
+func TestWithTempFileOnClosedFile(t *testing.T) {
+
+	res := WithTempFile(func(f *os.File) IOE.IOEither[error, []byte] {
+		return F.Pipe2(
+			f,
+			onWriteAll[*os.File]([]byte("Carsten")),
+			IOE.ChainFirst(F.Constant1[[]byte](onClose(f))),
+		)
+	})
+
+	assert.Equal(t, E.Of[error]([]byte("Carsten")), res())
+}

ioeither/file/write.go

@@ -34,7 +34,7 @@ func onWriteAll[W io.Writer](data []byte) func(w W) IOE.IOEither[error, []byte]
 func WriteAll[W io.WriteCloser](data []byte) func(acquire IOE.IOEither[error, W]) IOE.IOEither[error, []byte] {
 	onWrite := onWriteAll[W](data)
 	return func(onCreate IOE.IOEither[error, W]) IOE.IOEither[error, []byte] {
-		return IOE.WithResource[error, W, []byte](
+		return IOE.WithResource[[]byte](
 			onCreate,
 			onClose[W])(
 			onWrite,
@@ -43,8 +43,8 @@ func WriteAll[W io.WriteCloser](data []byte) func(acquire IOE.IOEither[error, W]
 }
 
 // Write uses a generator function to create a stream, writes data to it and closes it
-func Write[W io.WriteCloser, R any](acquire IOE.IOEither[error, W]) func(use func(W) IOE.IOEither[error, R]) IOE.IOEither[error, R] {
-	return IOE.WithResource[error, W, R](
+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])
 }

ioeither/gen.go

@@ -0,0 +1,500 @@
+// 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.
+
+// Code generated by go generate; DO NOT EDIT.
+// This file was generated by robots at
+// 2023-07-28 22:49:00.7618943 +0200 CEST m=+0.065441701
+package ioeither
+
+
+import (
+	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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// SequenceT1 converts 1 [IOEither[E, T]] into a [IOEither[E, T.Tuple1[T1]]]
+func SequenceT1[E, T1 any](
+  t1 IOEither[E, T1],
+) IOEither[E, T.Tuple1[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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) IOEither[E, T.Tuple2[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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}

ioeither/generic/ap.go

@@ -23,7 +23,7 @@ import (
 // MonadApFirst combines two effectful actions, keeping only the result of the first.
 func MonadApFirst[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GBA ~func() ET.Either[E, func(B) A], E, A, B any](first GA, second GB) GA {
 	return G.MonadApFirst(
-		MonadAp[GB, GA, GBA, E, B, A],
+		MonadAp[GA, GBA, GB],
 		MonadMap[GA, GBA, E, A, func(B) A],
 
 		first,
@@ -34,7 +34,7 @@ func MonadApFirst[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GBA ~f
 // ApFirst combines two effectful actions, keeping only the result of the first.
 func ApFirst[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GBA ~func() ET.Either[E, func(B) A], E, A, B any](second GB) func(GA) GA {
 	return G.ApFirst(
-		MonadAp[GB, GA, GBA, E, B, A],
+		MonadAp[GA, GBA, GB],
 		MonadMap[GA, GBA, E, A, func(B) A],
 
 		second,
@@ -44,7 +44,7 @@ func ApFirst[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GBA ~func()
 // MonadApSecond combines two effectful actions, keeping only the result of the second.
 func MonadApSecond[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GBB ~func() ET.Either[E, func(B) B], E, A, B any](first GA, second GB) GB {
 	return G.MonadApSecond(
-		MonadAp[GB, GB, GBB, E, B, B],
+		MonadAp[GB, GBB, GB],
 		MonadMap[GA, GBB, E, A, func(B) B],
 
 		first,
@@ -55,7 +55,7 @@ func MonadApSecond[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GBB ~
 // ApSecond combines two effectful actions, keeping only the result of the second.
 func ApSecond[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GBB ~func() ET.Either[E, func(B) B], E, A, B any](second GB) func(GA) GB {
 	return G.ApSecond(
-		MonadAp[GB, GB, GBB, E, B, B],
+		MonadAp[GB, GBB, GB],
 		MonadMap[GA, GBB, E, A, func(B) B],
 
 		second,

ioeither/generic/ioeither.go

@@ -144,37 +144,37 @@ func ChainEitherK[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A,
 	return F.Bind2nd(MonadChainEitherK[GA, GB, E, A, B], f)
 }
 
-func MonadAp[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], E, A, B any](mab GAB, ma GA) GB {
+func MonadAp[GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], GA ~func() ET.Either[E, A], E, A, B any](mab GAB, ma GA) GB {
 	return eithert.MonadAp(
 		IO.MonadAp[GA, GB, func() func(ET.Either[E, A]) ET.Either[E, B], ET.Either[E, A], ET.Either[E, B]],
 		IO.MonadMap[GAB, func() func(ET.Either[E, A]) ET.Either[E, B], ET.Either[E, func(A) B], func(ET.Either[E, A]) ET.Either[E, B]],
 		mab, ma)
 }
 
-func Ap[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], E, A, B any](ma GA) func(GAB) GB {
-	return F.Bind2nd(MonadAp[GA, GB, GAB, E, A, B], ma)
+func Ap[GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], GA ~func() ET.Either[E, A], E, A, B any](ma GA) func(GAB) GB {
+	return F.Bind2nd(MonadAp[GB, GAB, GA], ma)
 }
 
-func MonadApSeq[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], E, A, B any](mab GAB, ma GA) GB {
+func MonadApSeq[GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], GA ~func() ET.Either[E, A], E, A, B any](mab GAB, ma GA) GB {
 	return eithert.MonadAp(
 		IO.MonadApSeq[GA, GB, func() func(ET.Either[E, A]) ET.Either[E, B], ET.Either[E, A], ET.Either[E, B]],
 		IO.MonadMap[GAB, func() func(ET.Either[E, A]) ET.Either[E, B], ET.Either[E, func(A) B], func(ET.Either[E, A]) ET.Either[E, B]],
 		mab, ma)
 }
 
-func ApSeq[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], E, A, B any](ma GA) func(GAB) GB {
-	return F.Bind2nd(MonadApSeq[GA, GB, GAB, E, A, B], ma)
+func ApSeq[GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], GA ~func() ET.Either[E, A], E, A, B any](ma GA) func(GAB) GB {
+	return F.Bind2nd(MonadApSeq[GB, GAB, GA], ma)
 }
 
-func MonadApPar[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], E, A, B any](mab GAB, ma GA) GB {
+func MonadApPar[GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], GA ~func() ET.Either[E, A], E, A, B any](mab GAB, ma GA) GB {
 	return eithert.MonadAp(
 		IO.MonadApPar[GA, GB, func() func(ET.Either[E, A]) ET.Either[E, B], ET.Either[E, A], ET.Either[E, B]],
 		IO.MonadMap[GAB, func() func(ET.Either[E, A]) ET.Either[E, B], ET.Either[E, func(A) B], func(ET.Either[E, A]) ET.Either[E, B]],
 		mab, ma)
 }
 
-func ApPar[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], E, A, B any](ma GA) func(GAB) GB {
-	return F.Bind2nd(MonadApPar[GA, GB, GAB, E, A, B], ma)
+func ApPar[GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], GA ~func() ET.Either[E, A], E, A, B any](ma GA) func(GAB) GB {
+	return F.Bind2nd(MonadApPar[GB, GAB, GA], ma)
 }
 
 func Flatten[GA ~func() ET.Either[E, A], GAA ~func() ET.Either[E, GA], E, A any](mma GAA) GA {
@@ -191,79 +191,6 @@ func TryCatchError[GA ~func() ET.Either[error, A], A any](f func() (A, error)) G
 	return TryCatch[GA](f, errors.IdentityError)
 }
 
-func Eitherize0[GEA ~func() ET.Either[error, A], GA ~func() (A, error), A any](f GA) func() GEA {
-	ef := ET.Eitherize0(f)
-	return func() GEA {
-		return MakeIO(ef)
-	}
-}
-
-func Uneitherize0[GEA ~func() ET.Either[error, A], GTA ~func() GEA, A any](f GTA) func() (A, error) {
-	return func() (A, error) {
-		return ET.Unwrap(f()())
-	}
-}
-
-func Eitherize1[GEA ~func() ET.Either[error, A], GA ~func(t1 T1) (A, error), T1, A any](f GA) func(T1) GEA {
-	ef := ET.Eitherize1(f)
-	return func(t1 T1) GEA {
-		return MakeIO[GEA](func() ET.Either[error, A] {
-			return ef(t1)
-		})
-	}
-}
-
-func Uneitherize1[GEA ~func() ET.Either[error, A], GTA ~func(t1 T1) GEA, T1, A any](f GTA) func(T1) (A, error) {
-	return func(t1 T1) (A, error) {
-		return ET.Unwrap(f(t1)())
-	}
-}
-
-func Eitherize2[GEA ~func() ET.Either[error, A], GA ~func(t1 T1, t2 T2) (A, error), T1, T2, A any](f GA) func(T1, T2) GEA {
-	ef := ET.Eitherize2(f)
-	return func(t1 T1, t2 T2) GEA {
-		return MakeIO[GEA](func() ET.Either[error, A] {
-			return ef(t1, t2)
-		})
-	}
-}
-
-func Uneitherize2[GEA ~func() ET.Either[error, A], GTA ~func(t1 T1, t2 T2) GEA, T1, T2, A any](f GTA) func(T1, T2) (A, error) {
-	return func(t1 T1, t2 T2) (A, error) {
-		return ET.Unwrap(f(t1, t2)())
-	}
-}
-
-func Eitherize3[GEA ~func() ET.Either[error, A], GA ~func(t1 T1, t2 T2, t3 T3) (A, error), T1, T2, T3, A any](f GA) func(T1, T2, T3) GEA {
-	ef := ET.Eitherize3(f)
-	return func(t1 T1, t2 T2, t3 T3) GEA {
-		return MakeIO[GEA](func() ET.Either[error, A] {
-			return ef(t1, t2, t3)
-		})
-	}
-}
-
-func Uneitherize3[GEA ~func() ET.Either[error, A], GTA ~func(t1 T1, t2 T2, t3 T3) GEA, T1, T2, T3, A any](f GTA) func(T1, T2, T3) (A, error) {
-	return func(t1 T1, t2 T2, t3 T3) (A, error) {
-		return ET.Unwrap(f(t1, t2, t3)())
-	}
-}
-
-func Eitherize4[GEA ~func() ET.Either[error, A], GA ~func(t1 T1, t2 T2, t3 T3, t4 T4) (A, error), T1, T2, T3, T4, A any](f GA) func(T1, T2, T3, T4) GEA {
-	ef := ET.Eitherize4(f)
-	return func(t1 T1, t2 T2, t3 T3, t4 T4) GEA {
-		return MakeIO[GEA](func() ET.Either[error, A] {
-			return ef(t1, t2, t3, t4)
-		})
-	}
-}
-
-func Uneitherize4[GEA ~func() ET.Either[error, A], GTA ~func(t1 T1, t2 T2, t3 T3, t4 T4) GEA, T1, T2, T3, T4, A any](f GTA) func(T1, T2, T3, T4) (A, error) {
-	return func(t1 T1, t2 T2, t3 T3, t4 T4) (A, error) {
-		return ET.Unwrap(f(t1, t2, t3, t4)())
-	}
-}
-
 // Memoize computes the value of the provided IO monad lazily but exactly once
 func Memoize[GA ~func() ET.Either[E, A], E, A any](ma GA) GA {
 	return IO.Memoize(ma)

ioeither/generic/sequence.go

@@ -1,62 +0,0 @@
-// 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"
-	"github.com/IBM/fp-go/internal/apply"
-	T "github.com/IBM/fp-go/tuple"
-)
-
-// SequenceT converts n inputs of higher kinded types into a higher kinded types of n strongly typed values, represented as a tuple
-
-func SequenceT1[GA ~func() ET.Either[E, A], GTA ~func() ET.Either[E, T.Tuple1[A]], E, A any](a GA) GTA {
-	return apply.SequenceT1(
-		Map[GA, GTA, E, A, T.Tuple1[A]],
-
-		a,
-	)
-}
-
-func SequenceT2[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GTAB ~func() ET.Either[E, T.Tuple2[A, B]], E, A, B any](a GA, b GB) GTAB {
-	return apply.SequenceT2(
-		Map[GA, func() ET.Either[E, func(B) T.Tuple2[A, B]], E, A, func(B) T.Tuple2[A, B]],
-		Ap[GB, GTAB, func() ET.Either[E, func(B) T.Tuple2[A, B]], E, B, T.Tuple2[A, B]],
-
-		a, b,
-	)
-}
-
-func SequenceT3[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GC ~func() ET.Either[E, C], GTABC ~func() ET.Either[E, T.Tuple3[A, B, C]], E, A, B, C any](a GA, b GB, c GC) GTABC {
-	return apply.SequenceT3(
-		Map[GA, func() ET.Either[E, func(B) func(C) T.Tuple3[A, B, C]], E, A, func(B) func(C) T.Tuple3[A, B, C]],
-		Ap[GB, func() ET.Either[E, func(C) T.Tuple3[A, B, C]], func() ET.Either[E, func(B) func(C) T.Tuple3[A, B, C]], E, B, func(C) T.Tuple3[A, B, C]],
-		Ap[GC, GTABC, func() ET.Either[E, func(C) T.Tuple3[A, B, C]], E, C, T.Tuple3[A, B, C]],
-
-		a, b, c,
-	)
-}
-
-func SequenceT4[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GC ~func() ET.Either[E, C], GD ~func() ET.Either[E, D], GTABCD ~func() ET.Either[E, T.Tuple4[A, B, C, D]], E, A, B, C, D any](a GA, b GB, c GC, d GD) GTABCD {
-	return apply.SequenceT4(
-		Map[GA, func() ET.Either[E, func(B) func(C) func(D) T.Tuple4[A, B, C, D]], E, A, func(B) func(C) func(D) T.Tuple4[A, B, C, D]],
-		Ap[GB, func() ET.Either[E, func(C) func(D) T.Tuple4[A, B, C, D]], func() ET.Either[E, func(B) func(C) func(D) T.Tuple4[A, B, C, D]], E, B, func(C) func(D) T.Tuple4[A, B, C, D]],
-		Ap[GC, func() ET.Either[E, func(D) T.Tuple4[A, B, C, D]], func() ET.Either[E, func(C) func(D) T.Tuple4[A, B, C, D]], E, C, func(D) T.Tuple4[A, B, C, D]],
-		Ap[GD, GTABCD, func() ET.Either[E, func(D) T.Tuple4[A, B, C, D]], E, D, T.Tuple4[A, B, C, D]],
-
-		a, b, c, d,
-	)
-}

ioeither/generic/traverse.go

@@ -27,7 +27,7 @@ func MonadTraverseArray[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS
 	return RA.MonadTraverse[AAS](
 		Of[GBS, E, BBS],
 		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		Ap[GB, GBS, func() ET.Either[E, func(B) BBS], E, B, BBS],
+		Ap[GBS, func() ET.Either[E, func(B) BBS], GB],
 
 		tas,
 		f,
@@ -39,7 +39,7 @@ func TraverseArray[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AA
 	return RA.Traverse[AAS](
 		Of[GBS, E, BBS],
 		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		Ap[GB, GBS, func() ET.Either[E, func(B) BBS], E, B, BBS],
+		Ap[GBS, func() ET.Either[E, func(B) BBS], GB],
 
 		f,
 	)
@@ -55,7 +55,7 @@ func MonadTraverseRecord[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BB
 	return RR.MonadTraverse[AAS](
 		Of[GBS, E, BBS],
 		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		Ap[GB, GBS, func() ET.Either[E, func(B) BBS], E, B, BBS],
+		Ap[GBS, func() ET.Either[E, func(B) BBS], GB],
 
 		tas,
 		f,
@@ -67,7 +67,7 @@ func TraverseRecord[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], A
 	return RR.Traverse[AAS](
 		Of[GBS, E, BBS],
 		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		Ap[GB, GBS, func() ET.Either[E, func(B) BBS], E, B, BBS],
+		Ap[GBS, func() ET.Either[E, func(B) BBS], GB],
 
 		f,
 	)

ioeither/ioeither.go

@@ -22,7 +22,7 @@ import (
 	O "github.com/IBM/fp-go/option"
 )
 
-// IO represents a synchronous computation that may fail
+// IOEither represents a synchronous computation that may fail
 // refer to [https://andywhite.xyz/posts/2021-01-27-rte-foundations/#ioeitherlte-agt] for more details
 type IOEither[E, A any] I.IO[ET.Either[E, A]]
 
@@ -111,11 +111,11 @@ func ChainEitherK[E, A, B any](f func(A) ET.Either[E, B]) func(IOEither[E, A]) I
 }
 
 func MonadAp[B, E, A any](mab IOEither[E, func(A) B], ma IOEither[E, A]) IOEither[E, B] {
-	return G.MonadAp[IOEither[E, A], IOEither[E, B]](mab, ma)
+	return G.MonadAp[IOEither[E, B]](mab, ma)
 }
 
 func Ap[B, E, A any](ma IOEither[E, A]) func(IOEither[E, func(A) B]) IOEither[E, B] {
-	return G.Ap[IOEither[E, A], IOEither[E, B], IOEither[E, func(A) B]](ma)
+	return G.Ap[IOEither[E, B], IOEither[E, func(A) B]](ma)
 }
 
 func Flatten[E, A any](mma IOEither[E, IOEither[E, A]]) IOEither[E, A] {
@@ -130,26 +130,6 @@ func TryCatchError[A any](f func() (A, error)) IOEither[error, A] {
 	return G.TryCatchError[IOEither[error, A]](f)
 }
 
-func Eitherize0[A any](f func() (A, error)) func() IOEither[error, A] {
-	return G.Eitherize0[IOEither[error, A]](f)
-}
-
-func Eitherize1[T1, A any](f func(t1 T1) (A, error)) func(T1) IOEither[error, A] {
-	return G.Eitherize1[IOEither[error, A]](f)
-}
-
-func Eitherize2[T1, T2, A any](f func(t1 T1, t2 T2) (A, error)) func(T1, T2) IOEither[error, A] {
-	return G.Eitherize2[IOEither[error, A]](f)
-}
-
-func Eitherize3[T1, T2, T3, A any](f func(t1 T1, t2 T2, t3 T3) (A, error)) func(T1, T2, T3) IOEither[error, A] {
-	return G.Eitherize3[IOEither[error, A]](f)
-}
-
-func Eitherize4[T1, T2, T3, T4, A any](f func(t1 T1, t2 T2, t3 T3, t4 T4) (A, error)) func(T1, T2, T3, T4) IOEither[error, A] {
-	return G.Eitherize4[IOEither[error, A]](f)
-}
-
 func Memoize[E, A any](ma IOEither[E, A]) IOEither[E, A] {
 	return G.Memoize(ma)
 }
@@ -212,7 +192,7 @@ func ChainFirstIOK[E, A, B any](f func(A) I.IO[B]) func(IOEither[E, A]) IOEither
 }
 
 // WithResource constructs a function that creates a resource, then operates on it and then releases the resource
-func WithResource[E, R, A, ANY any](onCreate IOEither[E, R], onRelease func(R) IOEither[E, ANY]) func(func(R) IOEither[E, A]) IOEither[E, A] {
+func WithResource[A, E, R, ANY any](onCreate IOEither[E, R], onRelease func(R) IOEither[E, ANY]) func(func(R) IOEither[E, A]) IOEither[E, A] {
 	return G.WithResource[IOEither[E, A]](onCreate, onRelease)
 }
 

ioeither/ioeither_test.go

@@ -119,7 +119,7 @@ func TestApFirst(t *testing.T) {
 
 	x := F.Pipe1(
 		Of[error]("a"),
-		ApFirst[error, string](Of[error]("b")),
+		ApFirst[string](Of[error]("b")),
 	)
 
 	assert.Equal(t, E.Of[error]("a"), x())
@@ -129,7 +129,7 @@ func TestApSecond(t *testing.T) {
 
 	x := F.Pipe1(
 		Of[error]("a"),
-		ApSecond[error, string](Of[error]("b")),
+		ApSecond[string](Of[error]("b")),
 	)
 
 	assert.Equal(t, E.Of[error]("b"), x())

ioeither/sequence.go

@@ -1,69 +0,0 @@
-// 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"
-	T "github.com/IBM/fp-go/tuple"
-)
-
-// SequenceT converts n inputs of higher kinded types into a higher kinded types of n strongly typed values, represented as a tuple
-
-func SequenceT1[E, A any](a IOEither[E, A]) IOEither[E, T.Tuple1[A]] {
-	return G.SequenceT1[
-		IOEither[E, A],
-		IOEither[E, T.Tuple1[A]],
-	](a)
-}
-
-func SequenceT2[E, A, B any](
-	a IOEither[E, A],
-	b IOEither[E, B],
-) IOEither[E, T.Tuple2[A, B]] {
-	return G.SequenceT2[
-		IOEither[E, A],
-		IOEither[E, B],
-		IOEither[E, T.Tuple2[A, B]],
-	](a, b)
-}
-
-func SequenceT3[E, A, B, C any](
-	a IOEither[E, A],
-	b IOEither[E, B],
-	c IOEither[E, C],
-) IOEither[E, T.Tuple3[A, B, C]] {
-	return G.SequenceT3[
-		IOEither[E, A],
-		IOEither[E, B],
-		IOEither[E, C],
-		IOEither[E, T.Tuple3[A, B, C]],
-	](a, b, c)
-}
-
-func SequenceT4[E, A, B, C, D any](
-	a IOEither[E, A],
-	b IOEither[E, B],
-	c IOEither[E, C],
-	d IOEither[E, D],
-) IOEither[E, T.Tuple4[A, B, C, D]] {
-	return G.SequenceT4[
-		IOEither[E, A],
-		IOEither[E, B],
-		IOEither[E, C],
-		IOEither[E, D],
-		IOEither[E, T.Tuple4[A, B, C, D]],
-	](a, b, c, d)
-}

iooption/array.go

@@ -0,0 +1,30 @@
+// 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 iooption
+
+import (
+	G "github.com/IBM/fp-go/iooption/generic"
+)
+
+// TraverseArray transforms an array
+func TraverseArray[A, B any](f func(A) IOOption[B]) func([]A) IOOption[[]B] {
+	return G.TraverseArray[IOOption[B], IOOption[[]B], []A](f)
+}
+
+// SequenceArray converts a homogeneous sequence of either into an either of sequence
+func SequenceArray[A any](ma []IOOption[A]) IOOption[[]A] {
+	return G.SequenceArray[IOOption[A], IOOption[[]A], []IOOption[A], []A, A](ma)
+}

iooption/doc.go

@@ -0,0 +1,18 @@
+// 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 iooption
+
+//go:generate go run .. iooption --count 10 --filename gen.go

iooption/gen.go

@@ -0,0 +1,390 @@
+// 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.
+
+// Code generated by go generate; DO NOT EDIT.
+// This file was generated by robots at
+// 2023-07-28 22:49:03.8471425 +0200 CEST m=+0.087124201
+package iooption
+
+
+import (
+	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],
+) IOOption[T.Tuple1[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)
+}
+
+// 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)
+}
+
+// SequenceT2 converts 2 [IOOption[T]] into a [IOOption[T.Tuple2[T1, T2]]]
+func SequenceT2[T1, T2 any](
+  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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) IOOption[T.Tuple3[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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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],
+) 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)
+}
+
+// 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)
+}
+
+// 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)
+}

iooption/generic/gen.go

@@ -0,0 +1,846 @@
+// 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.
+
+// Code generated by go generate; DO NOT EDIT.
+// This file was generated by robots at
+// 2023-07-28 22:49:03.8541587 +0200 CEST m=+0.094140401
+package generic
+
+
+import (
+	T "github.com/IBM/fp-go/tuple"
+	O "github.com/IBM/fp-go/option"
+	A "github.com/IBM/fp-go/internal/apply"
+)
+
+// SequenceT1 converts 1 [func() O.Option[T]] into a [func() O.Option[T.Tuple1[T1]]]
+func SequenceT1[
+  G_TUPLE1 ~func() O.Option[T.Tuple1[T1]],
+  G_T1 ~func() O.Option[T1], 
+  T1 any](
+  t1 G_T1,
+)  G_TUPLE1 {
+  return A.SequenceT1(
+    Map[G_T1, G_TUPLE1, T1,  T.Tuple1[T1]],
+    t1,
+  )
+}
+
+// SequenceTuple1 converts a [T.Tuple1[func() O.Option[T]]] into a [func() O.Option[T.Tuple1[T1]]]
+func SequenceTuple1[
+  G_TUPLE1 ~func() O.Option[T.Tuple1[T1]],
+  G_T1 ~func() O.Option[T1], 
+  T1 any](t T.Tuple1[G_T1])  G_TUPLE1 {
+  return A.SequenceTuple1(
+    Map[G_T1, G_TUPLE1, T1,  T.Tuple1[T1]],
+    t)
+}
+
+// TraverseTuple1 converts a [T.Tuple1[func() O.Option[T]]] into a [func() O.Option[T.Tuple1[T1]]]
+func TraverseTuple1[
+  G_TUPLE1 ~func() O.Option[T.Tuple1[T1]],
+  F1 ~func(A1) G_T1,
+  G_T1 ~func() O.Option[T1], 
+  A1, T1 any](f1 F1) func(T.Tuple1[A1]) G_TUPLE1 {
+  return func(t T.Tuple1[A1]) G_TUPLE1 {
+    return A.TraverseTuple1(
+    Map[G_T1, G_TUPLE1, T1,  T.Tuple1[T1]],
+    f1,
+    t)
+   }
+}
+
+// SequenceT2 converts 2 [func() O.Option[T]] into a [func() O.Option[T.Tuple2[T1, T2]]]
+func SequenceT2[
+  G_TUPLE2 ~func() O.Option[T.Tuple2[T1, T2]],
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  T1, T2 any](
+  t1 G_T1,
+  t2 G_T2,
+)  G_TUPLE2 {
+  return A.SequenceT2(
+    Map[G_T1, func() O.Option[func(T2) T.Tuple2[T1, T2]], T1, func(T2) T.Tuple2[T1, T2]],
+    Ap[G_TUPLE2, func() O.Option[func(T2) T.Tuple2[T1, T2]], G_T2],
+    t1,
+    t2,
+  )
+}
+
+// SequenceTuple2 converts a [T.Tuple2[func() O.Option[T]]] into a [func() O.Option[T.Tuple2[T1, T2]]]
+func SequenceTuple2[
+  G_TUPLE2 ~func() O.Option[T.Tuple2[T1, T2]],
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  T1, T2 any](t T.Tuple2[G_T1, G_T2])  G_TUPLE2 {
+  return A.SequenceTuple2(
+    Map[G_T1, func() O.Option[func(T2) T.Tuple2[T1, T2]], T1, func(T2) T.Tuple2[T1, T2]],
+    Ap[G_TUPLE2, func() O.Option[func(T2) T.Tuple2[T1, T2]], G_T2],
+    t)
+}
+
+// TraverseTuple2 converts a [T.Tuple2[func() O.Option[T]]] into a [func() O.Option[T.Tuple2[T1, T2]]]
+func TraverseTuple2[
+  G_TUPLE2 ~func() O.Option[T.Tuple2[T1, T2]],
+  F1 ~func(A1) G_T1,
+  F2 ~func(A2) G_T2,
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  A1, A2, T1, T2 any](f1 F1, f2 F2) func(T.Tuple2[A1, A2]) G_TUPLE2 {
+  return func(t T.Tuple2[A1, A2]) G_TUPLE2 {
+    return A.TraverseTuple2(
+    Map[G_T1, func() O.Option[func(T2) T.Tuple2[T1, T2]], T1, func(T2) T.Tuple2[T1, T2]],
+    Ap[G_TUPLE2, func() O.Option[func(T2) T.Tuple2[T1, T2]], G_T2],
+    f1,
+    f2,
+    t)
+   }
+}
+
+// SequenceT3 converts 3 [func() O.Option[T]] into a [func() O.Option[T.Tuple3[T1, T2, T3]]]
+func SequenceT3[
+  G_TUPLE3 ~func() O.Option[T.Tuple3[T1, T2, T3]],
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  T1, T2, T3 any](
+  t1 G_T1,
+  t2 G_T2,
+  t3 G_T3,
+)  G_TUPLE3 {
+  return A.SequenceT3(
+    Map[G_T1, func() O.Option[func(T2) func(T3) T.Tuple3[T1, T2, T3]], T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
+    Ap[func() O.Option[func(T3) T.Tuple3[T1, T2, T3]], func() O.Option[func(T2) func(T3) T.Tuple3[T1, T2, T3]], G_T2],
+    Ap[G_TUPLE3, func() O.Option[func(T3) T.Tuple3[T1, T2, T3]], G_T3],
+    t1,
+    t2,
+    t3,
+  )
+}
+
+// SequenceTuple3 converts a [T.Tuple3[func() O.Option[T]]] into a [func() O.Option[T.Tuple3[T1, T2, T3]]]
+func SequenceTuple3[
+  G_TUPLE3 ~func() O.Option[T.Tuple3[T1, T2, T3]],
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  T1, T2, T3 any](t T.Tuple3[G_T1, G_T2, G_T3])  G_TUPLE3 {
+  return A.SequenceTuple3(
+    Map[G_T1, func() O.Option[func(T2) func(T3) T.Tuple3[T1, T2, T3]], T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
+    Ap[func() O.Option[func(T3) T.Tuple3[T1, T2, T3]], func() O.Option[func(T2) func(T3) T.Tuple3[T1, T2, T3]], G_T2],
+    Ap[G_TUPLE3, func() O.Option[func(T3) T.Tuple3[T1, T2, T3]], G_T3],
+    t)
+}
+
+// TraverseTuple3 converts a [T.Tuple3[func() O.Option[T]]] into a [func() O.Option[T.Tuple3[T1, T2, T3]]]
+func TraverseTuple3[
+  G_TUPLE3 ~func() O.Option[T.Tuple3[T1, T2, T3]],
+  F1 ~func(A1) G_T1,
+  F2 ~func(A2) G_T2,
+  F3 ~func(A3) G_T3,
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  A1, A2, A3, T1, T2, T3 any](f1 F1, f2 F2, f3 F3) func(T.Tuple3[A1, A2, A3]) G_TUPLE3 {
+  return func(t T.Tuple3[A1, A2, A3]) G_TUPLE3 {
+    return A.TraverseTuple3(
+    Map[G_T1, func() O.Option[func(T2) func(T3) T.Tuple3[T1, T2, T3]], T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
+    Ap[func() O.Option[func(T3) T.Tuple3[T1, T2, T3]], func() O.Option[func(T2) func(T3) T.Tuple3[T1, T2, T3]], G_T2],
+    Ap[G_TUPLE3, func() O.Option[func(T3) T.Tuple3[T1, T2, T3]], G_T3],
+    f1,
+    f2,
+    f3,
+    t)
+   }
+}
+
+// SequenceT4 converts 4 [func() O.Option[T]] into a [func() O.Option[T.Tuple4[T1, T2, T3, T4]]]
+func SequenceT4[
+  G_TUPLE4 ~func() O.Option[T.Tuple4[T1, T2, T3, T4]],
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  T1, T2, T3, T4 any](
+  t1 G_T1,
+  t2 G_T2,
+  t3 G_T3,
+  t4 G_T4,
+)  G_TUPLE4 {
+  return A.SequenceT4(
+    Map[G_T1, func() O.Option[func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
+    Ap[func() O.Option[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], func() O.Option[func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], G_T2],
+    Ap[func() O.Option[func(T4) T.Tuple4[T1, T2, T3, T4]], func() O.Option[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], G_T3],
+    Ap[G_TUPLE4, func() O.Option[func(T4) T.Tuple4[T1, T2, T3, T4]], G_T4],
+    t1,
+    t2,
+    t3,
+    t4,
+  )
+}
+
+// SequenceTuple4 converts a [T.Tuple4[func() O.Option[T]]] into a [func() O.Option[T.Tuple4[T1, T2, T3, T4]]]
+func SequenceTuple4[
+  G_TUPLE4 ~func() O.Option[T.Tuple4[T1, T2, T3, T4]],
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  T1, T2, T3, T4 any](t T.Tuple4[G_T1, G_T2, G_T3, G_T4])  G_TUPLE4 {
+  return A.SequenceTuple4(
+    Map[G_T1, func() O.Option[func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
+    Ap[func() O.Option[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], func() O.Option[func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], G_T2],
+    Ap[func() O.Option[func(T4) T.Tuple4[T1, T2, T3, T4]], func() O.Option[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], G_T3],
+    Ap[G_TUPLE4, func() O.Option[func(T4) T.Tuple4[T1, T2, T3, T4]], G_T4],
+    t)
+}
+
+// TraverseTuple4 converts a [T.Tuple4[func() O.Option[T]]] into a [func() O.Option[T.Tuple4[T1, T2, T3, T4]]]
+func TraverseTuple4[
+  G_TUPLE4 ~func() O.Option[T.Tuple4[T1, T2, T3, T4]],
+  F1 ~func(A1) G_T1,
+  F2 ~func(A2) G_T2,
+  F3 ~func(A3) G_T3,
+  F4 ~func(A4) G_T4,
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[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]) G_TUPLE4 {
+  return func(t T.Tuple4[A1, A2, A3, A4]) G_TUPLE4 {
+    return A.TraverseTuple4(
+    Map[G_T1, func() O.Option[func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
+    Ap[func() O.Option[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], func() O.Option[func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], G_T2],
+    Ap[func() O.Option[func(T4) T.Tuple4[T1, T2, T3, T4]], func() O.Option[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], G_T3],
+    Ap[G_TUPLE4, func() O.Option[func(T4) T.Tuple4[T1, T2, T3, T4]], G_T4],
+    f1,
+    f2,
+    f3,
+    f4,
+    t)
+   }
+}
+
+// SequenceT5 converts 5 [func() O.Option[T]] into a [func() O.Option[T.Tuple5[T1, T2, T3, T4, T5]]]
+func SequenceT5[
+  G_TUPLE5 ~func() O.Option[T.Tuple5[T1, T2, T3, T4, T5]],
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  G_T5 ~func() O.Option[T5], 
+  T1, T2, T3, T4, T5 any](
+  t1 G_T1,
+  t2 G_T2,
+  t3 G_T3,
+  t4 G_T4,
+  t5 G_T5,
+)  G_TUPLE5 {
+  return A.SequenceT5(
+    Map[G_T1, func() O.Option[func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
+    Ap[func() O.Option[func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() O.Option[func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T2],
+    Ap[func() O.Option[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() O.Option[func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T3],
+    Ap[func() O.Option[func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() O.Option[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T4],
+    Ap[G_TUPLE5, func() O.Option[func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T5],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+  )
+}
+
+// SequenceTuple5 converts a [T.Tuple5[func() O.Option[T]]] into a [func() O.Option[T.Tuple5[T1, T2, T3, T4, T5]]]
+func SequenceTuple5[
+  G_TUPLE5 ~func() O.Option[T.Tuple5[T1, T2, T3, T4, T5]],
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  G_T5 ~func() O.Option[T5], 
+  T1, T2, T3, T4, T5 any](t T.Tuple5[G_T1, G_T2, G_T3, G_T4, G_T5])  G_TUPLE5 {
+  return A.SequenceTuple5(
+    Map[G_T1, func() O.Option[func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
+    Ap[func() O.Option[func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() O.Option[func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T2],
+    Ap[func() O.Option[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() O.Option[func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T3],
+    Ap[func() O.Option[func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() O.Option[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T4],
+    Ap[G_TUPLE5, func() O.Option[func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T5],
+    t)
+}
+
+// TraverseTuple5 converts a [T.Tuple5[func() O.Option[T]]] into a [func() O.Option[T.Tuple5[T1, T2, T3, T4, T5]]]
+func TraverseTuple5[
+  G_TUPLE5 ~func() O.Option[T.Tuple5[T1, T2, T3, T4, T5]],
+  F1 ~func(A1) G_T1,
+  F2 ~func(A2) G_T2,
+  F3 ~func(A3) G_T3,
+  F4 ~func(A4) G_T4,
+  F5 ~func(A5) G_T5,
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  G_T5 ~func() O.Option[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]) G_TUPLE5 {
+  return func(t T.Tuple5[A1, A2, A3, A4, A5]) G_TUPLE5 {
+    return A.TraverseTuple5(
+    Map[G_T1, func() O.Option[func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
+    Ap[func() O.Option[func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() O.Option[func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T2],
+    Ap[func() O.Option[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() O.Option[func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T3],
+    Ap[func() O.Option[func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() O.Option[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T4],
+    Ap[G_TUPLE5, func() O.Option[func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T5],
+    f1,
+    f2,
+    f3,
+    f4,
+    f5,
+    t)
+   }
+}
+
+// SequenceT6 converts 6 [func() O.Option[T]] into a [func() O.Option[T.Tuple6[T1, T2, T3, T4, T5, T6]]]
+func SequenceT6[
+  G_TUPLE6 ~func() O.Option[T.Tuple6[T1, T2, T3, T4, T5, T6]],
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  G_T5 ~func() O.Option[T5], 
+  G_T6 ~func() O.Option[T6], 
+  T1, T2, T3, T4, T5, T6 any](
+  t1 G_T1,
+  t2 G_T2,
+  t3 G_T3,
+  t4 G_T4,
+  t5 G_T5,
+  t6 G_T6,
+)  G_TUPLE6 {
+  return A.SequenceT6(
+    Map[G_T1, func() O.Option[func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
+    Ap[func() O.Option[func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() O.Option[func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T2],
+    Ap[func() O.Option[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() O.Option[func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T3],
+    Ap[func() O.Option[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() O.Option[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T4],
+    Ap[func() O.Option[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() O.Option[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T5],
+    Ap[G_TUPLE6, func() O.Option[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T6],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+  )
+}
+
+// SequenceTuple6 converts a [T.Tuple6[func() O.Option[T]]] into a [func() O.Option[T.Tuple6[T1, T2, T3, T4, T5, T6]]]
+func SequenceTuple6[
+  G_TUPLE6 ~func() O.Option[T.Tuple6[T1, T2, T3, T4, T5, T6]],
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  G_T5 ~func() O.Option[T5], 
+  G_T6 ~func() O.Option[T6], 
+  T1, T2, T3, T4, T5, T6 any](t T.Tuple6[G_T1, G_T2, G_T3, G_T4, G_T5, G_T6])  G_TUPLE6 {
+  return A.SequenceTuple6(
+    Map[G_T1, func() O.Option[func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
+    Ap[func() O.Option[func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() O.Option[func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T2],
+    Ap[func() O.Option[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() O.Option[func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T3],
+    Ap[func() O.Option[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() O.Option[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T4],
+    Ap[func() O.Option[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() O.Option[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T5],
+    Ap[G_TUPLE6, func() O.Option[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T6],
+    t)
+}
+
+// TraverseTuple6 converts a [T.Tuple6[func() O.Option[T]]] into a [func() O.Option[T.Tuple6[T1, T2, T3, T4, T5, T6]]]
+func TraverseTuple6[
+  G_TUPLE6 ~func() O.Option[T.Tuple6[T1, T2, T3, T4, T5, T6]],
+  F1 ~func(A1) G_T1,
+  F2 ~func(A2) G_T2,
+  F3 ~func(A3) G_T3,
+  F4 ~func(A4) G_T4,
+  F5 ~func(A5) G_T5,
+  F6 ~func(A6) G_T6,
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  G_T5 ~func() O.Option[T5], 
+  G_T6 ~func() O.Option[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]) G_TUPLE6 {
+  return func(t T.Tuple6[A1, A2, A3, A4, A5, A6]) G_TUPLE6 {
+    return A.TraverseTuple6(
+    Map[G_T1, func() O.Option[func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
+    Ap[func() O.Option[func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() O.Option[func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T2],
+    Ap[func() O.Option[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() O.Option[func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T3],
+    Ap[func() O.Option[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() O.Option[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T4],
+    Ap[func() O.Option[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() O.Option[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T5],
+    Ap[G_TUPLE6, func() O.Option[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T6],
+    f1,
+    f2,
+    f3,
+    f4,
+    f5,
+    f6,
+    t)
+   }
+}
+
+// SequenceT7 converts 7 [func() O.Option[T]] into a [func() O.Option[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
+func SequenceT7[
+  G_TUPLE7 ~func() O.Option[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  G_T5 ~func() O.Option[T5], 
+  G_T6 ~func() O.Option[T6], 
+  G_T7 ~func() O.Option[T7], 
+  T1, T2, T3, T4, T5, T6, T7 any](
+  t1 G_T1,
+  t2 G_T2,
+  t3 G_T3,
+  t4 G_T4,
+  t5 G_T5,
+  t6 G_T6,
+  t7 G_T7,
+)  G_TUPLE7 {
+  return A.SequenceT7(
+    Map[G_T1, func() O.Option[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+    Ap[func() O.Option[func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() O.Option[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T2],
+    Ap[func() O.Option[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() O.Option[func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T3],
+    Ap[func() O.Option[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() O.Option[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T4],
+    Ap[func() O.Option[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() O.Option[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T5],
+    Ap[func() O.Option[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() O.Option[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T6],
+    Ap[G_TUPLE7, func() O.Option[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T7],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+  )
+}
+
+// SequenceTuple7 converts a [T.Tuple7[func() O.Option[T]]] into a [func() O.Option[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
+func SequenceTuple7[
+  G_TUPLE7 ~func() O.Option[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  G_T5 ~func() O.Option[T5], 
+  G_T6 ~func() O.Option[T6], 
+  G_T7 ~func() O.Option[T7], 
+  T1, T2, T3, T4, T5, T6, T7 any](t T.Tuple7[G_T1, G_T2, G_T3, G_T4, G_T5, G_T6, G_T7])  G_TUPLE7 {
+  return A.SequenceTuple7(
+    Map[G_T1, func() O.Option[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+    Ap[func() O.Option[func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() O.Option[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T2],
+    Ap[func() O.Option[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() O.Option[func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T3],
+    Ap[func() O.Option[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() O.Option[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T4],
+    Ap[func() O.Option[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() O.Option[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T5],
+    Ap[func() O.Option[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() O.Option[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T6],
+    Ap[G_TUPLE7, func() O.Option[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T7],
+    t)
+}
+
+// TraverseTuple7 converts a [T.Tuple7[func() O.Option[T]]] into a [func() O.Option[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
+func TraverseTuple7[
+  G_TUPLE7 ~func() O.Option[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+  F1 ~func(A1) G_T1,
+  F2 ~func(A2) G_T2,
+  F3 ~func(A3) G_T3,
+  F4 ~func(A4) G_T4,
+  F5 ~func(A5) G_T5,
+  F6 ~func(A6) G_T6,
+  F7 ~func(A7) G_T7,
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  G_T5 ~func() O.Option[T5], 
+  G_T6 ~func() O.Option[T6], 
+  G_T7 ~func() O.Option[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]) G_TUPLE7 {
+  return func(t T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) G_TUPLE7 {
+    return A.TraverseTuple7(
+    Map[G_T1, func() O.Option[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+    Ap[func() O.Option[func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() O.Option[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T2],
+    Ap[func() O.Option[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() O.Option[func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T3],
+    Ap[func() O.Option[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() O.Option[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T4],
+    Ap[func() O.Option[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() O.Option[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T5],
+    Ap[func() O.Option[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() O.Option[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T6],
+    Ap[G_TUPLE7, func() O.Option[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T7],
+    f1,
+    f2,
+    f3,
+    f4,
+    f5,
+    f6,
+    f7,
+    t)
+   }
+}
+
+// SequenceT8 converts 8 [func() O.Option[T]] into a [func() O.Option[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
+func SequenceT8[
+  G_TUPLE8 ~func() O.Option[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  G_T5 ~func() O.Option[T5], 
+  G_T6 ~func() O.Option[T6], 
+  G_T7 ~func() O.Option[T7], 
+  G_T8 ~func() O.Option[T8], 
+  T1, T2, T3, T4, T5, T6, T7, T8 any](
+  t1 G_T1,
+  t2 G_T2,
+  t3 G_T3,
+  t4 G_T4,
+  t5 G_T5,
+  t6 G_T6,
+  t7 G_T7,
+  t8 G_T8,
+)  G_TUPLE8 {
+  return A.SequenceT8(
+    Map[G_T1, func() O.Option[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], 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() O.Option[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() O.Option[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T2],
+    Ap[func() O.Option[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() O.Option[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T3],
+    Ap[func() O.Option[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() O.Option[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T4],
+    Ap[func() O.Option[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() O.Option[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T5],
+    Ap[func() O.Option[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() O.Option[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T6],
+    Ap[func() O.Option[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() O.Option[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T7],
+    Ap[G_TUPLE8, func() O.Option[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T8],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+    t8,
+  )
+}
+
+// SequenceTuple8 converts a [T.Tuple8[func() O.Option[T]]] into a [func() O.Option[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
+func SequenceTuple8[
+  G_TUPLE8 ~func() O.Option[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  G_T5 ~func() O.Option[T5], 
+  G_T6 ~func() O.Option[T6], 
+  G_T7 ~func() O.Option[T7], 
+  G_T8 ~func() O.Option[T8], 
+  T1, T2, T3, T4, T5, T6, T7, T8 any](t T.Tuple8[G_T1, G_T2, G_T3, G_T4, G_T5, G_T6, G_T7, G_T8])  G_TUPLE8 {
+  return A.SequenceTuple8(
+    Map[G_T1, func() O.Option[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], 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() O.Option[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() O.Option[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T2],
+    Ap[func() O.Option[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() O.Option[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T3],
+    Ap[func() O.Option[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() O.Option[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T4],
+    Ap[func() O.Option[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() O.Option[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T5],
+    Ap[func() O.Option[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() O.Option[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T6],
+    Ap[func() O.Option[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() O.Option[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T7],
+    Ap[G_TUPLE8, func() O.Option[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T8],
+    t)
+}
+
+// TraverseTuple8 converts a [T.Tuple8[func() O.Option[T]]] into a [func() O.Option[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
+func TraverseTuple8[
+  G_TUPLE8 ~func() O.Option[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+  F1 ~func(A1) G_T1,
+  F2 ~func(A2) G_T2,
+  F3 ~func(A3) G_T3,
+  F4 ~func(A4) G_T4,
+  F5 ~func(A5) G_T5,
+  F6 ~func(A6) G_T6,
+  F7 ~func(A7) G_T7,
+  F8 ~func(A8) G_T8,
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  G_T5 ~func() O.Option[T5], 
+  G_T6 ~func() O.Option[T6], 
+  G_T7 ~func() O.Option[T7], 
+  G_T8 ~func() O.Option[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]) G_TUPLE8 {
+  return func(t T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) G_TUPLE8 {
+    return A.TraverseTuple8(
+    Map[G_T1, func() O.Option[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], 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() O.Option[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() O.Option[func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T2],
+    Ap[func() O.Option[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() O.Option[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T3],
+    Ap[func() O.Option[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() O.Option[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T4],
+    Ap[func() O.Option[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() O.Option[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T5],
+    Ap[func() O.Option[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() O.Option[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T6],
+    Ap[func() O.Option[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() O.Option[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T7],
+    Ap[G_TUPLE8, func() O.Option[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T8],
+    f1,
+    f2,
+    f3,
+    f4,
+    f5,
+    f6,
+    f7,
+    f8,
+    t)
+   }
+}
+
+// SequenceT9 converts 9 [func() O.Option[T]] into a [func() O.Option[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
+func SequenceT9[
+  G_TUPLE9 ~func() O.Option[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  G_T5 ~func() O.Option[T5], 
+  G_T6 ~func() O.Option[T6], 
+  G_T7 ~func() O.Option[T7], 
+  G_T8 ~func() O.Option[T8], 
+  G_T9 ~func() O.Option[T9], 
+  T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+  t1 G_T1,
+  t2 G_T2,
+  t3 G_T3,
+  t4 G_T4,
+  t5 G_T5,
+  t6 G_T6,
+  t7 G_T7,
+  t8 G_T8,
+  t9 G_T9,
+)  G_TUPLE9 {
+  return A.SequenceT9(
+    Map[G_T1, func() O.Option[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]], 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() O.Option[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]], func() O.Option[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]], G_T2],
+    Ap[func() O.Option[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() O.Option[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]], G_T3],
+    Ap[func() O.Option[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() O.Option[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T4],
+    Ap[func() O.Option[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() O.Option[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T5],
+    Ap[func() O.Option[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() O.Option[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T6],
+    Ap[func() O.Option[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() O.Option[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T7],
+    Ap[func() O.Option[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() O.Option[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T8],
+    Ap[G_TUPLE9, func() O.Option[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T9],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+    t8,
+    t9,
+  )
+}
+
+// SequenceTuple9 converts a [T.Tuple9[func() O.Option[T]]] into a [func() O.Option[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
+func SequenceTuple9[
+  G_TUPLE9 ~func() O.Option[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  G_T5 ~func() O.Option[T5], 
+  G_T6 ~func() O.Option[T6], 
+  G_T7 ~func() O.Option[T7], 
+  G_T8 ~func() O.Option[T8], 
+  G_T9 ~func() O.Option[T9], 
+  T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t T.Tuple9[G_T1, G_T2, G_T3, G_T4, G_T5, G_T6, G_T7, G_T8, G_T9])  G_TUPLE9 {
+  return A.SequenceTuple9(
+    Map[G_T1, func() O.Option[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]], 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() O.Option[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]], func() O.Option[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]], G_T2],
+    Ap[func() O.Option[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() O.Option[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]], G_T3],
+    Ap[func() O.Option[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() O.Option[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T4],
+    Ap[func() O.Option[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() O.Option[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T5],
+    Ap[func() O.Option[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() O.Option[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T6],
+    Ap[func() O.Option[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() O.Option[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T7],
+    Ap[func() O.Option[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() O.Option[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T8],
+    Ap[G_TUPLE9, func() O.Option[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T9],
+    t)
+}
+
+// TraverseTuple9 converts a [T.Tuple9[func() O.Option[T]]] into a [func() O.Option[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
+func TraverseTuple9[
+  G_TUPLE9 ~func() O.Option[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+  F1 ~func(A1) G_T1,
+  F2 ~func(A2) G_T2,
+  F3 ~func(A3) G_T3,
+  F4 ~func(A4) G_T4,
+  F5 ~func(A5) G_T5,
+  F6 ~func(A6) G_T6,
+  F7 ~func(A7) G_T7,
+  F8 ~func(A8) G_T8,
+  F9 ~func(A9) G_T9,
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  G_T5 ~func() O.Option[T5], 
+  G_T6 ~func() O.Option[T6], 
+  G_T7 ~func() O.Option[T7], 
+  G_T8 ~func() O.Option[T8], 
+  G_T9 ~func() O.Option[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]) G_TUPLE9 {
+  return func(t T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) G_TUPLE9 {
+    return A.TraverseTuple9(
+    Map[G_T1, func() O.Option[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]], 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() O.Option[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]], func() O.Option[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]], G_T2],
+    Ap[func() O.Option[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() O.Option[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]], G_T3],
+    Ap[func() O.Option[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() O.Option[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T4],
+    Ap[func() O.Option[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() O.Option[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T5],
+    Ap[func() O.Option[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() O.Option[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T6],
+    Ap[func() O.Option[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() O.Option[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T7],
+    Ap[func() O.Option[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() O.Option[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T8],
+    Ap[G_TUPLE9, func() O.Option[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T9],
+    f1,
+    f2,
+    f3,
+    f4,
+    f5,
+    f6,
+    f7,
+    f8,
+    f9,
+    t)
+   }
+}
+
+// SequenceT10 converts 10 [func() O.Option[T]] into a [func() O.Option[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
+func SequenceT10[
+  G_TUPLE10 ~func() O.Option[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  G_T5 ~func() O.Option[T5], 
+  G_T6 ~func() O.Option[T6], 
+  G_T7 ~func() O.Option[T7], 
+  G_T8 ~func() O.Option[T8], 
+  G_T9 ~func() O.Option[T9], 
+  G_T10 ~func() O.Option[T10], 
+  T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](
+  t1 G_T1,
+  t2 G_T2,
+  t3 G_T3,
+  t4 G_T4,
+  t5 G_T5,
+  t6 G_T6,
+  t7 G_T7,
+  t8 G_T8,
+  t9 G_T9,
+  t10 G_T10,
+)  G_TUPLE10 {
+  return A.SequenceT10(
+    Map[G_T1, func() O.Option[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]], 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() O.Option[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]], func() O.Option[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]], G_T2],
+    Ap[func() O.Option[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]], func() O.Option[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]], G_T3],
+    Ap[func() O.Option[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() O.Option[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]], G_T4],
+    Ap[func() O.Option[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() O.Option[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T5],
+    Ap[func() O.Option[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() O.Option[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T6],
+    Ap[func() O.Option[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() O.Option[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T7],
+    Ap[func() O.Option[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() O.Option[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T8],
+    Ap[func() O.Option[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() O.Option[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T9],
+    Ap[G_TUPLE10, func() O.Option[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T10],
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+    t8,
+    t9,
+    t10,
+  )
+}
+
+// SequenceTuple10 converts a [T.Tuple10[func() O.Option[T]]] into a [func() O.Option[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
+func SequenceTuple10[
+  G_TUPLE10 ~func() O.Option[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  G_T5 ~func() O.Option[T5], 
+  G_T6 ~func() O.Option[T6], 
+  G_T7 ~func() O.Option[T7], 
+  G_T8 ~func() O.Option[T8], 
+  G_T9 ~func() O.Option[T9], 
+  G_T10 ~func() O.Option[T10], 
+  T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t T.Tuple10[G_T1, G_T2, G_T3, G_T4, G_T5, G_T6, G_T7, G_T8, G_T9, G_T10])  G_TUPLE10 {
+  return A.SequenceTuple10(
+    Map[G_T1, func() O.Option[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]], 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() O.Option[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]], func() O.Option[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]], G_T2],
+    Ap[func() O.Option[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]], func() O.Option[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]], G_T3],
+    Ap[func() O.Option[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() O.Option[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]], G_T4],
+    Ap[func() O.Option[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() O.Option[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T5],
+    Ap[func() O.Option[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() O.Option[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T6],
+    Ap[func() O.Option[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() O.Option[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T7],
+    Ap[func() O.Option[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() O.Option[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T8],
+    Ap[func() O.Option[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() O.Option[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T9],
+    Ap[G_TUPLE10, func() O.Option[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T10],
+    t)
+}
+
+// TraverseTuple10 converts a [T.Tuple10[func() O.Option[T]]] into a [func() O.Option[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
+func TraverseTuple10[
+  G_TUPLE10 ~func() O.Option[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+  F1 ~func(A1) G_T1,
+  F2 ~func(A2) G_T2,
+  F3 ~func(A3) G_T3,
+  F4 ~func(A4) G_T4,
+  F5 ~func(A5) G_T5,
+  F6 ~func(A6) G_T6,
+  F7 ~func(A7) G_T7,
+  F8 ~func(A8) G_T8,
+  F9 ~func(A9) G_T9,
+  F10 ~func(A10) G_T10,
+  G_T1 ~func() O.Option[T1], 
+  G_T2 ~func() O.Option[T2], 
+  G_T3 ~func() O.Option[T3], 
+  G_T4 ~func() O.Option[T4], 
+  G_T5 ~func() O.Option[T5], 
+  G_T6 ~func() O.Option[T6], 
+  G_T7 ~func() O.Option[T7], 
+  G_T8 ~func() O.Option[T8], 
+  G_T9 ~func() O.Option[T9], 
+  G_T10 ~func() O.Option[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]) G_TUPLE10 {
+  return func(t T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) G_TUPLE10 {
+    return A.TraverseTuple10(
+    Map[G_T1, func() O.Option[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]], 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() O.Option[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]], func() O.Option[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]], G_T2],
+    Ap[func() O.Option[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]], func() O.Option[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]], G_T3],
+    Ap[func() O.Option[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() O.Option[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]], G_T4],
+    Ap[func() O.Option[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() O.Option[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T5],
+    Ap[func() O.Option[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() O.Option[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T6],
+    Ap[func() O.Option[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() O.Option[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T7],
+    Ap[func() O.Option[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() O.Option[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T8],
+    Ap[func() O.Option[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() O.Option[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T9],
+    Ap[G_TUPLE10, func() O.Option[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T10],
+    f1,
+    f2,
+    f3,
+    f4,
+    f5,
+    f6,
+    f7,
+    f8,
+    f9,
+    f10,
+    t)
+   }
+}

iooption/generic/iooption.go

@@ -0,0 +1,180 @@
+// 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 (
+	"time"
+
+	F "github.com/IBM/fp-go/function"
+	FI "github.com/IBM/fp-go/internal/fromio"
+	"github.com/IBM/fp-go/internal/optiont"
+	IO "github.com/IBM/fp-go/io/generic"
+	O "github.com/IBM/fp-go/option"
+)
+
+// type IOOption[A any] = func() Option[A]
+
+func MakeIO[GA ~func() O.Option[A], A any](f GA) GA {
+	return f
+}
+
+func Of[GA ~func() O.Option[A], A any](r A) GA {
+	return MakeIO(optiont.Of(IO.MonadOf[GA, O.Option[A]], r))
+}
+
+func Some[GA ~func() O.Option[A], A any](r A) GA {
+	return Of[GA](r)
+}
+
+func None[GA ~func() O.Option[A], A any]() GA {
+	return MakeIO(optiont.None(IO.MonadOf[GA, O.Option[A]]))
+}
+
+func MonadOf[GA ~func() O.Option[A], A any](r A) GA {
+	return Of[GA](r)
+}
+
+func FromIO[GA ~func() O.Option[A], GR ~func() A, A any](mr GR) GA {
+	return MakeIO(optiont.OfF(IO.MonadMap[GR, GA, A, O.Option[A]], mr))
+}
+
+func FromOption[GA ~func() O.Option[A], A any](o O.Option[A]) GA {
+	return IO.Of[GA](o)
+}
+
+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)
+}
+
+func Map[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](f func(A) B) func(GA) GB {
+	return F.Bind2nd(MonadMap[GA, GB, A, B], f)
+}
+
+func MonadChain[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](fa GA, f func(A) GB) GB {
+	return optiont.MonadChain(IO.MonadChain[GA, GB, O.Option[A], O.Option[B]], IO.MonadOf[GB, O.Option[B]], fa, f)
+}
+
+func Chain[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](f func(A) GB) func(GA) GB {
+	return F.Bind2nd(MonadChain[GA, GB, A, B], f)
+}
+
+func MonadChainOptionK[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](ma GA, f func(A) O.Option[B]) GB {
+	return optiont.MonadChainOptionK(
+		IO.MonadChain[GA, GB, O.Option[A], O.Option[B]],
+		FromOption[GB, B],
+		ma,
+		f,
+	)
+}
+
+func ChainOptionK[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](f func(A) O.Option[B]) func(GA) GB {
+	return F.Bind2nd(MonadChainOptionK[GA, GB, A, B], f)
+}
+
+func MonadChainIOK[GA ~func() O.Option[A], GB ~func() O.Option[B], GR ~func() B, A, B any](ma GA, f func(A) GR) GB {
+	return FI.MonadChainIOK(
+		MonadChain[GA, GB, A, B],
+		FromIO[GB, GR, B],
+		ma,
+		f,
+	)
+}
+
+func ChainIOK[GA ~func() O.Option[A], GB ~func() O.Option[B], GR ~func() B, A, B any](f func(A) GR) func(GA) GB {
+	return FI.ChainIOK(
+		MonadChain[GA, GB, A, B],
+		FromIO[GB, GR, B],
+		f,
+	)
+}
+
+func MonadAp[GB ~func() O.Option[B], GAB ~func() O.Option[func(A) B], GA ~func() O.Option[A], A, B any](mab GAB, ma GA) GB {
+	return optiont.MonadAp(
+		IO.MonadAp[GA, GB, func() func(O.Option[A]) O.Option[B], O.Option[A], O.Option[B]],
+		IO.MonadMap[GAB, func() func(O.Option[A]) O.Option[B], O.Option[func(A) B], func(O.Option[A]) O.Option[B]],
+		mab, ma)
+}
+
+func Ap[GB ~func() O.Option[B], GAB ~func() O.Option[func(A) B], GA ~func() O.Option[A], A, B any](ma GA) func(GAB) GB {
+	return F.Bind2nd(MonadAp[GB, GAB, GA, A, B], ma)
+}
+
+func Flatten[GA ~func() O.Option[A], GAA ~func() O.Option[GA], A any](mma GAA) GA {
+	return MonadChain(mma, F.Identity[GA])
+}
+
+func Optionize0[GA ~func() O.Option[A], A any](f func() (A, bool)) func() GA {
+	ef := O.Optionize0(f)
+	return func() GA {
+		return MakeIO[GA](ef)
+	}
+}
+
+func Optionize1[GA ~func() O.Option[A], T1, A any](f func(t1 T1) (A, bool)) func(T1) GA {
+	ef := O.Optionize1(f)
+	return func(t1 T1) GA {
+		return MakeIO[GA](func() O.Option[A] {
+			return ef(t1)
+		})
+	}
+}
+
+func Optionize2[GA ~func() O.Option[A], T1, T2, A any](f func(t1 T1, t2 T2) (A, bool)) func(T1, T2) GA {
+	ef := O.Optionize2(f)
+	return func(t1 T1, t2 T2) GA {
+		return MakeIO[GA](func() O.Option[A] {
+			return ef(t1, t2)
+		})
+	}
+}
+
+func Optionize3[GA ~func() O.Option[A], T1, T2, T3, A any](f func(t1 T1, t2 T2, t3 T3) (A, bool)) func(T1, T2, T3) GA {
+	ef := O.Optionize3(f)
+	return func(t1 T1, t2 T2, t3 T3) GA {
+		return MakeIO[GA](func() O.Option[A] {
+			return ef(t1, t2, t3)
+		})
+	}
+}
+
+func Optionize4[GA ~func() O.Option[A], T1, T2, T3, T4, A any](f func(t1 T1, t2 T2, t3 T3, t4 T4) (A, bool)) func(T1, T2, T3, T4) GA {
+	ef := O.Optionize4(f)
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) GA {
+		return MakeIO[GA](func() O.Option[A] {
+			return ef(t1, t2, t3, t4)
+		})
+	}
+}
+
+// Memoize computes the value of the provided IO monad lazily but exactly once
+func Memoize[GA ~func() O.Option[A], A any](ma GA) GA {
+	return IO.Memoize(ma)
+}
+
+// Delay creates an operation that passes in the value after some delay
+func Delay[GA ~func() O.Option[A], A any](delay time.Duration) func(GA) GA {
+	return IO.Delay[GA](delay)
+}
+
+// Fold convers an IOOption into an IO
+func Fold[GA ~func() O.Option[A], GB ~func() B, A, B any](onNone func() GB, onSome func(A) GB) func(GA) GB {
+	return optiont.MatchE(IO.MonadChain[GA, GB, O.Option[A], B], onNone, onSome)
+}
+
+// Defer creates an IO by creating a brand new IO via a generator function, each time
+func Defer[GA ~func() O.Option[A], A any](gen func() GA) GA {
+	return IO.Defer[GA](gen)
+}

iooption/generic/retry.go

@@ -0,0 +1,41 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	O "github.com/IBM/fp-go/option"
+	R "github.com/IBM/fp-go/retry"
+	G "github.com/IBM/fp-go/retry/generic"
+)
+
+// Retry combinator for actions that don't raise exceptions, but
+// signal in their type the outcome has failed. Examples are the
+// `Option`, `Either` and `EitherT` monads.
+func Retrying[GA ~func() O.Option[A], A any](
+	policy R.RetryPolicy,
+	action func(R.RetryStatus) GA,
+	check func(A) bool,
+) GA {
+	// get an implementation for the types
+	return G.Retrying(
+		Chain[GA, GA, A, A],
+		Chain[func() O.Option[R.RetryStatus], GA, R.RetryStatus, A],
+		Of[GA, A],
+		Of[func() O.Option[R.RetryStatus], R.RetryStatus],
+		Delay[func() O.Option[R.RetryStatus], R.RetryStatus],
+
+		policy, action, check)
+}

iooption/generic/traverse.go

@@ -0,0 +1,33 @@
+// 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 (
+	F "github.com/IBM/fp-go/function"
+	I "github.com/IBM/fp-go/io/generic"
+	O "github.com/IBM/fp-go/option"
+)
+
+func TraverseArray[TB ~func() O.Option[B], TBS ~func() O.Option[GB], GA ~[]A, GB ~[]B, A, B any](f func(A) TB) func(GA) TBS {
+	return F.Flow2(
+		I.TraverseArray[TB, func() []O.Option[B], GA](f),
+		I.Map[func() []O.Option[B], TBS](O.SequenceArrayG[GB, []O.Option[B], B]),
+	)
+}
+
+func SequenceArray[TB ~func() O.Option[B], TBS ~func() O.Option[GB], GA ~[]TB, GB ~[]B, A, B any](ma GA) TBS {
+	return TraverseArray[TB, TBS, GA](F.Identity[TB])(ma)
+}

iooption/iooption.go

@@ -0,0 +1,128 @@
+// 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 iooption
+
+import (
+	I "github.com/IBM/fp-go/io"
+	G "github.com/IBM/fp-go/iooption/generic"
+	O "github.com/IBM/fp-go/option"
+)
+
+// IO represents a synchronous computation that may fail
+// refer to [https://andywhite.xyz/posts/2021-01-27-rte-foundations/#ioeitherlte-agt] for more details
+type IOOption[A any] I.IO[O.Option[A]]
+
+func MakeIO[A any](f IOOption[A]) IOOption[A] {
+	return G.MakeIO(f)
+}
+
+func Of[A any](r A) IOOption[A] {
+	return G.Of[IOOption[A]](r)
+}
+
+func Some[A any](r A) IOOption[A] {
+	return G.Some[IOOption[A]](r)
+}
+
+func None[A any]() IOOption[A] {
+	return G.None[IOOption[A]]()
+}
+
+func MonadOf[A any](r A) IOOption[A] {
+	return G.MonadOf[IOOption[A]](r)
+}
+
+func FromOption[A any](o O.Option[A]) IOOption[A] {
+	return G.FromOption[IOOption[A]](o)
+}
+
+func ChainOptionK[A, B any](f func(A) O.Option[B]) func(IOOption[A]) IOOption[B] {
+	return G.ChainOptionK[IOOption[A], IOOption[B]](f)
+}
+
+func MonadChainIOK[A, B any](ma IOOption[A], f func(A) I.IO[B]) IOOption[B] {
+	return G.MonadChainIOK[IOOption[A], IOOption[B]](ma, f)
+}
+
+func ChainIOK[A, B any](f func(A) I.IO[B]) func(IOOption[A]) IOOption[B] {
+	return G.ChainIOK[IOOption[A], IOOption[B]](f)
+}
+
+func FromIO[A any](mr I.IO[A]) IOOption[A] {
+	return G.FromIO[IOOption[A]](mr)
+}
+
+func MonadMap[A, B any](fa IOOption[A], f func(A) B) IOOption[B] {
+	return G.MonadMap[IOOption[A], IOOption[B]](fa, f)
+}
+
+func Map[A, B any](f func(A) B) func(IOOption[A]) IOOption[B] {
+	return G.Map[IOOption[A], IOOption[B]](f)
+}
+
+func MonadChain[A, B any](fa IOOption[A], f func(A) IOOption[B]) IOOption[B] {
+	return G.MonadChain(fa, f)
+}
+
+func Chain[A, B any](f func(A) IOOption[B]) func(IOOption[A]) IOOption[B] {
+	return G.Chain[IOOption[A]](f)
+}
+
+func MonadAp[B, A any](mab IOOption[func(A) B], ma IOOption[A]) IOOption[B] {
+	return G.MonadAp[IOOption[B]](mab, ma)
+}
+
+func Ap[B, A any](ma IOOption[A]) func(IOOption[func(A) B]) IOOption[B] {
+	return G.Ap[IOOption[B], IOOption[func(A) B]](ma)
+}
+
+func Flatten[A any](mma IOOption[IOOption[A]]) IOOption[A] {
+	return G.Flatten(mma)
+}
+
+func Optionize0[A any](f func() (A, bool)) func() IOOption[A] {
+	return G.Optionize0[IOOption[A]](f)
+}
+
+func Optionize1[T1, A any](f func(t1 T1) (A, bool)) func(T1) IOOption[A] {
+	return G.Optionize1[IOOption[A]](f)
+}
+
+func Optionize2[T1, T2, A any](f func(t1 T1, t2 T2) (A, bool)) func(T1, T2) IOOption[A] {
+	return G.Optionize2[IOOption[A]](f)
+}
+
+func Optionize3[T1, T2, T3, A any](f func(t1 T1, t2 T2, t3 T3) (A, bool)) func(T1, T2, T3) IOOption[A] {
+	return G.Optionize3[IOOption[A]](f)
+}
+
+func Optionize4[T1, T2, T3, T4, A any](f func(t1 T1, t2 T2, t3 T3, t4 T4) (A, bool)) func(T1, T2, T3, T4) IOOption[A] {
+	return G.Optionize4[IOOption[A]](f)
+}
+
+func Memoize[A any](ma IOOption[A]) IOOption[A] {
+	return G.Memoize(ma)
+}
+
+// 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)
+}
+
+// Defer creates an IO by creating a brand new IO via a generator function, each time
+func Defer[A any](gen func() IOOption[A]) IOOption[A] {
+	return G.Defer[IOOption[A]](gen)
+}

iooption/iooption_test.go

@@ -0,0 +1,73 @@
+// 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 iooption
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/utils"
+	I "github.com/IBM/fp-go/io"
+	O "github.com/IBM/fp-go/option"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMap(t *testing.T) {
+	assert.Equal(t, O.Of(2), F.Pipe1(
+		Of(1),
+		Map(utils.Double),
+	)())
+
+}
+
+func TestChainOptionK(t *testing.T) {
+	f := ChainOptionK(func(n int) O.Option[int] {
+		if n > 0 {
+			return O.Of(n)
+		}
+		return O.None[int]()
+
+	})
+	assert.Equal(t, O.Of(1), f(Of(1))())
+	assert.Equal(t, O.None[int](), f(Of(-1))())
+	assert.Equal(t, O.None[int](), f(None[int]())())
+}
+
+func TestFromOption(t *testing.T) {
+	f := FromOption[int]
+	assert.Equal(t, O.Of(1), f(O.Some(1))())
+	assert.Equal(t, O.None[int](), f(O.None[int]())())
+}
+
+func TestChainIOK(t *testing.T) {
+	f := ChainIOK(func(n int) I.IO[string] {
+		return I.MakeIO(func() string {
+			return fmt.Sprintf("%d", n)
+		})
+	})
+
+	assert.Equal(t, O.Of("1"), f(Of(1))())
+	assert.Equal(t, O.None[string](), f(None[int]())())
+}
+
+func TestEnv(t *testing.T) {
+	env := Optionize1(os.LookupEnv)
+
+	assert.True(t, O.IsSome(env("PATH")()))
+	assert.False(t, O.IsSome(env("PATHxyz")()))
+}

iooption/retry.go

@@ -0,0 +1,30 @@
+// 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 iooption
+
+import (
+	G "github.com/IBM/fp-go/iooption/generic"
+	R "github.com/IBM/fp-go/retry"
+)
+
+// Retrying will retry the actions according to the check policy
+func Retrying[A any](
+	policy R.RetryPolicy,
+	action func(R.RetryStatus) IOOption[A],
+	check func(A) bool,
+) IOOption[A] {
+	return G.Retrying(policy, action, check)
+}

iterator/stateless/doc.go

@@ -0,0 +1,18 @@
+// 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 defines a stateless (pure) iterator, i.e. one that can be iterated over multiple times without
+// side effects, it is threadsafe
+package stateless

iterator/stateless/generic/iterator.go

@@ -0,0 +1,207 @@
+// 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 (
+	A "github.com/IBM/fp-go/array/generic"
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/utils"
+	IO "github.com/IBM/fp-go/iooption/generic"
+	N "github.com/IBM/fp-go/number/integer"
+	O "github.com/IBM/fp-go/option"
+	T "github.com/IBM/fp-go/tuple"
+)
+
+// From constructs an array from a set of variadic arguments
+func From[GU ~func() O.Option[T.Tuple2[GU, U]], U any](data ...U) GU {
+	return FromArray[GU](data)
+}
+
+// Empty returns the empty iterator
+func Empty[GU ~func() O.Option[T.Tuple2[GU, U]], U any]() GU {
+	return IO.None[GU]()
+}
+
+// Of returns an iterator with one single element
+func Of[GU ~func() O.Option[T.Tuple2[GU, U]], U any](a U) GU {
+	return IO.Of[GU](T.MakeTuple2(Empty[GU](), a))
+}
+
+// FromArray returns an iterator from multiple elements
+func FromArray[GU ~func() O.Option[T.Tuple2[GU, U]], US ~[]U, U any](as US) GU {
+	return A.MatchLeft(Empty[GU], func(head U, tail US) GU {
+		return func() O.Option[T.Tuple2[GU, U]] {
+			return O.Of(T.MakeTuple2(FromArray[GU](tail), head))
+		}
+	})(as)
+}
+
+// Reduce applies a function for each value of the iterator with a floating result
+func Reduce[GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](f func(V, U) V, initial V) func(GU) V {
+	return func(as GU) V {
+		next, ok := O.Unwrap(as())
+		current := initial
+		for ok {
+			// next (with bad side effect)
+			current = f(current, next.F2)
+			next, ok = O.Unwrap(next.F1())
+		}
+		return current
+	}
+}
+
+// ToArray converts the iterator to an array
+func ToArray[GU ~func() O.Option[T.Tuple2[GU, U]], US ~[]U, U any](u GU) US {
+	return Reduce[GU](A.Append[US], A.Empty[US]())(u)
+}
+
+func Map[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(U) V, U, V any](f FCT) func(ma GU) GV {
+	// pre-declare to avoid cyclic reference
+	var m func(O.Option[T.Tuple2[GU, U]]) O.Option[T.Tuple2[GV, V]]
+
+	recurse := func(ma GU) GV {
+		return F.Nullary2(
+			ma,
+			m,
+		)
+	}
+	m = O.Map(T.Map2(recurse, f))
+
+	return recurse
+}
+
+func MonadMap[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](ma GU, f func(U) V) GV {
+	return Map[GV, GU](f)(ma)
+}
+
+func concat[GU ~func() O.Option[T.Tuple2[GU, U]], U any](right, left GU) GU {
+	var m func(ma O.Option[T.Tuple2[GU, U]]) O.Option[T.Tuple2[GU, U]]
+
+	recurse := func(left GU) GU {
+		return F.Nullary2(left, m)
+	}
+
+	m = O.Fold(
+		right,
+		F.Flow2(
+			T.Map2(recurse, F.Identity[U]),
+			O.Some[T.Tuple2[GU, U]],
+		))
+
+	return recurse(left)
+}
+
+func Chain[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](f func(U) GV) func(GU) GV {
+	// pre-declare to avoid cyclic reference
+	var m func(O.Option[T.Tuple2[GU, U]]) O.Option[T.Tuple2[GV, V]]
+
+	recurse := func(ma GU) GV {
+		return F.Nullary2(
+			ma,
+			m,
+		)
+	}
+	m = O.Chain(
+		F.Flow3(
+			T.Map2(recurse, f),
+			T.Tupled2(concat[GV]),
+			func(v GV) O.Option[T.Tuple2[GV, V]] {
+				return v()
+			},
+		),
+	)
+
+	return recurse
+}
+
+func MonadChain[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](ma GU, f func(U) GV) GV {
+	return Chain[GV, GU](f)(ma)
+}
+
+func Flatten[GV ~func() O.Option[T.Tuple2[GV, GU]], GU ~func() O.Option[T.Tuple2[GU, U]], U any](ma GV) GU {
+	return MonadChain(ma, F.Identity[GU])
+}
+
+// MakeBy returns an [Iterator] with `n` elements initialized with `f(i)`
+func MakeBy[GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(int) U, U any](n int, f FCT) GU {
+
+	var m func(int) O.Option[T.Tuple2[GU, U]]
+
+	recurse := func(i int) GU {
+		return func() O.Option[T.Tuple2[GU, U]] {
+			return F.Pipe1(
+				i,
+				m,
+			)
+		}
+	}
+
+	m = F.Flow2(
+		O.FromPredicate(N.Between(0, n)),
+		O.Map(F.Flow2(
+			T.Replicate2[int],
+			T.Map2(F.Flow2(
+				utils.Inc,
+				recurse),
+				f),
+		)),
+	)
+
+	// bootstrap
+	return recurse(0)
+}
+
+// Replicate creates an [Iterator] containing a value repeated the specified number of times.
+func Replicate[GU ~func() O.Option[T.Tuple2[GU, U]], U any](n int, a U) GU {
+	return MakeBy[GU](n, F.Constant1[int](a))
+}
+
+func FilterMap[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(U) O.Option[V], U, V any](f FCT) func(ma GU) GV {
+	// pre-declare to avoid cyclic reference
+	var m func(O.Option[T.Tuple2[GU, U]]) O.Option[T.Tuple2[GV, V]]
+
+	recurse := func(ma GU) GV {
+		return F.Nullary2(
+			ma,
+			m,
+		)
+	}
+
+	m = O.Fold(
+		Empty[GV](),
+		func(t T.Tuple2[GU, U]) O.Option[T.Tuple2[GV, V]] {
+			r := recurse(t.F1)
+			return O.MonadFold(f(t.F2), r, F.Flow2(
+				F.Bind1st(T.MakeTuple2[GV, V], r),
+				O.Some[T.Tuple2[GV, V]],
+			))
+		},
+	)
+
+	return recurse
+}
+
+func Filter[GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(U) bool, U any](f FCT) func(ma GU) GU {
+	return FilterMap[GU, GU](O.FromPredicate(f))
+}
+
+func Ap[GUV ~func() O.Option[T.Tuple2[GUV, func(U) V]], GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](ma GU) func(fab GUV) GV {
+	return Chain[GV, GUV](F.Bind1st(MonadMap[GV, GU], ma))
+}
+
+func MonadAp[GUV ~func() O.Option[T.Tuple2[GUV, func(U) V]], GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](fab GUV, ma GU) GV {
+	return Ap[GUV, GV, GU](ma)(fab)
+}

iterator/stateless/generic/monoid.go

@@ -0,0 +1,30 @@
+// 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 (
+	F "github.com/IBM/fp-go/function"
+	M "github.com/IBM/fp-go/monoid"
+	O "github.com/IBM/fp-go/option"
+	T "github.com/IBM/fp-go/tuple"
+)
+
+func Monoid[GU ~func() O.Option[T.Tuple2[GU, U]], U any]() M.Monoid[GU] {
+	return M.MakeMonoid(
+		F.Swap(concat[GU]),
+		Empty[GU](),
+	)
+}

iterator/stateless/iterator.go

@@ -0,0 +1,109 @@
+// 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 (
+	G "github.com/IBM/fp-go/iterator/stateless/generic"
+	L "github.com/IBM/fp-go/lazy"
+	O "github.com/IBM/fp-go/option"
+	T "github.com/IBM/fp-go/tuple"
+)
+
+// Iterator represents a stateless, pure way to iterate over a sequence
+type Iterator[U any] L.Lazy[O.Option[T.Tuple2[Iterator[U], U]]]
+
+// Empty returns the empty iterator
+func Empty[U any]() Iterator[U] {
+	return G.Empty[Iterator[U]]()
+}
+
+// Of returns an iterator with one single element
+func Of[U any](a U) Iterator[U] {
+	return G.Of[Iterator[U]](a)
+}
+
+// FromArray returns an iterator from multiple elements
+func FromArray[U any](as []U) Iterator[U] {
+	return G.FromArray[Iterator[U]](as)
+}
+
+// ToArray converts the iterator to an array
+func ToArray[U any](u Iterator[U]) []U {
+	return G.ToArray[Iterator[U], []U](u)
+}
+
+// Reduce applies a function for each value of the iterator with a floating result
+func Reduce[U, V any](f func(V, U) V, initial V) func(Iterator[U]) V {
+	return G.Reduce[Iterator[U]](f, initial)
+}
+
+// MonadMap transforms an [Iterator] of type [U] into an [Iterator] of type [V] via a mapping function
+func MonadMap[U, V any](ma Iterator[U], f func(U) V) Iterator[V] {
+	return G.MonadMap[Iterator[V], Iterator[U]](ma, f)
+}
+
+// Map transforms an [Iterator] of type [U] into an [Iterator] of type [V] via a mapping function
+func Map[U, V any](f func(U) V) func(ma Iterator[U]) Iterator[V] {
+	return G.Map[Iterator[V], Iterator[U]](f)
+}
+
+func MonadChain[U, V any](ma Iterator[U], f func(U) Iterator[V]) Iterator[V] {
+	return G.MonadChain[Iterator[V], Iterator[U]](ma, f)
+}
+
+func Chain[U, V any](f func(U) Iterator[V]) func(Iterator[U]) Iterator[V] {
+	return G.Chain[Iterator[V], Iterator[U]](f)
+}
+
+// Flatten converts an [Iterator] of [Iterator] into a simple [Iterator]
+func Flatten[U any](ma Iterator[Iterator[U]]) Iterator[U] {
+	return G.Flatten[Iterator[Iterator[U]], Iterator[U]](ma)
+}
+
+// From constructs an [Iterator] from a set of variadic arguments
+func From[U any](data ...U) Iterator[U] {
+	return G.From[Iterator[U]](data...)
+}
+
+// MakeBy returns an [Iterator] with `n` elements initialized with `f(i)`
+func MakeBy[FCT ~func(int) U, U any](n int, f FCT) Iterator[U] {
+	return G.MakeBy[Iterator[U]](n, f)
+}
+
+// Replicate creates an [Iterator] containing a value repeated the specified number of times.
+func Replicate[U any](n int, a U) Iterator[U] {
+	return G.Replicate[Iterator[U]](n, a)
+}
+
+// FilterMap filters and transforms the content of an iterator
+func FilterMap[U, V any](f func(U) O.Option[V]) func(ma Iterator[U]) Iterator[V] {
+	return G.FilterMap[Iterator[V], Iterator[U]](f)
+}
+
+// Filter filters the content of an iterator
+func Filter[U any](f func(U) bool) func(ma Iterator[U]) Iterator[U] {
+	return G.Filter[Iterator[U]](f)
+}
+
+// Ap is the applicative functor for iterators
+func Ap[V, U any](ma Iterator[U]) func(Iterator[func(U) V]) Iterator[V] {
+	return G.Ap[Iterator[func(U) V], Iterator[V]](ma)
+}
+
+// MonadAp is the applicative functor for iterators
+func MonadAp[V, U any](fab Iterator[func(U) V], ma Iterator[U]) Iterator[V] {
+	return G.MonadAp[Iterator[func(U) V], Iterator[V]](fab, ma)
+}

iterator/stateless/iterator_test.go

@@ -0,0 +1,103 @@
+// 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 (
+	"fmt"
+	"math"
+	"testing"
+
+	A "github.com/IBM/fp-go/array"
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/utils"
+	O "github.com/IBM/fp-go/option"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIterator(t *testing.T) {
+
+	result := F.Pipe2(
+		A.From(1, 2, 3),
+		FromArray[int],
+		Reduce(utils.Sum, 0),
+	)
+
+	assert.Equal(t, 6, result)
+}
+
+func TestChain(t *testing.T) {
+
+	outer := From(1, 2, 3)
+
+	inner := func(data int) Iterator[string] {
+		return F.Pipe2(
+			A.From(0, 1),
+			FromArray[int],
+			Map(func(idx int) string {
+				return fmt.Sprintf("item[%d][%d]", data, idx)
+			}),
+		)
+	}
+
+	total := F.Pipe2(
+		outer,
+		Chain(inner),
+		ToArray[string],
+	)
+
+	assert.Equal(t, A.From("item[1][0]", "item[1][1]", "item[2][0]", "item[2][1]", "item[3][0]", "item[3][1]"), total)
+}
+
+func isPrimeNumber(num int) bool {
+	if num <= 2 {
+		return true
+	}
+	sq_root := int(math.Sqrt(float64(num)))
+	for i := 2; i <= sq_root; i++ {
+		if num%i == 0 {
+			return false
+		}
+	}
+	return true
+}
+
+func TestFilterMap(t *testing.T) {
+
+	it := F.Pipe2(
+		MakeBy(100, utils.Inc),
+		FilterMap(O.FromPredicate(isPrimeNumber)),
+		ToArray[int],
+	)
+
+	assert.Equal(t, A.From(1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97), it)
+}
+
+func TestAp(t *testing.T) {
+
+	f := F.Curry3(func(s1 string, n int, s2 string) string {
+		return fmt.Sprintf("%s-%d-%s", s1, n, s2)
+	})
+
+	it := F.Pipe4(
+		Of(f),
+		Ap[func(int) func(string) string](From("a", "b")),
+		Ap[func(string) string](From(1, 2)),
+		Ap[string](From("c", "d")),
+		ToArray[string],
+	)
+
+	assert.Equal(t, A.From("a-1-c", "a-1-d", "a-2-c", "a-2-d", "b-1-c", "b-1-d", "b-2-c", "b-2-d"), it)
+}

iterator/stateless/monoid.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 stateless
+
+import (
+	G "github.com/IBM/fp-go/iterator/stateless/generic"
+	M "github.com/IBM/fp-go/monoid"
+)
+
+// Monoid contructs a [M.Monoid] that concatenates two [Iterator]s
+func Monoid[U any]() M.Monoid[Iterator[U]] {
+	return G.Monoid[Iterator[U]]()
+}

lambda/y.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 lambda
+
+type (
+	// RecFct is the function called recursively
+	RecFct[T, R any] func(T) R
+
+	// transformer
+	Transformer[T, R any] func(RecFct[T, R]) RecFct[T, R]
+
+	internalCombinator[T, R any] func(internalCombinator[T, R]) RecFct[T, R]
+)
+
+// Y is the Y-combinator based on https://dreamsongs.com/Files/WhyOfY.pdf
+func Y[T, R any](f Transformer[T, R]) RecFct[T, R] {
+	g := func(h internalCombinator[T, R]) RecFct[T, R] {
+		return func(t T) R {
+			return f(h(h))(t)
+		}
+	}
+	return g(g)
+}

lambda/y_test.go

@@ -0,0 +1,34 @@
+// 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 lambda
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestFactorial(t *testing.T) {
+	fct := Y(func(r RecFct[int, int]) RecFct[int, int] {
+		return func(n int) int {
+			if n <= 0 {
+				return 1
+			}
+			return n * r(n-1)
+		}
+	})
+
+	fmt.Println(fct(10))
+}

lazy/apply.go

@@ -0,0 +1,30 @@
+// 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 lazy
+
+import (
+	G "github.com/IBM/fp-go/io/generic"
+	M "github.com/IBM/fp-go/monoid"
+	S "github.com/IBM/fp-go/semigroup"
+)
+
+func ApplySemigroup[A any](s S.Semigroup[A]) S.Semigroup[Lazy[A]] {
+	return G.ApplySemigroup[Lazy[A]](s)
+}
+
+func ApplicativeMonoid[A any](m M.Monoid[A]) M.Monoid[Lazy[A]] {
+	return G.ApplicativeMonoid[Lazy[A]](m)
+}

lazy/eq.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 lazy
+
+import (
+	EQ "github.com/IBM/fp-go/eq"
+	G "github.com/IBM/fp-go/io/generic"
+)
+
+// Eq implements the equals predicate for values contained in the IO monad
+func Eq[A any](e EQ.Eq[A]) EQ.Eq[Lazy[A]] {
+	return G.Eq[Lazy[A]](e)
+}

lazy/lazy.go

@@ -0,0 +1,139 @@
+// 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 lazy
+
+import (
+	"time"
+
+	G "github.com/IBM/fp-go/io/generic"
+)
+
+// Lazy represents a synchronous computation without side effects
+type Lazy[A any] func() A
+
+func MakeLazy[A any](f func() A) Lazy[A] {
+	return G.MakeIO[Lazy[A]](f)
+}
+
+func Of[A any](a A) Lazy[A] {
+	return G.Of[Lazy[A]](a)
+}
+
+func FromLazy[A any](a Lazy[A]) Lazy[A] {
+	return G.FromIO(a)
+}
+
+// FromImpure converts a side effect without a return value into a side effect that returns any
+func FromImpure(f func()) Lazy[any] {
+	return G.FromImpure[Lazy[any]](f)
+}
+
+func MonadOf[A any](a A) Lazy[A] {
+	return G.MonadOf[Lazy[A]](a)
+}
+
+func MonadMap[A, B any](fa Lazy[A], f func(A) B) Lazy[B] {
+	return G.MonadMap[Lazy[A], Lazy[B]](fa, f)
+}
+
+func Map[A, B any](f func(A) B) func(fa Lazy[A]) Lazy[B] {
+	return G.Map[Lazy[A], Lazy[B]](f)
+}
+
+func MonadMapTo[A, B any](fa Lazy[A], b B) Lazy[B] {
+	return G.MonadMapTo[Lazy[A], Lazy[B]](fa, b)
+}
+
+func MapTo[A, B any](b B) func(Lazy[A]) Lazy[B] {
+	return G.MapTo[Lazy[A], Lazy[B]](b)
+}
+
+// MonadChain composes computations in sequence, using the return value of one computation to determine the next computation.
+func MonadChain[A, B any](fa Lazy[A], f func(A) Lazy[B]) Lazy[B] {
+	return G.MonadChain(fa, f)
+}
+
+// Chain composes computations in sequence, using the return value of one computation to determine the next computation.
+func Chain[A, B any](f func(A) Lazy[B]) func(Lazy[A]) Lazy[B] {
+	return G.Chain[Lazy[A]](f)
+}
+
+func MonadAp[B, A any](mab Lazy[func(A) B], ma Lazy[A]) Lazy[B] {
+	return G.MonadAp[Lazy[A], Lazy[B]](mab, ma)
+}
+
+func Ap[B, A any](ma Lazy[A]) func(Lazy[func(A) B]) Lazy[B] {
+	return G.Ap[Lazy[B], Lazy[func(A) B], Lazy[A]](ma)
+}
+
+func Flatten[A any](mma Lazy[Lazy[A]]) Lazy[A] {
+	return G.Flatten(mma)
+}
+
+// Memoize computes the value of the provided IO monad lazily but exactly once
+func Memoize[A any](ma Lazy[A]) Lazy[A] {
+	return G.Memoize(ma)
+}
+
+// MonadChainFirst composes computations in sequence, using the return value of one computation to determine the next computation and
+// keeping only the result of the first.
+func MonadChainFirst[A, B any](fa Lazy[A], f func(A) Lazy[B]) Lazy[A] {
+	return G.MonadChainFirst(fa, f)
+}
+
+// ChainFirst composes computations in sequence, using the return value of one computation to determine the next computation and
+// keeping only the result of the first.
+func ChainFirst[A, B any](f func(A) Lazy[B]) func(Lazy[A]) Lazy[A] {
+	return G.ChainFirst[Lazy[A]](f)
+}
+
+// MonadApFirst combines two effectful actions, keeping only the result of the first.
+func MonadApFirst[A, B any](first Lazy[A], second Lazy[B]) Lazy[A] {
+	return G.MonadApFirst[Lazy[A], Lazy[B], Lazy[func(B) A]](first, second)
+}
+
+// ApFirst combines two effectful actions, keeping only the result of the first.
+func ApFirst[A, B any](second Lazy[B]) func(Lazy[A]) Lazy[A] {
+	return G.ApFirst[Lazy[A], Lazy[B], Lazy[func(B) A]](second)
+}
+
+// MonadApSecond combines two effectful actions, keeping only the result of the second.
+func MonadApSecond[A, B any](first Lazy[A], second Lazy[B]) Lazy[B] {
+	return G.MonadApSecond[Lazy[A], Lazy[B], Lazy[func(B) B]](first, second)
+}
+
+// ApSecond combines two effectful actions, keeping only the result of the second.
+func ApSecond[A, B any](second Lazy[B]) func(Lazy[A]) Lazy[B] {
+	return G.ApSecond[Lazy[A], Lazy[B], Lazy[func(B) B]](second)
+}
+
+// MonadChainTo composes computations in sequence, ignoring the return value of the first computation
+func MonadChainTo[A, B any](fa Lazy[A], fb Lazy[B]) Lazy[B] {
+	return G.MonadChainTo(fa, fb)
+}
+
+// ChainTo composes computations in sequence, ignoring the return value of the first computation
+func ChainTo[A, B any](fb Lazy[B]) func(Lazy[A]) Lazy[B] {
+	return G.ChainTo[Lazy[A]](fb)
+}
+
+// Now returns the current timestamp
+var Now = G.Now[Lazy[time.Time]]()
+
+// Defer creates an IO by creating a brand new IO via a generator function, each time
+func Defer[A any](gen func() Lazy[A]) Lazy[A] {
+	return G.Defer[Lazy[A]](gen)
+}

lazy/lazy_test.go

@@ -0,0 +1,73 @@
+// 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 lazy
+
+import (
+	"math/rand"
+	"testing"
+
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/utils"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMap(t *testing.T) {
+	assert.Equal(t, 2, F.Pipe1(Of(1), Map(utils.Double))())
+}
+
+func TestChain(t *testing.T) {
+	f := func(n int) Lazy[int] {
+		return Of(n * 2)
+	}
+	assert.Equal(t, 2, F.Pipe1(Of(1), Chain(f))())
+}
+
+func TestAp(t *testing.T) {
+	assert.Equal(t, 2, F.Pipe1(Of(utils.Double), Ap[int, int](Of(1)))())
+}
+
+func TestFlatten(t *testing.T) {
+	assert.Equal(t, 1, F.Pipe1(Of(Of(1)), Flatten[int])())
+}
+
+func TestMemoize(t *testing.T) {
+	data := Memoize(MakeLazy(rand.Int))
+
+	value1 := data()
+	value2 := data()
+
+	assert.Equal(t, value1, value2)
+}
+
+func TestApFirst(t *testing.T) {
+
+	x := F.Pipe1(
+		Of("a"),
+		ApFirst[string](Of("b")),
+	)
+
+	assert.Equal(t, "a", x())
+}
+
+func TestApSecond(t *testing.T) {
+
+	x := F.Pipe1(
+		Of("a"),
+		ApSecond[string](Of("b")),
+	)
+
+	assert.Equal(t, "b", x())
+}

lazy/retry.go

@@ -0,0 +1,34 @@
+// 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 lazy
+
+import (
+	G "github.com/IBM/fp-go/io/generic"
+	R "github.com/IBM/fp-go/retry"
+)
+
+// Retrying will retry the actions according to the check policy
+//
+// policy - refers to the retry policy
+// action - converts a status into an operation to be executed
+// check  - checks if the result of the action needs to be retried
+func Retrying[A any](
+	policy R.RetryPolicy,
+	action func(R.RetryStatus) Lazy[A],
+	check func(A) bool,
+) Lazy[A] {
+	return G.Retrying(policy, action, check)
+}

lazy/retry_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 lazy
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	R "github.com/IBM/fp-go/retry"
+	"github.com/stretchr/testify/assert"
+)
+
+var expLogBackoff = R.ExponentialBackoff(10)
+
+// our retry policy with a 1s cap
+var testLogPolicy = R.CapDelay(
+	2*time.Second,
+	R.Monoid.Concat(expLogBackoff, R.LimitRetries(20)),
+)
+
+func TestRetry(t *testing.T) {
+	action := func(status R.RetryStatus) Lazy[string] {
+		return Of(fmt.Sprintf("Retrying %d", status.IterNumber))
+	}
+	check := func(value string) bool {
+		return !strings.Contains(value, "5")
+	}
+
+	r := Retrying(testLogPolicy, action, check)
+
+	assert.Equal(t, "Retrying 5", r())
+}

lazy/sequence.go

@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package io
+package lazy
 
 import (
 	G "github.com/IBM/fp-go/io/generic"
@@ -22,18 +22,18 @@ import (
 
 // SequenceT converts n inputs of higher kinded types into a higher kinded types of n strongly typed values, represented as a tuple
 
-func SequenceT1[A any](a IO[A]) IO[T.Tuple1[A]] {
-	return G.SequenceT1[IO[A], IO[T.Tuple1[A]]](a)
+func SequenceT1[A any](a Lazy[A]) Lazy[T.Tuple1[A]] {
+	return G.SequenceT1[Lazy[T.Tuple1[A]]](a)
 }
 
-func SequenceT2[A, B any](a IO[A], b IO[B]) IO[T.Tuple2[A, B]] {
-	return G.SequenceT2[IO[A], IO[B], IO[T.Tuple2[A, B]]](a, b)
+func SequenceT2[A, B any](a Lazy[A], b Lazy[B]) Lazy[T.Tuple2[A, B]] {
+	return G.SequenceT2[Lazy[T.Tuple2[A, B]]](a, b)
 }
 
-func SequenceT3[A, B, C any](a IO[A], b IO[B], c IO[C]) IO[T.Tuple3[A, B, C]] {
-	return G.SequenceT3[IO[A], IO[B], IO[C], IO[T.Tuple3[A, B, C]]](a, b, c)
+func SequenceT3[A, B, C any](a Lazy[A], b Lazy[B], c Lazy[C]) Lazy[T.Tuple3[A, B, C]] {
+	return G.SequenceT3[Lazy[T.Tuple3[A, B, C]]](a, b, c)
 }
 
-func SequenceT4[A, B, C, D any](a IO[A], b IO[B], c IO[C], d IO[D]) IO[T.Tuple4[A, B, C, D]] {
-	return G.SequenceT4[IO[A], IO[B], IO[C], IO[D], IO[T.Tuple4[A, B, C, D]]](a, b, c, d)
+func SequenceT4[A, B, C, D any](a Lazy[A], b Lazy[B], c Lazy[C], d Lazy[D]) Lazy[T.Tuple4[A, B, C, D]] {
+	return G.SequenceT4[Lazy[T.Tuple4[A, B, C, D]]](a, b, c, d)
 }

lazy/testing/laws.go

@@ -0,0 +1,74 @@
+// 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 testing
+
+import (
+	"testing"
+
+	EQ "github.com/IBM/fp-go/eq"
+	L "github.com/IBM/fp-go/internal/monad/testing"
+	"github.com/IBM/fp-go/lazy"
+)
+
+// AssertLaws asserts the apply monad laws for the `Either` monad
+func AssertLaws[A, B, C any](t *testing.T,
+	eqa EQ.Eq[A],
+	eqb EQ.Eq[B],
+	eqc EQ.Eq[C],
+
+	ab func(A) B,
+	bc func(B) C,
+) func(a A) bool {
+
+	return L.AssertLaws(t,
+		lazy.Eq(eqa),
+		lazy.Eq(eqb),
+		lazy.Eq(eqc),
+
+		lazy.Of[A],
+		lazy.Of[B],
+		lazy.Of[C],
+
+		lazy.Of[func(A) A],
+		lazy.Of[func(A) B],
+		lazy.Of[func(B) C],
+		lazy.Of[func(func(A) B) B],
+
+		lazy.MonadMap[A, A],
+		lazy.MonadMap[A, B],
+		lazy.MonadMap[A, C],
+		lazy.MonadMap[B, C],
+
+		lazy.MonadMap[func(B) C, func(func(A) B) func(A) C],
+
+		lazy.MonadChain[A, A],
+		lazy.MonadChain[A, B],
+		lazy.MonadChain[A, C],
+		lazy.MonadChain[B, C],
+
+		lazy.MonadAp[A, A],
+		lazy.MonadAp[B, A],
+		lazy.MonadAp[C, B],
+		lazy.MonadAp[C, A],
+
+		lazy.MonadAp[B, func(A) B],
+		lazy.MonadAp[func(A) C, func(A) B],
+
+		ab,
+		bc,
+	)
+
+}

lazy/testing/laws_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 testing
+
+import (
+	"fmt"
+	"testing"
+
+	EQ "github.com/IBM/fp-go/eq"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMonadLaws(t *testing.T) {
+	// some comparison
+	eqa := EQ.FromStrictEquals[bool]()
+	eqb := EQ.FromStrictEquals[int]()
+	eqc := EQ.FromStrictEquals[string]()
+
+	ab := func(a bool) int {
+		if a {
+			return 1
+		}
+		return 0
+	}
+
+	bc := func(b int) string {
+		return fmt.Sprintf("value %d", b)
+	}
+
+	laws := AssertLaws(t, eqa, eqb, eqc, ab, bc)
+
+	assert.True(t, laws(true))
+	assert.True(t, laws(false))
+}

lazy/traverse.go

@@ -0,0 +1,50 @@
+// 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 lazy
+
+import (
+	G "github.com/IBM/fp-go/io/generic"
+)
+
+func MonadTraverseArray[A, B any](tas []A, f func(A) Lazy[B]) Lazy[[]B] {
+	return G.MonadTraverseArray[Lazy[B], Lazy[[]B]](tas, f)
+}
+
+// TraverseArray applies a function returning an [IO] to all elements in an array and the
+// transforms this into an [IO] of that array
+func TraverseArray[A, B any](f func(A) Lazy[B]) func([]A) Lazy[[]B] {
+	return G.TraverseArray[Lazy[B], Lazy[[]B], []A](f)
+}
+
+// SequenceArray converts an array of [IO] to an [IO] of an array
+func SequenceArray[A any](tas []Lazy[A]) Lazy[[]A] {
+	return G.SequenceArray[Lazy[A], Lazy[[]A]](tas)
+}
+
+func MonadTraverseRecord[K comparable, A, B any](tas map[K]A, f func(A) Lazy[B]) Lazy[map[K]B] {
+	return G.MonadTraverseRecord[Lazy[B], Lazy[map[K]B]](tas, f)
+}
+
+// TraverseArray applies a function returning an [IO] to all elements in a record and the
+// transforms this into an [IO] of that record
+func TraverseRecord[K comparable, A, B any](f func(A) Lazy[B]) func(map[K]A) Lazy[map[K]B] {
+	return G.TraverseRecord[Lazy[B], Lazy[map[K]B], map[K]A](f)
+}
+
+// SequenceRecord converts a record of [IO] to an [IO] of a record
+func SequenceRecord[K comparable, A any](tas map[K]Lazy[A]) Lazy[map[K]A] {
+	return G.SequenceRecord[Lazy[A], Lazy[map[K]A]](tas)
+}

number/integer/ord.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 integer
+
+import (
+	O "github.com/IBM/fp-go/ord"
+)
+
+// Ord is the strict ordering for integers
+var Ord = O.FromStrictCompare[int]()
+
+// Between checks if an integer is between two values
+var Between = O.Between[int](Ord)

number/magma.go

@@ -19,7 +19,7 @@ import (
 	M "github.com/IBM/fp-go/magma"
 )
 
-func MagmaSub[A int | int8 | int16 | int32 | int64 | float32 | float64 | complex64 | complex128]() M.Magma[A] {
+func MagmaSub[A Number]() M.Magma[A] {
 	return M.MakeMagma(func(first A, second A) A {
 		return first - second
 	})

number/monoid.go

@@ -19,7 +19,7 @@ import (
 	M "github.com/IBM/fp-go/monoid"
 )
 
-func MonoidSum[A int | int8 | int16 | int32 | int64 | float32 | float64 | complex64 | complex128]() M.Monoid[A] {
+func MonoidSum[A Number]() M.Monoid[A] {
 	s := SemigroupSum[A]()
 	return M.MakeMonoid(
 		s.Concat,

number/semigroup.go

@@ -19,7 +19,7 @@ import (
 	S "github.com/IBM/fp-go/semigroup"
 )
 
-func SemigroupSum[A int | int8 | int16 | int32 | int64 | float32 | float64 | complex64 | complex128]() S.Semigroup[A] {
+func SemigroupSum[A Number]() S.Semigroup[A] {
 	return S.MakeSemigroup(func(first A, second A) A {
 		return first + second
 	})

number/utils.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 number
+
+import (
+	C "github.com/IBM/fp-go/constraints"
+)
+
+type Number interface {
+	C.Integer | C.Float | C.Complex
+}
+
+// Add is a curried function used to add two numbers
+func Add[T Number](left T) func(T) T {
+	return func(right T) T {
+		return left + right
+	}
+}
+
+// Inc is a function that increments a number
+func Inc[T Number](value T) T {
+	return value + 1
+}

ord/ord.go

@@ -170,7 +170,7 @@ func Geq[A any](O Ord[A]) func(A) func(A) bool {
 	}
 }
 
-// Test whether a value is between a minimum (inclusive) and a maximum (exclusive)
+// Between tests whether a value is between a minimum (inclusive) and a maximum (exclusive)
 func Between[A any](O Ord[A]) func(A, A) func(A) bool {
 	lt := Lt(O)
 	geq := Geq(O)

predicate/bool.go

@@ -17,7 +17,7 @@ package predicate
 
 func Not[A any](predicate func(A) bool) func(A) bool {
 	return func(a A) bool {
-		return !predicate((a))
+		return !predicate(a)
 	}
 }
 

reader/gen.go

@@ -15,75 +15,76 @@
 
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-21 10:23:01.7578306 +0200 CEST m=+0.326481301
+// 2023-07-28 22:49:14.4173227 +0200 CEST m=+0.013163201
 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

@@ -15,115 +15,116 @@
 
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-21 10:23:01.8951242 +0200 CEST m=+0.463774901
+// 2023-07-28 22:49:14.4173227 +0200 CEST m=+0.013163201
 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)
+    })
+  }
 }

readerio/ap.go

@@ -20,21 +20,21 @@ import (
 )
 
 // MonadApFirst combines two effectful actions, keeping only the result of the first.
-func MonadApFirst[R, A, B any](first ReaderIO[R, A], second ReaderIO[R, B]) ReaderIO[R, A] {
+func MonadApFirst[A, R, B any](first ReaderIO[R, A], second ReaderIO[R, B]) ReaderIO[R, A] {
 	return G.MonadApFirst[ReaderIO[R, A], ReaderIO[R, B], ReaderIO[R, func(B) A]](first, second)
 }
 
 // ApFirst combines two effectful actions, keeping only the result of the first.
-func ApFirst[R, A, B any](second ReaderIO[R, B]) func(ReaderIO[R, A]) ReaderIO[R, A] {
+func ApFirst[A, R, B any](second ReaderIO[R, B]) func(ReaderIO[R, A]) ReaderIO[R, A] {
 	return G.ApFirst[ReaderIO[R, A], ReaderIO[R, B], ReaderIO[R, func(B) A]](second)
 }
 
 // MonadApSecond combines two effectful actions, keeping only the result of the second.
-func MonadApSecond[R, A, B any](first ReaderIO[R, A], second ReaderIO[R, B]) ReaderIO[R, B] {
+func MonadApSecond[A, R, B any](first ReaderIO[R, A], second ReaderIO[R, B]) ReaderIO[R, B] {
 	return G.MonadApSecond[ReaderIO[R, A], ReaderIO[R, B], ReaderIO[R, func(B) B]](first, second)
 }
 
 // ApSecond combines two effectful actions, keeping only the result of the second.
-func ApSecond[R, A, B any](second ReaderIO[R, B]) func(ReaderIO[R, A]) ReaderIO[R, B] {
+func ApSecond[A, R, B any](second ReaderIO[R, B]) func(ReaderIO[R, A]) ReaderIO[R, B] {
 	return G.ApSecond[ReaderIO[R, A], ReaderIO[R, B], ReaderIO[R, func(B) B]](second)
 }

readerioeither/gen.go

@@ -15,141 +15,142 @@
 
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-21 10:23:04.372044 +0200 CEST m=+0.068576501
+// 2023-07-28 22:49:16.5272334 +0200 CEST m=+0.043108701
 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

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