fix: auto generate more sequence operations

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

array/array.go

@@ -230,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))
 	}

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)
 

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

constraints/constraints.go

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

context/readerioeither/gen.go

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

context/readerioeither/generic/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)()
 		}
 	}
 }

function/binds.go

@@ -1,469 +1,450 @@
-// 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-21 10:22:49.808764 +0200 CEST m=+0.064638701
+// 2023-07-27 22:37:37.5265731 +0200 CEST m=+0.007877601
 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

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

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

@@ -0,0 +1,375 @@
+// Code generated by go generate; DO NOT EDIT.
+// This file was generated by robots at
+// 2023-07-27 22:37:50.7171035 +0200 CEST m=+0.017994101
+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,830 @@
+// Code generated by go generate; DO NOT EDIT.
+// This file was generated by robots at
+// 2023-07-27 22:37:50.7191132 +0200 CEST m=+0.020003801
+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/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/sequence.go

@@ -1,39 +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 io
-
-import (
-	G "github.com/IBM/fp-go/io/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[A any](a IO[A]) IO[T.Tuple1[A]] {
-	return G.SequenceT1[IO[A], IO[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 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 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)
-}

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

@@ -0,0 +1,485 @@
+// Code generated by go generate; DO NOT EDIT.
+// This file was generated by robots at
+// 2023-07-27 22:37:53.458059 +0200 CEST m=+0.148734701
+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

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

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/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,375 @@
+// Code generated by go generate; DO NOT EDIT.
+// This file was generated by robots at
+// 2023-07-27 22:37:57.0377326 +0200 CEST m=+0.017325101
+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,831 @@
+// Code generated by go generate; DO NOT EDIT.
+// This file was generated by robots at
+// 2023-07-27 22:37:57.0377326 +0200 CEST m=+0.017325101
+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

@@ -101,15 +101,15 @@ func ChainIOK[GA ~func() O.Option[A], GB ~func() O.Option[B], GR ~func() B, A, B
 	)
 }
 
-func MonadAp[GA ~func() O.Option[A], GB ~func() O.Option[B], GAB ~func() O.Option[func(A) B], A, B any](mab GAB, ma GA) GB {
+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[GA ~func() O.Option[A], GB ~func() O.Option[B], GAB ~func() O.Option[func(A) B], A, B any](ma GA) func(GAB) GB {
-	return F.Bind2nd(MonadAp[GA, GB, GAB, A, B], 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 {

iooption/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 (
-	"github.com/IBM/fp-go/internal/apply"
-	O "github.com/IBM/fp-go/option"
-	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() O.Option[A], GTA ~func() O.Option[T.Tuple1[A]], A any](a GA) GTA {
-	return apply.SequenceT1(
-		Map[GA, GTA, A, T.Tuple1[A]],
-
-		a,
-	)
-}
-
-func SequenceT2[GA ~func() O.Option[A], GB ~func() O.Option[B], GTAB ~func() O.Option[T.Tuple2[A, B]], A, B any](a GA, b GB) GTAB {
-	return apply.SequenceT2(
-		Map[GA, func() O.Option[func(B) T.Tuple2[A, B]], A, func(B) T.Tuple2[A, B]],
-		Ap[GB, GTAB, func() O.Option[func(B) T.Tuple2[A, B]], B, T.Tuple2[A, B]],
-
-		a, b,
-	)
-}
-
-func SequenceT3[GA ~func() O.Option[A], GB ~func() O.Option[B], GC ~func() O.Option[C], GTABC ~func() O.Option[T.Tuple3[A, B, C]], A, B, C any](a GA, b GB, c GC) GTABC {
-	return apply.SequenceT3(
-		Map[GA, func() O.Option[func(B) func(C) T.Tuple3[A, B, C]], A, func(B) func(C) T.Tuple3[A, B, C]],
-		Ap[GB, func() O.Option[func(C) T.Tuple3[A, B, C]], func() O.Option[func(B) func(C) T.Tuple3[A, B, C]], B, func(C) T.Tuple3[A, B, C]],
-		Ap[GC, GTABC, func() O.Option[func(C) T.Tuple3[A, B, C]], C, T.Tuple3[A, B, C]],
-
-		a, b, c,
-	)
-}
-
-func SequenceT4[GA ~func() O.Option[A], GB ~func() O.Option[B], GC ~func() O.Option[C], GD ~func() O.Option[D], GTABCD ~func() O.Option[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() O.Option[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[GB, func() O.Option[func(C) func(D) T.Tuple4[A, B, C, D]], func() O.Option[func(B) func(C) func(D) T.Tuple4[A, B, C, D]], B, func(C) func(D) T.Tuple4[A, B, C, D]],
-		Ap[GC, func() O.Option[func(D) T.Tuple4[A, B, C, D]], func() O.Option[func(C) func(D) T.Tuple4[A, B, C, D]], C, func(D) T.Tuple4[A, B, C, D]],
-		Ap[GD, GTABCD, func() O.Option[func(D) T.Tuple4[A, B, C, D]], D, T.Tuple4[A, B, C, D]],
-
-		a, b, c, d,
-	)
-}

iooption/iooption.go

@@ -82,11 +82,11 @@ func Chain[A, B any](f func(A) IOOption[B]) func(IOOption[A]) IOOption[B] {
 }
 
 func MonadAp[B, A any](mab IOOption[func(A) B], ma IOOption[A]) IOOption[B] {
-	return G.MonadAp[IOOption[A], IOOption[B]](mab, ma)
+	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[A], IOOption[B], IOOption[func(A) B]](ma)
+	return G.Ap[IOOption[B], IOOption[func(A) B]](ma)
 }
 
 func Flatten[A any](mma IOOption[IOOption[A]]) IOOption[A] {

iooption/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 iooption
-
-import (
-	G "github.com/IBM/fp-go/iooption/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[A any](a IOOption[A]) IOOption[T.Tuple1[A]] {
-	return G.SequenceT1[
-		IOOption[A],
-		IOOption[T.Tuple1[A]],
-	](a)
-}
-
-func SequenceT2[A, B any](
-	a IOOption[A],
-	b IOOption[B],
-) IOOption[T.Tuple2[A, B]] {
-	return G.SequenceT2[
-		IOOption[A],
-		IOOption[B],
-		IOOption[T.Tuple2[A, B]],
-	](a, b)
-}
-
-func SequenceT3[A, B, C any](
-	a IOOption[A],
-	b IOOption[B],
-	c IOOption[C],
-) IOOption[T.Tuple3[A, B, C]] {
-	return G.SequenceT3[
-		IOOption[A],
-		IOOption[B],
-		IOOption[C],
-		IOOption[T.Tuple3[A, B, C]],
-	](a, b, c)
-}
-
-func SequenceT4[A, B, C, D any](
-	a IOOption[A],
-	b IOOption[B],
-	c IOOption[C],
-	d IOOption[D],
-) IOOption[T.Tuple4[A, B, C, D]] {
-	return G.SequenceT4[
-		IOOption[A],
-		IOOption[B],
-		IOOption[C],
-		IOOption[D],
-		IOOption[T.Tuple4[A, B, C, D]],
-	](a, b, c, d)
-}

iterator/stateless/generic/iterator.go

@@ -201,3 +201,7 @@ func Filter[GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(U) bool, U any](f FC
 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/iterator.go

@@ -31,7 +31,7 @@ func Empty[U any]() Iterator[U] {
 }
 
 // Of returns an iterator with one single element
-func Of[GU ~func() O.Option[T.Tuple2[GU, U]], U any](a U) Iterator[U] {
+func Of[U any](a U) Iterator[U] {
 	return G.Of[Iterator[U]](a)
 }
 
@@ -99,6 +99,11 @@ func Filter[U any](f func(U) bool) func(ma Iterator[U]) Iterator[U] {
 }
 
 // Ap is the applicative functor for iterators
-func Ap[U, V any](ma Iterator[U]) func(Iterator[func(U) V]) Iterator[V] {
+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

@@ -84,3 +84,20 @@ func TestFilterMap(t *testing.T) {
 
 	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)
+}

lazy/sequence.go

@@ -23,17 +23,17 @@ 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 Lazy[A]) Lazy[T.Tuple1[A]] {
-	return G.SequenceT1[Lazy[A], Lazy[T.Tuple1[A]]](a)
+	return G.SequenceT1[Lazy[T.Tuple1[A]]](a)
 }
 
 func SequenceT2[A, B any](a Lazy[A], b Lazy[B]) Lazy[T.Tuple2[A, B]] {
-	return G.SequenceT2[Lazy[A], Lazy[B], Lazy[T.Tuple2[A, B]]](a, b)
+	return G.SequenceT2[Lazy[T.Tuple2[A, B]]](a, b)
 }
 
 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[A], Lazy[B], Lazy[C], Lazy[T.Tuple3[A, B, C]]](a, b, c)
+	return G.SequenceT3[Lazy[T.Tuple3[A, B, C]]](a, b, c)
 }
 
 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[A], Lazy[B], Lazy[C], Lazy[D], Lazy[T.Tuple4[A, B, C, D]]](a, b, c, d)
+	return G.SequenceT4[Lazy[T.Tuple4[A, B, C, D]]](a, b, c, d)
 }

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

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

@@ -1,89 +1,75 @@
-// 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-21 10:23:01.7578306 +0200 CEST m=+0.326481301
+// 2023-07-27 22:38:07.286388 +0200 CEST m=+0.046901101
 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

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

readerioeither/gen.go

@@ -1,155 +1,141 @@
-// 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-21 10:23:04.372044 +0200 CEST m=+0.068576501
+// 2023-07-27 22:38:09.8136331 +0200 CEST m=+0.047621701
 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

@@ -1,23 +1,9 @@
-// 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-21 10:23:04.372044 +0200 CEST m=+0.068576501
+// 2023-07-27 22:38:09.8196347 +0200 CEST m=+0.053623301
 package generic
 
+
 import (
 	E "github.com/IBM/fp-go/either"
 	RD "github.com/IBM/fp-go/reader/generic"
@@ -26,197 +12,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)
+    }})
 }

string/string.go

@@ -16,6 +16,7 @@
 package string
 
 import (
+	"fmt"
 	"strings"
 
 	F "github.com/IBM/fp-go/function"
@@ -62,3 +63,10 @@ func Includes(searchString string) func(string) bool {
 func Equals(other string) func(string) bool {
 	return F.Bind2nd(Eq, other)
 }
+
+// Format applies a format string to an arbitrary value
+func Format[T any](format string) func(t T) string {
+	return func(t T) string {
+		return fmt.Sprintf(format, t)
+	}
+}