fix: optimize PipeXXX calls

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

.github/workflows/build.yml

@@ -17,8 +17,8 @@ on:
 env:
   # Currently no way to detect automatically
   DEFAULT_BRANCH: main
-  GO_VERSION: 1.20.6 # renovate: datasource=golang-version depName=golang
-  NODE_VERSION: 18
+  GO_VERSION: 1.21.6 # renovate: datasource=golang-version depName=golang
+  NODE_VERSION: 20
   DRY_RUN: true
 
 jobs:
@@ -26,14 +26,14 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-version: [ '1.20.x', '1.21.x' ]
+        go-version: [ '1.20.x', '1.21.x']
     steps:
       # full checkout for semantic-release
-      - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+      - 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@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
         with:
           fetch-depth: 0
 
       - name: Set up Node.js ${{ env.NODE_VERSION }}
-        uses: actions/setup-node@8f152de45cc393bb48ce5d89d36b731f54556e65 # v4.0.0
+        uses: actions/setup-node@b39b52d1213e96004bfcb1c61a8a6fa8ab84f3e8 # v4.0.1
         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}}
 

.gitignore

@@ -1,3 +1,4 @@
 fp-go.exe
 main.exe
-build/
+build/
+.idea

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

@@ -17,6 +17,7 @@ package array
 
 import (
 	G "github.com/IBM/fp-go/array/generic"
+	EM "github.com/IBM/fp-go/endomorphism"
 	F "github.com/IBM/fp-go/function"
 	"github.com/IBM/fp-go/internal/array"
 	M "github.com/IBM/fp-go/monoid"
@@ -52,6 +53,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 +65,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 +89,38 @@ func filterMapRef[A, B any](fa []A, pred func(a *A) bool, f func(a *A) B) []B {
 	return result
 }
 
-func Filter[A any](pred func(A) bool) func([]A) []A {
-	return F.Bind2nd(filter[A], pred)
+// Filter returns a new array with all elements from the original array that match a predicate
+func Filter[A any](pred func(A) bool) EM.Endomorphism[[]A] {
+	return G.Filter[[]A](pred)
 }
 
-func FilterRef[A any](pred func(*A) bool) func([]A) []A {
+// 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) EM.Endomorphism[[]A] {
+	return G.FilterWithIndex[[]A](pred)
+}
+
+func FilterRef[A any](pred func(*A) bool) EM.Endomorphism[[]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 +142,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 {
@@ -210,7 +228,7 @@ func Last[A any](as []A) O.Option[A] {
 	return G.Last(as)
 }
 
-func PrependAll[A any](middle A) func([]A) []A {
+func PrependAll[A any](middle A) EM.Endomorphism[[]A] {
 	return func(as []A) []A {
 		count := len(as)
 		dst := count * 2
@@ -225,7 +243,7 @@ func PrependAll[A any](middle A) func([]A) []A {
 	}
 }
 
-func Intersperse[A any](middle A) func([]A) []A {
+func Intersperse[A any](middle A) EM.Endomorphism[[]A] {
 	prepend := PrependAll(middle)
 	return func(as []A) []A {
 		if IsEmpty(as) {
@@ -254,7 +272,7 @@ func Lookup[A any](idx int) func([]A) O.Option[A] {
 	return G.Lookup[[]A](idx)
 }
 
-func UpsertAt[A any](a A) func([]A) []A {
+func UpsertAt[A any](a A) EM.Endomorphism[[]A] {
 	return G.UpsertAt[[]A](a)
 }
 
@@ -287,26 +305,37 @@ func ConstNil[A any]() []A {
 	return array.ConstNil[[]A]()
 }
 
-func SliceRight[A any](start int) func([]A) []A {
+func SliceRight[A any](start int) EM.Endomorphism[[]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)
 }
 
-func Push[A any](a A) func([]A) []A {
-	return G.Push[[]A](a)
+func Push[A any](a A) EM.Endomorphism[[]A] {
+	return G.Push[EM.Endomorphism[[]A]](a)
 }
 
 func MonadFlap[B, A any](fab []func(A) B, a A) []B {
@@ -316,3 +345,7 @@ func MonadFlap[B, A any](fab []func(A) B, a A) []B {
 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)
 }
+
+func Prepend[A any](head A) EM.Endomorphism[[]A] {
+	return G.Prepend[EM.Endomorphism[[]A]](head)
+}

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

@@ -0,0 +1,66 @@
+// 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"
+)
+
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[S any](
+	empty S,
+) []S {
+	return G.Do[[]S, S](empty)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) []T,
+) func([]S1) []S2 {
+	return G.Bind[[]S1, []S2, []T, S1, S2, T](setter, f)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) T,
+) func([]S1) []S2 {
+	return G.Let[[]S1, []S2, S1, S2, T](setter, f)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	b T,
+) func([]S1) []S2 {
+	return G.LetTo[[]S1, []S2, S1, S2, T](setter, b)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[S1, T any](
+	setter func(T) S1,
+) func([]T) []S1 {
+	return G.BindTo[[]S1, []T, S1, T](setter)
+}
+
+// ApS attaches a value to a context [S1] to produce a context [S2] by considering the context and the value concurrently
+func ApS[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa []T,
+) func([]S1) []S2 {
+	return G.ApS[[]S1, []S2, []T, S1, S2, T](setter, fa)
+}

array/bind_test.go

@@ -0,0 +1,56 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package array
+
+import (
+	"testing"
+
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/utils"
+	"github.com/stretchr/testify/assert"
+)
+
+func getLastName(s utils.Initial) []string {
+	return Of("Doe")
+}
+
+func getGivenName(s utils.WithLastName) []string {
+	return Of("John")
+}
+
+func TestBind(t *testing.T) {
+
+	res := F.Pipe3(
+		Do(utils.Empty),
+		Bind(utils.SetLastName, getLastName),
+		Bind(utils.SetGivenName, getGivenName),
+		Map(utils.GetFullName),
+	)
+
+	assert.Equal(t, res, Of("John Doe"))
+}
+
+func TestApS(t *testing.T) {
+
+	res := F.Pipe3(
+		Do(utils.Empty),
+		ApS(utils.SetLastName, Of("Doe")),
+		ApS(utils.SetGivenName, Of("John")),
+		Map(utils.GetFullName),
+	)
+
+	assert.Equal(t, res, Of("John Doe"))
+}

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

@@ -29,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
@@ -118,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),
@@ -143,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]()
@@ -232,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 {
@@ -242,13 +319,23 @@ 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())
 	}
 }
 
-func Push[GA ~[]A, A any](a A) func(GA) GA {
+func Push[ENDO ~func(GA) GA, GA ~[]A, A any](a A) ENDO {
 	return F.Bind2nd(array.Push[GA, A], a)
 }
 
@@ -259,3 +346,7 @@ func MonadFlap[FAB ~func(A) B, GFAB ~[]FAB, GB ~[]B, A, B any](fab GFAB, a A) GB
 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)
 }
+
+func Prepend[ENDO ~func(AS) AS, AS []A, A any](head A) ENDO {
+	return array.Prepend[ENDO](head)
+}

array/generic/bind.go

@@ -0,0 +1,89 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	A "github.com/IBM/fp-go/internal/apply"
+	C "github.com/IBM/fp-go/internal/chain"
+	F "github.com/IBM/fp-go/internal/functor"
+)
+
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[GS ~[]S, S any](
+	empty S,
+) GS {
+	return Of[GS](empty)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[GS1 ~[]S1, GS2 ~[]S2, GT ~[]T, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) GT,
+) func(GS1) GS2 {
+	return C.Bind(
+		Chain[GS1, GS2, S1, S2],
+		Map[GT, GS2, T, S2],
+		setter,
+		f,
+	)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[GS1 ~[]S1, GS2 ~[]S2, S1, S2, T any](
+	key func(T) func(S1) S2,
+	f func(S1) T,
+) func(GS1) GS2 {
+	return F.Let(
+		Map[GS1, GS2, S1, S2],
+		key,
+		f,
+	)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[GS1 ~[]S1, GS2 ~[]S2, S1, S2, B any](
+	key func(B) func(S1) S2,
+	b B,
+) func(GS1) GS2 {
+	return F.LetTo(
+		Map[GS1, GS2, S1, S2],
+		key,
+		b,
+	)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[GS1 ~[]S1, GT ~[]T, S1, T any](
+	setter func(T) S1,
+) func(GT) GS1 {
+	return C.BindTo(
+		Map[GT, GS1, T, S1],
+		setter,
+	)
+}
+
+// ApS attaches a value to a context [S1] to produce a context [S2] by considering the context and the value concurrently
+func ApS[GS1 ~[]S1, GS2 ~[]S2, GT ~[]T, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa GT,
+) func(GS1) GS2 {
+	return A.ApS(
+		Ap[GS2, []func(T) S2, GT, S2, T],
+		Map[GS1, []func(T) S2, S1, func(T) S2],
+		setter,
+		fa,
+	)
+}

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,15 +18,16 @@ 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 {
 	// some performance checks
 	ll := len(left)
-	lr := len(right)
 	if ll == 0 {
 		return right
 	}
+	lr := len(right)
 	if lr == 0 {
 		return left
 	}
@@ -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

@@ -17,6 +17,7 @@ package nonempty
 
 import (
 	G "github.com/IBM/fp-go/array/generic"
+	EM "github.com/IBM/fp-go/endomorphism"
 	F "github.com/IBM/fp-go/function"
 	"github.com/IBM/fp-go/internal/array"
 	S "github.com/IBM/fp-go/semigroup"
@@ -65,6 +66,12 @@ func Reduce[A, B any](f func(B, A) B, initial B) func(NonEmptyArray[A]) B {
 	}
 }
 
+func ReduceRight[A, B any](f func(A, B) B, initial B) func(NonEmptyArray[A]) B {
+	return func(as NonEmptyArray[A]) B {
+		return array.ReduceRight(as, f, initial)
+	}
+}
+
 func Tail[A any](as NonEmptyArray[A]) []A {
 	return as[1:]
 }
@@ -122,3 +129,8 @@ func Fold[A any](s S.Semigroup[A]) func(NonEmptyArray[A]) A {
 		return array.Reduce(Tail(as), s.Concat, Head(as))
 	}
 }
+
+// Prepend prepends a single value to an array
+func Prepend[A any](head A) EM.Endomorphism[NonEmptyArray[A]] {
+	return array.Prepend[EM.Endomorphism[NonEmptyArray[A]]](head)
+}

array/testing/laws.go

@@ -0,0 +1,74 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package testing
+
+import (
+	"testing"
+
+	RA "github.com/IBM/fp-go/array"
+	EQ "github.com/IBM/fp-go/eq"
+	L "github.com/IBM/fp-go/internal/monad/testing"
+)
+
+// AssertLaws asserts the apply monad laws for the array monad
+func AssertLaws[A, B, C any](t *testing.T,
+	eqa EQ.Eq[A],
+	eqb EQ.Eq[B],
+	eqc EQ.Eq[C],
+
+	ab func(A) B,
+	bc func(B) C,
+) func(a A) bool {
+
+	return L.AssertLaws(t,
+		RA.Eq(eqa),
+		RA.Eq(eqb),
+		RA.Eq(eqc),
+
+		RA.Of[A],
+		RA.Of[B],
+		RA.Of[C],
+
+		RA.Of[func(A) A],
+		RA.Of[func(A) B],
+		RA.Of[func(B) C],
+		RA.Of[func(func(A) B) B],
+
+		RA.MonadMap[A, A],
+		RA.MonadMap[A, B],
+		RA.MonadMap[A, C],
+		RA.MonadMap[B, C],
+
+		RA.MonadMap[func(B) C, func(func(A) B) func(A) C],
+
+		RA.MonadChain[A, A],
+		RA.MonadChain[A, B],
+		RA.MonadChain[A, C],
+		RA.MonadChain[B, C],
+
+		RA.MonadAp[A, A],
+		RA.MonadAp[B, A],
+		RA.MonadAp[C, B],
+		RA.MonadAp[C, A],
+
+		RA.MonadAp[B, func(A) B],
+		RA.MonadAp[func(A) C, func(A) B],
+
+		ab,
+		bc,
+	)
+
+}

array/testing/laws_test.go

@@ -0,0 +1,47 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package testing
+
+import (
+	"fmt"
+	"testing"
+
+	EQ "github.com/IBM/fp-go/eq"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMonadLaws(t *testing.T) {
+	// some comparison
+	eqa := EQ.FromStrictEquals[bool]()
+	eqb := EQ.FromStrictEquals[int]()
+	eqc := EQ.FromStrictEquals[string]()
+
+	ab := func(a bool) int {
+		if a {
+			return 1
+		}
+		return 0
+	}
+
+	bc := func(b int) string {
+		return fmt.Sprintf("value %d", b)
+	}
+
+	laws := AssertLaws(t, eqa, eqb, eqc, ab, bc)
+
+	assert.True(t, laws(true))
+	assert.True(t, laws(false))
+}

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

cli/commands.go

@@ -34,5 +34,6 @@ func Commands() []*C.Command {
 		IOEitherCommand(),
 		IOCommand(),
 		IOOptionCommand(),
+		DICommand(),
 	}
 }

cli/di.go

@@ -0,0 +1,231 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cli
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"time"
+
+	C "github.com/urfave/cli/v2"
+)
+
+func generateMakeProvider(f *os.File, i int) {
+	// non generic version
+	fmt.Fprintf(f, "\n// MakeProvider%d creates a [DIE.Provider] for an [InjectionToken] from a function with %d dependencies\n", i, i)
+	fmt.Fprintf(f, "func MakeProvider%d[", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j+1)
+	}
+	fmt.Fprintf(f, " any, R any](\n")
+	fmt.Fprintf(f, "  token InjectionToken[R],\n")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, "  d%d Dependency[T%d],\n", j+1, j+1)
+	}
+	fmt.Fprintf(f, "  f func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j+1)
+	}
+	fmt.Fprintf(f, ") IOE.IOEither[error, R],\n")
+	fmt.Fprintf(f, ") DIE.Provider {\n")
+	fmt.Fprint(f, "  return DIE.MakeProvider(\n")
+	fmt.Fprint(f, "    token,\n")
+	fmt.Fprintf(f, "    MakeProviderFactory%d(\n", i)
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, "      d%d,\n", j+1)
+	}
+	fmt.Fprint(f, "      f,\n")
+	fmt.Fprint(f, "  ))\n")
+	fmt.Fprintf(f, "}\n")
+}
+
+func generateMakeTokenWithDefault(f *os.File, i int) {
+	// non generic version
+	fmt.Fprintf(f, "\n// MakeTokenWithDefault%d creates an [InjectionToken] with a default implementation with %d dependencies\n", i, i)
+	fmt.Fprintf(f, "func MakeTokenWithDefault%d[", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j+1)
+	}
+	fmt.Fprintf(f, " any, R any](\n")
+	fmt.Fprintf(f, "  name string,\n")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, "  d%d Dependency[T%d],\n", j+1, j+1)
+	}
+	fmt.Fprintf(f, "  f func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j+1)
+	}
+	fmt.Fprintf(f, ") IOE.IOEither[error, R],\n")
+	fmt.Fprintf(f, ") InjectionToken[R] {\n")
+	fmt.Fprintf(f, "  return MakeTokenWithDefault[R](name, MakeProviderFactory%d(\n", i)
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, "    d%d,\n", j+1)
+	}
+	fmt.Fprint(f, "    f,\n")
+	fmt.Fprint(f, "  ))\n")
+	fmt.Fprintf(f, "}\n")
+}
+
+func generateMakeProviderFactory(f *os.File, i int) {
+	// non generic version
+	fmt.Fprintf(f, "\n// MakeProviderFactory%d creates a [DIE.ProviderFactory] from a function with %d arguments and %d dependencies\n", i, i, i)
+	fmt.Fprintf(f, "func MakeProviderFactory%d[", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j+1)
+	}
+	fmt.Fprintf(f, " any, R any](\n")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, "  d%d Dependency[T%d],\n", j+1, j+1)
+	}
+	fmt.Fprintf(f, "  f func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j+1)
+	}
+	fmt.Fprintf(f, ") IOE.IOEither[error, R],\n")
+	fmt.Fprintf(f, ") DIE.ProviderFactory {\n")
+	fmt.Fprint(f, "  return DIE.MakeProviderFactory(\n")
+	fmt.Fprint(f, "    A.From[DIE.Dependency](\n")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, "      d%d,\n", j+1)
+	}
+	fmt.Fprint(f, "    ),\n")
+	fmt.Fprintf(f, "    eraseProviderFactory%d(\n", i)
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, "      d%d,\n", j+1)
+	}
+	fmt.Fprint(f, "      f,\n")
+	fmt.Fprint(f, "    ),\n")
+	fmt.Fprint(f, "  )\n")
+	fmt.Fprintf(f, "}\n")
+}
+
+func generateEraseProviderFactory(f *os.File, i int) {
+	// non generic version
+	fmt.Fprintf(f, "\n// eraseProviderFactory%d creates a function that takes a variadic number of untyped arguments and from a function of %d strongly typed arguments and %d dependencies\n", i, i, i)
+	fmt.Fprintf(f, "func eraseProviderFactory%d[", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j+1)
+	}
+	fmt.Fprintf(f, " any, R any](\n")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, "  d%d Dependency[T%d],\n", j+1, j+1)
+	}
+	fmt.Fprintf(f, "  f func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j+1)
+	}
+	fmt.Fprintf(f, ") IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] {\n")
+	fmt.Fprintf(f, "  ft := eraseTuple(T.Tupled%d(f))\n", i)
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, "  t%d := lookupAt[T%d](%d, d%d)\n", j+1, j+1, j, j+1)
+	}
+	fmt.Fprint(f, "  return func(params ...any) IOE.IOEither[error, any] {\n")
+	fmt.Fprintf(f, "    return ft(E.SequenceT%d(\n", i)
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, "      t%d(params),\n", j+1)
+	}
+	fmt.Fprint(f, "    ))\n")
+	fmt.Fprint(f, "  }\n")
+	fmt.Fprintf(f, "}\n")
+}
+
+func generateDIHelpers(filename string, count int) error {
+	dir, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+	absDir, err := filepath.Abs(dir)
+	if err != nil {
+		return err
+	}
+	pkg := filepath.Base(absDir)
+	f, err := os.Create(filepath.Clean(filename))
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	// log
+	log.Printf("Generating code in [%s] for package [%s] with [%d] repetitions ...", filename, pkg, count)
+
+	// some header
+	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
+	fmt.Fprintln(f, "// This file was generated by robots at")
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
+
+	fmt.Fprintf(f, "package %s\n\n", pkg)
+
+	fmt.Fprint(f, `
+import (
+	E "github.com/IBM/fp-go/either"
+	IOE "github.com/IBM/fp-go/ioeither"
+	T "github.com/IBM/fp-go/tuple"
+	A "github.com/IBM/fp-go/array"
+	DIE "github.com/IBM/fp-go/di/erasure"
+)
+`)
+
+	for i := 1; i <= count; i++ {
+		generateEraseProviderFactory(f, i)
+		generateMakeProviderFactory(f, i)
+		generateMakeTokenWithDefault(f, i)
+		generateMakeProvider(f, i)
+	}
+
+	return nil
+}
+
+func DICommand() *C.Command {
+	return &C.Command{
+		Name:  "di",
+		Usage: "generate code for the dependency injection package",
+		Flags: []C.Flag{
+			flagCount,
+			flagFilename,
+		},
+		Action: func(ctx *C.Context) error {
+			return generateDIHelpers(
+				ctx.String(keyFilename),
+				ctx.Int(keyCount),
+			)
+		},
+	}
+}

cli/pipe.go

@@ -265,10 +265,15 @@ func generatePipe(f *os.File, i int) {
 		fmt.Fprintf(f, ", f%d F%d", j, j)
 	}
 	fmt.Fprintf(f, ") T%d {\n", i)
-	for j := 1; j <= i; j++ {
-		fmt.Fprintf(f, "  t%d := f%d(t%d)\n", j, j, j-1)
+	fmt.Fprintf(f, "  return ")
+	for j := i; j >= 1; j-- {
+		fmt.Fprintf(f, "f%d(", j)
 	}
-	fmt.Fprintf(f, "  return t%d\n", i)
+	fmt.Fprintf(f, "t0")
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, ")")
+	}
+	fmt.Fprintf(f, "\n")
 	fmt.Fprintln(f, "}")
 }
 
@@ -295,15 +300,16 @@ func recurseCurry(f *os.File, indent string, total, count int) {
 func generateCurry(f *os.File, i int) {
 	// Create the curry version
 	fmt.Fprintf(f, "\n// Curry%d takes a function with %d parameters and returns a cascade of functions each taking only one parameter.\n// The inverse function is [Uncurry%d]\n", i, i, i)
-	fmt.Fprintf(f, "func Curry%d[T0", i)
-	for j := 1; j <= i; j++ {
+	fmt.Fprintf(f, "func Curry%d[FCT ~func(T0", i)
+	for j := 1; j < i; j++ {
 		fmt.Fprintf(f, ", T%d", j)
 	}
-	fmt.Fprintf(f, " any](f func(T0")
-	for j := 2; j <= i; j++ {
-		fmt.Fprintf(f, ", T%d", j-1)
+	fmt.Fprintf(f, ") T%d", i)
+	// type arguments
+	for j := 0; j <= i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
 	}
-	fmt.Fprintf(f, ") T%d) func(T0)", i)
+	fmt.Fprintf(f, " any](f FCT) func(T0)")
 	for j := 2; j <= i; j++ {
 		fmt.Fprintf(f, " func(T%d)", j-1)
 	}
@@ -315,15 +321,16 @@ func generateCurry(f *os.File, i int) {
 func generateUncurry(f *os.File, i int) {
 	// Create the uncurry version
 	fmt.Fprintf(f, "\n// Uncurry%d takes a cascade of %d functions each taking only one parameter and returns a function with %d parameters .\n// The inverse function is [Curry%d]\n", i, i, i, i)
-	fmt.Fprintf(f, "func Uncurry%d[T0", i)
-	for j := 1; j <= i; j++ {
+	fmt.Fprintf(f, "func Uncurry%d[FCT ~func(T0)", i)
+	for j := 1; j < i; j++ {
+		fmt.Fprintf(f, " func(T%d)", j)
+	}
+	fmt.Fprintf(f, " T%d", i)
+	// the type parameters
+	for j := 0; j <= i; j++ {
 		fmt.Fprintf(f, ", T%d", j)
 	}
-	fmt.Fprintf(f, " any](f")
-	for j := 1; j <= i; j++ {
-		fmt.Fprintf(f, " func(T%d)", j-1)
-	}
-	fmt.Fprintf(f, " T%d) func(", i)
+	fmt.Fprintf(f, " any](f FCT) func(")
 	for j := 1; j <= i; j++ {
 		if j > 1 {
 			fmt.Fprintf(f, ", ")

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/readereither/bind.go

@@ -0,0 +1,68 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readereither
+
+import (
+	"context"
+
+	G "github.com/IBM/fp-go/readereither/generic"
+)
+
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[S any](
+	empty S,
+) ReaderEither[S] {
+	return G.Do[ReaderEither[S], context.Context, error, S](empty)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) ReaderEither[T],
+) func(ReaderEither[S1]) ReaderEither[S2] {
+	return G.Bind[ReaderEither[S1], ReaderEither[S2], ReaderEither[T], context.Context, error, S1, S2, T](setter, f)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) T,
+) func(ReaderEither[S1]) ReaderEither[S2] {
+	return G.Let[ReaderEither[S1], ReaderEither[S2], context.Context, error, S1, S2, T](setter, f)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	b T,
+) func(ReaderEither[S1]) ReaderEither[S2] {
+	return G.LetTo[ReaderEither[S1], ReaderEither[S2], context.Context, error, S1, S2, T](setter, b)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[S1, T any](
+	setter func(T) S1,
+) func(ReaderEither[T]) ReaderEither[S1] {
+	return G.BindTo[ReaderEither[S1], ReaderEither[T], context.Context, error, S1, T](setter)
+}
+
+// ApS attaches a value to a context [S1] to produce a context [S2] by considering the context and the value concurrently
+func ApS[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa ReaderEither[T],
+) func(ReaderEither[S1]) ReaderEither[S2] {
+	return G.ApS[ReaderEither[S1], ReaderEither[S2], ReaderEither[T], context.Context, error, S1, S2, T](setter, fa)
+}

context/readereither/bind_test.go

@@ -0,0 +1,58 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readereither
+
+import (
+	"context"
+	"testing"
+
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/utils"
+	"github.com/stretchr/testify/assert"
+)
+
+func getLastName(s utils.Initial) ReaderEither[string] {
+	return Of("Doe")
+}
+
+func getGivenName(s utils.WithLastName) ReaderEither[string] {
+	return Of("John")
+}
+
+func TestBind(t *testing.T) {
+
+	res := F.Pipe3(
+		Do(utils.Empty),
+		Bind(utils.SetLastName, getLastName),
+		Bind(utils.SetGivenName, getGivenName),
+		Map(utils.GetFullName),
+	)
+
+	assert.Equal(t, res(context.Background()), E.Of[error]("John Doe"))
+}
+
+func TestApS(t *testing.T) {
+
+	res := F.Pipe3(
+		Do(utils.Empty),
+		ApS(utils.SetLastName, Of("Doe")),
+		ApS(utils.SetGivenName, Of("John")),
+		Map(utils.GetFullName),
+	)
+
+	assert.Equal(t, res(context.Background()), E.Of[error]("John Doe"))
+}

context/readerioeither/bind.go

@@ -0,0 +1,67 @@
+// 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"
+	IOE "github.com/IBM/fp-go/ioeither"
+)
+
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[S any](
+	empty S,
+) ReaderIOEither[S] {
+	return G.Do[ReaderIOEither[S], IOE.IOEither[error, S], S](empty)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) ReaderIOEither[T],
+) func(ReaderIOEither[S1]) ReaderIOEither[S2] {
+	return G.Bind[ReaderIOEither[S1], ReaderIOEither[S2], ReaderIOEither[T], IOE.IOEither[error, S1], IOE.IOEither[error, S2], IOE.IOEither[error, T], S1, S2, T](setter, f)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) T,
+) func(ReaderIOEither[S1]) ReaderIOEither[S2] {
+	return G.Let[ReaderIOEither[S1], ReaderIOEither[S2], IOE.IOEither[error, S1], IOE.IOEither[error, S2], S1, S2, T](setter, f)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	b T,
+) func(ReaderIOEither[S1]) ReaderIOEither[S2] {
+	return G.LetTo[ReaderIOEither[S1], ReaderIOEither[S2], IOE.IOEither[error, S1], IOE.IOEither[error, S2], S1, S2, T](setter, b)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[S1, T any](
+	setter func(T) S1,
+) func(ReaderIOEither[T]) ReaderIOEither[S1] {
+	return G.BindTo[ReaderIOEither[S1], ReaderIOEither[T], IOE.IOEither[error, S1], IOE.IOEither[error, T], S1, T](setter)
+}
+
+// ApS attaches a value to a context [S1] to produce a context [S2] by considering the context and the value concurrently
+func ApS[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa ReaderIOEither[T],
+) func(ReaderIOEither[S1]) ReaderIOEither[S2] {
+	return G.ApS[ReaderIOEither[func(T) S2], ReaderIOEither[S1], ReaderIOEither[S2], ReaderIOEither[T], IOE.IOEither[error, func(T) S2], IOE.IOEither[error, S1], IOE.IOEither[error, S2], IOE.IOEither[error, T], S1, S2, T](setter, fa)
+}

context/readerioeither/bind_test.go

@@ -0,0 +1,58 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerioeither
+
+import (
+	"context"
+	"testing"
+
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/utils"
+	"github.com/stretchr/testify/assert"
+)
+
+func getLastName(s utils.Initial) ReaderIOEither[string] {
+	return Of("Doe")
+}
+
+func getGivenName(s utils.WithLastName) ReaderIOEither[string] {
+	return Of("John")
+}
+
+func TestBind(t *testing.T) {
+
+	res := F.Pipe3(
+		Do(utils.Empty),
+		Bind(utils.SetLastName, getLastName),
+		Bind(utils.SetGivenName, getGivenName),
+		Map(utils.GetFullName),
+	)
+
+	assert.Equal(t, res(context.Background())(), E.Of[error]("John Doe"))
+}
+
+func TestApS(t *testing.T) {
+
+	res := F.Pipe3(
+		Do(utils.Empty),
+		ApS(utils.SetLastName, Of("Doe")),
+		ApS(utils.SetGivenName, Of("John")),
+		Map(utils.GetFullName),
+	)
+
+	assert.Equal(t, res(context.Background())(), E.Of[error]("John Doe"))
+}

context/readerioeither/generic/bind.go

@@ -0,0 +1,92 @@
+// 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"
+	A "github.com/IBM/fp-go/internal/apply"
+	C "github.com/IBM/fp-go/internal/chain"
+	F "github.com/IBM/fp-go/internal/functor"
+)
+
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[GRS ~func(context.Context) GS, GS ~func() ET.Either[error, S], S any](
+	empty S,
+) GRS {
+	return Of[GRS, GS, S](empty)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[GRS1 ~func(context.Context) GS1, GRS2 ~func(context.Context) GS2, GRT ~func(context.Context) GT, GS1 ~func() ET.Either[error, S1], GS2 ~func() ET.Either[error, S2], GT ~func() ET.Either[error, T], S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) GRT,
+) func(GRS1) GRS2 {
+	return C.Bind(
+		Chain[GRS1, GRS2, GS1, GS2, S1, S2],
+		Map[GRT, GRS2, GT, GS2, T, S2],
+		setter,
+		f,
+	)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[GRS1 ~func(context.Context) GS1, GRS2 ~func(context.Context) GS2, GS1 ~func() ET.Either[error, S1], GS2 ~func() ET.Either[error, S2], S1, S2, T any](
+	key func(T) func(S1) S2,
+	f func(S1) T,
+) func(GRS1) GRS2 {
+	return F.Let(
+		Map[GRS1, GRS2, GS1, GS2, S1, S2],
+		key,
+		f,
+	)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[GRS1 ~func(context.Context) GS1, GRS2 ~func(context.Context) GS2, GS1 ~func() ET.Either[error, S1], GS2 ~func() ET.Either[error, S2], S1, S2, B any](
+	key func(B) func(S1) S2,
+	b B,
+) func(GRS1) GRS2 {
+	return F.LetTo(
+		Map[GRS1, GRS2, GS1, GS2, S1, S2],
+		key,
+		b,
+	)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[GRS1 ~func(context.Context) GS1, GRT ~func(context.Context) GT, GS1 ~func() ET.Either[error, S1], GT ~func() ET.Either[error, T], S1, T any](
+	setter func(T) S1,
+) func(GRT) GRS1 {
+	return C.BindTo(
+		Map[GRT, GRS1, GT, GS1, T, S1],
+		setter,
+	)
+}
+
+// ApS attaches a value to a context [S1] to produce a context [S2] by considering the context and the value concurrently
+func ApS[GRTS1 ~func(context.Context) GTS1, GRS1 ~func(context.Context) GS1, GRS2 ~func(context.Context) GS2, GRT ~func(context.Context) GT, GTS1 ~func() ET.Either[error, func(T) S2], GS1 ~func() ET.Either[error, S1], GS2 ~func() ET.Either[error, S2], GT ~func() ET.Either[error, T], S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa GRT,
+) func(GRS1) GRS2 {
+	return A.ApS(
+		Ap[GRS2, GRTS1, GRT, GS2, GTS1, GT],
+		Map[GRS1, GRTS1, GS1, GTS1, S1, func(T) S2],
+		setter,
+		fa,
+	)
+}

context/readerioeither/generic/traverse.go

@@ -166,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/http/builder/builder.go

@@ -0,0 +1,72 @@
+// 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 builder
+
+import (
+	"bytes"
+	"context"
+	"net/http"
+	"strconv"
+
+	RIOE "github.com/IBM/fp-go/context/readerioeither"
+	RIOEH "github.com/IBM/fp-go/context/readerioeither/http"
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	R "github.com/IBM/fp-go/http/builder"
+	H "github.com/IBM/fp-go/http/headers"
+	LZ "github.com/IBM/fp-go/lazy"
+	O "github.com/IBM/fp-go/option"
+)
+
+func Requester(builder *R.Builder) RIOEH.Requester {
+
+	withBody := F.Curry3(func(data []byte, url string, method string) RIOE.ReaderIOEither[*http.Request] {
+		return RIOE.TryCatch(func(ctx context.Context) func() (*http.Request, error) {
+			return func() (*http.Request, error) {
+				req, err := http.NewRequestWithContext(ctx, method, url, bytes.NewReader(data))
+				if err == nil {
+					req.Header.Set(H.ContentLength, strconv.Itoa(len(data)))
+					H.Monoid.Concat(req.Header, builder.GetHeaders())
+				}
+				return req, err
+			}
+		})
+	})
+
+	withoutBody := F.Curry2(func(url string, method string) RIOE.ReaderIOEither[*http.Request] {
+		return RIOE.TryCatch(func(ctx context.Context) func() (*http.Request, error) {
+			return func() (*http.Request, error) {
+				req, err := http.NewRequestWithContext(ctx, method, url, nil)
+				if err == nil {
+					H.Monoid.Concat(req.Header, builder.GetHeaders())
+				}
+				return req, err
+			}
+		})
+	})
+
+	return F.Pipe5(
+		builder.GetBody(),
+		O.Fold(LZ.Of(E.Of[error](withoutBody)), E.Map[error](withBody)),
+		E.Ap[func(string) RIOE.ReaderIOEither[*http.Request]](builder.GetTargetUrl()),
+		E.Flap[error, RIOE.ReaderIOEither[*http.Request]](builder.GetMethod()),
+		E.GetOrElse(RIOE.Left[*http.Request]),
+		RIOE.Map(func(req *http.Request) *http.Request {
+			req.Header = H.Monoid.Concat(req.Header, builder.GetHeaders())
+			return req
+		}),
+	)
+}

context/readerioeither/http/builder/builder_test.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 builder
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"testing"
+
+	RIOE "github.com/IBM/fp-go/context/readerioeither"
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	R "github.com/IBM/fp-go/http/builder"
+	IO "github.com/IBM/fp-go/io"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBuilderWithQuery(t *testing.T) {
+	// add some query
+	withLimit := R.WithQueryArg("limit")("10")
+	withUrl := R.WithUrl("http://www.example.org?a=b")
+
+	b := F.Pipe2(
+		R.Default,
+		withLimit,
+		withUrl,
+	)
+
+	req := F.Pipe3(
+		b,
+		Requester,
+		RIOE.Map(func(r *http.Request) *url.URL {
+			return r.URL
+		}),
+		RIOE.ChainFirstIOK(func(u *url.URL) IO.IO[any] {
+			return IO.FromImpure(func() {
+				q := u.Query()
+				assert.Equal(t, "10", q.Get("limit"))
+				assert.Equal(t, "b", q.Get("a"))
+			})
+		}),
+	)
+
+	assert.True(t, E.IsRight(req(context.Background())()))
+}

context/readerioeither/traverse.go

@@ -48,3 +48,63 @@ func TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) ReaderIOEither
 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)
+}

di/app.go

@@ -0,0 +1,38 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package di
+
+import (
+	DIE "github.com/IBM/fp-go/di/erasure"
+	F "github.com/IBM/fp-go/function"
+	IO "github.com/IBM/fp-go/io"
+	IOE "github.com/IBM/fp-go/ioeither"
+)
+
+var (
+	// InjMain is the [InjectionToken] for the main application
+	InjMain = MakeToken[any]("APP")
+
+	// Main is the resolver for the main application
+	Main = Resolve(InjMain)
+)
+
+// RunMain runs the main application from a set of [DIE.Provider]s
+var RunMain = F.Flow3(
+	DIE.MakeInjector,
+	Main,
+	IOE.Fold(IO.Of[error], F.Constant1[any](IO.Of[error](nil))),
+)

di/doc.go

@@ -0,0 +1,43 @@
+// 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 implements functions and data types supporting dependency injection patterns
+//
+// The fundamental building block is the concept of a [Dependency]. This describes the abstract concept of a function, service or value together with its type.
+// Examples for dependencies can be as simple as configuration values such as the API URL for a service, the current username, a [Dependency] could be the map
+// of the configuration environment, an http client or as complex as a service interface. Important is that a [Dependency] only defines the concept but
+// not the implementation.
+//
+// The implementation of a [Dependency] is called a [Provider], the dependency of an `API URL` could e.g. be realized by a provider that consults the environment to read the information
+// or a config file or simply hardcode it.
+// In many cases the implementation of a [Provider] depends in turn on other [Dependency] (but never directly on other [Provider]s), a provider for an `API URL` that reads
+// the information from the environment would e.g. depend on a [Dependency] that represents this environment.
+//
+// It is the resposibility of the [InjectableFactory] to create an instance of a [Dependency]. All instances are considered singletons. Create an [InjectableFactory] via the [MakeInjector] method. Use [Resolve] to create a strongly typed
+// factory for a particular [InjectionToken].
+//
+// In most cases it is not required to use [InjectableFactory] directly, instead you would create a [Provider] via the [MakeProvider2] method (suffix indicates the number of dependencies). In this call
+// you give a number of (strongly typed) [Dependency] identifiers and a (strongly typed) factory function for the implementation. The dependency injection framework makes
+// sure to resolve the dependencies before calling the factory method.
+//
+// For convenience purposes it can be helpful to attach a default implementation of a [Dependency]. In this case use the [MakeTokenWithDefault2] method (suffix indicates the number of dependencies)
+// to define the [InjectionToken].
+//
+// [Provider]: [github.com/IBM/fp-go/di/erasure.Provider]
+// [InjectableFactory]: [github.com/IBM/fp-go/di/erasure.InjectableFactory]
+// [MakeInjector]: [github.com/IBM/fp-go/di/erasure.MakeInjector]
+package di
+
+//go:generate go run .. di --count 10 --filename gen.go

di/erasure/injector.go

@@ -0,0 +1,170 @@
+// 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
+//
+// The resulting [InjectableFactory] can then be used to retrieve service instances given their [Dependency]. The implementation
+// makes sure to transitively resolve the required dependencies.
+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,181 @@
+// 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 is a factory function that can create an untyped instance of a service based on its [Dependency] identifier
+	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])
+
+	mapDeps = F.Curry2(A.MonadMap[Dependency, IOE.IOEither[error, 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(
+		mapDeps(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,32 @@
+// 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,79 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package 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"
+)
+
+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 eraseTuple[A, R any](f func(A) IOE.IOEither[error, R]) func(E.Either[error, A]) IOE.IOEither[error, any] {
+	return F.Flow3(
+		IOE.FromEither[error, A],
+		IOE.Chain(f),
+		IOE.Map[error](F.ToAny[R]),
+	)
+}
+
+func eraseProviderFactory0[R any](f 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 MakeProviderFactory0[R any](
+	fct IOE.IOEither[error, R],
+) DIE.ProviderFactory {
+	return DIE.MakeProviderFactory(
+		A.Empty[DIE.Dependency](),
+		eraseProviderFactory0(fct),
+	)
+}
+
+// MakeTokenWithDefault0 creates a unique [InjectionToken] for a specific type with an attached default [DIE.Provider]
+func MakeTokenWithDefault0[R any](name string, fct IOE.IOEither[error, R]) InjectionToken[R] {
+	return MakeTokenWithDefault[R](name, MakeProviderFactory0(fct))
+}
+
+func MakeProvider0[R any](
+	token InjectionToken[R],
+	fct IOE.IOEither[error, R],
+) DIE.Provider {
+	return DIE.MakeProvider(
+		token,
+		MakeProviderFactory0(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, IOE.Of[error](value))
+}

di/provider_test.go

@@ -0,0 +1,346 @@
+// 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) 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) 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) 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", 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", 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,197 @@
+// 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 that can have multiple implementations.
+// Implementations are provided via the [MultiInjectionToken.Item] injection token.
+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,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 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,84 @@
+// 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/array.go

@@ -61,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/bind.go

@@ -0,0 +1,89 @@
+// 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 (
+	A "github.com/IBM/fp-go/internal/apply"
+	C "github.com/IBM/fp-go/internal/chain"
+	F "github.com/IBM/fp-go/internal/functor"
+)
+
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[E, S any](
+	empty S,
+) Either[E, S] {
+	return Of[E](empty)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[E, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) Either[E, T],
+) func(Either[E, S1]) Either[E, S2] {
+	return C.Bind(
+		Chain[E, S1, S2],
+		Map[E, T, S2],
+		setter,
+		f,
+	)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[E, S1, S2, T any](
+	key func(T) func(S1) S2,
+	f func(S1) T,
+) func(Either[E, S1]) Either[E, S2] {
+	return F.Let(
+		Map[E, S1, S2],
+		key,
+		f,
+	)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[E, S1, S2, T any](
+	key func(T) func(S1) S2,
+	b T,
+) func(Either[E, S1]) Either[E, S2] {
+	return F.LetTo(
+		Map[E, S1, S2],
+		key,
+		b,
+	)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[E, S1, T any](
+	setter func(T) S1,
+) func(Either[E, T]) Either[E, S1] {
+	return C.BindTo(
+		Map[E, T, S1],
+		setter,
+	)
+}
+
+// ApS attaches a value to a context [S1] to produce a context [S2] by considering the context and the value concurrently
+func ApS[E, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa Either[E, T],
+) func(Either[E, S1]) Either[E, S2] {
+	return A.ApS(
+		Ap[S2, E, T],
+		Map[E, S1, func(T) S2],
+		setter,
+		fa,
+	)
+}

either/bind_test.go

@@ -0,0 +1,56 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package either
+
+import (
+	"testing"
+
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/utils"
+	"github.com/stretchr/testify/assert"
+)
+
+func getLastName(s utils.Initial) Either[error, string] {
+	return Of[error]("Doe")
+}
+
+func getGivenName(s utils.WithLastName) Either[error, string] {
+	return Of[error]("John")
+}
+
+func TestBind(t *testing.T) {
+
+	res := F.Pipe3(
+		Do[error](utils.Empty),
+		Bind(utils.SetLastName, getLastName),
+		Bind(utils.SetGivenName, getGivenName),
+		Map[error](utils.GetFullName),
+	)
+
+	assert.Equal(t, res, Of[error]("John Doe"))
+}
+
+func TestApS(t *testing.T) {
+
+	res := F.Pipe3(
+		Do[error](utils.Empty),
+		ApS(utils.SetLastName, Of[error]("Doe")),
+		ApS(utils.SetGivenName, Of[error]("John")),
+		Map[error](utils.GetFullName),
+	)
+
+	assert.Equal(t, res, Of[error]("John Doe"))
+}

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

@@ -67,16 +67,17 @@ func MapTo[E, A, B any](b B) func(Either[E, A]) Either[E, B] {
 	return F.Bind2nd(MonadMapTo[E, A, B], b)
 }
 
-func MonadMapLeft[E, A, B any](fa Either[E, A], f func(E) B) Either[B, A] {
-	return MonadFold(fa, F.Flow2(f, Left[A, B]), Right[B, A])
+func MonadMapLeft[E1, A, E2 any](fa Either[E1, A], f func(E1) E2) Either[E2, A] {
+	return MonadFold(fa, F.Flow2(f, Left[A, E2]), Right[E2, A])
 }
 
 func Map[E, A, B any](f func(a A) B) func(fa Either[E, A]) Either[E, B] {
 	return Chain(F.Flow2(f, Right[E, B]))
 }
 
-func MapLeft[E, A, B any](f func(E) B) func(fa Either[E, A]) Either[B, A] {
-	return F.Bind2nd(MonadMapLeft[E, A, B], f)
+// MapLeft applies a mapping function to the error channel
+func MapLeft[A, E1, E2 any](f func(E1) E2) func(fa Either[E1, A]) Either[E2, A] {
+	return F.Bind2nd(MonadMapLeft[E1, A, E2], f)
 }
 
 func MonadChain[E, A, B any](fa Either[E, A], f func(a A) Either[E, B]) Either[E, B] {
@@ -89,7 +90,7 @@ 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
 }
 
@@ -104,8 +105,8 @@ func ChainOptionK[A, B, E any](onNone func() E) func(func(A) O.Option[B]) func(E
 	}
 }
 
-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] {

either/eq.go

@@ -34,7 +34,7 @@ func Eq[E, A any](e EQ.Eq[E], a EQ.Eq[A]) EQ.Eq[Either[E, A]] {
 	return EQ.FromEquals(F.Uncurry2(fld))
 }
 
-// FromStrictEquals constructs an `Eq` from the canonical comparison function
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
 func FromStrictEquals[E, A comparable]() EQ.Eq[Either[E, A]] {
 	return Eq(EQ.FromStrictEquals[E](), EQ.FromStrictEquals[A]())
 }

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

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,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 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 MonadChain[A any](ma Endomorphism[A], f Endomorphism[A]) Endomorphism[A] {
+	return G.MonadChain[Endomorphism[A]](ma, f)
+}
+
+func Chain[A any](f Endomorphism[A]) Endomorphism[Endomorphism[A]] {
+	return G.Chain[Endomorphism[Endomorphism[A]], Endomorphism[A], 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,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 generic
+
+import (
+	F "github.com/IBM/fp-go/function"
+	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 MonadChain[GA ~func(A) A, A any](ma GA, f GA) GA {
+	return Compose(ma, f)
+}
+
+func Chain[ENDO ~func(GA) GA, GA ~func(A) A, A any](f GA) ENDO {
+	return Of[ENDO](F.Bind2nd(Compose[GA], f))
+}

endomorphism/generic/monoid.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 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)
+	}
+}
+
+// Wrap converts any function to an [Endomorphism]
+func Wrap[ENDO ~func(A) A, F ~func(A) A, A any](f F) ENDO {
+	return Of[ENDO](f)
+}
+
+// Unwrap converts any [Endomorphism] to a normal function
+func Unwrap[F ~func(A) A, ENDO ~func(A) A, A any](f ENDO) F {
+	return Of[F](f)
+}
+
+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,40 @@
 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)
+}
+
+// Wrap converts any function to an [Endomorphism]
+func Wrap[F ~func(A) A, A any](f F) Endomorphism[A] {
+	return G.Wrap[Endomorphism[A]](f)
+}
+
+// Unwrap converts any [Endomorphism] to a function
+func Unwrap[F ~func(A) A, A any](f Endomorphism[A]) F {
+	return G.Unwrap[F](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]]()
 }

eq/eq.go

@@ -35,12 +35,12 @@ func strictEq[A comparable](a, b A) bool {
 	return a == b
 }
 
-// FromStrictEquals constructs an `Eq` from the canonical comparison function
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
 func FromStrictEquals[T comparable]() Eq[T] {
 	return FromEquals(strictEq[T])
 }
 
-// FromEquals constructs an `Eq` from the comparison function
+// FromEquals constructs an [EQ.Eq] from the comparison function
 func FromEquals[T any](c func(x, y T) bool) Eq[T] {
 	return eq[T]{c: c}
 }

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])

file/getters.go

@@ -15,7 +15,10 @@
 
 package file
 
-import "path/filepath"
+import (
+	"io"
+	"path/filepath"
+)
 
 // Join appends a filename to a root path
 func Join(name string) func(root string) string {
@@ -23,3 +26,13 @@ func Join(name string) 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/binds.go

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

function/cache.go

@@ -28,3 +28,14 @@ func Memoize[K comparable, T any](f func(K) T) func(K) T {
 func ContramapMemoize[A any, K comparable, T any](kf func(A) K) func(func(A) T) func(A) T {
 	return G.ContramapMemoize[func(A) T](kf)
 }
+
+// CacheCallback converts a unary function into a unary function that caches the value depending on the parameter
+func CacheCallback[
+	A any, K comparable, T any](kf func(A) K, getOrCreate func(K, func() func() T) func() T) func(func(A) T) func(A) T {
+	return G.CacheCallback[func(func(A) T) func(A) T](kf, getOrCreate)
+}
+
+// SingleElementCache creates a cache function for use with the [CacheCallback] method that has a maximum capacity of one single item
+func SingleElementCache[K comparable, T any]() func(K, func() func() T) func() T {
+	return G.SingleElementCache[func() func() T, K]()
+}

function/cache_test.go

@@ -16,6 +16,8 @@
 package function
 
 import (
+	"fmt"
+	"math/rand"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -48,3 +50,21 @@ func TestCache(t *testing.T) {
 	assert.Equal(t, 10, cached(10))
 	assert.Equal(t, 2, count)
 }
+
+func TestSingleElementCache(t *testing.T) {
+	f := func(key string) string {
+		return fmt.Sprintf("%s: %d", key, rand.Int())
+	}
+	cb := CacheCallback(func(s string) string { return s }, SingleElementCache[string, string]())
+	cf := cb(f)
+
+	v1 := cf("1")
+	v2 := cf("1")
+	v3 := cf("2")
+	v4 := cf("1")
+
+	assert.Equal(t, v1, v2)
+	assert.NotEqual(t, v2, v3)
+	assert.NotEqual(t, v3, v4)
+	assert.NotEqual(t, v1, v4)
+}

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/generic/cache.go

@@ -28,7 +28,7 @@ func Memoize[F ~func(K) T, K comparable, T any](f F) F {
 
 // ContramapMemoize converts a unary function into a unary function that caches the value depending on the parameter
 func ContramapMemoize[F ~func(A) T, KF func(A) K, A any, K comparable, T any](kf KF) func(F) F {
-	return CacheCallback[F](kf, getOrCreate[K, T]())
+	return CacheCallback[func(F) F, func() func() T](kf, getOrCreate[K, T]())
 }
 
 // getOrCreate is a naive implementation of a cache, without bounds
@@ -50,13 +50,51 @@ func getOrCreate[K comparable, T any]() func(K, func() func() T) func() T {
 	}
 }
 
+// SingleElementCache is a cache with a capacity of a single element
+func SingleElementCache[
+	LLT ~func() LT, // generator of the generator
+	K comparable, // key into the cache
+	LT ~func() T, // generator of a value
+	T any, // the cached data type
+]() func(K, LLT) LT {
+	var l sync.Mutex
+
+	var key K
+	var value LT
+	hasKey := false
+
+	return func(k K, gen LLT) LT {
+		l.Lock()
+
+		existing := value
+		if !hasKey || key != k {
+			existing = gen()
+			// update state
+			key = k
+			value = existing
+			hasKey = true
+		}
+
+		l.Unlock()
+
+		return existing
+	}
+}
+
 // CacheCallback converts a unary function into a unary function that caches the value depending on the parameter
-func CacheCallback[F ~func(A) T, KF func(A) K, C ~func(K, func() func() T) func() T, A any, K comparable, T any](kf KF, getOrCreate C) func(F) F {
+func CacheCallback[
+	EM ~func(F) F, // endomorphism of the function
+	LLT ~func() LT, // generator of the generator
+	LT ~func() T, // generator of a value
+	F ~func(A) T, // function to actually cache
+	KF func(A) K, // extracts the cache key from the input
+	C ~func(K, LLT) LT, // the cache callback function
+	A any, K comparable, T any](kf KF, getOrCreate C) EM {
 	return func(f F) F {
 		return func(a A) T {
 			// cache entry
-			return getOrCreate(kf(a), func() func() T {
-				return L.Memoize[func() T](func() T {
+			return getOrCreate(kf(a), func() LT {
+				return L.Memoize[LT](func() T {
 					return f(a)
 				})
 			})()

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

go.mod

@@ -4,7 +4,7 @@ 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.27.1
 )
 
 require (
@@ -12,6 +12,6 @@ require (
 	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
-	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
+	github.com/xrash/smetrics v0.0.0-20231213231151-1d8dd44e695e // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -8,10 +8,10 @@ github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/urfave/cli/v2 v2.25.7 h1:VAzn5oq403l5pHjc4OhD54+XGO9cdKVL/7lDjF+iKUs=
-github.com/urfave/cli/v2 v2.25.7/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ=
-github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU=
-github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8=
+github.com/urfave/cli/v2 v2.27.1 h1:8xSQ6szndafKVRmfyeUMxkNUJQMjL1F2zmsZ+qHpfho=
+github.com/urfave/cli/v2 v2.27.1/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ=
+github.com/xrash/smetrics v0.0.0-20231213231151-1d8dd44e695e h1:+SOyEddqYF09QP7vr7CgJ1eti3pY9Fn3LHO1M1r/0sI=
+github.com/xrash/smetrics v0.0.0-20231213231151-1d8dd44e695e/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

http/builder/builder.go

@@ -0,0 +1,311 @@
+// 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 builder
+
+import (
+	"net/http"
+	"net/url"
+
+	E "github.com/IBM/fp-go/either"
+	ENDO "github.com/IBM/fp-go/endomorphism"
+	F "github.com/IBM/fp-go/function"
+	C "github.com/IBM/fp-go/http/content"
+	FM "github.com/IBM/fp-go/http/form"
+	H "github.com/IBM/fp-go/http/headers"
+	J "github.com/IBM/fp-go/json"
+	LZ "github.com/IBM/fp-go/lazy"
+	L "github.com/IBM/fp-go/optics/lens"
+	O "github.com/IBM/fp-go/option"
+	S "github.com/IBM/fp-go/string"
+	T "github.com/IBM/fp-go/tuple"
+)
+
+type (
+	Builder struct {
+		method  O.Option[string]
+		url     string
+		headers http.Header
+		body    O.Option[E.Either[error, []byte]]
+		query   url.Values
+	}
+
+	// Endomorphism returns an [ENDO.Endomorphism] that transforms a builder
+	Endomorphism = ENDO.Endomorphism[*Builder]
+)
+
+var (
+	// Default is the default builder
+	Default = &Builder{method: O.Some(defaultMethod()), headers: make(http.Header), body: noBody}
+
+	defaultMethod = F.Constant(http.MethodGet)
+
+	// Monoid is the [M.Monoid] for the [Endomorphism]
+	Monoid = ENDO.Monoid[*Builder]()
+
+	// Url is a [L.Lens] for the URL
+	Url = L.MakeLensRef((*Builder).GetUrl, (*Builder).SetUrl)
+	// Method is a [L.Lens] for the HTTP method
+	Method = L.MakeLensRef((*Builder).GetMethod, (*Builder).SetMethod)
+	// Body is a [L.Lens] for the request body
+	Body = L.MakeLensRef((*Builder).GetBody, (*Builder).SetBody)
+	// Headers is a [L.Lens] for the complete set of request headers
+	Headers = L.MakeLensRef((*Builder).GetHeaders, (*Builder).SetHeaders)
+	// Query is a [L.Lens] for the set of query parameters
+	Query = L.MakeLensRef((*Builder).GetQuery, (*Builder).SetQuery)
+
+	rawQuery = L.MakeLensRef(getRawQuery, setRawQuery)
+
+	getHeader = F.Bind2of2((*Builder).GetHeader)
+	delHeader = F.Bind2of2((*Builder).DelHeader)
+	setHeader = F.Bind2of3((*Builder).SetHeader)
+
+	noHeader   = O.None[string]()
+	noBody     = O.None[E.Either[error, []byte]]()
+	noQueryArg = O.None[string]()
+
+	parseUrl   = E.Eitherize1(url.Parse)
+	parseQuery = E.Eitherize1(url.ParseQuery)
+
+	// WithQuery creates a [Endomorphism] for a complete set of query parameters
+	WithQuery = Query.Set
+	// WithMethod creates a [Endomorphism] for a certain method
+	WithMethod = Method.Set
+	// WithUrl creates a [Endomorphism] for a certain method
+	WithUrl = Url.Set
+	// WithHeaders creates a [Endomorphism] for a set of headers
+	WithHeaders = Headers.Set
+	// WithBody creates a [Endomorphism] for a request body
+	WithBody = F.Flow2(
+		O.Of[E.Either[error, []byte]],
+		Body.Set,
+	)
+	// WithBytes creates a [Endomorphism] for a request body using bytes
+	WithBytes = F.Flow2(
+		E.Of[error, []byte],
+		WithBody,
+	)
+	// WithContentType adds the [H.ContentType] header
+	WithContentType = WithHeader(H.ContentType)
+	// WithAuthorization adds the [H.Authorization] header
+	WithAuthorization = WithHeader(H.Authorization)
+
+	// WithGet adds the [http.MethodGet] method
+	WithGet = WithMethod(http.MethodGet)
+	// WithPost adds the [http.MethodPost] method
+	WithPost = WithMethod(http.MethodPost)
+	// WithPut adds the [http.MethodPut] method
+	WithPut = WithMethod(http.MethodPut)
+	// WithDelete adds the [http.MethodDelete] method
+	WithDelete = WithMethod(http.MethodDelete)
+
+	// WithBearer creates a [Endomorphism] to add a Bearer [H.Authorization] header
+	WithBearer = F.Flow2(
+		S.Format[string]("Bearer %s"),
+		WithAuthorization,
+	)
+
+	// WithoutBody creates a [Endomorphism] to remove the body
+	WithoutBody = F.Pipe1(
+		noBody,
+		Body.Set,
+	)
+
+	// WithFormData creates a [Endomorphism] to send form data payload
+	WithFormData = F.Flow4(
+		url.Values.Encode,
+		S.ToBytes,
+		WithBytes,
+		ENDO.Chain(WithContentType(C.FormEncoded)),
+	)
+)
+
+func setRawQuery(u *url.URL, raw string) *url.URL {
+	u.RawQuery = raw
+	return u
+}
+
+func getRawQuery(u *url.URL) string {
+	return u.RawQuery
+}
+
+func (builder *Builder) clone() *Builder {
+	cpy := *builder
+	cpy.headers = cpy.headers.Clone()
+	return &cpy
+}
+
+// GetTargetUrl constructs a full URL with query parameters on top of the provided URL string
+func (builder *Builder) GetTargetUrl() E.Either[error, string] {
+	// construct the final URL
+	return F.Pipe3(
+		builder,
+		Url.Get,
+		parseUrl,
+		E.Chain(F.Flow4(
+			T.Replicate2[*url.URL],
+			T.Map2(
+				F.Flow2(
+					F.Curry2(setRawQuery),
+					E.Of[error, func(string) *url.URL],
+				),
+				F.Flow3(
+					rawQuery.Get,
+					parseQuery,
+					E.Map[error](F.Flow2(
+						F.Curry2(FM.ValuesMonoid.Concat)(builder.GetQuery()),
+						(url.Values).Encode,
+					)),
+				),
+			),
+			T.Tupled2(E.MonadAp[*url.URL, error, string]),
+			E.Map[error]((*url.URL).String),
+		)),
+	)
+}
+
+func (builder *Builder) GetUrl() string {
+	return builder.url
+}
+
+func (builder *Builder) GetMethod() string {
+	return F.Pipe1(
+		builder.method,
+		O.GetOrElse(defaultMethod),
+	)
+}
+
+func (builder *Builder) GetHeaders() http.Header {
+	return builder.headers
+}
+
+func (builder *Builder) GetQuery() url.Values {
+	return builder.query
+}
+
+func (builder *Builder) SetQuery(query url.Values) *Builder {
+	builder.query = query
+	return builder
+}
+
+func (builder *Builder) GetBody() O.Option[E.Either[error, []byte]] {
+	return builder.body
+}
+
+func (builder *Builder) SetMethod(method string) *Builder {
+	builder.method = O.Some(method)
+	return builder
+}
+
+func (builder *Builder) SetUrl(url string) *Builder {
+	builder.url = url
+	return builder
+}
+
+func (builder *Builder) SetHeaders(headers http.Header) *Builder {
+	builder.headers = headers
+	return builder
+}
+
+func (builder *Builder) SetBody(body O.Option[E.Either[error, []byte]]) *Builder {
+	builder.body = body
+	return builder
+}
+
+func (builder *Builder) SetHeader(name, value string) *Builder {
+	builder.headers.Set(name, value)
+	return builder
+}
+
+func (builder *Builder) DelHeader(name string) *Builder {
+	builder.headers.Del(name)
+	return builder
+}
+
+func (builder *Builder) GetHeader(name string) O.Option[string] {
+	return F.Pipe2(
+		name,
+		builder.headers.Get,
+		O.FromPredicate(S.IsNonEmpty),
+	)
+}
+
+func (builder *Builder) GetHeaderValues(name string) []string {
+	return builder.headers.Values(name)
+}
+
+// Header returns a [L.Lens] for a single header
+func Header(name string) L.Lens[*Builder, O.Option[string]] {
+	get := getHeader(name)
+	set := F.Bind1of2(setHeader(name))
+	del := F.Flow2(
+		LZ.Of[*Builder],
+		LZ.Map(delHeader(name)),
+	)
+
+	return L.MakeLens(get, func(b *Builder, value O.Option[string]) *Builder {
+		cpy := b.clone()
+		return F.Pipe1(
+			value,
+			O.Fold(del(cpy), set(cpy)),
+		)
+	})
+}
+
+// WithHeader creates a [Endomorphism] for a certain header
+func WithHeader(name string) func(value string) Endomorphism {
+	return F.Flow2(
+		O.Of[string],
+		Header(name).Set,
+	)
+}
+
+// WithoutHeader creates a [Endomorphism] to remove a certain header
+func WithoutHeader(name string) Endomorphism {
+	return Header(name).Set(noHeader)
+}
+
+// WithJson creates a [Endomorphism] to send JSON payload
+func WithJson[T any](data T) Endomorphism {
+	return Monoid.Concat(
+		F.Pipe2(
+			data,
+			J.Marshal[T],
+			WithBody,
+		),
+		WithContentType(C.Json),
+	)
+}
+
+// QueryArg is a [L.Lens] for the first value of a query argument
+func QueryArg(name string) L.Lens[*Builder, O.Option[string]] {
+	return F.Pipe1(
+		Query,
+		L.Compose[*Builder](FM.AtValue(name)),
+	)
+}
+
+// WithQueryArg creates a [Endomorphism] for a certain query argument
+func WithQueryArg(name string) func(value string) Endomorphism {
+	return F.Flow2(
+		O.Of[string],
+		QueryArg(name).Set,
+	)
+}
+
+// WithoutQueryArg creates a [Endomorphism] that removes a query argument
+func WithoutQueryArg(name string) Endomorphism {
+	return QueryArg(name).Set(noQueryArg)
+}

http/builder/builder_test.go

@@ -0,0 +1,68 @@
+// 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 builder
+
+import (
+	"testing"
+
+	F "github.com/IBM/fp-go/function"
+	C "github.com/IBM/fp-go/http/content"
+	FD "github.com/IBM/fp-go/http/form"
+	H "github.com/IBM/fp-go/http/headers"
+	O "github.com/IBM/fp-go/option"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBuilder(t *testing.T) {
+
+	name := H.ContentType
+	withContentType := WithHeader(name)
+	withoutContentType := WithoutHeader(name)
+
+	b1 := F.Pipe1(
+		Default,
+		withContentType(C.Json),
+	)
+
+	b2 := F.Pipe1(
+		b1,
+		withContentType(C.TextPlain),
+	)
+
+	b3 := F.Pipe1(
+		b2,
+		withoutContentType,
+	)
+
+	assert.Equal(t, O.None[string](), Default.GetHeader(name))
+	assert.Equal(t, O.Of(C.Json), b1.GetHeader(name))
+	assert.Equal(t, O.Of(C.TextPlain), b2.GetHeader(name))
+	assert.Equal(t, O.None[string](), b3.GetHeader(name))
+}
+
+func TestWithFormData(t *testing.T) {
+	data := F.Pipe1(
+		FD.Default,
+		FD.WithValue("a")("b"),
+	)
+
+	res := F.Pipe1(
+		Default,
+		WithFormData(data),
+	)
+
+	assert.Equal(t, C.FormEncoded, Headers.Get(res).Get(H.ContentType))
+}

http/content/content.go

@@ -0,0 +1,22 @@
+// 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 content
+
+const (
+	TextPlain   = "text/plain"
+	Json        = "application/json"
+	FormEncoded = "application/x-www-form-urlencoded"
+)

http/form/form.go

@@ -0,0 +1,74 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package form
+
+import (
+	"net/url"
+
+	A "github.com/IBM/fp-go/array"
+	ENDO "github.com/IBM/fp-go/endomorphism"
+	F "github.com/IBM/fp-go/function"
+	L "github.com/IBM/fp-go/optics/lens"
+	LA "github.com/IBM/fp-go/optics/lens/array"
+	LRG "github.com/IBM/fp-go/optics/lens/record/generic"
+	O "github.com/IBM/fp-go/option"
+	RG "github.com/IBM/fp-go/record/generic"
+)
+
+type (
+	// Endomorphism returns an [ENDO.Endomorphism] that transforms a form
+	Endomorphism = ENDO.Endomorphism[url.Values]
+)
+
+var (
+	// Default is the default form field
+	Default = make(url.Values)
+
+	noField = O.None[string]()
+
+	// Monoid is the [M.Monoid] for the [Endomorphism]
+	Monoid = ENDO.Monoid[url.Values]()
+
+	// ValuesMonoid is a [M.Monoid] to concatenate [url.Values] maps
+	ValuesMonoid = RG.UnionMonoid[url.Values](A.Semigroup[string]())
+
+	// AtValues is a [L.Lens] that focusses on the values of a form field
+	AtValues = LRG.AtRecord[url.Values, []string]
+
+	composeHead = F.Pipe1(
+		LA.AtHead[string](),
+		L.ComposeOptions[url.Values, string](A.Empty[string]()),
+	)
+
+	// AtValue is a [L.Lens] that focusses on first value in form fields
+	AtValue = F.Flow2(
+		AtValues,
+		composeHead,
+	)
+)
+
+// WithValue creates a [FormBuilder] for a certain field
+func WithValue(name string) func(value string) Endomorphism {
+	return F.Flow2(
+		O.Of[string],
+		AtValue(name).Set,
+	)
+}
+
+// WithoutValue creates a [FormBuilder] that removes a field
+func WithoutValue(name string) Endomorphism {
+	return AtValue(name).Set(noField)
+}

http/form/form_test.go

@@ -0,0 +1,93 @@
+// 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 form
+
+import (
+	"net/url"
+	"testing"
+
+	A "github.com/IBM/fp-go/array"
+	"github.com/IBM/fp-go/eq"
+	F "github.com/IBM/fp-go/function"
+	LT "github.com/IBM/fp-go/optics/lens/testing"
+	O "github.com/IBM/fp-go/option"
+	RG "github.com/IBM/fp-go/record/generic"
+	S "github.com/IBM/fp-go/string"
+	"github.com/stretchr/testify/assert"
+)
+
+var (
+	sEq      = eq.FromEquals(S.Eq)
+	valuesEq = RG.Eq[url.Values](A.Eq(sEq))
+)
+
+func TestLaws(t *testing.T) {
+	name := "Content-Type"
+	fieldLaws := LT.AssertLaws[url.Values, O.Option[string]](t, O.Eq(sEq), valuesEq)(AtValue(name))
+
+	n := O.None[string]()
+	s1 := O.Some("s1")
+
+	v1 := F.Pipe1(
+		Default,
+		WithValue(name)("v1"),
+	)
+
+	v2 := F.Pipe1(
+		Default,
+		WithValue("Other-Header")("v2"),
+	)
+
+	assert.True(t, fieldLaws(Default, n))
+	assert.True(t, fieldLaws(v1, n))
+	assert.True(t, fieldLaws(v2, n))
+
+	assert.True(t, fieldLaws(Default, s1))
+	assert.True(t, fieldLaws(v1, s1))
+	assert.True(t, fieldLaws(v2, s1))
+}
+
+func TestFormField(t *testing.T) {
+
+	v1 := F.Pipe1(
+		Default,
+		WithValue("h1")("v1"),
+	)
+
+	v2 := F.Pipe1(
+		v1,
+		WithValue("h2")("v2"),
+	)
+
+	// make sure the code does not change structures
+	assert.False(t, valuesEq.Equals(Default, v1))
+	assert.False(t, valuesEq.Equals(Default, v2))
+	assert.False(t, valuesEq.Equals(v1, v2))
+
+	// check for existence of values
+	assert.Equal(t, "v1", v1.Get("h1"))
+	assert.Equal(t, "v1", v2.Get("h1"))
+	assert.Equal(t, "v2", v2.Get("h2"))
+
+	// check getter on lens
+
+	l1 := AtValue("h1")
+	l2 := AtValue("h2")
+
+	assert.Equal(t, O.Of("v1"), l1.Get(v1))
+	assert.Equal(t, O.Of("v1"), l1.Get(v2))
+	assert.Equal(t, O.Of("v2"), l2.Get(v2))
+}

http/headers/headers.go

@@ -0,0 +1,58 @@
+// 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 headers
+
+import (
+	"net/http"
+	"net/textproto"
+
+	A "github.com/IBM/fp-go/array"
+	F "github.com/IBM/fp-go/function"
+	L "github.com/IBM/fp-go/optics/lens"
+	LA "github.com/IBM/fp-go/optics/lens/array"
+	LRG "github.com/IBM/fp-go/optics/lens/record/generic"
+	RG "github.com/IBM/fp-go/record/generic"
+)
+
+// HTTP headers
+const (
+	Accept        = "Accept"
+	Authorization = "Authorization"
+	ContentType   = "Content-Type"
+	ContentLength = "Content-Length"
+)
+
+var (
+	// Monoid is a [M.Monoid] to concatenate [http.Header] maps
+	Monoid = RG.UnionMonoid[http.Header](A.Semigroup[string]())
+
+	// AtValues is a [L.Lens] that focusses on the values of a header
+	AtValues = F.Flow2(
+		textproto.CanonicalMIMEHeaderKey,
+		LRG.AtRecord[http.Header, []string],
+	)
+
+	composeHead = F.Pipe1(
+		LA.AtHead[string](),
+		L.ComposeOptions[http.Header, string](A.Empty[string]()),
+	)
+
+	// AtValue is a [L.Lens] that focusses on first value of a header
+	AtValue = F.Flow2(
+		AtValues,
+		composeHead,
+	)
+)

http/headers/headers_test.go

@@ -0,0 +1,58 @@
+// 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 headers
+
+import (
+	"net/http"
+	"testing"
+
+	A "github.com/IBM/fp-go/array"
+	"github.com/IBM/fp-go/eq"
+	LT "github.com/IBM/fp-go/optics/lens/testing"
+	O "github.com/IBM/fp-go/option"
+	RG "github.com/IBM/fp-go/record/generic"
+	S "github.com/IBM/fp-go/string"
+	"github.com/stretchr/testify/assert"
+)
+
+var (
+	sEq      = eq.FromEquals(S.Eq)
+	valuesEq = RG.Eq[http.Header](A.Eq(sEq))
+)
+
+func TestLaws(t *testing.T) {
+	name := "Content-Type"
+	fieldLaws := LT.AssertLaws[http.Header, O.Option[string]](t, O.Eq(sEq), valuesEq)(AtValue(name))
+
+	n := O.None[string]()
+	s1 := O.Some("s1")
+
+	def := make(http.Header)
+
+	v1 := make(http.Header)
+	v1.Set(name, "v1")
+
+	v2 := make(http.Header)
+	v2.Set("Other-Header", "v2")
+
+	assert.True(t, fieldLaws(def, n))
+	assert.True(t, fieldLaws(v1, n))
+	assert.True(t, fieldLaws(v2, n))
+
+	assert.True(t, fieldLaws(def, s1))
+	assert.True(t, fieldLaws(v1, s1))
+	assert.True(t, fieldLaws(v2, s1))
+}

http/utils.go

@@ -20,6 +20,7 @@ import (
 	"io"
 	"mime"
 	H "net/http"
+	"net/url"
 	"regexp"
 
 	A "github.com/IBM/fp-go/array"
@@ -33,6 +34,13 @@ import (
 
 type (
 	ParsedMediaType = T.Tuple2[string, map[string]string]
+
+	HttpError struct {
+		statusCode int
+		headers    H.Header
+		body       []byte
+		url        *url.URL
+	}
 )
 
 var (
@@ -72,6 +80,31 @@ func ParseMediaType(mediaType string) E.Either[error, ParsedMediaType] {
 	return E.TryCatchError(T.MakeTuple2(m, p), err)
 }
 
+// Error fulfills the error interface
+func (r *HttpError) Error() string {
+	return fmt.Sprintf("invalid status code [%d] when accessing URL [%s]", r.statusCode, r.url)
+}
+
+func (r *HttpError) String() string {
+	return r.Error()
+}
+
+func (r *HttpError) StatusCode() int {
+	return r.statusCode
+}
+
+func (r *HttpError) Headers() H.Header {
+	return r.headers
+}
+
+func (r *HttpError) URL() *url.URL {
+	return r.url
+}
+
+func (r *HttpError) Body() []byte {
+	return r.body
+}
+
 func GetHeader(resp *H.Response) H.Header {
 	return resp.Header
 }
@@ -84,6 +117,13 @@ func isValidStatus(resp *H.Response) bool {
 	return resp.StatusCode >= H.StatusOK && resp.StatusCode < H.StatusMultipleChoices
 }
 
+// StatusCodeError creates an instance of [HttpError] filled with information from the response
 func StatusCodeError(resp *H.Response) error {
-	return fmt.Errorf("invalid status code [%d] when accessing URL [%s]", resp.StatusCode, resp.Request.URL)
+	// read the body
+	bodyRdr := GetBody(resp)
+	defer bodyRdr.Close()
+	// try to access body content
+	body, _ := io.ReadAll(bodyRdr)
+	// return an error with comprehensive information
+	return &HttpError{statusCode: resp.StatusCode, headers: GetHeader(resp).Clone(), body: body, url: resp.Request.URL}
 }

http/utils_test.go

@@ -20,6 +20,7 @@ import (
 
 	E "github.com/IBM/fp-go/either"
 	F "github.com/IBM/fp-go/function"
+	C "github.com/IBM/fp-go/http/content"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -38,7 +39,7 @@ func Error[A any](t *testing.T) func(E.Either[error, A]) bool {
 func TestValidateJsonContentTypeString(t *testing.T) {
 
 	res := F.Pipe1(
-		validateJsonContentTypeString("application/json"),
+		validateJsonContentTypeString(C.Json),
 		NoError[ParsedMediaType](t),
 	)
 

identity/bind.go

@@ -0,0 +1,89 @@
+// 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 identity
+
+import (
+	A "github.com/IBM/fp-go/internal/apply"
+	C "github.com/IBM/fp-go/internal/chain"
+	F "github.com/IBM/fp-go/internal/functor"
+)
+
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[S any](
+	empty S,
+) S {
+	return empty
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) T,
+) func(S1) S2 {
+	return C.Bind(
+		Chain[S1, S2],
+		Map[T, S2],
+		setter,
+		f,
+	)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[S1, S2, T any](
+	key func(T) func(S1) S2,
+	f func(S1) T,
+) func(S1) S2 {
+	return F.Let(
+		Map[S1, S2],
+		key,
+		f,
+	)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[S1, S2, B any](
+	key func(B) func(S1) S2,
+	b B,
+) func(S1) S2 {
+	return F.LetTo(
+		Map[S1, S2],
+		key,
+		b,
+	)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[S1, T any](
+	setter func(T) S1,
+) func(T) S1 {
+	return C.BindTo(
+		Map[T, S1],
+		setter,
+	)
+}
+
+// ApS attaches a value to a context [S1] to produce a context [S2] by considering the context and the value concurrently
+func ApS[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa T,
+) func(S1) S2 {
+	return A.ApS(
+		Ap[S2, T],
+		Map[S1, func(T) S2],
+		setter,
+		fa,
+	)
+}

identity/generic/identity.go

@@ -57,6 +57,6 @@ func MonadFlap[GAB ~func(A) B, A, B any](fab GAB, a A) B {
 	return FC.MonadFlap(MonadMap[func(GAB) B, GAB, B], fab, a)
 }
 
-func Flap[GAB ~func(A) B, A, B any](a A) func(GAB) B {
+func Flap[GAB ~func(A) B, B, A any](a A) func(GAB) B {
 	return F.Bind2nd(MonadFlap[GAB, A, B], a)
 }

internal/apply/ap.go

@@ -37,6 +37,16 @@ func MonadAp[HKTGA, HKTGB, HKTGAB, HKTFGAB, HKTFGGAB, HKTFGA, HKTFGB any](
 	return fap(fmap(fab, F.Bind1st(F.Bind1st[HKTGAB, HKTGA, HKTGB], gap)), fa)
 }
 
+// func Ap[HKTGA, HKTGB, HKTGAB, HKTFGAB, HKTFGGAB, HKTFGA, HKTFGB any](
+// 	fap func(HKTFGA) func(HKTFGGAB) HKTFGB,
+// 	fmap func(func(HKTGAB) func(HKTGA) HKTGB) func(HKTFGAB) HKTFGGAB,
+// 	gap func(HKTGA) func(HKTGAB) HKTGB,
+
+// 	fa HKTFGA) func(HKTFGAB) HKTFGB {
+
+// 	return fap(fmap(F.Bind1st(F.Bind1st[HKTGAB, HKTGA, HKTGB], gap)), fa)
+// }
+
 // export function ap<F, G>(
 // 	F: Apply<F>,
 // 	G: Apply<G>
@@ -107,3 +117,25 @@ func ApSecond[HKTGA, HKTGB, HKTGBB, A, B any](
 		return MonadApSecond(fap, fmap, first, second)
 	}
 }
+
+func MonadApS[S1, S2, B, HKTBGBS2, HKTS1, HKTS2, HKTB any](
+	fap func(HKTBGBS2, HKTB) HKTS2,
+	fmap func(HKTS1, func(S1) func(B) S2) HKTBGBS2,
+	fa HKTS1,
+	key func(B) func(S1) S2,
+	fb HKTB,
+) HKTS2 {
+	return fap(fmap(fa, F.Flip(key)), fb)
+}
+
+func ApS[S1, S2, B, HKTBGBS2, HKTS1, HKTS2, HKTB any](
+	fap func(HKTB) func(HKTBGBS2) HKTS2,
+	fmap func(func(S1) func(B) S2) func(HKTS1) HKTBGBS2,
+	key func(B) func(S1) S2,
+	fb HKTB,
+) func(HKTS1) HKTS2 {
+	return F.Flow2(
+		fmap(F.Flip(key)),
+		fap(fb),
+	)
+}

internal/array/array.go

@@ -51,6 +51,24 @@ func ReduceWithIndex[GA ~[]A, A, B any](fa GA, f func(int, B, A) B, initial B) B
 	return current
 }
 
+func ReduceRight[GA ~[]A, A, B any](fa GA, f func(A, B) B, initial B) B {
+	current := initial
+	count := len(fa)
+	for i := count - 1; i >= 0; i-- {
+		current = f(fa[i], current)
+	}
+	return current
+}
+
+func ReduceRightWithIndex[GA ~[]A, A, B any](fa GA, f func(int, A, B) B, initial B) B {
+	current := initial
+	count := len(fa)
+	for i := count - 1; i >= 0; i-- {
+		current = f(i, fa[i], current)
+	}
+	return current
+}
+
 func Append[GA ~[]A, A any](as GA, a A) GA {
 	return append(as, a)
 }
@@ -88,6 +106,15 @@ func MonadMap[GA ~[]A, GB ~[]B, A, B any](as GA, f func(a A) B) GB {
 	return bs
 }
 
+func MonadMapWithIndex[GA ~[]A, GB ~[]B, A, B any](as GA, f func(idx int, a A) B) GB {
+	count := len(as)
+	bs := make(GB, count)
+	for i := count - 1; i >= 0; i-- {
+		bs[i] = f(i, as[i])
+	}
+	return bs
+}
+
 func ConstNil[GA ~[]A, A any]() GA {
 	return (GA)(nil)
 }

internal/array/prepend.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 array
+
+// Prepend prepends a single value to an array
+func Prepend[ENDO ~func(AS) AS, AS ~[]A, A any](head A) ENDO {
+	return func(as AS) AS {
+		l := len(as)
+		cpy := make(AS, l+1)
+		copy(cpy[1:], as)
+		cpy[0] = head
+		return cpy
+
+	}
+}

internal/bindt/bind.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 bindt
-
-import (
-	F "github.com/IBM/fp-go/function"
-	I "github.com/IBM/fp-go/identity"
-	T "github.com/IBM/fp-go/tuple"
-)
-
-func Bind[SET ~func(B) func(S1) S2, FCT ~func(S1) HKTB, S1, S2, B, HKTS1, HKTS2, HKTB any](
-	mchain func(func(S1) HKTS2) func(HKTS1) HKTS2,
-	mmap func(func(B) S2) func(HKTB) HKTS2,
-	s SET,
-	f FCT,
-) func(HKTS1) HKTS2 {
-	return mchain(F.Flow3(
-		T.Replicate2[S1],
-		T.Map2(F.Flow2(
-			I.Ap[S2, S1],
-			F.Flow2(
-				F.Bind1st(F.Flow2[SET, func(func(S1) S2) S2], s),
-				mmap,
-			)), f),
-		T.Tupled2(I.MonadAp[HKTS2, HKTB]),
-	))
-}
-
-func BindTo[SET ~func(B) S2, S2, B, HKTS2, HKTB any](
-	mmap func(func(B) S2) func(HKTB) HKTS2,
-	s SET,
-) func(HKTB) HKTS2 {
-	return mmap(s)
-}
-
-func ApS[
-	SET ~func(B) func(S1) S2,
-	S1, S2, B, HKTS1S2, HKTS1, HKTS2, HKTB any,
-](
-	ap func(HKTS1) func(HKTS1S2) HKTS2,
-	mmap func(func(B) func(S1) S2) func(HKTB) HKTS1S2,
-	s SET, fb HKTB) func(HKTS1) HKTS2 {
-
-	return F.Flow2(
-		ap,
-		I.Ap[HKTS2, HKTS1S2](mmap(s)(fb)),
-	)
-}
-
-func Let[SET ~func(B) func(S1) S2, FCT ~func(S1) B, S1, S2, B, HKTS1, HKTS2 any](
-	mmap func(func(S1) S2) func(HKTS1) HKTS2,
-	s SET,
-	f FCT,
-) func(HKTS1) HKTS2 {
-	return mmap(F.Flow3(
-		T.Replicate2[S1],
-		T.Map2(F.Flow2(
-			I.Ap[S2, S1],
-			F.Bind1st(F.Flow2[SET, func(func(S1) S2) S2], s)), f),
-		T.Tupled2(I.MonadAp[S2, B]),
-	))
-}

internal/chain/chain.go

@@ -52,10 +52,59 @@ func ChainFirst[A, B, HKTA, HKTB any](
 }
 
 func Chain[A, B, HKTA, HKTB any](
-	mchain func(HKTA, func(A) HKTB) HKTB,
+	mchain func(func(A) HKTB) func(HKTA) HKTB,
 	f func(A) HKTB,
 ) func(HKTA) HKTB {
-	return func(first HKTA) HKTB {
-		return MonadChain[A, B](mchain, first, f)
-	}
+	return mchain(f)
+}
+
+func MonadBind[S1, S2, B, HKTS1, HKTS2, HKTB any](
+	mchain func(HKTS1, func(S1) HKTS2) HKTS2,
+	mmap func(HKTB, func(B) S2) HKTS2,
+	first HKTS1,
+	key func(B) func(S1) S2,
+	f func(S1) HKTB,
+) HKTS2 {
+	return mchain(first, func(s1 S1) HKTS2 {
+		return mmap(f(s1), func(b B) S2 {
+			return key(b)(s1)
+		})
+	})
+}
+
+func Bind[S1, S2, B, HKTS1, HKTS2, HKTB any](
+	mchain func(func(S1) HKTS2) func(HKTS1) HKTS2,
+	mmap func(func(B) S2) func(HKTB) HKTS2,
+	key func(B) func(S1) S2,
+	f func(S1) HKTB,
+) func(HKTS1) HKTS2 {
+	mapb := F.Flow2(
+		F.Flip(key),
+		mmap,
+	)
+	return mchain(func(s1 S1) HKTS2 {
+		return F.Pipe2(
+			s1,
+			f,
+			F.Pipe1(
+				s1,
+				mapb,
+			),
+		)
+	})
+}
+
+func BindTo[S1, B, HKTS1, HKTB any](
+	mmap func(func(B) S1) func(HKTB) HKTS1,
+	key func(B) S1,
+) func(fa HKTB) HKTS1 {
+	return mmap(key)
+}
+
+func MonadBindTo[S1, B, HKTS1, HKTB any](
+	mmap func(HKTB, func(B) S1) HKTS1,
+	first HKTB,
+	key func(B) S1,
+) HKTS1 {
+	return mmap(first, key)
 }

internal/eithert/either.go

@@ -32,6 +32,17 @@ func MonadAlt[LAZY ~func() HKTFA, E, A, HKTFA any](
 	return fchain(first, ET.Fold(F.Ignore1of1[E](second), F.Flow2(ET.Of[E, A], fof)))
 }
 
+func Alt[LAZY ~func() HKTFA, E, A, HKTFA any](
+	fof func(ET.Either[E, A]) HKTFA,
+	fchain func(HKTFA, func(ET.Either[E, A]) HKTFA) HKTFA,
+
+	second LAZY) func(HKTFA) HKTFA {
+
+	return func(fa HKTFA) HKTFA {
+		return MonadAlt(fof, fchain, fa, second)
+	}
+}
+
 // HKTFA = HKT<F, Either<E, A>>
 // HKTFB = HKT<F, Either<E, B>>
 func MonadMap[E, A, B, HKTFA, HKTFB any](fmap func(HKTFA, func(ET.Either[E, A]) ET.Either[E, B]) HKTFB, fa HKTFA, f func(A) B) HKTFB {

internal/fromio/io.go

@@ -47,7 +47,7 @@ func MonadChainIOK[GR ~func() B, A, B, HKTA, HKTB any](
 }
 
 func ChainIOK[GR ~func() B, A, B, HKTA, HKTB any](
-	mchain func(HKTA, func(A) HKTB) HKTB,
+	mchain func(func(A) HKTB) func(HKTA) HKTB,
 	fromio func(GR) HKTB,
 	f func(A) GR) func(HKTA) HKTB {
 	// chain

internal/fromioeither/ioeither.go

@@ -48,7 +48,7 @@ func MonadChainIOEitherK[GIOB ~func() ET.Either[E, B], E, A, B, HKTA, HKTB any](
 }
 
 func ChainIOEitherK[GIOB ~func() ET.Either[E, B], E, A, B, HKTA, HKTB any](
-	mchain func(HKTA, func(A) HKTB) HKTB,
+	mchain func(func(A) HKTB) func(HKTA) HKTB,
 	fromio func(GIOB) HKTB,
 	f func(A) GIOB) func(HKTA) HKTB {
 	// chain

internal/functor/functor.go

@@ -21,6 +21,54 @@ import (
 
 // HKTFGA = HKT[F, HKT[G, A]]
 // HKTFGB = HKT[F, HKT[G, B]]
-func MonadMap[A, B, HKTGA, HKTGB, HKTFGA, HKTFGB any](fmap func(HKTFGA, func(HKTGA) HKTGB) HKTFGB, gmap func(HKTGA, func(A) B) HKTGB, fa HKTFGA, f func(A) B) HKTFGB {
+func MonadMap[A, B, HKTGA, HKTGB, HKTFGA, HKTFGB any](
+	fmap func(HKTFGA, func(HKTGA) HKTGB) HKTFGB,
+	gmap func(HKTGA, func(A) B) HKTGB,
+	fa HKTFGA,
+	f func(A) B) HKTFGB {
 	return fmap(fa, F.Bind2nd(gmap, f))
 }
+
+func Map[A, B, HKTGA, HKTGB, HKTFGA, HKTFGB any](
+	fmap func(func(HKTGA) HKTGB) func(HKTFGA) HKTFGB,
+	gmap func(func(A) B) func(HKTGA) HKTGB,
+	f func(A) B) func(HKTFGA) HKTFGB {
+	return F.Pipe2(
+		f,
+		gmap,
+		fmap,
+	)
+}
+
+func MonadLet[S1, S2, B, HKTS1, HKTS2 any](
+	mmap func(HKTS1, func(S1) S2) HKTS2,
+	first HKTS1,
+	key func(B) func(S1) S2,
+	f func(S1) B,
+) HKTS2 {
+	return mmap(first, func(s1 S1) S2 {
+		return key(f(s1))(s1)
+	})
+}
+
+func Let[S1, S2, B, HKTS1, HKTS2 any](
+	mmap func(func(S1) S2) func(HKTS1) HKTS2,
+	key func(B) func(S1) S2,
+	f func(S1) B,
+) func(HKTS1) HKTS2 {
+	return mmap(func(s1 S1) S2 {
+		return key(f(s1))(s1)
+	})
+}
+
+func LetTo[S1, S2, B, HKTS1, HKTS2 any](
+	mmap func(func(S1) S2) func(HKTS1) HKTS2,
+	key func(B) func(S1) S2,
+	b B,
+) func(HKTS1) HKTS2 {
+	return F.Pipe2(
+		b,
+		key,
+		mmap,
+	)
+}

internal/optiont/option.go

@@ -49,14 +49,21 @@ func MonadChain[A, B, HKTFA, HKTFB any](
 	return fchain(ma, O.Fold(F.Nullary2(O.None[B], fof), f))
 }
 
+func Chain[A, B, HKTFA, HKTFB any](
+	fchain func(HKTFA, func(O.Option[A]) HKTFB) HKTFB,
+	fof func(O.Option[B]) HKTFB,
+	f func(A) HKTFB) func(ma HKTFA) HKTFB {
+	// dispatch to the even more generic implementation
+	return func(ma HKTFA) HKTFB {
+		return MonadChain(fchain, fof, ma, f)
+	}
+}
+
 func MonadAp[A, B, HKTFAB, HKTFGAB, HKTFA, HKTFB any](
 	fap func(HKTFGAB, HKTFA) HKTFB,
 	fmap func(HKTFAB, func(O.Option[func(A) B]) func(O.Option[A]) O.Option[B]) HKTFGAB,
 	fab HKTFAB,
 	fa HKTFA) HKTFB {
-	// HKTGA  = O.Option[A]
-	// HKTGB  = O.Option[B]
-	// HKTGAB = O.Option[func(a A) B]
 	return apply.MonadAp(fap, fmap, O.MonadAp[B, A], fab, fa)
 }
 
@@ -78,3 +85,24 @@ func MonadChainOptionK[A, B, HKTA, HKTB any](
 ) HKTB {
 	return MonadChain(fchain, fof, ma, FromOptionK(fof, f))
 }
+
+func MonadAlt[LAZY ~func() HKTFA, A, HKTFA any](
+	fof func(O.Option[A]) HKTFA,
+	fchain func(HKTFA, func(O.Option[A]) HKTFA) HKTFA,
+
+	first HKTFA,
+	second LAZY) HKTFA {
+
+	return fchain(first, O.Fold(second, F.Flow2(O.Of[A], fof)))
+}
+
+func Alt[LAZY ~func() HKTFA, A, HKTFA any](
+	fof func(O.Option[A]) HKTFA,
+	fchain func(HKTFA, func(O.Option[A]) HKTFA) HKTFA,
+
+	second LAZY) func(HKTFA) HKTFA {
+
+	return func(fa HKTFA) HKTFA {
+		return MonadAlt(fof, fchain, fa, second)
+	}
+}

internal/readert/reader.go

@@ -23,10 +23,25 @@ import (
 // here we implement the monadic operations using callbacks from
 // higher kinded types, as good a golang allows use to do this
 
-func MonadMap[GEA ~func(E) HKTA, GEB ~func(E) HKTB, E, A, B, HKTA, HKTB any](fmap func(HKTA, func(A) B) HKTB, fa GEA, f func(A) B) GEB {
+func MonadMap[GEA ~func(E) HKTA, GEB ~func(E) HKTB, E, A, B, HKTA, HKTB any](
+	fmap func(HKTA, func(A) B) HKTB,
+	fa GEA,
+	f func(A) B,
+) GEB {
 	return R.MonadMap[GEA, GEB](fa, F.Bind2nd(fmap, f))
 }
 
+func Map[GEA ~func(E) HKTA, GEB ~func(E) HKTB, E, A, B, HKTA, HKTB any](
+	fmap func(func(A) B) func(HKTA) HKTB,
+	f func(A) B,
+) func(GEA) GEB {
+	return F.Pipe2(
+		f,
+		fmap,
+		R.Map[GEA, GEB, E, HKTA, HKTB],
+	)
+}
+
 func MonadChain[GEA ~func(E) HKTA, GEB ~func(E) HKTB, A, E, HKTA, HKTB any](fchain func(HKTA, func(A) HKTB) HKTB, ma GEA, f func(A) GEB) GEB {
 	return R.MakeReader(func(r E) HKTB {
 		return fchain(ma(r), func(a A) HKTB {

internal/utils/do.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 utils
+
+import (
+	"fmt"
+
+	F "github.com/IBM/fp-go/function"
+)
+
+type (
+	Initial struct {
+	}
+
+	WithLastName struct {
+		Initial
+		LastName string
+	}
+
+	WithGivenName struct {
+		WithLastName
+		GivenName string
+	}
+)
+
+var (
+	Empty = Initial{}
+
+	SetLastName = F.Curry2(func(name string, s1 Initial) WithLastName {
+		return WithLastName{
+			Initial:  s1,
+			LastName: name,
+		}
+	})
+
+	SetGivenName = F.Curry2(func(name string, s1 WithLastName) WithGivenName {
+		return WithGivenName{
+			WithLastName: s1,
+			GivenName:    name,
+		}
+	})
+)
+
+func GetFullName(s WithGivenName) string {
+	return fmt.Sprintf("%s %s", s.GivenName, s.LastName)
+}

io/bind.go

@@ -0,0 +1,66 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package io
+
+import (
+	G "github.com/IBM/fp-go/io/generic"
+)
+
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[S any](
+	empty S,
+) IO[S] {
+	return G.Do[IO[S], S](empty)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) IO[T],
+) func(IO[S1]) IO[S2] {
+	return G.Bind[IO[S1], IO[S2], IO[T], S1, S2, T](setter, f)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) T,
+) func(IO[S1]) IO[S2] {
+	return G.Let[IO[S1], IO[S2], S1, S2, T](setter, f)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	b T,
+) func(IO[S1]) IO[S2] {
+	return G.LetTo[IO[S1], IO[S2], S1, S2, T](setter, b)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[S1, T any](
+	setter func(T) S1,
+) func(IO[T]) IO[S1] {
+	return G.BindTo[IO[S1], IO[T], S1, T](setter)
+}
+
+// ApS attaches a value to a context [S1] to produce a context [S2] by considering the context and the value concurrently
+func ApS[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa IO[T],
+) func(IO[S1]) IO[S2] {
+	return G.ApS[IO[S1], IO[S2], IO[T], S1, S2, T](setter, fa)
+}

io/bind_test.go

@@ -0,0 +1,56 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package io
+
+import (
+	"testing"
+
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/utils"
+	"github.com/stretchr/testify/assert"
+)
+
+func getLastName(s utils.Initial) IO[string] {
+	return Of("Doe")
+}
+
+func getGivenName(s utils.WithLastName) IO[string] {
+	return Of("John")
+}
+
+func TestBind(t *testing.T) {
+
+	res := F.Pipe3(
+		Do(utils.Empty),
+		Bind(utils.SetLastName, getLastName),
+		Bind(utils.SetGivenName, getGivenName),
+		Map(utils.GetFullName),
+	)
+
+	assert.Equal(t, res(), "John Doe")
+}
+
+func TestApS(t *testing.T) {
+
+	res := F.Pipe3(
+		Do(utils.Empty),
+		ApS(utils.SetLastName, Of("Doe")),
+		ApS(utils.SetGivenName, Of("John")),
+		Map(utils.GetFullName),
+	)
+
+	assert.Equal(t, res(), "John Doe")
+}