fix: refactor either type (#102)

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,7 +26,7 @@ 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@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
@@ -60,7 +60,7 @@ jobs:
           fetch-depth: 0
 
       - name: Set up Node.js ${{ env.NODE_VERSION }}
-        uses: actions/setup-node@8f152de45cc393bb48ce5d89d36b731f54556e65 # v4.0.0
+        uses: actions/setup-node@60edb5dd545a775178f52524783378180af0d1f8 # v4.0.2
         with:
           node-version: ${{ env.NODE_VERSION }}
 

.gitignore

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

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"
@@ -57,7 +58,7 @@ func MapWithIndex[A, B any](f func(int, A) B) func([]A) []B {
 }
 
 func Map[A, B any](f func(a A) B) func([]A) []B {
-	return F.Bind2nd(MonadMap[A, B], f)
+	return G.Map[[]A, []B, A, B](f)
 }
 
 func MapRef[A, B any](f func(a *A) B) func([]A) []B {
@@ -89,16 +90,16 @@ func filterMapRef[A, B any](fa []A, pred func(a *A) bool, f func(a *A) B) []B {
 }
 
 // Filter returns a new array with all elements from the original array that match a predicate
-func Filter[A any](pred func(A) bool) func([]A) []A {
+func Filter[A any](pred func(A) bool) EM.Endomorphism[[]A] {
 	return G.Filter[[]A](pred)
 }
 
 // FilterWithIndex returns a new array with all elements from the original array that match a predicate
-func FilterWithIndex[A any](pred func(int, A) bool) func([]A) []A {
+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) func([]A) []A {
+func FilterRef[A any](pred func(*A) bool) EM.Endomorphism[[]A] {
 	return F.Bind2nd(filterRef[A], pred)
 }
 
@@ -227,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
@@ -242,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) {
@@ -271,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)
 }
 
@@ -304,7 +305,7 @@ 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)
 }
 
@@ -333,8 +334,8 @@ 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 {
@@ -344,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/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/generic/array.go

@@ -147,7 +147,7 @@ func MonadMap[GA ~[]A, GB ~[]B, A, B any](as GA, f func(a A) B) GB {
 }
 
 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)
+	return array.Map[GA, GB](f)
 }
 
 func MonadMapWithIndex[GA ~[]A, GB ~[]B, A, B any](as GA, f func(int, A) B) GB {
@@ -335,7 +335,7 @@ func Fold[AS ~[]A, A any](m M.Monoid[A]) func(AS) A {
 	}
 }
 
-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)
 }
 
@@ -344,5 +344,9 @@ 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)
+	return FC.Flap(Map[GFAB, GB], 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/monad.go

@@ -0,0 +1,43 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	"github.com/IBM/fp-go/internal/monad"
+)
+
+type arrayMonad[A, B any, GA ~[]A, GB ~[]B, GAB ~[]func(A) B] struct{}
+
+func (o *arrayMonad[A, B, GA, GB, GAB]) Of(a A) GA {
+	return Of[GA, A](a)
+}
+
+func (o *arrayMonad[A, B, GA, GB, GAB]) Map(f func(A) B) func(GA) GB {
+	return Map[GA, GB, A, B](f)
+}
+
+func (o *arrayMonad[A, B, GA, GB, GAB]) Chain(f func(A) GB) func(GA) GB {
+	return Chain[GA, GB, A, B](f)
+}
+
+func (o *arrayMonad[A, B, GA, GB, GAB]) Ap(fa GA) func(GAB) GB {
+	return Ap[GB, GAB, GA, B, A](fa)
+}
+
+// Monad implements the monadic operations for an array
+func Monad[A, B any, GA ~[]A, GB ~[]B, GAB ~[]func(A) B]() monad.Monad[A, B, GA, GB, GAB] {
+	return &arrayMonad[A, B, GA, GB, GAB]{}
+}

array/monad.go

@@ -0,0 +1,26 @@
+// Copyright (c) 2024 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"
+	"github.com/IBM/fp-go/internal/monad"
+)
+
+// Monad returns the monadic operations for an array
+func Monad[A, B any]() monad.Monad[A, B, []A, []B, []func(A) B] {
+	return G.Monad[A, B, []A, []B, []func(A) B]()
+}

array/monoid.go

@@ -24,10 +24,10 @@ import (
 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
 	}

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"
@@ -43,11 +44,11 @@ func From[A any](first A, data ...A) NonEmptyArray[A] {
 	return buffer
 }
 
-func IsEmpty[A any](as NonEmptyArray[A]) bool {
+func IsEmpty[A any](_ NonEmptyArray[A]) bool {
 	return false
 }
 
-func IsNonEmpty[A any](as NonEmptyArray[A]) bool {
+func IsNonEmpty[A any](_ NonEmptyArray[A]) bool {
 	return true
 }
 
@@ -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))
+}

bounded/bounded.go

@@ -32,20 +32,20 @@ type bounded[T any] struct {
 	b T
 }
 
-func (self bounded[T]) Equals(x, y T) bool {
-	return self.e(x, y)
+func (b bounded[T]) Equals(x, y T) bool {
+	return b.e(x, y)
 }
 
-func (self bounded[T]) Compare(x, y T) int {
-	return self.c(x, y)
+func (b bounded[T]) Compare(x, y T) int {
+	return b.c(x, y)
 }
 
-func (self bounded[T]) Top() T {
-	return self.t
+func (b bounded[T]) Top() T {
+	return b.t
 }
 
-func (self bounded[T]) Bottom() T {
-	return self.b
+func (b bounded[T]) Bottom() T {
+	return b.b
 }
 
 // MakeBounded creates an instance of a bounded type

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

@@ -37,7 +37,7 @@ func Of[E, A any](m M.Monoid[E]) func(A) Const[E, A] {
 	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] {
+func MonadMap[E, A, B any](fa Const[E, A], _ func(A) B) Const[E, B] {
 	return Make[E, B](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/file/file_test.go

@@ -47,5 +47,5 @@ func ExampleReadFile() {
 	fmt.Println(result())
 
 	// Output:
-	// Right[<nil>, string](Carsten)
+	// Right[string](Carsten)
 }

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

@@ -182,10 +182,7 @@ func withCancelCauseFunc[
 		ma,
 		IOE.Swap[GIOA, func() E.Either[A, error]],
 		IOE.ChainFirstIOK[func() E.Either[A, error], func() any](func(err error) func() any {
-			return IO.MakeIO[func() any](func() any {
-				cancel(err)
-				return nil
-			})
+			return IO.FromImpure[func() any](func() { cancel(err) })
 		}),
 		IOE.Swap[func() E.Either[A, error], GIOA],
 	)

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/http/request.go

@@ -103,12 +103,19 @@ func ReadText(client Client) func(Requester) RIOE.ReaderIOEither[string] {
 }
 
 // ReadJson sends a request, reads the response and parses the response as JSON
+//
+// Deprecated: use [ReadJSON] instead
 func ReadJson[A any](client Client) func(Requester) RIOE.ReaderIOEither[A] {
+	return ReadJSON[A](client)
+}
+
+// ReadJSON sends a request, reads the response and parses the response as JSON
+func ReadJSON[A any](client Client) func(Requester) RIOE.ReaderIOEither[A] {
 	return F.Flow3(
 		ReadFullResponse(client),
 		RIOE.ChainFirstEitherK(F.Flow2(
 			H.Response,
-			H.ValidateJsonResponse,
+			H.ValidateJSONResponse,
 		)),
 		RIOE.ChainEitherK(F.Flow2(
 			H.Body,

context/readerioeither/http/request_test.go

@@ -31,7 +31,7 @@ import (
 )
 
 type PostItem struct {
-	UserId uint   `json:"userId"`
+	UserID uint   `json:"userId"`
 	Id     uint   `json:"id"`
 	Title  string `json:"title"`
 	Body   string `json:"body"`
@@ -84,7 +84,7 @@ func TestSendSingleRequest(t *testing.T) {
 
 	req1 := MakeGetRequest("https://jsonplaceholder.typicode.com/posts/1")
 
-	readItem := ReadJson[PostItem](client)
+	readItem := ReadJSON[PostItem](client)
 
 	resp1 := readItem(req1)
 
@@ -112,7 +112,7 @@ func TestSendSingleRequestWithHeaderUnsafe(t *testing.T) {
 		R.Map(setHeaderUnsafe("Content-Type", "text/html")),
 	)
 
-	readItem := ReadJson[PostItem](client)
+	readItem := ReadJSON[PostItem](client)
 
 	resp1 := F.Pipe2(
 		req1,
@@ -140,7 +140,7 @@ func TestSendSingleRequestWithHeaderSafe(t *testing.T) {
 		WithHeader("Content-Type", "text/html").
 		Build()
 
-	readItem := ReadJson[PostItem](client)
+	readItem := ReadJSON[PostItem](client)
 
 	response := F.Pipe2(
 		request,

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

@@ -7,7 +7,6 @@
 //
 // 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.
@@ -115,6 +114,9 @@ func itemProviderFactory(fcts []ProviderFactory) ProviderFactory {
 }
 
 // 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]
@@ -125,7 +127,7 @@ func MakeInjector(providers []Provider) InjectableFactory {
 	var resolved sync.Map
 
 	// provide a mapping for all providers
-	factoryById := assembleProviders(providers)
+	factoryByID := assembleProviders(providers)
 
 	// the actual factory, we need lazy initialization
 	var injFct InjectableFactory
@@ -147,7 +149,7 @@ func MakeInjector(providers []Provider) InjectableFactory {
 					T.Map2(F.Flow3(
 						Dependency.Id,
 						R.Lookup[ProviderFactory, string],
-						I.Ap[O.Option[ProviderFactory]](factoryById),
+						I.Ap[O.Option[ProviderFactory]](factoryByID),
 					), handleMissingProvider),
 					T.Tupled2(O.MonadGetOrElse[ProviderFactory]),
 					IG.Ap[ProviderFactory](injFct),

di/erasure/provider.go

@@ -31,25 +31,29 @@ import (
 	R "github.com/IBM/fp-go/record"
 )
 
-type InjectableFactory = func(Dependency) IOE.IOEither[error, any]
-type ProviderFactory = func(InjectableFactory) IOE.IOEither[error, any]
+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]
 
-type paramIndex = map[int]int
-type paramValue = map[int]any
-type handler = func(paramIndex) func([]IOE.IOEither[error, any]) IOE.IOEither[error, paramValue]
+	paramIndex = map[int]int
+	paramValue = map[int]any
+	handler    = func(paramIndex) func([]IOE.IOEither[error, any]) IOE.IOEither[error, paramValue]
+	mapping    = map[int]paramIndex
 
-type 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 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
+	}
 
-type provider struct {
-	provides Dependency
-	factory  ProviderFactory
-}
+	provider struct {
+		provides Dependency
+		factory  ProviderFactory
+	}
+)
 
 func (p *provider) Provides() Dependency {
 	return p.provides
@@ -72,11 +76,16 @@ func mapFromToken(idx int, token Dependency) map[int]paramIndex {
 }
 
 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] {
@@ -127,15 +136,13 @@ var (
 	}
 )
 
-type Mapping = map[int]paramIndex
-
 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] {
+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] {
@@ -167,7 +174,7 @@ func MakeProviderFactory(
 	fct func(param ...any) IOE.IOEither[error, any]) ProviderFactory {
 
 	return F.Flow3(
-		F.Curry2(A.MonadMap[Dependency, IOE.IOEither[error, any]])(deps),
+		mapDeps(deps),
 		handleMapping(foldDeps(deps)),
 		IOE.Chain(F.Unvariadic0(fct)),
 	)

di/injector.go

@@ -7,7 +7,6 @@
 //
 // 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.

di/provider.go

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

di/provider_test.go

@@ -12,6 +12,7 @@
 // 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 (
@@ -38,12 +39,10 @@ func TestSimpleProvider(t *testing.T) {
 
 	var staticCount int
 
-	staticValue := func(value string) func() IOE.IOEither[error, string] {
-		return func() IOE.IOEither[error, string] {
-			return func() E.Either[error, string] {
-				staticCount++
-				return E.Of[error](fmt.Sprintf("Static based on [%s], at [%s]", value, time.Now()))
-			}
+	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()))
 		}
 	}
 
@@ -82,12 +81,10 @@ func TestOptionalProvider(t *testing.T) {
 
 	var staticCount int
 
-	staticValue := func(value string) func() IOE.IOEither[error, string] {
-		return func() IOE.IOEither[error, string] {
-			return func() E.Either[error, string] {
-				staticCount++
-				return E.Of[error](fmt.Sprintf("Static based on [%s], at [%s]", value, time.Now()))
-			}
+	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()))
 		}
 	}
 
@@ -182,12 +179,10 @@ func TestEagerAndLazyProvider(t *testing.T) {
 
 	var staticCount int
 
-	staticValue := func(value string) func() IOE.IOEither[error, string] {
-		return func() IOE.IOEither[error, string] {
-			return func() E.Either[error, string] {
-				staticCount++
-				return E.Of[error](fmt.Sprintf("Static based on [%s], at [%s]", value, time.Now()))
-			}
+	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()))
 		}
 	}
 
@@ -307,7 +302,7 @@ func TestTokenWithDefaultProvider(t *testing.T) {
 	// token without a default
 	injToken1 := MakeToken[string]("Token1")
 	// token with a default
-	injToken2 := MakeTokenWithDefault0("Token2", F.Constant(IOE.Of[error]("Carsten")))
+	injToken2 := MakeTokenWithDefault0("Token2", IOE.Of[error]("Carsten"))
 	// dependency
 	injToken3 := MakeToken[string]("Token3")
 
@@ -330,7 +325,7 @@ func TestTokenWithDefaultProvider(t *testing.T) {
 
 func TestTokenWithDefaultProviderAndOverride(t *testing.T) {
 	// token with a default
-	injToken2 := MakeTokenWithDefault0("Token2", F.Constant(IOE.Of[error]("Carsten")))
+	injToken2 := MakeTokenWithDefault0("Token2", IOE.Of[error]("Carsten"))
 	// dependency
 	injToken3 := MakeToken[string]("Token3")
 

di/token.go

@@ -42,20 +42,21 @@ type InjectionToken[T any] interface {
 	// 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 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
+	// 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
+	// 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.
+// 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]
@@ -64,34 +65,38 @@ type MultiInjectionToken[T any] interface {
 }
 
 // makeID creates a generator of unique string IDs
-func makeId() IO.IO[string] {
+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()
+// genID is the common generator of unique string IDs
+var genID = makeID()
 
-type token[T any] struct {
+type tokenBase struct {
 	name            string
 	id              string
 	flag            int
-	toType          func(val any) E.Either[error, T]
 	providerFactory O.Option[DIE.ProviderFactory]
 }
 
+type token[T any] struct {
+	base   *tokenBase
+	toType func(val any) E.Either[error, T]
+}
+
 func (t *token[T]) Id() string {
-	return t.id
+	return t.base.id
 }
 
 func (t *token[T]) Flag() int {
-	return t.flag
+	return t.base.flag
 }
 
 func (t *token[T]) String() string {
-	return t.name
+	return t.base.name
 }
 
 func (t *token[T]) Unerase(val any) E.Either[error, T] {
@@ -99,11 +104,14 @@ func (t *token[T]) Unerase(val any) E.Either[error, T] {
 }
 
 func (t *token[T]) ProviderFactory() O.Option[DIE.ProviderFactory] {
-	return t.providerFactory
+	return t.base.providerFactory
+}
+func makeTokenBase(name string, id string, typ int, providerFactory O.Option[DIE.ProviderFactory]) *tokenBase {
+	return &tokenBase{name, id, typ, 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}
+	return &token[T]{makeTokenBase(name, id, typ, providerFactory), unerase}
 }
 
 type injectionToken[T any] struct {
@@ -135,7 +143,7 @@ func (i *injectionToken[T]) IOOption() Dependency[IOO.IOOption[T]] {
 }
 
 func (i *injectionToken[T]) ProviderFactory() O.Option[DIE.ProviderFactory] {
-	return i.providerFactory
+	return i.base.providerFactory
 }
 
 func (m *multiInjectionToken[T]) Container() InjectionToken[[]T] {
@@ -146,31 +154,31 @@ func (m *multiInjectionToken[T]) Item() InjectionToken[T] {
 	return m.item
 }
 
-// makeToken create a unique `InjectionToken` for a specific type
+// makeToken create a unique [InjectionToken] for a specific type
 func makeInjectionToken[T any](name string, providerFactory O.Option[DIE.ProviderFactory]) InjectionToken[T] {
-	id := genId()
+	id := genID()
 	toIdentity := toType[T]()
 	return &injectionToken[T]{
-		token[T]{name, id, DIE.Identity, toIdentity, providerFactory},
+		token[T]{makeTokenBase(name, id, DIE.Identity, providerFactory), toIdentity},
 		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
+// 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
+// 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()
+	id := genID()
 	toItem := toType[T]()
 	toContainer := toArrayType(toItem)
 	containerName := fmt.Sprintf("Container[%s]", name)
@@ -179,14 +187,14 @@ func MakeMultiToken[T any](name string) MultiInjectionToken[T] {
 	providerFactory := O.None[DIE.ProviderFactory]()
 	// container
 	container := &injectionToken[[]T]{
-		token[[]T]{containerName, id, DIE.Multi | DIE.Identity, toContainer, providerFactory},
+		token[[]T]{makeTokenBase(containerName, id, DIE.Multi|DIE.Identity, providerFactory), toContainer},
 		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},
+		token[T]{makeTokenBase(itemName, id, DIE.Item|DIE.Identity, providerFactory), toItem},
 		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),

di/utils.go

@@ -12,6 +12,7 @@
 // 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 (
@@ -24,6 +25,13 @@ import (
 	O "github.com/IBM/fp-go/option"
 )
 
+var (
+	toOptionAny   = toType[O.Option[any]]()
+	toIOEitherAny = toType[IOE.IOEither[error, any]]()
+	toIOOptionAny = toType[IOO.IOOption[any]]()
+	toArrayAny    = toType[[]any]()
+)
+
 // asDependency converts a generic type to a [DIE.Dependency]
 func asDependency[T DIE.Dependency](t T) DIE.Dependency {
 	return t
@@ -37,7 +45,7 @@ func toType[T any]() func(t any) E.Either[error, T] {
 // 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]](),
+		toOptionAny,
 		E.Chain(O.Fold(
 			F.Nullary2(O.None[T], E.Of[error, O.Option[T]]),
 			F.Flow2(
@@ -51,7 +59,7 @@ func toOptionType[T any](item func(any) E.Either[error, T]) func(t any) E.Either
 // 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]](),
+		toIOEitherAny,
 		E.Map[error](IOE.ChainEitherK(item)),
 	)
 }
@@ -59,7 +67,7 @@ func toIOEitherType[T any](item func(any) E.Either[error, T]) func(t any) E.Eith
 // 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]](),
+		toIOOptionAny,
 		E.Map[error](IOO.ChainOptionK(F.Flow2(
 			item,
 			E.ToOption[error, T],
@@ -70,7 +78,7 @@ func toIOOptionType[T any](item func(any) E.Either[error, T]) func(t any) E.Eith
 // 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](),
+		toArrayAny,
 		E.Chain(E.TraverseArray(item)),
 	)
 }

di/utils_test.go

@@ -12,6 +12,7 @@
 // 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 (

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

@@ -23,17 +23,16 @@ type (
 	// Either defines a data structure that logically holds either an E or an A. The flag discriminates the cases
 	Either[E, A any] struct {
 		isLeft bool
-		left   E
-		right  A
+		value  any
 	}
 )
 
 // String prints some debug info for the object
 func (s Either[E, A]) String() string {
 	if s.isLeft {
-		return fmt.Sprintf("Left[%T, %T](%v)", s.left, s.right, s.left)
+		return fmt.Sprintf("Left[%T](%v)", s.value, s.value)
 	}
-	return fmt.Sprintf("Right[%T, %T](%v)", s.left, s.right, s.right)
+	return fmt.Sprintf("Right[%T](%v)", s.value, s.value)
 }
 
 // Format prints some debug info for the object
@@ -58,23 +57,29 @@ func IsRight[E, A any](val Either[E, A]) bool {
 
 // Left creates a new instance of an [Either] representing the left value.
 func Left[A, E any](value E) Either[E, A] {
-	return Either[E, A]{isLeft: true, left: value}
+	return Either[E, A]{true, value}
 }
 
 // Right creates a new instance of an [Either] representing the right value.
 func Right[E, A any](value A) Either[E, A] {
-	return Either[E, A]{isLeft: false, right: value}
+	return Either[E, A]{false, value}
 }
 
 // MonadFold extracts the values from an [Either] by invoking the [onLeft] callback or the [onRight] callback depending on the case
 func MonadFold[E, A, B any](ma Either[E, A], onLeft func(e E) B, onRight func(a A) B) B {
 	if ma.isLeft {
-		return onLeft(ma.left)
+		return onLeft(ma.value.(E))
 	}
-	return onRight(ma.right)
+	return onRight(ma.value.(A))
 }
 
 // Unwrap converts an [Either] into the idiomatic tuple
 func Unwrap[E, A any](ma Either[E, A]) (A, E) {
-	return ma.right, ma.left
+	if ma.isLeft {
+		var a A
+		return a, ma.value.(E)
+	} else {
+		var e E
+		return ma.value.(A), e
+	}
 }

either/either.go

@@ -22,6 +22,7 @@ package either
 import (
 	E "github.com/IBM/fp-go/errors"
 	F "github.com/IBM/fp-go/function"
+	C "github.com/IBM/fp-go/internal/chain"
 	FC "github.com/IBM/fp-go/internal/functor"
 	L "github.com/IBM/fp-go/lazy"
 	O "github.com/IBM/fp-go/option"
@@ -64,19 +65,20 @@ func MonadMapTo[E, A, B any](fa Either[E, A], b B) Either[E, B] {
 }
 
 func MapTo[E, A, B any](b B) func(Either[E, A]) Either[E, B] {
-	return F.Bind2nd(MonadMapTo[E, A, B], b)
+	return Map[E](F.Constant1[A](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 Fold(F.Flow2(f, Left[A, E2]), Right[E2, A])
 }
 
 func MonadChain[E, A, B any](fa Either[E, A], f func(a A) Either[E, B]) Either[E, B] {
@@ -84,12 +86,15 @@ func MonadChain[E, A, B any](fa Either[E, A], f func(a A) Either[E, B]) Either[E
 }
 
 func MonadChainFirst[E, A, B any](ma Either[E, A], f func(a A) Either[E, B]) Either[E, A] {
-	return MonadChain(ma, func(a A) Either[E, A] {
-		return MonadMap(f(a), F.Constant1[B](a))
-	})
+	return C.MonadChainFirst(
+		MonadChain[E, A, A],
+		MonadMap[E, B, A],
+		ma,
+		f,
+	)
 }
 
-func MonadChainTo[A, E, B any](ma Either[E, A], mb Either[E, B]) Either[E, B] {
+func MonadChainTo[A, E, B any](_ Either[E, A], mb Either[E, B]) Either[E, B] {
 	return mb
 }
 
@@ -105,15 +110,19 @@ func ChainOptionK[A, B, E any](onNone func() E) func(func(A) O.Option[B]) func(E
 }
 
 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)
+	return F.Constant1[Either[E, A]](mb)
 }
 
 func Chain[E, A, B any](f func(a A) Either[E, B]) func(Either[E, A]) Either[E, B] {
-	return F.Bind2nd(MonadChain[E, A, B], f)
+	return Fold(Left[B, E], f)
 }
 
 func ChainFirst[E, A, B any](f func(a A) Either[E, B]) func(Either[E, A]) Either[E, A] {
-	return F.Bind2nd(MonadChainFirst[E, A, B], f)
+	return C.ChainFirst(
+		Chain[E, A, A],
+		Map[E, B, A],
+		f,
+	)
 }
 
 func Flatten[E, A any](mma Either[E, Either[E, A]]) Either[E, A] {
@@ -250,7 +259,7 @@ func MonadFlap[E, B, A any](fab Either[E, func(A) B], a A) Either[E, B] {
 }
 
 func Flap[E, B, A any](a A) func(Either[E, func(A) B]) Either[E, B] {
-	return F.Bind2nd(MonadFlap[E, B, A], a)
+	return FC.Flap(Map[E, func(A) B, B], a)
 }
 
 func MonadAlt[E, A any](fa Either[E, A], that L.Lazy[Either[E, A]]) Either[E, A] {

either/either_test.go

@@ -26,12 +26,6 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestDefault(t *testing.T) {
-	var e Either[error, string]
-
-	assert.Equal(t, Of[error](""), e)
-}
-
 func TestIsLeft(t *testing.T) {
 	err := errors.New("Some error")
 	withError := Left[string](err)

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

@@ -48,11 +48,11 @@ func ExampleEither_creation() {
 	fmt.Println(rightFromPred)
 
 	// Output:
-	// Left[*errors.errorString, string](some error)
-	// Right[<nil>, string](value)
-	// Left[*errors.errorString, *string](value was nil)
+	// Left[*errors.errorString](some error)
+	// Right[string](value)
+	// Left[*errors.errorString](value was nil)
 	// true
-	// Left[*errors.errorString, int](3 is an odd number)
-	// Right[<nil>, int](4)
+	// Left[*errors.errorString](3 is an odd number)
+	// Right[int](4)
 
 }

either/examples_extract_test.go

@@ -53,8 +53,8 @@ func ExampleEither_extraction() {
 	fmt.Println(doubleFromRightBis)
 
 	// Output:
-	// Left[*errors.errorString, int](Division by Zero!)
-	// Right[<nil>, int](10)
+	// Left[*errors.errorString](Division by Zero!)
+	// Right[int](10)
 	// 0
 	// 10
 	// 0

either/monad.go

@@ -0,0 +1,43 @@
+// Copyright (c) 2024 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 (
+	"github.com/IBM/fp-go/internal/monad"
+)
+
+type eitherMonad[E, A, B any] struct{}
+
+func (o *eitherMonad[E, A, B]) Of(a A) Either[E, A] {
+	return Of[E, A](a)
+}
+
+func (o *eitherMonad[E, A, B]) Map(f func(A) B) func(Either[E, A]) Either[E, B] {
+	return Map[E, A, B](f)
+}
+
+func (o *eitherMonad[E, A, B]) Chain(f func(A) Either[E, B]) func(Either[E, A]) Either[E, B] {
+	return Chain[E, A, B](f)
+}
+
+func (o *eitherMonad[E, A, B]) Ap(fa Either[E, A]) func(Either[E, func(A) B]) Either[E, B] {
+	return Ap[B, E, A](fa)
+}
+
+// Monad implements the monadic operations for [Either]
+func Monad[E, A, B any]() monad.Monad[A, B, Either[E, A], Either[E, B], Either[E, func(A) B]] {
+	return &eitherMonad[E, A, B]{}
+}

either/traverse.go

@@ -19,38 +19,17 @@ import (
 	F "github.com/IBM/fp-go/function"
 )
 
-/*
-*
-We need to pass the members of the applicative explicitly, because golang does neither support higher kinded types nor template methods on structs or interfaces
-
-HKTRB = HKT<Either[B]>
-HKTA = HKT<A>
-HKTB = HKT<B>
-*/
-func traverse[E, A, B, HKTB, HKTRB any](
-	mof func(Either[E, B]) HKTRB,
-	mmap func(func(B) Either[E, B]) func(HKTB) HKTRB,
-) func(Either[E, A], func(A) HKTB) HKTRB {
-
-	left := F.Flow2(Left[B, E], mof)
-	right := mmap(Right[E, B])
-
-	return func(ta Either[E, A], f func(A) HKTB) HKTRB {
-		return MonadFold(ta,
-			left,
-			F.Flow2(f, right),
-		)
-	}
-}
-
 // Traverse converts an [Either] of some higher kinded type into the higher kinded type of an [Either]
 func Traverse[A, E, B, HKTB, HKTRB any](
 	mof func(Either[E, B]) HKTRB,
 	mmap func(func(B) Either[E, B]) func(HKTB) HKTRB,
 ) func(func(A) HKTB) func(Either[E, A]) HKTRB {
-	delegate := traverse[E, A, B](mof, mmap)
+
+	left := F.Flow2(Left[B, E], mof)
+	right := mmap(Right[E, B])
+
 	return func(f func(A) HKTB) func(Either[E, A]) HKTRB {
-		return F.Bind2nd(delegate, f)
+		return Fold(left, F.Flow2(f, right))
 	}
 }
 

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

@@ -27,34 +27,10 @@ func Ap[A any](fa A) func(Endomorphism[A]) A {
 	return G.Ap[Endomorphism[A]](fa)
 }
 
-func MonadFlap[A any](fab Endomorphism[A], a A) A {
-	return G.MonadFlap[Endomorphism[A]](fab, a)
-}
-
-func Flap[A any](a A) func(Endomorphism[A]) A {
-	return G.Flap[Endomorphism[A]](a)
-}
-
-func MonadMap[A any](fa A, f Endomorphism[A]) A {
-	return G.MonadMap[Endomorphism[A]](fa, f)
-}
-
-func Map[A any](f Endomorphism[A]) Endomorphism[A] {
-	return G.Map[Endomorphism[A]](f)
-}
-
-func MonadChain[A any](ma A, f Endomorphism[A]) A {
+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[A] {
-	return G.Chain[Endomorphism[A], A](f)
-}
-
-func MonadChainFirst[A any](fa A, f Endomorphism[A]) A {
-	return G.MonadChainFirst[Endomorphism[A]](fa, f)
-}
-
-func ChainFirst[A any](f Endomorphism[A]) Endomorphism[A] {
-	return G.ChainFirst[Endomorphism[A]](f)
+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

@@ -16,6 +16,7 @@
 package generic
 
 import (
+	F "github.com/IBM/fp-go/function"
 	I "github.com/IBM/fp-go/identity/generic"
 )
 
@@ -27,34 +28,10 @@ func Ap[GA ~func(A) A, A any](fa A) func(GA) A {
 	return I.Ap[GA, A, A](fa)
 }
 
-func MonadFlap[GA ~func(A) A, A any](fab GA, a A) A {
-	return I.MonadFlap[GA, A, A](fab, a)
+func MonadChain[GA ~func(A) A, A any](ma GA, f GA) GA {
+	return Compose(ma, f)
 }
 
-func Flap[GA ~func(A) A, A any](a A) func(GA) A {
-	return I.Flap[GA, A, A](a)
-}
-
-func MonadMap[GA ~func(A) A, A any](fa A, f GA) A {
-	return I.MonadMap[GA, A, A](fa, f)
-}
-
-func Map[GA ~func(A) A, A any](f GA) GA {
-	return I.Map[GA, A, A](f)
-}
-
-func MonadChain[GA ~func(A) A, A any](ma A, f GA) A {
-	return I.MonadChain[GA, A, A](ma, f)
-}
-
-func Chain[GA ~func(A) A, A any](f GA) GA {
-	return I.Chain[GA, A](f)
-}
-
-func MonadChainFirst[GA ~func(A) A, A any](fa A, f GA) A {
-	return I.MonadChainFirst[GA, A, A](fa, f)
-}
-
-func ChainFirst[GA ~func(A) A, A any](f GA) GA {
-	return I.ChainFirst[GA, A, A](f)
+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

@@ -28,6 +28,16 @@ func Of[ENDO ~func(A) A, F ~func(A) A, A any](f F) ENDO {
 	}
 }
 
+// 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])
 }

endomorphism/monoid.go

@@ -29,6 +29,16 @@ 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]]()

eq/eq.go

@@ -27,20 +27,20 @@ type eq[T any] struct {
 	c func(x, y T) bool
 }
 
-func (self eq[T]) Equals(x, y T) bool {
-	return self.c(x, y)
+func (e eq[T]) Equals(x, y T) bool {
+	return e.c(x, y)
 }
 
 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}
 }

function/binds.go

@@ -1,6 +1,6 @@
 // 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
 

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

@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-10-23 08:30:41.7972101 +0200 CEST m=+0.008029101
+// 2024-01-31 21:44:55.7538323 +0100 CET m=+0.013067701
 
 package function
 
@@ -34,8 +34,7 @@ func Unsliced0[F ~func([]T) R, T, R any](f F) func() R {
 // Pipe1 takes an initial value t0 and successively applies 1 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe1[F1 ~func(T0) T1, T0, T1 any](t0 T0, f1 F1) T1 {
-	t1 := f1(t0)
-	return t1
+	return f1(t0)
 }
 
 // Flow1 creates a function that takes an initial value t0 and successively applies 1 functions where the input of a function is the return value of the previous function
@@ -55,7 +54,7 @@ func Nullary1[F1 ~func() T1, T1 any](f1 F1) func() T1 {
 
 // Curry1 takes a function with 1 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry1]
-func Curry1[T0, T1 any](f func(T0) T1) func(T0) T1 {
+func Curry1[FCT ~func(T0) T1, T0, T1 any](f FCT) func(T0) T1 {
 	return func(t0 T0) T1 {
 		return f(t0)
 	}
@@ -63,7 +62,7 @@ func Curry1[T0, T1 any](f func(T0) T1) func(T0) T1 {
 
 // Uncurry1 takes a cascade of 1 functions each taking only one parameter and returns a function with 1 parameters .
 // The inverse function is [Curry1]
-func Uncurry1[T0, T1 any](f func(T0) T1) func(T0) T1 {
+func Uncurry1[FCT ~func(T0) T1, T0, T1 any](f FCT) func(T0) T1 {
 	return func(t0 T0) T1 {
 		return f(t0)
 	}
@@ -93,9 +92,7 @@ func Unsliced1[F ~func([]T) R, T, R any](f F) func(T) R {
 // Pipe2 takes an initial value t0 and successively applies 2 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe2[F1 ~func(T0) T1, F2 ~func(T1) T2, T0, T1, T2 any](t0 T0, f1 F1, f2 F2) T2 {
-	t1 := f1(t0)
-	t2 := f2(t1)
-	return t2
+	return f2(f1(t0))
 }
 
 // Flow2 creates a function that takes an initial value t0 and successively applies 2 functions where the input of a function is the return value of the previous function
@@ -115,7 +112,7 @@ func Nullary2[F1 ~func() T1, F2 ~func(T1) T2, T1, T2 any](f1 F1, f2 F2) func() T
 
 // Curry2 takes a function with 2 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry2]
-func Curry2[T0, T1, T2 any](f func(T0, T1) T2) func(T0) func(T1) T2 {
+func Curry2[FCT ~func(T0, T1) T2, T0, T1, T2 any](f FCT) func(T0) func(T1) T2 {
 	return func(t0 T0) func(t1 T1) T2 {
 		return func(t1 T1) T2 {
 			return f(t0, t1)
@@ -125,7 +122,7 @@ func Curry2[T0, T1, T2 any](f func(T0, T1) T2) func(T0) func(T1) T2 {
 
 // Uncurry2 takes a cascade of 2 functions each taking only one parameter and returns a function with 2 parameters .
 // The inverse function is [Curry2]
-func Uncurry2[T0, T1, T2 any](f func(T0) func(T1) T2) func(T0, T1) T2 {
+func Uncurry2[FCT ~func(T0) func(T1) T2, T0, T1, T2 any](f FCT) func(T0, T1) T2 {
 	return func(t0 T0, t1 T1) T2 {
 		return f(t0)(t1)
 	}
@@ -155,10 +152,7 @@ func Unsliced2[F ~func([]T) R, T, R any](f F) func(T, T) R {
 // Pipe3 takes an initial value t0 and successively applies 3 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe3[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, T0, T1, T2, T3 any](t0 T0, f1 F1, f2 F2, f3 F3) T3 {
-	t1 := f1(t0)
-	t2 := f2(t1)
-	t3 := f3(t2)
-	return t3
+	return f3(f2(f1(t0)))
 }
 
 // Flow3 creates a function that takes an initial value t0 and successively applies 3 functions where the input of a function is the return value of the previous function
@@ -178,7 +172,7 @@ func Nullary3[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, T1, T2, T3 any](f
 
 // Curry3 takes a function with 3 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry3]
-func Curry3[T0, T1, T2, T3 any](f func(T0, T1, T2) T3) func(T0) func(T1) func(T2) T3 {
+func Curry3[FCT ~func(T0, T1, T2) T3, T0, T1, T2, T3 any](f FCT) func(T0) func(T1) func(T2) T3 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) T3 {
 		return func(t1 T1) func(t2 T2) T3 {
 			return func(t2 T2) T3 {
@@ -190,7 +184,7 @@ func Curry3[T0, T1, T2, T3 any](f func(T0, T1, T2) T3) func(T0) func(T1) func(T2
 
 // Uncurry3 takes a cascade of 3 functions each taking only one parameter and returns a function with 3 parameters .
 // The inverse function is [Curry3]
-func Uncurry3[T0, T1, T2, T3 any](f func(T0) func(T1) func(T2) T3) func(T0, T1, T2) T3 {
+func Uncurry3[FCT ~func(T0) func(T1) func(T2) T3, T0, T1, T2, T3 any](f FCT) func(T0, T1, T2) T3 {
 	return func(t0 T0, t1 T1, t2 T2) T3 {
 		return f(t0)(t1)(t2)
 	}
@@ -220,11 +214,7 @@ func Unsliced3[F ~func([]T) R, T, R any](f F) func(T, T, T) R {
 // Pipe4 takes an initial value t0 and successively applies 4 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe4[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, T0, T1, T2, T3, T4 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4) T4 {
-	t1 := f1(t0)
-	t2 := f2(t1)
-	t3 := f3(t2)
-	t4 := f4(t3)
-	return t4
+	return f4(f3(f2(f1(t0))))
 }
 
 // Flow4 creates a function that takes an initial value t0 and successively applies 4 functions where the input of a function is the return value of the previous function
@@ -244,7 +234,7 @@ func Nullary4[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry4 takes a function with 4 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry4]
-func Curry4[T0, T1, T2, T3, T4 any](f func(T0, T1, T2, T3) T4) func(T0) func(T1) func(T2) func(T3) T4 {
+func Curry4[FCT ~func(T0, T1, T2, T3) T4, T0, T1, T2, T3, T4 any](f FCT) func(T0) func(T1) func(T2) func(T3) T4 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) T4 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) T4 {
 			return func(t2 T2) func(t3 T3) T4 {
@@ -258,7 +248,7 @@ func Curry4[T0, T1, T2, T3, T4 any](f func(T0, T1, T2, T3) T4) func(T0) func(T1)
 
 // Uncurry4 takes a cascade of 4 functions each taking only one parameter and returns a function with 4 parameters .
 // The inverse function is [Curry4]
-func Uncurry4[T0, T1, T2, T3, T4 any](f func(T0) func(T1) func(T2) func(T3) T4) func(T0, T1, T2, T3) T4 {
+func Uncurry4[FCT ~func(T0) func(T1) func(T2) func(T3) T4, T0, T1, T2, T3, T4 any](f FCT) func(T0, T1, T2, T3) T4 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3) T4 {
 		return f(t0)(t1)(t2)(t3)
 	}
@@ -288,12 +278,7 @@ func Unsliced4[F ~func([]T) R, T, R any](f F) func(T, T, T, T) R {
 // Pipe5 takes an initial value t0 and successively applies 5 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe5[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, T0, T1, T2, T3, T4, T5 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) T5 {
-	t1 := f1(t0)
-	t2 := f2(t1)
-	t3 := f3(t2)
-	t4 := f4(t3)
-	t5 := f5(t4)
-	return t5
+	return f5(f4(f3(f2(f1(t0)))))
 }
 
 // Flow5 creates a function that takes an initial value t0 and successively applies 5 functions where the input of a function is the return value of the previous function
@@ -313,7 +298,7 @@ func Nullary5[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry5 takes a function with 5 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry5]
-func Curry5[T0, T1, T2, T3, T4, T5 any](f func(T0, T1, T2, T3, T4) T5) func(T0) func(T1) func(T2) func(T3) func(T4) T5 {
+func Curry5[FCT ~func(T0, T1, T2, T3, T4) T5, T0, T1, T2, T3, T4, T5 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) T5 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) T5 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) T5 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) T5 {
@@ -329,7 +314,7 @@ func Curry5[T0, T1, T2, T3, T4, T5 any](f func(T0, T1, T2, T3, T4) T5) func(T0)
 
 // Uncurry5 takes a cascade of 5 functions each taking only one parameter and returns a function with 5 parameters .
 // The inverse function is [Curry5]
-func Uncurry5[T0, T1, T2, T3, T4, T5 any](f func(T0) func(T1) func(T2) func(T3) func(T4) T5) func(T0, T1, T2, T3, T4) T5 {
+func Uncurry5[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) T5, T0, T1, T2, T3, T4, T5 any](f FCT) func(T0, T1, T2, T3, T4) T5 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) T5 {
 		return f(t0)(t1)(t2)(t3)(t4)
 	}
@@ -359,13 +344,7 @@ func Unsliced5[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T) R {
 // Pipe6 takes an initial value t0 and successively applies 6 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe6[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, T0, T1, T2, T3, T4, T5, T6 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) T6 {
-	t1 := f1(t0)
-	t2 := f2(t1)
-	t3 := f3(t2)
-	t4 := f4(t3)
-	t5 := f5(t4)
-	t6 := f6(t5)
-	return t6
+	return f6(f5(f4(f3(f2(f1(t0))))))
 }
 
 // Flow6 creates a function that takes an initial value t0 and successively applies 6 functions where the input of a function is the return value of the previous function
@@ -385,7 +364,7 @@ func Nullary6[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry6 takes a function with 6 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry6]
-func Curry6[T0, T1, T2, T3, T4, T5, T6 any](f func(T0, T1, T2, T3, T4, T5) T6) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) T6 {
+func Curry6[FCT ~func(T0, T1, T2, T3, T4, T5) T6, T0, T1, T2, T3, T4, T5, T6 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) T6 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) T6 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) T6 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) T6 {
@@ -403,7 +382,7 @@ func Curry6[T0, T1, T2, T3, T4, T5, T6 any](f func(T0, T1, T2, T3, T4, T5) T6) f
 
 // Uncurry6 takes a cascade of 6 functions each taking only one parameter and returns a function with 6 parameters .
 // The inverse function is [Curry6]
-func Uncurry6[T0, T1, T2, T3, T4, T5, T6 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) T6) func(T0, T1, T2, T3, T4, T5) T6 {
+func Uncurry6[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) T6, T0, T1, T2, T3, T4, T5, T6 any](f FCT) func(T0, T1, T2, T3, T4, T5) T6 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) T6 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)
 	}
@@ -433,14 +412,7 @@ func Unsliced6[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T) R {
 // Pipe7 takes an initial value t0 and successively applies 7 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe7[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, T0, T1, T2, T3, T4, T5, T6, T7 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) T7 {
-	t1 := f1(t0)
-	t2 := f2(t1)
-	t3 := f3(t2)
-	t4 := f4(t3)
-	t5 := f5(t4)
-	t6 := f6(t5)
-	t7 := f7(t6)
-	return t7
+	return f7(f6(f5(f4(f3(f2(f1(t0)))))))
 }
 
 // Flow7 creates a function that takes an initial value t0 and successively applies 7 functions where the input of a function is the return value of the previous function
@@ -460,7 +432,7 @@ func Nullary7[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry7 takes a function with 7 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry7]
-func Curry7[T0, T1, T2, T3, T4, T5, T6, T7 any](f func(T0, T1, T2, T3, T4, T5, T6) T7) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) T7 {
+func Curry7[FCT ~func(T0, T1, T2, T3, T4, T5, T6) T7, T0, T1, T2, T3, T4, T5, T6, T7 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) T7 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) T7 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) T7 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) T7 {
@@ -480,7 +452,7 @@ func Curry7[T0, T1, T2, T3, T4, T5, T6, T7 any](f func(T0, T1, T2, T3, T4, T5, T
 
 // Uncurry7 takes a cascade of 7 functions each taking only one parameter and returns a function with 7 parameters .
 // The inverse function is [Curry7]
-func Uncurry7[T0, T1, T2, T3, T4, T5, T6, T7 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) T7) func(T0, T1, T2, T3, T4, T5, T6) T7 {
+func Uncurry7[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) T7, T0, T1, T2, T3, T4, T5, T6, T7 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6) T7 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) T7 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)
 	}
@@ -510,15 +482,7 @@ func Unsliced7[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T) R {
 // Pipe8 takes an initial value t0 and successively applies 8 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe8[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, T0, T1, T2, T3, T4, T5, T6, T7, T8 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) T8 {
-	t1 := f1(t0)
-	t2 := f2(t1)
-	t3 := f3(t2)
-	t4 := f4(t3)
-	t5 := f5(t4)
-	t6 := f6(t5)
-	t7 := f7(t6)
-	t8 := f8(t7)
-	return t8
+	return f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))
 }
 
 // Flow8 creates a function that takes an initial value t0 and successively applies 8 functions where the input of a function is the return value of the previous function
@@ -538,7 +502,7 @@ func Nullary8[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry8 takes a function with 8 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry8]
-func Curry8[T0, T1, T2, T3, T4, T5, T6, T7, T8 any](f func(T0, T1, T2, T3, T4, T5, T6, T7) T8) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T8 {
+func Curry8[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7) T8, T0, T1, T2, T3, T4, T5, T6, T7, T8 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T8 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) T8 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) T8 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) T8 {
@@ -560,7 +524,7 @@ func Curry8[T0, T1, T2, T3, T4, T5, T6, T7, T8 any](f func(T0, T1, T2, T3, T4, T
 
 // Uncurry8 takes a cascade of 8 functions each taking only one parameter and returns a function with 8 parameters .
 // The inverse function is [Curry8]
-func Uncurry8[T0, T1, T2, T3, T4, T5, T6, T7, T8 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T8) func(T0, T1, T2, T3, T4, T5, T6, T7) T8 {
+func Uncurry8[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T8, T0, T1, T2, T3, T4, T5, T6, T7, T8 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7) T8 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) T8 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)
 	}
@@ -590,16 +554,7 @@ func Unsliced8[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T) R {
 // Pipe9 takes an initial value t0 and successively applies 9 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe9[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) T9 {
-	t1 := f1(t0)
-	t2 := f2(t1)
-	t3 := f3(t2)
-	t4 := f4(t3)
-	t5 := f5(t4)
-	t6 := f6(t5)
-	t7 := f7(t6)
-	t8 := f8(t7)
-	t9 := f9(t8)
-	return t9
+	return f9(f8(f7(f6(f5(f4(f3(f2(f1(t0)))))))))
 }
 
 // Flow9 creates a function that takes an initial value t0 and successively applies 9 functions where the input of a function is the return value of the previous function
@@ -619,7 +574,7 @@ func Nullary9[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry9 takes a function with 9 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry9]
-func Curry9[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8) T9) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T9 {
+func Curry9[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) T9, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T9 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) T9 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) T9 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) T9 {
@@ -643,7 +598,7 @@ func Curry9[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](f func(T0, T1, T2, T3, T
 
 // Uncurry9 takes a cascade of 9 functions each taking only one parameter and returns a function with 9 parameters .
 // The inverse function is [Curry9]
-func Uncurry9[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T9) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) T9 {
+func Uncurry9[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T9, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) T9 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) T9 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)
 	}
@@ -673,17 +628,7 @@ func Unsliced9[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T) R
 // Pipe10 takes an initial value t0 and successively applies 10 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe10[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) T10 {
-	t1 := f1(t0)
-	t2 := f2(t1)
-	t3 := f3(t2)
-	t4 := f4(t3)
-	t5 := f5(t4)
-	t6 := f6(t5)
-	t7 := f7(t6)
-	t8 := f8(t7)
-	t9 := f9(t8)
-	t10 := f10(t9)
-	return t10
+	return f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))))
 }
 
 // Flow10 creates a function that takes an initial value t0 and successively applies 10 functions where the input of a function is the return value of the previous function
@@ -703,7 +648,7 @@ func Nullary10[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry10 takes a function with 10 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry10]
-func Curry10[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) T10) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T10 {
+func Curry10[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) T10, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T10 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) T10 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) T10 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) T10 {
@@ -729,7 +674,7 @@ func Curry10[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](f func(T0, T1, T2,
 
 // Uncurry10 takes a cascade of 10 functions each taking only one parameter and returns a function with 10 parameters .
 // The inverse function is [Curry10]
-func Uncurry10[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T10) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) T10 {
+func Uncurry10[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T10, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) T10 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) T10 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)
 	}
@@ -759,18 +704,7 @@ func Unsliced10[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe11 takes an initial value t0 and successively applies 11 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe11[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11) T11 {
-	t1 := f1(t0)
-	t2 := f2(t1)
-	t3 := f3(t2)
-	t4 := f4(t3)
-	t5 := f5(t4)
-	t6 := f6(t5)
-	t7 := f7(t6)
-	t8 := f8(t7)
-	t9 := f9(t8)
-	t10 := f10(t9)
-	t11 := f11(t10)
-	return t11
+	return f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0)))))))))))
 }
 
 // Flow11 creates a function that takes an initial value t0 and successively applies 11 functions where the input of a function is the return value of the previous function
@@ -790,7 +724,7 @@ func Nullary11[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry11 takes a function with 11 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry11]
-func Curry11[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) T11) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T11 {
+func Curry11[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) T11, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T11 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) T11 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) T11 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) T11 {
@@ -818,7 +752,7 @@ func Curry11[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](f func(T0, T1
 
 // Uncurry11 takes a cascade of 11 functions each taking only one parameter and returns a function with 11 parameters .
 // The inverse function is [Curry11]
-func Uncurry11[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T11) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) T11 {
+func Uncurry11[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T11, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) T11 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10) T11 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)
 	}
@@ -848,19 +782,7 @@ func Unsliced11[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe12 takes an initial value t0 and successively applies 12 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe12[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12) T12 {
-	t1 := f1(t0)
-	t2 := f2(t1)
-	t3 := f3(t2)
-	t4 := f4(t3)
-	t5 := f5(t4)
-	t6 := f6(t5)
-	t7 := f7(t6)
-	t8 := f8(t7)
-	t9 := f9(t8)
-	t10 := f10(t9)
-	t11 := f11(t10)
-	t12 := f12(t11)
-	return t12
+	return f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))))))
 }
 
 // Flow12 creates a function that takes an initial value t0 and successively applies 12 functions where the input of a function is the return value of the previous function
@@ -880,7 +802,7 @@ func Nullary12[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry12 takes a function with 12 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry12]
-func Curry12[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) T12) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T12 {
+func Curry12[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) T12, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T12 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) T12 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) T12 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) T12 {
@@ -910,7 +832,7 @@ func Curry12[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](f func(T
 
 // Uncurry12 takes a cascade of 12 functions each taking only one parameter and returns a function with 12 parameters .
 // The inverse function is [Curry12]
-func Uncurry12[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T12) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) T12 {
+func Uncurry12[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T12, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) T12 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11) T12 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)(t11)
 	}
@@ -940,20 +862,7 @@ func Unsliced12[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe13 takes an initial value t0 and successively applies 13 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe13[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13) T13 {
-	t1 := f1(t0)
-	t2 := f2(t1)
-	t3 := f3(t2)
-	t4 := f4(t3)
-	t5 := f5(t4)
-	t6 := f6(t5)
-	t7 := f7(t6)
-	t8 := f8(t7)
-	t9 := f9(t8)
-	t10 := f10(t9)
-	t11 := f11(t10)
-	t12 := f12(t11)
-	t13 := f13(t12)
-	return t13
+	return f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0)))))))))))))
 }
 
 // Flow13 creates a function that takes an initial value t0 and successively applies 13 functions where the input of a function is the return value of the previous function
@@ -973,7 +882,7 @@ func Nullary13[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry13 takes a function with 13 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry13]
-func Curry13[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) T13) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T13 {
+func Curry13[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) T13, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T13 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) T13 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) T13 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) T13 {
@@ -1005,7 +914,7 @@ func Curry13[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](f f
 
 // Uncurry13 takes a cascade of 13 functions each taking only one parameter and returns a function with 13 parameters .
 // The inverse function is [Curry13]
-func Uncurry13[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T13) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) T13 {
+func Uncurry13[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T13, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) T13 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12) T13 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)(t11)(t12)
 	}
@@ -1035,21 +944,7 @@ func Unsliced13[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe14 takes an initial value t0 and successively applies 14 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe14[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14) T14 {
-	t1 := f1(t0)
-	t2 := f2(t1)
-	t3 := f3(t2)
-	t4 := f4(t3)
-	t5 := f5(t4)
-	t6 := f6(t5)
-	t7 := f7(t6)
-	t8 := f8(t7)
-	t9 := f9(t8)
-	t10 := f10(t9)
-	t11 := f11(t10)
-	t12 := f12(t11)
-	t13 := f13(t12)
-	t14 := f14(t13)
-	return t14
+	return f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))))))))
 }
 
 // Flow14 creates a function that takes an initial value t0 and successively applies 14 functions where the input of a function is the return value of the previous function
@@ -1069,7 +964,7 @@ func Nullary14[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry14 takes a function with 14 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry14]
-func Curry14[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) T14) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T14 {
+func Curry14[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) T14, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T14 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) T14 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) T14 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) T14 {
@@ -1103,7 +998,7 @@ func Curry14[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any
 
 // Uncurry14 takes a cascade of 14 functions each taking only one parameter and returns a function with 14 parameters .
 // The inverse function is [Curry14]
-func Uncurry14[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T14) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) T14 {
+func Uncurry14[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T14, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) T14 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13) T14 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)(t11)(t12)(t13)
 	}
@@ -1133,22 +1028,7 @@ func Unsliced14[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe15 takes an initial value t0 and successively applies 15 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe15[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15) T15 {
-	t1 := f1(t0)
-	t2 := f2(t1)
-	t3 := f3(t2)
-	t4 := f4(t3)
-	t5 := f5(t4)
-	t6 := f6(t5)
-	t7 := f7(t6)
-	t8 := f8(t7)
-	t9 := f9(t8)
-	t10 := f10(t9)
-	t11 := f11(t10)
-	t12 := f12(t11)
-	t13 := f13(t12)
-	t14 := f14(t13)
-	t15 := f15(t14)
-	return t15
+	return f15(f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0)))))))))))))))
 }
 
 // Flow15 creates a function that takes an initial value t0 and successively applies 15 functions where the input of a function is the return value of the previous function
@@ -1168,7 +1048,7 @@ func Nullary15[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry15 takes a function with 15 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry15]
-func Curry15[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) T15) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T15 {
+func Curry15[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) T15, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T15 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) T15 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) T15 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) T15 {
@@ -1204,7 +1084,7 @@ func Curry15[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T1
 
 // Uncurry15 takes a cascade of 15 functions each taking only one parameter and returns a function with 15 parameters .
 // The inverse function is [Curry15]
-func Uncurry15[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T15) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) T15 {
+func Uncurry15[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T15, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) T15 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14) T15 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)(t11)(t12)(t13)(t14)
 	}
@@ -1234,23 +1114,7 @@ func Unsliced15[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe16 takes an initial value t0 and successively applies 16 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe16[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16) T16 {
-	t1 := f1(t0)
-	t2 := f2(t1)
-	t3 := f3(t2)
-	t4 := f4(t3)
-	t5 := f5(t4)
-	t6 := f6(t5)
-	t7 := f7(t6)
-	t8 := f8(t7)
-	t9 := f9(t8)
-	t10 := f10(t9)
-	t11 := f11(t10)
-	t12 := f12(t11)
-	t13 := f13(t12)
-	t14 := f14(t13)
-	t15 := f15(t14)
-	t16 := f16(t15)
-	return t16
+	return f16(f15(f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))))))))))
 }
 
 // Flow16 creates a function that takes an initial value t0 and successively applies 16 functions where the input of a function is the return value of the previous function
@@ -1270,7 +1134,7 @@ func Nullary16[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry16 takes a function with 16 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry16]
-func Curry16[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) T16) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T16 {
+func Curry16[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) T16, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T16 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) T16 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) T16 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) T16 {
@@ -1308,7 +1172,7 @@ func Curry16[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T1
 
 // Uncurry16 takes a cascade of 16 functions each taking only one parameter and returns a function with 16 parameters .
 // The inverse function is [Curry16]
-func Uncurry16[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T16) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) T16 {
+func Uncurry16[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T16, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) T16 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, t15 T15) T16 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)(t11)(t12)(t13)(t14)(t15)
 	}
@@ -1338,24 +1202,7 @@ func Unsliced16[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe17 takes an initial value t0 and successively applies 17 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe17[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17) T17 {
-	t1 := f1(t0)
-	t2 := f2(t1)
-	t3 := f3(t2)
-	t4 := f4(t3)
-	t5 := f5(t4)
-	t6 := f6(t5)
-	t7 := f7(t6)
-	t8 := f8(t7)
-	t9 := f9(t8)
-	t10 := f10(t9)
-	t11 := f11(t10)
-	t12 := f12(t11)
-	t13 := f13(t12)
-	t14 := f14(t13)
-	t15 := f15(t14)
-	t16 := f16(t15)
-	t17 := f17(t16)
-	return t17
+	return f17(f16(f15(f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0)))))))))))))))))
 }
 
 // Flow17 creates a function that takes an initial value t0 and successively applies 17 functions where the input of a function is the return value of the previous function
@@ -1375,7 +1222,7 @@ func Nullary17[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry17 takes a function with 17 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry17]
-func Curry17[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) T17) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) func(T16) T17 {
+func Curry17[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) T17, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) func(T16) T17 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) T17 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) T17 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) T17 {
@@ -1415,7 +1262,7 @@ func Curry17[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T1
 
 // Uncurry17 takes a cascade of 17 functions each taking only one parameter and returns a function with 17 parameters .
 // The inverse function is [Curry17]
-func Uncurry17[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) func(T16) T17) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) T17 {
+func Uncurry17[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) func(T16) T17, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) T17 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, t15 T15, t16 T16) T17 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)(t11)(t12)(t13)(t14)(t15)(t16)
 	}
@@ -1445,25 +1292,7 @@ func Unsliced17[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe18 takes an initial value t0 and successively applies 18 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe18[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18) T18 {
-	t1 := f1(t0)
-	t2 := f2(t1)
-	t3 := f3(t2)
-	t4 := f4(t3)
-	t5 := f5(t4)
-	t6 := f6(t5)
-	t7 := f7(t6)
-	t8 := f8(t7)
-	t9 := f9(t8)
-	t10 := f10(t9)
-	t11 := f11(t10)
-	t12 := f12(t11)
-	t13 := f13(t12)
-	t14 := f14(t13)
-	t15 := f15(t14)
-	t16 := f16(t15)
-	t17 := f17(t16)
-	t18 := f18(t17)
-	return t18
+	return f18(f17(f16(f15(f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))))))))))))
 }
 
 // Flow18 creates a function that takes an initial value t0 and successively applies 18 functions where the input of a function is the return value of the previous function
@@ -1483,7 +1312,7 @@ func Nullary18[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry18 takes a function with 18 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry18]
-func Curry18[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) T18) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) func(T16) func(T17) T18 {
+func Curry18[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) T18, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) func(T16) func(T17) T18 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) func(t17 T17) T18 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) func(t17 T17) T18 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) func(t17 T17) T18 {
@@ -1525,7 +1354,7 @@ func Curry18[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T1
 
 // Uncurry18 takes a cascade of 18 functions each taking only one parameter and returns a function with 18 parameters .
 // The inverse function is [Curry18]
-func Uncurry18[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) func(T16) func(T17) T18) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) T18 {
+func Uncurry18[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) func(T16) func(T17) T18, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) T18 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, t15 T15, t16 T16, t17 T17) T18 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)(t11)(t12)(t13)(t14)(t15)(t16)(t17)
 	}
@@ -1555,26 +1384,7 @@ func Unsliced18[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe19 takes an initial value t0 and successively applies 19 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe19[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, F19 ~func(T18) T19, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18, f19 F19) T19 {
-	t1 := f1(t0)
-	t2 := f2(t1)
-	t3 := f3(t2)
-	t4 := f4(t3)
-	t5 := f5(t4)
-	t6 := f6(t5)
-	t7 := f7(t6)
-	t8 := f8(t7)
-	t9 := f9(t8)
-	t10 := f10(t9)
-	t11 := f11(t10)
-	t12 := f12(t11)
-	t13 := f13(t12)
-	t14 := f14(t13)
-	t15 := f15(t14)
-	t16 := f16(t15)
-	t17 := f17(t16)
-	t18 := f18(t17)
-	t19 := f19(t18)
-	return t19
+	return f19(f18(f17(f16(f15(f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0)))))))))))))))))))
 }
 
 // Flow19 creates a function that takes an initial value t0 and successively applies 19 functions where the input of a function is the return value of the previous function
@@ -1594,7 +1404,7 @@ func Nullary19[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry19 takes a function with 19 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry19]
-func Curry19[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) T19) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) func(T16) func(T17) func(T18) T19 {
+func Curry19[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) T19, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) func(T16) func(T17) func(T18) T19 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) func(t17 T17) func(t18 T18) T19 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) func(t17 T17) func(t18 T18) T19 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) func(t17 T17) func(t18 T18) T19 {
@@ -1638,7 +1448,7 @@ func Curry19[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T1
 
 // Uncurry19 takes a cascade of 19 functions each taking only one parameter and returns a function with 19 parameters .
 // The inverse function is [Curry19]
-func Uncurry19[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) func(T16) func(T17) func(T18) T19) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) T19 {
+func Uncurry19[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) func(T16) func(T17) func(T18) T19, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) T19 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, t15 T15, t16 T16, t17 T17, t18 T18) T19 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)(t11)(t12)(t13)(t14)(t15)(t16)(t17)(t18)
 	}
@@ -1668,27 +1478,7 @@ func Unsliced19[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe20 takes an initial value t0 and successively applies 20 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe20[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, F19 ~func(T18) T19, F20 ~func(T19) T20, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18, f19 F19, f20 F20) T20 {
-	t1 := f1(t0)
-	t2 := f2(t1)
-	t3 := f3(t2)
-	t4 := f4(t3)
-	t5 := f5(t4)
-	t6 := f6(t5)
-	t7 := f7(t6)
-	t8 := f8(t7)
-	t9 := f9(t8)
-	t10 := f10(t9)
-	t11 := f11(t10)
-	t12 := f12(t11)
-	t13 := f13(t12)
-	t14 := f14(t13)
-	t15 := f15(t14)
-	t16 := f16(t15)
-	t17 := f17(t16)
-	t18 := f18(t17)
-	t19 := f19(t18)
-	t20 := f20(t19)
-	return t20
+	return f20(f19(f18(f17(f16(f15(f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))))))))))))))
 }
 
 // Flow20 creates a function that takes an initial value t0 and successively applies 20 functions where the input of a function is the return value of the previous function
@@ -1708,7 +1498,7 @@ func Nullary20[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry20 takes a function with 20 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry20]
-func Curry20[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) T20) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) func(T16) func(T17) func(T18) func(T19) T20 {
+func Curry20[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) T20, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) func(T16) func(T17) func(T18) func(T19) T20 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) func(t17 T17) func(t18 T18) func(t19 T19) T20 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) func(t17 T17) func(t18 T18) func(t19 T19) T20 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) func(t17 T17) func(t18 T18) func(t19 T19) T20 {
@@ -1754,7 +1544,7 @@ func Curry20[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T1
 
 // Uncurry20 takes a cascade of 20 functions each taking only one parameter and returns a function with 20 parameters .
 // The inverse function is [Curry20]
-func Uncurry20[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) func(T16) func(T17) func(T18) func(T19) T20) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) T20 {
+func Uncurry20[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) func(T16) func(T17) func(T18) func(T19) T20, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) T20 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, t15 T15, t16 T16, t17 T17, t18 T18, t19 T19) T20 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)(t11)(t12)(t13)(t14)(t15)(t16)(t17)(t18)(t19)
 	}

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

go.mod

@@ -4,7 +4,7 @@ go 1.20
 
 require (
 	github.com/stretchr/testify v1.8.4
-	github.com/urfave/cli/v2 v2.26.0
+	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,12 +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/urfave/cli/v2 v2.26.0 h1:3f3AMg3HpThFNT4I++TKOejZO8yU55t3JnnSr4S4QEI=
-github.com/urfave/cli/v2 v2.26.0/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,344 @@
+// 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
+	//
+	// Deprecated: use [URL] instead
+	Url = L.MakeLensRef((*Builder).GetURL, (*Builder).SetURL)
+	// 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 the URL
+	//
+	// Deprecated: use [WithURL] instead
+	WithUrl = URL.Set
+	// WithURL creates a [Endomorphism] for the URL
+	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
+//
+// Deprecated: use [GetTargetURL] instead
+func (builder *Builder) GetTargetUrl() E.Either[error, string] {
+	return builder.GetTargetURL()
+}
+
+// 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),
+		)),
+	)
+}
+
+// Deprecated: use [GetURL] instead
+func (builder *Builder) GetUrl() string {
+	return builder.url
+}
+
+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
+}
+
+// Deprecated: use [SetURL] instead
+func (builder *Builder) SetUrl(url string) *Builder {
+	builder.url = url
+	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
+//
+// Deprecated: use [WithJSON] instead
+func WithJson[T any](data T) Endomorphism {
+	return WithJSON[T](data)
+}
+
+// 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,23 @@
+// 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"
+	Json        = JSON // Deprecated: use [JSON] instead
+	FormEncoded = "application/x-www-form-urlencoded"
+)

http/form/form.go

@@ -25,6 +25,7 @@ import (
 	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 (
@@ -38,9 +39,12 @@ var (
 
 	noField = O.None[string]()
 
-	// FormMonoid is the [M.Monoid] for the [Endomorphism]
+	// 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]
 
@@ -58,10 +62,9 @@ var (
 
 // WithValue creates a [FormBuilder] for a certain field
 func WithValue(name string) func(value string) Endomorphism {
-	return F.Flow3(
+	return F.Flow2(
 		O.Of[string],
 		AtValue(name).Set,
-		ENDO.Of[func(url.Values) url.Values],
 	)
 }
 

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,33 +34,44 @@ import (
 
 type (
 	ParsedMediaType = T.Tuple2[string, map[string]string]
+
+	HttpError struct {
+		statusCode int
+		headers    H.Header
+		body       []byte
+		url        *url.URL
+	}
 )
 
 var (
 	// mime type to check if a media type matches
-	reJsonMimeType = regexp.MustCompile(`application/(?:\w+\+)?json`)
+	reJSONMimeType = regexp.MustCompile(`application/(?:\w+\+)?json`)
 	// ValidateResponse validates an HTTP response and returns an [E.Either] if the response is not a success
 	ValidateResponse = E.FromPredicate(isValidStatus, StatusCodeError)
 	// alidateJsonContentTypeString parses a content type a validates that it is valid JSON
-	validateJsonContentTypeString = F.Flow2(
+	validateJSONContentTypeString = F.Flow2(
 		ParseMediaType,
 		E.ChainFirst(F.Flow2(
 			T.First[string, map[string]string],
-			E.FromPredicate(reJsonMimeType.MatchString, func(mimeType string) error {
+			E.FromPredicate(reJSONMimeType.MatchString, func(mimeType string) error {
 				return fmt.Errorf("mimetype [%s] is not a valid JSON content type", mimeType)
 			}),
 		)),
 	)
-	// ValidateJsonResponse checks if an HTTP response is a valid JSON response
-	ValidateJsonResponse = F.Flow2(
+	// ValidateJSONResponse checks if an HTTP response is a valid JSON response
+	ValidateJSONResponse = F.Flow2(
 		E.Of[error, *H.Response],
 		E.ChainFirst(F.Flow5(
 			GetHeader,
 			R.Lookup[H.Header](HeaderContentType),
 			O.Chain(A.First[string]),
 			E.FromOption[string](errors.OnNone("unable to access the [%s] header", HeaderContentType)),
-			E.ChainFirst(validateJsonContentTypeString),
+			E.ChainFirst(validateJSONContentTypeString),
 		)))
+	// ValidateJsonResponse checks if an HTTP response is a valid JSON response
+	//
+	// Deprecated: use [ValidateJSONResponse] instead
+	ValidateJsonResponse = ValidateJSONResponse
 )
 
 const (
@@ -72,6 +84,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 +121,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),
 	)
 
@@ -48,7 +49,7 @@ func TestValidateJsonContentTypeString(t *testing.T) {
 func TestValidateInvalidJsonContentTypeString(t *testing.T) {
 
 	res := F.Pipe1(
-		validateJsonContentTypeString("application/xml"),
+		validateJSONContentTypeString("application/xml"),
 		Error[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

@@ -50,7 +50,11 @@ func MonadChainFirst[GAB ~func(A) B, A, B any](fa A, f GAB) A {
 }
 
 func ChainFirst[GAB ~func(A) B, A, B any](f GAB) func(A) A {
-	return C.ChainFirst(MonadChain[func(A) A, A, A], MonadMap[func(B) A, B, A], f)
+	return C.ChainFirst(
+		Chain[func(A) A, A, A],
+		Map[func(B) A, B, A],
+		f,
+	)
 }
 
 func MonadFlap[GAB ~func(A) B, A, B any](fab GAB, a A) B {
@@ -58,5 +62,5 @@ func MonadFlap[GAB ~func(A) B, A, B any](fab GAB, a A) B {
 }
 
 func Flap[GAB ~func(A) B, B, A any](a A) func(GAB) B {
-	return F.Bind2nd(MonadFlap[GAB, A, B], a)
+	return FC.Flap(Map[func(GAB) B, GAB, B], a)
 }

identity/monad.go

@@ -0,0 +1,43 @@
+// Copyright (c) 2024 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 (
+	"github.com/IBM/fp-go/internal/monad"
+)
+
+type identityMonad[A, B any] struct{}
+
+func (o *identityMonad[A, B]) Of(a A) A {
+	return Of[A](a)
+}
+
+func (o *identityMonad[A, B]) Map(f func(A) B) func(A) B {
+	return Map[A, B](f)
+}
+
+func (o *identityMonad[A, B]) Chain(f func(A) B) func(A) B {
+	return Chain[A, B](f)
+}
+
+func (o *identityMonad[A, B]) Ap(fa A) func(func(A) B) B {
+	return Ap[B, A](fa)
+}
+
+// Monad implements the monadic operations for [Option]
+func Monad[A, B any]() monad.Monad[A, B, A, B, func(A) B] {
+	return &identityMonad[A, B]{}
+}

internal/applicative/testing/law.go

@@ -34,6 +34,9 @@ func AssertIdentity[HKTA, HKTAA, A any](t *testing.T,
 
 	fap func(HKTAA, HKTA) HKTA,
 ) func(fa HKTA) bool {
+	// mark as test helper
+	t.Helper()
+
 	return func(fa HKTA) bool {
 
 		left := fap(fof(F.Identity[A]), fa)
@@ -57,6 +60,9 @@ func AssertHomomorphism[HKTA, HKTB, HKTAB, A, B any](t *testing.T,
 
 	ab func(A) B,
 ) func(a A) bool {
+	// mark as test helper
+	t.Helper()
+
 	return func(a A) bool {
 
 		left := fap(fofab(ab), fofa(a))
@@ -73,7 +79,6 @@ func AssertInterchange[HKTA, HKTB, HKTAB, HKTABB, A, B any](t *testing.T,
 	eq E.Eq[HKTB],
 
 	fofa func(A) HKTA,
-	fofb func(B) HKTB,
 	fofab func(func(A) B) HKTAB,
 	fofabb func(func(func(A) B) B) HKTABB,
 
@@ -82,6 +87,9 @@ func AssertInterchange[HKTA, HKTB, HKTAB, HKTABB, A, B any](t *testing.T,
 
 	ab func(A) B,
 ) func(a A) bool {
+	// mark as test helper
+	t.Helper()
+
 	return func(a A) bool {
 
 		fab := fofab(ab)
@@ -127,12 +135,15 @@ func AssertLaws[HKTA, HKTB, HKTC, HKTAA, HKTAB, HKTBC, HKTAC, HKTABB, HKTABAC, A
 	ab func(A) B,
 	bc func(B) C,
 ) func(a A) bool {
+	// mark as test helper
+	t.Helper()
+
 	// apply laws
 	apply := L.AssertLaws(t, eqa, eqc, fofab, fofbc, faa, fab, fac, fbc, fmap, fapab, fapbc, fapac, fapabac, ab, bc)
 	// applicative laws
 	identity := AssertIdentity(t, eqa, fofaa, fapaa)
 	homomorphism := AssertHomomorphism(t, eqb, fofa, fofb, fofab, fapab, ab)
-	interchange := AssertInterchange(t, eqb, fofa, fofb, fofab, fofabb, fapab, fapabb, ab)
+	interchange := AssertInterchange(t, eqb, fofa, fofab, fofabb, fapab, fapabb, ab)
 
 	return func(a A) bool {
 		fa := fofa(a)

internal/applicative/types.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 applicative
+
+import (
+	"github.com/IBM/fp-go/internal/apply"
+	"github.com/IBM/fp-go/internal/pointed"
+)
+
+type Applicative[A, B, HKTA, HKTB, HKTFAB any] interface {
+	apply.Apply[A, B, HKTA, HKTB, HKTFAB]
+	pointed.Pointed[A, HKTA]
+}

internal/apply/ap.go

@@ -19,13 +19,6 @@ import (
 	F "github.com/IBM/fp-go/function"
 )
 
-// HKTFGA  = HKT<F, HKT<G, A>>
-// HKTFGB  = HKT<F, HKT<G, B>>
-// HKTFGAB = HKT<F, HKT<G, (a: A) => B>>
-
-// HKTGA   = HKT<G, A>
-// HKTGB   = HKT<G, B>
-// HKTGAB  = HKT<G, (a: A) => B>
 func MonadAp[HKTGA, HKTGB, HKTGAB, HKTFGAB, HKTFGGAB, HKTFGA, HKTFGB any](
 	fap func(HKTFGGAB, HKTFGA) HKTFGB,
 	fmap func(HKTFGAB, func(HKTGAB) func(HKTGA) HKTGB) HKTFGGAB,
@@ -37,6 +30,29 @@ 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 F.Flow2(
+		fmap(F.Flip(gap)),
+		fap(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 +123,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/apply/testing/laws.go

@@ -43,6 +43,7 @@ func AssertAssociativeComposition[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC
 	ab func(A) B,
 	bc func(B) C,
 ) func(fa HKTA) bool {
+	t.Helper()
 	return func(fa HKTA) bool {
 
 		fab := fofab(ab)
@@ -86,6 +87,8 @@ func AssertLaws[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *
 	ab func(A) B,
 	bc func(B) C,
 ) func(fa HKTA) bool {
+	// mark as test helper
+	t.Helper()
 	// functor laws
 	functor := FCT.AssertLaws(t, eqa, eqc, faa, fab, fac, fbc, ab, bc)
 	// associative composition laws

internal/apply/types.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 apply
+
+import (
+	"github.com/IBM/fp-go/internal/functor"
+)
+
+type Apply[A, B, HKTA, HKTB, HKTFAB any] interface {
+	functor.Functor[A, B, HKTA, HKTB]
+	Ap(HKTA) func(HKTFAB) HKTB
+}

internal/array/array.go

@@ -106,6 +106,12 @@ func MonadMap[GA ~[]A, GB ~[]B, A, B any](as GA, f func(a A) B) GB {
 	return bs
 }
 
+func Map[GA ~[]A, GB ~[]B, A, B any](f func(a A) B) func(GA) GB {
+	return func(as GA) GB {
+		return MonadMap[GA, GB](as, f)
+	}
+}
+
 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)

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

@@ -43,19 +43,68 @@ func MonadChain[A, B, HKTA, HKTB any](
 // HKTA=HKT[A]
 // HKTB=HKT[B]
 func ChainFirst[A, B, HKTA, HKTB any](
-	mchain func(HKTA, func(A) HKTA) HKTA,
-	mmap func(HKTB, func(B) A) HKTA,
+	mchain func(func(A) HKTA) func(HKTA) HKTA,
+	mmap func(func(B) A) func(HKTB) HKTA,
 	f func(A) HKTB) func(HKTA) HKTA {
-	return F.Bind2nd(mchain, func(a A) HKTA {
-		return mmap(f(a), F.Constant1[B](a))
+	return mchain(func(a A) HKTA {
+		return mmap(F.Constant1[B](a))(f(a))
 	})
 }
 
 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/chain/testing/laws.go

@@ -30,7 +30,6 @@ import (
 func AssertAssociativity[HKTA, HKTB, HKTC, A, B, C any](t *testing.T,
 	eq E.Eq[HKTC],
 
-	fofa func(A) HKTA,
 	fofb func(B) HKTB,
 	fofc func(C) HKTC,
 
@@ -61,7 +60,6 @@ func AssertLaws[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *
 	eqa E.Eq[HKTA],
 	eqc E.Eq[HKTC],
 
-	fofa func(A) HKTA,
 	fofb func(B) HKTB,
 	fofc func(C) HKTC,
 
@@ -91,7 +89,7 @@ func AssertLaws[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *
 	// apply laws
 	apply := L.AssertLaws(t, eqa, eqc, fofab, fofbc, faa, fab, fac, fbc, fmap, fapab, fapbc, fapac, fapabac, ab, bc)
 	// chain laws
-	associativity := AssertAssociativity(t, eqc, fofa, fofb, fofc, chainab, chainac, chainbc, ab, bc)
+	associativity := AssertAssociativity(t, eqc, fofb, fofc, chainab, chainac, chainbc, ab, bc)
 
 	return func(fa HKTA) bool {
 		return apply(fa) && associativity(fa)

internal/chain/types.go

@@ -0,0 +1,25 @@
+// Copyright (c) 2024 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 chain
+
+import (
+	"github.com/IBM/fp-go/internal/apply"
+)
+
+type Chainable[A, B, HKTA, HKTB, HKTFAB any] interface {
+	apply.Apply[A, B, HKTA, HKTB, HKTFAB]
+	Chain(func(A) HKTB) func(HKTA) HKTB
+}

internal/eithert/either.go

@@ -51,6 +51,14 @@ func MonadMap[E, A, B, HKTFA, HKTFB any](fmap func(HKTFA, func(ET.Either[E, A])
 	return FC.MonadMap(fmap, ET.MonadMap[E, A, B], fa, f)
 }
 
+func Map[E, A, B, HKTFA, HKTFB any](
+	fmap func(func(ET.Either[E, A]) ET.Either[E, B]) func(HKTFA) HKTFB,
+	f func(A) B) func(HKTFA) HKTFB {
+	// HKTGA = Either[E, A]
+	// HKTGB = Either[E, B]
+	return FC.Map(fmap, ET.Map[E, A, B], f)
+}
+
 // HKTFA = HKT<F, Either<E, A>>
 // HKTFB = HKT<F, Either<E, B>>
 func MonadBiMap[E1, E2, A, B, HKTFA, HKTFB any](fmap func(HKTFA, func(ET.Either[E1, A]) ET.Either[E2, B]) HKTFB, fa HKTFA, f func(E1) E2, g func(A) B) HKTFB {
@@ -61,10 +69,12 @@ func MonadBiMap[E1, E2, A, B, HKTFA, HKTFB any](fmap func(HKTFA, func(ET.Either[
 
 // HKTFA = HKT<F, Either<E, A>>
 // HKTFB = HKT<F, Either<E, B>>
-func BiMap[E1, E2, A, B, HKTFA, HKTFB any](fmap func(HKTFA, func(ET.Either[E1, A]) ET.Either[E2, B]) HKTFB, f func(E1) E2, g func(A) B) func(HKTFA) HKTFB {
+func BiMap[E1, E2, A, B, HKTFA, HKTFB any](
+	fmap func(func(ET.Either[E1, A]) ET.Either[E2, B]) func(HKTFA) HKTFB,
+	f func(E1) E2, g func(A) B) func(HKTFA) HKTFB {
 	// HKTGA = Either[E, A]
 	// HKTGB = Either[E, B]
-	return F.Bind2nd(fmap, ET.BiMap(f, g))
+	return fmap(ET.BiMap(f, g))
 }
 
 // HKTFA = HKT<F, Either<E, A>>
@@ -78,22 +88,29 @@ func MonadChain[E, A, B, HKTFA, HKTFB any](
 	return fchain(ma, ET.Fold(F.Flow2(ET.Left[B, E], fof), f))
 }
 
-// func(fa func(R) T.Task[ET.Either[E, func(A) B]], f func(ET.Either[E, func(A) B]) func(ET.Either[E, A]) ET.Either[E, B]) GEFAB
+func Chain[E, A, B, HKTFA, HKTFB any](
+	fchain func(func(ET.Either[E, A]) HKTFB) func(HKTFA) HKTFB,
+	fof func(ET.Either[E, B]) HKTFB,
+	f func(A) HKTFB) func(HKTFA) HKTFB {
+	// dispatch to the even more generic implementation
+	return fchain(ET.Fold(F.Flow2(ET.Left[B, E], fof), f))
+}
 
-// HKTFA   = HKT[Either[E, A]]
-// HKTFB   = HKT[Either[E, B]]
-// HKTFAB  = HKT[Either[E, func(A)B]]
 func MonadAp[E, A, B, HKTFAB, HKTFGAB, HKTFA, HKTFB any](
 	fap func(HKTFGAB, HKTFA) HKTFB,
 	fmap func(HKTFAB, func(ET.Either[E, func(A) B]) func(ET.Either[E, A]) ET.Either[E, B]) HKTFGAB,
 	fab HKTFAB,
 	fa HKTFA) HKTFB {
-	// HKTGA  = ET.Either[E, A]
-	// HKTGB  = ET.Either[E, B]
-	// HKTGAB = ET.Either[E, func(a A) B]
 	return apply.MonadAp(fap, fmap, ET.MonadAp[B, E, A], fab, fa)
 }
 
+func Ap[E, A, B, HKTFAB, HKTFGAB, HKTFA, HKTFB any](
+	fap func(HKTFA) func(HKTFGAB) HKTFB,
+	fmap func(func(ET.Either[E, func(A) B]) func(ET.Either[E, A]) ET.Either[E, B]) func(HKTFAB) HKTFGAB,
+	fa HKTFA) func(HKTFAB) HKTFB {
+	return apply.Ap(fap, fmap, ET.Ap[B, E, A], fa)
+}
+
 func Right[E, A, HKTA any](fof func(ET.Either[E, A]) HKTA, a A) HKTA {
 	return F.Pipe2(a, ET.Right[E, A], fof)
 }
@@ -142,3 +159,7 @@ func OrLeft[E1, E2, A, HKTE1A, HKTE2, HKTE2A any](
 func MonadMapLeft[E, A, B, HKTFA, HKTFB any](fmap func(HKTFA, func(ET.Either[E, A]) ET.Either[B, A]) HKTFB, fa HKTFA, f func(E) B) HKTFB {
 	return FC.MonadMap(fmap, ET.MonadMapLeft[E, A, B], fa, f)
 }
+
+func MapLeft[E, A, B, HKTFA, HKTFB any](fmap func(func(ET.Either[E, A]) ET.Either[B, A]) func(HKTFA) HKTFB, f func(E) B) func(HKTFA) HKTFB {
+	return FC.Map(fmap, ET.MapLeft[A, E, B], f)
+}

internal/foldable/types.go

@@ -0,0 +1,26 @@
+// Copyright (c) 2024 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 foldable
+
+import (
+	M "github.com/IBM/fp-go/monoid"
+)
+
+type Foldable[A, B, HKTA any] interface {
+	Reduce(func(B, A) B, B) func(HKTA) B
+	ReduceRight(func(B, A) B, B) func(HKTA) B
+	FoldMap(m M.Monoid[B]) func(func(A) B) func(HKTA) B
+}

internal/fromeither/either.go

@@ -60,6 +60,13 @@ func MonadChainEitherK[A, E, B, HKTEA, HKTEB any](
 	return mchain(ma, F.Flow2(f, fromEither))
 }
 
+func ChainEitherK[A, E, B, HKTEA, HKTEB any](
+	mchain func(func(A) HKTEB) func(HKTEA) HKTEB,
+	fromEither func(ET.Either[E, B]) HKTEB,
+	f func(A) ET.Either[E, B]) func(HKTEA) HKTEB {
+	return mchain(F.Flow2(f, fromEither))
+}
+
 func ChainOptionK[A, E, B, HKTEA, HKTEB any](
 	mchain func(HKTEA, func(A) HKTEB) HKTEB,
 	fromEither func(ET.Either[E, B]) HKTEB,
@@ -78,8 +85,8 @@ func MonadChainFirstEitherK[A, E, B, HKTEA, HKTEB any](
 }
 
 func ChainFirstEitherK[A, E, B, HKTEA, HKTEB any](
-	mchain func(HKTEA, func(A) HKTEA) HKTEA,
-	mmap func(HKTEB, func(B) A) HKTEA,
+	mchain func(func(A) HKTEA) func(HKTEA) HKTEA,
+	mmap func(func(B) A) func(HKTEB) HKTEA,
 	fromEither func(ET.Either[E, B]) HKTEB,
 	f func(A) ET.Either[E, B]) func(HKTEA) HKTEA {
 	return C.ChainFirst(mchain, mmap, F.Flow2(f, fromEither))

internal/fromeither/types.go

@@ -0,0 +1,24 @@
+// Copyright (c) 2024 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 fromeither
+
+import (
+	ET "github.com/IBM/fp-go/either"
+)
+
+type FromEither[E, A, HKTA any] interface {
+	FromEither(ET.Either[E, A]) HKTA
+}

internal/fromio/io.go

@@ -30,8 +30,8 @@ func MonadChainFirstIOK[A, B, HKTA, HKTB any, GIOB ~func() B](
 }
 
 func ChainFirstIOK[A, B, HKTA, HKTB any, GIOB ~func() B](
-	mchain func(HKTA, func(A) HKTA) HKTA,
-	mmap func(HKTB, func(B) A) HKTA,
+	mchain func(func(A) HKTA) func(HKTA) HKTA,
+	mmap func(func(B) A) func(HKTB) HKTA,
 	fromio func(GIOB) HKTB,
 	f func(A) GIOB) func(HKTA) HKTA {
 	// chain
@@ -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/fromio/types.go

@@ -0,0 +1,20 @@
+// Copyright (c) 2024 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 fromio
+
+type FromIO[A, GA ~func() A, HKTA any] interface {
+	FromIO(GA) HKTA
+}

internal/fromioeither/ioeither.go

@@ -31,8 +31,8 @@ func MonadChainFirstIOEitherK[GIOB ~func() ET.Either[E, B], E, A, B, HKTA, HKTB
 }
 
 func ChainFirstIOEitherK[GIOB ~func() ET.Either[E, B], E, A, B, HKTA, HKTB any](
-	mchain func(HKTA, func(A) HKTA) HKTA,
-	mmap func(HKTB, func(B) A) HKTA,
+	mchain func(func(A) HKTA) func(HKTA) HKTA,
+	mmap func(func(B) A) func(HKTB) HKTA,
 	fromio func(GIOB) HKTB,
 	f func(A) GIOB) func(HKTA) HKTA {
 	// chain
@@ -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/flap.go

@@ -15,23 +15,24 @@
 
 package functor
 
+func flap[FAB ~func(A) B, A, B any](a A) func(FAB) B {
+	return func(f FAB) B {
+		return f(a)
+	}
+}
+
 func MonadFlap[FAB ~func(A) B, A, B, HKTFAB, HKTB any](
 	fmap func(HKTFAB, func(FAB) B) HKTB,
 
 	fab HKTFAB,
 	a A,
 ) HKTB {
-	return fmap(fab, func(f FAB) B {
-		return f(a)
-	})
+	return fmap(fab, flap[FAB, A, B](a))
 }
 
 func Flap[FAB ~func(A) B, A, B, HKTFAB, HKTB any](
-	fmap func(HKTFAB, func(FAB) B) HKTB,
-
+	fmap func(func(FAB) B) func(HKTFAB) HKTB,
 	a A,
 ) func(HKTFAB) HKTB {
-	return func(fab HKTFAB) HKTB {
-		return MonadFlap(fmap, fab, a)
-	}
+	return fmap(flap[FAB, A, B](a))
 }

internal/functor/functor.go

@@ -21,6 +21,46 @@ 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 fmap(gmap(f))
+}
+
+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 mmap(key(b))
+}

internal/functor/testing/laws.go

@@ -27,6 +27,7 @@ import (
 //
 // F.map(fa, a => a) <-> fa
 func AssertIdentity[HKTA, A any](t *testing.T, eq E.Eq[HKTA], fmap func(HKTA, func(A) A) HKTA) func(fa HKTA) bool {
+	t.Helper()
 	return func(fa HKTA) bool {
 		return assert.True(t, eq.Equals(fa, fmap(fa, F.Identity[A])), "Functor identity law")
 	}
@@ -46,6 +47,7 @@ func AssertComposition[HKTA, HKTB, HKTC, A, B, C any](
 	ab func(A) B,
 	bc func(B) C,
 ) func(fa HKTA) bool {
+	t.Helper()
 	return func(fa HKTA) bool {
 		return assert.True(t, eq.Equals(fac(fa, F.Flow2(ab, bc)), fbc(fab(fa, ab), bc)), "Functor composition law")
 	}
@@ -63,6 +65,7 @@ func AssertLaws[HKTA, HKTB, HKTC, A, B, C any](t *testing.T,
 	ab func(A) B,
 	bc func(B) C,
 ) func(fa HKTA) bool {
+	t.Helper()
 	identity := AssertIdentity(t, eqa, faa)
 	composition := AssertComposition(t, eqc, fab, fac, fbc, ab, bc)
 

internal/functor/types.go

@@ -0,0 +1,20 @@
+// 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 functor
+
+type Functor[A, B, HKTA, HKTB any] interface {
+	Map(func(A) B) func(HKTA) HKTB
+}

internal/monad/monad.go

@@ -0,0 +1,26 @@
+// Copyright (c) 2024 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 monad
+
+import (
+	"github.com/IBM/fp-go/internal/applicative"
+	"github.com/IBM/fp-go/internal/chain"
+)
+
+type Monad[A, B, HKTA, HKTB, HKTFAB any] interface {
+	applicative.Applicative[A, B, HKTA, HKTB, HKTFAB]
+	chain.Chainable[A, B, HKTA, HKTB, HKTFAB]
+}

internal/monad/testing/laws.go

@@ -110,7 +110,7 @@ func AssertLaws[HKTA, HKTB, HKTC, HKTAA, HKTAB, HKTBC, HKTAC, HKTABB, HKTABAC, A
 	// applicative laws
 	applicative := LA.AssertLaws(t, eqa, eqb, eqc, fofa, fofb, fofaa, fofab, fofbc, fofabb, faa, fab, fac, fbc, fmap, fapaa, fapab, fapbc, fapac, fapabb, fapabac, ab, bc)
 	// chain laws
-	chain := LC.AssertLaws(t, eqa, eqc, fofa, fofb, fofc, fofab, fofbc, faa, fab, fac, fbc, fmap, chainab, chainac, chainbc, fapab, fapbc, fapac, fapabac, ab, bc)
+	chain := LC.AssertLaws(t, eqa, eqc, fofb, fofc, fofab, fofbc, faa, fab, fac, fbc, fmap, chainab, chainac, chainbc, fapab, fapbc, fapac, fapabac, ab, bc)
 	// monad laws
 	leftIdentity := AssertLeftIdentity(t, eqb, fofa, fofb, chainab, ab)
 	rightIdentity := AssertRightIdentity(t, eqa, fofa, chainaa)

internal/optiont/option.go

@@ -40,6 +40,12 @@ func MonadMap[A, B, HKTFA, HKTFB any](fmap func(HKTFA, func(O.Option[A]) O.Optio
 	return FC.MonadMap(fmap, O.MonadMap[A, B], fa, f)
 }
 
+func Map[A, B, HKTFA, HKTFB any](fmap func(func(O.Option[A]) O.Option[B]) func(HKTFA) HKTFB, f func(A) B) func(HKTFA) HKTFB {
+	// HKTGA = Either[E, A]
+	// HKTGB = Either[E, B]
+	return FC.Map(fmap, O.Map[A, B], f)
+}
+
 func MonadChain[A, B, HKTFA, HKTFB any](
 	fchain func(HKTFA, func(O.Option[A]) HKTFB) HKTFB,
 	fof func(O.Option[B]) HKTFB,
@@ -50,13 +56,11 @@ func MonadChain[A, B, HKTFA, HKTFB any](
 }
 
 func Chain[A, B, HKTFA, HKTFB any](
-	fchain func(HKTFA, func(O.Option[A]) HKTFB) HKTFB,
+	fchain func(func(O.Option[A]) HKTFB) func(HKTFA) 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)
-	}
+	return fchain(O.Fold(F.Nullary2(O.None[B], fof), f))
 }
 
 func MonadAp[A, B, HKTFAB, HKTFGAB, HKTFA, HKTFB any](
@@ -64,12 +68,16 @@ func MonadAp[A, B, HKTFAB, HKTFGAB, HKTFA, HKTFB any](
 	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)
 }
 
+func Ap[A, B, HKTFAB, HKTFGAB, HKTFA, HKTFB any](
+	fap func(HKTFA) func(HKTFGAB) HKTFB,
+	fmap func(func(O.Option[func(A) B]) func(O.Option[A]) O.Option[B]) func(HKTFAB) HKTFGAB,
+	fa HKTFA) func(HKTFAB) HKTFB {
+	return apply.Ap(fap, fmap, O.Ap[B, A], fa)
+}
+
 func MatchE[A, HKTEA, HKTB any](mchain func(HKTEA, func(O.Option[A]) HKTB) HKTB, onNone func() HKTB, onSome func(A) HKTB) func(HKTEA) HKTB {
 	return F.Bind2nd(mchain, O.Fold(onNone, onSome))
 }
@@ -89,6 +97,14 @@ func MonadChainOptionK[A, B, HKTA, HKTB any](
 	return MonadChain(fchain, fof, ma, FromOptionK(fof, f))
 }
 
+func ChainOptionK[A, B, HKTA, HKTB any](
+	fchain func(func(O.Option[A]) HKTB) func(HKTA) HKTB,
+	fof func(O.Option[B]) HKTB,
+	f func(A) O.Option[B],
+) func(HKTA) HKTB {
+	return Chain(fchain, fof, 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,
@@ -101,11 +117,9 @@ func MonadAlt[LAZY ~func() HKTFA, A, HKTFA any](
 
 func Alt[LAZY ~func() HKTFA, A, HKTFA any](
 	fof func(O.Option[A]) HKTFA,
-	fchain func(HKTFA, func(O.Option[A]) HKTFA) HKTFA,
+	fchain func(func(O.Option[A]) HKTFA) func(HKTFA) HKTFA,
 
 	second LAZY) func(HKTFA) HKTFA {
 
-	return func(fa HKTFA) HKTFA {
-		return MonadAlt(fof, fchain, fa, second)
-	}
+	return fchain(O.Fold(second, F.Flow2(O.Of[A], fof)))
 }