fix: use endomorphism in optics

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

.github/workflows/build.yml

@@ -29,11 +29,11 @@ jobs:
         go-version: [ '1.20.x', '1.21.x' ]
     steps:
       # full checkout for semantic-release
-      - uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 # v3.5.3
+      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
         with:
           fetch-depth: 0
       - name: Set up go ${{ matrix.go-version }}
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@v5
         with:
           go-version: ${{ matrix.go-version }}
       -
@@ -55,17 +55,17 @@ jobs:
     steps:
       # full checkout for semantic-release
       - name: Full checkout
-        uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 # v3.5.3
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
         with:
           fetch-depth: 0
 
       - name: Set up Node.js ${{ env.NODE_VERSION }}
-        uses: actions/setup-node@e33196f7422957bea03ed53f6fbb155025ffc7b8 # v3.7.0
+        uses: actions/setup-node@8f152de45cc393bb48ce5d89d36b731f54556e65 # v4.0.0
         with:
           node-version: ${{ env.NODE_VERSION }}
 
       - name: Set up go ${{env.GO_VERSION}}
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@v5
         with:
           go-version: ${{env.GO_VERSION}}
 

README.md

@@ -14,6 +14,8 @@ go get github.com/IBM/fp-go
 
 Refer to the [samples](./samples/).
 
+Find API documentation [here](https://pkg.go.dev/github.com/IBM/fp-go)
+
 ## Design Goal
 
 This library aims to provide a set of data types and functions that make it easy and fun to write maintainable and testable code in golang. It encourages the following patterns:
@@ -192,3 +194,14 @@ this would be the completely generic method signature for all possible monads. I
 This FP library addresses this by introducing the HKTs as individual types, e.g. `HKT[A]` would be represented as a new generic type `HKTA`. This loses the correlation to the type `A` but allows to implement generic algorithms, at the price of readability.
 
 For that reason these implementations are kept in the `internal` package. These are meant to be used by the library itself or by extensions, not by end users.
+
+## Map/Ap/Flap
+
+The following table lists the relationship between some selected operators
+
+| Opertator | Parameter        | Monad           | Result   |
+| --------  | ---------------- | --------------- | -------- |
+| Map       | `func(A) B`      | `HKT[A]`        | `HKT[B]` |
+| Chain     | `func(A) HKT[B]` | `HKT[A]` | `HKT[B]` |
+| Ap        | `HKT[A]`         | `HKT[func(A)B]` | `HKT[B]` |
+| Flap      | `A`              | `HKT[func(A)B]` | `HKT[B]` |

array/any.go

@@ -0,0 +1,30 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package array
+
+import (
+	G "github.com/IBM/fp-go/array/generic"
+)
+
+// AnyWithIndex tests if any of the elements in the array matches the predicate
+func AnyWithIndex[A any](pred func(int, A) bool) func([]A) bool {
+	return G.AnyWithIndex[[]A](pred)
+}
+
+// Any tests if any of the elements in the array matches the predicate
+func Any[A any](pred func(A) bool) func([]A) bool {
+	return G.Any[[]A](pred)
+}

array/any_test.go

@@ -0,0 +1,30 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package array
+
+import (
+	"testing"
+
+	F "github.com/IBM/fp-go/function"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAny(t *testing.T) {
+	anyBool := Any(F.Identity[bool])
+
+	assert.True(t, anyBool(From(false, true, false)))
+	assert.False(t, anyBool(From(false, false, false)))
+}

array/array.go

@@ -52,6 +52,10 @@ func MonadMapRef[A, B any](as []A, f func(a *A) B) []B {
 	return bs
 }
 
+func MapWithIndex[A, B any](f func(int, A) B) func([]A) []B {
+	return G.MapWithIndex[[]A, []B](f)
+}
+
 func Map[A, B any](f func(a A) B) func([]A) []B {
 	return F.Bind2nd(MonadMap[A, B], f)
 }
@@ -60,18 +64,6 @@ func MapRef[A, B any](f func(a *A) B) func([]A) []B {
 	return F.Bind2nd(MonadMapRef[A, B], f)
 }
 
-func filter[A any](fa []A, pred func(A) bool) []A {
-	var result []A
-	count := len(fa)
-	for i := 0; i < count; i++ {
-		a := fa[i]
-		if pred(a) {
-			result = append(result, a)
-		}
-	}
-	return result
-}
-
 func filterRef[A any](fa []A, pred func(a *A) bool) []A {
 	var result []A
 	count := len(fa)
@@ -96,23 +88,38 @@ func filterMapRef[A, B any](fa []A, pred func(a *A) bool, f func(a *A) B) []B {
 	return result
 }
 
+// Filter returns a new array with all elements from the original array that match a predicate
 func Filter[A any](pred func(A) bool) func([]A) []A {
-	return F.Bind2nd(filter[A], pred)
+	return G.Filter[[]A](pred)
+}
+
+// FilterWithIndex returns a new array with all elements from the original array that match a predicate
+func FilterWithIndex[A any](pred func(int, A) bool) func([]A) []A {
+	return G.FilterWithIndex[[]A](pred)
 }
 
 func FilterRef[A any](pred func(*A) bool) func([]A) []A {
 	return F.Bind2nd(filterRef[A], pred)
 }
 
-func MonadFilterMap[A, B any](fa []A, f func(a A) O.Option[B]) []B {
+func MonadFilterMap[A, B any](fa []A, f func(A) O.Option[B]) []B {
 	return G.MonadFilterMap[[]A, []B](fa, f)
 }
 
-// FilterChain maps an array with an iterating function that returns an [O.Option] and it keeps only the Some values discarding the Nones.
-func FilterMap[A, B any](f func(a A) O.Option[B]) func([]A) []B {
+func MonadFilterMapWithIndex[A, B any](fa []A, f func(int, A) O.Option[B]) []B {
+	return G.MonadFilterMapWithIndex[[]A, []B](fa, f)
+}
+
+// FilterMap maps an array with an iterating function that returns an [O.Option] and it keeps only the Some values discarding the Nones.
+func FilterMap[A, B any](f func(A) O.Option[B]) func([]A) []B {
 	return G.FilterMap[[]A, []B](f)
 }
 
+// FilterMapWithIndex maps an array with an iterating function that returns an [O.Option] and it keeps only the Some values discarding the Nones.
+func FilterMapWithIndex[A, B any](f func(int, A) O.Option[B]) func([]A) []B {
+	return G.FilterMapWithIndex[[]A, []B](f)
+}
+
 // FilterChain maps an array with an iterating function that returns an [O.Option] of an array. It keeps only the Some values discarding the Nones and then flattens the result.
 func FilterChain[A, B any](f func(A) O.Option[[]B]) func([]A) []B {
 	return G.FilterChain[[]A](f)
@@ -134,9 +141,19 @@ func reduceRef[A, B any](fa []A, f func(B, *A) B, initial B) B {
 }
 
 func Reduce[A, B any](f func(B, A) B, initial B) func([]A) B {
-	return func(as []A) B {
-		return array.Reduce(as, f, initial)
-	}
+	return G.Reduce[[]A](f, initial)
+}
+
+func ReduceWithIndex[A, B any](f func(int, B, A) B, initial B) func([]A) B {
+	return G.ReduceWithIndex[[]A](f, initial)
+}
+
+func ReduceRight[A, B any](f func(A, B) B, initial B) func([]A) B {
+	return G.ReduceRight[[]A](f, initial)
+}
+
+func ReduceRightWithIndex[A, B any](f func(int, A, B) B, initial B) func([]A) B {
+	return G.ReduceRightWithIndex[[]A](f, initial)
 }
 
 func ReduceRef[A, B any](f func(B, *A) B, initial B) func([]A) B {
@@ -291,15 +308,26 @@ func SliceRight[A any](start int) func([]A) []A {
 	return G.SliceRight[[]A](start)
 }
 
+// Copy creates a shallow copy of the array
 func Copy[A any](b []A) []A {
 	return G.Copy(b)
 }
 
+// Clone creates a deep copy of the array using the provided endomorphism to clone the values
+func Clone[A any](f func(A) A) func(as []A) []A {
+	return G.Clone[[]A](f)
+}
+
 // FoldMap maps and folds an array. Map the Array passing each value to the iterating function. Then fold the results using the provided Monoid.
 func FoldMap[A, B any](m M.Monoid[B]) func(func(A) B) func([]A) B {
 	return G.FoldMap[[]A](m)
 }
 
+// FoldMapWithIndex maps and folds an array. Map the Array passing each value to the iterating function. Then fold the results using the provided Monoid.
+func FoldMapWithIndex[A, B any](m M.Monoid[B]) func(func(int, A) B) func([]A) B {
+	return G.FoldMapWithIndex[[]A](m)
+}
+
 // Fold folds the array using the provided Monoid.
 func Fold[A any](m M.Monoid[A]) func([]A) A {
 	return G.Fold[[]A](m)
@@ -308,3 +336,11 @@ func Fold[A any](m M.Monoid[A]) func([]A) A {
 func Push[A any](a A) func([]A) []A {
 	return G.Push[[]A](a)
 }
+
+func MonadFlap[B, A any](fab []func(A) B, a A) []B {
+	return G.MonadFlap[func(A) B, []func(A) B, []B, A, B](fab, a)
+}
+
+func Flap[B, A any](a A) func([]func(A) B) []B {
+	return G.Flap[func(A) B, []func(A) B, []B, A, B](a)
+}

array/array_test.go

@@ -59,6 +59,17 @@ func TestMap(t *testing.T) {
 	assert.Equal(t, dst, []string{"A", "B", "C"})
 }
 
+func TestReduceRight(t *testing.T) {
+	values := From("a", "b", "c")
+	f := func(a, acc string) string {
+		return fmt.Sprintf("%s%s", acc, a)
+	}
+	b := ""
+
+	assert.Equal(t, "cba", ReduceRight(f, b)(values))
+	assert.Equal(t, "", ReduceRight(f, b)(Empty[string]()))
+}
+
 func TestReduce(t *testing.T) {
 
 	values := MakeBy(101, F.Identity[int])

array/example_any_test.go

@@ -0,0 +1,77 @@
+// 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"
+
+	F "github.com/IBM/fp-go/function"
+	O "github.com/IBM/fp-go/option"
+)
+
+func Example_any() {
+
+	pred := func(val int) bool {
+		return val&2 == 0
+	}
+
+	data1 := From(1, 2, 3)
+
+	fmt.Println(Any(pred)(data1))
+
+	// Output:
+	// true
+}
+
+func Example_any_filter() {
+
+	pred := func(val int) bool {
+		return val&2 == 0
+	}
+
+	data1 := From(1, 2, 3)
+
+	// Any tests if any of the entries in the array matches the condition
+	Any := F.Flow2(
+		Filter(pred),
+		IsNonEmpty[int],
+	)
+
+	fmt.Println(Any(data1))
+
+	// Output:
+	// true
+}
+
+func Example_any_find() {
+
+	pred := func(val int) bool {
+		return val&2 == 0
+	}
+
+	data1 := From(1, 2, 3)
+
+	// Any tests if any of the entries in the array matches the condition
+	Any := F.Flow2(
+		FindFirst(pred),
+		O.IsSome[int],
+	)
+
+	fmt.Println(Any(data1))
+
+	// Output:
+	// true
+}

array/example_find_test.go

@@ -0,0 +1,55 @@
+// 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"
+
+	F "github.com/IBM/fp-go/function"
+)
+
+func Example_find() {
+
+	pred := func(val int) bool {
+		return val&2 == 0
+	}
+
+	data1 := From(1, 2, 3)
+
+	fmt.Println(FindFirst(pred)(data1))
+
+	// Output:
+	// Some[int](1)
+}
+
+func Example_find_filter() {
+
+	pred := func(val int) bool {
+		return val&2 == 0
+	}
+
+	data1 := From(1, 2, 3)
+
+	Find := F.Flow2(
+		Filter(pred),
+		Head[int],
+	)
+
+	fmt.Println(Find(data1))
+
+	// Output:
+	// Some[int](1)
+}

array/find.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 array
+
+import (
+	G "github.com/IBM/fp-go/array/generic"
+	O "github.com/IBM/fp-go/option"
+)
+
+// FindFirst finds the first element which satisfies a predicate (or a refinement) function
+func FindFirst[A any](pred func(A) bool) func([]A) O.Option[A] {
+	return G.FindFirst[[]A](pred)
+}
+
+// FindFirstWithIndex finds the first element which satisfies a predicate (or a refinement) function
+func FindFirstWithIndex[A any](pred func(int, A) bool) func([]A) O.Option[A] {
+	return G.FindFirstWithIndex[[]A](pred)
+}
+
+// FindFirstMap finds the first element returned by an [O.Option] based selector function
+func FindFirstMap[A, B any](sel func(A) O.Option[B]) func([]A) O.Option[B] {
+	return G.FindFirstMap[[]A](sel)
+}
+
+// FindFirstMapWithIndex finds the first element returned by an [O.Option] based selector function
+func FindFirstMapWithIndex[A, B any](sel func(int, A) O.Option[B]) func([]A) O.Option[B] {
+	return G.FindFirstMapWithIndex[[]A](sel)
+}
+
+// FindLast finds the Last element which satisfies a predicate (or a refinement) function
+func FindLast[A any](pred func(A) bool) func([]A) O.Option[A] {
+	return G.FindLast[[]A](pred)
+}
+
+// FindLastWithIndex finds the Last element which satisfies a predicate (or a refinement) function
+func FindLastWithIndex[A any](pred func(int, A) bool) func([]A) O.Option[A] {
+	return G.FindLastWithIndex[[]A](pred)
+}
+
+// FindLastMap finds the Last element returned by an [O.Option] based selector function
+func FindLastMap[A, B any](sel func(A) O.Option[B]) func([]A) O.Option[B] {
+	return G.FindLastMap[[]A](sel)
+}
+
+// FindLastMapWithIndex finds the Last element returned by an [O.Option] based selector function
+func FindLastMapWithIndex[A, B any](sel func(int, A) O.Option[B]) func([]A) O.Option[B] {
+	return G.FindLastMapWithIndex[[]A](sel)
+}

array/generic/any.go

@@ -0,0 +1,34 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	F "github.com/IBM/fp-go/function"
+	O "github.com/IBM/fp-go/option"
+)
+
+// AnyWithIndex tests if any of the elements in the array matches the predicate
+func AnyWithIndex[AS ~[]A, PRED ~func(int, A) bool, A any](pred PRED) func(AS) bool {
+	return F.Flow2(
+		FindFirstWithIndex[AS](pred),
+		O.IsSome[A],
+	)
+}
+
+// Any tests if any of the elements in the array matches the predicate
+func Any[AS ~[]A, PRED ~func(A) bool, A any](pred PRED) func(AS) bool {
+	return AnyWithIndex[AS](F.Ignore1of2[int](pred))
+}

array/generic/array.go

@@ -18,6 +18,7 @@ package generic
 import (
 	F "github.com/IBM/fp-go/function"
 	"github.com/IBM/fp-go/internal/array"
+	FC "github.com/IBM/fp-go/internal/functor"
 	M "github.com/IBM/fp-go/monoid"
 	O "github.com/IBM/fp-go/option"
 	"github.com/IBM/fp-go/tuple"
@@ -28,14 +29,46 @@ func Of[GA ~[]A, A any](value A) GA {
 	return GA{value}
 }
 
-func Reduce[GA ~[]A, A, B any](fa GA, f func(B, A) B, initial B) B {
+func Reduce[GA ~[]A, A, B any](f func(B, A) B, initial B) func(GA) B {
+	return func(as GA) B {
+		return MonadReduce[GA](as, f, initial)
+	}
+}
+
+func ReduceWithIndex[GA ~[]A, A, B any](f func(int, B, A) B, initial B) func(GA) B {
+	return func(as GA) B {
+		return MonadReduceWithIndex[GA](as, f, initial)
+	}
+}
+
+func ReduceRight[GA ~[]A, A, B any](f func(A, B) B, initial B) func(GA) B {
+	return func(as GA) B {
+		return MonadReduceRight[GA](as, f, initial)
+	}
+}
+
+func ReduceRightWithIndex[GA ~[]A, A, B any](f func(int, A, B) B, initial B) func(GA) B {
+	return func(as GA) B {
+		return MonadReduceRightWithIndex[GA](as, f, initial)
+	}
+}
+
+func MonadReduce[GA ~[]A, A, B any](fa GA, f func(B, A) B, initial B) B {
 	return array.Reduce(fa, f, initial)
 }
 
-func ReduceWithIndex[GA ~[]A, A, B any](fa GA, f func(int, B, A) B, initial B) B {
+func MonadReduceWithIndex[GA ~[]A, A, B any](fa GA, f func(int, B, A) B, initial B) B {
 	return array.ReduceWithIndex(fa, f, initial)
 }
 
+func MonadReduceRight[GA ~[]A, A, B any](fa GA, f func(A, B) B, initial B) B {
+	return array.ReduceRight(fa, f, initial)
+}
+
+func MonadReduceRightWithIndex[GA ~[]A, A, B any](fa GA, f func(int, A, B) B, initial B) B {
+	return array.ReduceRightWithIndex(fa, f, initial)
+}
+
 // From constructs an array from a set of variadic arguments
 func From[GA ~[]A, A any](data ...A) GA {
 	return data
@@ -117,20 +150,56 @@ func Map[GA ~[]A, GB ~[]B, A, B any](f func(a A) B) func(GA) GB {
 	return F.Bind2nd(MonadMap[GA, GB, A, B], f)
 }
 
+func MonadMapWithIndex[GA ~[]A, GB ~[]B, A, B any](as GA, f func(int, A) B) GB {
+	return array.MonadMapWithIndex[GA, GB](as, f)
+}
+
+func MapWithIndex[GA ~[]A, GB ~[]B, A, B any](f func(int, A) B) func(GA) GB {
+	return F.Bind2nd(MonadMapWithIndex[GA, GB, A, B], f)
+}
+
 func Size[GA ~[]A, A any](as GA) int {
 	return len(as)
 }
 
-func filterMap[GA ~[]A, GB ~[]B, A, B any](fa GA, f func(a A) O.Option[B]) GB {
+func filterMap[GA ~[]A, GB ~[]B, A, B any](fa GA, f func(A) O.Option[B]) GB {
 	return array.Reduce(fa, func(bs GB, a A) GB {
 		return O.MonadFold(f(a), F.Constant(bs), F.Bind1st(Append[GB, B], bs))
 	}, Empty[GB]())
 }
 
-func MonadFilterMap[GA ~[]A, GB ~[]B, A, B any](fa GA, f func(a A) O.Option[B]) GB {
+func filterMapWithIndex[GA ~[]A, GB ~[]B, A, B any](fa GA, f func(int, A) O.Option[B]) GB {
+	return array.ReduceWithIndex(fa, func(idx int, bs GB, a A) GB {
+		return O.MonadFold(f(idx, a), F.Constant(bs), F.Bind1st(Append[GB, B], bs))
+	}, Empty[GB]())
+}
+
+func MonadFilterMap[GA ~[]A, GB ~[]B, A, B any](fa GA, f func(A) O.Option[B]) GB {
 	return filterMap[GA, GB](fa, f)
 }
 
+func MonadFilterMapWithIndex[GA ~[]A, GB ~[]B, A, B any](fa GA, f func(int, A) O.Option[B]) GB {
+	return filterMapWithIndex[GA, GB](fa, f)
+}
+
+func filterWithIndex[AS ~[]A, PRED ~func(int, A) bool, A any](fa AS, pred PRED) AS {
+	result := make(AS, 0, len(fa))
+	for i, a := range fa {
+		if pred(i, a) {
+			result = append(result, a)
+		}
+	}
+	return result
+}
+
+func FilterWithIndex[AS ~[]A, PRED ~func(int, A) bool, A any](pred PRED) func(AS) AS {
+	return F.Bind2nd(filterWithIndex[AS, PRED, A], pred)
+}
+
+func Filter[AS ~[]A, PRED ~func(A) bool, A any](pred PRED) func(AS) AS {
+	return FilterWithIndex[AS](F.Ignore1of2[int](pred))
+}
+
 func FilterChain[GA ~[]A, GB ~[]B, A, B any](f func(a A) O.Option[GB]) func(GA) GB {
 	return F.Flow2(
 		FilterMap[GA, []GB](f),
@@ -142,10 +211,14 @@ func Flatten[GAA ~[]GA, GA ~[]A, A any](mma GAA) GA {
 	return MonadChain(mma, F.Identity[GA])
 }
 
-func FilterMap[GA ~[]A, GB ~[]B, A, B any](f func(a A) O.Option[B]) func(GA) GB {
+func FilterMap[GA ~[]A, GB ~[]B, A, B any](f func(A) O.Option[B]) func(GA) GB {
 	return F.Bind2nd(MonadFilterMap[GA, GB, A, B], f)
 }
 
+func FilterMapWithIndex[GA ~[]A, GB ~[]B, A, B any](f func(int, A) O.Option[B]) func(GA) GB {
+	return F.Bind2nd(MonadFilterMapWithIndex[GA, GB, A, B], f)
+}
+
 func MonadPartition[GA ~[]A, A any](as GA, pred func(A) bool) tuple.Tuple2[GA, GA] {
 	left := Empty[GA]()
 	right := Empty[GA]()
@@ -231,6 +304,11 @@ func Copy[AS ~[]A, A any](b AS) AS {
 	return buf
 }
 
+func Clone[AS ~[]A, A any](f func(A) A) func(as AS) AS {
+	// implementation assumes that map does not optimize for the empty array
+	return Map[AS, AS](f)
+}
+
 func FoldMap[AS ~[]A, A, B any](m M.Monoid[B]) func(func(A) B) func(AS) B {
 	return func(f func(A) B) func(AS) B {
 		return func(as AS) B {
@@ -241,6 +319,16 @@ func FoldMap[AS ~[]A, A, B any](m M.Monoid[B]) func(func(A) B) func(AS) B {
 	}
 }
 
+func FoldMapWithIndex[AS ~[]A, A, B any](m M.Monoid[B]) func(func(int, A) B) func(AS) B {
+	return func(f func(int, A) B) func(AS) B {
+		return func(as AS) B {
+			return array.ReduceWithIndex(as, func(idx int, cur B, a A) B {
+				return m.Concat(cur, f(idx, a))
+			}, m.Empty())
+		}
+	}
+}
+
 func Fold[AS ~[]A, A any](m M.Monoid[A]) func(AS) A {
 	return func(as AS) A {
 		return array.Reduce(as, m.Concat, m.Empty())
@@ -250,3 +338,11 @@ func Fold[AS ~[]A, A any](m M.Monoid[A]) func(AS) A {
 func Push[GA ~[]A, A any](a A) func(GA) GA {
 	return F.Bind2nd(array.Push[GA, A], a)
 }
+
+func MonadFlap[FAB ~func(A) B, GFAB ~[]FAB, GB ~[]B, A, B any](fab GFAB, a A) GB {
+	return FC.MonadFlap(MonadMap[GFAB, GB], fab, a)
+}
+
+func Flap[FAB ~func(A) B, GFAB ~[]FAB, GB ~[]B, A, B any](a A) func(GFAB) GB {
+	return F.Bind2nd(MonadFlap[FAB, GFAB, GB, A, B], a)
+}

array/generic/find.go

@@ -0,0 +1,97 @@
+// 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"
+	O "github.com/IBM/fp-go/option"
+)
+
+// FindFirstWithIndex finds the first element which satisfies a predicate (or a refinement) function
+func FindFirstWithIndex[AS ~[]A, PRED ~func(int, A) bool, A any](pred PRED) func(AS) O.Option[A] {
+	none := O.None[A]()
+	return func(as AS) O.Option[A] {
+		for i, a := range as {
+			if pred(i, a) {
+				return O.Some(a)
+			}
+		}
+		return none
+	}
+}
+
+// FindFirst finds the first element which satisfies a predicate (or a refinement) function
+func FindFirst[AS ~[]A, PRED ~func(A) bool, A any](pred PRED) func(AS) O.Option[A] {
+	return FindFirstWithIndex[AS](F.Ignore1of2[int](pred))
+}
+
+// FindFirstMapWithIndex finds the first element returned by an [O.Option] based selector function
+func FindFirstMapWithIndex[AS ~[]A, PRED ~func(int, A) O.Option[B], A, B any](pred PRED) func(AS) O.Option[B] {
+	none := O.None[B]()
+	return func(as AS) O.Option[B] {
+		count := len(as)
+		for i := 0; i < count; i++ {
+			out := pred(i, as[i])
+			if O.IsSome(out) {
+				return out
+			}
+		}
+		return none
+	}
+}
+
+// FindFirstMap finds the first element returned by an [O.Option] based selector function
+func FindFirstMap[AS ~[]A, PRED ~func(A) O.Option[B], A, B any](pred PRED) func(AS) O.Option[B] {
+	return FindFirstMapWithIndex[AS](F.Ignore1of2[int](pred))
+}
+
+// FindLastWithIndex finds the first element which satisfies a predicate (or a refinement) function
+func FindLastWithIndex[AS ~[]A, PRED ~func(int, A) bool, A any](pred PRED) func(AS) O.Option[A] {
+	none := O.None[A]()
+	return func(as AS) O.Option[A] {
+		for i := len(as) - 1; i >= 0; i-- {
+			a := as[i]
+			if pred(i, a) {
+				return O.Some(a)
+			}
+		}
+		return none
+	}
+}
+
+// FindLast finds the first element which satisfies a predicate (or a refinement) function
+func FindLast[AS ~[]A, PRED ~func(A) bool, A any](pred PRED) func(AS) O.Option[A] {
+	return FindLastWithIndex[AS](F.Ignore1of2[int](pred))
+}
+
+// FindLastMapWithIndex finds the first element returned by an [O.Option] based selector function
+func FindLastMapWithIndex[AS ~[]A, PRED ~func(int, A) O.Option[B], A, B any](pred PRED) func(AS) O.Option[B] {
+	none := O.None[B]()
+	return func(as AS) O.Option[B] {
+		for i := len(as) - 1; i >= 0; i-- {
+			out := pred(i, as[i])
+			if O.IsSome(out) {
+				return out
+			}
+		}
+		return none
+	}
+}
+
+// FindLastMap finds the first element returned by an [O.Option] based selector function
+func FindLastMap[AS ~[]A, PRED ~func(A) O.Option[B], A, B any](pred PRED) func(AS) O.Option[B] {
+	return FindLastMapWithIndex[AS](F.Ignore1of2[int](pred))
+}

array/generic/uniq.go

@@ -0,0 +1,32 @@
+package generic
+
+import F "github.com/IBM/fp-go/function"
+
+// StrictUniq converts an array of arbitrary items into an array or unique items
+// where uniqueness is determined by the built-in uniqueness constraint
+func StrictUniq[AS ~[]A, A comparable](as AS) AS {
+	return Uniq[AS](F.Identity[A])(as)
+}
+
+// uniquePredUnsafe returns a predicate on a map for uniqueness
+func uniquePredUnsafe[PRED ~func(A) K, A any, K comparable](f PRED) func(int, A) bool {
+	lookup := make(map[K]bool)
+	return func(_ int, a A) bool {
+		k := f(a)
+		_, has := lookup[k]
+		if has {
+			return false
+		}
+		lookup[k] = true
+		return true
+	}
+}
+
+// Uniq converts an array of arbitrary items into an array or unique items
+// where uniqueness is determined based on a key extractor function
+func Uniq[AS ~[]A, PRED ~func(A) K, A any, K comparable](f PRED) func(as AS) AS {
+	return func(as AS) AS {
+		// we need to create a new predicate for each iteration
+		return filterWithIndex(as, uniquePredUnsafe(f))
+	}
+}

array/monoid.go

@@ -18,6 +18,7 @@ package array
 import (
 	"github.com/IBM/fp-go/internal/array"
 	M "github.com/IBM/fp-go/monoid"
+	S "github.com/IBM/fp-go/semigroup"
 )
 
 func concat[T any](left, right []T) []T {
@@ -40,6 +41,10 @@ func Monoid[T any]() M.Monoid[[]T] {
 	return M.MakeMonoid(concat[T], Empty[T]())
 }
 
+func Semigroup[T any]() S.Semigroup[[]T] {
+	return S.MakeSemigroup(concat[T])
+}
+
 func addLen[A any](count int, data []A) int {
 	return count + len(data)
 }

array/nonempty/array.go

@@ -0,0 +1,124 @@
+// 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 nonempty
+
+import (
+	G "github.com/IBM/fp-go/array/generic"
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/array"
+	S "github.com/IBM/fp-go/semigroup"
+)
+
+// NonEmptyArray represents an array with at least one element
+type NonEmptyArray[A any] []A
+
+// Of constructs a single element array
+func Of[A any](first A) NonEmptyArray[A] {
+	return G.Of[NonEmptyArray[A]](first)
+}
+
+// From constructs a [NonEmptyArray] from a set of variadic arguments
+func From[A any](first A, data ...A) NonEmptyArray[A] {
+	count := len(data)
+	if count == 0 {
+		return Of(first)
+	}
+	// allocate the requested buffer
+	buffer := make(NonEmptyArray[A], count+1)
+	buffer[0] = first
+	copy(buffer[1:], data)
+	return buffer
+}
+
+func IsEmpty[A any](as NonEmptyArray[A]) bool {
+	return false
+}
+
+func IsNonEmpty[A any](as NonEmptyArray[A]) bool {
+	return true
+}
+
+func MonadMap[A, B any](as NonEmptyArray[A], f func(a A) B) NonEmptyArray[B] {
+	return G.MonadMap[NonEmptyArray[A], NonEmptyArray[B]](as, f)
+}
+
+func Map[A, B any](f func(a A) B) func(NonEmptyArray[A]) NonEmptyArray[B] {
+	return F.Bind2nd(MonadMap[A, B], f)
+}
+
+func Reduce[A, B any](f func(B, A) B, initial B) func(NonEmptyArray[A]) B {
+	return func(as NonEmptyArray[A]) B {
+		return array.Reduce(as, f, initial)
+	}
+}
+
+func Tail[A any](as NonEmptyArray[A]) []A {
+	return as[1:]
+}
+
+func Head[A any](as NonEmptyArray[A]) A {
+	return as[0]
+}
+
+func First[A any](as NonEmptyArray[A]) A {
+	return as[0]
+}
+
+func Last[A any](as NonEmptyArray[A]) A {
+	return as[len(as)-1]
+}
+
+func Size[A any](as NonEmptyArray[A]) int {
+	return G.Size(as)
+}
+
+func Flatten[A any](mma NonEmptyArray[NonEmptyArray[A]]) NonEmptyArray[A] {
+	return G.Flatten(mma)
+}
+
+func MonadChain[A, B any](fa NonEmptyArray[A], f func(a A) NonEmptyArray[B]) NonEmptyArray[B] {
+	return G.MonadChain[NonEmptyArray[A], NonEmptyArray[B]](fa, f)
+}
+
+func Chain[A, B any](f func(A) NonEmptyArray[B]) func(NonEmptyArray[A]) NonEmptyArray[B] {
+	return G.Chain[NonEmptyArray[A], NonEmptyArray[B]](f)
+}
+
+func MonadAp[B, A any](fab NonEmptyArray[func(A) B], fa NonEmptyArray[A]) NonEmptyArray[B] {
+	return G.MonadAp[NonEmptyArray[B]](fab, fa)
+}
+
+func Ap[B, A any](fa NonEmptyArray[A]) func(NonEmptyArray[func(A) B]) NonEmptyArray[B] {
+	return G.Ap[NonEmptyArray[B], NonEmptyArray[func(A) B]](fa)
+}
+
+// FoldMap maps and folds a [NonEmptyArray]. Map the [NonEmptyArray] passing each value to the iterating function. Then fold the results using the provided [Semigroup].
+func FoldMap[A, B any](s S.Semigroup[B]) func(func(A) B) func(NonEmptyArray[A]) B {
+	return func(f func(A) B) func(NonEmptyArray[A]) B {
+		return func(as NonEmptyArray[A]) B {
+			return array.Reduce(Tail(as), func(cur B, a A) B {
+				return s.Concat(cur, f(a))
+			}, f(Head(as)))
+		}
+	}
+}
+
+// Fold folds the [NonEmptyArray] using the provided [Semigroup].
+func Fold[A any](s S.Semigroup[A]) func(NonEmptyArray[A]) A {
+	return func(as NonEmptyArray[A]) A {
+		return array.Reduce(Tail(as), s.Concat, Head(as))
+	}
+}

array/uniq.go

@@ -0,0 +1,17 @@
+package array
+
+import (
+	G "github.com/IBM/fp-go/array/generic"
+)
+
+// StrictUniq converts an array of arbitrary items into an array or unique items
+// where uniqueness is determined by the built-in uniqueness constraint
+func StrictUniq[A comparable](as []A) []A {
+	return G.StrictUniq[[]A](as)
+}
+
+// Uniq converts an array of arbitrary items into an array or unique items
+// where uniqueness is determined based on a key extractor function
+func Uniq[A any, K comparable](f func(A) K) func(as []A) []A {
+	return G.Uniq[[]A](f)
+}

array/uniq_test.go

@@ -0,0 +1,14 @@
+package array
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestUniq(t *testing.T) {
+	data := From(1, 2, 3, 2, 4, 1)
+
+	uniq := StrictUniq(data)
+	assert.Equal(t, From(1, 2, 3, 4), uniq)
+}

assert/assert_test.go

@@ -0,0 +1,109 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package assert
+
+import (
+	"fmt"
+	"testing"
+
+	E "github.com/IBM/fp-go/either"
+	EQ "github.com/IBM/fp-go/eq"
+	"github.com/stretchr/testify/assert"
+)
+
+var (
+	errTest = fmt.Errorf("test failure")
+
+	// Eq is the equal predicate checking if objects are equal
+	Eq = EQ.FromEquals(assert.ObjectsAreEqual)
+)
+
+func wrap1[T any](wrapped func(t assert.TestingT, expected, actual any, msgAndArgs ...any) bool, t *testing.T, expected T) func(actual T) E.Either[error, T] {
+	return func(actual T) E.Either[error, T] {
+		ok := wrapped(t, expected, actual)
+		if ok {
+			return E.Of[error](actual)
+		}
+		return E.Left[T](errTest)
+	}
+}
+
+// NotEqual tests if the expected and the actual values are not equal
+func NotEqual[T any](t *testing.T, expected T) func(actual T) E.Either[error, T] {
+	return wrap1(assert.NotEqual, t, expected)
+}
+
+// Equal tests if the expected and the actual values are equal
+func Equal[T any](t *testing.T, expected T) func(actual T) E.Either[error, T] {
+	return wrap1(assert.Equal, t, expected)
+}
+
+// Length tests if an array has the expected length
+func Length[T any](t *testing.T, expected int) func(actual []T) E.Either[error, []T] {
+	return func(actual []T) E.Either[error, []T] {
+		ok := assert.Len(t, actual, expected)
+		if ok {
+			return E.Of[error](actual)
+		}
+		return E.Left[[]T](errTest)
+	}
+}
+
+// NoError validates that there is no error
+func NoError[T any](t *testing.T) func(actual E.Either[error, T]) E.Either[error, T] {
+	return func(actual E.Either[error, T]) E.Either[error, T] {
+		return E.MonadFold(actual, func(e error) E.Either[error, T] {
+			assert.NoError(t, e)
+			return E.Left[T](e)
+		}, func(value T) E.Either[error, T] {
+			assert.NoError(t, nil)
+			return E.Right[error](value)
+		})
+	}
+}
+
+// ArrayContains tests if a value is contained in an array
+func ArrayContains[T any](t *testing.T, expected T) func(actual []T) E.Either[error, []T] {
+	return func(actual []T) E.Either[error, []T] {
+		ok := assert.Contains(t, actual, expected)
+		if ok {
+			return E.Of[error](actual)
+		}
+		return E.Left[[]T](errTest)
+	}
+}
+
+// ContainsKey tests if a key is contained in a map
+func ContainsKey[T any, K comparable](t *testing.T, expected K) func(actual map[K]T) E.Either[error, map[K]T] {
+	return func(actual map[K]T) E.Either[error, map[K]T] {
+		ok := assert.Contains(t, actual, expected)
+		if ok {
+			return E.Of[error](actual)
+		}
+		return E.Left[map[K]T](errTest)
+	}
+}
+
+// NotContainsKey tests if a key is not contained in a map
+func NotContainsKey[T any, K comparable](t *testing.T, expected K) func(actual map[K]T) E.Either[error, map[K]T] {
+	return func(actual map[K]T) E.Either[error, map[K]T] {
+		ok := assert.NotContains(t, actual, expected)
+		if ok {
+			return E.Of[error](actual)
+		}
+		return E.Left[map[K]T](errTest)
+	}
+}

boolean/boolean.go

@@ -0,0 +1,59 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package boolean
+
+import (
+	EQ "github.com/IBM/fp-go/eq"
+	M "github.com/IBM/fp-go/monoid"
+	O "github.com/IBM/fp-go/ord"
+)
+
+var (
+	// MonoidAny is the boolean [M.Monoid] under disjunction
+	MonoidAny = M.MakeMonoid(
+		func(l, r bool) bool {
+			return l || r
+		},
+		false,
+	)
+
+	// MonoidAll is the boolean [M.Monoid] under conjuction
+	MonoidAll = M.MakeMonoid(
+		func(l, r bool) bool {
+			return l && r
+		},
+		true,
+	)
+
+	// Eq is the equals predicate for boolean
+	Eq = EQ.FromStrictEquals[bool]()
+
+	// Ord is the strict ordering for boolean
+	Ord = O.MakeOrd(func(l, r bool) int {
+		if l {
+			if r {
+				return 0
+			}
+			return +1
+		}
+		if r {
+			return -1
+		}
+		return 0
+	}, func(l, r bool) bool {
+		return l == r
+	})
+)

cli/either.go

@@ -115,16 +115,14 @@ func generateEitherize(f *os.File, i int) {
 		fmt.Fprintf(f, "t%d T%d", j, j)
 	}
 	fmt.Fprintf(f, ") Either[error, R] {\n")
-	fmt.Fprintf(f, "    return TryCatchError(func() (R, error) {\n")
-	fmt.Fprintf(f, "      return f(")
+	fmt.Fprintf(f, "    return TryCatchError(f(")
 	for j := 0; j < i; j++ {
 		if j > 0 {
 			fmt.Fprintf(f, ", ")
 		}
 		fmt.Fprintf(f, "t%d", j)
 	}
-	fmt.Fprintln(f, ")")
-	fmt.Fprintln(f, "    })")
+	fmt.Fprintln(f, "))")
 	fmt.Fprintln(f, "  }")
 	fmt.Fprintln(f, "}")
 }

cli/pipe.go

@@ -25,6 +25,40 @@ import (
 	C "github.com/urfave/cli/v2"
 )
 
+func generateUnsliced(f *os.File, i int) {
+	// Create the optionize version
+	fmt.Fprintf(f, "\n// Unsliced%d converts a function taking a slice parameter into a function with %d parameters\n", i, i)
+	fmt.Fprintf(f, "func Unsliced%d[F ~func([]T) R, T, R any](f F) func(", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T")
+	}
+	fmt.Fprintf(f, ") R {\n")
+	fmt.Fprintf(f, "  return func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "t%d", j+1)
+	}
+	if i > 0 {
+		fmt.Fprintf(f, " T")
+	}
+	fmt.Fprintf(f, ") R {\n")
+	fmt.Fprintf(f, "    return f([]T{")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "t%d", j+1)
+	}
+	fmt.Fprintln(f, "})")
+	fmt.Fprintln(f, "  }")
+	fmt.Fprintln(f, "}")
+}
+
 func generateVariadic(f *os.File, i int) {
 	// Create the nullary version
 	fmt.Fprintf(f, "\n// Variadic%d converts a function taking %d parameters and a final slice into a function with %d parameters but a final variadic argument\n", i, i, i)
@@ -83,7 +117,7 @@ func generateVariadic(f *os.File, i int) {
 	fmt.Fprintf(f, "v)\n")
 	fmt.Fprintf(f, "  }\n")
 
-	fmt.Fprintf(f, "}")
+	fmt.Fprintf(f, "}\n")
 }
 
 func generateUnvariadic(f *os.File, i int) {
@@ -144,7 +178,7 @@ func generateUnvariadic(f *os.File, i int) {
 	fmt.Fprintf(f, "v...)\n")
 	fmt.Fprintf(f, "  }\n")
 
-	fmt.Fprintf(f, "}")
+	fmt.Fprintf(f, "}\n")
 }
 
 func generateNullary(f *os.File, i int) {
@@ -347,6 +381,8 @@ func generatePipeHelpers(filename string, count int) error {
 	generateVariadic(f, 0)
 	// unvariadic
 	generateUnvariadic(f, 0)
+	// unsliced
+	generateUnsliced(f, 0)
 
 	for i := 1; i <= count; i++ {
 
@@ -364,6 +400,8 @@ func generatePipeHelpers(filename string, count int) error {
 		generateVariadic(f, i)
 		// unvariadic
 		generateUnvariadic(f, i)
+		// unsliced
+		generateUnsliced(f, i)
 	}
 
 	return nil

cli/tuple.go

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

constant/const.go

@@ -22,30 +22,28 @@ import (
 )
 
 type Const[E, A any] struct {
-	Value E
+	value E
 }
 
 func Make[E, A any](e E) Const[E, A] {
-	return Const[E, A]{Value: e}
+	return Const[E, A]{value: e}
 }
 
 func Unwrap[E, A any](c Const[E, A]) E {
-	return c.Value
+	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())
-	}
+	return F.Constant1[A](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)
+	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))
+		return Make[E, B](s.Concat(fab.value, fa.value))
 	}
 }
 

context/ioeither/generic/ioeither.go

@@ -19,15 +19,14 @@ import (
 	"context"
 
 	E "github.com/IBM/fp-go/either"
-	ET "github.com/IBM/fp-go/either"
 	IOE "github.com/IBM/fp-go/ioeither/generic"
 )
 
-// withContext wraps an existing IOEither and performs a context check for cancellation before delegating
+// WithContext wraps an existing IOEither and performs a context check for cancellation before delegating
 func WithContext[GIO ~func() E.Either[error, A], A any](ctx context.Context, ma GIO) GIO {
 	return IOE.MakeIO[GIO](func() E.Either[error, A] {
 		if err := context.Cause(ctx); err != nil {
-			return ET.Left[A](err)
+			return E.Left[A](err)
 		}
 		return ma()
 	})

context/reader/curry.go

@@ -1,53 +0,0 @@
-//   Copyright (c) 2023 IBM Corp.
-//   All rights reserved.
-//
-//   Licensed under the Apache License, Version 2.0 (the "License");
-//   you may not use this file except in compliance with the License.
-//   You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-//   Unless required by applicable law or agreed to in writing, software
-//   distributed under the License is distributed on an "AS IS" BASIS,
-//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//   See the License for the specific language governing permissions and
-//   limitations under the License.
-
-package reader
-
-import (
-	"context"
-
-	R "github.com/IBM/fp-go/reader/generic"
-)
-
-// these functions curry a golang function with the context as the firsr parameter into a either reader with the context as the last parameter
-// this goes back to the advice in https://pkg.go.dev/context to put the context as a first parameter as a convention
-
-func Curry0[A any](f func(context.Context) A) Reader[A] {
-	return R.Curry0[Reader[A]](f)
-}
-
-func Curry1[T1, A any](f func(context.Context, T1) A) func(T1) Reader[A] {
-	return R.Curry1[Reader[A]](f)
-}
-
-func Curry2[T1, T2, A any](f func(context.Context, T1, T2) A) func(T1) func(T2) Reader[A] {
-	return R.Curry2[Reader[A]](f)
-}
-
-func Curry3[T1, T2, T3, A any](f func(context.Context, T1, T2, T3) A) func(T1) func(T2) func(T3) Reader[A] {
-	return R.Curry3[Reader[A]](f)
-}
-
-func Uncurry1[T1, A any](f func(T1) Reader[A]) func(context.Context, T1) A {
-	return R.Uncurry1(f)
-}
-
-func Uncurry2[T1, T2, A any](f func(T1) func(T2) Reader[A]) func(context.Context, T1, T2) A {
-	return R.Uncurry2(f)
-}
-
-func Uncurry3[T1, T2, T3, A any](f func(T1) func(T2) func(T3) Reader[A]) func(context.Context, T1, T2, T3) A {
-	return R.Uncurry3(f)
-}

context/reader/from.go

@@ -1,41 +0,0 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package reader
-
-import (
-	"context"
-
-	R "github.com/IBM/fp-go/reader/generic"
-)
-
-// these functions curry a golang function with the context as the firsr parameter into a either reader with the context as the last parameter
-// this goes back to the advice in https://pkg.go.dev/context to put the context as a first parameter as a convention
-
-func From0[A any](f func(context.Context) A) func() Reader[A] {
-	return R.From0[Reader[A]](f)
-}
-
-func From1[T1, A any](f func(context.Context, T1) A) func(T1) Reader[A] {
-	return R.From1[Reader[A]](f)
-}
-
-func From2[T1, T2, A any](f func(context.Context, T1, T2) A) func(T1, T2) Reader[A] {
-	return R.From2[Reader[A]](f)
-}
-
-func From3[T1, T2, T3, A any](f func(context.Context, T1, T2, T3) A) func(T1, T2, T3) Reader[A] {
-	return R.From3[Reader[A]](f)
-}

context/reader/reader.go

@@ -1,58 +0,0 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package reader
-
-import (
-	"context"
-
-	R "github.com/IBM/fp-go/reader/generic"
-)
-
-func MonadMap[A, B any](fa Reader[A], f func(A) B) Reader[B] {
-	return R.MonadMap[Reader[A], Reader[B]](fa, f)
-}
-
-func Map[A, B any](f func(A) B) func(Reader[A]) Reader[B] {
-	return R.Map[Reader[A], Reader[B]](f)
-}
-
-func MonadChain[A, B any](ma Reader[A], f func(A) Reader[B]) Reader[B] {
-	return R.MonadChain(ma, f)
-}
-
-func Chain[A, B any](f func(A) Reader[B]) func(Reader[A]) Reader[B] {
-	return R.Chain[Reader[A]](f)
-}
-
-func Of[A any](a A) Reader[A] {
-	return R.Of[Reader[A]](a)
-}
-
-func MonadAp[A, B any](fab Reader[func(A) B], fa Reader[A]) Reader[B] {
-	return R.MonadAp[Reader[A], Reader[B]](fab, fa)
-}
-
-func Ap[A, B any](fa Reader[A]) func(Reader[func(A) B]) Reader[B] {
-	return R.Ap[Reader[A], Reader[B], Reader[func(A) B]](fa)
-}
-
-func Ask() Reader[context.Context] {
-	return R.Ask[Reader[context.Context]]()
-}
-
-func Asks[A any](r Reader[A]) Reader[A] {
-	return R.Asks(r)
-}

context/reader/reader_test.go

@@ -1,75 +0,0 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package reader
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"testing"
-
-	F "github.com/IBM/fp-go/function"
-	T "github.com/IBM/fp-go/tuple"
-	"github.com/stretchr/testify/assert"
-)
-
-func GoFunction(ctx context.Context, data string) string {
-	return strings.ToUpper(data)
-}
-
-func GoIntFunction(ctx context.Context, data string, number int) string {
-	return fmt.Sprintf("%s: %d", data, number)
-}
-
-func TestReaderFrom(t *testing.T) {
-	ctx := context.Background()
-	f := From1(GoFunction)
-
-	result := f("input")(ctx)
-
-	assert.Equal(t, result, "INPUT")
-
-}
-
-func MyFinalResult(left, right string) string {
-	return fmt.Sprintf("%s-%s", left, right)
-}
-
-func TestReadersFrom(t *testing.T) {
-	ctx := context.Background()
-
-	f1 := From1(GoFunction)
-	f2 := From2(GoIntFunction)
-
-	result1 := f1("input")(ctx)
-	result2 := f2("input", 10)(ctx)
-
-	result3 := MyFinalResult(result1, result2)
-
-	h := F.Pipe1(
-		SequenceT2(f1("input"), f2("input", 10)),
-		Map(T.Tupled2(MyFinalResult)),
-	)
-
-	composedResult := h(ctx)
-
-	assert.Equal(t, result1, "INPUT")
-	assert.Equal(t, result2, "input: 10")
-	assert.Equal(t, result3, "INPUT-input: 10")
-
-	assert.Equal(t, composedResult, "INPUT-input: 10")
-
-}

context/reader/sequence.go

@@ -1,57 +0,0 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package reader
-
-import (
-	R "github.com/IBM/fp-go/reader/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 Reader[A]) Reader[T.Tuple1[A]] {
-	return R.SequenceT1[
-		Reader[A],
-		Reader[T.Tuple1[A]],
-	](a)
-}
-
-func SequenceT2[A, B any](a Reader[A], b Reader[B]) Reader[T.Tuple2[A, B]] {
-	return R.SequenceT2[
-		Reader[A],
-		Reader[B],
-		Reader[T.Tuple2[A, B]],
-	](a, b)
-}
-
-func SequenceT3[A, B, C any](a Reader[A], b Reader[B], c Reader[C]) Reader[T.Tuple3[A, B, C]] {
-	return R.SequenceT3[
-		Reader[A],
-		Reader[B],
-		Reader[C],
-		Reader[T.Tuple3[A, B, C]],
-	](a, b, c)
-}
-
-func SequenceT4[A, B, C, D any](a Reader[A], b Reader[B], c Reader[C], d Reader[D]) Reader[T.Tuple4[A, B, C, D]] {
-	return R.SequenceT4[
-		Reader[A],
-		Reader[B],
-		Reader[C],
-		Reader[D],
-		Reader[T.Tuple4[A, B, C, D]],
-	](a, b, c, d)
-}

context/readereither/array.go

@@ -24,6 +24,11 @@ func TraverseArray[A, B any](f func(A) ReaderEither[B]) func([]A) ReaderEither[[
 	return RE.TraverseArray[ReaderEither[B], ReaderEither[[]B], []A](f)
 }
 
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[A, B any](f func(int, A) ReaderEither[B]) func([]A) ReaderEither[[]B] {
+	return RE.TraverseArrayWithIndex[ReaderEither[B], ReaderEither[[]B], []A](f)
+}
+
 // SequenceArray converts a homogeneous sequence of either into an either of sequence
 func SequenceArray[A any](ma []ReaderEither[A]) ReaderEither[[]A] {
 	return RE.SequenceArray[ReaderEither[A], ReaderEither[[]A]](ma)

context/readereither/exec/exec.go

@@ -34,8 +34,6 @@ var (
 
 func command(name string, args []string, in []byte) RE.ReaderEither[exec.CommandOutput] {
 	return func(ctx context.Context) E.Either[error, exec.CommandOutput] {
-		return E.TryCatchError(func() (exec.CommandOutput, error) {
-			return GE.Exec(ctx, name, args, in)
-		})
+		return E.TryCatchError(GE.Exec(ctx, name, args, in))
 	}
 }

context/readereither/reader.go

@@ -18,7 +18,6 @@ package readereither
 import (
 	"context"
 
-	R "github.com/IBM/fp-go/context/reader"
 	ET "github.com/IBM/fp-go/either"
 	O "github.com/IBM/fp-go/option"
 	RE "github.com/IBM/fp-go/readereither/generic"
@@ -32,14 +31,6 @@ func FromEither[A any](e ET.Either[error, A]) ReaderEither[A] {
 	return RE.FromEither[ReaderEither[A]](e)
 }
 
-func RightReader[A any](r R.Reader[A]) ReaderEither[A] {
-	return RE.RightReader[R.Reader[A], ReaderEither[A]](r)
-}
-
-func LeftReader[A any](l R.Reader[error]) ReaderEither[A] {
-	return RE.LeftReader[R.Reader[error], ReaderEither[A]](l)
-}
-
 func Left[A any](l error) ReaderEither[A] {
 	return RE.Left[ReaderEither[A]](l)
 }
@@ -48,10 +39,6 @@ func Right[A any](r A) ReaderEither[A] {
 	return RE.Right[ReaderEither[A]](r)
 }
 
-func FromReader[A any](r R.Reader[A]) ReaderEither[A] {
-	return RE.FromReader[R.Reader[A], ReaderEither[A]](r)
-}
-
 func MonadMap[A, B any](fa ReaderEither[A], f func(A) B) ReaderEither[B] {
 	return RE.MonadMap[ReaderEither[A], ReaderEither[B]](fa, f)
 }
@@ -84,30 +71,14 @@ func FromPredicate[A any](pred func(A) bool, onFalse func(A) error) func(A) Read
 	return RE.FromPredicate[ReaderEither[A]](pred, onFalse)
 }
 
-func Fold[A, B any](onLeft func(error) R.Reader[B], onRight func(A) R.Reader[B]) func(ReaderEither[A]) R.Reader[B] {
-	return RE.Fold[ReaderEither[A]](onLeft, onRight)
-}
-
-func GetOrElse[A any](onLeft func(error) R.Reader[A]) func(ReaderEither[A]) R.Reader[A] {
-	return RE.GetOrElse[ReaderEither[A]](onLeft)
-}
-
 func OrElse[A any](onLeft func(error) ReaderEither[A]) func(ReaderEither[A]) ReaderEither[A] {
 	return RE.OrElse[ReaderEither[A]](onLeft)
 }
 
-func OrLeft[A any](onLeft func(error) R.Reader[error]) func(ReaderEither[A]) ReaderEither[A] {
-	return RE.OrLeft[ReaderEither[A], ReaderEither[A]](onLeft)
-}
-
 func Ask() ReaderEither[context.Context] {
 	return RE.Ask[ReaderEither[context.Context]]()
 }
 
-func Asks[A any](r R.Reader[A]) ReaderEither[A] {
-	return RE.Asks[R.Reader[A], ReaderEither[A]](r)
-}
-
 func MonadChainEitherK[A, B any](ma ReaderEither[A], f func(A) ET.Either[error, B]) ReaderEither[B] {
 	return RE.MonadChainEitherK[ReaderEither[A], ReaderEither[B]](ma, f)
 }
@@ -119,3 +90,11 @@ func ChainEitherK[A, B any](f func(A) ET.Either[error, B]) func(ma ReaderEither[
 func ChainOptionK[A, B any](onNone func() error) func(func(A) O.Option[B]) func(ReaderEither[A]) ReaderEither[B] {
 	return RE.ChainOptionK[ReaderEither[A], ReaderEither[B]](onNone)
 }
+
+func MonadFlap[B, A any](fab ReaderEither[func(A) B], a A) ReaderEither[B] {
+	return RE.MonadFlap[ReaderEither[func(A) B], ReaderEither[B]](fab, a)
+}
+
+func Flap[B, A any](a A) func(ReaderEither[func(A) B]) ReaderEither[B] {
+	return RE.Flap[ReaderEither[func(A) B], ReaderEither[B]](a)
+}

context/readerio/from.go

@@ -1,42 +0,0 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package readerio
-
-import (
-	"context"
-
-	IO "github.com/IBM/fp-go/io"
-	R "github.com/IBM/fp-go/readerio/generic"
-)
-
-// these functions curry a golang function with the context as the firsr parameter into a either reader with the context as the last parameter
-// this goes back to the advice in https://pkg.go.dev/context to put the context as a first parameter as a convention
-
-func From0[A any](f func(context.Context) IO.IO[A]) func() ReaderIO[A] {
-	return R.From0[ReaderIO[A]](f)
-}
-
-func From1[T1, A any](f func(context.Context, T1) IO.IO[A]) func(T1) ReaderIO[A] {
-	return R.From1[ReaderIO[A]](f)
-}
-
-func From2[T1, T2, A any](f func(context.Context, T1, T2) IO.IO[A]) func(T1, T2) ReaderIO[A] {
-	return R.From2[ReaderIO[A]](f)
-}
-
-func From3[T1, T2, T3, A any](f func(context.Context, T1, T2, T3) IO.IO[A]) func(T1, T2, T3) ReaderIO[A] {
-	return R.From3[ReaderIO[A]](f)
-}

context/readerio/reader.go

@@ -1,59 +0,0 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package readerio
-
-import (
-	"context"
-
-	R "github.com/IBM/fp-go/readerio/generic"
-)
-
-func MonadMap[A, B any](fa ReaderIO[A], f func(A) B) ReaderIO[B] {
-	return R.MonadMap[ReaderIO[A], ReaderIO[B]](fa, f)
-}
-
-func Map[A, B any](f func(A) B) func(ReaderIO[A]) ReaderIO[B] {
-	return R.Map[ReaderIO[A], ReaderIO[B]](f)
-}
-
-func MonadChain[A, B any](ma ReaderIO[A], f func(A) ReaderIO[B]) ReaderIO[B] {
-	return R.MonadChain(ma, f)
-}
-
-func Chain[A, B any](f func(A) ReaderIO[B]) func(ReaderIO[A]) ReaderIO[B] {
-	return R.Chain[ReaderIO[A]](f)
-}
-
-func Of[A any](a A) ReaderIO[A] {
-	return R.Of[ReaderIO[A]](a)
-}
-
-func MonadAp[A, B any](fab ReaderIO[func(A) B], fa ReaderIO[A]) ReaderIO[B] {
-	return R.MonadAp[ReaderIO[A], ReaderIO[B]](fab, fa)
-}
-
-func Ap[A, B any](fa ReaderIO[A]) func(ReaderIO[func(A) B]) ReaderIO[B] {
-	return R.Ap[ReaderIO[A], ReaderIO[B], ReaderIO[func(A) B]](fa)
-}
-
-func Ask() ReaderIO[context.Context] {
-	return R.Ask[ReaderIO[context.Context]]()
-}
-
-// Defer creates an IO by creating a brand new IO via a generator function, each time
-func Defer[A any](gen func() ReaderIO[A]) ReaderIO[A] {
-	return R.Defer[ReaderIO[A]](gen)
-}

context/readerio/reader_test.go

@@ -1,80 +0,0 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package readerio
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"testing"
-
-	F "github.com/IBM/fp-go/function"
-	IO "github.com/IBM/fp-go/io"
-	T "github.com/IBM/fp-go/tuple"
-	"github.com/stretchr/testify/assert"
-)
-
-func GoFunction(ctx context.Context, data string) IO.IO[string] {
-	return func() string {
-		return strings.ToUpper(data)
-	}
-}
-
-func GoIntFunction(ctx context.Context, data string, number int) IO.IO[string] {
-	return func() string {
-		return fmt.Sprintf("%s: %d", data, number)
-	}
-}
-
-func TestReaderFrom(t *testing.T) {
-	ctx := context.Background()
-	f := From1(GoFunction)
-
-	result := f("input")(ctx)
-
-	assert.Equal(t, result(), "INPUT")
-
-}
-
-func MyFinalResult(left, right string) string {
-	return fmt.Sprintf("%s-%s", left, right)
-}
-
-func TestReadersFrom(t *testing.T) {
-	ctx := context.Background()
-
-	f1 := From1(GoFunction)
-	f2 := From2(GoIntFunction)
-
-	result1 := f1("input")(ctx)
-	result2 := f2("input", 10)(ctx)
-
-	result3 := MyFinalResult(result1(), result2())
-
-	h := F.Pipe1(
-		SequenceT2(f1("input"), f2("input", 10)),
-		Map(T.Tupled2(MyFinalResult)),
-	)
-
-	composedResult := h(ctx)
-
-	assert.Equal(t, result1(), "INPUT")
-	assert.Equal(t, result2(), "input: 10")
-	assert.Equal(t, result3, "INPUT-input: 10")
-
-	assert.Equal(t, composedResult(), "INPUT-input: 10")
-
-}

context/readerio/sequence.go

@@ -1,57 +0,0 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package readerio
-
-import (
-	R "github.com/IBM/fp-go/readerio/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 ReaderIO[A]) ReaderIO[T.Tuple1[A]] {
-	return R.SequenceT1[
-		ReaderIO[A],
-		ReaderIO[T.Tuple1[A]],
-	](a)
-}
-
-func SequenceT2[A, B any](a ReaderIO[A], b ReaderIO[B]) ReaderIO[T.Tuple2[A, B]] {
-	return R.SequenceT2[
-		ReaderIO[A],
-		ReaderIO[B],
-		ReaderIO[T.Tuple2[A, B]],
-	](a, b)
-}
-
-func SequenceT3[A, B, C any](a ReaderIO[A], b ReaderIO[B], c ReaderIO[C]) ReaderIO[T.Tuple3[A, B, C]] {
-	return R.SequenceT3[
-		ReaderIO[A],
-		ReaderIO[B],
-		ReaderIO[C],
-		ReaderIO[T.Tuple3[A, B, C]],
-	](a, b, c)
-}
-
-func SequenceT4[A, B, C, D any](a ReaderIO[A], b ReaderIO[B], c ReaderIO[C], d ReaderIO[D]) ReaderIO[T.Tuple4[A, B, C, D]] {
-	return R.SequenceT4[
-		ReaderIO[A],
-		ReaderIO[B],
-		ReaderIO[C],
-		ReaderIO[D],
-		ReaderIO[T.Tuple4[A, B, C, D]],
-	](a, b, c, d)
-}

context/readerioeither/bracket.go

@@ -0,0 +1,37 @@
+// 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"
+	E "github.com/IBM/fp-go/either"
+)
+
+// Bracket makes sure that a resource is cleaned up in the event of an error. The release action is called regardless of
+// whether the body action returns and error or not.
+func Bracket[
+	A, B, ANY any](
+
+	acquire ReaderIOEither[A],
+	use func(A) ReaderIOEither[B],
+	release func(A, E.Either[error, B]) ReaderIOEither[ANY],
+) ReaderIOEither[B] {
+	return G.Bracket[ReaderIOEither[A], ReaderIOEither[B], ReaderIOEither[ANY]](
+		acquire,
+		use,
+		release,
+	)
+}

context/readerioeither/file/file.go

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

context/readerioeither/file/file_test.go

@@ -19,9 +19,7 @@ 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"
@@ -37,20 +35,17 @@ func getData(r RecordType) string {
 
 func ExampleReadFile() {
 
-	data := F.Pipe4(
+	data := F.Pipe3(
 		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
+	// Output:
+	// Right[<nil>, string](Carsten)
 }

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

context/readerioeither/file/tempfile_test.go

@@ -0,0 +1,47 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package file
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	RIOE "github.com/IBM/fp-go/context/readerioeither"
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestWithTempFile(t *testing.T) {
+
+	res := WithTempFile(onWriteAll[*os.File]([]byte("Carsten")))
+
+	assert.Equal(t, E.Of[error]([]byte("Carsten")), res(context.Background())())
+}
+
+func TestWithTempFileOnClosedFile(t *testing.T) {
+
+	res := WithTempFile(func(f *os.File) RIOE.ReaderIOEither[[]byte] {
+		return F.Pipe2(
+			f,
+			onWriteAll[*os.File]([]byte("Carsten")),
+			RIOE.ChainFirst(F.Constant1[[]byte](Close(f))),
+		)
+	})
+
+	assert.Equal(t, E.Of[error]([]byte("Carsten")), res(context.Background())())
+}

context/readerioeither/file/write.go

@@ -0,0 +1,57 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package file
+
+import (
+	"context"
+	"io"
+
+	RIOE "github.com/IBM/fp-go/context/readerioeither"
+	F "github.com/IBM/fp-go/function"
+)
+
+func onWriteAll[W io.Writer](data []byte) func(w W) RIOE.ReaderIOEither[[]byte] {
+	return func(w W) RIOE.ReaderIOEither[[]byte] {
+		return F.Pipe1(
+			RIOE.TryCatch(func(ctx context.Context) func() ([]byte, error) {
+				return func() ([]byte, error) {
+					_, err := w.Write(data)
+					return data, err
+				}
+			}),
+			RIOE.WithContext[[]byte],
+		)
+	}
+}
+
+// WriteAll uses a generator function to create a stream, writes data to it and closes it
+func WriteAll[W io.WriteCloser](data []byte) func(acquire RIOE.ReaderIOEither[W]) RIOE.ReaderIOEither[[]byte] {
+	onWrite := onWriteAll[W](data)
+	return func(onCreate RIOE.ReaderIOEither[W]) RIOE.ReaderIOEither[[]byte] {
+		return RIOE.WithResource[[]byte](
+			onCreate,
+			Close[W])(
+			onWrite,
+		)
+	}
+}
+
+// Write uses a generator function to create a stream, writes data to it and closes it
+func Write[R any, W io.WriteCloser](acquire RIOE.ReaderIOEither[W]) func(use func(W) RIOE.ReaderIOEither[R]) RIOE.ReaderIOEither[R] {
+	return RIOE.WithResource[R](
+		acquire,
+		Close[W])
+}

context/readerioeither/gen.go

@@ -2,7 +2,7 @@ package readerioeither
 
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-08-17 22:58:56.457404 +0200 CEST m=+0.024265101
+// 2023-10-23 08:30:39.012572 +0200 CEST m=+0.008846101
 
 import (
 	"context"

context/readerioeither/generic/bracket.go

@@ -0,0 +1,53 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	"context"
+
+	E "github.com/IBM/fp-go/either"
+	G "github.com/IBM/fp-go/internal/bracket"
+	I "github.com/IBM/fp-go/readerio/generic"
+)
+
+// Bracket makes sure that a resource is cleaned up in the event of an error. The release action is called regardless of
+// whether the body action returns and error or not.
+func Bracket[
+	GA ~func(context.Context) TA,
+	GB ~func(context.Context) TB,
+	GANY ~func(context.Context) TANY,
+
+	TA ~func() E.Either[error, A],
+	TB ~func() E.Either[error, B],
+	TANY ~func() E.Either[error, ANY],
+
+	A, B, ANY any](
+
+	acquire GA,
+	use func(A) GB,
+	release func(A, E.Either[error, B]) GANY,
+) GB {
+	return G.Bracket[GA, GB, GANY, E.Either[error, B], A, B](
+		I.Of[GB, TB, context.Context, E.Either[error, B]],
+		MonadChain[GA, GB, TA, TB, A, B],
+		I.MonadChain[GB, GB, TB, TB, context.Context, E.Either[error, B], E.Either[error, B]],
+		MonadChain[GANY, GB, TANY, TB, ANY, B],
+
+		acquire,
+		use,
+		release,
+	)
+}

context/readerioeither/generic/gen.go

@@ -2,7 +2,7 @@ package generic
 
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-08-17 22:58:56.457404 +0200 CEST m=+0.024265101
+// 2023-10-23 08:30:39.012572 +0200 CEST m=+0.008846101
 
 import (
 	"context"

context/readerioeither/generic/monoid.go

@@ -0,0 +1,56 @@
+//   Copyright (c) 2023 IBM Corp.
+//   All rights reserved.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package generic
+
+import (
+	"context"
+
+	ET "github.com/IBM/fp-go/either"
+	M "github.com/IBM/fp-go/monoid"
+)
+
+func ApplicativeMonoid[GRA ~func(context.Context) GIOA, GRFA ~func(context.Context) GIOFA, GIOA ~func() ET.Either[error, A], GIOFA ~func() ET.Either[error, func(A) A], A any](
+	m M.Monoid[A],
+) M.Monoid[GRA] {
+	return M.ApplicativeMonoid(
+		Of[GRA],
+		MonadMap[GRA, GRFA],
+		MonadAp[GRA, GRA, GRFA],
+		m,
+	)
+}
+
+func ApplicativeMonoidSeq[GRA ~func(context.Context) GIOA, GRFA ~func(context.Context) GIOFA, GIOA ~func() ET.Either[error, A], GIOFA ~func() ET.Either[error, func(A) A], A any](
+	m M.Monoid[A],
+) M.Monoid[GRA] {
+	return M.ApplicativeMonoid(
+		Of[GRA],
+		MonadMap[GRA, GRFA],
+		MonadApSeq[GRA, GRA, GRFA],
+		m,
+	)
+}
+
+func ApplicativeMonoidPar[GRA ~func(context.Context) GIOA, GRFA ~func(context.Context) GIOFA, GIOA ~func() ET.Either[error, A], GIOFA ~func() ET.Either[error, func(A) A], A any](
+	m M.Monoid[A],
+) M.Monoid[GRA] {
+	return M.ApplicativeMonoid(
+		Of[GRA],
+		MonadMap[GRA, GRFA],
+		MonadApPar[GRA, GRA, GRFA],
+		m,
+	)
+}

context/readerioeither/generic/reader.go

@@ -100,6 +100,28 @@ func Map[
 	return RIE.Map[GRA, GRB](f)
 }
 
+func MonadMapTo[
+	GRA ~func(context.Context) GIOA,
+	GRB ~func(context.Context) GIOB,
+
+	GIOA ~func() E.Either[error, A],
+	GIOB ~func() E.Either[error, B],
+
+	A, B any](fa GRA, b B) GRB {
+	return RIE.MonadMapTo[GRA, GRB](fa, b)
+}
+
+func MapTo[
+	GRA ~func(context.Context) GIOA,
+	GRB ~func(context.Context) GIOB,
+
+	GIOA ~func() E.Either[error, A],
+	GIOB ~func() E.Either[error, B],
+
+	A, B any](b B) func(GRA) GRB {
+	return RIE.MapTo[GRA, GRB](b)
+}
+
 func MonadChain[
 	GRA ~func(context.Context) GIOA,
 	GRB ~func(context.Context) GIOB,
@@ -410,10 +432,10 @@ func FromIOEither[
 
 func FromIO[
 	GRA ~func(context.Context) GIOA,
-	GIOA ~func() E.Either[error, A],
-
 	GIOB ~func() A,
 
+	GIOA ~func() E.Either[error, A],
+
 	A any](t GIOB) GRA {
 	return RIE.FromIO[GRA](t)
 }
@@ -458,6 +480,34 @@ func ChainIOK[
 	return RIE.ChainIOK[GRA, GRB](f)
 }
 
+func MonadChainReaderIOK[
+	GRB ~func(context.Context) GIOB,
+	GRA ~func(context.Context) GIOA,
+	GRIO ~func(context.Context) GIO,
+
+	GIOA ~func() E.Either[error, A],
+	GIOB ~func() E.Either[error, B],
+
+	GIO ~func() B,
+
+	A, B any](ma GRA, f func(A) GRIO) GRB {
+	return RIE.MonadChainReaderIOK[GRA, GRB](ma, f)
+}
+
+func ChainReaderIOK[
+	GRB ~func(context.Context) GIOB,
+	GRA ~func(context.Context) GIOA,
+	GRIO ~func(context.Context) GIO,
+
+	GIOA ~func() E.Either[error, A],
+	GIOB ~func() E.Either[error, B],
+
+	GIO ~func() B,
+
+	A, B any](f func(A) GRIO) func(ma GRA) GRB {
+	return RIE.ChainReaderIOK[GRA, GRB](f)
+}
+
 func MonadChainFirstIOK[
 	GRA ~func(context.Context) GIOA,
 	GIOA ~func() E.Either[error, A],
@@ -521,7 +571,7 @@ func Timer[
 ](delay time.Duration) GRA {
 	return F.Pipe2(
 		IO.Now[func() time.Time](),
-		FromIO[GRA, GIOA, func() time.Time],
+		FromIO[GRA, func() time.Time],
 		Delay[GRA](delay),
 	)
 }
@@ -543,3 +593,82 @@ func TryCatch[
 	A any](f func(context.Context) func() (A, error)) GRA {
 	return RIE.TryCatch[GRA](f, ER.IdentityError)
 }
+
+func MonadAlt[LAZY ~func() GEA, GEA ~func(context.Context) GIOA, GIOA ~func() E.Either[error, A], A any](first GEA, second LAZY) GEA {
+	return RIE.MonadAlt(first, second)
+}
+
+func Alt[LAZY ~func() GEA, GEA ~func(context.Context) GIOA, GIOA ~func() E.Either[error, A], A any](second LAZY) func(GEA) GEA {
+	return RIE.Alt(second)
+}
+
+// Memoize computes the value of the provided monad lazily but exactly once
+// The context used to compute the value is the context of the first call, so do not use this
+// method if the value has a functional dependency on the content of the context
+func Memoize[
+	GRA ~func(context.Context) GIOA,
+	GIOA ~func() E.Either[error, A],
+	A any](rdr GRA) GRA {
+	return RIE.Memoize[GRA](rdr)
+}
+
+func Flatten[
+	GGRA ~func(context.Context) GGIOA,
+	GGIOA ~func() E.Either[error, GRA],
+	GRA ~func(context.Context) GIOA,
+	GIOA ~func() E.Either[error, A],
+	A any](rdr GGRA) GRA {
+	return RIE.Flatten[GRA](rdr)
+}
+
+func MonadFromReaderIO[
+	GRIOEA ~func(context.Context) GIOEA,
+	GIOEA ~func() E.Either[error, A],
+
+	GRIOA ~func(context.Context) GIOA,
+	GIOA ~func() A,
+
+	A any](a A, f func(A) GRIOA) GRIOEA {
+	return RIE.MonadFromReaderIO[GRIOEA](a, f)
+}
+
+func FromReaderIO[
+	GRIOEA ~func(context.Context) GIOEA,
+	GIOEA ~func() E.Either[error, A],
+
+	GRIOA ~func(context.Context) GIOA,
+	GIOA ~func() A,
+
+	A any](f func(A) GRIOA) func(A) GRIOEA {
+	return RIE.FromReaderIO[GRIOEA](f)
+}
+
+func RightReaderIO[
+	GRIOEA ~func(context.Context) GIOEA,
+	GIOEA ~func() E.Either[error, A],
+
+	GRIOA ~func(context.Context) GIOA,
+	GIOA ~func() A,
+
+	A any](ma GRIOA) GRIOEA {
+	return RIE.RightReaderIO[GRIOEA](ma)
+}
+
+func LeftReaderIO[
+	GRIOEA ~func(context.Context) GIOEA,
+	GIOEA ~func() E.Either[error, A],
+
+	GRIOE ~func(context.Context) GIOE,
+	GIOE ~func() error,
+
+	A any](ma GRIOE) GRIOEA {
+	return RIE.LeftReaderIO[GRIOEA](ma)
+}
+
+func MonadFlap[GREAB ~func(context.Context) GEAB, GREB ~func(context.Context) GEB, GEAB ~func() E.Either[error, func(A) B], GEB ~func() E.Either[error, B], B, A any](fab GREAB, a A) GREB {
+	return RIE.MonadFlap[GREAB, GREB](fab, a)
+}
+
+func Flap[GREAB ~func(context.Context) GEAB, GREB ~func(context.Context) GEB, GEAB ~func() E.Either[error, func(A) B], GEB ~func() E.Either[error, B], B, A any](a A) func(GREAB) GREB {
+	return RIE.Flap[GREAB, GREB](a)
+}

context/readerioeither/generic/semigroup.go

@@ -13,18 +13,17 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
-package reader
+package generic
 
 import (
-	R "github.com/IBM/fp-go/reader/generic"
+	"context"
+
+	ET "github.com/IBM/fp-go/either"
+	S "github.com/IBM/fp-go/semigroup"
 )
 
-// TraverseArray transforms an array
-func TraverseArray[A, B any](f func(A) Reader[B]) func([]A) Reader[[]B] {
-	return R.TraverseArray[Reader[B], Reader[[]B], []A](f)
-}
-
-// SequenceArray converts a homogeneous sequence of either into an either of sequence
-func SequenceArray[A any](ma []Reader[A]) Reader[[]A] {
-	return R.SequenceArray[Reader[A], Reader[[]A]](ma)
+func AltSemigroup[GRA ~func(context.Context) GIOA, GIOA ~func() ET.Either[error, A], A any]() S.Semigroup[GRA] {
+	return S.AltSemigroup(
+		MonadAlt[func() GRA],
+	)
 }

context/readerioeither/generic/sync.go

@@ -0,0 +1,44 @@
+// 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"
+	F "github.com/IBM/fp-go/function"
+	IO "github.com/IBM/fp-go/io/generic"
+)
+
+// WithLock executes the provided IO operation in the scope of a lock
+func WithLock[
+	GRA ~func(context.Context) GIOA,
+	GIOA ~func() E.Either[error, A],
+	GRCANCEL ~func(context.Context) GIOCANCEL,
+	GIOCANCEL ~func() E.Either[error, context.CancelFunc],
+	A any](lock GRCANCEL) func(fa GRA) GRA {
+
+	type GRANY func(ctx context.Context) func() E.Either[error, any]
+	type IOANY func() any
+
+	return F.Flow2(
+		F.Constant1[context.CancelFunc, GRA],
+		WithResource[GRA, GRCANCEL, GRANY](lock, F.Flow2(
+			IO.FromImpure[IOANY, context.CancelFunc],
+			FromIO[GRANY, IOANY],
+		)),
+	)
+}

context/readerioeither/generic/traverse.go

@@ -62,6 +62,25 @@ func TraverseArray[
 	)
 }
 
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[
+	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](f func(int, A) GRB) func(AS) GRBS {
+
+	return RA.TraverseWithIndex[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
 func SequenceArray[
 	AS ~[]A,
@@ -115,6 +134,26 @@ func TraverseRecord[K comparable,
 	)
 }
 
+// TraverseRecordWithIndex transforms a record
+func TraverseRecordWithIndex[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](f func(K, A) GRB) func(AS) GRBS {
+
+	return RR.TraverseWithIndex[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
 func SequenceRecord[K comparable,
 	AS ~map[K]A,
@@ -127,3 +166,289 @@ func SequenceRecord[K comparable,
 
 	return MonadTraverseRecord[K, GAS, GRAS](ma, F.Identity[GRA])
 }
+
+// MonadTraverseArraySeq transforms an array
+func MonadTraverseArraySeq[
+	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],
+		ApSeq[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		as, f,
+	)
+}
+
+// TraverseArraySeq transforms an array
+func TraverseArraySeq[
+	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](f func(A) GRB) func(AS) GRBS {
+
+	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],
+		ApSeq[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		f,
+	)
+}
+
+// TraverseArrayWithIndexSeq transforms an array
+func TraverseArrayWithIndexSeq[
+	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](f func(int, A) GRB) func(AS) GRBS {
+
+	return RA.TraverseWithIndex[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],
+		ApSeq[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		f,
+	)
+}
+
+// SequenceArraySeq converts a homogeneous sequence of either into an either of sequence
+func SequenceArraySeq[
+	AS ~[]A,
+	GAS ~[]GRA,
+	GRAS ~func(context.Context) GIOAS,
+	GRA ~func(context.Context) GIOA,
+	GIOAS ~func() E.Either[error, AS],
+	GIOA ~func() E.Either[error, A],
+	A any](ma GAS) GRAS {
+
+	return MonadTraverseArraySeq[GAS, GRAS](ma, F.Identity[GRA])
+}
+
+// MonadTraverseRecordSeq transforms a record
+func MonadTraverseRecordSeq[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],
+		ApSeq[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		ma, f,
+	)
+}
+
+// TraverseRecordSeq transforms a record
+func TraverseRecordSeq[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](f func(A) GRB) func(AS) GRBS {
+
+	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],
+		ApSeq[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		f,
+	)
+}
+
+// TraverseRecordWithIndexSeq transforms a record
+func TraverseRecordWithIndexSeq[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](f func(K, A) GRB) func(AS) GRBS {
+
+	return RR.TraverseWithIndex[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],
+		ApSeq[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		f,
+	)
+}
+
+// SequenceRecordSeq converts a homogeneous sequence of either into an either of sequence
+func SequenceRecordSeq[K comparable,
+	AS ~map[K]A,
+	GAS ~map[K]GRA,
+	GRAS ~func(context.Context) GIOAS,
+	GRA ~func(context.Context) GIOA,
+	GIOAS ~func() E.Either[error, AS],
+	GIOA ~func() E.Either[error, A],
+	A any](ma GAS) GRAS {
+
+	return MonadTraverseRecordSeq[K, GAS, GRAS](ma, F.Identity[GRA])
+}
+
+// MonadTraverseArrayPar transforms an array
+func MonadTraverseArrayPar[
+	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],
+		ApPar[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		as, f,
+	)
+}
+
+// TraverseArrayPar transforms an array
+func TraverseArrayPar[
+	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](f func(A) GRB) func(AS) GRBS {
+
+	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],
+		ApPar[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		f,
+	)
+}
+
+// TraverseArrayWithIndexPar transforms an array
+func TraverseArrayWithIndexPar[
+	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](f func(int, A) GRB) func(AS) GRBS {
+
+	return RA.TraverseWithIndex[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],
+		ApPar[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		f,
+	)
+}
+
+// SequenceArrayPar converts a homogeneous sequence of either into an either of sequence
+func SequenceArrayPar[
+	AS ~[]A,
+	GAS ~[]GRA,
+	GRAS ~func(context.Context) GIOAS,
+	GRA ~func(context.Context) GIOA,
+	GIOAS ~func() E.Either[error, AS],
+	GIOA ~func() E.Either[error, A],
+	A any](ma GAS) GRAS {
+
+	return MonadTraverseArrayPar[GAS, GRAS](ma, F.Identity[GRA])
+}
+
+// MonadTraverseRecordPar transforms a record
+func MonadTraverseRecordPar[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],
+		ApPar[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		ma, f,
+	)
+}
+
+// TraverseRecordPar transforms a record
+func TraverseRecordPar[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](f func(A) GRB) func(AS) GRBS {
+
+	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],
+		ApPar[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		f,
+	)
+}
+
+// TraverseRecordWithIndexPar transforms a record
+func TraverseRecordWithIndexPar[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](f func(K, A) GRB) func(AS) GRBS {
+
+	return RR.TraverseWithIndex[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],
+		ApPar[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		f,
+	)
+}
+
+// SequenceRecordPar converts a homogeneous sequence of either into an either of sequence
+func SequenceRecordPar[K comparable,
+	AS ~map[K]A,
+	GAS ~map[K]GRA,
+	GRAS ~func(context.Context) GIOAS,
+	GRA ~func(context.Context) GIOA,
+	GIOAS ~func() E.Either[error, AS],
+	GIOA ~func() E.Either[error, A],
+	A any](ma GAS) GRAS {
+
+	return MonadTraverseRecordPar[K, GAS, GRAS](ma, F.Identity[GRA])
+}

context/readerioeither/monoid.go

@@ -0,0 +1,56 @@
+//   Copyright (c) 2023 IBM Corp.
+//   All rights reserved.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package readerioeither
+
+import (
+	G "github.com/IBM/fp-go/context/readerioeither/generic"
+	L "github.com/IBM/fp-go/lazy"
+	M "github.com/IBM/fp-go/monoid"
+)
+
+// ApplicativeMonoid returns a [Monoid] that concatenates [ReaderIOEither] instances via their applicative
+func ApplicativeMonoid[A any](m M.Monoid[A]) M.Monoid[ReaderIOEither[A]] {
+	return G.ApplicativeMonoid[ReaderIOEither[A], ReaderIOEither[func(A) A]](m)
+}
+
+// ApplicativeMonoidSeq returns a [Monoid] that concatenates [ReaderIOEither] instances via their applicative
+func ApplicativeMonoidSeq[A any](m M.Monoid[A]) M.Monoid[ReaderIOEither[A]] {
+	return G.ApplicativeMonoidSeq[ReaderIOEither[A], ReaderIOEither[func(A) A]](m)
+}
+
+// ApplicativeMonoidPar returns a [Monoid] that concatenates [ReaderIOEither] instances via their applicative
+func ApplicativeMonoidPar[A any](m M.Monoid[A]) M.Monoid[ReaderIOEither[A]] {
+	return G.ApplicativeMonoidPar[ReaderIOEither[A], ReaderIOEither[func(A) A]](m)
+}
+
+// AlternativeMonoid is the alternative [Monoid] for [ReaderIOEither]
+func AlternativeMonoid[A any](m M.Monoid[A]) M.Monoid[ReaderIOEither[A]] {
+	return M.AlternativeMonoid(
+		Of[A],
+		MonadMap[A, func(A) A],
+		MonadAp[A, A],
+		MonadAlt[A],
+		m,
+	)
+}
+
+// AltMonoid is the alternative [Monoid] for an [ReaderIOEither]
+func AltMonoid[A any](zero L.Lazy[ReaderIOEither[A]]) M.Monoid[ReaderIOEither[A]] {
+	return M.AltMonoid(
+		zero,
+		MonadAlt[A],
+	)
+}

context/readerioeither/reader.go

@@ -19,12 +19,11 @@ import (
 	"context"
 	"time"
 
-	R "github.com/IBM/fp-go/context/reader"
-	RIO "github.com/IBM/fp-go/context/readerio"
 	G "github.com/IBM/fp-go/context/readerioeither/generic"
 	ET "github.com/IBM/fp-go/either"
 	IO "github.com/IBM/fp-go/io"
 	IOE "github.com/IBM/fp-go/ioeither"
+	L "github.com/IBM/fp-go/lazy"
 	O "github.com/IBM/fp-go/option"
 )
 
@@ -32,14 +31,6 @@ func FromEither[A any](e ET.Either[error, A]) ReaderIOEither[A] {
 	return G.FromEither[ReaderIOEither[A]](e)
 }
 
-func RightReader[A any](r R.Reader[A]) ReaderIOEither[A] {
-	return G.RightReader[ReaderIOEither[A]](r)
-}
-
-func LeftReader[A any](l R.Reader[error]) ReaderIOEither[A] {
-	return G.LeftReader[ReaderIOEither[A]](l)
-}
-
 func Left[A any](l error) ReaderIOEither[A] {
 	return G.Left[ReaderIOEither[A]](l)
 }
@@ -48,10 +39,6 @@ func Right[A any](r A) ReaderIOEither[A] {
 	return G.Right[ReaderIOEither[A]](r)
 }
 
-func FromReader[A any](r R.Reader[A]) ReaderIOEither[A] {
-	return G.FromReader[ReaderIOEither[A]](r)
-}
-
 func MonadMap[A, B any](fa ReaderIOEither[A], f func(A) B) ReaderIOEither[B] {
 	return G.MonadMap[ReaderIOEither[A], ReaderIOEither[B]](fa, f)
 }
@@ -60,6 +47,14 @@ func Map[A, B any](f func(A) B) func(ReaderIOEither[A]) ReaderIOEither[B] {
 	return G.Map[ReaderIOEither[A], ReaderIOEither[B]](f)
 }
 
+func MonadMapTo[A, B any](fa ReaderIOEither[A], b B) ReaderIOEither[B] {
+	return G.MonadMapTo[ReaderIOEither[A], ReaderIOEither[B]](fa, b)
+}
+
+func MapTo[A, B any](b B) func(ReaderIOEither[A]) ReaderIOEither[B] {
+	return G.MapTo[ReaderIOEither[A], ReaderIOEither[B]](b)
+}
+
 func MonadChain[A, B any](ma ReaderIOEither[A], f func(A) ReaderIOEither[B]) ReaderIOEither[B] {
 	return G.MonadChain(ma, f)
 }
@@ -94,30 +89,14 @@ func FromPredicate[A any](pred func(A) bool, onFalse func(A) error) func(A) Read
 	return G.FromPredicate[ReaderIOEither[A]](pred, onFalse)
 }
 
-func Fold[A, B any](onLeft func(error) RIO.ReaderIO[B], onRight func(A) RIO.ReaderIO[B]) func(ReaderIOEither[A]) RIO.ReaderIO[B] {
-	return G.Fold[RIO.ReaderIO[B], ReaderIOEither[A]](onLeft, onRight)
-}
-
-func GetOrElse[A any](onLeft func(error) RIO.ReaderIO[A]) func(ReaderIOEither[A]) RIO.ReaderIO[A] {
-	return G.GetOrElse[RIO.ReaderIO[A], ReaderIOEither[A]](onLeft)
-}
-
 func OrElse[A any](onLeft func(error) ReaderIOEither[A]) func(ReaderIOEither[A]) ReaderIOEither[A] {
 	return G.OrElse[ReaderIOEither[A]](onLeft)
 }
 
-func OrLeft[A any](onLeft func(error) RIO.ReaderIO[error]) func(ReaderIOEither[A]) ReaderIOEither[A] {
-	return G.OrLeft[ReaderIOEither[A], RIO.ReaderIO[error]](onLeft)
-}
-
 func Ask() ReaderIOEither[context.Context] {
 	return G.Ask[ReaderIOEither[context.Context]]()
 }
 
-func Asks[A any](r R.Reader[A]) ReaderIOEither[A] {
-	return G.Asks[ReaderIOEither[A]](r)
-}
-
 func MonadChainEitherK[A, B any](ma ReaderIOEither[A], f func(A) ET.Either[error, B]) ReaderIOEither[B] {
 	return G.MonadChainEitherK[ReaderIOEither[A], ReaderIOEither[B]](ma, f)
 }
@@ -146,6 +125,10 @@ func FromIO[A any](t IO.IO[A]) ReaderIOEither[A] {
 	return G.FromIO[ReaderIOEither[A]](t)
 }
 
+func FromLazy[A any](t L.Lazy[A]) ReaderIOEither[A] {
+	return G.FromIO[ReaderIOEither[A]](t)
+}
+
 // Never returns a 'ReaderIOEither' that never returns, except if its context gets canceled
 func Never[A any]() ReaderIOEither[A] {
 	return G.Never[ReaderIOEither[A]]()
@@ -182,7 +165,7 @@ func Timer(delay time.Duration) ReaderIOEither[time.Time] {
 }
 
 // Defer creates an IO by creating a brand new IO via a generator function, each time
-func Defer[A any](gen func() ReaderIOEither[A]) ReaderIOEither[A] {
+func Defer[A any](gen L.Lazy[ReaderIOEither[A]]) ReaderIOEither[A] {
 	return G.Defer[ReaderIOEither[A]](gen)
 }
 
@@ -190,3 +173,34 @@ func Defer[A any](gen func() ReaderIOEither[A]) ReaderIOEither[A] {
 func TryCatch[A any](f func(context.Context) func() (A, error)) ReaderIOEither[A] {
 	return G.TryCatch[ReaderIOEither[A]](f)
 }
+
+// MonadAlt identifies an associative operation on a type constructor
+func MonadAlt[A any](first ReaderIOEither[A], second L.Lazy[ReaderIOEither[A]]) ReaderIOEither[A] {
+	return G.MonadAlt(first, second)
+}
+
+// Alt identifies an associative operation on a type constructor
+func Alt[A any](second L.Lazy[ReaderIOEither[A]]) func(ReaderIOEither[A]) ReaderIOEither[A] {
+	return G.Alt(second)
+}
+
+// Memoize computes the value of the provided [ReaderIOEither] monad lazily but exactly once
+// The context used to compute the value is the context of the first call, so do not use this
+// method if the value has a functional dependency on the content of the context
+func Memoize[A any](rdr ReaderIOEither[A]) ReaderIOEither[A] {
+	return G.Memoize[ReaderIOEither[A]](rdr)
+}
+
+// Flatten converts a nested [ReaderIOEither] into a [ReaderIOEither]
+func Flatten[
+	A any](rdr ReaderIOEither[ReaderIOEither[A]]) ReaderIOEither[A] {
+	return G.Flatten[ReaderIOEither[ReaderIOEither[A]]](rdr)
+}
+
+func MonadFlap[B, A any](fab ReaderIOEither[func(A) B], a A) ReaderIOEither[B] {
+	return G.MonadFlap[ReaderIOEither[func(A) B], ReaderIOEither[B]](fab, a)
+}
+
+func Flap[B, A any](a A) func(ReaderIOEither[func(A) B]) ReaderIOEither[B] {
+	return G.Flap[ReaderIOEither[func(A) B], ReaderIOEither[B]](a)
+}

context/readerioeither/reader_test.go

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

context/readerioeither/semigroup.go

@@ -0,0 +1,26 @@
+//   Copyright (c) 2023 IBM Corp.
+//   All rights reserved.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package readerioeither
+
+import (
+	G "github.com/IBM/fp-go/context/readerioeither/generic"
+	S "github.com/IBM/fp-go/semigroup"
+)
+
+// AltSemigroup is a [Semigroup] that tries the first item and then the second one using an alternative
+func AltSemigroup[A any]() S.Semigroup[ReaderIOEither[A]] {
+	return G.AltSemigroup[ReaderIOEither[A]]()
+}

context/readerioeither/sync.go

@@ -13,14 +13,15 @@
 // 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
+package readerioeither
 
 import (
 	"context"
 
-	R "github.com/IBM/fp-go/reader"
+	G "github.com/IBM/fp-go/context/readerioeither/generic"
 )
 
-// Reader is a specialization of the Reader monad assuming a golang context as the context of the monad
-type Reader[A any] R.Reader[context.Context, A]
+// WithLock executes the provided IO operation in the scope of a lock
+func WithLock[A any](lock ReaderIOEither[context.CancelFunc]) func(fa ReaderIOEither[A]) ReaderIOEither[A] {
+	return G.WithLock[ReaderIOEither[A]](lock)
+}

context/readerioeither/traverse.go

@@ -24,6 +24,11 @@ func TraverseArray[A, B any](f func(A) ReaderIOEither[B]) func([]A) ReaderIOEith
 	return G.TraverseArray[[]A, ReaderIOEither[[]B]](f)
 }
 
+// TraverseArrayWithIndex uses transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]]
+func TraverseArrayWithIndex[A, B any](f func(int, A) ReaderIOEither[B]) func([]A) ReaderIOEither[[]B] {
+	return G.TraverseArrayWithIndex[[]A, ReaderIOEither[[]B]](f)
+}
+
 // SequenceArray converts a homogeneous sequence of either into an either of sequence
 func SequenceArray[A any](ma []ReaderIOEither[A]) ReaderIOEither[[]A] {
 	return G.SequenceArray[[]A, []ReaderIOEither[A], ReaderIOEither[[]A]](ma)
@@ -34,7 +39,72 @@ func TraverseRecord[K comparable, A, B any](f func(A) ReaderIOEither[B]) func(ma
 	return G.TraverseRecord[K, map[K]A, ReaderIOEither[map[K]B]](f)
 }
 
+// TraverseRecordWithIndex uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
+func TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) ReaderIOEither[B]) func(map[K]A) ReaderIOEither[map[K]B] {
+	return G.TraverseRecordWithIndex[K, map[K]A, ReaderIOEither[map[K]B]](f)
+}
+
 // SequenceRecord converts a homogeneous sequence of either into an either of sequence
 func SequenceRecord[K comparable, A any](ma map[K]ReaderIOEither[A]) ReaderIOEither[map[K]A] {
 	return G.SequenceRecord[K, map[K]A, map[K]ReaderIOEither[A], ReaderIOEither[map[K]A]](ma)
 }
+
+// TraverseArraySeq uses transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]]
+func TraverseArraySeq[A, B any](f func(A) ReaderIOEither[B]) func([]A) ReaderIOEither[[]B] {
+	return G.TraverseArraySeq[[]A, ReaderIOEither[[]B]](f)
+}
+
+// TraverseArrayWithIndexSeq uses transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]]
+func TraverseArrayWithIndexSeq[A, B any](f func(int, A) ReaderIOEither[B]) func([]A) ReaderIOEither[[]B] {
+	return G.TraverseArrayWithIndexSeq[[]A, ReaderIOEither[[]B]](f)
+}
+
+// SequenceArraySeq converts a homogeneous sequence of either into an either of sequence
+func SequenceArraySeq[A any](ma []ReaderIOEither[A]) ReaderIOEither[[]A] {
+	return G.SequenceArraySeq[[]A, []ReaderIOEither[A], ReaderIOEither[[]A]](ma)
+}
+
+// TraverseRecordSeq uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
+func TraverseRecordSeq[K comparable, A, B any](f func(A) ReaderIOEither[B]) func(map[K]A) ReaderIOEither[map[K]B] {
+	return G.TraverseRecordSeq[K, map[K]A, ReaderIOEither[map[K]B]](f)
+}
+
+// TraverseRecordWithIndexSeq uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
+func TraverseRecordWithIndexSeq[K comparable, A, B any](f func(K, A) ReaderIOEither[B]) func(map[K]A) ReaderIOEither[map[K]B] {
+	return G.TraverseRecordWithIndexSeq[K, map[K]A, ReaderIOEither[map[K]B]](f)
+}
+
+// SequenceRecordSeq converts a homogeneous sequence of either into an either of sequence
+func SequenceRecordSeq[K comparable, A any](ma map[K]ReaderIOEither[A]) ReaderIOEither[map[K]A] {
+	return G.SequenceRecordSeq[K, map[K]A, map[K]ReaderIOEither[A], ReaderIOEither[map[K]A]](ma)
+}
+
+// TraverseArrayPar uses transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]]
+func TraverseArrayPar[A, B any](f func(A) ReaderIOEither[B]) func([]A) ReaderIOEither[[]B] {
+	return G.TraverseArrayPar[[]A, ReaderIOEither[[]B]](f)
+}
+
+// TraverseArrayWithIndexPar uses transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]]
+func TraverseArrayWithIndexPar[A, B any](f func(int, A) ReaderIOEither[B]) func([]A) ReaderIOEither[[]B] {
+	return G.TraverseArrayWithIndexPar[[]A, ReaderIOEither[[]B]](f)
+}
+
+// SequenceArrayPar converts a homogeneous sequence of either into an either of sequence
+func SequenceArrayPar[A any](ma []ReaderIOEither[A]) ReaderIOEither[[]A] {
+	return G.SequenceArrayPar[[]A, []ReaderIOEither[A], ReaderIOEither[[]A]](ma)
+}
+
+// TraverseRecordPar uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
+func TraverseRecordPar[K comparable, A, B any](f func(A) ReaderIOEither[B]) func(map[K]A) ReaderIOEither[map[K]B] {
+	return G.TraverseRecordPar[K, map[K]A, ReaderIOEither[map[K]B]](f)
+}
+
+// TraverseRecordWithIndexPar uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
+func TraverseRecordWithIndexPar[K comparable, A, B any](f func(K, A) ReaderIOEither[B]) func(map[K]A) ReaderIOEither[map[K]B] {
+	return G.TraverseRecordWithIndexPar[K, map[K]A, ReaderIOEither[map[K]B]](f)
+}
+
+// SequenceRecordPar converts a homogeneous sequence of either into an either of sequence
+func SequenceRecordPar[K comparable, A any](ma map[K]ReaderIOEither[A]) ReaderIOEither[map[K]A] {
+	return G.SequenceRecordPar[K, map[K]A, map[K]ReaderIOEither[A], ReaderIOEither[map[K]A]](ma)
+}

coverage.bat

@@ -0,0 +1,2 @@
+@echo off
+go tool cover -html=build/cover.out -o build/cover.html

di/erasure/injector.go

@@ -0,0 +1,168 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package erasure
+
+import (
+	A "github.com/IBM/fp-go/array"
+	"github.com/IBM/fp-go/errors"
+	F "github.com/IBM/fp-go/function"
+	I "github.com/IBM/fp-go/identity"
+	IG "github.com/IBM/fp-go/identity/generic"
+	IOE "github.com/IBM/fp-go/ioeither"
+	L "github.com/IBM/fp-go/lazy"
+	O "github.com/IBM/fp-go/option"
+	R "github.com/IBM/fp-go/record"
+	T "github.com/IBM/fp-go/tuple"
+
+	"sync"
+)
+
+func providerToEntry(p Provider) T.Tuple2[string, ProviderFactory] {
+	return T.MakeTuple2(p.Provides().Id(), p.Factory())
+}
+
+func itemProviderToMap(p Provider) map[string][]ProviderFactory {
+	return R.Singleton(p.Provides().Id(), A.Of(p.Factory()))
+}
+
+var (
+	// missingProviderError returns a [ProviderFactory] that fails due to a missing dependency
+	missingProviderError = F.Flow4(
+		Dependency.String,
+		errors.OnSome[string]("no provider for dependency [%s]"),
+		IOE.Left[any, error],
+		F.Constant1[InjectableFactory, IOE.IOEither[error, any]],
+	)
+
+	// missingProviderErrorOrDefault returns the default [ProviderFactory] or an error
+	missingProviderErrorOrDefault = F.Flow3(
+		T.Replicate2[Dependency],
+		T.Map2(Dependency.ProviderFactory, F.Flow2(missingProviderError, F.Constant[ProviderFactory])),
+		T.Tupled2(O.MonadGetOrElse[ProviderFactory]),
+	)
+
+	emptyMulti any = A.Empty[any]()
+
+	// emptyMultiDependency returns a [ProviderFactory] for an empty, multi dependency
+	emptyMultiDependency = F.Constant1[Dependency](F.Constant1[InjectableFactory](IOE.Of[error](emptyMulti)))
+
+	// handleMissingProvider covers the case of a missing provider. It either
+	// returns an error or an empty multi value provider
+	handleMissingProvider = F.Flow2(
+		F.Ternary(isMultiDependency, emptyMultiDependency, missingProviderErrorOrDefault),
+		F.Constant[ProviderFactory],
+	)
+
+	// mergeItemProviders is a monoid for item provider factories
+	mergeItemProviders = R.UnionMonoid[string](A.Semigroup[ProviderFactory]())
+
+	// mergeProviders is a monoid for provider factories
+	mergeProviders = R.UnionLastMonoid[string, ProviderFactory]()
+
+	// collectItemProviders create a provider map for item providers
+	collectItemProviders = F.Flow2(
+		A.FoldMap[Provider](mergeItemProviders)(itemProviderToMap),
+		R.Map[string](itemProviderFactory),
+	)
+
+	// collectProviders collects non-item providers
+	collectProviders = F.Flow2(
+		A.Map(providerToEntry),
+		R.FromEntries[string, ProviderFactory],
+	)
+
+	// assembleProviders constructs the provider map for item and non-item providers
+	assembleProviders = F.Flow3(
+		A.Partition(isItemProvider),
+		T.Map2(collectProviders, collectItemProviders),
+		T.Tupled2(mergeProviders.Concat),
+	)
+)
+
+// isMultiDependency tests if a dependency is a container dependency
+func isMultiDependency(dep Dependency) bool {
+	return dep.Flag()&Multi == Multi
+}
+
+// isItemProvider tests if a provivder provides a single item
+func isItemProvider(provider Provider) bool {
+	return provider.Provides().Flag()&Item == Item
+}
+
+// itemProviderFactory combines multiple factories into one, returning an array
+func itemProviderFactory(fcts []ProviderFactory) ProviderFactory {
+	return func(inj InjectableFactory) IOE.IOEither[error, any] {
+		return F.Pipe2(
+			fcts,
+			IOE.TraverseArray(I.Flap[IOE.IOEither[error, any]](inj)),
+			IOE.Map[error](F.ToAny[[]any]),
+		)
+	}
+}
+
+// MakeInjector creates an [InjectableFactory] based on a set of [Provider]s
+func MakeInjector(providers []Provider) InjectableFactory {
+
+	type Result = IOE.IOEither[error, any]
+	type LazyResult = L.Lazy[Result]
+
+	// resolved stores the values resolved so far, key is the string ID
+	// of the token, value is a lazy result
+	var resolved sync.Map
+
+	// provide a mapping for all providers
+	factoryById := assembleProviders(providers)
+
+	// the actual factory, we need lazy initialization
+	var injFct InjectableFactory
+
+	// lazy initialization, so we can cross reference it
+	injFct = func(token Dependency) Result {
+
+		key := token.Id()
+
+		// according to https://github.com/golang/go/issues/44159 this
+		// is the best way to use the sync map
+		actual, loaded := resolved.Load(key)
+		if !loaded {
+
+			computeResult := L.MakeLazy(func() Result {
+				return F.Pipe5(
+					token,
+					T.Replicate2[Dependency],
+					T.Map2(F.Flow3(
+						Dependency.Id,
+						R.Lookup[ProviderFactory, string],
+						I.Ap[O.Option[ProviderFactory]](factoryById),
+					), handleMissingProvider),
+					T.Tupled2(O.MonadGetOrElse[ProviderFactory]),
+					IG.Ap[ProviderFactory](injFct),
+					IOE.Memoize[error, any],
+				)
+			})
+
+			actual, _ = resolved.LoadOrStore(key, F.Pipe1(
+				computeResult,
+				L.Memoize[Result],
+			))
+		}
+
+		return actual.(LazyResult)()
+	}
+
+	return injFct
+}

di/erasure/provider.go

@@ -0,0 +1,178 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package erasure
+
+import (
+	"fmt"
+
+	A "github.com/IBM/fp-go/array"
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	I "github.com/IBM/fp-go/identity"
+	IO "github.com/IBM/fp-go/io"
+	IOG "github.com/IBM/fp-go/io/generic"
+	IOE "github.com/IBM/fp-go/ioeither"
+	IOO "github.com/IBM/fp-go/iooption"
+	Int "github.com/IBM/fp-go/number/integer"
+	O "github.com/IBM/fp-go/option"
+	R "github.com/IBM/fp-go/record"
+)
+
+type (
+	InjectableFactory = func(Dependency) IOE.IOEither[error, any]
+	ProviderFactory   = func(InjectableFactory) IOE.IOEither[error, any]
+
+	paramIndex = map[int]int
+	paramValue = map[int]any
+	handler    = func(paramIndex) func([]IOE.IOEither[error, any]) IOE.IOEither[error, paramValue]
+	mapping    = map[int]paramIndex
+
+	Provider interface {
+		fmt.Stringer
+		// Provides returns the [Dependency] implemented by this provider
+		Provides() Dependency
+		// Factory returns s function that can create an instance of the dependency based on an [InjectableFactory]
+		Factory() ProviderFactory
+	}
+
+	provider struct {
+		provides Dependency
+		factory  ProviderFactory
+	}
+)
+
+func (p *provider) Provides() Dependency {
+	return p.provides
+}
+
+func (p *provider) Factory() ProviderFactory {
+	return p.factory
+}
+
+func (p *provider) String() string {
+	return fmt.Sprintf("Provider for [%s]", p.provides)
+}
+
+func MakeProvider(token Dependency, fct ProviderFactory) Provider {
+	return &provider{token, fct}
+}
+
+func mapFromToken(idx int, token Dependency) map[int]paramIndex {
+	return R.Singleton(token.Flag()&BehaviourMask, R.Singleton(idx, idx))
+}
+
+var (
+	// Empty is the empty array of providers
+	Empty = A.Empty[Provider]()
+
+	mergeTokenMaps = R.UnionMonoid[int](R.UnionLastSemigroup[int, int]())
+	foldDeps       = A.FoldMapWithIndex[Dependency](mergeTokenMaps)(mapFromToken)
+	mergeMaps      = R.UnionLastMonoid[int, any]()
+	collectParams  = R.CollectOrd[any, any](Int.Ord)(F.SK[int, any])
+
+	handlers = map[int]handler{
+		Identity: func(mp paramIndex) func([]IOE.IOEither[error, any]) IOE.IOEither[error, paramValue] {
+			return func(res []IOE.IOEither[error, any]) IOE.IOEither[error, paramValue] {
+				return F.Pipe1(
+					mp,
+					IOE.TraverseRecord[int](getAt(res)),
+				)
+			}
+		},
+		Option: func(mp paramIndex) func([]IOE.IOEither[error, any]) IOE.IOEither[error, paramValue] {
+			return func(res []IOE.IOEither[error, any]) IOE.IOEither[error, paramValue] {
+				return F.Pipe3(
+					mp,
+					IOG.TraverseRecord[IO.IO[map[int]E.Either[error, any]], paramIndex](getAt(res)),
+					IO.Map(R.Map[int](F.Flow2(
+						E.ToOption[error, any],
+						F.ToAny[O.Option[any]],
+					))),
+					IOE.FromIO[error, paramValue],
+				)
+			}
+		},
+		IOEither: func(mp paramIndex) func([]IOE.IOEither[error, any]) IOE.IOEither[error, paramValue] {
+			return func(res []IOE.IOEither[error, any]) IOE.IOEither[error, paramValue] {
+				return F.Pipe2(
+					mp,
+					R.Map[int](F.Flow2(
+						getAt(res),
+						F.ToAny[IOE.IOEither[error, any]],
+					)),
+					IOE.Of[error, paramValue],
+				)
+			}
+		},
+		IOOption: func(mp paramIndex) func([]IOE.IOEither[error, any]) IOE.IOEither[error, paramValue] {
+			return func(res []IOE.IOEither[error, any]) IOE.IOEither[error, paramValue] {
+				return F.Pipe2(
+					mp,
+					R.Map[int](F.Flow3(
+						getAt(res),
+						IOE.ToIOOption[error, any],
+						F.ToAny[IOO.IOOption[any]],
+					)),
+					IOE.Of[error, paramValue],
+				)
+			}
+		},
+	}
+)
+
+func getAt[T any](ar []T) func(idx int) T {
+	return func(idx int) T {
+		return ar[idx]
+	}
+}
+
+func handleMapping(mp mapping) func(res []IOE.IOEither[error, any]) IOE.IOEither[error, []any] {
+	preFct := F.Pipe1(
+		mp,
+		R.Collect(func(idx int, p paramIndex) func([]IOE.IOEither[error, any]) IOE.IOEither[error, paramValue] {
+			return handlers[idx](p)
+		}),
+	)
+	doFct := F.Flow2(
+		I.Flap[IOE.IOEither[error, paramValue], []IOE.IOEither[error, any]],
+		IOE.TraverseArray[error, func([]IOE.IOEither[error, any]) IOE.IOEither[error, paramValue], paramValue],
+	)
+	postFct := IOE.Map[error](F.Flow2(
+		A.Fold(mergeMaps),
+		collectParams,
+	))
+
+	return func(res []IOE.IOEither[error, any]) IOE.IOEither[error, []any] {
+		return F.Pipe2(
+			preFct,
+			doFct(res),
+			postFct,
+		)
+	}
+}
+
+// MakeProviderFactory constructs a [ProviderFactory] based on a set of [Dependency]s and
+// a function that accepts the resolved dependencies to return a result
+func MakeProviderFactory(
+	deps []Dependency,
+	fct func(param ...any) IOE.IOEither[error, any]) ProviderFactory {
+
+	return F.Flow3(
+		F.Curry2(A.MonadMap[Dependency, IOE.IOEither[error, any]])(deps),
+		handleMapping(foldDeps(deps)),
+		IOE.Chain(F.Unvariadic0(fct)),
+	)
+}

di/erasure/token.go

@@ -0,0 +1,45 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package erasure
+
+import (
+	"fmt"
+
+	O "github.com/IBM/fp-go/option"
+)
+
+const (
+	BehaviourMask = 0x0f
+	Identity      = 0 // required dependency
+	Option        = 1 // optional dependency
+	IOEither      = 2 // lazy and required
+	IOOption      = 3 // lazy and optional
+
+	TypeMask = 0xf0
+	Multi    = 1 << 4 // array of implementations
+	Item     = 2 << 4 // item of a multi token
+)
+
+// Dependency describes the relationship to a service
+type Dependency interface {
+	fmt.Stringer
+	// Id returns a unique identifier for a token that can be used as a cache key
+	Id() string
+	// Flag returns a tag that identifies the behaviour of the dependency
+	Flag() int
+	// ProviderFactory optionally returns an attached [ProviderFactory] that represents the default for this dependency
+	ProviderFactory() O.Option[ProviderFactory]
+}

di/injector.go

@@ -0,0 +1,33 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package di
+
+import (
+	DIE "github.com/IBM/fp-go/di/erasure"
+	F "github.com/IBM/fp-go/function"
+	IG "github.com/IBM/fp-go/identity/generic"
+	IOE "github.com/IBM/fp-go/ioeither"
+	RIOE "github.com/IBM/fp-go/readerioeither"
+)
+
+// Resolve performs a type safe resolution of a dependency
+func Resolve[T any](token InjectionToken[T]) RIOE.ReaderIOEither[DIE.InjectableFactory, error, T] {
+	return F.Flow2(
+		IG.Ap[DIE.InjectableFactory](asDependency(token)),
+		IOE.ChainEitherK(token.Unerase),
+	)
+}

di/provider.go

@@ -0,0 +1,281 @@
+// 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 di
+
+import (
+	A "github.com/IBM/fp-go/array"
+	DIE "github.com/IBM/fp-go/di/erasure"
+	E "github.com/IBM/fp-go/either"
+	"github.com/IBM/fp-go/errors"
+	F "github.com/IBM/fp-go/function"
+	IOE "github.com/IBM/fp-go/ioeither"
+	T "github.com/IBM/fp-go/tuple"
+)
+
+func lookupAt[T any](idx int, token Dependency[T]) func(params []any) E.Either[error, T] {
+	return F.Flow3(
+		A.Lookup[any](idx),
+		E.FromOption[any](errors.OnNone("No parameter at position %d", idx)),
+		E.Chain(token.Unerase),
+	)
+}
+
+func eraseProviderFactory0[R any](f func() IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] {
+	return func(params ...any) IOE.IOEither[error, any] {
+		return F.Pipe1(
+			f(),
+			IOE.Map[error](F.ToAny[R]),
+		)
+	}
+}
+
+func eraseProviderFactory1[T1 any, R any](
+	d1 Dependency[T1],
+	f func(T1) IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] {
+	ft := T.Tupled1(f)
+	t1 := lookupAt[T1](0, d1)
+	return func(params ...any) IOE.IOEither[error, any] {
+		return F.Pipe3(
+			E.SequenceT1(t1(params)),
+			IOE.FromEither[error, T.Tuple1[T1]],
+			IOE.Chain(ft),
+			IOE.Map[error](F.ToAny[R]),
+		)
+	}
+}
+
+func eraseProviderFactory2[T1, T2 any, R any](
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	f func(T1, T2) IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] {
+	ft := T.Tupled2(f)
+	t1 := lookupAt[T1](0, d1)
+	t2 := lookupAt[T2](1, d2)
+	return func(params ...any) IOE.IOEither[error, any] {
+		return F.Pipe3(
+			E.SequenceT2(t1(params), t2(params)),
+			IOE.FromEither[error, T.Tuple2[T1, T2]],
+			IOE.Chain(ft),
+			IOE.Map[error](F.ToAny[R]),
+		)
+	}
+}
+
+func eraseProviderFactory3[T1, T2, T3 any, R any](
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	f func(T1, T2, T3) IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] {
+	ft := T.Tupled3(f)
+	t1 := lookupAt[T1](0, d1)
+	t2 := lookupAt[T2](1, d2)
+	t3 := lookupAt[T3](2, d3)
+	return func(params ...any) IOE.IOEither[error, any] {
+		return F.Pipe3(
+			E.SequenceT3(t1(params), t2(params), t3(params)),
+			IOE.FromEither[error, T.Tuple3[T1, T2, T3]],
+			IOE.Chain(ft),
+			IOE.Map[error](F.ToAny[R]),
+		)
+	}
+}
+
+func eraseProviderFactory4[T1, T2, T3, T4 any, R any](
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	f func(T1, T2, T3, T4) IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] {
+	ft := T.Tupled4(f)
+	t1 := lookupAt[T1](0, d1)
+	t2 := lookupAt[T2](1, d2)
+	t3 := lookupAt[T3](2, d3)
+	t4 := lookupAt[T4](3, d4)
+	return func(params ...any) IOE.IOEither[error, any] {
+		return F.Pipe3(
+			E.SequenceT4(t1(params), t2(params), t3(params), t4(params)),
+			IOE.FromEither[error, T.Tuple4[T1, T2, T3, T4]],
+			IOE.Chain(ft),
+			IOE.Map[error](F.ToAny[R]),
+		)
+	}
+}
+
+func MakeProviderFactory0[R any](
+	fct func() IOE.IOEither[error, R],
+) DIE.ProviderFactory {
+	return DIE.MakeProviderFactory(
+		A.Empty[DIE.Dependency](),
+		eraseProviderFactory0(fct),
+	)
+}
+
+// MakeTokenWithDefault0 create a unique `InjectionToken` for a specific type with an attached default provider
+func MakeTokenWithDefault0[R any](name string, fct func() IOE.IOEither[error, R]) InjectionToken[R] {
+	return MakeTokenWithDefault[R](name, MakeProviderFactory0(fct))
+}
+
+func MakeProvider0[R any](
+	token InjectionToken[R],
+	fct func() IOE.IOEither[error, R],
+) DIE.Provider {
+	return DIE.MakeProvider(
+		token,
+		MakeProviderFactory0(fct),
+	)
+}
+
+func MakeProviderFactory1[T1, R any](
+	d1 Dependency[T1],
+	fct func(T1) IOE.IOEither[error, R],
+) DIE.ProviderFactory {
+
+	return DIE.MakeProviderFactory(
+		A.From[DIE.Dependency](d1),
+		eraseProviderFactory1(d1, fct),
+	)
+}
+
+// MakeTokenWithDefault1 create a unique `InjectionToken` for a specific type with an attached default provider
+func MakeTokenWithDefault1[T1, R any](name string,
+	d1 Dependency[T1],
+	fct func(T1) IOE.IOEither[error, R]) InjectionToken[R] {
+	return MakeTokenWithDefault[R](name, MakeProviderFactory1(d1, fct))
+}
+
+func MakeProvider1[T1, R any](
+	token InjectionToken[R],
+	d1 Dependency[T1],
+	fct func(T1) IOE.IOEither[error, R],
+) DIE.Provider {
+
+	return DIE.MakeProvider(
+		token,
+		MakeProviderFactory1(d1, fct),
+	)
+}
+
+func MakeProviderFactory2[T1, T2, R any](
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	fct func(T1, T2) IOE.IOEither[error, R],
+) DIE.ProviderFactory {
+
+	return DIE.MakeProviderFactory(
+		A.From[DIE.Dependency](d1, d2),
+		eraseProviderFactory2(d1, d2, fct),
+	)
+}
+
+// MakeTokenWithDefault2 create a unique `InjectionToken` for a specific type with an attached default provider
+func MakeTokenWithDefault2[T1, T2, R any](name string,
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	fct func(T1, T2) IOE.IOEither[error, R]) InjectionToken[R] {
+	return MakeTokenWithDefault[R](name, MakeProviderFactory2(d1, d2, fct))
+}
+
+func MakeProvider2[T1, T2, R any](
+	token InjectionToken[R],
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	fct func(T1, T2) IOE.IOEither[error, R],
+) DIE.Provider {
+
+	return DIE.MakeProvider(
+		token,
+		MakeProviderFactory2(d1, d2, fct),
+	)
+}
+
+func MakeProviderFactory3[T1, T2, T3, R any](
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	fct func(T1, T2, T3) IOE.IOEither[error, R],
+) DIE.ProviderFactory {
+
+	return DIE.MakeProviderFactory(
+		A.From[DIE.Dependency](d1, d2, d3),
+		eraseProviderFactory3(d1, d2, d3, fct),
+	)
+}
+
+// MakeTokenWithDefault3 create a unique `InjectionToken` for a specific type with an attached default provider
+func MakeTokenWithDefault3[T1, T2, T3, R any](name string,
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	fct func(T1, T2, T3) IOE.IOEither[error, R]) InjectionToken[R] {
+	return MakeTokenWithDefault[R](name, MakeProviderFactory3(d1, d2, d3, fct))
+}
+
+func MakeProvider3[T1, T2, T3, R any](
+	token InjectionToken[R],
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	fct func(T1, T2, T3) IOE.IOEither[error, R],
+) DIE.Provider {
+
+	return DIE.MakeProvider(
+		token,
+		MakeProviderFactory3(d1, d2, d3, fct),
+	)
+}
+
+func MakeProviderFactory4[T1, T2, T3, T4, R any](
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	fct func(T1, T2, T3, T4) IOE.IOEither[error, R],
+) DIE.ProviderFactory {
+
+	return DIE.MakeProviderFactory(
+		A.From[DIE.Dependency](d1, d2, d3, d4),
+		eraseProviderFactory4(d1, d2, d3, d4, fct),
+	)
+}
+
+// MakeTokenWithDefault4 create a unique `InjectionToken` for a specific type with an attached default provider
+func MakeTokenWithDefault4[T1, T2, T3, T4, R any](name string,
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	fct func(T1, T2, T3, T4) IOE.IOEither[error, R]) InjectionToken[R] {
+	return MakeTokenWithDefault[R](name, MakeProviderFactory4(d1, d2, d3, d4, fct))
+}
+
+func MakeProvider4[T1, T2, T3, T4, R any](
+	token InjectionToken[R],
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	fct func(T1, T2, T3, T4) IOE.IOEither[error, R],
+) DIE.Provider {
+
+	return DIE.MakeProvider(
+		token,
+		MakeProviderFactory4(d1, d2, d3, d4, fct),
+	)
+}
+
+// ConstProvider simple implementation for a provider with a constant value
+func ConstProvider[R any](token InjectionToken[R], value R) DIE.Provider {
+	return MakeProvider0[R](token, F.Constant(IOE.Of[error](value)))
+}

di/provider_test.go

@@ -0,0 +1,351 @@
+// 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 di
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	A "github.com/IBM/fp-go/array"
+	DIE "github.com/IBM/fp-go/di/erasure"
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	IOE "github.com/IBM/fp-go/ioeither"
+	O "github.com/IBM/fp-go/option"
+	"github.com/stretchr/testify/assert"
+)
+
+var (
+	INJ_KEY2 = MakeToken[string]("INJ_KEY2")
+	INJ_KEY1 = MakeToken[string]("INJ_KEY1")
+	INJ_KEY3 = MakeToken[string]("INJ_KEY3")
+)
+
+func TestSimpleProvider(t *testing.T) {
+
+	var staticCount int
+
+	staticValue := func(value string) func() IOE.IOEither[error, string] {
+		return func() IOE.IOEither[error, string] {
+			return func() E.Either[error, string] {
+				staticCount++
+				return E.Of[error](fmt.Sprintf("Static based on [%s], at [%s]", value, time.Now()))
+			}
+		}
+	}
+
+	var dynamicCount int
+
+	dynamicValue := func(value string) IOE.IOEither[error, string] {
+		return func() E.Either[error, string] {
+			dynamicCount++
+			return E.Of[error](fmt.Sprintf("Dynamic based on [%s] at [%s]", value, time.Now()))
+		}
+	}
+
+	p1 := MakeProvider0(INJ_KEY1, staticValue("Carsten"))
+	p2 := MakeProvider1(INJ_KEY2, INJ_KEY1.Identity(), dynamicValue)
+
+	inj := DIE.MakeInjector(A.From(p1, p2))
+
+	i1 := Resolve(INJ_KEY1)
+	i2 := Resolve(INJ_KEY2)
+
+	res := IOE.SequenceT4(
+		i2(inj),
+		i1(inj),
+		i2(inj),
+		i1(inj),
+	)
+
+	r := res()
+
+	assert.True(t, E.IsRight(r))
+	assert.Equal(t, 1, staticCount)
+	assert.Equal(t, 1, dynamicCount)
+}
+
+func TestOptionalProvider(t *testing.T) {
+
+	var staticCount int
+
+	staticValue := func(value string) func() IOE.IOEither[error, string] {
+		return func() IOE.IOEither[error, string] {
+			return func() E.Either[error, string] {
+				staticCount++
+				return E.Of[error](fmt.Sprintf("Static based on [%s], at [%s]", value, time.Now()))
+			}
+		}
+	}
+
+	var dynamicCount int
+
+	dynamicValue := func(value O.Option[string]) IOE.IOEither[error, string] {
+		return func() E.Either[error, string] {
+			dynamicCount++
+			return E.Of[error](fmt.Sprintf("Dynamic based on [%s] at [%s]", value, time.Now()))
+		}
+	}
+
+	p1 := MakeProvider0(INJ_KEY1, staticValue("Carsten"))
+	p2 := MakeProvider1(INJ_KEY2, INJ_KEY1.Option(), dynamicValue)
+
+	inj := DIE.MakeInjector(A.From(p1, p2))
+
+	i1 := Resolve(INJ_KEY1)
+	i2 := Resolve(INJ_KEY2)
+
+	res := IOE.SequenceT4(
+		i2(inj),
+		i1(inj),
+		i2(inj),
+		i1(inj),
+	)
+
+	r := res()
+
+	assert.True(t, E.IsRight(r))
+	assert.Equal(t, 1, staticCount)
+	assert.Equal(t, 1, dynamicCount)
+}
+
+func TestOptionalProviderMissingDependency(t *testing.T) {
+
+	var dynamicCount int
+
+	dynamicValue := func(value O.Option[string]) IOE.IOEither[error, string] {
+		return func() E.Either[error, string] {
+			dynamicCount++
+			return E.Of[error](fmt.Sprintf("Dynamic based on [%s] at [%s]", value, time.Now()))
+		}
+	}
+
+	p2 := MakeProvider1(INJ_KEY2, INJ_KEY1.Option(), dynamicValue)
+
+	inj := DIE.MakeInjector(A.From(p2))
+
+	i2 := Resolve(INJ_KEY2)
+
+	res := IOE.SequenceT2(
+		i2(inj),
+		i2(inj),
+	)
+
+	r := res()
+
+	assert.True(t, E.IsRight(r))
+	assert.Equal(t, 1, dynamicCount)
+}
+
+func TestProviderMissingDependency(t *testing.T) {
+
+	var dynamicCount int
+
+	dynamicValue := func(value string) IOE.IOEither[error, string] {
+		return func() E.Either[error, string] {
+			dynamicCount++
+			return E.Of[error](fmt.Sprintf("Dynamic based on [%s] at [%s]", value, time.Now()))
+		}
+	}
+
+	p2 := MakeProvider1(INJ_KEY2, INJ_KEY1.Identity(), dynamicValue)
+
+	inj := DIE.MakeInjector(A.From(p2))
+
+	i2 := Resolve(INJ_KEY2)
+
+	res := IOE.SequenceT2(
+		i2(inj),
+		i2(inj),
+	)
+
+	r := res()
+
+	assert.True(t, E.IsLeft(r))
+	assert.Equal(t, 0, dynamicCount)
+}
+
+func TestEagerAndLazyProvider(t *testing.T) {
+
+	var staticCount int
+
+	staticValue := func(value string) func() IOE.IOEither[error, string] {
+		return func() IOE.IOEither[error, string] {
+			return func() E.Either[error, string] {
+				staticCount++
+				return E.Of[error](fmt.Sprintf("Static based on [%s], at [%s]", value, time.Now()))
+			}
+		}
+	}
+
+	var dynamicCount int
+
+	dynamicValue := func(value string) IOE.IOEither[error, string] {
+		return func() E.Either[error, string] {
+			dynamicCount++
+			return E.Of[error](fmt.Sprintf("Dynamic based on [%s] at [%s]", value, time.Now()))
+		}
+	}
+
+	var lazyEagerCount int
+
+	lazyEager := func(laz IOE.IOEither[error, string], eager string) IOE.IOEither[error, string] {
+		return F.Pipe1(
+			laz,
+			IOE.Chain(func(lazValue string) IOE.IOEither[error, string] {
+				return func() E.Either[error, string] {
+					lazyEagerCount++
+					return E.Of[error](fmt.Sprintf("Dynamic based on [%s], [%s] at [%s]", lazValue, eager, time.Now()))
+				}
+			}),
+		)
+	}
+
+	p1 := MakeProvider0(INJ_KEY1, staticValue("Carsten"))
+	p2 := MakeProvider1(INJ_KEY2, INJ_KEY1.Identity(), dynamicValue)
+	p3 := MakeProvider2(INJ_KEY3, INJ_KEY2.IOEither(), INJ_KEY1.Identity(), lazyEager)
+
+	inj := DIE.MakeInjector(A.From(p1, p2, p3))
+
+	i3 := Resolve(INJ_KEY3)
+
+	r := i3(inj)()
+
+	fmt.Println(r)
+
+	assert.True(t, E.IsRight(r))
+	assert.Equal(t, 1, staticCount)
+	assert.Equal(t, 1, dynamicCount)
+	assert.Equal(t, 1, lazyEagerCount)
+}
+
+func TestItemProvider(t *testing.T) {
+	// define a multi token
+	injMulti := MakeMultiToken[string]("configs")
+
+	// provide some values
+	v1 := ConstProvider(injMulti.Item(), "Value1")
+	v2 := ConstProvider(injMulti.Item(), "Value2")
+	// mix in non-multi values
+	p1 := ConstProvider(INJ_KEY1, "Value3")
+	p2 := ConstProvider(INJ_KEY2, "Value4")
+
+	// populate the injector
+	inj := DIE.MakeInjector(A.From(p1, v1, p2, v2))
+
+	// access the multi value
+	multi := Resolve(injMulti.Container())
+
+	multiInj := multi(inj)
+
+	value := multiInj()
+
+	assert.Equal(t, E.Of[error](A.From("Value1", "Value2")), value)
+}
+
+func TestEmptyItemProvider(t *testing.T) {
+	// define a multi token
+	injMulti := MakeMultiToken[string]("configs")
+
+	// mix in non-multi values
+	p1 := ConstProvider(INJ_KEY1, "Value3")
+	p2 := ConstProvider(INJ_KEY2, "Value4")
+
+	// populate the injector
+	inj := DIE.MakeInjector(A.From(p1, p2))
+
+	// access the multi value
+	multi := Resolve(injMulti.Container())
+
+	multiInj := multi(inj)
+
+	value := multiInj()
+
+	assert.Equal(t, E.Of[error](A.Empty[string]()), value)
+}
+
+func TestDependencyOnMultiProvider(t *testing.T) {
+	// define a multi token
+	injMulti := MakeMultiToken[string]("configs")
+
+	// provide some values
+	v1 := ConstProvider(injMulti.Item(), "Value1")
+	v2 := ConstProvider(injMulti.Item(), "Value2")
+	// mix in non-multi values
+	p1 := ConstProvider(INJ_KEY1, "Value3")
+	p2 := ConstProvider(INJ_KEY2, "Value4")
+
+	fromMulti := func(val string, multi []string) IOE.IOEither[error, string] {
+		return IOE.Of[error](fmt.Sprintf("Val: %s, Multi: %s", val, multi))
+	}
+	p3 := MakeProvider2(INJ_KEY3, INJ_KEY1.Identity(), injMulti.Container().Identity(), fromMulti)
+
+	// populate the injector
+	inj := DIE.MakeInjector(A.From(p1, p2, v1, v2, p3))
+
+	r3 := Resolve(INJ_KEY3)
+
+	v := r3(inj)()
+
+	assert.Equal(t, E.Of[error]("Val: Value3, Multi: [Value1 Value2]"), v)
+}
+
+func TestTokenWithDefaultProvider(t *testing.T) {
+	// token without a default
+	injToken1 := MakeToken[string]("Token1")
+	// token with a default
+	injToken2 := MakeTokenWithDefault0("Token2", F.Constant(IOE.Of[error]("Carsten")))
+	// dependency
+	injToken3 := MakeToken[string]("Token3")
+
+	p3 := MakeProvider1(injToken3, injToken2.Identity(), func(data string) IOE.IOEither[error, string] {
+		return IOE.Of[error](fmt.Sprintf("Token: %s", data))
+	})
+
+	// populate the injector
+	inj := DIE.MakeInjector(A.From(p3))
+
+	// resolving injToken3 should work and use the default provider for injToken2
+	r1 := Resolve(injToken1)
+	r3 := Resolve(injToken3)
+
+	// inj1 should not be available
+	assert.True(t, E.IsLeft(r1(inj)()))
+	// r3 should work
+	assert.Equal(t, E.Of[error]("Token: Carsten"), r3(inj)())
+}
+
+func TestTokenWithDefaultProviderAndOverride(t *testing.T) {
+	// token with a default
+	injToken2 := MakeTokenWithDefault0("Token2", F.Constant(IOE.Of[error]("Carsten")))
+	// dependency
+	injToken3 := MakeToken[string]("Token3")
+
+	p2 := ConstProvider(injToken2, "Override")
+
+	p3 := MakeProvider1(injToken3, injToken2.Identity(), func(data string) IOE.IOEither[error, string] {
+		return IOE.Of[error](fmt.Sprintf("Token: %s", data))
+	})
+
+	// populate the injector
+	inj := DIE.MakeInjector(A.From(p2, p3))
+
+	// resolving injToken3 should work and use the default provider for injToken2
+	r3 := Resolve(injToken3)
+
+	// r3 should work
+	assert.Equal(t, E.Of[error]("Token: Override"), r3(inj)())
+}

di/token.go

@@ -0,0 +1,196 @@
+// 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 di
+
+import (
+	"fmt"
+	"strconv"
+	"sync/atomic"
+
+	DIE "github.com/IBM/fp-go/di/erasure"
+	E "github.com/IBM/fp-go/either"
+	IO "github.com/IBM/fp-go/io"
+	IOE "github.com/IBM/fp-go/ioeither"
+	IOO "github.com/IBM/fp-go/iooption"
+	O "github.com/IBM/fp-go/option"
+)
+
+// Dependency describes the relationship to a service, that has a type and
+// a behaviour such as required, option or lazy
+type Dependency[T any] interface {
+	DIE.Dependency
+	// Unerase converts a value with erased type signature into a strongly typed value
+	Unerase(val any) E.Either[error, T]
+}
+
+// InjectionToken uniquely identifies a dependency by giving it an Id, Type and name
+type InjectionToken[T any] interface {
+	Dependency[T]
+	// Identity idenifies this dependency as a mandatory, required dependency, it will be resolved eagerly and injected as `T`.
+	// If the dependency cannot be resolved, the resolution process fails
+	Identity() Dependency[T]
+	// Option identifies this dependency as optional, it will be resolved eagerly and injected as `O.Option[T]`.
+	// If the dependency cannot be resolved, the resolution process continues and the dependency is represented as `O.None[T]`
+	Option() Dependency[O.Option[T]]
+	// IOEither identifies this dependency as mandatory but it will be resolved lazily as a `IOE.IOEither[error, T]`. This
+	// value is memoized to make sure the dependency is a singleton.
+	// If the dependency cannot be resolved, the resolution process fails
+	IOEither() Dependency[IOE.IOEither[error, T]]
+	// IOOption identifies this dependency as optional but it will be resolved lazily as a `IOO.IOOption[T]`. This
+	// value is memoized to make sure the dependency is a singleton.
+	// If the dependency cannot be resolved, the resolution process continues and the dependency is represented as the none value.
+	IOOption() Dependency[IOO.IOOption[T]]
+}
+
+// MultiInjectionToken uniquely identifies a dependency by giving it an Id, Type and name.
+type MultiInjectionToken[T any] interface {
+	// Container returns the injection token used to request an array of all provided items
+	Container() InjectionToken[[]T]
+	// Item returns the injection token used to provide an item
+	Item() InjectionToken[T]
+}
+
+// makeID creates a generator of unique string IDs
+func makeId() IO.IO[string] {
+	var count atomic.Int64
+	return IO.MakeIO(func() string {
+		return strconv.FormatInt(count.Add(1), 16)
+	})
+}
+
+// genId is the common generator of unique string IDs
+var genId = makeId()
+
+type token[T any] struct {
+	name            string
+	id              string
+	flag            int
+	toType          func(val any) E.Either[error, T]
+	providerFactory O.Option[DIE.ProviderFactory]
+}
+
+func (t *token[T]) Id() string {
+	return t.id
+}
+
+func (t *token[T]) Flag() int {
+	return t.flag
+}
+
+func (t *token[T]) String() string {
+	return t.name
+}
+
+func (t *token[T]) Unerase(val any) E.Either[error, T] {
+	return t.toType(val)
+}
+
+func (t *token[T]) ProviderFactory() O.Option[DIE.ProviderFactory] {
+	return t.providerFactory
+}
+
+func makeToken[T any](name string, id string, typ int, unerase func(val any) E.Either[error, T], providerFactory O.Option[DIE.ProviderFactory]) Dependency[T] {
+	return &token[T]{name, id, typ, unerase, providerFactory}
+}
+
+type injectionToken[T any] struct {
+	token[T]
+	option   Dependency[O.Option[T]]
+	ioeither Dependency[IOE.IOEither[error, T]]
+	iooption Dependency[IOO.IOOption[T]]
+}
+
+type multiInjectionToken[T any] struct {
+	container *injectionToken[[]T]
+	item      *injectionToken[T]
+}
+
+func (i *injectionToken[T]) Identity() Dependency[T] {
+	return i
+}
+
+func (i *injectionToken[T]) Option() Dependency[O.Option[T]] {
+	return i.option
+}
+
+func (i *injectionToken[T]) IOEither() Dependency[IOE.IOEither[error, T]] {
+	return i.ioeither
+}
+
+func (i *injectionToken[T]) IOOption() Dependency[IOO.IOOption[T]] {
+	return i.iooption
+}
+
+func (i *injectionToken[T]) ProviderFactory() O.Option[DIE.ProviderFactory] {
+	return i.providerFactory
+}
+
+func (m *multiInjectionToken[T]) Container() InjectionToken[[]T] {
+	return m.container
+}
+
+func (m *multiInjectionToken[T]) Item() InjectionToken[T] {
+	return m.item
+}
+
+// makeToken create a unique `InjectionToken` for a specific type
+func makeInjectionToken[T any](name string, providerFactory O.Option[DIE.ProviderFactory]) InjectionToken[T] {
+	id := genId()
+	toIdentity := toType[T]()
+	return &injectionToken[T]{
+		token[T]{name, id, DIE.Identity, toIdentity, providerFactory},
+		makeToken[O.Option[T]](fmt.Sprintf("Option[%s]", name), id, DIE.Option, toOptionType(toIdentity), providerFactory),
+		makeToken[IOE.IOEither[error, T]](fmt.Sprintf("IOEither[%s]", name), id, DIE.IOEither, toIOEitherType(toIdentity), providerFactory),
+		makeToken[IOO.IOOption[T]](fmt.Sprintf("IOOption[%s]", name), id, DIE.IOOption, toIOOptionType(toIdentity), providerFactory),
+	}
+}
+
+// MakeToken create a unique `InjectionToken` for a specific type
+func MakeToken[T any](name string) InjectionToken[T] {
+	return makeInjectionToken[T](name, O.None[DIE.ProviderFactory]())
+}
+
+// MakeToken create a unique `InjectionToken` for a specific type
+func MakeTokenWithDefault[T any](name string, providerFactory DIE.ProviderFactory) InjectionToken[T] {
+	return makeInjectionToken[T](name, O.Of(providerFactory))
+}
+
+// MakeMultiToken creates a [MultiInjectionToken]
+func MakeMultiToken[T any](name string) MultiInjectionToken[T] {
+	id := genId()
+	toItem := toType[T]()
+	toContainer := toArrayType(toItem)
+	containerName := fmt.Sprintf("Container[%s]", name)
+	itemName := fmt.Sprintf("Item[%s]", name)
+	// empty factory
+	providerFactory := O.None[DIE.ProviderFactory]()
+	// container
+	container := &injectionToken[[]T]{
+		token[[]T]{containerName, id, DIE.Multi | DIE.Identity, toContainer, providerFactory},
+		makeToken[O.Option[[]T]](fmt.Sprintf("Option[%s]", containerName), id, DIE.Multi|DIE.Option, toOptionType(toContainer), providerFactory),
+		makeToken[IOE.IOEither[error, []T]](fmt.Sprintf("IOEither[%s]", containerName), id, DIE.Multi|DIE.IOEither, toIOEitherType(toContainer), providerFactory),
+		makeToken[IOO.IOOption[[]T]](fmt.Sprintf("IOOption[%s]", containerName), id, DIE.Multi|DIE.IOOption, toIOOptionType(toContainer), providerFactory),
+	}
+	// item
+	item := &injectionToken[T]{
+		token[T]{itemName, id, DIE.Item | DIE.Identity, toItem, providerFactory},
+		makeToken[O.Option[T]](fmt.Sprintf("Option[%s]", itemName), id, DIE.Item|DIE.Option, toOptionType(toItem), providerFactory),
+		makeToken[IOE.IOEither[error, T]](fmt.Sprintf("IOEither[%s]", itemName), id, DIE.Item|DIE.IOEither, toIOEitherType(toItem), providerFactory),
+		makeToken[IOO.IOOption[T]](fmt.Sprintf("IOOption[%s]", itemName), id, DIE.Item|DIE.IOOption, toIOOptionType(toItem), providerFactory),
+	}
+	// returns the token
+	return &multiInjectionToken[T]{container, item}
+}

di/utils.go

@@ -0,0 +1,76 @@
+// 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 di
+
+import (
+	DIE "github.com/IBM/fp-go/di/erasure"
+	E "github.com/IBM/fp-go/either"
+	"github.com/IBM/fp-go/errors"
+	F "github.com/IBM/fp-go/function"
+	IOE "github.com/IBM/fp-go/ioeither"
+	IOO "github.com/IBM/fp-go/iooption"
+	O "github.com/IBM/fp-go/option"
+)
+
+// asDependency converts a generic type to a [DIE.Dependency]
+func asDependency[T DIE.Dependency](t T) DIE.Dependency {
+	return t
+}
+
+// toType converts an any to a T
+func toType[T any]() func(t any) E.Either[error, T] {
+	return E.ToType[T](errors.OnSome[any]("Value of type [%T] cannot be converted."))
+}
+
+// toOptionType converts an any to an Option[any] and then to an Option[T]
+func toOptionType[T any](item func(any) E.Either[error, T]) func(t any) E.Either[error, O.Option[T]] {
+	return F.Flow2(
+		toType[O.Option[any]](),
+		E.Chain(O.Fold(
+			F.Nullary2(O.None[T], E.Of[error, O.Option[T]]),
+			F.Flow2(
+				item,
+				E.Map[error](O.Of[T]),
+			),
+		)),
+	)
+}
+
+// toIOEitherType converts an any to an IOEither[error, any] and then to an IOEither[error, T]
+func toIOEitherType[T any](item func(any) E.Either[error, T]) func(t any) E.Either[error, IOE.IOEither[error, T]] {
+	return F.Flow2(
+		toType[IOE.IOEither[error, any]](),
+		E.Map[error](IOE.ChainEitherK(item)),
+	)
+}
+
+// toIOOptionType converts an any to an IOOption[any] and then to an IOOption[T]
+func toIOOptionType[T any](item func(any) E.Either[error, T]) func(t any) E.Either[error, IOO.IOOption[T]] {
+	return F.Flow2(
+		toType[IOO.IOOption[any]](),
+		E.Map[error](IOO.ChainOptionK(F.Flow2(
+			item,
+			E.ToOption[error, T],
+		))),
+	)
+}
+
+// toArrayType converts an any to a []T
+func toArrayType[T any](item func(any) E.Either[error, T]) func(t any) E.Either[error, []T] {
+	return F.Flow2(
+		toType[[]any](),
+		E.Chain(E.TraverseArray(item)),
+	)
+}

di/utils_test.go

@@ -0,0 +1,83 @@
+// 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 di
+
+import (
+	"testing"
+
+	A "github.com/IBM/fp-go/array"
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	IOE "github.com/IBM/fp-go/ioeither"
+	O "github.com/IBM/fp-go/option"
+	"github.com/stretchr/testify/assert"
+)
+
+var (
+	toInt    = toType[int]()
+	toString = toType[string]()
+)
+
+func TestToType(t *testing.T) {
+	// good cases
+	assert.Equal(t, E.Of[error](10), toInt(any(10)))
+	assert.Equal(t, E.Of[error]("Carsten"), toString(any("Carsten")))
+	assert.Equal(t, E.Of[error](O.Of("Carsten")), toType[O.Option[string]]()(any(O.Of("Carsten"))))
+	assert.Equal(t, E.Of[error](O.Of(any("Carsten"))), toType[O.Option[any]]()(any(O.Of(any("Carsten")))))
+	// failure
+	assert.False(t, E.IsRight(toInt(any("Carsten"))))
+	assert.False(t, E.IsRight(toType[O.Option[string]]()(O.Of(any("Carsten")))))
+}
+
+func TestToOptionType(t *testing.T) {
+	// shortcuts
+	toOptInt := toOptionType(toInt)
+	toOptString := toOptionType(toString)
+	// good cases
+	assert.Equal(t, E.Of[error](O.Of(10)), toOptInt(any(O.Of(any(10)))))
+	assert.Equal(t, E.Of[error](O.Of("Carsten")), toOptString(any(O.Of(any("Carsten")))))
+	// bad cases
+	assert.False(t, E.IsRight(toOptInt(any(10))))
+	assert.False(t, E.IsRight(toOptInt(any(O.Of(10)))))
+}
+
+func invokeIOEither[T any](e E.Either[error, IOE.IOEither[error, T]]) E.Either[error, T] {
+	return F.Pipe1(
+		e,
+		E.Chain(func(ioe IOE.IOEither[error, T]) E.Either[error, T] {
+			return ioe()
+		}),
+	)
+}
+
+func TestToIOEitherType(t *testing.T) {
+	// shortcuts
+	toIOEitherInt := toIOEitherType(toInt)
+	toIOEitherString := toIOEitherType(toString)
+	// good cases
+	assert.Equal(t, E.Of[error](10), invokeIOEither(toIOEitherInt(any(IOE.Of[error](any(10))))))
+	assert.Equal(t, E.Of[error]("Carsten"), invokeIOEither(toIOEitherString(any(IOE.Of[error](any("Carsten"))))))
+	// bad cases
+	assert.False(t, E.IsRight(invokeIOEither(toIOEitherString(any(IOE.Of[error](any(10)))))))
+	assert.False(t, E.IsRight(invokeIOEither(toIOEitherString(any(IOE.Of[error]("Carsten"))))))
+	assert.False(t, E.IsRight(invokeIOEither(toIOEitherString(any("Carsten")))))
+}
+
+func TestToArrayType(t *testing.T) {
+	// shortcuts
+	toArrayString := toArrayType(toString)
+	// good cases
+	assert.Equal(t, E.Of[error](A.From("a", "b")), toArrayString(any(A.From(any("a"), any("b")))))
+}

either/apply.go

@@ -24,6 +24,7 @@ func ApplySemigroup[E, A any](s S.Semigroup[A]) S.Semigroup[Either[E, A]] {
 	return S.ApplySemigroup(MonadMap[E, A, func(A) A], MonadAp[A, E, A], s)
 }
 
+// ApplicativeMonoid returns a [Monoid] that concatenates [Either] instances via their applicative
 func ApplicativeMonoid[E, A any](m M.Monoid[A]) M.Monoid[Either[E, A]] {
 	return M.ApplicativeMonoid(Of[E, A], MonadMap[E, A, func(A) A], MonadAp[A, E, A], m)
 }

either/array.go

@@ -20,7 +20,7 @@ import (
 	RA "github.com/IBM/fp-go/internal/array"
 )
 
-// TraverseArray transforms an array
+// TraverseArrayG 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],
@@ -36,6 +36,22 @@ func TraverseArray[E, A, B any](f func(A) Either[E, B]) func([]A) Either[E, []B]
 	return TraverseArrayG[[]A, []B](f)
 }
 
+// TraverseArrayWithIndexG transforms an array
+func TraverseArrayWithIndexG[GA ~[]A, GB ~[]B, E, A, B any](f func(int, A) Either[E, B]) func(GA) Either[E, GB] {
+	return RA.TraverseWithIndex[GA](
+		Of[E, GB],
+		Map[E, GB, func(B) GB],
+		Ap[GB, E, B],
+
+		f,
+	)
+}
+
+// TraverseArrayWithIndex transforms an array
+func TraverseArrayWithIndex[E, A, B any](f func(int, A) Either[E, B]) func([]A) Either[E, []B] {
+	return TraverseArrayWithIndexG[[]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)
 }
@@ -45,14 +61,14 @@ func SequenceArray[E, A any](ma []Either[E, A]) Either[E, []A] {
 	return SequenceArrayG[[]A](ma)
 }
 
-// CompactArrayG discards the none values and keeps the some values
+// CompactArrayG discards the none values and keeps the right values
 func CompactArrayG[A1 ~[]Either[E, A], A2 ~[]A, E, A any](fa A1) A2 {
 	return RA.Reduce(fa, func(out A2, value Either[E, A]) A2 {
 		return MonadFold(value, F.Constant1[E](out), F.Bind1st(RA.Append[A2, A], out))
-	}, make(A2, len(fa)))
+	}, make(A2, 0, len(fa)))
 }
 
-// CompactArray discards the none values and keeps the some values
+// CompactArray discards the none values and keeps the right values
 func CompactArray[E, A any](fa []Either[E, A]) []A {
 	return CompactArrayG[[]Either[E, A], []A](fa)
 }

either/array_test.go

@@ -0,0 +1,18 @@
+package either
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCompactArray(t *testing.T) {
+	ar := []Either[string, string]{
+		Of[string]("ok"),
+		Left[string]("err"),
+		Of[string]("ok"),
+	}
+
+	res := CompactArray(ar)
+	assert.Equal(t, 2, len(res))
+}

either/core.go

@@ -46,12 +46,12 @@ func (s Either[E, A]) Format(f fmt.State, c rune) {
 	}
 }
 
-// IsLeft tests if the either is a left value. Rather use [Fold] if you need to access the values. Inverse is [IsRight].
+// IsLeft tests if the [Either] is a left value. Rather use [Fold] if you need to access the values. Inverse is [IsRight].
 func IsLeft[E, A any](val Either[E, A]) bool {
 	return val.isLeft
 }
 
-// IsLeft tests if the either is a right value. Rather use [Fold] if you need to access the values. Inverse is [IsLeft].
+// IsLeft tests if the [Either] is a right value. Rather use [Fold] if you need to access the values. Inverse is [IsLeft].
 func IsRight[E, A any](val Either[E, A]) bool {
 	return !val.isLeft
 }

either/either.go

@@ -22,6 +22,8 @@ package either
 import (
 	E "github.com/IBM/fp-go/errors"
 	F "github.com/IBM/fp-go/function"
+	FC "github.com/IBM/fp-go/internal/functor"
+	L "github.com/IBM/fp-go/lazy"
 	O "github.com/IBM/fp-go/option"
 )
 
@@ -87,23 +89,23 @@ func MonadChainFirst[E, A, B any](ma Either[E, A], f func(a A) Either[E, B]) Eit
 	})
 }
 
-func MonadChainTo[E, A, B any](ma Either[E, A], mb Either[E, B]) Either[E, B] {
+func MonadChainTo[A, E, B any](ma Either[E, A], mb Either[E, B]) Either[E, B] {
 	return mb
 }
 
 func MonadChainOptionK[A, B, E any](onNone func() E, ma Either[E, A], f func(A) O.Option[B]) Either[E, B] {
-	return MonadChain(ma, F.Flow2(f, FromOption[E, B](onNone)))
+	return MonadChain(ma, F.Flow2(f, FromOption[B](onNone)))
 }
 
 func ChainOptionK[A, B, E any](onNone func() E) func(func(A) O.Option[B]) func(Either[E, A]) Either[E, B] {
-	from := FromOption[E, B](onNone)
+	from := FromOption[B](onNone)
 	return func(f func(A) O.Option[B]) func(Either[E, A]) Either[E, B] {
 		return Chain(F.Flow2(f, from))
 	}
 }
 
-func ChainTo[E, A, B any](mb Either[E, B]) func(Either[E, A]) Either[E, B] {
-	return F.Bind2nd(MonadChainTo[E, A, B], mb)
+func ChainTo[A, E, B any](mb Either[E, B]) func(Either[E, A]) Either[E, B] {
+	return F.Bind2nd(MonadChainTo[A, E, B], mb)
 }
 
 func Chain[E, A, B any](f func(a A) Either[E, B]) func(Either[E, A]) Either[E, B] {
@@ -118,16 +120,15 @@ func Flatten[E, A any](mma Either[E, Either[E, A]]) Either[E, A] {
 	return MonadChain(mma, F.Identity[Either[E, A]])
 }
 
-func TryCatch[FA ~func() (A, error), FE func(error) E, E, A any](f FA, onThrow FE) Either[E, A] {
-	val, err := f()
+func TryCatch[FE func(error) E, E, A any](val A, err error, onThrow FE) Either[E, A] {
 	if err != nil {
 		return F.Pipe2(err, onThrow, Left[A, E])
 	}
 	return F.Pipe1(val, Right[E, A])
 }
 
-func TryCatchError[F ~func() (A, error), A any](f F) Either[error, A] {
-	return TryCatch(f, E.IdentityError)
+func TryCatchError[A any](val A, err error) Either[error, A] {
+	return TryCatch(val, err, E.IdentityError)
 }
 
 func Sequence2[E, T1, T2, R any](f func(T1, T2) Either[E, R]) func(Either[E, T1], Either[E, T2]) Either[E, R] {
@@ -142,7 +143,7 @@ func Sequence3[E, T1, T2, T3, R any](f func(T1, T2, T3) Either[E, R]) func(Eithe
 	}
 }
 
-func FromOption[E, A any](onNone func() E) func(O.Option[A]) Either[E, A] {
+func FromOption[A, E any](onNone func() E) func(O.Option[A]) Either[E, A] {
 	return O.Fold(F.Nullary2(onNone, Left[A, E]), Right[E, A])
 }
 
@@ -152,9 +153,7 @@ func ToOption[E, A any](ma Either[E, A]) O.Option[A] {
 
 func FromError[A any](f func(a A) error) func(A) Either[error, A] {
 	return func(a A) Either[error, A] {
-		return TryCatchError(func() (A, error) {
-			return a, f(a)
-		})
+		return TryCatchError(a, f(a))
 	}
 }
 
@@ -197,11 +196,11 @@ func Reduce[E, A, B any](f func(B, A) B, initial B) func(Either[E, A]) B {
 	)
 }
 
-func AltW[E, E1, A any](that func() Either[E1, A]) func(Either[E, A]) Either[E1, A] {
+func AltW[E, E1, A any](that L.Lazy[Either[E1, A]]) func(Either[E, A]) Either[E1, A] {
 	return Fold(F.Ignore1of1[E](that), Right[E1, A])
 }
 
-func Alt[E, A any](that func() Either[E, A]) func(Either[E, A]) Either[E, A] {
+func Alt[E, A any](that L.Lazy[Either[E, A]]) func(Either[E, A]) Either[E, A] {
 	return AltW[E](that)
 }
 
@@ -245,3 +244,15 @@ func MonadSequence3[E, T1, T2, T3, R any](e1 Either[E, T1], e2 Either[E, T2], e3
 func Swap[E, A any](val Either[E, A]) Either[A, E] {
 	return MonadFold(val, Right[A, E], Left[E, A])
 }
+
+func MonadFlap[E, B, A any](fab Either[E, func(A) B], a A) Either[E, B] {
+	return FC.MonadFlap(MonadMap[E, func(A) B, B], fab, a)
+}
+
+func Flap[E, B, A any](a A) func(Either[E, func(A) B]) Either[E, B] {
+	return F.Bind2nd(MonadFlap[E, B, A], a)
+}
+
+func MonadAlt[E, A any](fa Either[E, A], that L.Lazy[Either[E, A]]) Either[E, A] {
+	return MonadFold(fa, F.Ignore1of1[E](that), Of[E, A])
+}

either/either_test.go

@@ -112,6 +112,6 @@ func TestChainOptionK(t *testing.T) {
 }
 
 func TestFromOption(t *testing.T) {
-	assert.Equal(t, Left[int]("none"), FromOption[string, int](F.Constant("none"))(O.None[int]()))
-	assert.Equal(t, Right[string](1), FromOption[string, int](F.Constant("none"))(O.Some(1)))
+	assert.Equal(t, Left[int]("none"), FromOption[int](F.Constant("none"))(O.None[int]()))
+	assert.Equal(t, Right[string](1), FromOption[int](F.Constant("none"))(O.Some(1)))
 }

either/exec/exec.go

@@ -27,12 +27,10 @@ import (
 var (
 	// Command executes a command
 	// use this version if the command does not produce any side effect, i.e. if the output is uniquely determined by by the input
-	// typically you'd rather use the IOEither version of the command
+	// typically you'd rather use the [IOEither] version of the command
 	Command = F.Curry3(command)
 )
 
 func command(name string, args []string, in []byte) E.Either[error, exec.CommandOutput] {
-	return E.TryCatchError(func() (exec.CommandOutput, error) {
-		return GE.Exec(context.Background(), name, args, in)
-	})
+	return E.TryCatchError(GE.Exec(context.Background(), name, args, in))
 }

either/gen.go

@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-08-17 22:58:57.9925506 +0200 CEST m=+0.033401101
+// 2023-10-23 08:30:40.410373 +0200 CEST m=+0.010337601
 
 package either
 
@@ -13,9 +13,7 @@ import (
 // The inverse function is [Uneitherize0]
 func Eitherize0[F ~func() (R, error), R any](f F) func() Either[error, R] {
 	return func() Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f()
-		})
+		return TryCatchError(f())
 	}
 }
 
@@ -31,9 +29,7 @@ func Uneitherize0[F ~func() Either[error, R], R any](f F) func() (R, error) {
 // The inverse function is [Uneitherize1]
 func Eitherize1[F ~func(T0) (R, error), T0, R any](f F) func(T0) Either[error, R] {
 	return func(t0 T0) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0)
-		})
+		return TryCatchError(f(t0))
 	}
 }
 
@@ -76,9 +72,7 @@ func TraverseTuple1[F1 ~func(A1) Either[E, T1], E, A1, T1 any](f1 F1) func(T.Tup
 // The inverse function is [Uneitherize2]
 func Eitherize2[F ~func(T0, T1) (R, error), T0, T1, R any](f F) func(T0, T1) Either[error, R] {
 	return func(t0 T0, t1 T1) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1)
-		})
+		return TryCatchError(f(t0, t1))
 	}
 }
 
@@ -126,9 +120,7 @@ func TraverseTuple2[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], E, A
 // The inverse function is [Uneitherize3]
 func Eitherize3[F ~func(T0, T1, T2) (R, error), T0, T1, T2, R any](f F) func(T0, T1, T2) Either[error, R] {
 	return func(t0 T0, t1 T1, t2 T2) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2)
-		})
+		return TryCatchError(f(t0, t1, t2))
 	}
 }
 
@@ -181,9 +173,7 @@ func TraverseTuple3[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
 // The inverse function is [Uneitherize4]
 func Eitherize4[F ~func(T0, T1, T2, T3) (R, error), T0, T1, T2, T3, R any](f F) func(T0, T1, T2, T3) Either[error, R] {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3)
-		})
+		return TryCatchError(f(t0, t1, t2, t3))
 	}
 }
 
@@ -241,9 +231,7 @@ func TraverseTuple4[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
 // The inverse function is [Uneitherize5]
 func Eitherize5[F ~func(T0, T1, T2, T3, T4) (R, error), T0, T1, T2, T3, T4, R any](f F) func(T0, T1, T2, T3, T4) Either[error, R] {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3, t4)
-		})
+		return TryCatchError(f(t0, t1, t2, t3, t4))
 	}
 }
 
@@ -306,9 +294,7 @@ func TraverseTuple5[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
 // The inverse function is [Uneitherize6]
 func Eitherize6[F ~func(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) Either[error, R] {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3, t4, t5)
-		})
+		return TryCatchError(f(t0, t1, t2, t3, t4, t5))
 	}
 }
 
@@ -376,9 +362,7 @@ func TraverseTuple6[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
 // The inverse function is [Uneitherize7]
 func Eitherize7[F ~func(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) Either[error, R] {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3, t4, t5, t6)
-		})
+		return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6))
 	}
 }
 
@@ -451,9 +435,7 @@ func TraverseTuple7[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
 // The inverse function is [Uneitherize8]
 func Eitherize8[F ~func(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) Either[error, R] {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3, t4, t5, t6, t7)
-		})
+		return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6, t7))
 	}
 }
 
@@ -531,9 +513,7 @@ func TraverseTuple8[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
 // The inverse function is [Uneitherize9]
 func Eitherize9[F ~func(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) Either[error, R] {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3, t4, t5, t6, t7, t8)
-		})
+		return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8))
 	}
 }
 
@@ -616,9 +596,7 @@ func TraverseTuple9[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
 // The inverse function is [Uneitherize10]
 func Eitherize10[F ~func(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) Either[error, R] {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
-		})
+		return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9))
 	}
 }
 

either/http/request.go

@@ -35,17 +35,13 @@ var (
 func bodyRequest(method string) func(string) func([]byte) E.Either[error, *http.Request] {
 	return func(url string) func([]byte) E.Either[error, *http.Request] {
 		return func(body []byte) E.Either[error, *http.Request] {
-			return E.TryCatchError(func() (*http.Request, error) {
-				return http.NewRequest(method, url, bytes.NewReader(body))
-			})
+			return E.TryCatchError(http.NewRequest(method, url, bytes.NewReader(body)))
 		}
 	}
 }
 
 func noBodyRequest(method string) func(string) E.Either[error, *http.Request] {
 	return func(url string) E.Either[error, *http.Request] {
-		return E.TryCatchError(func() (*http.Request, error) {
-			return http.NewRequest(method, url, nil)
-		})
+		return E.TryCatchError(http.NewRequest(method, url, nil))
 	}
 }

either/logger.go

@@ -41,7 +41,7 @@ func Logger[E, A any](loggers ...*log.Logger) func(string) func(Either[E, A]) Ei
 		return func(ma Either[E, A]) Either[E, A] {
 			return F.Pipe1(
 				delegate(ma),
-				ChainTo[E, A](ma),
+				ChainTo[A](ma),
 			)
 		}
 	}

either/monoid.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 either
+
+import (
+	L "github.com/IBM/fp-go/lazy"
+	M "github.com/IBM/fp-go/monoid"
+)
+
+// AlternativeMonoid is the alternative [Monoid] for an [Either]
+func AlternativeMonoid[E, A any](m M.Monoid[A]) M.Monoid[Either[E, A]] {
+	return M.AlternativeMonoid(
+		Of[E, A],
+		MonadMap[E, A, func(A) A],
+		MonadAp[A, E, A],
+		MonadAlt[E, A],
+		m,
+	)
+}
+
+// AltMonoid is the alternative [Monoid] for an [Either]
+func AltMonoid[E, A any](zero L.Lazy[Either[E, A]]) M.Monoid[Either[E, A]] {
+	return M.AltMonoid(
+		zero,
+		MonadAlt[E, A],
+	)
+}

either/record.go

@@ -20,7 +20,7 @@ import (
 	RR "github.com/IBM/fp-go/internal/record"
 )
 
-// TraverseRecord transforms a record of options into an option of a record
+// TraverseRecordG transforms a record of options into an option of a record
 func TraverseRecordG[GA ~map[K]A, GB ~map[K]B, K comparable, E, A, B any](f func(A) Either[E, B]) func(GA) Either[E, GB] {
 	return RR.Traverse[GA](
 		Of[E, GB],
@@ -35,6 +35,21 @@ func TraverseRecord[K comparable, E, A, B any](f func(A) Either[E, B]) func(map[
 	return TraverseRecordG[map[K]A, map[K]B](f)
 }
 
+// TraverseRecordWithIndexG transforms a record of options into an option of a record
+func TraverseRecordWithIndexG[GA ~map[K]A, GB ~map[K]B, K comparable, E, A, B any](f func(K, A) Either[E, B]) func(GA) Either[E, GB] {
+	return RR.TraverseWithIndex[GA](
+		Of[E, GB],
+		Map[E, GB, func(B) GB],
+		Ap[GB, E, B],
+		f,
+	)
+}
+
+// TraverseRecordWithIndex transforms a record of eithers into an either of a record
+func TraverseRecordWithIndex[K comparable, E, A, B any](f func(K, A) Either[E, B]) func(map[K]A) Either[E, map[K]B] {
+	return TraverseRecordWithIndexG[map[K]A, map[K]B](f)
+}
+
 func SequenceRecordG[GA ~map[K]A, GOA ~map[K]Either[E, A], K comparable, E, A any](ma GOA) Either[E, GA] {
 	return TraverseRecordG[GOA, GA](F.Identity[Either[E, A]])(ma)
 }

either/resource_test.go

@@ -25,20 +25,14 @@ import (
 
 func TestWithResource(t *testing.T) {
 	onCreate := func() Either[error, *os.File] {
-		return TryCatchError(func() (*os.File, error) {
-			return os.CreateTemp("", "*")
-		})
+		return TryCatchError(os.CreateTemp("", "*"))
 	}
 	onDelete := F.Flow2(
 		func(f *os.File) Either[error, string] {
-			return TryCatchError(func() (string, error) {
-				return f.Name(), f.Close()
-			})
+			return TryCatchError(f.Name(), f.Close())
 		},
 		Chain(func(name string) Either[error, any] {
-			return TryCatchError(func() (any, error) {
-				return name, os.Remove(name)
-			})
+			return TryCatchError(any(name), os.Remove(name))
 		}),
 	)
 

either/semigroup.go

@@ -13,17 +13,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package file
+package either
 
 import (
-	"io"
-
-	IOE "github.com/IBM/fp-go/ioeither"
+	S "github.com/IBM/fp-go/semigroup"
 )
 
-// onClose closes a closeable resource
-func onClose[R io.Closer](r R) IOE.IOEither[error, R] {
-	return IOE.TryCatchError(func() (R, error) {
-		return r, r.Close()
-	})
+// AltSemigroup is the alternative [Semigroup] for an [Either]
+func AltSemigroup[E, A any]() S.Semigroup[Either[E, A]] {
+	return S.AltSemigroup(
+		MonadAlt[E, A],
+	)
 }

either/variadic.go

@@ -17,80 +17,60 @@ package either
 
 func Variadic0[V, R any](f func([]V) (R, error)) func(...V) Either[error, R] {
 	return func(v ...V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(v)
-		})
+		return TryCatchError(f(v))
 	}
 }
 
 func Variadic1[T1, V, R any](f func(T1, []V) (R, error)) func(T1, ...V) Either[error, R] {
 	return func(t1 T1, v ...V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t1, v)
-		})
+		return TryCatchError(f(t1, v))
 	}
 }
 
 func Variadic2[T1, T2, V, R any](f func(T1, T2, []V) (R, error)) func(T1, T2, ...V) Either[error, R] {
 	return func(t1 T1, t2 T2, v ...V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t1, t2, v)
-		})
+		return TryCatchError(f(t1, t2, v))
 	}
 }
 
 func Variadic3[T1, T2, T3, V, R any](f func(T1, T2, T3, []V) (R, error)) func(T1, T2, T3, ...V) Either[error, R] {
 	return func(t1 T1, t2 T2, t3 T3, v ...V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t1, t2, t3, v)
-		})
+		return TryCatchError(f(t1, t2, t3, v))
 	}
 }
 
 func Variadic4[T1, T2, T3, T4, V, R any](f func(T1, T2, T3, T4, []V) (R, error)) func(T1, T2, T3, T4, ...V) Either[error, R] {
 	return func(t1 T1, t2 T2, t3 T3, t4 T4, v ...V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t1, t2, t3, t4, v)
-		})
+		return TryCatchError(f(t1, t2, t3, t4, v))
 	}
 }
 
 func Unvariadic0[V, R any](f func(...V) (R, error)) func([]V) Either[error, R] {
 	return func(v []V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(v...)
-		})
+		return TryCatchError(f(v...))
 	}
 }
 
 func Unvariadic1[T1, V, R any](f func(T1, ...V) (R, error)) func(T1, []V) Either[error, R] {
 	return func(t1 T1, v []V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t1, v...)
-		})
+		return TryCatchError(f(t1, v...))
 	}
 }
 
 func Unvariadic2[T1, T2, V, R any](f func(T1, T2, ...V) (R, error)) func(T1, T2, []V) Either[error, R] {
 	return func(t1 T1, t2 T2, v []V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t1, t2, v...)
-		})
+		return TryCatchError(f(t1, t2, v...))
 	}
 }
 
 func Unvariadic3[T1, T2, T3, V, R any](f func(T1, T2, T3, ...V) (R, error)) func(T1, T2, T3, []V) Either[error, R] {
 	return func(t1 T1, t2 T2, t3 T3, v []V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t1, t2, t3, v...)
-		})
+		return TryCatchError(f(t1, t2, t3, v...))
 	}
 }
 
 func Unvariadic4[T1, T2, T3, T4, V, R any](f func(T1, T2, T3, T4, ...V) (R, error)) func(T1, T2, T3, T4, []V) Either[error, R] {
 	return func(t1 T1, t2 T2, t3 T3, t4 T4, v []V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t1, t2, t3, t4, v...)
-		})
+		return TryCatchError(f(t1, t2, t3, t4, v...))
 	}
 }

endomorphism/curry.go

@@ -0,0 +1,30 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package endomorphism
+
+import (
+	G "github.com/IBM/fp-go/endomorphism/generic"
+)
+
+// Curry2 curries a binary function
+func Curry2[FCT ~func(T0, T1) T1, T0, T1 any](f FCT) func(T0) Endomorphism[T1] {
+	return G.Curry2[Endomorphism[T1]](f)
+}
+
+// Curry3 curries a ternary function
+func Curry3[FCT ~func(T0, T1, T2) T2, T0, T1, T2 any](f FCT) func(T0) func(T1) Endomorphism[T2] {
+	return G.Curry3[Endomorphism[T2]](f)
+}

endomorphism/endo.go

@@ -0,0 +1,60 @@
+// 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 endomorphism
+
+import (
+	G "github.com/IBM/fp-go/endomorphism/generic"
+)
+
+func MonadAp[A any](fab Endomorphism[A], fa A) A {
+	return G.MonadAp[Endomorphism[A]](fab, fa)
+}
+
+func Ap[A any](fa A) func(Endomorphism[A]) A {
+	return G.Ap[Endomorphism[A]](fa)
+}
+
+func MonadFlap[A any](fab Endomorphism[A], a A) A {
+	return G.MonadFlap[Endomorphism[A]](fab, a)
+}
+
+func Flap[A any](a A) func(Endomorphism[A]) A {
+	return G.Flap[Endomorphism[A]](a)
+}
+
+func MonadMap[A any](fa A, f Endomorphism[A]) A {
+	return G.MonadMap[Endomorphism[A]](fa, f)
+}
+
+func Map[A any](f Endomorphism[A]) Endomorphism[A] {
+	return G.Map[Endomorphism[A]](f)
+}
+
+func MonadChain[A any](ma A, f Endomorphism[A]) A {
+	return G.MonadChain[Endomorphism[A]](ma, f)
+}
+
+func Chain[A any](f Endomorphism[A]) Endomorphism[A] {
+	return G.Chain[Endomorphism[A], A](f)
+}
+
+func MonadChainFirst[A any](fa A, f Endomorphism[A]) A {
+	return G.MonadChainFirst[Endomorphism[A]](fa, f)
+}
+
+func ChainFirst[A any](f Endomorphism[A]) Endomorphism[A] {
+	return G.ChainFirst[Endomorphism[A]](f)
+}

endomorphism/generic/curry.go

@@ -0,0 +1,36 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+// Curry2 is a duplicate of [F.Curry2] but because of the type system it's not compatible otherwise
+func Curry2[GT1 ~func(T1) T1, FCT ~func(T0, T1) T1, T0, T1 any](f FCT) func(T0) GT1 {
+	return func(t0 T0) GT1 {
+		return func(t1 T1) T1 {
+			return f(t0, t1)
+		}
+	}
+}
+
+// Curry2 is a duplicate of [F.Curry2] but because of the type system it's not compatible otherwise
+func Curry3[GT2 ~func(T2) T2, FCT ~func(T0, T1, T2) T2, T0, T1, T2 any](f FCT) func(T0) func(T1) GT2 {
+	return func(t0 T0) func(T1) GT2 {
+		return func(t1 T1) GT2 {
+			return func(t2 T2) T2 {
+				return f(t0, t1, t2)
+			}
+		}
+	}
+}

endomorphism/generic/endo.go

@@ -0,0 +1,60 @@
+// 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 (
+	I "github.com/IBM/fp-go/identity/generic"
+)
+
+func MonadAp[GA ~func(A) A, A any](fab GA, fa A) A {
+	return I.MonadAp[GA, A, A](fab, fa)
+}
+
+func Ap[GA ~func(A) A, A any](fa A) func(GA) A {
+	return I.Ap[GA, A, A](fa)
+}
+
+func MonadFlap[GA ~func(A) A, A any](fab GA, a A) A {
+	return I.MonadFlap[GA, A, A](fab, a)
+}
+
+func Flap[GA ~func(A) A, A any](a A) func(GA) A {
+	return I.Flap[GA, A, A](a)
+}
+
+func MonadMap[GA ~func(A) A, A any](fa A, f GA) A {
+	return I.MonadMap[GA, A, A](fa, f)
+}
+
+func Map[GA ~func(A) A, A any](f GA) GA {
+	return I.Map[GA, A, A](f)
+}
+
+func MonadChain[GA ~func(A) A, A any](ma A, f GA) A {
+	return I.MonadChain[GA, A, A](ma, f)
+}
+
+func Chain[GA ~func(A) A, A any](f GA) GA {
+	return I.Chain[GA, A](f)
+}
+
+func MonadChainFirst[GA ~func(A) A, A any](fa A, f GA) A {
+	return I.MonadChainFirst[GA, A, A](fa, f)
+}
+
+func ChainFirst[GA ~func(A) A, A any](f GA) GA {
+	return I.ChainFirst[GA, A, A](f)
+}

endomorphism/generic/monoid.go

@@ -0,0 +1,47 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	F "github.com/IBM/fp-go/function"
+	M "github.com/IBM/fp-go/monoid"
+	S "github.com/IBM/fp-go/semigroup"
+)
+
+// Of converts any function to an [Endomorphism]
+func Of[ENDO ~func(A) A, F ~func(A) A, A any](f F) ENDO {
+	return func(a A) A {
+		return f(a)
+	}
+}
+
+func Identity[ENDO ~func(A) A, A any]() ENDO {
+	return Of[ENDO](F.Identity[A])
+}
+
+func Compose[ENDO ~func(A) A, A any](f1, f2 ENDO) ENDO {
+	return Of[ENDO](F.Flow2(f1, f2))
+}
+
+// Semigroup for the Endomorphism where the `concat` operation is the usual function composition.
+func Semigroup[ENDO ~func(A) A, A any]() S.Semigroup[ENDO] {
+	return S.MakeSemigroup(Compose[ENDO])
+}
+
+// Monoid for the Endomorphism where the `concat` operation is the usual function composition.
+func Monoid[ENDO ~func(A) A, A any]() M.Monoid[ENDO] {
+	return M.MakeMonoid(Compose[ENDO], Identity[ENDO]())
+}

endomorphism/monoid.go

@@ -16,17 +16,30 @@
 package endomorphism
 
 import (
-	F "github.com/IBM/fp-go/function"
+	G "github.com/IBM/fp-go/endomorphism/generic"
 	M "github.com/IBM/fp-go/monoid"
 	S "github.com/IBM/fp-go/semigroup"
 )
 
+// Endomorphism is a function  that
+type Endomorphism[A any] func(A) A
+
+// Of converts any function to an [Endomorphism]
+func Of[F ~func(A) A, A any](f F) Endomorphism[A] {
+	return G.Of[Endomorphism[A]](f)
+}
+
+// Identity returns the identity [Endomorphism]
+func Identity[A any]() Endomorphism[A] {
+	return G.Identity[Endomorphism[A]]()
+}
+
 // Semigroup for the Endomorphism where the `concat` operation is the usual function composition.
-func Semigroup[A any]() S.Semigroup[func(A) A] {
-	return S.MakeSemigroup(F.Flow2[func(A) A, func(A) A])
+func Semigroup[A any]() S.Semigroup[Endomorphism[A]] {
+	return G.Semigroup[Endomorphism[A]]()
 }
 
 // Monoid for the Endomorphism where the `concat` operation is the usual function composition.
-func Monoid[A any]() M.Monoid[func(A) A] {
-	return M.MakeMonoid(F.Flow2[func(A) A, func(A) A], F.Identity[A])
+func Monoid[A any]() M.Monoid[Endomorphism[A]] {
+	return G.Monoid[Endomorphism[A]]()
 }

erasure/erasure.go

@@ -16,6 +16,8 @@
 package erasure
 
 import (
+	E "github.com/IBM/fp-go/either"
+	"github.com/IBM/fp-go/errors"
 	F "github.com/IBM/fp-go/function"
 )
 
@@ -29,6 +31,15 @@ func Unerase[T any](t any) T {
 	return *t.(*T)
 }
 
+// SafeUnerase converts an erased variable back to its original value
+func SafeUnerase[T any](t any) E.Either[error, T] {
+	return F.Pipe2(
+		t,
+		E.ToType[*T](errors.OnSome[any]("Value of type [%T] is not erased")),
+		E.Map[error](F.Deref[T]),
+	)
+}
+
 // Erase0 converts a type safe function into an erased function
 func Erase0[T1 any](f func() T1) func() any {
 	return F.Nullary2(f, Erase[T1])

exec/exec.go

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

file/getters.go

@@ -15,9 +15,24 @@
 
 package file
 
-import "os"
+import (
+	"io"
+	"path/filepath"
+)
 
-// GetName is the getter for the `Name` property of [os.File]
-func GetName(f *os.File) string {
-	return f.Name()
+// Join appends a filename to a root path
+func Join(name string) func(root string) string {
+	return func(root string) string {
+		return filepath.Join(root, name)
+	}
+}
+
+// ToReader converts a [io.Reader]
+func ToReader[R io.Reader](r R) io.Reader {
+	return r
+}
+
+// ToCloser converts a [io.Closer]
+func ToCloser[C io.Closer](c C) io.Closer {
+	return c
 }

function/bind.go

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

function/binds.go

@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-08-17 22:59:01.9404821 +0200 CEST m=+0.161366801
+// 2023-10-23 08:30:44.6474482 +0200 CEST m=+0.150851901
 
 package function
 

function/flip.go

@@ -0,0 +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 function
+
+// Flip reverses the order of parameters of a curried function
+func Flip[T1, T2, R any](f func(T1) func(T2) R) func(T2) func(T1) R {
+	return func(t2 T2) func(T1) R {
+		return func(t1 T1) R {
+			return f(t1)(t2)
+		}
+	}
+}

function/flip_test.go

@@ -0,0 +1,36 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package function
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFlip(t *testing.T) {
+
+	x := Curry2(func(a, b string) string {
+		return fmt.Sprintf("%s:%s", a, b)
+	})
+
+	assert.Equal(t, "a:b", x("a")("b"))
+
+	y := Flip(x)
+
+	assert.Equal(t, "b:a", y("a")("b"))
+}

function/function.go

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

function/gen.go

@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-08-17 22:58:59.8663985 +0200 CEST m=+0.103744101
+// 2023-10-23 08:30:41.7972101 +0200 CEST m=+0.008029101
 
 package function
 
@@ -24,6 +24,13 @@ func Unvariadic0[V, R any](f func(...V) R) func([]V) R {
 	}
 }
 
+// Unsliced0 converts a function taking a slice parameter into a function with 0 parameters
+func Unsliced0[F ~func([]T) R, T, R any](f F) func() R {
+	return func() R {
+		return f([]T{})
+	}
+}
+
 // Pipe1 takes an initial value t0 and successively applies 1 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe1[F1 ~func(T0) T1, T0, T1 any](t0 T0, f1 F1) T1 {
@@ -76,6 +83,13 @@ func Unvariadic1[T1, V, R any](f func(T1, ...V) R) func(T1, []V) R {
 	}
 }
 
+// Unsliced1 converts a function taking a slice parameter into a function with 1 parameters
+func Unsliced1[F ~func([]T) R, T, R any](f F) func(T) R {
+	return func(t1 T) R {
+		return f([]T{t1})
+	}
+}
+
 // Pipe2 takes an initial value t0 and successively applies 2 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe2[F1 ~func(T0) T1, F2 ~func(T1) T2, T0, T1, T2 any](t0 T0, f1 F1, f2 F2) T2 {
@@ -131,6 +145,13 @@ func Unvariadic2[T1, T2, V, R any](f func(T1, T2, ...V) R) func(T1, T2, []V) R {
 	}
 }
 
+// Unsliced2 converts a function taking a slice parameter into a function with 2 parameters
+func Unsliced2[F ~func([]T) R, T, R any](f F) func(T, T) R {
+	return func(t1, t2 T) R {
+		return f([]T{t1, t2})
+	}
+}
+
 // Pipe3 takes an initial value t0 and successively applies 3 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe3[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, T0, T1, T2, T3 any](t0 T0, f1 F1, f2 F2, f3 F3) T3 {
@@ -189,6 +210,13 @@ func Unvariadic3[T1, T2, T3, V, R any](f func(T1, T2, T3, ...V) R) func(T1, T2,
 	}
 }
 
+// Unsliced3 converts a function taking a slice parameter into a function with 3 parameters
+func Unsliced3[F ~func([]T) R, T, R any](f F) func(T, T, T) R {
+	return func(t1, t2, t3 T) R {
+		return f([]T{t1, t2, t3})
+	}
+}
+
 // Pipe4 takes an initial value t0 and successively applies 4 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe4[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, T0, T1, T2, T3, T4 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4) T4 {
@@ -250,6 +278,13 @@ func Unvariadic4[T1, T2, T3, T4, V, R any](f func(T1, T2, T3, T4, ...V) R) func(
 	}
 }
 
+// Unsliced4 converts a function taking a slice parameter into a function with 4 parameters
+func Unsliced4[F ~func([]T) R, T, R any](f F) func(T, T, T, T) R {
+	return func(t1, t2, t3, t4 T) R {
+		return f([]T{t1, t2, t3, t4})
+	}
+}
+
 // Pipe5 takes an initial value t0 and successively applies 5 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe5[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, T0, T1, T2, T3, T4, T5 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) T5 {
@@ -314,6 +349,13 @@ func Unvariadic5[T1, T2, T3, T4, T5, V, R any](f func(T1, T2, T3, T4, T5, ...V)
 	}
 }
 
+// Unsliced5 converts a function taking a slice parameter into a function with 5 parameters
+func Unsliced5[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T) R {
+	return func(t1, t2, t3, t4, t5 T) R {
+		return f([]T{t1, t2, t3, t4, t5})
+	}
+}
+
 // Pipe6 takes an initial value t0 and successively applies 6 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe6[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, T0, T1, T2, T3, T4, T5, T6 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) T6 {
@@ -381,6 +423,13 @@ func Unvariadic6[T1, T2, T3, T4, T5, T6, V, R any](f func(T1, T2, T3, T4, T5, T6
 	}
 }
 
+// Unsliced6 converts a function taking a slice parameter into a function with 6 parameters
+func Unsliced6[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T) R {
+	return func(t1, t2, t3, t4, t5, t6 T) R {
+		return f([]T{t1, t2, t3, t4, t5, t6})
+	}
+}
+
 // Pipe7 takes an initial value t0 and successively applies 7 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe7[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, T0, T1, T2, T3, T4, T5, T6, T7 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) T7 {
@@ -451,6 +500,13 @@ func Unvariadic7[T1, T2, T3, T4, T5, T6, T7, V, R any](f func(T1, T2, T3, T4, T5
 	}
 }
 
+// Unsliced7 converts a function taking a slice parameter into a function with 7 parameters
+func Unsliced7[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T) R {
+	return func(t1, t2, t3, t4, t5, t6, t7 T) R {
+		return f([]T{t1, t2, t3, t4, t5, t6, t7})
+	}
+}
+
 // Pipe8 takes an initial value t0 and successively applies 8 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe8[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, T0, T1, T2, T3, T4, T5, T6, T7, T8 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) T8 {
@@ -524,6 +580,13 @@ func Unvariadic8[T1, T2, T3, T4, T5, T6, T7, T8, V, R any](f func(T1, T2, T3, T4
 	}
 }
 
+// Unsliced8 converts a function taking a slice parameter into a function with 8 parameters
+func Unsliced8[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T) R {
+	return func(t1, t2, t3, t4, t5, t6, t7, t8 T) R {
+		return f([]T{t1, t2, t3, t4, t5, t6, t7, t8})
+	}
+}
+
 // Pipe9 takes an initial value t0 and successively applies 9 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe9[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) T9 {
@@ -600,6 +663,13 @@ func Unvariadic9[T1, T2, T3, T4, T5, T6, T7, T8, T9, V, R any](f func(T1, T2, T3
 	}
 }
 
+// Unsliced9 converts a function taking a slice parameter into a function with 9 parameters
+func Unsliced9[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T) R {
+	return func(t1, t2, t3, t4, t5, t6, t7, t8, t9 T) R {
+		return f([]T{t1, t2, t3, t4, t5, t6, t7, t8, t9})
+	}
+}
+
 // Pipe10 takes an initial value t0 and successively applies 10 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe10[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) T10 {
@@ -679,6 +749,13 @@ func Unvariadic10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, V, R any](f func(T1,
 	}
 }
 
+// Unsliced10 converts a function taking a slice parameter into a function with 10 parameters
+func Unsliced10[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T) R {
+	return func(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10 T) R {
+		return f([]T{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10})
+	}
+}
+
 // Pipe11 takes an initial value t0 and successively applies 11 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe11[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11) T11 {
@@ -761,6 +838,13 @@ func Unvariadic11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, V, R any](f func
 	}
 }
 
+// Unsliced11 converts a function taking a slice parameter into a function with 11 parameters
+func Unsliced11[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T, T) R {
+	return func(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11 T) R {
+		return f([]T{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11})
+	}
+}
+
 // Pipe12 takes an initial value t0 and successively applies 12 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe12[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12) T12 {
@@ -846,6 +930,13 @@ func Unvariadic12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, V, R any](f
 	}
 }
 
+// Unsliced12 converts a function taking a slice parameter into a function with 12 parameters
+func Unsliced12[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T, T, T) R {
+	return func(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12 T) R {
+		return f([]T{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12})
+	}
+}
+
 // Pipe13 takes an initial value t0 and successively applies 13 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe13[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13) T13 {
@@ -934,6 +1025,13 @@ func Unvariadic13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, V, R a
 	}
 }
 
+// Unsliced13 converts a function taking a slice parameter into a function with 13 parameters
+func Unsliced13[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T, T, T, T) R {
+	return func(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13 T) R {
+		return f([]T{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13})
+	}
+}
+
 // Pipe14 takes an initial value t0 and successively applies 14 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe14[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14) T14 {
@@ -1025,6 +1123,13 @@ func Unvariadic14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, V
 	}
 }
 
+// Unsliced14 converts a function taking a slice parameter into a function with 14 parameters
+func Unsliced14[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T, T, T, T, T) R {
+	return func(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14 T) R {
+		return f([]T{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14})
+	}
+}
+
 // Pipe15 takes an initial value t0 and successively applies 15 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe15[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15) T15 {
@@ -1119,6 +1224,13 @@ func Unvariadic15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
 	}
 }
 
+// Unsliced15 converts a function taking a slice parameter into a function with 15 parameters
+func Unsliced15[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) R {
+	return func(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15 T) R {
+		return f([]T{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15})
+	}
+}
+
 // Pipe16 takes an initial value t0 and successively applies 16 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe16[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16) T16 {
@@ -1216,6 +1328,13 @@ func Unvariadic16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
 	}
 }
 
+// Unsliced16 converts a function taking a slice parameter into a function with 16 parameters
+func Unsliced16[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) R {
+	return func(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16 T) R {
+		return f([]T{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16})
+	}
+}
+
 // Pipe17 takes an initial value t0 and successively applies 17 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe17[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17) T17 {
@@ -1316,6 +1435,13 @@ func Unvariadic17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
 	}
 }
 
+// Unsliced17 converts a function taking a slice parameter into a function with 17 parameters
+func Unsliced17[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) R {
+	return func(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17 T) R {
+		return f([]T{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17})
+	}
+}
+
 // Pipe18 takes an initial value t0 and successively applies 18 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe18[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18) T18 {
@@ -1419,6 +1545,13 @@ func Unvariadic18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
 	}
 }
 
+// Unsliced18 converts a function taking a slice parameter into a function with 18 parameters
+func Unsliced18[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) R {
+	return func(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18 T) R {
+		return f([]T{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18})
+	}
+}
+
 // Pipe19 takes an initial value t0 and successively applies 19 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe19[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, F19 ~func(T18) T19, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18, f19 F19) T19 {
@@ -1525,6 +1658,13 @@ func Unvariadic19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
 	}
 }
 
+// Unsliced19 converts a function taking a slice parameter into a function with 19 parameters
+func Unsliced19[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) R {
+	return func(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19 T) R {
+		return f([]T{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19})
+	}
+}
+
 // Pipe20 takes an initial value t0 and successively applies 20 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe20[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, F19 ~func(T18) T19, F20 ~func(T19) T20, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18, f19 F19, f20 F20) T20 {
@@ -1633,3 +1773,10 @@ func Unvariadic20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
 		return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, v...)
 	}
 }
+
+// Unsliced20 converts a function taking a slice parameter into a function with 20 parameters
+func Unsliced20[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) R {
+	return func(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20 T) R {
+		return f([]T{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20})
+	}
+}

function/generic/switch.go

@@ -0,0 +1,28 @@
+// 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
+
+// Switch applies a handler to different cases. The handers are stored in a map. A key function
+// extracts the case from a value.
+func Switch[HF ~func(T) R, N ~map[K]HF, KF ~func(T) K, K comparable, T, R any](kf KF, n N, d HF) HF {
+	return func(t T) R {
+		f, ok := n[kf(t)]
+		if ok {
+			return f(t)
+		}
+		return d(t)
+	}
+}

function/switch.go

@@ -0,0 +1,26 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package function
+
+import (
+	G "github.com/IBM/fp-go/function/generic"
+)
+
+// Switch applies a handler to different cases. The handers are stored in a map. A key function
+// extracts the case from a value.
+func Switch[K comparable, T, R any](kf func(T) K, n map[K]func(T) R, d func(T) R) func(T) R {
+	return G.Switch(kf, n, d)
+}

function/unvariadic_test.go

@@ -0,0 +1,45 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package function
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func fromLibrary(data ...string) string {
+	return strings.Join(data, "-")
+}
+
+func TestUnvariadic(t *testing.T) {
+
+	res := Pipe1(
+		[]string{"A", "B"},
+		Unvariadic0(fromLibrary),
+	)
+
+	assert.Equal(t, "A-B", res)
+}
+
+func TestVariadicArity(t *testing.T) {
+
+	f := Unsliced2(Unvariadic0(fromLibrary))
+
+	res := f("A", "B")
+	assert.Equal(t, "A-B", res)
+}

go.mod

@@ -4,11 +4,11 @@ go 1.20
 
 require (
 	github.com/stretchr/testify v1.8.4
-	github.com/urfave/cli/v2 v2.25.7
+	github.com/urfave/cli/v2 v2.26.0
 )
 
 require (
-	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect