From 91d796136378b09a27bd2e45b012b0604c285070 Mon Sep 17 00:00:00 2001 From: "Dr. Carsten Leue" Date: Fri, 21 Jul 2023 10:55:03 +0200 Subject: [PATCH] fix: auto generate TraverseTuple for ReaderIOEither Signed-off-by: Dr. Carsten Leue --- cli/contextreaderioeither.go | 411 ++- cli/monad.go | 32 +- context/doc.go | 2 +- context/readerioeither/file/data/file.json | 3 + context/readerioeither/file/file_test.go | 41 + context/readerioeither/gen.go | 352 ++- context/readerioeither/generic/gen.go | 2947 +++++++++++++++++++- context/readerioeither/generic/reader.go | 70 +- either/gen.go | 2 +- errors/messages.go | 5 + function/binds.go | 2 +- function/gen.go | 2 +- identity/gen.go | 2 +- internal/apply/gen.go | 2 +- io/generic/ap.go | 12 +- io/generic/io.go | 10 +- io/generic/sequence.go | 12 +- io/generic/traverse.go | 8 +- io/io.go | 2 +- ioeither/generic/ioeither.go | 22 + option/gen.go | 2 +- reader/gen.go | 2 +- reader/generic/gen.go | 2 +- readerio/generic/reader.go | 16 + readerioeither/gen.go | 2 +- readerioeither/generic/gen.go | 2 +- readerioeither/generic/reader.go | 56 + samples/http/http_test.go | 33 + tuple/gen.go | 2 +- 29 files changed, 3861 insertions(+), 195 deletions(-) create mode 100644 context/readerioeither/file/data/file.json create mode 100644 context/readerioeither/file/file_test.go diff --git a/cli/contextreaderioeither.go b/cli/contextreaderioeither.go index 270c2dc..c38cf1a 100644 --- a/cli/contextreaderioeither.go +++ b/cli/contextreaderioeither.go @@ -21,178 +21,289 @@ func generateNestedCallbacks(i, total int) string { if i > 0 { buf.WriteString(" ") } - buf.WriteString(tupleType(total)) + buf.WriteString(tupleType("T")(total)) return buf.String() } -func generateContextReaderIOEitherSequenceTuple(f, fg *os.File, i int) { - // tuple type - tuple := tupleType(i) +func generateContextReaderIOEitherTraverseTuple(suffix string) func(f, fg *os.File, i int) { + return func(f, fg *os.File, i int) { + // tupleT type + tupleT := tupleType("T")(i) + tupleA := tupleType("A")(i) - // non-generic version - // generic version - fmt.Fprintf(f, "\n// SequenceTuple%d converts a [T.Tuple%d] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple%d].\n", i, i, i) - fmt.Fprintf(f, "func SequenceTuple%d[", i) - for j := 0; j < i; j++ { - if j > 0 { - fmt.Fprintf(f, ", ") + // non-generic version + // generic version + fmt.Fprintf(f, "\n// Traverse%sTuple%d converts a [T.Tuple%d] of [A] via transformer functions transforming [A] to a [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple%d].\n", suffix, i, i, i) + fmt.Fprintf(f, "func Traverse%sTuple%d[", suffix, i) + for j := 0; j < i; j++ { + if j > 0 { + fmt.Fprintf(f, ", ") + } + fmt.Fprintf(f, "F%d ~func(A%d) ReaderIOEither[T%d]", j+1, j+1, j+1) } - fmt.Fprintf(f, "T%d", j+1) - } - fmt.Fprintf(f, " any](t T.Tuple%d[", i) - for j := 0; j < i; j++ { - if j > 0 { - fmt.Fprintf(f, ", ") + for j := 0; j < i; j++ { + fmt.Fprintf(f, ", A%d, T%d", j+1, j+1) } - fmt.Fprintf(f, "ReaderIOEither[T%d]", j+1) - } - fmt.Fprintf(f, "]) ReaderIOEither[%s] {\n", tuple) - fmt.Fprintf(f, " return G.SequenceTuple%d[ReaderIOEither[%s]](t)\n", i, tuple) - fmt.Fprintf(f, "}\n") - - // generic version - fmt.Fprintf(fg, "\n// SequenceTuple%d converts a [T.Tuple%d] of readers into a reader of a [T.Tuple%d].\n", i, i, i) - fmt.Fprintf(fg, "func SequenceTuple%d[\n", i) - - fmt.Fprintf(fg, " GR_TUPLE%d ~func(context.Context) GIO_TUPLE%d,\n", i, i) - for j := 0; j < i; j++ { - fmt.Fprintf(fg, " GR_T%d ~func(context.Context) GIO_T%d,\n", j+1, j+1) - } - - fmt.Fprintf(fg, " GIO_TUPLE%d ~func() E.Either[error, %s],\n", i, tuple) - for j := 0; j < i; j++ { - fmt.Fprintf(fg, " GIO_T%d ~func() E.Either[error, T%d],\n", j+1, j+1) - } - - for j := 0; j < i; j++ { - fmt.Fprintf(fg, " T%d", j+1) - if j < i-1 { - fmt.Fprintf(fg, ",\n") + fmt.Fprintf(f, " any](") + 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(fg, " any](t T.Tuple%d[", i) - for j := 0; j < i; j++ { - if j > 0 { - fmt.Fprintf(fg, ", ") + fmt.Fprintf(f, ") func(%s) ReaderIOEither[%s] {\n", tupleA, tupleT) + fmt.Fprintf(f, " return G.Traverse%sTuple%d[ReaderIOEither[%s]](", suffix, i, tupleT) + for j := 0; j < i; j++ { + if j > 0 { + fmt.Fprintf(f, ", ") + } + fmt.Fprintf(f, "f%d", j+1) } - fmt.Fprintf(fg, "GR_T%d", j+1) - } - fmt.Fprintf(fg, "]) GR_TUPLE%d {\n", i) - fmt.Fprintf(fg, " return A.SequenceTuple%d(\n", i) - // map call - var cr string - if i > 1 { - cb := generateNestedCallbacks(1, i) - cio := fmt.Sprintf("func() E.Either[error, %s]", cb) - cr = fmt.Sprintf("func(context.Context) %s", cio) - } else { - cr = fmt.Sprintf("GR_TUPLE%d", i) - } - fmt.Fprintf(fg, " Map[GR_T%d, %s, GIO_T%d],\n", 1, cr, 1) - // the apply calls - for j := 1; j < i; j++ { - if j < i-1 { - cb := generateNestedCallbacks(j+1, i) + fmt.Fprintf(f, ")\n") + fmt.Fprintf(f, "}\n") + + // generic version + fmt.Fprintf(fg, "\n// Traverse%sTuple%d converts a [T.Tuple%d] of readers into a reader of a [T.Tuple%d].\n", suffix, i, i, i) + fmt.Fprintf(fg, "func Traverse%sTuple%d[\n", suffix, i) + fmt.Fprintf(fg, " GR_TUPLE%d ~func(context.Context) GIO_TUPLE%d,\n", i, i) + // the transformation functions + for j := 0; j < i; j++ { + fmt.Fprintf(fg, " F%d ~func(A%d) GR_T%d,\n", j+1, j+1, j+1) + } + // the readers + for j := 0; j < i; j++ { + fmt.Fprintf(fg, " GR_T%d ~func(context.Context) GIO_T%d,\n", j+1, j+1) + } + // the tuples + fmt.Fprintf(fg, " GIO_TUPLE%d ~func() E.Either[error, %s],\n", i, tupleT) + for j := 0; j < i; j++ { + fmt.Fprintf(fg, " GIO_T%d ~func() E.Either[error, T%d],\n", j+1, j+1) + } + // input and result parameters + for j := 0; j < i; j++ { + fmt.Fprintf(fg, " A%d,\n", j+1) + fmt.Fprintf(fg, " T%d", j+1) + if j < i-1 { + fmt.Fprintf(fg, ",\n") + } + } + fmt.Fprintf(fg, " any](") + 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) GR_TUPLE%d {\n", tupleA, i) + fmt.Fprintf(fg, " return func(t %s) GR_TUPLE%d {\n", tupleA, i) + fmt.Fprintf(fg, " return A.TraverseTuple%d(\n", i) + // map call + var cr string + if i > 1 { + cb := generateNestedCallbacks(1, i) cio := fmt.Sprintf("func() E.Either[error, %s]", cb) cr = fmt.Sprintf("func(context.Context) %s", cio) } else { cr = fmt.Sprintf("GR_TUPLE%d", i) } - fmt.Fprintf(fg, " Ap[%s, func(context.Context) func() E.Either[error, %s], GR_T%d],\n", cr, generateNestedCallbacks(j, i), j+1) - } - // raw parameters - fmt.Fprintf(fg, " t,\n") + fmt.Fprintf(fg, " Map[GR_T%d, %s, GIO_T%d],\n", 1, cr, 1) + // the apply calls + for j := 1; j < i; j++ { + if j < i-1 { + cb := generateNestedCallbacks(j+1, i) + cio := fmt.Sprintf("func() E.Either[error, %s]", cb) + cr = fmt.Sprintf("func(context.Context) %s", cio) + } else { + cr = fmt.Sprintf("GR_TUPLE%d", i) + } + fmt.Fprintf(fg, " Ap%s[%s, func(context.Context) func() E.Either[error, %s], GR_T%d],\n", suffix, cr, generateNestedCallbacks(j, i), j+1) + } + // function parameters + for j := 0; j < i; j++ { + fmt.Fprintf(fg, " f%d,\n", j+1) + } - fmt.Fprintf(fg, " )\n") - fmt.Fprintf(fg, "}\n") + // raw parameters + fmt.Fprintf(fg, " t,\n") + + fmt.Fprintf(fg, " )\n") + fmt.Fprintf(fg, " }\n") + fmt.Fprintf(fg, "}\n") + } } -func generateContextReaderIOEitherSequenceT(f, fg *os.File, i int) { - // tuple type - tuple := tupleType(i) +func generateContextReaderIOEitherSequenceTuple(suffix string) func(f, fg *os.File, i int) { + return func(f, fg *os.File, i int) { + // tuple type + tuple := tupleType("T")(i) - // non-generic version - // generic version - fmt.Fprintf(f, "\n// SequenceT%d converts %d [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple%d].\n", i, i, i) - fmt.Fprintf(f, "func SequenceT%d[", i) - for j := 0; j < i; j++ { - if j > 0 { - fmt.Fprintf(f, ", ") + // non-generic version + // generic version + fmt.Fprintf(f, "\n// Sequence%sTuple%d converts a [T.Tuple%d] of [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple%d].\n", suffix, i, i, i) + fmt.Fprintf(f, "func Sequence%sTuple%d[", suffix, i) + for j := 0; j < i; j++ { + if j > 0 { + fmt.Fprintf(f, ", ") + } + fmt.Fprintf(f, "T%d", j+1) } - fmt.Fprintf(f, "T%d", j+1) - } - fmt.Fprintf(f, " any](") - for j := 0; j < i; j++ { - if j > 0 { - fmt.Fprintf(f, ", ") + fmt.Fprintf(f, " any](t T.Tuple%d[", i) + for j := 0; j < i; j++ { + if j > 0 { + fmt.Fprintf(f, ", ") + } + fmt.Fprintf(f, "ReaderIOEither[T%d]", j+1) } - fmt.Fprintf(f, "t%d ReaderIOEither[T%d]", j+1, j+1) - } - fmt.Fprintf(f, ") ReaderIOEither[%s] {\n", tuple) - fmt.Fprintf(f, " return G.SequenceT%d[ReaderIOEither[%s]](", i, tuple) - for j := 0; j < i; j++ { - if j > 0 { - fmt.Fprintf(f, ", ") + fmt.Fprintf(f, "]) ReaderIOEither[%s] {\n", tuple) + fmt.Fprintf(f, " return G.Sequence%sTuple%d[ReaderIOEither[%s]](t)\n", suffix, i, tuple) + fmt.Fprintf(f, "}\n") + + // generic version + fmt.Fprintf(fg, "\n// Sequence%sTuple%d converts a [T.Tuple%d] of readers into a reader of a [T.Tuple%d].\n", suffix, i, i, i) + fmt.Fprintf(fg, "func Sequence%sTuple%d[\n", suffix, i) + + fmt.Fprintf(fg, " GR_TUPLE%d ~func(context.Context) GIO_TUPLE%d,\n", i, i) + for j := 0; j < i; j++ { + fmt.Fprintf(fg, " GR_T%d ~func(context.Context) GIO_T%d,\n", j+1, j+1) } - 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 readers into a reader of a [T.Tuple%d].\n", i, i, i) - fmt.Fprintf(fg, "func SequenceT%d[\n", i) - - fmt.Fprintf(fg, " GR_TUPLE%d ~func(context.Context) GIO_TUPLE%d,\n", i, i) - for j := 0; j < i; j++ { - fmt.Fprintf(fg, " GR_T%d ~func(context.Context) GIO_T%d,\n", j+1, j+1) - } - - fmt.Fprintf(fg, " GIO_TUPLE%d ~func() E.Either[error, %s],\n", i, tuple) - for j := 0; j < i; j++ { - fmt.Fprintf(fg, " GIO_T%d ~func() E.Either[error, T%d],\n", j+1, j+1) - } - - for j := 0; j < i; j++ { - fmt.Fprintf(fg, " T%d", j+1) - if j < i-1 { - fmt.Fprintf(fg, ",\n") + fmt.Fprintf(fg, " GIO_TUPLE%d ~func() E.Either[error, %s],\n", i, tuple) + for j := 0; j < i; j++ { + fmt.Fprintf(fg, " GIO_T%d ~func() E.Either[error, T%d],\n", j+1, j+1) } - } - fmt.Fprintf(fg, " any](\n") - for j := 0; j < i; j++ { - fmt.Fprintf(fg, " t%d GR_T%d,\n", j+1, j+1) - } - fmt.Fprintf(fg, ") GR_TUPLE%d {\n", i) - fmt.Fprintf(fg, " return A.SequenceT%d(\n", i) - // map call - var cr string - if i > 1 { - cb := generateNestedCallbacks(1, i) - cio := fmt.Sprintf("func() E.Either[error, %s]", cb) - cr = fmt.Sprintf("func(context.Context) %s", cio) - } else { - cr = fmt.Sprintf("GR_TUPLE%d", i) - } - fmt.Fprintf(fg, " Map[GR_T%d, %s, GIO_T%d],\n", 1, cr, 1) - // the apply calls - for j := 1; j < i; j++ { - if j < i-1 { - cb := generateNestedCallbacks(j+1, i) + + for j := 0; j < i; j++ { + fmt.Fprintf(fg, " T%d", j+1) + if j < i-1 { + fmt.Fprintf(fg, ",\n") + } + } + fmt.Fprintf(fg, " any](t T.Tuple%d[", i) + for j := 0; j < i; j++ { + if j > 0 { + fmt.Fprintf(fg, ", ") + } + fmt.Fprintf(fg, "GR_T%d", j+1) + } + fmt.Fprintf(fg, "]) GR_TUPLE%d {\n", i) + fmt.Fprintf(fg, " return A.SequenceTuple%d(\n", i) + // map call + var cr string + if i > 1 { + cb := generateNestedCallbacks(1, i) cio := fmt.Sprintf("func() E.Either[error, %s]", cb) cr = fmt.Sprintf("func(context.Context) %s", cio) } else { cr = fmt.Sprintf("GR_TUPLE%d", i) } - fmt.Fprintf(fg, " Ap[%s, func(context.Context) func() E.Either[error, %s], GR_T%d],\n", cr, generateNestedCallbacks(j, i), j+1) - } - // raw parameters - for j := 0; j < i; j++ { - fmt.Fprintf(fg, " t%d,\n", j+1) - } + fmt.Fprintf(fg, " Map[GR_T%d, %s, GIO_T%d],\n", 1, cr, 1) + // the apply calls + for j := 1; j < i; j++ { + if j < i-1 { + cb := generateNestedCallbacks(j+1, i) + cio := fmt.Sprintf("func() E.Either[error, %s]", cb) + cr = fmt.Sprintf("func(context.Context) %s", cio) + } else { + cr = fmt.Sprintf("GR_TUPLE%d", i) + } + fmt.Fprintf(fg, " Ap%s[%s, func(context.Context) func() E.Either[error, %s], GR_T%d],\n", suffix, cr, generateNestedCallbacks(j, i), j+1) + } + // raw parameters + fmt.Fprintf(fg, " t,\n") - fmt.Fprintf(fg, " )\n") - fmt.Fprintf(fg, "}\n") + fmt.Fprintf(fg, " )\n") + fmt.Fprintf(fg, "}\n") + } +} + +func generateContextReaderIOEitherSequenceT(suffix string) func(f, fg *os.File, i int) { + return func(f, fg *os.File, i int) { + // tuple type + tuple := tupleType("T")(i) + + // non-generic version + // generic version + fmt.Fprintf(f, "\n// Sequence%sT%d converts %d [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple%d].\n", suffix, i, i, i) + fmt.Fprintf(f, "func Sequence%sT%d[", suffix, i) + for j := 0; j < i; j++ { + if j > 0 { + fmt.Fprintf(f, ", ") + } + fmt.Fprintf(f, "T%d", j+1) + } + fmt.Fprintf(f, " any](") + for j := 0; j < i; j++ { + if j > 0 { + fmt.Fprintf(f, ", ") + } + fmt.Fprintf(f, "t%d ReaderIOEither[T%d]", j+1, j+1) + } + fmt.Fprintf(f, ") ReaderIOEither[%s] {\n", tuple) + fmt.Fprintf(f, " return G.Sequence%sT%d[ReaderIOEither[%s]](", suffix, i, tuple) + 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// Sequence%sT%d converts %d readers into a reader of a [T.Tuple%d].\n", suffix, i, i, i) + fmt.Fprintf(fg, "func Sequence%sT%d[\n", suffix, i) + + fmt.Fprintf(fg, " GR_TUPLE%d ~func(context.Context) GIO_TUPLE%d,\n", i, i) + for j := 0; j < i; j++ { + fmt.Fprintf(fg, " GR_T%d ~func(context.Context) GIO_T%d,\n", j+1, j+1) + } + + fmt.Fprintf(fg, " GIO_TUPLE%d ~func() E.Either[error, %s],\n", i, tuple) + for j := 0; j < i; j++ { + fmt.Fprintf(fg, " GIO_T%d ~func() E.Either[error, T%d],\n", j+1, j+1) + } + + for j := 0; j < i; j++ { + fmt.Fprintf(fg, " T%d", j+1) + if j < i-1 { + fmt.Fprintf(fg, ",\n") + } + } + fmt.Fprintf(fg, " any](\n") + for j := 0; j < i; j++ { + fmt.Fprintf(fg, " t%d GR_T%d,\n", j+1, j+1) + } + fmt.Fprintf(fg, ") GR_TUPLE%d {\n", i) + fmt.Fprintf(fg, " return A.SequenceT%d(\n", i) + // map call + var cr string + if i > 1 { + cb := generateNestedCallbacks(1, i) + cio := fmt.Sprintf("func() E.Either[error, %s]", cb) + cr = fmt.Sprintf("func(context.Context) %s", cio) + } else { + cr = fmt.Sprintf("GR_TUPLE%d", i) + } + fmt.Fprintf(fg, " Map[GR_T%d, %s, GIO_T%d],\n", 1, cr, 1) + // the apply calls + for j := 1; j < i; j++ { + if j < i-1 { + cb := generateNestedCallbacks(j+1, i) + cio := fmt.Sprintf("func() E.Either[error, %s]", cb) + cr = fmt.Sprintf("func(context.Context) %s", cio) + } else { + cr = fmt.Sprintf("GR_TUPLE%d", i) + } + fmt.Fprintf(fg, " Ap%s[%s, func(context.Context) func() E.Either[error, %s], GR_T%d],\n", suffix, cr, generateNestedCallbacks(j, i), j+1) + } + // raw parameters + for j := 0; j < i; j++ { + fmt.Fprintf(fg, " t%d,\n", j+1) + } + + fmt.Fprintf(fg, " )\n") + fmt.Fprintf(fg, "}\n") + } } func generateContextReaderIOEitherEitherize(f, fg *os.File, i int) { @@ -299,9 +410,17 @@ import ( // eitherize generateContextReaderIOEitherEitherize(f, fg, i) // sequenceT - generateContextReaderIOEitherSequenceT(f, fg, i) + generateContextReaderIOEitherSequenceT("")(f, fg, i) + generateContextReaderIOEitherSequenceT("Seq")(f, fg, i) + generateContextReaderIOEitherSequenceT("Par")(f, fg, i) // sequenceTuple - generateContextReaderIOEitherSequenceTuple(f, fg, i) + generateContextReaderIOEitherSequenceTuple("")(f, fg, i) + generateContextReaderIOEitherSequenceTuple("Seq")(f, fg, i) + generateContextReaderIOEitherSequenceTuple("Par")(f, fg, i) + // traverseTuple + generateContextReaderIOEitherTraverseTuple("")(f, fg, i) + generateContextReaderIOEitherTraverseTuple("Seq")(f, fg, i) + generateContextReaderIOEitherTraverseTuple("Par")(f, fg, i) } return nil diff --git a/cli/monad.go b/cli/monad.go index 524305e..efd1766 100644 --- a/cli/monad.go +++ b/cli/monad.go @@ -6,18 +6,20 @@ import ( "strings" ) -func tupleType(i int) string { - var buf strings.Builder - buf.WriteString(fmt.Sprintf("T.Tuple%d[", i)) - for j := 0; j < i; j++ { - if j > 0 { - buf.WriteString(", ") +func tupleType(name string) func(i int) string { + return func(i int) string { + var buf strings.Builder + buf.WriteString(fmt.Sprintf("T.Tuple%d[", i)) + for j := 0; j < i; j++ { + if j > 0 { + buf.WriteString(", ") + } + buf.WriteString(fmt.Sprintf("%s%d", name, j+1)) } - buf.WriteString(fmt.Sprintf("T%d", j+1)) - } - buf.WriteString("]") + buf.WriteString("]") - return buf.String() + return buf.String() + } } func monadGenerateSequenceTNonGeneric( @@ -27,7 +29,7 @@ func monadGenerateSequenceTNonGeneric( ) func(f *os.File, i int) { return func(f *os.File, i int) { - tuple := tupleType(i) + tuple := tupleType("T")(i) fmt.Fprintf(f, "SequenceT%d[", i) for j := 0; j < i; j++ { @@ -80,7 +82,7 @@ func monadGenerateSequenceTGeneric( ) func(f *os.File, i int) { return func(f *os.File, i int) { - tuple := tupleType(i) + tuple := tupleType("T")(i) fmt.Fprintf(f, "SequenceT%d[", i) for j := 0; j < i; j++ { @@ -131,7 +133,7 @@ func generateTraverseTuple1( infix string) func(f *os.File, i int) { return func(f *os.File, i int) { - tuple := tupleType(i) + tuple := tupleType("T")(i) fmt.Fprintf(f, "\n// TraverseTuple%d converts a [Tuple%d] of [A] via transformation functions transforming [A] to [%s] into a [%s].\n", i, i, hkt("A"), hkt(fmt.Sprintf("Tuple%d", i))) fmt.Fprintf(f, "func TraverseTuple%d[", i) @@ -218,7 +220,7 @@ func generateSequenceTuple1( return func(f *os.File, i int) { - tuple := tupleType(i) + tuple := tupleType("T")(i) fmt.Fprintf(f, "\n// SequenceTuple%d converts a [Tuple%d] of [%s] into an [%s].\n", i, i, hkt("T"), hkt(fmt.Sprintf("Tuple%d", i))) fmt.Fprintf(f, "func SequenceTuple%d[", i) @@ -281,7 +283,7 @@ func generateSequenceT1( return func(f *os.File, i int) { - tuple := tupleType(i) + tuple := tupleType("T")(i) fmt.Fprintf(f, "\n// SequenceT%d converts %d parameters of [%s] into a [%s].\n", i, i, hkt("T"), hkt(fmt.Sprintf("Tuple%d", i))) fmt.Fprintf(f, "func SequenceT%d[", i) diff --git a/context/doc.go b/context/doc.go index 9f3bcfc..89597b2 100644 --- a/context/doc.go +++ b/context/doc.go @@ -13,5 +13,5 @@ // See the License for the specific language governing permissions and // limitations under the License. -// Package context contains versions of monads that work with a golang [context.Context] +// Package context contains versions of reader IO monads that work with a golang [context.Context] package context diff --git a/context/readerioeither/file/data/file.json b/context/readerioeither/file/data/file.json new file mode 100644 index 0000000..6f6b333 --- /dev/null +++ b/context/readerioeither/file/data/file.json @@ -0,0 +1,3 @@ +{ + "data": "Carsten" +} \ No newline at end of file diff --git a/context/readerioeither/file/file_test.go b/context/readerioeither/file/file_test.go new file mode 100644 index 0000000..231a9f9 --- /dev/null +++ b/context/readerioeither/file/file_test.go @@ -0,0 +1,41 @@ +package file + +import ( + "context" + "fmt" + + RIO "github.com/IBM/fp-go/context/readerio" + R "github.com/IBM/fp-go/context/readerioeither" + "github.com/IBM/fp-go/errors" + F "github.com/IBM/fp-go/function" + IO "github.com/IBM/fp-go/io" + J "github.com/IBM/fp-go/json" +) + +type RecordType struct { + Data string `json:"data"` +} + +func getData(r RecordType) string { + return r.Data +} + +func ExampleReadFile() { + + data := F.Pipe4( + ReadFile("./data/file.json"), + R.ChainEitherK(J.Unmarshal[RecordType]), + R.ChainFirstIOK(IO.Logf[RecordType]("Log: %v")), + R.Map(getData), + R.GetOrElse(F.Flow2( + errors.ToString, + RIO.Of[string], + )), + ) + + result := data(context.Background()) + + fmt.Println(result()) + + // Output: Carsten +} diff --git a/context/readerioeither/gen.go b/context/readerioeither/gen.go index 423cb98..580fb87 100644 --- a/context/readerioeither/gen.go +++ b/context/readerioeither/gen.go @@ -2,7 +2,7 @@ package readerioeither // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-07-20 23:13:55.3160763 +0200 CEST m=+0.008374301 +// 2023-07-21 10:22:43.4901011 +0200 CEST m=+0.009264601 import ( "context" @@ -28,11 +28,46 @@ func SequenceT1[T1 any](t1 ReaderIOEither[T1]) ReaderIOEither[T.Tuple1[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) +} + +// 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) +} + // 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) } +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} + // 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] { @@ -44,11 +79,46 @@ func SequenceT2[T1, T2 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2]) Reader 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) +} + +// 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) +} + // 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) } +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} + // 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] { @@ -60,11 +130,46 @@ func SequenceT3[T1, T2, T3 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[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) +} + +// 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) +} + // 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) } +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} + // 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] { @@ -76,11 +181,46 @@ func SequenceT4[T1, T2, T3, T4 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2] 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) +} + +// 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) +} + // 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) } +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} + // 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] { @@ -92,11 +232,46 @@ func SequenceT5[T1, T2, T3, T4, T5 any](t1 ReaderIOEither[T1], t2 ReaderIOEither 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) +} + +// 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) +} + // 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) } +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} + // 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] { @@ -108,11 +283,46 @@ func SequenceT6[T1, T2, T3, T4, T5, T6 any](t1 ReaderIOEither[T1], t2 ReaderIOEi 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) +} + +// 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) +} + // 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) } +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} + // 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] { @@ -124,11 +334,46 @@ func SequenceT7[T1, T2, T3, T4, T5, T6, T7 any](t1 ReaderIOEither[T1], t2 Reader 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) +} + +// 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) +} + // 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) } +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} + // 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] { @@ -140,11 +385,46 @@ func SequenceT8[T1, T2, T3, T4, T5, T6, T7, T8 any](t1 ReaderIOEither[T1], t2 Re 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) +} + +// 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) +} + // 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) } +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} + // 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] { @@ -156,11 +436,46 @@ func SequenceT9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t1 ReaderIOEither[T1], t 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) +} + +// 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) +} + // 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) } +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} + // 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] { @@ -172,7 +487,42 @@ func SequenceT10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t1 ReaderIOEither[ 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) +} + +// 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) +} + // 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) } + +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} + +// 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) +} diff --git a/context/readerioeither/generic/gen.go b/context/readerioeither/generic/gen.go index da54123..e6c7e52 100644 --- a/context/readerioeither/generic/gen.go +++ b/context/readerioeither/generic/gen.go @@ -2,7 +2,7 @@ package generic // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-07-20 23:13:55.3160763 +0200 CEST m=+0.008374301 +// 2023-07-21 10:22:43.4901011 +0200 CEST m=+0.009264601 import ( "context" @@ -40,6 +40,36 @@ func SequenceT1[ ) } +// SequenceSeqT1 converts 1 readers into a reader of a [T.Tuple1]. +func SequenceSeqT1[ + GR_TUPLE1 ~func(context.Context) GIO_TUPLE1, + GR_T1 ~func(context.Context) GIO_T1, + GIO_TUPLE1 ~func() E.Either[error, T.Tuple1[T1]], + GIO_T1 ~func() E.Either[error, T1], + T1 any]( + t1 GR_T1, +) GR_TUPLE1 { + return A.SequenceT1( + Map[GR_T1, GR_TUPLE1, GIO_T1], + t1, + ) +} + +// SequenceParT1 converts 1 readers into a reader of a [T.Tuple1]. +func SequenceParT1[ + GR_TUPLE1 ~func(context.Context) GIO_TUPLE1, + GR_T1 ~func(context.Context) GIO_T1, + GIO_TUPLE1 ~func() E.Either[error, T.Tuple1[T1]], + GIO_T1 ~func() E.Either[error, T1], + T1 any]( + t1 GR_T1, +) GR_TUPLE1 { + return A.SequenceT1( + Map[GR_T1, GR_TUPLE1, GIO_T1], + t1, + ) +} + // SequenceTuple1 converts a [T.Tuple1] of readers into a reader of a [T.Tuple1]. func SequenceTuple1[ GR_TUPLE1 ~func(context.Context) GIO_TUPLE1, @@ -53,6 +83,86 @@ func SequenceTuple1[ ) } +// SequenceSeqTuple1 converts a [T.Tuple1] of readers into a reader of a [T.Tuple1]. +func SequenceSeqTuple1[ + GR_TUPLE1 ~func(context.Context) GIO_TUPLE1, + GR_T1 ~func(context.Context) GIO_T1, + GIO_TUPLE1 ~func() E.Either[error, T.Tuple1[T1]], + GIO_T1 ~func() E.Either[error, T1], + T1 any](t T.Tuple1[GR_T1]) GR_TUPLE1 { + return A.SequenceTuple1( + Map[GR_T1, GR_TUPLE1, GIO_T1], + t, + ) +} + +// SequenceParTuple1 converts a [T.Tuple1] of readers into a reader of a [T.Tuple1]. +func SequenceParTuple1[ + GR_TUPLE1 ~func(context.Context) GIO_TUPLE1, + GR_T1 ~func(context.Context) GIO_T1, + GIO_TUPLE1 ~func() E.Either[error, T.Tuple1[T1]], + GIO_T1 ~func() E.Either[error, T1], + T1 any](t T.Tuple1[GR_T1]) GR_TUPLE1 { + return A.SequenceTuple1( + Map[GR_T1, GR_TUPLE1, GIO_T1], + t, + ) +} + +// TraverseTuple1 converts a [T.Tuple1] of readers into a reader of a [T.Tuple1]. +func TraverseTuple1[ + GR_TUPLE1 ~func(context.Context) GIO_TUPLE1, + F1 ~func(A1) GR_T1, + GR_T1 ~func(context.Context) GIO_T1, + GIO_TUPLE1 ~func() E.Either[error, T.Tuple1[T1]], + GIO_T1 ~func() E.Either[error, T1], + A1, + T1 any](f1 F1) func(T.Tuple1[A1]) GR_TUPLE1 { + return func(t T.Tuple1[A1]) GR_TUPLE1 { + return A.TraverseTuple1( + Map[GR_T1, GR_TUPLE1, GIO_T1], + f1, + t, + ) + } +} + +// TraverseSeqTuple1 converts a [T.Tuple1] of readers into a reader of a [T.Tuple1]. +func TraverseSeqTuple1[ + GR_TUPLE1 ~func(context.Context) GIO_TUPLE1, + F1 ~func(A1) GR_T1, + GR_T1 ~func(context.Context) GIO_T1, + GIO_TUPLE1 ~func() E.Either[error, T.Tuple1[T1]], + GIO_T1 ~func() E.Either[error, T1], + A1, + T1 any](f1 F1) func(T.Tuple1[A1]) GR_TUPLE1 { + return func(t T.Tuple1[A1]) GR_TUPLE1 { + return A.TraverseTuple1( + Map[GR_T1, GR_TUPLE1, GIO_T1], + f1, + t, + ) + } +} + +// TraverseParTuple1 converts a [T.Tuple1] of readers into a reader of a [T.Tuple1]. +func TraverseParTuple1[ + GR_TUPLE1 ~func(context.Context) GIO_TUPLE1, + F1 ~func(A1) GR_T1, + GR_T1 ~func(context.Context) GIO_T1, + GIO_TUPLE1 ~func() E.Either[error, T.Tuple1[T1]], + GIO_T1 ~func() E.Either[error, T1], + A1, + T1 any](f1 F1) func(T.Tuple1[A1]) GR_TUPLE1 { + return func(t T.Tuple1[A1]) GR_TUPLE1 { + return A.TraverseTuple1( + Map[GR_T1, GR_TUPLE1, GIO_T1], + f1, + t, + ) + } +} + // Eitherize2 converts a function with 2 parameters returning a tuple into a function with 2 parameters returning a [GRA] // The inverse function is [Uneitherize2] func Eitherize2[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1) (R, error), GIOA ~func() E.Either[error, R], T0, T1, R any](f F) func(T0, T1) GRA { @@ -80,6 +190,48 @@ func SequenceT2[ ) } +// SequenceSeqT2 converts 2 readers into a reader of a [T.Tuple2]. +func SequenceSeqT2[ + GR_TUPLE2 ~func(context.Context) GIO_TUPLE2, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GIO_TUPLE2 ~func() E.Either[error, T.Tuple2[T1, T2]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + T1, + T2 any]( + t1 GR_T1, + t2 GR_T2, +) GR_TUPLE2 { + return A.SequenceT2( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) T.Tuple2[T1, T2]], GIO_T1], + ApSeq[GR_TUPLE2, func(context.Context) func() E.Either[error, func(T2) T.Tuple2[T1, T2]], GR_T2], + t1, + t2, + ) +} + +// SequenceParT2 converts 2 readers into a reader of a [T.Tuple2]. +func SequenceParT2[ + GR_TUPLE2 ~func(context.Context) GIO_TUPLE2, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GIO_TUPLE2 ~func() E.Either[error, T.Tuple2[T1, T2]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + T1, + T2 any]( + t1 GR_T1, + t2 GR_T2, +) GR_TUPLE2 { + return A.SequenceT2( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) T.Tuple2[T1, T2]], GIO_T1], + ApPar[GR_TUPLE2, func(context.Context) func() E.Either[error, func(T2) T.Tuple2[T1, T2]], GR_T2], + t1, + t2, + ) +} + // SequenceTuple2 converts a [T.Tuple2] of readers into a reader of a [T.Tuple2]. func SequenceTuple2[ GR_TUPLE2 ~func(context.Context) GIO_TUPLE2, @@ -97,6 +249,115 @@ func SequenceTuple2[ ) } +// SequenceSeqTuple2 converts a [T.Tuple2] of readers into a reader of a [T.Tuple2]. +func SequenceSeqTuple2[ + GR_TUPLE2 ~func(context.Context) GIO_TUPLE2, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GIO_TUPLE2 ~func() E.Either[error, T.Tuple2[T1, T2]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + T1, + T2 any](t T.Tuple2[GR_T1, GR_T2]) GR_TUPLE2 { + return A.SequenceTuple2( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) T.Tuple2[T1, T2]], GIO_T1], + ApSeq[GR_TUPLE2, func(context.Context) func() E.Either[error, func(T2) T.Tuple2[T1, T2]], GR_T2], + t, + ) +} + +// SequenceParTuple2 converts a [T.Tuple2] of readers into a reader of a [T.Tuple2]. +func SequenceParTuple2[ + GR_TUPLE2 ~func(context.Context) GIO_TUPLE2, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GIO_TUPLE2 ~func() E.Either[error, T.Tuple2[T1, T2]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + T1, + T2 any](t T.Tuple2[GR_T1, GR_T2]) GR_TUPLE2 { + return A.SequenceTuple2( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) T.Tuple2[T1, T2]], GIO_T1], + ApPar[GR_TUPLE2, func(context.Context) func() E.Either[error, func(T2) T.Tuple2[T1, T2]], GR_T2], + t, + ) +} + +// TraverseTuple2 converts a [T.Tuple2] of readers into a reader of a [T.Tuple2]. +func TraverseTuple2[ + GR_TUPLE2 ~func(context.Context) GIO_TUPLE2, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GIO_TUPLE2 ~func() E.Either[error, T.Tuple2[T1, T2]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + A1, + T1, + A2, + T2 any](f1 F1, f2 F2) func(T.Tuple2[A1, A2]) GR_TUPLE2 { + return func(t T.Tuple2[A1, A2]) GR_TUPLE2 { + return A.TraverseTuple2( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) T.Tuple2[T1, T2]], GIO_T1], + Ap[GR_TUPLE2, func(context.Context) func() E.Either[error, func(T2) T.Tuple2[T1, T2]], GR_T2], + f1, + f2, + t, + ) + } +} + +// TraverseSeqTuple2 converts a [T.Tuple2] of readers into a reader of a [T.Tuple2]. +func TraverseSeqTuple2[ + GR_TUPLE2 ~func(context.Context) GIO_TUPLE2, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GIO_TUPLE2 ~func() E.Either[error, T.Tuple2[T1, T2]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + A1, + T1, + A2, + T2 any](f1 F1, f2 F2) func(T.Tuple2[A1, A2]) GR_TUPLE2 { + return func(t T.Tuple2[A1, A2]) GR_TUPLE2 { + return A.TraverseTuple2( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) T.Tuple2[T1, T2]], GIO_T1], + ApSeq[GR_TUPLE2, func(context.Context) func() E.Either[error, func(T2) T.Tuple2[T1, T2]], GR_T2], + f1, + f2, + t, + ) + } +} + +// TraverseParTuple2 converts a [T.Tuple2] of readers into a reader of a [T.Tuple2]. +func TraverseParTuple2[ + GR_TUPLE2 ~func(context.Context) GIO_TUPLE2, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GIO_TUPLE2 ~func() E.Either[error, T.Tuple2[T1, T2]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + A1, + T1, + A2, + T2 any](f1 F1, f2 F2) func(T.Tuple2[A1, A2]) GR_TUPLE2 { + return func(t T.Tuple2[A1, A2]) GR_TUPLE2 { + return A.TraverseTuple2( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) T.Tuple2[T1, T2]], GIO_T1], + ApPar[GR_TUPLE2, func(context.Context) func() E.Either[error, func(T2) T.Tuple2[T1, T2]], GR_T2], + f1, + f2, + t, + ) + } +} + // Eitherize3 converts a function with 3 parameters returning a tuple into a function with 3 parameters returning a [GRA] // The inverse function is [Uneitherize3] func Eitherize3[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, R any](f F) func(T0, T1, T2) GRA { @@ -130,6 +391,60 @@ func SequenceT3[ ) } +// SequenceSeqT3 converts 3 readers into a reader of a [T.Tuple3]. +func SequenceSeqT3[ + GR_TUPLE3 ~func(context.Context) GIO_TUPLE3, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GIO_TUPLE3 ~func() E.Either[error, T.Tuple3[T1, T2, T3]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + T1, + T2, + T3 any]( + t1 GR_T1, + t2 GR_T2, + t3 GR_T3, +) GR_TUPLE3 { + return A.SequenceT3( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) T.Tuple3[T1, T2, T3]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, func(T3) T.Tuple3[T1, T2, T3]], func(context.Context) func() E.Either[error, func(T2) func(T3) T.Tuple3[T1, T2, T3]], GR_T2], + ApSeq[GR_TUPLE3, func(context.Context) func() E.Either[error, func(T3) T.Tuple3[T1, T2, T3]], GR_T3], + t1, + t2, + t3, + ) +} + +// SequenceParT3 converts 3 readers into a reader of a [T.Tuple3]. +func SequenceParT3[ + GR_TUPLE3 ~func(context.Context) GIO_TUPLE3, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GIO_TUPLE3 ~func() E.Either[error, T.Tuple3[T1, T2, T3]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + T1, + T2, + T3 any]( + t1 GR_T1, + t2 GR_T2, + t3 GR_T3, +) GR_TUPLE3 { + return A.SequenceT3( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) T.Tuple3[T1, T2, T3]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, func(T3) T.Tuple3[T1, T2, T3]], func(context.Context) func() E.Either[error, func(T2) func(T3) T.Tuple3[T1, T2, T3]], GR_T2], + ApPar[GR_TUPLE3, func(context.Context) func() E.Either[error, func(T3) T.Tuple3[T1, T2, T3]], GR_T3], + t1, + t2, + t3, + ) +} + // SequenceTuple3 converts a [T.Tuple3] of readers into a reader of a [T.Tuple3]. func SequenceTuple3[ GR_TUPLE3 ~func(context.Context) GIO_TUPLE3, @@ -151,6 +466,144 @@ func SequenceTuple3[ ) } +// SequenceSeqTuple3 converts a [T.Tuple3] of readers into a reader of a [T.Tuple3]. +func SequenceSeqTuple3[ + GR_TUPLE3 ~func(context.Context) GIO_TUPLE3, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GIO_TUPLE3 ~func() E.Either[error, T.Tuple3[T1, T2, T3]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + T1, + T2, + T3 any](t T.Tuple3[GR_T1, GR_T2, GR_T3]) GR_TUPLE3 { + return A.SequenceTuple3( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) T.Tuple3[T1, T2, T3]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, func(T3) T.Tuple3[T1, T2, T3]], func(context.Context) func() E.Either[error, func(T2) func(T3) T.Tuple3[T1, T2, T3]], GR_T2], + ApSeq[GR_TUPLE3, func(context.Context) func() E.Either[error, func(T3) T.Tuple3[T1, T2, T3]], GR_T3], + t, + ) +} + +// SequenceParTuple3 converts a [T.Tuple3] of readers into a reader of a [T.Tuple3]. +func SequenceParTuple3[ + GR_TUPLE3 ~func(context.Context) GIO_TUPLE3, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GIO_TUPLE3 ~func() E.Either[error, T.Tuple3[T1, T2, T3]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + T1, + T2, + T3 any](t T.Tuple3[GR_T1, GR_T2, GR_T3]) GR_TUPLE3 { + return A.SequenceTuple3( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) T.Tuple3[T1, T2, T3]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, func(T3) T.Tuple3[T1, T2, T3]], func(context.Context) func() E.Either[error, func(T2) func(T3) T.Tuple3[T1, T2, T3]], GR_T2], + ApPar[GR_TUPLE3, func(context.Context) func() E.Either[error, func(T3) T.Tuple3[T1, T2, T3]], GR_T3], + t, + ) +} + +// TraverseTuple3 converts a [T.Tuple3] of readers into a reader of a [T.Tuple3]. +func TraverseTuple3[ + GR_TUPLE3 ~func(context.Context) GIO_TUPLE3, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GIO_TUPLE3 ~func() E.Either[error, T.Tuple3[T1, T2, T3]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + A1, + T1, + A2, + T2, + A3, + T3 any](f1 F1, f2 F2, f3 F3) func(T.Tuple3[A1, A2, A3]) GR_TUPLE3 { + return func(t T.Tuple3[A1, A2, A3]) GR_TUPLE3 { + return A.TraverseTuple3( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) T.Tuple3[T1, T2, T3]], GIO_T1], + Ap[func(context.Context) func() E.Either[error, func(T3) T.Tuple3[T1, T2, T3]], func(context.Context) func() E.Either[error, func(T2) func(T3) T.Tuple3[T1, T2, T3]], GR_T2], + Ap[GR_TUPLE3, func(context.Context) func() E.Either[error, func(T3) T.Tuple3[T1, T2, T3]], GR_T3], + f1, + f2, + f3, + t, + ) + } +} + +// TraverseSeqTuple3 converts a [T.Tuple3] of readers into a reader of a [T.Tuple3]. +func TraverseSeqTuple3[ + GR_TUPLE3 ~func(context.Context) GIO_TUPLE3, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GIO_TUPLE3 ~func() E.Either[error, T.Tuple3[T1, T2, T3]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + A1, + T1, + A2, + T2, + A3, + T3 any](f1 F1, f2 F2, f3 F3) func(T.Tuple3[A1, A2, A3]) GR_TUPLE3 { + return func(t T.Tuple3[A1, A2, A3]) GR_TUPLE3 { + return A.TraverseTuple3( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) T.Tuple3[T1, T2, T3]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, func(T3) T.Tuple3[T1, T2, T3]], func(context.Context) func() E.Either[error, func(T2) func(T3) T.Tuple3[T1, T2, T3]], GR_T2], + ApSeq[GR_TUPLE3, func(context.Context) func() E.Either[error, func(T3) T.Tuple3[T1, T2, T3]], GR_T3], + f1, + f2, + f3, + t, + ) + } +} + +// TraverseParTuple3 converts a [T.Tuple3] of readers into a reader of a [T.Tuple3]. +func TraverseParTuple3[ + GR_TUPLE3 ~func(context.Context) GIO_TUPLE3, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GIO_TUPLE3 ~func() E.Either[error, T.Tuple3[T1, T2, T3]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + A1, + T1, + A2, + T2, + A3, + T3 any](f1 F1, f2 F2, f3 F3) func(T.Tuple3[A1, A2, A3]) GR_TUPLE3 { + return func(t T.Tuple3[A1, A2, A3]) GR_TUPLE3 { + return A.TraverseTuple3( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) T.Tuple3[T1, T2, T3]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, func(T3) T.Tuple3[T1, T2, T3]], func(context.Context) func() E.Either[error, func(T2) func(T3) T.Tuple3[T1, T2, T3]], GR_T2], + ApPar[GR_TUPLE3, func(context.Context) func() E.Either[error, func(T3) T.Tuple3[T1, T2, T3]], GR_T3], + f1, + f2, + f3, + t, + ) + } +} + // Eitherize4 converts a function with 4 parameters returning a tuple into a function with 4 parameters returning a [GRA] // The inverse function is [Uneitherize4] func Eitherize4[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, R any](f F) func(T0, T1, T2, T3) GRA { @@ -190,6 +643,72 @@ func SequenceT4[ ) } +// SequenceSeqT4 converts 4 readers into a reader of a [T.Tuple4]. +func SequenceSeqT4[ + GR_TUPLE4 ~func(context.Context) GIO_TUPLE4, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GIO_TUPLE4 ~func() E.Either[error, T.Tuple4[T1, T2, T3, T4]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + T1, + T2, + T3, + T4 any]( + t1 GR_T1, + t2 GR_T2, + t3 GR_T3, + t4 GR_T4, +) GR_TUPLE4 { + return A.SequenceT4( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, func(T4) T.Tuple4[T1, T2, T3, T4]], func(context.Context) func() E.Either[error, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T3], + ApSeq[GR_TUPLE4, func(context.Context) func() E.Either[error, func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T4], + t1, + t2, + t3, + t4, + ) +} + +// SequenceParT4 converts 4 readers into a reader of a [T.Tuple4]. +func SequenceParT4[ + GR_TUPLE4 ~func(context.Context) GIO_TUPLE4, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GIO_TUPLE4 ~func() E.Either[error, T.Tuple4[T1, T2, T3, T4]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + T1, + T2, + T3, + T4 any]( + t1 GR_T1, + t2 GR_T2, + t3 GR_T3, + t4 GR_T4, +) GR_TUPLE4 { + return A.SequenceT4( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, func(T4) T.Tuple4[T1, T2, T3, T4]], func(context.Context) func() E.Either[error, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T3], + ApPar[GR_TUPLE4, func(context.Context) func() E.Either[error, func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T4], + t1, + t2, + t3, + t4, + ) +} + // SequenceTuple4 converts a [T.Tuple4] of readers into a reader of a [T.Tuple4]. func SequenceTuple4[ GR_TUPLE4 ~func(context.Context) GIO_TUPLE4, @@ -215,6 +734,173 @@ func SequenceTuple4[ ) } +// SequenceSeqTuple4 converts a [T.Tuple4] of readers into a reader of a [T.Tuple4]. +func SequenceSeqTuple4[ + GR_TUPLE4 ~func(context.Context) GIO_TUPLE4, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GIO_TUPLE4 ~func() E.Either[error, T.Tuple4[T1, T2, T3, T4]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + T1, + T2, + T3, + T4 any](t T.Tuple4[GR_T1, GR_T2, GR_T3, GR_T4]) GR_TUPLE4 { + return A.SequenceTuple4( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, func(T4) T.Tuple4[T1, T2, T3, T4]], func(context.Context) func() E.Either[error, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T3], + ApSeq[GR_TUPLE4, func(context.Context) func() E.Either[error, func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T4], + t, + ) +} + +// SequenceParTuple4 converts a [T.Tuple4] of readers into a reader of a [T.Tuple4]. +func SequenceParTuple4[ + GR_TUPLE4 ~func(context.Context) GIO_TUPLE4, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GIO_TUPLE4 ~func() E.Either[error, T.Tuple4[T1, T2, T3, T4]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + T1, + T2, + T3, + T4 any](t T.Tuple4[GR_T1, GR_T2, GR_T3, GR_T4]) GR_TUPLE4 { + return A.SequenceTuple4( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, func(T4) T.Tuple4[T1, T2, T3, T4]], func(context.Context) func() E.Either[error, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T3], + ApPar[GR_TUPLE4, func(context.Context) func() E.Either[error, func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T4], + t, + ) +} + +// TraverseTuple4 converts a [T.Tuple4] of readers into a reader of a [T.Tuple4]. +func TraverseTuple4[ + GR_TUPLE4 ~func(context.Context) GIO_TUPLE4, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GIO_TUPLE4 ~func() E.Either[error, T.Tuple4[T1, T2, T3, T4]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, 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]) GR_TUPLE4 { + return func(t T.Tuple4[A1, A2, A3, A4]) GR_TUPLE4 { + return A.TraverseTuple4( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GIO_T1], + Ap[func(context.Context) func() E.Either[error, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T2], + Ap[func(context.Context) func() E.Either[error, func(T4) T.Tuple4[T1, T2, T3, T4]], func(context.Context) func() E.Either[error, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T3], + Ap[GR_TUPLE4, func(context.Context) func() E.Either[error, func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T4], + f1, + f2, + f3, + f4, + t, + ) + } +} + +// TraverseSeqTuple4 converts a [T.Tuple4] of readers into a reader of a [T.Tuple4]. +func TraverseSeqTuple4[ + GR_TUPLE4 ~func(context.Context) GIO_TUPLE4, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GIO_TUPLE4 ~func() E.Either[error, T.Tuple4[T1, T2, T3, T4]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, 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]) GR_TUPLE4 { + return func(t T.Tuple4[A1, A2, A3, A4]) GR_TUPLE4 { + return A.TraverseTuple4( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, func(T4) T.Tuple4[T1, T2, T3, T4]], func(context.Context) func() E.Either[error, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T3], + ApSeq[GR_TUPLE4, func(context.Context) func() E.Either[error, func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T4], + f1, + f2, + f3, + f4, + t, + ) + } +} + +// TraverseParTuple4 converts a [T.Tuple4] of readers into a reader of a [T.Tuple4]. +func TraverseParTuple4[ + GR_TUPLE4 ~func(context.Context) GIO_TUPLE4, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GIO_TUPLE4 ~func() E.Either[error, T.Tuple4[T1, T2, T3, T4]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, 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]) GR_TUPLE4 { + return func(t T.Tuple4[A1, A2, A3, A4]) GR_TUPLE4 { + return A.TraverseTuple4( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, func(T4) T.Tuple4[T1, T2, T3, T4]], func(context.Context) func() E.Either[error, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T3], + ApPar[GR_TUPLE4, func(context.Context) func() E.Either[error, func(T4) T.Tuple4[T1, T2, T3, T4]], GR_T4], + f1, + f2, + f3, + f4, + t, + ) + } +} + // Eitherize5 converts a function with 5 parameters returning a tuple into a function with 5 parameters returning a [GRA] // The inverse function is [Uneitherize5] func Eitherize5[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, R any](f F) func(T0, T1, T2, T3, T4) GRA { @@ -260,6 +946,84 @@ func SequenceT5[ ) } +// SequenceSeqT5 converts 5 readers into a reader of a [T.Tuple5]. +func SequenceSeqT5[ + GR_TUPLE5 ~func(context.Context) GIO_TUPLE5, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GIO_TUPLE5 ~func() E.Either[error, T.Tuple5[T1, T2, T3, T4, T5]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + T1, + T2, + T3, + T4, + T5 any]( + t1 GR_T1, + t2 GR_T2, + t3 GR_T3, + t4 GR_T4, + t5 GR_T5, +) GR_TUPLE5 { + return A.SequenceT5( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T3], + ApSeq[func(context.Context) func() E.Either[error, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T4], + ApSeq[GR_TUPLE5, func(context.Context) func() E.Either[error, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T5], + t1, + t2, + t3, + t4, + t5, + ) +} + +// SequenceParT5 converts 5 readers into a reader of a [T.Tuple5]. +func SequenceParT5[ + GR_TUPLE5 ~func(context.Context) GIO_TUPLE5, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GIO_TUPLE5 ~func() E.Either[error, T.Tuple5[T1, T2, T3, T4, T5]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + T1, + T2, + T3, + T4, + T5 any]( + t1 GR_T1, + t2 GR_T2, + t3 GR_T3, + t4 GR_T4, + t5 GR_T5, +) GR_TUPLE5 { + return A.SequenceT5( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T3], + ApPar[func(context.Context) func() E.Either[error, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T4], + ApPar[GR_TUPLE5, func(context.Context) func() E.Either[error, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T5], + t1, + t2, + t3, + t4, + t5, + ) +} + // SequenceTuple5 converts a [T.Tuple5] of readers into a reader of a [T.Tuple5]. func SequenceTuple5[ GR_TUPLE5 ~func(context.Context) GIO_TUPLE5, @@ -289,6 +1053,202 @@ func SequenceTuple5[ ) } +// SequenceSeqTuple5 converts a [T.Tuple5] of readers into a reader of a [T.Tuple5]. +func SequenceSeqTuple5[ + GR_TUPLE5 ~func(context.Context) GIO_TUPLE5, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GIO_TUPLE5 ~func() E.Either[error, T.Tuple5[T1, T2, T3, T4, T5]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + T1, + T2, + T3, + T4, + T5 any](t T.Tuple5[GR_T1, GR_T2, GR_T3, GR_T4, GR_T5]) GR_TUPLE5 { + return A.SequenceTuple5( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T3], + ApSeq[func(context.Context) func() E.Either[error, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T4], + ApSeq[GR_TUPLE5, func(context.Context) func() E.Either[error, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T5], + t, + ) +} + +// SequenceParTuple5 converts a [T.Tuple5] of readers into a reader of a [T.Tuple5]. +func SequenceParTuple5[ + GR_TUPLE5 ~func(context.Context) GIO_TUPLE5, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GIO_TUPLE5 ~func() E.Either[error, T.Tuple5[T1, T2, T3, T4, T5]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + T1, + T2, + T3, + T4, + T5 any](t T.Tuple5[GR_T1, GR_T2, GR_T3, GR_T4, GR_T5]) GR_TUPLE5 { + return A.SequenceTuple5( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T3], + ApPar[func(context.Context) func() E.Either[error, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T4], + ApPar[GR_TUPLE5, func(context.Context) func() E.Either[error, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T5], + t, + ) +} + +// TraverseTuple5 converts a [T.Tuple5] of readers into a reader of a [T.Tuple5]. +func TraverseTuple5[ + GR_TUPLE5 ~func(context.Context) GIO_TUPLE5, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + F5 ~func(A5) GR_T5, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GIO_TUPLE5 ~func() E.Either[error, T.Tuple5[T1, T2, T3, T4, T5]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, 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]) GR_TUPLE5 { + return func(t T.Tuple5[A1, A2, A3, A4, A5]) GR_TUPLE5 { + return A.TraverseTuple5( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GIO_T1], + Ap[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T2], + Ap[func(context.Context) func() E.Either[error, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T3], + Ap[func(context.Context) func() E.Either[error, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T4], + Ap[GR_TUPLE5, func(context.Context) func() E.Either[error, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T5], + f1, + f2, + f3, + f4, + f5, + t, + ) + } +} + +// TraverseSeqTuple5 converts a [T.Tuple5] of readers into a reader of a [T.Tuple5]. +func TraverseSeqTuple5[ + GR_TUPLE5 ~func(context.Context) GIO_TUPLE5, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + F5 ~func(A5) GR_T5, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GIO_TUPLE5 ~func() E.Either[error, T.Tuple5[T1, T2, T3, T4, T5]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, 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]) GR_TUPLE5 { + return func(t T.Tuple5[A1, A2, A3, A4, A5]) GR_TUPLE5 { + return A.TraverseTuple5( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T3], + ApSeq[func(context.Context) func() E.Either[error, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T4], + ApSeq[GR_TUPLE5, func(context.Context) func() E.Either[error, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T5], + f1, + f2, + f3, + f4, + f5, + t, + ) + } +} + +// TraverseParTuple5 converts a [T.Tuple5] of readers into a reader of a [T.Tuple5]. +func TraverseParTuple5[ + GR_TUPLE5 ~func(context.Context) GIO_TUPLE5, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + F5 ~func(A5) GR_T5, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GIO_TUPLE5 ~func() E.Either[error, T.Tuple5[T1, T2, T3, T4, T5]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, 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]) GR_TUPLE5 { + return func(t T.Tuple5[A1, A2, A3, A4, A5]) GR_TUPLE5 { + return A.TraverseTuple5( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T3], + ApPar[func(context.Context) func() E.Either[error, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func(context.Context) func() E.Either[error, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T4], + ApPar[GR_TUPLE5, func(context.Context) func() E.Either[error, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], GR_T5], + f1, + f2, + f3, + f4, + f5, + t, + ) + } +} + // Eitherize6 converts a function with 6 parameters returning a tuple into a function with 6 parameters returning a [GRA] // The inverse function is [Uneitherize6] func Eitherize6[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, R any](f F) func(T0, T1, T2, T3, T4, T5) GRA { @@ -340,6 +1300,96 @@ func SequenceT6[ ) } +// SequenceSeqT6 converts 6 readers into a reader of a [T.Tuple6]. +func SequenceSeqT6[ + GR_TUPLE6 ~func(context.Context) GIO_TUPLE6, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GIO_TUPLE6 ~func() E.Either[error, T.Tuple6[T1, T2, T3, T4, T5, T6]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + T1, + T2, + T3, + T4, + T5, + T6 any]( + t1 GR_T1, + t2 GR_T2, + t3 GR_T3, + t4 GR_T4, + t5 GR_T5, + t6 GR_T6, +) GR_TUPLE6 { + return A.SequenceT6( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T3], + ApSeq[func(context.Context) func() E.Either[error, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T4], + ApSeq[func(context.Context) func() E.Either[error, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T5], + ApSeq[GR_TUPLE6, func(context.Context) func() E.Either[error, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T6], + t1, + t2, + t3, + t4, + t5, + t6, + ) +} + +// SequenceParT6 converts 6 readers into a reader of a [T.Tuple6]. +func SequenceParT6[ + GR_TUPLE6 ~func(context.Context) GIO_TUPLE6, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GIO_TUPLE6 ~func() E.Either[error, T.Tuple6[T1, T2, T3, T4, T5, T6]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + T1, + T2, + T3, + T4, + T5, + T6 any]( + t1 GR_T1, + t2 GR_T2, + t3 GR_T3, + t4 GR_T4, + t5 GR_T5, + t6 GR_T6, +) GR_TUPLE6 { + return A.SequenceT6( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T3], + ApPar[func(context.Context) func() E.Either[error, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T4], + ApPar[func(context.Context) func() E.Either[error, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T5], + ApPar[GR_TUPLE6, func(context.Context) func() E.Either[error, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T6], + t1, + t2, + t3, + t4, + t5, + t6, + ) +} + // SequenceTuple6 converts a [T.Tuple6] of readers into a reader of a [T.Tuple6]. func SequenceTuple6[ GR_TUPLE6 ~func(context.Context) GIO_TUPLE6, @@ -373,6 +1423,231 @@ func SequenceTuple6[ ) } +// SequenceSeqTuple6 converts a [T.Tuple6] of readers into a reader of a [T.Tuple6]. +func SequenceSeqTuple6[ + GR_TUPLE6 ~func(context.Context) GIO_TUPLE6, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GIO_TUPLE6 ~func() E.Either[error, T.Tuple6[T1, T2, T3, T4, T5, T6]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + T1, + T2, + T3, + T4, + T5, + T6 any](t T.Tuple6[GR_T1, GR_T2, GR_T3, GR_T4, GR_T5, GR_T6]) GR_TUPLE6 { + return A.SequenceTuple6( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T3], + ApSeq[func(context.Context) func() E.Either[error, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T4], + ApSeq[func(context.Context) func() E.Either[error, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T5], + ApSeq[GR_TUPLE6, func(context.Context) func() E.Either[error, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T6], + t, + ) +} + +// SequenceParTuple6 converts a [T.Tuple6] of readers into a reader of a [T.Tuple6]. +func SequenceParTuple6[ + GR_TUPLE6 ~func(context.Context) GIO_TUPLE6, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GIO_TUPLE6 ~func() E.Either[error, T.Tuple6[T1, T2, T3, T4, T5, T6]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + T1, + T2, + T3, + T4, + T5, + T6 any](t T.Tuple6[GR_T1, GR_T2, GR_T3, GR_T4, GR_T5, GR_T6]) GR_TUPLE6 { + return A.SequenceTuple6( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T3], + ApPar[func(context.Context) func() E.Either[error, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T4], + ApPar[func(context.Context) func() E.Either[error, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T5], + ApPar[GR_TUPLE6, func(context.Context) func() E.Either[error, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T6], + t, + ) +} + +// TraverseTuple6 converts a [T.Tuple6] of readers into a reader of a [T.Tuple6]. +func TraverseTuple6[ + GR_TUPLE6 ~func(context.Context) GIO_TUPLE6, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + F5 ~func(A5) GR_T5, + F6 ~func(A6) GR_T6, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GIO_TUPLE6 ~func() E.Either[error, T.Tuple6[T1, T2, T3, T4, T5, T6]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, 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]) GR_TUPLE6 { + return func(t T.Tuple6[A1, A2, A3, A4, A5, A6]) GR_TUPLE6 { + return A.TraverseTuple6( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GIO_T1], + Ap[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T2], + Ap[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T3], + Ap[func(context.Context) func() E.Either[error, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T4], + Ap[func(context.Context) func() E.Either[error, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T5], + Ap[GR_TUPLE6, func(context.Context) func() E.Either[error, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T6], + f1, + f2, + f3, + f4, + f5, + f6, + t, + ) + } +} + +// TraverseSeqTuple6 converts a [T.Tuple6] of readers into a reader of a [T.Tuple6]. +func TraverseSeqTuple6[ + GR_TUPLE6 ~func(context.Context) GIO_TUPLE6, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + F5 ~func(A5) GR_T5, + F6 ~func(A6) GR_T6, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GIO_TUPLE6 ~func() E.Either[error, T.Tuple6[T1, T2, T3, T4, T5, T6]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, 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]) GR_TUPLE6 { + return func(t T.Tuple6[A1, A2, A3, A4, A5, A6]) GR_TUPLE6 { + return A.TraverseTuple6( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T3], + ApSeq[func(context.Context) func() E.Either[error, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T4], + ApSeq[func(context.Context) func() E.Either[error, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T5], + ApSeq[GR_TUPLE6, func(context.Context) func() E.Either[error, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T6], + f1, + f2, + f3, + f4, + f5, + f6, + t, + ) + } +} + +// TraverseParTuple6 converts a [T.Tuple6] of readers into a reader of a [T.Tuple6]. +func TraverseParTuple6[ + GR_TUPLE6 ~func(context.Context) GIO_TUPLE6, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + F5 ~func(A5) GR_T5, + F6 ~func(A6) GR_T6, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GIO_TUPLE6 ~func() E.Either[error, T.Tuple6[T1, T2, T3, T4, T5, T6]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, 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]) GR_TUPLE6 { + return func(t T.Tuple6[A1, A2, A3, A4, A5, A6]) GR_TUPLE6 { + return A.TraverseTuple6( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T3], + ApPar[func(context.Context) func() E.Either[error, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T4], + ApPar[func(context.Context) func() E.Either[error, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func(context.Context) func() E.Either[error, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T5], + ApPar[GR_TUPLE6, func(context.Context) func() E.Either[error, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], GR_T6], + f1, + f2, + f3, + f4, + f5, + f6, + t, + ) + } +} + // Eitherize7 converts a function with 7 parameters returning a tuple into a function with 7 parameters returning a [GRA] // The inverse function is [Uneitherize7] func Eitherize7[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) GRA { @@ -430,6 +1705,108 @@ func SequenceT7[ ) } +// SequenceSeqT7 converts 7 readers into a reader of a [T.Tuple7]. +func SequenceSeqT7[ + GR_TUPLE7 ~func(context.Context) GIO_TUPLE7, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GIO_TUPLE7 ~func() E.Either[error, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + T1, + T2, + T3, + T4, + T5, + T6, + T7 any]( + t1 GR_T1, + t2 GR_T2, + t3 GR_T3, + t4 GR_T4, + t5 GR_T5, + t6 GR_T6, + t7 GR_T7, +) GR_TUPLE7 { + return A.SequenceT7( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T3], + ApSeq[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T4], + ApSeq[func(context.Context) func() E.Either[error, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T5], + ApSeq[func(context.Context) func() E.Either[error, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T6], + ApSeq[GR_TUPLE7, func(context.Context) func() E.Either[error, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T7], + t1, + t2, + t3, + t4, + t5, + t6, + t7, + ) +} + +// SequenceParT7 converts 7 readers into a reader of a [T.Tuple7]. +func SequenceParT7[ + GR_TUPLE7 ~func(context.Context) GIO_TUPLE7, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GIO_TUPLE7 ~func() E.Either[error, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + T1, + T2, + T3, + T4, + T5, + T6, + T7 any]( + t1 GR_T1, + t2 GR_T2, + t3 GR_T3, + t4 GR_T4, + t5 GR_T5, + t6 GR_T6, + t7 GR_T7, +) GR_TUPLE7 { + return A.SequenceT7( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T3], + ApPar[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T4], + ApPar[func(context.Context) func() E.Either[error, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T5], + ApPar[func(context.Context) func() E.Either[error, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T6], + ApPar[GR_TUPLE7, func(context.Context) func() E.Either[error, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T7], + t1, + t2, + t3, + t4, + t5, + t6, + t7, + ) +} + // SequenceTuple7 converts a [T.Tuple7] of readers into a reader of a [T.Tuple7]. func SequenceTuple7[ GR_TUPLE7 ~func(context.Context) GIO_TUPLE7, @@ -467,6 +1844,260 @@ func SequenceTuple7[ ) } +// SequenceSeqTuple7 converts a [T.Tuple7] of readers into a reader of a [T.Tuple7]. +func SequenceSeqTuple7[ + GR_TUPLE7 ~func(context.Context) GIO_TUPLE7, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GIO_TUPLE7 ~func() E.Either[error, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + T1, + T2, + T3, + T4, + T5, + T6, + T7 any](t T.Tuple7[GR_T1, GR_T2, GR_T3, GR_T4, GR_T5, GR_T6, GR_T7]) GR_TUPLE7 { + return A.SequenceTuple7( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T3], + ApSeq[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T4], + ApSeq[func(context.Context) func() E.Either[error, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T5], + ApSeq[func(context.Context) func() E.Either[error, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T6], + ApSeq[GR_TUPLE7, func(context.Context) func() E.Either[error, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T7], + t, + ) +} + +// SequenceParTuple7 converts a [T.Tuple7] of readers into a reader of a [T.Tuple7]. +func SequenceParTuple7[ + GR_TUPLE7 ~func(context.Context) GIO_TUPLE7, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GIO_TUPLE7 ~func() E.Either[error, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + T1, + T2, + T3, + T4, + T5, + T6, + T7 any](t T.Tuple7[GR_T1, GR_T2, GR_T3, GR_T4, GR_T5, GR_T6, GR_T7]) GR_TUPLE7 { + return A.SequenceTuple7( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T3], + ApPar[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T4], + ApPar[func(context.Context) func() E.Either[error, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T5], + ApPar[func(context.Context) func() E.Either[error, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T6], + ApPar[GR_TUPLE7, func(context.Context) func() E.Either[error, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T7], + t, + ) +} + +// TraverseTuple7 converts a [T.Tuple7] of readers into a reader of a [T.Tuple7]. +func TraverseTuple7[ + GR_TUPLE7 ~func(context.Context) GIO_TUPLE7, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + F5 ~func(A5) GR_T5, + F6 ~func(A6) GR_T6, + F7 ~func(A7) GR_T7, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GIO_TUPLE7 ~func() E.Either[error, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, 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]) GR_TUPLE7 { + return func(t T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) GR_TUPLE7 { + return A.TraverseTuple7( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GIO_T1], + Ap[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T2], + Ap[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T3], + Ap[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T4], + Ap[func(context.Context) func() E.Either[error, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T5], + Ap[func(context.Context) func() E.Either[error, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T6], + Ap[GR_TUPLE7, func(context.Context) func() E.Either[error, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T7], + f1, + f2, + f3, + f4, + f5, + f6, + f7, + t, + ) + } +} + +// TraverseSeqTuple7 converts a [T.Tuple7] of readers into a reader of a [T.Tuple7]. +func TraverseSeqTuple7[ + GR_TUPLE7 ~func(context.Context) GIO_TUPLE7, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + F5 ~func(A5) GR_T5, + F6 ~func(A6) GR_T6, + F7 ~func(A7) GR_T7, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GIO_TUPLE7 ~func() E.Either[error, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, 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]) GR_TUPLE7 { + return func(t T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) GR_TUPLE7 { + return A.TraverseTuple7( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T3], + ApSeq[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T4], + ApSeq[func(context.Context) func() E.Either[error, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T5], + ApSeq[func(context.Context) func() E.Either[error, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T6], + ApSeq[GR_TUPLE7, func(context.Context) func() E.Either[error, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T7], + f1, + f2, + f3, + f4, + f5, + f6, + f7, + t, + ) + } +} + +// TraverseParTuple7 converts a [T.Tuple7] of readers into a reader of a [T.Tuple7]. +func TraverseParTuple7[ + GR_TUPLE7 ~func(context.Context) GIO_TUPLE7, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + F5 ~func(A5) GR_T5, + F6 ~func(A6) GR_T6, + F7 ~func(A7) GR_T7, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GIO_TUPLE7 ~func() E.Either[error, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, 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]) GR_TUPLE7 { + return func(t T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) GR_TUPLE7 { + return A.TraverseTuple7( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T3], + ApPar[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T4], + ApPar[func(context.Context) func() E.Either[error, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T5], + ApPar[func(context.Context) func() E.Either[error, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func(context.Context) func() E.Either[error, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T6], + ApPar[GR_TUPLE7, func(context.Context) func() E.Either[error, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], GR_T7], + f1, + f2, + f3, + f4, + f5, + f6, + f7, + t, + ) + } +} + // Eitherize8 converts a function with 8 parameters returning a tuple into a function with 8 parameters returning a [GRA] // The inverse function is [Uneitherize8] func Eitherize8[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) GRA { @@ -530,6 +2161,120 @@ func SequenceT8[ ) } +// SequenceSeqT8 converts 8 readers into a reader of a [T.Tuple8]. +func SequenceSeqT8[ + GR_TUPLE8 ~func(context.Context) GIO_TUPLE8, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GIO_TUPLE8 ~func() E.Either[error, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, T8], + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8 any]( + t1 GR_T1, + t2 GR_T2, + t3 GR_T3, + t4 GR_T4, + t5 GR_T5, + t6 GR_T6, + t7 GR_T7, + t8 GR_T8, +) GR_TUPLE8 { + return A.SequenceT8( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T3], + ApSeq[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T4], + ApSeq[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T5], + ApSeq[func(context.Context) func() E.Either[error, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T6], + ApSeq[func(context.Context) func() E.Either[error, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T7], + ApSeq[GR_TUPLE8, func(context.Context) func() E.Either[error, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T8], + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + ) +} + +// SequenceParT8 converts 8 readers into a reader of a [T.Tuple8]. +func SequenceParT8[ + GR_TUPLE8 ~func(context.Context) GIO_TUPLE8, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GIO_TUPLE8 ~func() E.Either[error, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, T8], + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8 any]( + t1 GR_T1, + t2 GR_T2, + t3 GR_T3, + t4 GR_T4, + t5 GR_T5, + t6 GR_T6, + t7 GR_T7, + t8 GR_T8, +) GR_TUPLE8 { + return A.SequenceT8( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T3], + ApPar[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T4], + ApPar[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T5], + ApPar[func(context.Context) func() E.Either[error, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T6], + ApPar[func(context.Context) func() E.Either[error, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T7], + ApPar[GR_TUPLE8, func(context.Context) func() E.Either[error, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T8], + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + ) +} + // SequenceTuple8 converts a [T.Tuple8] of readers into a reader of a [T.Tuple8]. func SequenceTuple8[ GR_TUPLE8 ~func(context.Context) GIO_TUPLE8, @@ -571,6 +2316,289 @@ func SequenceTuple8[ ) } +// SequenceSeqTuple8 converts a [T.Tuple8] of readers into a reader of a [T.Tuple8]. +func SequenceSeqTuple8[ + GR_TUPLE8 ~func(context.Context) GIO_TUPLE8, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GIO_TUPLE8 ~func() E.Either[error, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, T8], + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8 any](t T.Tuple8[GR_T1, GR_T2, GR_T3, GR_T4, GR_T5, GR_T6, GR_T7, GR_T8]) GR_TUPLE8 { + return A.SequenceTuple8( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T3], + ApSeq[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T4], + ApSeq[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T5], + ApSeq[func(context.Context) func() E.Either[error, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T6], + ApSeq[func(context.Context) func() E.Either[error, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T7], + ApSeq[GR_TUPLE8, func(context.Context) func() E.Either[error, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T8], + t, + ) +} + +// SequenceParTuple8 converts a [T.Tuple8] of readers into a reader of a [T.Tuple8]. +func SequenceParTuple8[ + GR_TUPLE8 ~func(context.Context) GIO_TUPLE8, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GIO_TUPLE8 ~func() E.Either[error, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, T8], + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8 any](t T.Tuple8[GR_T1, GR_T2, GR_T3, GR_T4, GR_T5, GR_T6, GR_T7, GR_T8]) GR_TUPLE8 { + return A.SequenceTuple8( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T3], + ApPar[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T4], + ApPar[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T5], + ApPar[func(context.Context) func() E.Either[error, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T6], + ApPar[func(context.Context) func() E.Either[error, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T7], + ApPar[GR_TUPLE8, func(context.Context) func() E.Either[error, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T8], + t, + ) +} + +// TraverseTuple8 converts a [T.Tuple8] of readers into a reader of a [T.Tuple8]. +func TraverseTuple8[ + GR_TUPLE8 ~func(context.Context) GIO_TUPLE8, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + F5 ~func(A5) GR_T5, + F6 ~func(A6) GR_T6, + F7 ~func(A7) GR_T7, + F8 ~func(A8) GR_T8, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GIO_TUPLE8 ~func() E.Either[error, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, 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]) GR_TUPLE8 { + return func(t T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) GR_TUPLE8 { + return A.TraverseTuple8( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GIO_T1], + Ap[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T2], + Ap[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T3], + Ap[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T4], + Ap[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T5], + Ap[func(context.Context) func() E.Either[error, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T6], + Ap[func(context.Context) func() E.Either[error, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T7], + Ap[GR_TUPLE8, func(context.Context) func() E.Either[error, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T8], + f1, + f2, + f3, + f4, + f5, + f6, + f7, + f8, + t, + ) + } +} + +// TraverseSeqTuple8 converts a [T.Tuple8] of readers into a reader of a [T.Tuple8]. +func TraverseSeqTuple8[ + GR_TUPLE8 ~func(context.Context) GIO_TUPLE8, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + F5 ~func(A5) GR_T5, + F6 ~func(A6) GR_T6, + F7 ~func(A7) GR_T7, + F8 ~func(A8) GR_T8, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GIO_TUPLE8 ~func() E.Either[error, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, 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]) GR_TUPLE8 { + return func(t T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) GR_TUPLE8 { + return A.TraverseTuple8( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T3], + ApSeq[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T4], + ApSeq[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T5], + ApSeq[func(context.Context) func() E.Either[error, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T6], + ApSeq[func(context.Context) func() E.Either[error, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T7], + ApSeq[GR_TUPLE8, func(context.Context) func() E.Either[error, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T8], + f1, + f2, + f3, + f4, + f5, + f6, + f7, + f8, + t, + ) + } +} + +// TraverseParTuple8 converts a [T.Tuple8] of readers into a reader of a [T.Tuple8]. +func TraverseParTuple8[ + GR_TUPLE8 ~func(context.Context) GIO_TUPLE8, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + F5 ~func(A5) GR_T5, + F6 ~func(A6) GR_T6, + F7 ~func(A7) GR_T7, + F8 ~func(A8) GR_T8, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GIO_TUPLE8 ~func() E.Either[error, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, 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]) GR_TUPLE8 { + return func(t T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) GR_TUPLE8 { + return A.TraverseTuple8( + Map[GR_T1, func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T3], + ApPar[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T4], + ApPar[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T5], + ApPar[func(context.Context) func() E.Either[error, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T6], + ApPar[func(context.Context) func() E.Either[error, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func(context.Context) func() E.Either[error, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T7], + ApPar[GR_TUPLE8, func(context.Context) func() E.Either[error, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], GR_T8], + f1, + f2, + f3, + f4, + f5, + f6, + f7, + f8, + t, + ) + } +} + // Eitherize9 converts a function with 9 parameters returning a tuple into a function with 9 parameters returning a [GRA] // The inverse function is [Uneitherize9] func Eitherize9[GRA ~func(context.Context) GIOA, F ~func(context.Context, 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, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) GRA { @@ -640,6 +2668,132 @@ func SequenceT9[ ) } +// SequenceSeqT9 converts 9 readers into a reader of a [T.Tuple9]. +func SequenceSeqT9[ + GR_TUPLE9 ~func(context.Context) GIO_TUPLE9, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GR_T9 ~func(context.Context) GIO_T9, + GIO_TUPLE9 ~func() E.Either[error, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, T8], + GIO_T9 ~func() E.Either[error, T9], + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9 any]( + t1 GR_T1, + t2 GR_T2, + t3 GR_T3, + t4 GR_T4, + t5 GR_T5, + t6 GR_T6, + t7 GR_T7, + t8 GR_T8, + t9 GR_T9, +) GR_TUPLE9 { + return A.SequenceT9( + Map[GR_T1, func(context.Context) func() E.Either[error, 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]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, 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]], GR_T3], + ApSeq[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T4], + ApSeq[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T5], + ApSeq[func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T6], + ApSeq[func(context.Context) func() E.Either[error, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T7], + ApSeq[func(context.Context) func() E.Either[error, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T8], + ApSeq[GR_TUPLE9, func(context.Context) func() E.Either[error, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T9], + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + ) +} + +// SequenceParT9 converts 9 readers into a reader of a [T.Tuple9]. +func SequenceParT9[ + GR_TUPLE9 ~func(context.Context) GIO_TUPLE9, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GR_T9 ~func(context.Context) GIO_T9, + GIO_TUPLE9 ~func() E.Either[error, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, T8], + GIO_T9 ~func() E.Either[error, T9], + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9 any]( + t1 GR_T1, + t2 GR_T2, + t3 GR_T3, + t4 GR_T4, + t5 GR_T5, + t6 GR_T6, + t7 GR_T7, + t8 GR_T8, + t9 GR_T9, +) GR_TUPLE9 { + return A.SequenceT9( + Map[GR_T1, func(context.Context) func() E.Either[error, 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]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, 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]], GR_T3], + ApPar[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T4], + ApPar[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T5], + ApPar[func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T6], + ApPar[func(context.Context) func() E.Either[error, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T7], + ApPar[func(context.Context) func() E.Either[error, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T8], + ApPar[GR_TUPLE9, func(context.Context) func() E.Either[error, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T9], + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + ) +} + // SequenceTuple9 converts a [T.Tuple9] of readers into a reader of a [T.Tuple9]. func SequenceTuple9[ GR_TUPLE9 ~func(context.Context) GIO_TUPLE9, @@ -685,6 +2839,318 @@ func SequenceTuple9[ ) } +// SequenceSeqTuple9 converts a [T.Tuple9] of readers into a reader of a [T.Tuple9]. +func SequenceSeqTuple9[ + GR_TUPLE9 ~func(context.Context) GIO_TUPLE9, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GR_T9 ~func(context.Context) GIO_T9, + GIO_TUPLE9 ~func() E.Either[error, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, T8], + GIO_T9 ~func() E.Either[error, T9], + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9 any](t T.Tuple9[GR_T1, GR_T2, GR_T3, GR_T4, GR_T5, GR_T6, GR_T7, GR_T8, GR_T9]) GR_TUPLE9 { + return A.SequenceTuple9( + Map[GR_T1, func(context.Context) func() E.Either[error, 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]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, 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]], GR_T3], + ApSeq[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T4], + ApSeq[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T5], + ApSeq[func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T6], + ApSeq[func(context.Context) func() E.Either[error, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T7], + ApSeq[func(context.Context) func() E.Either[error, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T8], + ApSeq[GR_TUPLE9, func(context.Context) func() E.Either[error, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T9], + t, + ) +} + +// SequenceParTuple9 converts a [T.Tuple9] of readers into a reader of a [T.Tuple9]. +func SequenceParTuple9[ + GR_TUPLE9 ~func(context.Context) GIO_TUPLE9, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GR_T9 ~func(context.Context) GIO_T9, + GIO_TUPLE9 ~func() E.Either[error, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, T8], + GIO_T9 ~func() E.Either[error, T9], + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9 any](t T.Tuple9[GR_T1, GR_T2, GR_T3, GR_T4, GR_T5, GR_T6, GR_T7, GR_T8, GR_T9]) GR_TUPLE9 { + return A.SequenceTuple9( + Map[GR_T1, func(context.Context) func() E.Either[error, 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]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, 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]], GR_T3], + ApPar[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T4], + ApPar[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T5], + ApPar[func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T6], + ApPar[func(context.Context) func() E.Either[error, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T7], + ApPar[func(context.Context) func() E.Either[error, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T8], + ApPar[GR_TUPLE9, func(context.Context) func() E.Either[error, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T9], + t, + ) +} + +// TraverseTuple9 converts a [T.Tuple9] of readers into a reader of a [T.Tuple9]. +func TraverseTuple9[ + GR_TUPLE9 ~func(context.Context) GIO_TUPLE9, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + F5 ~func(A5) GR_T5, + F6 ~func(A6) GR_T6, + F7 ~func(A7) GR_T7, + F8 ~func(A8) GR_T8, + F9 ~func(A9) GR_T9, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GR_T9 ~func(context.Context) GIO_T9, + GIO_TUPLE9 ~func() E.Either[error, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, T8], + GIO_T9 ~func() E.Either[error, 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]) GR_TUPLE9 { + return func(t T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) GR_TUPLE9 { + return A.TraverseTuple9( + Map[GR_T1, func(context.Context) func() E.Either[error, 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]], GIO_T1], + Ap[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T2], + Ap[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, 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]], GR_T3], + Ap[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T4], + Ap[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T5], + Ap[func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T6], + Ap[func(context.Context) func() E.Either[error, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T7], + Ap[func(context.Context) func() E.Either[error, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T8], + Ap[GR_TUPLE9, func(context.Context) func() E.Either[error, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T9], + f1, + f2, + f3, + f4, + f5, + f6, + f7, + f8, + f9, + t, + ) + } +} + +// TraverseSeqTuple9 converts a [T.Tuple9] of readers into a reader of a [T.Tuple9]. +func TraverseSeqTuple9[ + GR_TUPLE9 ~func(context.Context) GIO_TUPLE9, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + F5 ~func(A5) GR_T5, + F6 ~func(A6) GR_T6, + F7 ~func(A7) GR_T7, + F8 ~func(A8) GR_T8, + F9 ~func(A9) GR_T9, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GR_T9 ~func(context.Context) GIO_T9, + GIO_TUPLE9 ~func() E.Either[error, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, T8], + GIO_T9 ~func() E.Either[error, 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]) GR_TUPLE9 { + return func(t T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) GR_TUPLE9 { + return A.TraverseTuple9( + Map[GR_T1, func(context.Context) func() E.Either[error, 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]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, 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]], GR_T3], + ApSeq[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T4], + ApSeq[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T5], + ApSeq[func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T6], + ApSeq[func(context.Context) func() E.Either[error, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T7], + ApSeq[func(context.Context) func() E.Either[error, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T8], + ApSeq[GR_TUPLE9, func(context.Context) func() E.Either[error, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T9], + f1, + f2, + f3, + f4, + f5, + f6, + f7, + f8, + f9, + t, + ) + } +} + +// TraverseParTuple9 converts a [T.Tuple9] of readers into a reader of a [T.Tuple9]. +func TraverseParTuple9[ + GR_TUPLE9 ~func(context.Context) GIO_TUPLE9, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + F5 ~func(A5) GR_T5, + F6 ~func(A6) GR_T6, + F7 ~func(A7) GR_T7, + F8 ~func(A8) GR_T8, + F9 ~func(A9) GR_T9, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GR_T9 ~func(context.Context) GIO_T9, + GIO_TUPLE9 ~func() E.Either[error, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, T8], + GIO_T9 ~func() E.Either[error, 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]) GR_TUPLE9 { + return func(t T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) GR_TUPLE9 { + return A.TraverseTuple9( + Map[GR_T1, func(context.Context) func() E.Either[error, 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]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, 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]], GR_T3], + ApPar[func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T4], + ApPar[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T5], + ApPar[func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T6], + ApPar[func(context.Context) func() E.Either[error, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T7], + ApPar[func(context.Context) func() E.Either[error, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func(context.Context) func() E.Either[error, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T8], + ApPar[GR_TUPLE9, func(context.Context) func() E.Either[error, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], GR_T9], + f1, + f2, + f3, + f4, + f5, + f6, + f7, + f8, + f9, + t, + ) + } +} + // Eitherize10 converts a function with 10 parameters returning a tuple into a function with 10 parameters returning a [GRA] // The inverse function is [Uneitherize10] func Eitherize10[GRA ~func(context.Context) GIOA, F ~func(context.Context, 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, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) GRA { @@ -760,6 +3226,144 @@ func SequenceT10[ ) } +// SequenceSeqT10 converts 10 readers into a reader of a [T.Tuple10]. +func SequenceSeqT10[ + GR_TUPLE10 ~func(context.Context) GIO_TUPLE10, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GR_T9 ~func(context.Context) GIO_T9, + GR_T10 ~func(context.Context) GIO_T10, + GIO_TUPLE10 ~func() E.Either[error, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, T8], + GIO_T9 ~func() E.Either[error, T9], + GIO_T10 ~func() E.Either[error, T10], + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10 any]( + t1 GR_T1, + t2 GR_T2, + t3 GR_T3, + t4 GR_T4, + t5 GR_T5, + t6 GR_T6, + t7 GR_T7, + t8 GR_T8, + t9 GR_T9, + t10 GR_T10, +) GR_TUPLE10 { + return A.SequenceT10( + Map[GR_T1, func(context.Context) func() E.Either[error, 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]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T3], + ApSeq[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T4], + ApSeq[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T5], + ApSeq[func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T6], + ApSeq[func(context.Context) func() E.Either[error, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T7], + ApSeq[func(context.Context) func() E.Either[error, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T8], + ApSeq[func(context.Context) func() E.Either[error, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T9], + ApSeq[GR_TUPLE10, func(context.Context) func() E.Either[error, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T10], + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + ) +} + +// SequenceParT10 converts 10 readers into a reader of a [T.Tuple10]. +func SequenceParT10[ + GR_TUPLE10 ~func(context.Context) GIO_TUPLE10, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GR_T9 ~func(context.Context) GIO_T9, + GR_T10 ~func(context.Context) GIO_T10, + GIO_TUPLE10 ~func() E.Either[error, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, T8], + GIO_T9 ~func() E.Either[error, T9], + GIO_T10 ~func() E.Either[error, T10], + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10 any]( + t1 GR_T1, + t2 GR_T2, + t3 GR_T3, + t4 GR_T4, + t5 GR_T5, + t6 GR_T6, + t7 GR_T7, + t8 GR_T8, + t9 GR_T9, + t10 GR_T10, +) GR_TUPLE10 { + return A.SequenceT10( + Map[GR_T1, func(context.Context) func() E.Either[error, 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]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T3], + ApPar[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T4], + ApPar[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T5], + ApPar[func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T6], + ApPar[func(context.Context) func() E.Either[error, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T7], + ApPar[func(context.Context) func() E.Either[error, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T8], + ApPar[func(context.Context) func() E.Either[error, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T9], + ApPar[GR_TUPLE10, func(context.Context) func() E.Either[error, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T10], + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + ) +} + // SequenceTuple10 converts a [T.Tuple10] of readers into a reader of a [T.Tuple10]. func SequenceTuple10[ GR_TUPLE10 ~func(context.Context) GIO_TUPLE10, @@ -808,3 +3412,344 @@ func SequenceTuple10[ t, ) } + +// SequenceSeqTuple10 converts a [T.Tuple10] of readers into a reader of a [T.Tuple10]. +func SequenceSeqTuple10[ + GR_TUPLE10 ~func(context.Context) GIO_TUPLE10, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GR_T9 ~func(context.Context) GIO_T9, + GR_T10 ~func(context.Context) GIO_T10, + GIO_TUPLE10 ~func() E.Either[error, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, T8], + GIO_T9 ~func() E.Either[error, T9], + GIO_T10 ~func() E.Either[error, T10], + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10 any](t T.Tuple10[GR_T1, GR_T2, GR_T3, GR_T4, GR_T5, GR_T6, GR_T7, GR_T8, GR_T9, GR_T10]) GR_TUPLE10 { + return A.SequenceTuple10( + Map[GR_T1, func(context.Context) func() E.Either[error, 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]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T3], + ApSeq[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T4], + ApSeq[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T5], + ApSeq[func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T6], + ApSeq[func(context.Context) func() E.Either[error, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T7], + ApSeq[func(context.Context) func() E.Either[error, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T8], + ApSeq[func(context.Context) func() E.Either[error, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T9], + ApSeq[GR_TUPLE10, func(context.Context) func() E.Either[error, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T10], + t, + ) +} + +// SequenceParTuple10 converts a [T.Tuple10] of readers into a reader of a [T.Tuple10]. +func SequenceParTuple10[ + GR_TUPLE10 ~func(context.Context) GIO_TUPLE10, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GR_T9 ~func(context.Context) GIO_T9, + GR_T10 ~func(context.Context) GIO_T10, + GIO_TUPLE10 ~func() E.Either[error, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, T8], + GIO_T9 ~func() E.Either[error, T9], + GIO_T10 ~func() E.Either[error, T10], + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10 any](t T.Tuple10[GR_T1, GR_T2, GR_T3, GR_T4, GR_T5, GR_T6, GR_T7, GR_T8, GR_T9, GR_T10]) GR_TUPLE10 { + return A.SequenceTuple10( + Map[GR_T1, func(context.Context) func() E.Either[error, 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]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T3], + ApPar[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T4], + ApPar[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T5], + ApPar[func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T6], + ApPar[func(context.Context) func() E.Either[error, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T7], + ApPar[func(context.Context) func() E.Either[error, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T8], + ApPar[func(context.Context) func() E.Either[error, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T9], + ApPar[GR_TUPLE10, func(context.Context) func() E.Either[error, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T10], + t, + ) +} + +// TraverseTuple10 converts a [T.Tuple10] of readers into a reader of a [T.Tuple10]. +func TraverseTuple10[ + GR_TUPLE10 ~func(context.Context) GIO_TUPLE10, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + F5 ~func(A5) GR_T5, + F6 ~func(A6) GR_T6, + F7 ~func(A7) GR_T7, + F8 ~func(A8) GR_T8, + F9 ~func(A9) GR_T9, + F10 ~func(A10) GR_T10, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GR_T9 ~func(context.Context) GIO_T9, + GR_T10 ~func(context.Context) GIO_T10, + GIO_TUPLE10 ~func() E.Either[error, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, T8], + GIO_T9 ~func() E.Either[error, T9], + GIO_T10 ~func() E.Either[error, 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]) GR_TUPLE10 { + return func(t T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) GR_TUPLE10 { + return A.TraverseTuple10( + Map[GR_T1, func(context.Context) func() E.Either[error, 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]], GIO_T1], + Ap[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T2], + Ap[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T3], + Ap[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T4], + Ap[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T5], + Ap[func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T6], + Ap[func(context.Context) func() E.Either[error, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T7], + Ap[func(context.Context) func() E.Either[error, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T8], + Ap[func(context.Context) func() E.Either[error, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T9], + Ap[GR_TUPLE10, func(context.Context) func() E.Either[error, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T10], + f1, + f2, + f3, + f4, + f5, + f6, + f7, + f8, + f9, + f10, + t, + ) + } +} + +// TraverseSeqTuple10 converts a [T.Tuple10] of readers into a reader of a [T.Tuple10]. +func TraverseSeqTuple10[ + GR_TUPLE10 ~func(context.Context) GIO_TUPLE10, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + F5 ~func(A5) GR_T5, + F6 ~func(A6) GR_T6, + F7 ~func(A7) GR_T7, + F8 ~func(A8) GR_T8, + F9 ~func(A9) GR_T9, + F10 ~func(A10) GR_T10, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GR_T9 ~func(context.Context) GIO_T9, + GR_T10 ~func(context.Context) GIO_T10, + GIO_TUPLE10 ~func() E.Either[error, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, T8], + GIO_T9 ~func() E.Either[error, T9], + GIO_T10 ~func() E.Either[error, 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]) GR_TUPLE10 { + return func(t T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) GR_TUPLE10 { + return A.TraverseTuple10( + Map[GR_T1, func(context.Context) func() E.Either[error, 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]], GIO_T1], + ApSeq[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T2], + ApSeq[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T3], + ApSeq[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T4], + ApSeq[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T5], + ApSeq[func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T6], + ApSeq[func(context.Context) func() E.Either[error, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T7], + ApSeq[func(context.Context) func() E.Either[error, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T8], + ApSeq[func(context.Context) func() E.Either[error, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T9], + ApSeq[GR_TUPLE10, func(context.Context) func() E.Either[error, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T10], + f1, + f2, + f3, + f4, + f5, + f6, + f7, + f8, + f9, + f10, + t, + ) + } +} + +// TraverseParTuple10 converts a [T.Tuple10] of readers into a reader of a [T.Tuple10]. +func TraverseParTuple10[ + GR_TUPLE10 ~func(context.Context) GIO_TUPLE10, + F1 ~func(A1) GR_T1, + F2 ~func(A2) GR_T2, + F3 ~func(A3) GR_T3, + F4 ~func(A4) GR_T4, + F5 ~func(A5) GR_T5, + F6 ~func(A6) GR_T6, + F7 ~func(A7) GR_T7, + F8 ~func(A8) GR_T8, + F9 ~func(A9) GR_T9, + F10 ~func(A10) GR_T10, + GR_T1 ~func(context.Context) GIO_T1, + GR_T2 ~func(context.Context) GIO_T2, + GR_T3 ~func(context.Context) GIO_T3, + GR_T4 ~func(context.Context) GIO_T4, + GR_T5 ~func(context.Context) GIO_T5, + GR_T6 ~func(context.Context) GIO_T6, + GR_T7 ~func(context.Context) GIO_T7, + GR_T8 ~func(context.Context) GIO_T8, + GR_T9 ~func(context.Context) GIO_T9, + GR_T10 ~func(context.Context) GIO_T10, + GIO_TUPLE10 ~func() E.Either[error, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], + GIO_T1 ~func() E.Either[error, T1], + GIO_T2 ~func() E.Either[error, T2], + GIO_T3 ~func() E.Either[error, T3], + GIO_T4 ~func() E.Either[error, T4], + GIO_T5 ~func() E.Either[error, T5], + GIO_T6 ~func() E.Either[error, T6], + GIO_T7 ~func() E.Either[error, T7], + GIO_T8 ~func() E.Either[error, T8], + GIO_T9 ~func() E.Either[error, T9], + GIO_T10 ~func() E.Either[error, 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]) GR_TUPLE10 { + return func(t T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) GR_TUPLE10 { + return A.TraverseTuple10( + Map[GR_T1, func(context.Context) func() E.Either[error, 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]], GIO_T1], + ApPar[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T2], + ApPar[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T3], + ApPar[func(context.Context) func() E.Either[error, 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(context.Context) func() E.Either[error, 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]], GR_T4], + ApPar[func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T5], + ApPar[func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T6], + ApPar[func(context.Context) func() E.Either[error, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T7], + ApPar[func(context.Context) func() E.Either[error, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T8], + ApPar[func(context.Context) func() E.Either[error, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func(context.Context) func() E.Either[error, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T9], + ApPar[GR_TUPLE10, func(context.Context) func() E.Either[error, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], GR_T10], + f1, + f2, + f3, + f4, + f5, + f6, + f7, + f8, + f9, + f10, + t, + ) + } +} diff --git a/context/readerioeither/generic/reader.go b/context/readerioeither/generic/reader.go index baa0e56..7568b24 100644 --- a/context/readerioeither/generic/reader.go +++ b/context/readerioeither/generic/reader.go @@ -13,6 +13,11 @@ import ( RIE "github.com/IBM/fp-go/readerioeither/generic" ) +const ( + // useParallel is the feature flag to control if we use the parallel or the sequential implementation of ap + useParallel = true +) + func FromEither[ GRA ~func(context.Context) GIOA, GIOA ~func() E.Either[error, A], @@ -149,9 +154,25 @@ func withCancelCauseFunc[ ) } +// MonadApSeq implements the `Ap` function for a reader with context. It creates a sub-context that will +// be canceled if any of the input operations errors out or +func MonadApSeq[ + GRB ~func(context.Context) GIOB, + GRA ~func(context.Context) GIOA, + GRAB ~func(context.Context) GIOAB, + + GIOA ~func() E.Either[error, A], + GIOB ~func() E.Either[error, B], + GIOAB ~func() E.Either[error, func(A) B], + + A, B any](fab GRAB, fa GRA) GRB { + + return RIE.MonadApSeq[GRA, GRB](fab, fa) +} + // MonadAp implements the `Ap` function for a reader with context. It creates a sub-context that will // be canceled if any of the input operations errors out or -func MonadAp[ +func MonadApPar[ GRB ~func(context.Context) GIOB, GRA ~func(context.Context) GIOA, GRAB ~func(context.Context) GIOAB, @@ -184,11 +205,30 @@ func MonadAp[ fabIOE := withCancelCauseFunc(cancelSub, cfab(ctxSub)) faIOE := withCancelCauseFunc(cancelSub, cfa(ctxSub)) - return IOE.MonadAp[GIOA, GIOB, GIOAB](fabIOE, faIOE)() + return IOE.MonadApPar[GIOA, GIOB, GIOAB](fabIOE, faIOE)() } } } +// MonadAp implements the `Ap` function for a reader with context. It creates a sub-context that will +// be canceled if any of the input operations errors out or +func MonadAp[ + GRB ~func(context.Context) GIOB, + GRA ~func(context.Context) GIOA, + GRAB ~func(context.Context) GIOAB, + + GIOA ~func() E.Either[error, A], + GIOB ~func() E.Either[error, B], + GIOAB ~func() E.Either[error, func(A) B], + + A, B any](fab GRAB, fa GRA) GRB { + // dispatch to the configured version + if useParallel { + return MonadApPar[GRB](fab, fa) + } + return MonadApSeq[GRB](fab, fa) +} + func Ap[ GRB ~func(context.Context) GIOB, GRAB ~func(context.Context) GIOAB, @@ -202,6 +242,32 @@ func Ap[ return F.Bind2nd(MonadAp[GRB, GRA, GRAB], fa) } +func ApSeq[ + GRB ~func(context.Context) GIOB, + GRAB ~func(context.Context) GIOAB, + GRA ~func(context.Context) GIOA, + + GIOB ~func() E.Either[error, B], + GIOAB ~func() E.Either[error, func(A) B], + GIOA ~func() E.Either[error, A], + + A, B any](fa GRA) func(GRAB) GRB { + return F.Bind2nd(MonadApSeq[GRB, GRA, GRAB], fa) +} + +func ApPar[ + GRB ~func(context.Context) GIOB, + GRAB ~func(context.Context) GIOAB, + GRA ~func(context.Context) GIOA, + + GIOB ~func() E.Either[error, B], + GIOAB ~func() E.Either[error, func(A) B], + GIOA ~func() E.Either[error, A], + + A, B any](fa GRA) func(GRAB) GRB { + return F.Bind2nd(MonadApPar[GRB, GRA, GRAB], fa) +} + func FromPredicate[ GRA ~func(context.Context) GIOA, GIOA ~func() E.Either[error, A], diff --git a/either/gen.go b/either/gen.go index 2e7bcb6..78176a8 100644 --- a/either/gen.go +++ b/either/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-07-20 16:14:28.8955293 +0200 CEST m=+0.018988301 +// 2023-07-21 10:22:45.2674057 +0200 CEST m=+0.015622601 package either diff --git a/errors/messages.go b/errors/messages.go index f6e0027..6923ff0 100644 --- a/errors/messages.go +++ b/errors/messages.go @@ -21,3 +21,8 @@ func OnError(msg string, args ...any) func(error) error { return fmt.Errorf(msg+", Caused By: %w", A.ArrayConcatAll(args, A.Of[any](err))...) } } + +// ToString converts an error to a string +func ToString(err error) string { + return err.Error() +} diff --git a/function/binds.go b/function/binds.go index 3300181..a64447c 100644 --- a/function/binds.go +++ b/function/binds.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-07-20 16:14:35.0470953 +0200 CEST m=+0.022083401 +// 2023-07-21 10:22:49.808764 +0200 CEST m=+0.064638701 package function // Combinations for a total of 1 arguments diff --git a/function/gen.go b/function/gen.go index 54a3c86..7bc5216 100644 --- a/function/gen.go +++ b/function/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-07-20 16:14:30.549415 +0200 CEST m=+0.067044301 +// 2023-07-21 10:22:47.675104 +0200 CEST m=+0.112962501 package function // Pipe0 takes an initial value t0 and successively applies 0 functions where the input of a function is the return value of the previous function diff --git a/identity/gen.go b/identity/gen.go index fb43de3..1b3ec87 100644 --- a/identity/gen.go +++ b/identity/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-07-20 16:14:38.2378673 +0200 CEST m=+0.054938201 +// 2023-07-21 10:22:53.6381914 +0200 CEST m=+0.019961301 package identity diff --git a/internal/apply/gen.go b/internal/apply/gen.go index 2de2644..3904784 100644 --- a/internal/apply/gen.go +++ b/internal/apply/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-07-20 16:14:40.4020781 +0200 CEST m=+0.037015301 +// 2023-07-21 10:22:55.7987979 +0200 CEST m=+0.076670601 package apply diff --git a/io/generic/ap.go b/io/generic/ap.go index 8e1a5ed..74570ec 100644 --- a/io/generic/ap.go +++ b/io/generic/ap.go @@ -9,16 +9,16 @@ const ( useParallel = true ) -// monadApSeq implements the applicative on a single thread by first executing mab and the ma -func monadApSeq[GA ~func() A, GB ~func() B, GAB ~func() func(A) B, A, B any](mab GAB, ma GA) GB { +// MonadApSeq implements the applicative on a single thread by first executing mab and the ma +func MonadApSeq[GA ~func() A, GB ~func() B, GAB ~func() func(A) B, A, B any](mab GAB, ma GA) GB { return MakeIO[GB](func() B { return mab()(ma()) }) } -// monadApPar implements the applicative on two threads, the main thread executes mab and the actuall +// MonadApPar implements the applicative on two threads, the main thread executes mab and the actuall // apply operation and the second thred computes ma. Communication between the threads happens via a channel -func monadApPar[GA ~func() A, GB ~func() B, GAB ~func() func(A) B, A, B any](mab GAB, ma GA) GB { +func MonadApPar[GA ~func() A, GB ~func() B, GAB ~func() func(A) B, A, B any](mab GAB, ma GA) GB { return MakeIO[GB](func() B { c := make(chan A) go func() { @@ -33,9 +33,9 @@ func monadApPar[GA ~func() A, GB ~func() B, GAB ~func() func(A) B, A, B any](mab // is parallel func MonadAp[GA ~func() A, GB ~func() B, GAB ~func() func(A) B, A, B any](mab GAB, ma GA) GB { if useParallel { - return monadApPar[GA, GB](mab, ma) + return MonadApPar[GA, GB](mab, ma) } - return monadApSeq[GA, GB](mab, ma) + return MonadApSeq[GA, GB](mab, ma) } // MonadApFirst combines two effectful actions, keeping only the result of the first. diff --git a/io/generic/io.go b/io/generic/io.go index 2be8c5c..b863efe 100644 --- a/io/generic/io.go +++ b/io/generic/io.go @@ -86,7 +86,15 @@ func ChainFirst[GA ~func() A, GB ~func() B, A, B any](f func(A) GB) func(GA) GA return C.ChainFirst(MonadChain[GA, GA, A, A], MonadMap[GB, GA, B, A], f) } -func Ap[GA ~func() A, GB ~func() B, GAB ~func() func(A) B, A, B any](ma GA) func(GAB) GB { +func ApSeq[GB ~func() B, GAB ~func() func(A) B, GA ~func() A, B, A any](ma GA) func(GAB) GB { + return F.Bind2nd(MonadApSeq[GA, GB, GAB, A, B], ma) +} + +func ApPar[GB ~func() B, GAB ~func() func(A) B, GA ~func() A, B, A any](ma GA) func(GAB) GB { + return F.Bind2nd(MonadApPar[GA, GB, GAB, A, B], ma) +} + +func Ap[GB ~func() B, GAB ~func() func(A) B, GA ~func() A, B, A any](ma GA) func(GAB) GB { return F.Bind2nd(MonadAp[GA, GB, GAB, A, B], ma) } diff --git a/io/generic/sequence.go b/io/generic/sequence.go index a151b9c..4fa2d6b 100644 --- a/io/generic/sequence.go +++ b/io/generic/sequence.go @@ -17,7 +17,7 @@ func SequenceT1[GA ~func() A, GTA ~func() T.Tuple1[A], A any](a GA) GTA { 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[GB, GTAB, func() func(B) T.Tuple2[A, B], B, T.Tuple2[A, B]], + Ap[GTAB, func() func(B) T.Tuple2[A, B], GB], a, b, ) @@ -26,8 +26,8 @@ func SequenceT2[GA ~func() A, GB ~func() B, GTAB ~func() T.Tuple2[A, B], A, B an 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[GB, func() func(C) T.Tuple3[A, B, C], func() func(B) func(C) T.Tuple3[A, B, C], B, func(C) T.Tuple3[A, B, C]], - Ap[GC, GTABC, func() func(C) T.Tuple3[A, B, C], 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, ) @@ -36,9 +36,9 @@ func SequenceT3[GA ~func() A, GB ~func() B, GC ~func() C, GTABC ~func() T.Tuple3 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[GB, func() func(C) func(D) T.Tuple4[A, B, C, D], func() 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() func(D) T.Tuple4[A, B, C, D], func() func(C) func(D) T.Tuple4[A, B, C, D], C, func(D) T.Tuple4[A, B, C, D]], - Ap[GD, GTABCD, func() func(D) T.Tuple4[A, B, C, D], 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, ) diff --git a/io/generic/traverse.go b/io/generic/traverse.go index 03d75b7..8f75bcf 100644 --- a/io/generic/traverse.go +++ b/io/generic/traverse.go @@ -10,7 +10,7 @@ func MonadTraverseArray[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B return RA.MonadTraverse( Of[GBS, BBS], Map[GBS, func() func(B) BBS, BBS, func(B) BBS], - Ap[GB, GBS, func() func(B) BBS, B, BBS], + Ap[GBS, func() func(B) BBS, GB], tas, f, @@ -21,7 +21,7 @@ func TraverseArray[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B any]( return RA.Traverse[AAS]( Of[GBS, BBS], Map[GBS, func() func(B) BBS, BBS, func(B) BBS], - Ap[GB, GBS, func() func(B) BBS, B, BBS], + Ap[GBS, func() func(B) BBS, GB], f, ) @@ -36,7 +36,7 @@ func MonadTraverseRecord[GB ~func() B, GBS ~func() MB, MA ~map[K]A, MB ~map[K]B, return RR.MonadTraverse[MA]( Of[GBS, MB], Map[GBS, func() func(B) MB, MB, func(B) MB], - Ap[GB, GBS, func() func(B) MB, B, MB], + Ap[GBS, func() func(B) MB, GB], ma, f, ) } @@ -46,7 +46,7 @@ func TraverseRecord[GB ~func() B, GBS ~func() MB, MA ~map[K]A, MB ~map[K]B, K co return RR.Traverse[MA]( Of[GBS, MB], Map[GBS, func() func(B) MB, MB, func(B) MB], - Ap[GB, GBS, func() func(B) MB, B, MB], + Ap[GBS, func() func(B) MB, GB], f, ) } diff --git a/io/io.go b/io/io.go index 36c8c27..bb7dd1e 100644 --- a/io/io.go +++ b/io/io.go @@ -62,7 +62,7 @@ func MonadAp[B, A any](mab IO[func(A) B], ma IO[A]) IO[B] { } func Ap[B, A any](ma IO[A]) func(IO[func(A) B]) IO[B] { - return G.Ap[IO[A], IO[B], IO[func(A) B]](ma) + return G.Ap[IO[B], IO[func(A) B], IO[A]](ma) } func Flatten[A any](mma IO[IO[A]]) IO[A] { diff --git a/ioeither/generic/ioeither.go b/ioeither/generic/ioeither.go index 7c7b773..9788e10 100644 --- a/ioeither/generic/ioeither.go +++ b/ioeither/generic/ioeither.go @@ -140,6 +140,28 @@ func Ap[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GAB ~func() ET.E return F.Bind2nd(MonadAp[GA, GB, GAB, E, A, B], 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 { + 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 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 { + 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 Flatten[GA ~func() ET.Either[E, A], GAA ~func() ET.Either[E, GA], E, A any](mma GAA) GA { return MonadChain(mma, F.Identity[GA]) } diff --git a/option/gen.go b/option/gen.go index dc202a3..fc6959e 100644 --- a/option/gen.go +++ b/option/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-07-20 16:14:43.2805352 +0200 CEST m=+0.019400701 +// 2023-07-21 10:22:58.9182026 +0200 CEST m=+0.113159801 package option diff --git a/reader/gen.go b/reader/gen.go index 3f44982..c323ccc 100644 --- a/reader/gen.go +++ b/reader/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-07-20 16:14:46.7504208 +0200 CEST m=+0.095418801 +// 2023-07-21 10:23:01.7578306 +0200 CEST m=+0.326481301 package reader diff --git a/reader/generic/gen.go b/reader/generic/gen.go index f17fbda..99623be 100644 --- a/reader/generic/gen.go +++ b/reader/generic/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-07-20 16:14:46.7514193 +0200 CEST m=+0.096417301 +// 2023-07-21 10:23:01.8951242 +0200 CEST m=+0.463774901 package generic diff --git a/readerio/generic/reader.go b/readerio/generic/reader.go index 3823f7b..437d95d 100644 --- a/readerio/generic/reader.go +++ b/readerio/generic/reader.go @@ -44,6 +44,22 @@ func Ap[GEA ~func(E) GIOA, GEB ~func(E) GIOB, GEFAB ~func(E) GIOFAB, GIOA ~func( return F.Bind2nd(MonadAp[GEA, GEB, GEFAB, GIOA, GIOB, GIOFAB, E, A, B], fa) } +func MonadApSeq[GEA ~func(E) GIOA, GEB ~func(E) GIOB, GEFAB ~func(E) GIOFAB, GIOA ~func() A, GIOB ~func() B, GIOFAB ~func() func(A) B, E, A, B any](fab GEFAB, fa GEA) GEB { + return readert.MonadAp[GEA, GEB, GEFAB, E, A](IO.MonadApSeq[GIOA, GIOB, GIOFAB, A, B], fab, fa) +} + +func ApSeq[GEA ~func(E) GIOA, GEB ~func(E) GIOB, GEFAB ~func(E) GIOFAB, GIOA ~func() A, GIOB ~func() B, GIOFAB ~func() func(A) B, E, A, B any](fa GEA) func(GEFAB) GEB { + return F.Bind2nd(MonadApSeq[GEA, GEB, GEFAB, GIOA, GIOB, GIOFAB, E, A, B], fa) +} + +func MonadApPar[GEA ~func(E) GIOA, GEB ~func(E) GIOB, GEFAB ~func(E) GIOFAB, GIOA ~func() A, GIOB ~func() B, GIOFAB ~func() func(A) B, E, A, B any](fab GEFAB, fa GEA) GEB { + return readert.MonadAp[GEA, GEB, GEFAB, E, A](IO.MonadApPar[GIOA, GIOB, GIOFAB, A, B], fab, fa) +} + +func ApPar[GEA ~func(E) GIOA, GEB ~func(E) GIOB, GEFAB ~func(E) GIOFAB, GIOA ~func() A, GIOB ~func() B, GIOFAB ~func() func(A) B, E, A, B any](fa GEA) func(GEFAB) GEB { + return F.Bind2nd(MonadApPar[GEA, GEB, GEFAB, GIOA, GIOB, GIOFAB, E, A, B], fa) +} + func Ask[GEE ~func(E) GIOE, GIOE ~func() E, E any]() GEE { return FR.Ask(FromReader[func(E) E, GEE, GIOE, E, E])() } diff --git a/readerioeither/gen.go b/readerioeither/gen.go index 890f392..0bf8504 100644 --- a/readerioeither/gen.go +++ b/readerioeither/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-07-20 16:14:48.8807201 +0200 CEST m=+0.044278401 +// 2023-07-21 10:23:04.372044 +0200 CEST m=+0.068576501 package readerioeither diff --git a/readerioeither/generic/gen.go b/readerioeither/generic/gen.go index afa0743..6242cda 100644 --- a/readerioeither/generic/gen.go +++ b/readerioeither/generic/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-07-20 16:14:48.8823313 +0200 CEST m=+0.045889601 +// 2023-07-21 10:23:04.372044 +0200 CEST m=+0.068576501 package generic diff --git a/readerioeither/generic/reader.go b/readerioeither/generic/reader.go index 53284e4..16c4719 100644 --- a/readerioeither/generic/reader.go +++ b/readerioeither/generic/reader.go @@ -176,6 +176,62 @@ func Ap[ return F.Bind2nd(MonadAp[GEA, GEB, GEFAB, GIOA, GIOB, GIOFAB, R, E, A, B], fa) } +func MonadApSeq[ + GEA ~func(R) GIOA, + GEB ~func(R) GIOB, + GEFAB ~func(R) GIOFAB, + GIOA ~func() ET.Either[E, A], + GIOB ~func() ET.Either[E, B], + GIOFAB ~func() ET.Either[E, func(A) B], + R, E, A, B any](fab GEFAB, fa GEA) GEB { + + return eithert.MonadAp( + G.MonadApSeq[GEA, GEB, func(R) func() func(ET.Either[E, A]) ET.Either[E, B], GIOA, GIOB, func() func(ET.Either[E, A]) ET.Either[E, B], R, ET.Either[E, A], ET.Either[E, B]], + G.MonadMap[GEFAB, func(R) func() func(ET.Either[E, A]) ET.Either[E, B], GIOFAB, func() func(ET.Either[E, A]) ET.Either[E, B], R, ET.Either[E, func(A) B], func(ET.Either[E, A]) ET.Either[E, B]], + fab, + fa, + ) +} + +func ApSeq[ + GEA ~func(R) GIOA, + GEB ~func(R) GIOB, + GEFAB ~func(R) GIOFAB, + GIOA ~func() ET.Either[E, A], + GIOB ~func() ET.Either[E, B], + GIOFAB ~func() ET.Either[E, func(A) B], + R, E, A, B any](fa GEA) func(fab GEFAB) GEB { + return F.Bind2nd(MonadApSeq[GEA, GEB, GEFAB, GIOA, GIOB, GIOFAB, R, E, A, B], fa) +} + +func MonadApPar[ + GEA ~func(R) GIOA, + GEB ~func(R) GIOB, + GEFAB ~func(R) GIOFAB, + GIOA ~func() ET.Either[E, A], + GIOB ~func() ET.Either[E, B], + GIOFAB ~func() ET.Either[E, func(A) B], + R, E, A, B any](fab GEFAB, fa GEA) GEB { + + return eithert.MonadAp( + G.MonadApPar[GEA, GEB, func(R) func() func(ET.Either[E, A]) ET.Either[E, B], GIOA, GIOB, func() func(ET.Either[E, A]) ET.Either[E, B], R, ET.Either[E, A], ET.Either[E, B]], + G.MonadMap[GEFAB, func(R) func() func(ET.Either[E, A]) ET.Either[E, B], GIOFAB, func() func(ET.Either[E, A]) ET.Either[E, B], R, ET.Either[E, func(A) B], func(ET.Either[E, A]) ET.Either[E, B]], + fab, + fa, + ) +} + +func ApPar[ + GEA ~func(R) GIOA, + GEB ~func(R) GIOB, + GEFAB ~func(R) GIOFAB, + GIOA ~func() ET.Either[E, A], + GIOB ~func() ET.Either[E, B], + GIOFAB ~func() ET.Either[E, func(A) B], + R, E, A, B any](fa GEA) func(fab GEFAB) GEB { + return F.Bind2nd(MonadApPar[GEA, GEB, GEFAB, GIOA, GIOB, GIOFAB, R, E, A, B], fa) +} + func Right[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](a A) GEA { return eithert.Right(G.Of[GEA, GIOA, R, ET.Either[E, A]], a) } diff --git a/samples/http/http_test.go b/samples/http/http_test.go index 52a94ab..e33fd89 100644 --- a/samples/http/http_test.go +++ b/samples/http/http_test.go @@ -13,6 +13,7 @@ import ( E "github.com/IBM/fp-go/either" F "github.com/IBM/fp-go/function" IO "github.com/IBM/fp-go/io" + T "github.com/IBM/fp-go/tuple" "github.com/stretchr/testify/assert" ) @@ -23,13 +24,20 @@ type PostItem struct { Body string `json:"body"` } +type CatFact struct { + Fact string `json:"fact"` +} + func idxToUrl(idx int) string { return fmt.Sprintf("https://jsonplaceholder.typicode.com/posts/%d", idx+1) } +// TestMultipleHttpRequests shows how to execute multiple HTTP requests in parallel assuming +// that the response structure of all requests is identical, which is why we can use [R.TraverseArray] func TestMultipleHttpRequests(t *testing.T) { // prepare the http client client := H.MakeClient(HTTP.DefaultClient) + // readSinglePost sends a GET request and parses the response as [PostItem] readSinglePost := H.ReadJson[PostItem](client) // total number of http requests @@ -50,3 +58,28 @@ func TestMultipleHttpRequests(t *testing.T) { assert.Equal(t, E.Of[error](count), result()) } + +// TestHeterogeneousHttpRequests shows how to execute multiple HTTP requests in parallel when +// the response structure of these requests is different. We use [R.TraverseTuple2] to account for the different types +func TestHeterogeneousHttpRequests(t *testing.T) { + // prepare the http client + client := H.MakeClient(HTTP.DefaultClient) + // readSinglePost sends a GET request and parses the response as [PostItem] + readSinglePost := H.ReadJson[PostItem](client) + // readSingleCatFact sends a GET request and parses the response as [CatFact] + readSingleCatFact := H.ReadJson[CatFact](client) + + data := F.Pipe3( + T.MakeTuple2("https://jsonplaceholder.typicode.com/posts/1", "https://catfact.ninja/fact"), + T.Map2(H.MakeGetRequest, H.MakeGetRequest), + R.TraverseTuple2( + readSinglePost, + readSingleCatFact, + ), + R.ChainFirstIOK(IO.Logf[T.Tuple2[PostItem, CatFact]]("Log Result: %v")), + ) + + result := data(context.Background()) + + fmt.Println(result()) +} diff --git a/tuple/gen.go b/tuple/gen.go index af0e6cc..c67374b 100644 --- a/tuple/gen.go +++ b/tuple/gen.go @@ -1,6 +1,6 @@ // Code generated by go generate; DO NOT EDIT. // This file was generated by robots at -// 2023-07-20 16:14:50.7418331 +0200 CEST m=+0.011380701 +// 2023-07-21 10:23:06.8090834 +0200 CEST m=+0.149601501 package tuple