Merge pull request #19 from IBM/cleue-implement-first-and-last

fix: add first and last

README.md

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

array/array.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package array
 
 import (
@@ -15,22 +30,13 @@ func From[A any](data ...A) []A {
 }
 
 // MakeBy returns a `Array` of length `n` with element `i` initialized with `f(i)`.
-func MakeBy[A any](n int, f func(int) A) []A {
-	// sanity check
-	if n <= 0 {
-		return Empty[A]()
-	}
-	// run the generator function across the input
-	as := make([]A, n)
-	for i := n - 1; i >= 0; i-- {
-		as[i] = f(i)
-	}
-	return as
+func MakeBy[F ~func(int) A, A any](n int, f F) []A {
+	return G.MakeBy[[]A](n, f)
 }
 
 // Replicate creates a `Array` containing a value repeated the specified number of times.
 func Replicate[A any](n int, a A) []A {
-	return MakeBy(n, F.Constant1[int](a))
+	return G.Replicate[[]A](n, a)
 }
 
 func MonadMap[A, B any](as []A, f func(a A) B) []B {
@@ -138,7 +144,7 @@ func Append[A any](as []A, a A) []A {
 }
 
 func IsEmpty[A any](as []A) bool {
-	return array.IsEmpty(as)
+	return G.IsEmpty(as)
 }
 
 func IsNonEmpty[A any](as []A) bool {
@@ -159,30 +165,27 @@ func Of[A any](a A) []A {
 }
 
 func MonadChain[A, B any](fa []A, f func(a A) []B) []B {
-	return array.Reduce(fa, func(bs []B, a A) []B {
-		return append(bs, f(a)...)
-	}, Zero[B]())
+	return G.MonadChain[[]A, []B](fa, f)
 }
 
-func Chain[A, B any](f func(a A) []B) func([]A) []B {
-	return F.Bind2nd(MonadChain[A, B], f)
+func Chain[A, B any](f func(A) []B) func([]A) []B {
+	return G.Chain[[]A, []B](f)
 }
 
 func MonadAp[B, A any](fab []func(A) B, fa []A) []B {
-	return MonadChain(fab, F.Bind1st(MonadMap[A, B], fa))
+	return G.MonadAp[[]B](fab, fa)
 }
 
 func Ap[B, A any](fa []A) func([]func(A) B) []B {
-	return F.Bind2nd(MonadAp[B, A], fa)
+	return G.Ap[[]B, []func(A) B](fa)
 }
 
 func Match[A, B any](onEmpty func() B, onNonEmpty func([]A) B) func([]A) B {
-	return func(as []A) B {
-		if IsEmpty(as) {
-			return onEmpty()
-		}
-		return onNonEmpty(as)
-	}
+	return G.Match[[]A](onEmpty, onNonEmpty)
+}
+
+func MatchLeft[A, B any](onEmpty func() B, onNonEmpty func(A, []A) B) func([]A) B {
+	return G.MatchLeft[[]A](onEmpty, onNonEmpty)
 }
 
 func Tail[A any](as []A) O.Option[[]A] {
@@ -227,7 +230,7 @@ func Intersperse[A any](middle A) func([]A) []A {
 }
 
 func Intercalate[A any](m M.Monoid[A]) func(A) func([]A) A {
-	concatAll := ConcatAll[A](m)(m.Empty())
+	concatAll := ConcatAll[A](m)
 	return func(middle A) func([]A) A {
 		return Match(m.Empty, F.Flow2(Intersperse(middle), concatAll))
 	}
@@ -277,3 +280,11 @@ func IsNonNil[A any](as []A) bool {
 func ConstNil[A any]() []A {
 	return array.ConstNil[[]A]()
 }
+
+func SliceRight[A any](start int) func([]A) []A {
+	return G.SliceRight[[]A](start)
+}
+
+func Copy[A any](b []A) []A {
+	return G.Copy(b)
+}

array/array_test.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package array
 
 import (

array/eq.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package array
 
 import (

array/generic/array.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package generic
 
 import (
@@ -17,6 +32,24 @@ func From[GA ~[]A, A any](data ...A) GA {
 	return data
 }
 
+// MakeBy returns a `Array` of length `n` with element `i` initialized with `f(i)`.
+func MakeBy[AS ~[]A, F ~func(int) A, A any](n int, f F) AS {
+	// sanity check
+	if n <= 0 {
+		return Empty[AS]()
+	}
+	// run the generator function across the input
+	as := make(AS, n)
+	for i := n - 1; i >= 0; i-- {
+		as[i] = f(i)
+	}
+	return as
+}
+
+func Replicate[AS ~[]A, A any](n int, a A) AS {
+	return MakeBy[AS](n, F.Constant1[int](a))
+}
+
 func Lookup[GA ~[]A, A any](idx int) func(GA) O.Option[A] {
 	none := O.None[A]()
 	if idx < 0 {
@@ -107,3 +140,61 @@ func MonadPartition[GA ~[]A, A any](as GA, pred func(A) bool) tuple.Tuple2[GA, G
 func Partition[GA ~[]A, A any](pred func(A) bool) func(GA) tuple.Tuple2[GA, GA] {
 	return F.Bind2nd(MonadPartition[GA, A], pred)
 }
+
+func MonadChain[AS ~[]A, BS ~[]B, A, B any](fa AS, f func(a A) BS) BS {
+	return array.Reduce(fa, func(bs BS, a A) BS {
+		return append(bs, f(a)...)
+	}, Empty[BS]())
+}
+
+func Chain[AS ~[]A, BS ~[]B, A, B any](f func(A) BS) func(AS) BS {
+	return F.Bind2nd(MonadChain[AS, BS, A, B], f)
+}
+
+func MonadAp[BS ~[]B, ABS ~[]func(A) B, AS ~[]A, B, A any](fab ABS, fa AS) BS {
+	return MonadChain(fab, F.Bind1st(MonadMap[AS, BS, A, B], fa))
+}
+
+func Ap[BS ~[]B, ABS ~[]func(A) B, AS ~[]A, B, A any](fa AS) func(ABS) BS {
+	return F.Bind2nd(MonadAp[BS, ABS, AS], fa)
+}
+
+func IsEmpty[AS ~[]A, A any](as AS) bool {
+	return array.IsEmpty(as)
+}
+
+func Match[AS ~[]A, A, B any](onEmpty func() B, onNonEmpty func(AS) B) func(AS) B {
+	return func(as AS) B {
+		if IsEmpty(as) {
+			return onEmpty()
+		}
+		return onNonEmpty(as)
+	}
+}
+
+func MatchLeft[AS ~[]A, A, B any](onEmpty func() B, onNonEmpty func(A, AS) B) func(AS) B {
+	return func(as AS) B {
+		if IsEmpty(as) {
+			return onEmpty()
+		}
+		return onNonEmpty(as[0], as[1:])
+	}
+}
+
+func Slice[AS ~[]A, A any](start int, end int) func(AS) AS {
+	return func(a AS) AS {
+		return a[start:end]
+	}
+}
+
+func SliceRight[AS ~[]A, A any](start int) func(AS) AS {
+	return func(a AS) AS {
+		return a[start:]
+	}
+}
+
+func Copy[AS ~[]A, A any](b AS) AS {
+	buf := make(AS, len(b))
+	copy(buf, b)
+	return buf
+}

array/generic/sort.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package generic
 
 import (

array/generic/zip.go

@@ -0,0 +1,52 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	F "github.com/IBM/fp-go/function"
+	N "github.com/IBM/fp-go/number"
+	T "github.com/IBM/fp-go/tuple"
+)
+
+// ZipWith applies a function to pairs of elements at the same index in two arrays, collecting the results in a new array. If one
+// input array is short, excess elements of the longer array are discarded.
+func ZipWith[AS ~[]A, BS ~[]B, CS ~[]C, FCT ~func(A, B) C, A, B, C any](fa AS, fb BS, f FCT) CS {
+	l := N.Min(len(fa), len(fb))
+	res := make(CS, l)
+	for i := l - 1; i >= 0; i-- {
+		res[i] = f(fa[i], fb[i])
+	}
+	return res
+}
+
+// Zip takes two arrays and returns an array of corresponding pairs. If one input array is short, excess elements of the
+// longer array are discarded
+func Zip[AS ~[]A, BS ~[]B, CS ~[]T.Tuple2[A, B], A, B any](fb BS) func(AS) CS {
+	return F.Bind23of3(ZipWith[AS, BS, CS, func(A, B) T.Tuple2[A, B]])(fb, T.MakeTuple2[A, B])
+}
+
+// Unzip is the function is reverse of [Zip]. Takes an array of pairs and return two corresponding arrays
+func Unzip[AS ~[]A, BS ~[]B, CS ~[]T.Tuple2[A, B], A, B any](cs CS) T.Tuple2[AS, BS] {
+	l := len(cs)
+	as := make(AS, l)
+	bs := make(BS, l)
+	for i := l - 1; i >= 0; i-- {
+		t := cs[i]
+		as[i] = t.F1
+		bs[i] = t.F2
+	}
+	return T.MakeTuple2(as, bs)
+}

array/magma.go

@@ -1,10 +1,24 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package array
 
 import (
-	F "github.com/IBM/fp-go/function"
-	M "github.com/IBM/fp-go/magma"
+	M "github.com/IBM/fp-go/monoid"
 )
 
-func ConcatAll[A any](m M.Magma[A]) func(A) func([]A) A {
-	return F.Bind1st(Reduce[A, A], m.Concat)
+func ConcatAll[A any](m M.Monoid[A]) func([]A) A {
+	return Reduce(m.Concat, m.Empty())
 }

array/magma_test.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package array
 
 import (
@@ -5,16 +20,16 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	M "github.com/IBM/fp-go/magma"
+	M "github.com/IBM/fp-go/monoid"
 )
 
-var subInt = M.MakeMagma(func(first int, second int) int {
+var subInt = M.MakeMonoid(func(first int, second int) int {
 	return first - second
-})
+}, 0)
 
 func TestConcatAll(t *testing.T) {
 
-	var subAll = ConcatAll(subInt)(0)
+	var subAll = ConcatAll(subInt)
 
 	assert.Equal(t, subAll([]int{1, 2, 3}), -6)
 

array/monoid.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package array
 
 import (

array/monoid_test.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package array
 
 import (

array/sequence.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package array
 
 import (

array/sequence_test.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package array
 
 import (

array/sort.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package array
 
 import (

array/sort_test.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package array
 
 import (

array/traverse.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package array
 
 import "github.com/IBM/fp-go/internal/array"

array/traverse_test.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package array
 
 import (

array/zip.go

@@ -0,0 +1,38 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package array
+
+import (
+	G "github.com/IBM/fp-go/array/generic"
+	T "github.com/IBM/fp-go/tuple"
+)
+
+// ZipWith applies a function to pairs of elements at the same index in two arrays, collecting the results in a new array. If one
+// input array is short, excess elements of the longer array are discarded.
+func ZipWith[FCT ~func(A, B) C, A, B, C any](fa []A, fb []B, f FCT) []C {
+	return G.ZipWith[[]A, []B, []C, FCT](fa, fb, f)
+}
+
+// Zip takes two arrays and returns an array of corresponding pairs. If one input array is short, excess elements of the
+// longer array are discarded
+func Zip[A, B any](fb []B) func([]A) []T.Tuple2[A, B] {
+	return G.Zip[[]A, []B, []T.Tuple2[A, B]](fb)
+}
+
+// Unzip is the function is reverse of [Zip]. Takes an array of pairs and return two corresponding arrays
+func Unzip[A, B any](cs []T.Tuple2[A, B]) T.Tuple2[[]A, []B] {
+	return G.Unzip[[]A, []B, []T.Tuple2[A, B]](cs)
+}

array/zip_test.go

@@ -0,0 +1,56 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package array
+
+import (
+	"fmt"
+	"testing"
+
+	T "github.com/IBM/fp-go/tuple"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestZipWith(t *testing.T) {
+	left := From(1, 2, 3)
+	right := From("a", "b", "c", "d")
+
+	res := ZipWith(left, right, func(l int, r string) string {
+		return fmt.Sprintf("%s%d", r, l)
+	})
+
+	assert.Equal(t, From("a1", "b2", "c3"), res)
+}
+
+func TestZip(t *testing.T) {
+	left := From(1, 2, 3)
+	right := From("a", "b", "c", "d")
+
+	res := Zip[string](left)(right)
+
+	assert.Equal(t, From(T.MakeTuple2("a", 1), T.MakeTuple2("b", 2), T.MakeTuple2("c", 3)), res)
+}
+
+func TestUnzip(t *testing.T) {
+	left := From(1, 2, 3)
+	right := From("a", "b", "c")
+
+	zipped := Zip[string](left)(right)
+
+	unzipped := Unzip(zipped)
+
+	assert.Equal(t, right, unzipped.F1)
+	assert.Equal(t, left, unzipped.F2)
+}

bounded/bounded.go

@@ -0,0 +1,64 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bounded
+
+import (
+	O "github.com/IBM/fp-go/ord"
+)
+
+type Bounded[T any] interface {
+	O.Ord[T]
+	Top() T
+	Bottom() T
+}
+
+type bounded[T any] struct {
+	c func(x, y T) int
+	e func(x, y T) bool
+	t T
+	b T
+}
+
+func (self bounded[T]) Equals(x, y T) bool {
+	return self.e(x, y)
+}
+
+func (self bounded[T]) Compare(x, y T) int {
+	return self.c(x, y)
+}
+
+func (self bounded[T]) Top() T {
+	return self.t
+}
+
+func (self bounded[T]) Bottom() T {
+	return self.b
+}
+
+// MakeBounded creates an instance of a bounded type
+func MakeBounded[T any](o O.Ord[T], t, b T) Bounded[T] {
+	return bounded[T]{c: o.Compare, e: o.Equals, t: t, b: b}
+}
+
+// Clamp returns a function that clamps against the bounds defined in the bounded type
+func Clamp[T any](b Bounded[T]) func(T) T {
+	return O.Clamp[T](b)(b.Bottom(), b.Top())
+}
+
+// Reverse reverses the ordering and swaps the bounds
+func Reverse[T any](b Bounded[T]) Bounded[T] {
+	return MakeBounded(O.Reverse[T](b), b.Bottom(), b.Top())
+}

bytes/bytes.go

@@ -1,5 +1,24 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package bytes
 
 func ToString(a []byte) string {
 	return string(a)
 }
+
+func Size(as []byte) int {
+	return len(as)
+}

bytes/monoid.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package bytes
 
 import (

bytes/monoid_test.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package bytes
 
 import (

cli/apply.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package cli
 
 import (

cli/bind.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package cli
 
 import (

cli/commands.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package cli
 
 import (
@@ -16,5 +31,8 @@ func Commands() []*C.Command {
 		ContextReaderIOEitherCommand(),
 		ReaderIOEitherCommand(),
 		ReaderCommand(),
+		IOEitherCommand(),
+		IOCommand(),
+		IOOptionCommand(),
 	}
 }

cli/common.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package cli
 
 import (

cli/contextreaderioeither.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package cli
 
 import (
@@ -5,10 +20,307 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	"strings"
 
 	C "github.com/urfave/cli/v2"
 )
 
+func generateNestedCallbacks(i, total int) string {
+	var buf strings.Builder
+	for j := i; j < total; j++ {
+		if j > i {
+			buf.WriteString(" ")
+		}
+		buf.WriteString(fmt.Sprintf("func(T%d)", j+1))
+	}
+	if i > 0 {
+		buf.WriteString(" ")
+	}
+	buf.WriteString(tupleType("T")(total))
+	return buf.String()
+}
+
+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// 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)
+		}
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(f, ", A%d, T%d", j+1, j+1)
+		}
+		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(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(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, "      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)
+		}
+
+		// raw parameters
+		fmt.Fprintf(fg, "      t,\n")
+
+		fmt.Fprintf(fg, "    )\n")
+		fmt.Fprintf(fg, "  }\n")
+		fmt.Fprintf(fg, "}\n")
+	}
+}
+
+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// 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, " 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, "]) 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(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](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, "    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")
+	}
+}
+
+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) {
 	// non generic version
 	fmt.Fprintf(f, "\n// Eitherize%d converts a function with %d parameters returning a tuple into a function with %d parameters returning a [ReaderIOEither[R]]\n// The inverse function is [Uneitherize%d]\n", i, i, i, i)
@@ -90,6 +402,7 @@ import (
 	"context"
 
 	G "github.com/IBM/fp-go/context/%s/generic"
+	T "github.com/IBM/fp-go/tuple"
 )
 `, pkg)
 
@@ -101,6 +414,8 @@ import (
 
 	E "github.com/IBM/fp-go/either"
 	RE "github.com/IBM/fp-go/readerioeither/generic"
+	A "github.com/IBM/fp-go/internal/apply"
+	T "github.com/IBM/fp-go/tuple"
 )
 `)
 
@@ -109,6 +424,18 @@ import (
 	for i := 1; i <= count; i++ {
 		// eitherize
 		generateContextReaderIOEitherEitherize(f, fg, i)
+		// sequenceT
+		generateContextReaderIOEitherSequenceT("")(f, fg, i)
+		generateContextReaderIOEitherSequenceT("Seq")(f, fg, i)
+		generateContextReaderIOEitherSequenceT("Par")(f, fg, i)
+		// sequenceTuple
+		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

cli/either.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package cli
 
 import (

cli/header.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package cli
 
 import (

cli/identity.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package cli
 
 import (

cli/io.go

@@ -0,0 +1,136 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cli
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"time"
+
+	A "github.com/IBM/fp-go/array"
+	C "github.com/urfave/cli/v2"
+)
+
+func nonGenericIO(param string) string {
+	return fmt.Sprintf("IO[%s]", param)
+}
+
+func genericIO(param string) string {
+	return fmt.Sprintf("func() %s", param)
+}
+
+var extrasIO = A.Empty[string]()
+
+func generateIOSequenceT(f, fg *os.File, i int) {
+	generateGenericSequenceT(nonGenericIO, genericIO, extrasIO)(f, fg, i)
+}
+
+func generateIOSequenceTuple(f, fg *os.File, i int) {
+	generateGenericSequenceTuple(nonGenericIO, genericIO, extrasIO)(f, fg, i)
+}
+
+func generateIOTraverseTuple(f, fg *os.File, i int) {
+	generateGenericTraverseTuple(nonGenericIO, genericIO, extrasIO)(f, fg, i)
+}
+
+func generateIOHelpers(filename string, count int) error {
+	dir, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+	absDir, err := filepath.Abs(dir)
+	if err != nil {
+		return err
+	}
+	pkg := filepath.Base(absDir)
+	f, err := os.Create(filepath.Clean(filename))
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	// construct subdirectory
+	genFilename := filepath.Join("generic", filename)
+	err = os.MkdirAll("generic", os.ModePerm)
+	if err != nil {
+		return err
+	}
+	fg, err := os.Create(filepath.Clean(genFilename))
+	if err != nil {
+		return err
+	}
+	defer fg.Close()
+
+	// log
+	log.Printf("Generating code in [%s] for package [%s] with [%d] repetitions ...", filename, pkg, count)
+
+	// some header
+	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
+	fmt.Fprintln(f, "// This file was generated by robots at")
+	fmt.Fprintf(f, "// %s\n", time.Now())
+
+	fmt.Fprintf(f, "package %s\n\n", pkg)
+
+	fmt.Fprintf(f, `
+import (
+	G "github.com/IBM/fp-go/%s/generic"	
+	T "github.com/IBM/fp-go/tuple"
+)
+`, pkg)
+
+	// some header
+	fmt.Fprintln(fg, "// Code generated by go generate; DO NOT EDIT.")
+	fmt.Fprintln(fg, "// This file was generated by robots at")
+	fmt.Fprintf(fg, "// %s\n", time.Now())
+
+	fmt.Fprintf(fg, "package generic\n\n")
+
+	fmt.Fprintf(fg, `
+import (
+	T "github.com/IBM/fp-go/tuple"
+	A "github.com/IBM/fp-go/internal/apply"
+)
+`)
+
+	for i := 1; i <= count; i++ {
+		// sequenceT
+		generateIOSequenceT(f, fg, i)
+		// sequenceTuple
+		generateIOSequenceTuple(f, fg, i)
+		// traverseTuple
+		generateIOTraverseTuple(f, fg, i)
+	}
+
+	return nil
+}
+
+func IOCommand() *C.Command {
+	return &C.Command{
+		Name:  "io",
+		Usage: "generate code for IO",
+		Flags: []C.Flag{
+			flagCount,
+			flagFilename,
+		},
+		Action: func(ctx *C.Context) error {
+			return generateIOHelpers(
+				ctx.String(keyFilename),
+				ctx.Int(keyCount),
+			)
+		},
+	}
+}

cli/ioeither.go

@@ -0,0 +1,282 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cli
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"time"
+
+	A "github.com/IBM/fp-go/array"
+	C "github.com/urfave/cli/v2"
+)
+
+// [GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GTAB ~func() ET.Either[E, T.Tuple2[A, B]], E, A, B any](a GA, b GB) GTAB {
+
+func nonGenericIOEither(param string) string {
+	return fmt.Sprintf("IOEither[E, %s]", param)
+}
+
+func genericIOEither(param string) string {
+	return fmt.Sprintf("func() ET.Either[E, %s]", param)
+}
+
+var extrasIOEither = A.From("E")
+
+func generateIOEitherSequenceT(f, fg *os.File, i int) {
+	generateGenericSequenceT(nonGenericIOEither, genericIOEither, extrasIOEither)(f, fg, i)
+}
+
+func generateIOEitherSequenceTuple(f, fg *os.File, i int) {
+	generateGenericSequenceTuple(nonGenericIOEither, genericIOEither, extrasIOEither)(f, fg, i)
+}
+
+func generateIOEitherTraverseTuple(f, fg *os.File, i int) {
+	generateGenericTraverseTuple(nonGenericIOEither, genericIOEither, extrasIOEither)(f, fg, i)
+}
+
+func generateIOEitherUneitherize(f, fg *os.File, i int) {
+	// non generic version
+	fmt.Fprintf(f, "\n// Uneitherize%d converts a function with %d parameters returning a tuple into a function with %d parameters returning a [IOEither[error, R]]\n", i, i+1, i)
+	fmt.Fprintf(f, "func Uneitherize%d[F ~func(", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j+1)
+	}
+	fmt.Fprintf(f, ") IOEither[error, R]")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j+1)
+	}
+	fmt.Fprintf(f, ", R any](f F) func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j+1)
+	}
+	fmt.Fprintf(f, ") (R, error) {\n")
+	fmt.Fprintf(f, "  return G.Uneitherize%d[IOEither[error, R]](f)\n", i)
+	fmt.Fprintln(f, "}")
+
+	// generic version
+	fmt.Fprintf(fg, "\n// Uneitherize%d converts a function with %d parameters returning a tuple into a function with %d parameters returning a [GIOA]\n", i, i, i)
+	fmt.Fprintf(fg, "func Uneitherize%d[GIOA ~func() ET.Either[error, R], GTA ~func(", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "T%d", j+1)
+	}
+	fmt.Fprintf(fg, ") GIOA")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", T%d", j+1)
+	}
+	fmt.Fprintf(fg, ", R any](f GTA) func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "T%d", j+1)
+	}
+	fmt.Fprintf(fg, ") (R, error) {\n")
+	fmt.Fprintf(fg, "  return func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "t%d T%d", j+1, j+1)
+	}
+	fmt.Fprintf(fg, ") (R, error) {\n")
+	fmt.Fprintf(fg, "    return ET.Unwrap(f(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "t%d", j+1)
+	}
+	fmt.Fprintf(fg, ")())\n")
+	fmt.Fprintf(fg, "  }\n")
+	fmt.Fprintf(fg, "}\n")
+}
+
+func generateIOEitherEitherize(f, fg *os.File, i int) {
+	// non generic version
+	fmt.Fprintf(f, "\n// Eitherize%d converts a function with %d parameters returning a tuple into a function with %d parameters returning a [IOEither[error, R]]\n", i, i+1, i)
+	fmt.Fprintf(f, "func Eitherize%d[F ~func(", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j+1)
+	}
+	fmt.Fprintf(f, ") (R, error)")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j+1)
+	}
+	fmt.Fprintf(f, ", R any](f F) func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j+1)
+	}
+	fmt.Fprintf(f, ") IOEither[error, R] {\n")
+	fmt.Fprintf(f, "  return G.Eitherize%d[IOEither[error, R]](f)\n", i)
+	fmt.Fprintln(f, "}")
+
+	// generic version
+	fmt.Fprintf(fg, "\n// Eitherize%d converts a function with %d parameters returning a tuple into a function with %d parameters returning a [GIOA]\n", i, i, i)
+	fmt.Fprintf(fg, "func Eitherize%d[GIOA ~func() ET.Either[error, R], F ~func(", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "T%d", j+1)
+	}
+	fmt.Fprintf(fg, ") (R, error)")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", T%d", j+1)
+	}
+	fmt.Fprintf(fg, ", R any](f F) func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "T%d", j+1)
+	}
+	fmt.Fprintf(fg, ") GIOA {\n")
+	fmt.Fprintf(fg, "  e := ET.Eitherize%d(f)\n", i)
+	fmt.Fprintf(fg, "  return func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "t%d T%d", j+1, j+1)
+	}
+	fmt.Fprintf(fg, ") GIOA {\n")
+	fmt.Fprintf(fg, "    return func() ET.Either[error, R] {\n")
+	fmt.Fprintf(fg, "      return e(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "t%d", j+1)
+	}
+	fmt.Fprintf(fg, ")\n")
+	fmt.Fprintf(fg, "    }}\n")
+	fmt.Fprintf(fg, "}\n")
+}
+
+func generateIOEitherHelpers(filename string, count int) error {
+	dir, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+	absDir, err := filepath.Abs(dir)
+	if err != nil {
+		return err
+	}
+	pkg := filepath.Base(absDir)
+	f, err := os.Create(filepath.Clean(filename))
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	// construct subdirectory
+	genFilename := filepath.Join("generic", filename)
+	err = os.MkdirAll("generic", os.ModePerm)
+	if err != nil {
+		return err
+	}
+	fg, err := os.Create(filepath.Clean(genFilename))
+	if err != nil {
+		return err
+	}
+	defer fg.Close()
+
+	// log
+	log.Printf("Generating code in [%s] for package [%s] with [%d] repetitions ...", filename, pkg, count)
+
+	// some header
+	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
+	fmt.Fprintln(f, "// This file was generated by robots at")
+	fmt.Fprintf(f, "// %s\n", time.Now())
+
+	fmt.Fprintf(f, "package %s\n\n", pkg)
+
+	fmt.Fprintf(f, `
+import (
+	G "github.com/IBM/fp-go/%s/generic"	
+	T "github.com/IBM/fp-go/tuple"
+)
+`, pkg)
+
+	// some header
+	fmt.Fprintln(fg, "// Code generated by go generate; DO NOT EDIT.")
+	fmt.Fprintln(fg, "// This file was generated by robots at")
+	fmt.Fprintf(fg, "// %s\n", time.Now())
+
+	fmt.Fprintf(fg, "package generic\n\n")
+
+	fmt.Fprintf(fg, `
+import (
+	ET "github.com/IBM/fp-go/either"
+	T "github.com/IBM/fp-go/tuple"
+	A "github.com/IBM/fp-go/internal/apply"
+)
+`)
+
+	// eitherize
+	generateIOEitherEitherize(f, fg, 0)
+	// uneitherize
+	generateIOEitherUneitherize(f, fg, 0)
+
+	for i := 1; i <= count; i++ {
+		// eitherize
+		generateIOEitherEitherize(f, fg, i)
+		// uneitherize
+		generateIOEitherUneitherize(f, fg, i)
+		// sequenceT
+		generateIOEitherSequenceT(f, fg, i)
+		// sequenceTuple
+		generateIOEitherSequenceTuple(f, fg, i)
+		// traverseTuple
+		generateIOEitherTraverseTuple(f, fg, i)
+	}
+
+	return nil
+}
+
+func IOEitherCommand() *C.Command {
+	return &C.Command{
+		Name:  "ioeither",
+		Usage: "generate code for IOEither",
+		Flags: []C.Flag{
+			flagCount,
+			flagFilename,
+		},
+		Action: func(ctx *C.Context) error {
+			return generateIOEitherHelpers(
+				ctx.String(keyFilename),
+				ctx.Int(keyCount),
+			)
+		},
+	}
+}

cli/iooption.go

@@ -0,0 +1,137 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cli
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"time"
+
+	A "github.com/IBM/fp-go/array"
+	C "github.com/urfave/cli/v2"
+)
+
+func nonGenericIOOption(param string) string {
+	return fmt.Sprintf("IOOption[%s]", param)
+}
+
+func genericIOOption(param string) string {
+	return fmt.Sprintf("func() O.Option[%s]", param)
+}
+
+var extrasIOOption = A.Empty[string]()
+
+func generateIOOptionSequenceT(f, fg *os.File, i int) {
+	generateGenericSequenceT(nonGenericIOOption, genericIOOption, extrasIOOption)(f, fg, i)
+}
+
+func generateIOOptionSequenceTuple(f, fg *os.File, i int) {
+	generateGenericSequenceTuple(nonGenericIOOption, genericIOOption, extrasIOOption)(f, fg, i)
+}
+
+func generateIOOptionTraverseTuple(f, fg *os.File, i int) {
+	generateGenericTraverseTuple(nonGenericIOOption, genericIOOption, extrasIOOption)(f, fg, i)
+}
+
+func generateIOOptionHelpers(filename string, count int) error {
+	dir, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+	absDir, err := filepath.Abs(dir)
+	if err != nil {
+		return err
+	}
+	pkg := filepath.Base(absDir)
+	f, err := os.Create(filepath.Clean(filename))
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	// construct subdirectory
+	genFilename := filepath.Join("generic", filename)
+	err = os.MkdirAll("generic", os.ModePerm)
+	if err != nil {
+		return err
+	}
+	fg, err := os.Create(filepath.Clean(genFilename))
+	if err != nil {
+		return err
+	}
+	defer fg.Close()
+
+	// log
+	log.Printf("Generating code in [%s] for package [%s] with [%d] repetitions ...", filename, pkg, count)
+
+	// some header
+	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
+	fmt.Fprintln(f, "// This file was generated by robots at")
+	fmt.Fprintf(f, "// %s\n", time.Now())
+
+	fmt.Fprintf(f, "package %s\n\n", pkg)
+
+	fmt.Fprintf(f, `
+import (
+	G "github.com/IBM/fp-go/%s/generic"	
+	T "github.com/IBM/fp-go/tuple"
+)
+`, pkg)
+
+	// some header
+	fmt.Fprintln(fg, "// Code generated by go generate; DO NOT EDIT.")
+	fmt.Fprintln(fg, "// This file was generated by robots at")
+	fmt.Fprintf(fg, "// %s\n", time.Now())
+
+	fmt.Fprintf(fg, "package generic\n\n")
+
+	fmt.Fprintf(fg, `
+import (
+	T "github.com/IBM/fp-go/tuple"
+	O "github.com/IBM/fp-go/option"
+	A "github.com/IBM/fp-go/internal/apply"
+)
+`)
+
+	for i := 1; i <= count; i++ {
+		// sequenceT
+		generateIOOptionSequenceT(f, fg, i)
+		// sequenceTuple
+		generateIOOptionSequenceTuple(f, fg, i)
+		// traverseTuple
+		generateIOOptionTraverseTuple(f, fg, i)
+	}
+
+	return nil
+}
+
+func IOOptionCommand() *C.Command {
+	return &C.Command{
+		Name:  "iooption",
+		Usage: "generate code for IOOption",
+		Flags: []C.Flag{
+			flagCount,
+			flagFilename,
+		},
+		Action: func(ctx *C.Context) error {
+			return generateIOOptionHelpers(
+				ctx.String(keyFilename),
+				ctx.Int(keyCount),
+			)
+		},
+	}
+}

cli/monad.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package cli
 
 import (
@@ -6,18 +21,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 +44,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 +97,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 +148,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 +235,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 +298,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)

cli/monad2.go

@@ -0,0 +1,284 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cli
+
+import (
+	"fmt"
+	"os"
+
+	A "github.com/IBM/fp-go/array"
+	F "github.com/IBM/fp-go/function"
+	N "github.com/IBM/fp-go/number"
+	S "github.com/IBM/fp-go/string"
+)
+
+var (
+	concStrgs     = A.Monoid[string]().Concat
+	intercalStrgs = A.Intercalate(S.Monoid)
+	concAllStrgs  = A.ConcatAll(A.Monoid[string]())
+)
+
+func joinAll(middle string) func(all ...[]string) string {
+	ic := intercalStrgs(middle)
+	return func(all ...[]string) string {
+		return ic(concAllStrgs(all))
+	}
+}
+
+func generateGenericSequenceT(
+	nonGenericType func(string) string,
+	genericType func(string) string,
+	extra []string,
+) func(f, fg *os.File, i int) {
+	return func(f, fg *os.File, i int) {
+		// tuple
+		tuple := tupleType("T")(i)
+		// all types T
+		typesT := A.MakeBy(i, F.Flow2(
+			N.Inc[int],
+			S.Format[int]("T%d"),
+		))
+		// non generic version
+		fmt.Fprintf(f, "\n// SequenceT%d converts %d [%s] into a [%s]\n", i, i, nonGenericType("T"), nonGenericType(tuple))
+		fmt.Fprintf(f, "func SequenceT%d[%s any](\n", i, joinAll(", ")(extra, typesT))
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(f, "  t%d %s,\n", j+1, nonGenericType(fmt.Sprintf("T%d", j+1)))
+		}
+		fmt.Fprintf(f, ") %s {\n", nonGenericType(tuple))
+		fmt.Fprintf(f, "  return G.SequenceT%d[\n", i)
+		fmt.Fprintf(f, "    %s,\n", nonGenericType(tuple))
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(f, "    %s,\n", nonGenericType(fmt.Sprintf("T%d", j+1)))
+		}
+		fmt.Fprintf(f, "  ](")
+		for j := 0; j < i; j++ {
+			if j > 0 {
+				fmt.Fprintf(f, ", ")
+			}
+			fmt.Fprintf(f, "t%d", j+1)
+		}
+		fmt.Fprintf(f, ")\n")
+		fmt.Fprintf(f, "}\n")
+
+		// generic version
+		fmt.Fprintf(fg, "\n// SequenceT%d converts %d [%s] into a [%s]\n", i, i, genericType("T"), genericType(tuple))
+		fmt.Fprintf(fg, "func SequenceT%d[\n", i)
+		fmt.Fprintf(fg, "  G_TUPLE%d ~%s,\n", i, genericType(tuple))
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(fg, "  G_T%d ~%s, \n", j+1, genericType(fmt.Sprintf("T%d", j+1)))
+		}
+		fmt.Fprintf(fg, "  %s any](\n", joinAll(", ")(extra, typesT))
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(fg, "  t%d G_T%d,\n", j+1, j+1)
+		}
+		fmt.Fprintf(fg, ")  G_TUPLE%d {\n", i)
+		fmt.Fprintf(fg, "  return A.SequenceT%d(\n", i)
+		// map call
+		var cio string
+		cb := generateNestedCallbacks(1, i)
+		if i > 1 {
+			cio = genericType(cb)
+		} else {
+			cio = fmt.Sprintf("G_TUPLE%d", i)
+		}
+		fmt.Fprintf(fg, "    Map[%s],\n", joinAll(", ")(A.From("G_T1", cio), extra, A.From("T1", cb)))
+		// the apply calls
+		for j := 1; j < i; j++ {
+			if j < i-1 {
+				cb := generateNestedCallbacks(j+1, i)
+				cio = genericType(cb)
+			} else {
+				cio = fmt.Sprintf("G_TUPLE%d", i)
+			}
+			fmt.Fprintf(fg, "    Ap[%s, %s, G_T%d],\n", cio, genericType(generateNestedCallbacks(j, i)), j+1)
+		}
+		// function parameters
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(fg, "    t%d,\n", j+1)
+		}
+
+		fmt.Fprintf(fg, "  )\n")
+		fmt.Fprintf(fg, "}\n")
+	}
+}
+
+func generateGenericSequenceTuple(
+	nonGenericType func(string) string,
+	genericType func(string) string,
+	extra []string,
+) func(f, fg *os.File, i int) {
+	return func(f, fg *os.File, i int) {
+		// tuple
+		tuple := tupleType("T")(i)
+		// all types T
+		typesT := A.MakeBy(i, F.Flow2(
+			N.Inc[int],
+			S.Format[int]("T%d"),
+		))
+		// non generic version
+		fmt.Fprintf(f, "\n// SequenceTuple%d converts a [T.Tuple%d[%s]] into a [%s]\n", i, i, nonGenericType("T"), nonGenericType(tuple))
+		fmt.Fprintf(f, "func SequenceTuple%d[%s any](t T.Tuple%d[", i, joinAll(", ")(extra, typesT), i)
+		for j := 0; j < i; j++ {
+			if j > 0 {
+				fmt.Fprintf(f, ", ")
+			}
+			fmt.Fprintf(f, "%s", nonGenericType(fmt.Sprintf("T%d", j+1)))
+		}
+		fmt.Fprintf(f, "]) %s {\n", nonGenericType(tuple))
+		fmt.Fprintf(f, "  return G.SequenceTuple%d[\n", i)
+		fmt.Fprintf(f, "    %s,\n", nonGenericType(tuple))
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(f, "    %s,\n", nonGenericType(fmt.Sprintf("T%d", j+1)))
+		}
+		fmt.Fprintf(f, "  ](t)\n")
+		fmt.Fprintf(f, "}\n")
+
+		// generic version
+		fmt.Fprintf(fg, "\n// SequenceTuple%d converts a [T.Tuple%d[%s]] into a [%s]\n", i, i, genericType("T"), genericType(tuple))
+		fmt.Fprintf(fg, "func SequenceTuple%d[\n", i)
+		fmt.Fprintf(fg, "  G_TUPLE%d ~%s,\n", i, genericType(tuple))
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(fg, "  G_T%d ~%s, \n", j+1, genericType(fmt.Sprintf("T%d", j+1)))
+		}
+		fmt.Fprintf(fg, "  %s any](t T.Tuple%d[", joinAll(", ")(extra, typesT), i)
+		for j := 0; j < i; j++ {
+			if j > 0 {
+				fmt.Fprintf(fg, ", ")
+			}
+			fmt.Fprintf(fg, "G_T%d", j+1)
+		}
+		fmt.Fprintf(fg, "])  G_TUPLE%d {\n", i)
+		fmt.Fprintf(fg, "  return A.SequenceTuple%d(\n", i)
+		// map call
+		var cio string
+		cb := generateNestedCallbacks(1, i)
+		if i > 1 {
+			cio = genericType(cb)
+		} else {
+			cio = fmt.Sprintf("G_TUPLE%d", i)
+		}
+		fmt.Fprintf(fg, "    Map[%s],\n", joinAll(", ")(A.From("G_T1", cio), extra, A.From("T1", cb)))
+		// the apply calls
+		for j := 1; j < i; j++ {
+			if j < i-1 {
+				cb := generateNestedCallbacks(j+1, i)
+				cio = genericType(cb)
+			} else {
+				cio = fmt.Sprintf("G_TUPLE%d", i)
+			}
+			fmt.Fprintf(fg, "    Ap[%s, %s, G_T%d],\n", cio, genericType(generateNestedCallbacks(j, i)), j+1)
+		}
+		// function parameters
+		fmt.Fprintf(fg, "    t)\n")
+		fmt.Fprintf(fg, "}\n")
+	}
+}
+
+func generateGenericTraverseTuple(
+	nonGenericType func(string) string,
+	genericType func(string) string,
+	extra []string,
+) func(f, fg *os.File, i int) {
+	return func(f, fg *os.File, i int) {
+		// tuple
+		tupleT := tupleType("T")(i)
+		tupleA := tupleType("A")(i)
+		// all types T
+		typesT := A.MakeBy(i, F.Flow2(
+			N.Inc[int],
+			S.Format[int]("T%d"),
+		))
+		// all types A
+		typesA := A.MakeBy(i, F.Flow2(
+			N.Inc[int],
+			S.Format[int]("A%d"),
+		))
+		// all function types
+		typesF := A.MakeBy(i, F.Flow2(
+			N.Inc[int],
+			func(j int) string {
+				return fmt.Sprintf("F%d ~func(A%d) %s", j, j, nonGenericType(fmt.Sprintf("T%d", j)))
+			},
+		))
+		// non generic version
+		fmt.Fprintf(f, "\n// TraverseTuple%d converts a [T.Tuple%d[%s]] into a [%s]\n", i, i, nonGenericType("T"), nonGenericType(tupleT))
+		fmt.Fprintf(f, "func TraverseTuple%d[%s any](", i, joinAll(", ")(typesF, extra, typesA, typesT))
+		for j := 0; j < i; j++ {
+			if j > 0 {
+				fmt.Fprintf(f, ", ")
+			}
+			fmt.Fprintf(f, "f%d F%d", j+1, j+1)
+		}
+		fmt.Fprintf(f, ") func(%s) %s {\n", tupleA, nonGenericType(tupleT))
+		fmt.Fprintf(f, "  return G.TraverseTuple%d[%s](", i, nonGenericType(tupleT))
+		for j := 0; j < i; j++ {
+			if j > 0 {
+				fmt.Fprintf(f, ", ")
+			}
+			fmt.Fprintf(f, "f%d", j+1)
+		}
+		fmt.Fprintf(f, ")\n")
+		fmt.Fprintf(f, "}\n")
+
+		// generic version
+		fmt.Fprintf(fg, "\n// TraverseTuple%d converts a [T.Tuple%d[%s]] into a [%s]\n", i, i, genericType("T"), genericType(tupleT))
+		fmt.Fprintf(fg, "func TraverseTuple%d[\n", i)
+		fmt.Fprintf(fg, "  G_TUPLE%d ~%s,\n", i, genericType(tupleT))
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(fg, "  F%d ~func(A%d) G_T%d,\n", j+1, j+1, j+1)
+		}
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(fg, "  G_T%d ~%s, \n", j+1, genericType(fmt.Sprintf("T%d", j+1)))
+		}
+		fmt.Fprintf(fg, "  %s any](", joinAll(", ")(extra, typesA, typesT))
+		for j := 0; j < i; j++ {
+			if j > 0 {
+				fmt.Fprintf(fg, ", ")
+			}
+			fmt.Fprintf(fg, "f%d F%d", j+1, j+1)
+		}
+		fmt.Fprintf(fg, ") func(%s) G_TUPLE%d {\n", tupleA, i)
+		fmt.Fprintf(fg, "  return func(t %s) G_TUPLE%d {\n", tupleA, i)
+		fmt.Fprintf(fg, "    return A.TraverseTuple%d(\n", i)
+		// map call
+		var cio string
+		cb := generateNestedCallbacks(1, i)
+		if i > 1 {
+			cio = genericType(cb)
+		} else {
+			cio = fmt.Sprintf("G_TUPLE%d", i)
+		}
+		fmt.Fprintf(fg, "    Map[%s],\n", joinAll(", ")(A.From("G_T1", cio), extra, A.From("T1", cb)))
+		// the apply calls
+		for j := 1; j < i; j++ {
+			if j < i-1 {
+				cb := generateNestedCallbacks(j+1, i)
+				cio = genericType(cb)
+			} else {
+				cio = fmt.Sprintf("G_TUPLE%d", i)
+			}
+			fmt.Fprintf(fg, "    Ap[%s, %s, G_T%d],\n", cio, genericType(generateNestedCallbacks(j, i)), j+1)
+		}
+		// function parameters
+		for j := 0; j < i; j++ {
+			fmt.Fprintf(fg, "    f%d,\n", j+1)
+		}
+		// tuple parameter
+		fmt.Fprintf(fg, "    t)\n")
+		fmt.Fprintf(fg, "   }\n")
+		fmt.Fprintf(fg, "}\n")
+	}
+}

cli/option.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package cli
 
 import (

cli/pipe.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package cli
 
 import (

cli/readerioeither.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package cli
 
 import (

cli/tuple.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package cli
 
 import (
@@ -346,8 +361,10 @@ func generateTupleHelpers(filename string, count int) error {
 
 	fmt.Fprintf(f, `
 import (
+	"fmt"
+	"encoding/json"
 	M "github.com/IBM/fp-go/monoid"
-	O "github.com/IBM/fp-go/ord"
+	O "github.com/IBM/fp-go/ord"	
 )
 `)
 
@@ -371,11 +388,203 @@ import (
 		generateMap(f, i)
 		// generate replicate
 		generateReplicate(f, i)
+		// generate tuple functions such as string and fmt
+		generateTupleString(f, i)
+		// generate json support
+		generateTupleMarshal(f, i)
+		// generate json support
+		generateTupleUnmarshal(f, i)
+		// generate toArray
+		generateToArray(f, i)
+		// generate fromArray
+		generateFromArray(f, i)
 	}
 
 	return nil
 }
 
+func generateTupleMarshal(f *os.File, i int) {
+	// Create the stringify version
+	fmt.Fprintf(f, "\n// MarshalJSON marshals the [Tuple%d] into a JSON array\n", i)
+	fmt.Fprintf(f, "func (t ")
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, ") MarshalJSON() ([]byte, error) {\n")
+	fmt.Fprintf(f, "  return json.Marshal([]any{")
+	// function prototypes
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "t.F%d", j)
+	}
+	fmt.Fprintf(f, "})\n")
+	fmt.Fprintf(f, "}\n")
+}
+
+func generateTupleUnmarshal(f *os.File, i int) {
+	// Create the stringify version
+	fmt.Fprintf(f, "\n// UnmarshalJSON unmarshals a JSON array into a [Tuple%d]\n", i)
+	fmt.Fprintf(f, "func (t *")
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, ") UnmarshalJSON(data []byte) error {\n")
+	fmt.Fprintf(f, "  var tmp []json.RawMessage\n")
+	fmt.Fprintf(f, "  if err := json.Unmarshal(data, &tmp); err != nil {return err}\n")
+	fmt.Fprintf(f, "  l := len(tmp)\n")
+	// unmarshal fields
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, "  if l > %d {\n", j-1)
+		fmt.Fprintf(f, "  if err := json.Unmarshal(tmp[%d], &t.F%d); err != nil {return err}\n", j-1, j)
+	}
+	fmt.Fprintf(f, "  ")
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, "}")
+	}
+	fmt.Fprintf(f, "\n  return nil\n")
+	fmt.Fprintf(f, "}\n")
+}
+
+func generateToArray(f *os.File, i int) {
+	// Create the stringify version
+	fmt.Fprintf(f, "\n// ToArray converts the [Tuple%d] into an array of type [R] using %d transformation functions from [T] to [R]\n// The inverse function is [FromArray%d]\n", i, i, i)
+	fmt.Fprintf(f, "func ToArray%d[", i)
+	// function prototypes
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "F%d ~func(T%d) R", j, j)
+	}
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ", R any](")
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "f%d F%d", j, j)
+	}
+	fmt.Fprintf(f, ") func(t ")
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, ") []R {\n")
+	fmt.Fprintf(f, "  return func(t ")
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, ") []R {\n")
+	fmt.Fprintf(f, "    return []R{\n")
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, "      f%d(t.F%d),\n", j, j)
+	}
+	fmt.Fprintf(f, "    }\n")
+	fmt.Fprintf(f, "  }\n")
+	fmt.Fprintf(f, "}\n")
+}
+
+func generateFromArray(f *os.File, i int) {
+	// Create the stringify version
+	fmt.Fprintf(f, "\n// FromArray converts an array of [R] into a [Tuple%d] using %d functions from [R] to [T]\n// The inverse function is [ToArray%d]\n", i, i, i)
+	fmt.Fprintf(f, "func FromArray%d[", i)
+	// function prototypes
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "F%d ~func(R) T%d", j, j)
+	}
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ", R any](")
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "f%d F%d", j, j)
+	}
+	fmt.Fprintf(f, ") func(r []R) ")
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, " {\n")
+	fmt.Fprintf(f, "  return func(r []R) ")
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, " {\n")
+	fmt.Fprintf(f, "    return MakeTuple%d(\n", i)
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, "      f%d(r[%d]),\n", j, j-1)
+	}
+	fmt.Fprintf(f, "    )\n")
+	fmt.Fprintf(f, "  }\n")
+	fmt.Fprintf(f, "}\n")
+}
+
+func generateTupleString(f *os.File, i int) {
+	// Create the stringify version
+	fmt.Fprintf(f, "\n// String prints some debug info for the [Tuple%d]\n", i)
+	fmt.Fprintf(f, "func (t ")
+	writeTupleType(f, "T", i)
+	fmt.Fprintf(f, ") String() string {\n")
+	// convert to string
+	fmt.Fprintf(f, "  return fmt.Sprintf(\"Tuple%d[", i)
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "%s", "%T")
+	}
+	fmt.Fprintf(f, "](")
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "%s", "%v")
+	}
+	fmt.Fprintf(f, ")\", ")
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "t.F%d", j)
+	}
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, ", t.F%d", j)
+	}
+	fmt.Fprintf(f, ")\n")
+	fmt.Fprintf(f, "}\n")
+}
+
+// func generateTupleJson(f *os.File, i int) {
+// 	// Create the stringify version
+// 	fmt.Fprintf(f, "\n// MarshalJSON converts the [Tuple%d] into a JSON byte stream\n", i)
+// 	fmt.Fprintf(f, "func (t ")
+// 	writeTupleType(f, "T", i)
+// 	fmt.Fprintf(f, ") MarshalJSON() ([]byte, error) {\n")
+// 	// convert to string
+// 	fmt.Fprintf(f, "  return fmt.Sprintf(\"Tuple%d[", i)
+// 	for j := 1; j <= i; j++ {
+// 		if j > 1 {
+// 			fmt.Fprintf(f, ", ")
+// 		}
+// 		fmt.Fprintf(f, "%s", "%T")
+// 	}
+// 	fmt.Fprintf(f, "](")
+// 	for j := 1; j <= i; j++ {
+// 		if j > 1 {
+// 			fmt.Fprintf(f, ", ")
+// 		}
+// 		fmt.Fprintf(f, "%s", "%v")
+// 	}
+// 	fmt.Fprintf(f, ")\", ")
+// 	for j := 1; j <= i; j++ {
+// 		if j > 1 {
+// 			fmt.Fprintf(f, ", ")
+// 		}
+// 		fmt.Fprintf(f, "t.F%d", j)
+// 	}
+// 	for j := 1; j <= i; j++ {
+// 		fmt.Fprintf(f, ", t.F%d", j)
+// 	}
+// 	fmt.Fprintf(f, ")\n")
+// 	fmt.Fprintf(f, "}\n")
+// }
+
 func TupleCommand() *C.Command {
 	return &C.Command{
 		Name:  "tuple",

constant/const.go

@@ -0,0 +1,61 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package constant
+
+import (
+	F "github.com/IBM/fp-go/function"
+	M "github.com/IBM/fp-go/monoid"
+	S "github.com/IBM/fp-go/semigroup"
+)
+
+type Const[E, A any] struct {
+	Value E
+}
+
+func Make[E, A any](e E) Const[E, A] {
+	return Const[E, A]{Value: e}
+}
+
+func Unwrap[E, A any](c Const[E, A]) E {
+	return c.Value
+}
+
+func Of[E, A any](m M.Monoid[E]) func(A) Const[E, A] {
+	return func(a A) Const[E, A] {
+		return Make[E, A](m.Empty())
+	}
+}
+
+func MonadMap[E, A, B any](fa Const[E, A], f func(A) B) Const[E, B] {
+	return Make[E, B](fa.Value)
+}
+
+func MonadAp[E, A, B any](s S.Semigroup[E]) func(fab Const[E, func(A) B], fa Const[E, A]) Const[E, B] {
+	return func(fab Const[E, func(A) B], fa Const[E, A]) Const[E, B] {
+		return Make[E, B](s.Concat(fab.Value, fa.Value))
+	}
+}
+
+func Map[E, A, B any](f func(A) B) func(fa Const[E, A]) Const[E, B] {
+	return F.Bind2nd(MonadMap[E, A, B], f)
+}
+
+func Ap[E, A, B any](s S.Semigroup[E]) func(fa Const[E, A]) func(fab Const[E, func(A) B]) Const[E, B] {
+	monadap := MonadAp[E, A, B](s)
+	return func(fa Const[E, A]) func(fab Const[E, func(A) B]) Const[E, B] {
+		return F.Bind2nd(monadap, fa)
+	}
+}

constant/const_test.go

@@ -0,0 +1,40 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package constant
+
+import (
+	"testing"
+
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/utils"
+	S "github.com/IBM/fp-go/string"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMap(t *testing.T) {
+	fa := Make[string, int]("foo")
+	assert.Equal(t, fa, F.Pipe1(fa, Map[string, int](utils.Double)))
+}
+
+func TestOf(t *testing.T) {
+	assert.Equal(t, Make[string, int](""), Of[string, int](S.Monoid)(1))
+}
+
+func TestAp(t *testing.T) {
+	fab := Make[string, int]("bar")
+	assert.Equal(t, Make[string, int]("foobar"), Ap[string, int, int](S.Monoid)(fab)(Make[string, func(int) int]("foo")))
+}

constraints/constraints.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package constraints
 
 type Ordered interface {
@@ -19,3 +34,7 @@ type Integer interface {
 type Float interface {
 	~float32 | ~float64
 }
+
+type Complex interface {
+	~complex64 | ~complex128
+}

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

context/ioeither/generic/ioeither.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package generic
 
 import (

context/ioeither/ioeither.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package ioeither
 
 import (

context/reader/from.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package reader
 
 import (

context/reader/reader.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package reader
 
 import (

context/reader/reader_test.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package reader
 
 import (

context/reader/sequence.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package reader
 
 import (

context/reader/type.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 // Package reader implements a specialization of the Reader monad assuming a golang context as the context of the monad
 package reader
 

context/readereither/array.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package readereither
 
 import (

context/readereither/cancel.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package readereither
 
 import (

context/readereither/curry.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package readereither
 
 import (

context/readereither/exec/exec.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package exec
 
 import (

context/readereither/from.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package readereither
 
 import (

context/readereither/reader.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package readereither
 
 import (

context/readereither/sequence.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package readereither
 
 import (

context/readereither/type.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 // Package readereither implements a specialization of the Reader monad assuming a golang context as the context of the monad and a standard golang error
 package readereither
 

context/readerio/array.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package readerio
 
 import (

context/readerio/from.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package readerio
 
 import (

context/readerio/reader.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package readerio
 
 import (

context/readerio/reader_test.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package readerio
 
 import (

context/readerio/sequence.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package readerio
 
 import (

context/readerio/type.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 // Package readerio implements a specialization of the ReaderIO monad assuming a golang context as the context of the monad
 package readerio
 

context/readerioeither/cancel.go

@@ -1,10 +1,25 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package readerioeither
 
 import (
 	G "github.com/IBM/fp-go/context/readerioeither/generic"
 )
 
-// WithContext wraps an existing ReaderIOEither and performs a context check for cancellation before delegating
+// WithContext wraps an existing [ReaderIOEither] and performs a context check for cancellation before delegating
 func WithContext[A any](ma ReaderIOEither[A]) ReaderIOEither[A] {
 	return G.WithContext(ma)
 }

context/readerioeither/data/file.txt

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

context/readerioeither/doc.go

@@ -1,4 +1,19 @@
-// Package readerioeither contains a version of [ReaderIOEither] that takes a golang [context.Context] as its context
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package readerioeither contains a version of [ReaderIOEither] that takes a golang [context.Context] as its context and that assumes the standard go error
 package readerioeither
 
 //go:generate go run ../.. contextreaderioeither --count 10 --filename gen.go

context/readerioeither/eq.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package readerioeither
 
 import (
@@ -8,7 +23,7 @@ import (
 	EQ "github.com/IBM/fp-go/eq"
 )
 
-// Eq implements the equals predicate for values contained in the IOEither monad
+// Eq implements the equals predicate for values contained in the [ReaderIOEither] monad
 func Eq[A any](eq EQ.Eq[ET.Either[error, A]]) func(context.Context) EQ.Eq[ReaderIOEither[A]] {
 	return G.Eq[ReaderIOEither[A]](eq)
 }

context/readerioeither/exec/exec.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package exec
 
 import (

context/readerioeither/file/data/file.json

@@ -0,0 +1,3 @@
+{
+    "data": "Carsten"
+}

context/readerioeither/file/file.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package file
 
 import (
@@ -33,7 +48,7 @@ func Close[C io.Closer](c C) RIOE.ReaderIOEither[any] {
 
 // ReadFile reads a file in the scope of a context
 func ReadFile(path string) RIOE.ReaderIOEither[[]byte] {
-	return RIOE.WithResource[*os.File, []byte](Open(path), Close[*os.File])(func(r *os.File) RIOE.ReaderIOEither[[]byte] {
+	return RIOE.WithResource[[]byte](Open(path), Close[*os.File])(func(r *os.File) RIOE.ReaderIOEither[[]byte] {
 		return func(ctx context.Context) IOE.IOEither[error, []byte] {
 			return IOE.MakeIO(func() ET.Either[error, []byte] {
 				return file.ReadAll(ctx, r)

context/readerioeither/file/file_test.go

@@ -0,0 +1,56 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package 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
+}

context/readerioeither/gen.go

@@ -1,77 +1,543 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package readerioeither
 
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-19 16:18:34.1521763 +0200 CEST m=+0.011558001
+// 2023-07-28 22:48:20.012425 +0200 CEST m=+0.019517901
 
 import (
 	"context"
 
 	G "github.com/IBM/fp-go/context/readerioeither/generic"
+	T "github.com/IBM/fp-go/tuple"
 )
 
 // Eitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize0]
 func Eitherize0[F ~func(context.Context) (R, error), R any](f F) func() ReaderIOEither[R] {
-  return G.Eitherize0[ReaderIOEither[R]](f)
+	return G.Eitherize0[ReaderIOEither[R]](f)
 }
 
 // Eitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize1]
 func Eitherize1[F ~func(context.Context, T0) (R, error), T0, R any](f F) func(T0) ReaderIOEither[R] {
-  return G.Eitherize1[ReaderIOEither[R]](f)
+	return G.Eitherize1[ReaderIOEither[R]](f)
+}
+
+// SequenceT1 converts 1 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple1].
+func SequenceT1[T1 any](t1 ReaderIOEither[T1]) ReaderIOEither[T.Tuple1[T1]] {
+	return G.SequenceT1[ReaderIOEither[T.Tuple1[T1]]](t1)
+}
+
+// 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] {
-  return G.Eitherize2[ReaderIOEither[R]](f)
+	return G.Eitherize2[ReaderIOEither[R]](f)
+}
+
+// SequenceT2 converts 2 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple2].
+func SequenceT2[T1, T2 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2]) ReaderIOEither[T.Tuple2[T1, T2]] {
+	return G.SequenceT2[ReaderIOEither[T.Tuple2[T1, T2]]](t1, t2)
+}
+
+// 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] {
-  return G.Eitherize3[ReaderIOEither[R]](f)
+	return G.Eitherize3[ReaderIOEither[R]](f)
+}
+
+// SequenceT3 converts 3 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple3].
+func SequenceT3[T1, T2, T3 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3]) ReaderIOEither[T.Tuple3[T1, T2, T3]] {
+	return G.SequenceT3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](t1, t2, t3)
+}
+
+// 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] {
-  return G.Eitherize4[ReaderIOEither[R]](f)
+	return G.Eitherize4[ReaderIOEither[R]](f)
+}
+
+// SequenceT4 converts 4 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple4].
+func SequenceT4[T1, T2, T3, T4 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4]) ReaderIOEither[T.Tuple4[T1, T2, T3, T4]] {
+	return G.SequenceT4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](t1, t2, t3, t4)
+}
+
+// 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] {
-  return G.Eitherize5[ReaderIOEither[R]](f)
+	return G.Eitherize5[ReaderIOEither[R]](f)
+}
+
+// SequenceT5 converts 5 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple5].
+func SequenceT5[T1, T2, T3, T4, T5 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5]) ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]] {
+	return G.SequenceT5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](t1, t2, t3, t4, t5)
+}
+
+// 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] {
-  return G.Eitherize6[ReaderIOEither[R]](f)
+	return G.Eitherize6[ReaderIOEither[R]](f)
+}
+
+// SequenceT6 converts 6 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple6].
+func SequenceT6[T1, T2, T3, T4, T5, T6 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6]) ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
+	return G.SequenceT6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](t1, t2, t3, t4, t5, t6)
+}
+
+// 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] {
-  return G.Eitherize7[ReaderIOEither[R]](f)
+	return G.Eitherize7[ReaderIOEither[R]](f)
+}
+
+// SequenceT7 converts 7 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple7].
+func SequenceT7[T1, T2, T3, T4, T5, T6, T7 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6], t7 ReaderIOEither[T7]) ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
+	return G.SequenceT7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](t1, t2, t3, t4, t5, t6, t7)
+}
+
+// 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] {
-  return G.Eitherize8[ReaderIOEither[R]](f)
+	return G.Eitherize8[ReaderIOEither[R]](f)
+}
+
+// SequenceT8 converts 8 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple8].
+func SequenceT8[T1, T2, T3, T4, T5, T6, T7, T8 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6], t7 ReaderIOEither[T7], t8 ReaderIOEither[T8]) ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
+	return G.SequenceT8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](t1, t2, t3, t4, t5, t6, t7, t8)
+}
+
+// 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] {
-  return G.Eitherize9[ReaderIOEither[R]](f)
+	return G.Eitherize9[ReaderIOEither[R]](f)
+}
+
+// SequenceT9 converts 9 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple9].
+func SequenceT9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6], t7 ReaderIOEither[T7], t8 ReaderIOEither[T8], t9 ReaderIOEither[T9]) ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
+	return G.SequenceT9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](t1, t2, t3, t4, t5, t6, t7, t8, t9)
+}
+
+// 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] {
-  return G.Eitherize10[ReaderIOEither[R]](f)
+	return G.Eitherize10[ReaderIOEither[R]](f)
+}
+
+// SequenceT10 converts 10 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple10].
+func SequenceT10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6], t7 ReaderIOEither[T7], t8 ReaderIOEither[T8], t9 ReaderIOEither[T9], t10 ReaderIOEither[T10]) ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
+	return G.SequenceT10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
+}
+
+// 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)
 }

context/readerioeither/generic/cancel.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package generic
 
 import (

context/readerioeither/generic/eq.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package generic
 
 import (

context/readerioeither/generic/reader.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package generic
 
 import (
@@ -13,6 +28,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 +169,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,24 +220,69 @@ func MonadAp[
 			fabIOE := withCancelCauseFunc(cancelSub, cfab(ctxSub))
 			faIOE := withCancelCauseFunc(cancelSub, cfa(ctxSub))
 
-			return IOE.MonadAp[GIOA, GIOB, GIOAB](fabIOE, faIOE)()
+			return IOE.MonadApPar[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,
 	GRA ~func(context.Context) GIOA,
 
-	GIOA ~func() E.Either[error, A],
 	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(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],

context/readerioeither/generic/resource.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package generic
 
 import (

context/readerioeither/generic/sequence.go

@@ -1,85 +0,0 @@
-package generic
-
-import (
-	"context"
-
-	E "github.com/IBM/fp-go/either"
-	RE "github.com/IBM/fp-go/readerioeither/generic"
-	T "github.com/IBM/fp-go/tuple"
-)
-
-// SequenceT converts n inputs of higher kinded types into a higher kinded types of n strongly typed values, represented as a tuple
-
-func SequenceT1[
-	GRT ~func(context.Context) GIOT,
-	GRA ~func(context.Context) GIOA,
-
-	GIOA ~func() E.Either[error, A],
-	GIOT ~func() E.Either[error, T.Tuple1[A]],
-
-	A any](a GRA) GRT {
-	return RE.SequenceT1[
-		GRA,
-		GRT,
-	](a)
-}
-
-func SequenceT2[
-	GRT ~func(context.Context) GIOT,
-	GRA ~func(context.Context) GIOA,
-	GRB ~func(context.Context) GIOB,
-
-	GIOA ~func() E.Either[error, A],
-	GIOB ~func() E.Either[error, B],
-	GIOT ~func() E.Either[error, T.Tuple2[A, B]],
-
-	A, B any](a GRA, b GRB) GRT {
-	return RE.SequenceT2[
-		GRA,
-		GRB,
-		GRT,
-	](a, b)
-}
-
-func SequenceT3[
-	GRT ~func(context.Context) GIOT,
-	GRA ~func(context.Context) GIOA,
-	GRB ~func(context.Context) GIOB,
-	GRC ~func(context.Context) GIOC,
-
-	GIOA ~func() E.Either[error, A],
-	GIOB ~func() E.Either[error, B],
-	GIOC ~func() E.Either[error, C],
-	GIOT ~func() E.Either[error, T.Tuple3[A, B, C]],
-
-	A, B, C any](a GRA, b GRB, c GRC) GRT {
-	return RE.SequenceT3[
-		GRA,
-		GRB,
-		GRC,
-		GRT,
-	](a, b, c)
-}
-
-func SequenceT4[
-	GRT ~func(context.Context) GIOT,
-	GRA ~func(context.Context) GIOA,
-	GRB ~func(context.Context) GIOB,
-	GRC ~func(context.Context) GIOC,
-	GRD ~func(context.Context) GIOD,
-
-	GIOA ~func() E.Either[error, A],
-	GIOB ~func() E.Either[error, B],
-	GIOC ~func() E.Either[error, C],
-	GIOD ~func() E.Either[error, D],
-	GIOT ~func() E.Either[error, T.Tuple4[A, B, C, D]],
-
-	A, B, C, D any](a GRA, b GRB, c GRC, d GRD) GRT {
-	return RE.SequenceT4[
-		GRA,
-		GRB,
-		GRC,
-		GRD,
-		GRT,
-	](a, b, c, d)
-}

context/readerioeither/generic/traverse.go

@@ -1,12 +1,48 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package generic
 
 import (
 	"context"
 
 	E "github.com/IBM/fp-go/either"
-	RE "github.com/IBM/fp-go/readerioeither/generic"
+	F "github.com/IBM/fp-go/function"
+	RA "github.com/IBM/fp-go/internal/array"
+	RR "github.com/IBM/fp-go/internal/record"
 )
 
+// MonadTraverseArray transforms an array
+func MonadTraverseArray[
+	AS ~[]A,
+	GRBS ~func(context.Context) GIOBS,
+	GRB ~func(context.Context) GIOB,
+	GIOBS ~func() E.Either[error, BS],
+	GIOB ~func() E.Either[error, B],
+	BS ~[]B,
+	A, B any](as AS, f func(A) GRB) GRBS {
+
+	return RA.MonadTraverse[AS](
+		Of[GRBS, GIOBS, BS],
+		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
+		Ap[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		as, f,
+	)
+}
+
 // TraverseArray transforms an array
 func TraverseArray[
 	AS ~[]A,
@@ -16,7 +52,14 @@ func TraverseArray[
 	GIOB ~func() E.Either[error, B],
 	BS ~[]B,
 	A, B any](f func(A) GRB) func(AS) GRBS {
-	return RE.TraverseArray[GRB, GRBS, GIOB, GIOBS, AS](f)
+
+	return RA.Traverse[AS](
+		Of[GRBS, GIOBS, BS],
+		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
+		Ap[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		f,
+	)
 }
 
 // SequenceArray converts a homogeneous sequence of either into an either of sequence
@@ -28,7 +71,28 @@ func SequenceArray[
 	GIOAS ~func() E.Either[error, AS],
 	GIOA ~func() E.Either[error, A],
 	A any](ma GAS) GRAS {
-	return RE.SequenceArray[GRA, GRAS](ma)
+
+	return MonadTraverseArray[GAS, GRAS](ma, F.Identity[GRA])
+}
+
+// MonadTraverseRecord transforms a record
+func MonadTraverseRecord[K comparable,
+	AS ~map[K]A,
+	GRBS ~func(context.Context) GIOBS,
+	GRB ~func(context.Context) GIOB,
+	GIOBS ~func() E.Either[error, BS],
+	GIOB ~func() E.Either[error, B],
+	BS ~map[K]B,
+
+	A, B any](ma AS, f func(A) GRB) GRBS {
+
+	return RR.MonadTraverse[AS](
+		Of[GRBS, GIOBS, BS],
+		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
+		Ap[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		ma, f,
+	)
 }
 
 // TraverseRecord transforms a record
@@ -41,7 +105,14 @@ func TraverseRecord[K comparable,
 	BS ~map[K]B,
 
 	A, B any](f func(A) GRB) func(AS) GRBS {
-	return RE.TraverseRecord[GRB, GRBS, GIOB, GIOBS, AS](f)
+
+	return RR.Traverse[AS](
+		Of[GRBS, GIOBS, BS],
+		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
+		Ap[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		f,
+	)
 }
 
 // SequenceRecord converts a homogeneous sequence of either into an either of sequence
@@ -53,5 +124,6 @@ func SequenceRecord[K comparable,
 	GIOAS ~func() E.Either[error, AS],
 	GIOA ~func() E.Either[error, A],
 	A any](ma GAS) GRAS {
-	return RE.SequenceRecord[GRA, GRAS](ma)
+
+	return MonadTraverseRecord[K, GAS, GRAS](ma, F.Identity[GRA])
 }

context/readerioeither/http/request.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package http
 
 import (

context/readerioeither/http/request_test.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package http
 
 import (

context/readerioeither/reader.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package readerioeither
 
 import (

context/readerioeither/reader_test.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package readerioeither
 
 import (

context/readerioeither/resource.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package readerioeither
 
 import (
@@ -5,7 +20,7 @@ import (
 )
 
 // WithResource constructs a function that creates a resource, then operates on it and then releases the resource
-func WithResource[R, A, ANY any](onCreate ReaderIOEither[R], onRelease func(R) ReaderIOEither[ANY]) func(func(R) ReaderIOEither[A]) ReaderIOEither[A] {
+func WithResource[A, R, ANY any](onCreate ReaderIOEither[R], onRelease func(R) ReaderIOEither[ANY]) func(func(R) ReaderIOEither[A]) ReaderIOEither[A] {
 	// wraps the callback functions with a context check
 	return G.WithResource[ReaderIOEither[A]](onCreate, onRelease)
 }

context/readerioeither/resource_test.go

@@ -0,0 +1,79 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerioeither
+
+import (
+	"context"
+	"io"
+	"os"
+
+	B "github.com/IBM/fp-go/bytes"
+	F "github.com/IBM/fp-go/function"
+	IO "github.com/IBM/fp-go/io"
+	IOE "github.com/IBM/fp-go/ioeither"
+)
+
+var (
+	openFile = F.Flow3(
+		IOE.Eitherize1(os.Open),
+		FromIOEither[*os.File],
+		ChainFirstIOK(F.Flow2(
+			(*os.File).Name,
+			IO.Logf[string]("Opened file [%s]"),
+		)),
+	)
+)
+
+func closeFile(f *os.File) ReaderIOEither[string] {
+	return F.Pipe1(
+		TryCatch(func(_ context.Context) func() (string, error) {
+			return func() (string, error) {
+				return f.Name(), f.Close()
+			}
+		}),
+		ChainFirstIOK(IO.Logf[string]("Closed file [%s]")),
+	)
+}
+
+func ExampleWithResource() {
+
+	stringReader := WithResource[string](openFile("data/file.txt"), closeFile)
+
+	rdr := stringReader(func(f *os.File) ReaderIOEither[string] {
+		return F.Pipe2(
+			TryCatch(func(_ context.Context) func() ([]byte, error) {
+				return func() ([]byte, error) {
+					return io.ReadAll(f)
+				}
+			}),
+			ChainFirstIOK(F.Flow2(
+				B.Size,
+				IO.Logf[int]("Read content of length [%d]"),
+			)),
+			Map(B.ToString),
+		)
+	})
+
+	contentIOE := F.Pipe2(
+		context.Background(),
+		rdr,
+		IOE.ChainFirstIOK[error](IO.Printf[string]("Content: %s")),
+	)
+
+	contentIOE()
+
+	// Output: Content: Carsten
+}

context/readerioeither/sequence.go

@@ -1,24 +0,0 @@
-package readerioeither
-
-import (
-	G "github.com/IBM/fp-go/context/readerioeither/generic"
-	T "github.com/IBM/fp-go/tuple"
-)
-
-// SequenceT converts n inputs of higher kinded types into a higher kinded types of n strongly typed values, represented as a tuple
-
-func SequenceT1[A any](a ReaderIOEither[A]) ReaderIOEither[T.Tuple1[A]] {
-	return G.SequenceT1[ReaderIOEither[T.Tuple1[A]]](a)
-}
-
-func SequenceT2[A, B any](a ReaderIOEither[A], b ReaderIOEither[B]) ReaderIOEither[T.Tuple2[A, B]] {
-	return G.SequenceT2[ReaderIOEither[T.Tuple2[A, B]]](a, b)
-}
-
-func SequenceT3[A, B, C any](a ReaderIOEither[A], b ReaderIOEither[B], c ReaderIOEither[C]) ReaderIOEither[T.Tuple3[A, B, C]] {
-	return G.SequenceT3[ReaderIOEither[T.Tuple3[A, B, C]]](a, b, c)
-}
-
-func SequenceT4[A, B, C, D any](a ReaderIOEither[A], b ReaderIOEither[B], c ReaderIOEither[C], d ReaderIOEither[D]) ReaderIOEither[T.Tuple4[A, B, C, D]] {
-	return G.SequenceT4[ReaderIOEither[T.Tuple4[A, B, C, D]]](a, b, c, d)
-}

context/readerioeither/traverse.go

@@ -1,10 +1,25 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package readerioeither
 
 import (
 	G "github.com/IBM/fp-go/context/readerioeither/generic"
 )
 
-// TraverseArray transforms an array
+// TraverseArray uses transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]]
 func TraverseArray[A, B any](f func(A) ReaderIOEither[B]) func([]A) ReaderIOEither[[]B] {
 	return G.TraverseArray[[]A, ReaderIOEither[[]B]](f)
 }
@@ -14,7 +29,7 @@ func SequenceArray[A any](ma []ReaderIOEither[A]) ReaderIOEither[[]A] {
 	return G.SequenceArray[[]A, []ReaderIOEither[A], ReaderIOEither[[]A]](ma)
 }
 
-// TraverseRecord transforms a record
+// TraverseRecord uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
 func TraverseRecord[K comparable, A, B any](f func(A) ReaderIOEither[B]) func(map[K]A) ReaderIOEither[map[K]B] {
 	return G.TraverseRecord[K, map[K]A, ReaderIOEither[map[K]B]](f)
 }

context/readerioeither/type.go

@@ -1,4 +1,18 @@
-// Package readerioeither implements a specialization of the Reader monad assuming a golang context as the context of the monad and a standard golang error
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package readerioeither
 
 import (
@@ -7,5 +21,6 @@ import (
 	RE "github.com/IBM/fp-go/readerioeither"
 )
 
-// ReaderIOEither is a specialization of the Reader monad for the typical golang scenario
+// ReaderIOEither is a specialization of the [RE.ReaderIOEither] monad for the typical golang scenario in which the
+// left value is an [error] and the context is a [context.Context]
 type ReaderIOEither[A any] RE.ReaderIOEither[context.Context, error, A]

either/apply.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package either
 
 import (

either/apply_test.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package either
 
 import (

either/array.go

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

either/core.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package either
 
 import (

either/curry.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package either
 
 import (

either/doc.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package either
 
 //go:generate go run .. either --count 10 --filename gen.go

either/either.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 // package either implements the Either monad
 //
 // A data type that can be of either of two types but not both. This is

either/either_test.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package either
 
 import (

either/eq.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package either
 
 import (

either/eq_test.go

@@ -1,3 +1,18 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package either
 
 import (