fix: add ReaderIOEither sample

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

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

@@ -344,7 +344,7 @@ func MonadFlap[FAB ~func(A) B, GFAB ~[]FAB, GB ~[]B, A, B any](fab GFAB, a A) GB
 }
 
 func Flap[FAB ~func(A) B, GFAB ~[]FAB, GB ~[]B, A, B any](a A) func(GFAB) GB {
-	return F.Bind2nd(MonadFlap[FAB, GFAB, GB, A, B], a)
+	return FC.Flap(Map[GFAB, GB], a)
 }
 
 func Prepend[ENDO ~func(AS) AS, AS []A, A any](head A) ENDO {

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

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

context/readereither/bind.go

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

context/readereither/bind_test.go

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

context/readerioeither/bind.go

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

context/readerioeither/bind_test.go

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

context/readerioeither/generic/bind.go

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

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

@@ -64,19 +64,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] {
@@ -105,11 +106,11 @@ 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] {
@@ -250,7 +251,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/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]())
 }

eq/eq.go

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

function/binds.go

@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-12-18 09:38:59.1616876 +0100 CET m=+0.008641801
+// 2024-01-31 21:45:01.6437619 +0100 CET m=+0.032758901
 
 package function
 

function/gen.go

@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-12-18 09:38:51.4946446 +0100 CET m=+0.008838401
+// 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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

http/form/form.go

@@ -39,7 +39,7 @@ 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

http/utils.go

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

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

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

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/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/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/optiont/option.go

@@ -50,13 +50,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 +62,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 +91,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 +111,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)))
 }

internal/readert/reader.go

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

internal/utils/do.go

@@ -0,0 +1,59 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package utils
+
+import (
+	"fmt"
+
+	F "github.com/IBM/fp-go/function"
+)
+
+type (
+	Initial struct {
+	}
+
+	WithLastName struct {
+		Initial
+		LastName string
+	}
+
+	WithGivenName struct {
+		WithLastName
+		GivenName string
+	}
+)
+
+var (
+	Empty = Initial{}
+
+	SetLastName = F.Curry2(func(name string, s1 Initial) WithLastName {
+		return WithLastName{
+			Initial:  s1,
+			LastName: name,
+		}
+	})
+
+	SetGivenName = F.Curry2(func(name string, s1 WithLastName) WithGivenName {
+		return WithGivenName{
+			WithLastName: s1,
+			GivenName:    name,
+		}
+	})
+)
+
+func GetFullName(s WithGivenName) string {
+	return fmt.Sprintf("%s %s", s.GivenName, s.LastName)
+}

io/bind.go

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

io/bind_test.go

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

io/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 ~func() 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 ~func() S1, GS2 ~func() S2, GT ~func() 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 ~func() S1, GS2 ~func() 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 ~func() S1, GS2 ~func() 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 ~func() S1, GT ~func() 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 ~func() S1, GS2 ~func() S2, GT ~func() T, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa GT,
+) func(GS1) GS2 {
+	return A.ApS(
+		Ap[GS2, func() func(T) S2, GT, S2, T],
+		Map[GS1, func() func(T) S2, S1, func(T) S2],
+		setter,
+		fa,
+	)
+}

io/generic/io.go

@@ -22,6 +22,7 @@ import (
 	C "github.com/IBM/fp-go/internal/chain"
 	FC "github.com/IBM/fp-go/internal/functor"
 	L "github.com/IBM/fp-go/internal/lazy"
+	T "github.com/IBM/fp-go/tuple"
 )
 
 // type IO[A any] = func() A
@@ -52,7 +53,7 @@ func MonadOf[GA ~func() A, A any](a A) GA {
 
 func MonadMap[GA ~func() A, GB ~func() B, A, B any](fa GA, f func(A) B) GB {
 	return MakeIO[GB](func() B {
-		return F.Pipe1(fa(), f)
+		return f(fa())
 	})
 }
 
@@ -65,13 +66,13 @@ func MonadMapTo[GA ~func() A, GB ~func() B, A, B any](fa GA, b B) GB {
 }
 
 func MapTo[GA ~func() A, GB ~func() B, A, B any](b B) func(GA) GB {
-	return F.Bind2nd(MonadMapTo[GA, GB, A, B], b)
+	return Map[GA, GB](F.Constant1[A](b))
 }
 
 // MonadChain composes computations in sequence, using the return value of one computation to determine the next computation.
 func MonadChain[GA ~func() A, GB ~func() B, A, B any](fa GA, f func(A) GB) GB {
 	return MakeIO[GB](func() B {
-		return F.Pipe1(fa(), f)()
+		return f(fa())()
 	})
 }
 
@@ -87,7 +88,7 @@ func MonadChainTo[GA ~func() A, GB ~func() B, A, B any](fa GA, fb GB) GB {
 
 // ChainTo composes computations in sequence, ignoring the return value of the first computation
 func ChainTo[GA ~func() A, GB ~func() B, A, B any](fb GB) func(GA) GB {
-	return F.Bind2nd(MonadChainTo[GA, GB, A, B], fb)
+	return Chain[GA, GB](F.Constant1[A](fb))
 }
 
 // MonadChainFirst composes computations in sequence, using the return value of one computation to determine the next computation and
@@ -99,7 +100,11 @@ func MonadChainFirst[GA ~func() A, GB ~func() B, A, B any](fa GA, f func(A) GB)
 // ChainFirst composes computations in sequence, using the return value of one computation to determine the next computation and
 // keeping only the result of the first.
 func ChainFirst[GA ~func() A, GB ~func() B, A, B any](f func(A) GB) func(GA) GA {
-	return C.ChainFirst(MonadChain[GA, GA, A, A], MonadMap[GB, GA, B, A], f)
+	return C.ChainFirst(
+		Chain[GA, GA, A, A],
+		Map[GB, GA, B, A],
+		f,
+	)
 }
 
 func ApSeq[GB ~func() B, GAB ~func() func(A) B, GA ~func() A, B, A any](ma GA) func(GAB) GB {
@@ -173,5 +178,25 @@ func MonadFlap[FAB ~func(A) B, GFAB ~func() FAB, GB ~func() B, A, B any](fab GFA
 }
 
 func Flap[FAB ~func(A) B, GFAB ~func() FAB, GB ~func() 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, FAB, B], a)
+}
+
+// WithTime returns an operation that measures the start and end timestamp of the operation
+func WithTime[GTA ~func() T.Tuple3[A, time.Time, time.Time], GA ~func() A, A any](a GA) GTA {
+	return MakeIO[GTA](func() T.Tuple3[A, time.Time, time.Time] {
+		t0 := time.Now()
+		res := a()
+		t1 := time.Now()
+		return T.MakeTuple3(res, t0, t1)
+	})
+}
+
+// WithDuration returns an operation that measures the duration of the operation
+func WithDuration[GTA ~func() T.Tuple2[A, time.Duration], GA ~func() A, A any](a GA) GTA {
+	return MakeIO[GTA](func() T.Tuple2[A, time.Duration] {
+		t0 := time.Now()
+		res := a()
+		t1 := time.Now()
+		return T.MakeTuple2(res, t1.Sub(t0))
+	})
 }

io/io.go

@@ -19,6 +19,7 @@ import (
 	"time"
 
 	G "github.com/IBM/fp-go/io/generic"
+	T "github.com/IBM/fp-go/tuple"
 )
 
 // IO represents a synchronous computation that cannot fail
@@ -143,7 +144,7 @@ func MonadFlap[B, A any](fab IO[func(A) B], a A) IO[B] {
 	return G.MonadFlap[func(A) B, IO[func(A) B], IO[B], A, B](fab, a)
 }
 
-func Flap[FAB ~func(A) B, GFAB ~func() FAB, GB ~func() B, A, B any](a A) func(IO[func(A) B]) IO[B] {
+func Flap[B, A any](a A) func(IO[func(A) B]) IO[B] {
 	return G.Flap[func(A) B, IO[func(A) B], IO[B], A, B](a)
 }
 
@@ -156,3 +157,13 @@ func Delay[A any](delay time.Duration) func(IO[A]) IO[A] {
 func After[A any](timestamp time.Time) func(IO[A]) IO[A] {
 	return G.After[IO[A]](timestamp)
 }
+
+// WithTime returns an operation that measures the start and end [time.Time] of the operation
+func WithTime[A any](a IO[A]) IO[T.Tuple3[A, time.Time, time.Time]] {
+	return G.WithTime[IO[T.Tuple3[A, time.Time, time.Time]], IO[A]](a)
+}
+
+// WithDuration returns an operation that measures the [time.Duration]
+func WithDuration[A any](a IO[A]) IO[T.Tuple2[A, time.Duration]] {
+	return G.WithDuration[IO[T.Tuple2[A, time.Duration]], IO[A]](a)
+}

ioeither/bind.go

@@ -19,26 +19,48 @@ import (
 	G "github.com/IBM/fp-go/ioeither/generic"
 )
 
-// Bind applies a function to an input state and merges the result into that state
-func Bind[E, A, S1, S2 any](s func(A) func(S1) S2, f func(S1) IOEither[E, A]) func(IOEither[E, S1]) IOEither[E, S2] {
-	return G.Bind[IOEither[E, S1], IOEither[E, S2], IOEither[E, A], func(S1) IOEither[E, A]](s, f)
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[E, S any](
+	empty S,
+) IOEither[E, S] {
+	return G.Do[IOEither[E, S], E, S](empty)
 }
 
-// BindTo initializes some state based on a value
-func BindTo[
-	E, A, S2 any](s func(A) S2) func(IOEither[E, A]) IOEither[E, S2] {
-	return G.BindTo[IOEither[E, S2], IOEither[E, A]](s)
-}
-
-func ApS[
-	E, A, S1, S2 any,
-](s func(A) func(S1) S2, fa IOEither[E, A]) func(IOEither[E, S1]) IOEither[E, S2] {
-	return G.ApS[IOEither[E, S1], IOEither[E, S2], IOEither[E, A], IOEither[E, func(S1) S2]](s, fa)
-}
-
-func Let[E, A, S1, S2 any](
-	s func(A) func(S1) S2,
-	f func(S1) A,
+// 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) IOEither[E, T],
 ) func(IOEither[E, S1]) IOEither[E, S2] {
-	return G.Let[IOEither[E, S1], IOEither[E, S2]](s, f)
+	return G.Bind[IOEither[E, S1], IOEither[E, S2], IOEither[E, T], E, S1, S2, T](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](
+	setter func(T) func(S1) S2,
+	f func(S1) T,
+) func(IOEither[E, S1]) IOEither[E, S2] {
+	return G.Let[IOEither[E, S1], IOEither[E, S2], E, S1, S2, T](setter, f)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[E, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	b T,
+) func(IOEither[E, S1]) IOEither[E, S2] {
+	return G.LetTo[IOEither[E, S1], IOEither[E, S2], E, S1, S2, T](setter, b)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[E, S1, T any](
+	setter func(T) S1,
+) func(IOEither[E, T]) IOEither[E, S1] {
+	return G.BindTo[IOEither[E, S1], IOEither[E, T], E, 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[E, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa IOEither[E, T],
+) func(IOEither[E, S1]) IOEither[E, S2] {
+	return G.ApS[IOEither[E, S1], IOEither[E, S2], IOEither[E, T], E, S1, S2, T](setter, fa)
 }

ioeither/bind_test.go

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

ioeither/eq.go

@@ -26,7 +26,7 @@ func Eq[E, A any](eq EQ.Eq[ET.Either[E, A]]) EQ.Eq[IOEither[E, A]] {
 	return G.Eq[IOEither[E, A]](eq)
 }
 
-// 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[IOEither[E, A]] {
 	return G.FromStrictEquals[IOEither[E, A]]()
 }

ioeither/file/dir.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 file
+
+import (
+	"os"
+
+	IOE "github.com/IBM/fp-go/ioeither"
+)
+
+// MkdirAll create a sequence of directories, see [os.MkdirAll]
+func MkdirAll(path string, perm os.FileMode) IOE.IOEither[error, string] {
+	return IOE.TryCatchError(func() (string, error) {
+		return path, os.MkdirAll(path, perm)
+	})
+}
+
+// Mkdir create a directory, see [os.Mkdir]
+func Mkdir(path string, perm os.FileMode) IOE.IOEither[error, string] {
+	return IOE.TryCatchError(func() (string, error) {
+		return path, os.Mkdir(path, perm)
+	})
+}

ioeither/generic/bind.go

@@ -17,63 +17,74 @@ package generic
 
 import (
 	ET "github.com/IBM/fp-go/either"
-	G "github.com/IBM/fp-go/internal/bindt"
+	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 applies a function to an input state and merges the result into that state
-func Bind[
-	GS1 ~func() ET.Either[E, S1],
-	GS2 ~func() ET.Either[E, S2],
-	GA ~func() ET.Either[E, A],
-	FCT ~func(S1) GA,
-	E any,
-	SET ~func(A) func(S1) S2,
-	A, S1, S2 any](s SET, f FCT) func(GS1) GS2 {
-	return G.Bind(
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[GS ~func() ET.Either[E, S], E, S any](
+	empty S,
+) GS {
+	return Of[GS, E, S](empty)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[GS1 ~func() ET.Either[E, S1], GS2 ~func() ET.Either[E, S2], GT ~func() ET.Either[E, T], E, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) GT,
+) func(GS1) GS2 {
+	return C.Bind(
 		Chain[GS1, GS2, E, S1, S2],
-		Map[GA, GS2, E, A, S2],
-		s,
+		Map[GT, GS2, E, T, S2],
+		setter,
 		f,
 	)
 }
 
-// BindTo initializes some state based on a value
-func BindTo[
-	GS2 ~func() ET.Either[E, S2],
-	GA ~func() ET.Either[E, A],
-	E any,
-	SET ~func(A) S2,
-	A, S2 any](s SET) func(GA) GS2 {
-	return G.BindTo(
-		Map[GA, GS2, E, A, S2],
-		s,
-	)
-}
-
-func ApS[
-	GS1 ~func() ET.Either[E, S1],
-	GS2 ~func() ET.Either[E, S2],
-	GB ~func() ET.Either[E, B],
-	GS1S2 ~func() ET.Either[E, func(S1) S2],
-	SET ~func(B) func(S1) S2,
-	E, S1, S2, B any,
-](s SET, fb GB) func(GS1) GS2 {
-	return G.ApS[SET, S1, S2, B, GS1S2, GS1, GS2, GB](
-		Ap[GS2, GS1S2, GS1, E, S1, S2],
-		Map[GB, GS1S2, E, B, func(S1) S2],
-		s,
-		fb,
-	)
-}
-
-func Let[
-	GS1 ~func() ET.Either[E, S1],
-	GS2 ~func() ET.Either[E, S2],
-	SET ~func(B) func(S1) S2,
-	FCT ~func(S1) B,
-	E, S1, S2, B any](
-	s SET,
-	f FCT,
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[GS1 ~func() ET.Either[E, S1], GS2 ~func() ET.Either[E, S2], E, S1, S2, T any](
+	key func(T) func(S1) S2,
+	f func(S1) T,
 ) func(GS1) GS2 {
-	return G.Let[SET, FCT, S1, S2, B, GS1, GS2](Map[GS1, GS2, E, S1, S2], s, f)
+	return F.Let(
+		Map[GS1, GS2, E, S1, S2],
+		key,
+		f,
+	)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[GS1 ~func() ET.Either[E, S1], GS2 ~func() ET.Either[E, S2], E, S1, S2, B any](
+	key func(B) func(S1) S2,
+	b B,
+) func(GS1) GS2 {
+	return F.LetTo(
+		Map[GS1, GS2, E, S1, S2],
+		key,
+		b,
+	)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[GS1 ~func() ET.Either[E, S1], GT ~func() ET.Either[E, T], E, S1, S2, T any](
+	setter func(T) S1,
+) func(GT) GS1 {
+	return C.BindTo(
+		Map[GT, GS1, 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[GS1 ~func() ET.Either[E, S1], GS2 ~func() ET.Either[E, S2], GT ~func() ET.Either[E, T], E, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa GT,
+) func(GS1) GS2 {
+	return A.ApS(
+		Ap[GS2, func() ET.Either[E, func(T) S2], GT, E, T, S2],
+		Map[GS1, func() ET.Either[E, func(T) S2], E, S1, func(T) S2],
+		setter,
+		fa,
+	)
 }

ioeither/generic/eq.go

@@ -26,7 +26,7 @@ func Eq[GA ~func() ET.Either[E, A], E, A any](eq EQ.Eq[ET.Either[E, A]]) EQ.Eq[G
 	return G.Eq[GA](eq)
 }
 
-// FromStrictEquals constructs an `Eq` from the canonical comparison function
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
 func FromStrictEquals[GA ~func() ET.Either[E, A], E, A comparable]() EQ.Eq[GA] {
 	return Eq[GA](ET.FromStrictEquals[E, A]())
 }

ioeither/generic/ioeither.go

@@ -87,7 +87,7 @@ func MonadMap[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B an
 }
 
 func Map[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](f func(A) B) func(GA) GB {
-	return F.Bind2nd(MonadMap[GA, GB, E, A, B], f)
+	return eithert.Map(IO.Map[GA, GB, ET.Either[E, A], ET.Either[E, B]], f)
 }
 
 func MonadMapTo[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](fa GA, b B) GB {
@@ -95,7 +95,7 @@ func MonadMapTo[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B
 }
 
 func MapTo[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](b B) func(GA) GB {
-	return F.Bind2nd(MonadMapTo[GA, GB, E, A, B], b)
+	return Map[GA, GB](F.Constant1[A](b))
 }
 
 func MonadChain[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](fa GA, f func(A) GB) GB {
@@ -103,7 +103,7 @@ func MonadChain[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B
 }
 
 func Chain[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](f func(A) GB) func(GA) GB {
-	return F.Bind2nd(MonadChain[GA, GB, E, A, B], f)
+	return eithert.Chain(IO.Chain[GA, GB, ET.Either[E, A], ET.Either[E, B]], IO.Of[GB, ET.Either[E, B]], f)
 }
 
 func MonadChainTo[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](fa GA, fb GB) GB {
@@ -111,7 +111,7 @@ func MonadChainTo[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A,
 }
 
 func ChainTo[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](fb GB) func(GA) GB {
-	return F.Bind2nd(MonadChainTo[GA, GB, E, A, B], fb)
+	return Chain[GA, GB, E, A, B](F.Constant1[A](fb))
 }
 
 func MonadChainEitherK[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](ma GA, f func(A) ET.Either[E, B]) GB {
@@ -134,14 +134,18 @@ func MonadChainIOK[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GR ~f
 
 func ChainIOK[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GR ~func() B, E, A, B any](f func(A) GR) func(GA) GB {
 	return FI.ChainIOK(
-		MonadChain[GA, GB, E, A, B],
+		Chain[GA, GB, E, A, B],
 		FromIO[GB, GR, E, B],
 		f,
 	)
 }
 
 func ChainEitherK[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](f func(A) ET.Either[E, B]) func(GA) GB {
-	return F.Bind2nd(MonadChainEitherK[GA, GB, E, A, B], f)
+	return FE.ChainEitherK(
+		Chain[GA, GB, E, A, B],
+		FromEither[GB, E, B],
+		f,
+	)
 }
 
 func MonadAp[GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], GA ~func() ET.Either[E, A], E, A, B any](mab GAB, ma GA) GB {
@@ -223,7 +227,7 @@ func MonadBiMap[GA ~func() ET.Either[E1, A], GB ~func() ET.Either[E2, B], E1, E2
 
 // BiMap maps a pair of functions over the two type arguments of the bifunctor.
 func BiMap[GA ~func() ET.Either[E1, A], GB ~func() ET.Either[E2, B], E1, E2, A, B any](f func(E1) E2, g func(A) B) func(GA) GB {
-	return eithert.BiMap(IO.MonadMap[GA, GB, ET.Either[E1, A], ET.Either[E2, B]], f, g)
+	return eithert.BiMap(IO.Map[GA, GB, ET.Either[E1, A], ET.Either[E2, B]], f, g)
 }
 
 // Fold convers an IOEither into an IO
@@ -253,8 +257,8 @@ func MonadChainFirst[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E,
 // ChainFirst runs the monad returned by the function but returns the result of the original monad
 func ChainFirst[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](f func(A) GB) func(GA) GA {
 	return C.ChainFirst(
-		MonadChain[GA, GA, E, A, A],
-		MonadMap[GB, GA, E, B, A],
+		Chain[GA, GA, E, A, A],
+		Map[GB, GA, E, B, A],
 		f,
 	)
 }
@@ -273,8 +277,8 @@ func MonadChainFirstIOK[GA ~func() ET.Either[E, A], GIOB ~func() B, E, A, B any]
 // ChainFirstIOK runs the monad returned by the function but returns the result of the original monad
 func ChainFirstIOK[GA ~func() ET.Either[E, A], GIOB ~func() B, E, A, B any](f func(A) GIOB) func(GA) GA {
 	return FI.ChainFirstIOK(
-		MonadChain[GA, GA, E, A, A],
-		MonadMap[func() ET.Either[E, B], GA, E, B, A],
+		Chain[GA, GA, E, A, A],
+		Map[func() ET.Either[E, B], GA, E, B, A],
 		FromIO[func() ET.Either[E, B], GIOB, E, B],
 		f,
 	)
@@ -294,8 +298,8 @@ func MonadChainFirstEitherK[GA ~func() ET.Either[E, A], E, A, B any](first GA, f
 // ChainFirstEitherK runs the monad returned by the function but returns the result of the original monad
 func ChainFirstEitherK[GA ~func() ET.Either[E, A], E, A, B any](f func(A) ET.Either[E, B]) func(GA) GA {
 	return FE.ChainFirstEitherK(
-		MonadChain[GA, GA, E, A, A],
-		MonadMap[func() ET.Either[E, B], GA, E, B, A],
+		Chain[GA, GA, E, A, A],
+		Map[func() ET.Either[E, B], GA, E, B, A],
 		FromEither[func() ET.Either[E, B], E, B],
 		f,
 	)
@@ -339,7 +343,7 @@ func MonadFlap[GEAB ~func() ET.Either[E, func(A) B], GEB ~func() ET.Either[E, B]
 }
 
 func Flap[GEAB ~func() ET.Either[E, func(A) B], GEB ~func() ET.Either[E, B], E, B, A any](a A) func(GEAB) GEB {
-	return FC.Flap(MonadMap[GEAB, GEB], a)
+	return FC.Flap(Map[GEAB, GEB], a)
 }
 
 func ToIOOption[GA ~func() O.Option[A], GEA ~func() ET.Either[E, A], E, A any](ioe GEA) GA {

ioeither/ioeither.go

@@ -175,7 +175,7 @@ func MonadMapLeft[E1, E2, A any](fa IOEither[E1, A], f func(E1) E2) IOEither[E2,
 	return G.MonadMapLeft[IOEither[E1, A], IOEither[E2, A]](fa, f)
 }
 
-func MapLeft[E1, E2, A any](f func(E1) E2) func(IOEither[E1, A]) IOEither[E2, A] {
+func MapLeft[A, E1, E2 any](f func(E1) E2) func(IOEither[E1, A]) IOEither[E2, A] {
 	return G.MapLeft[IOEither[E1, A], IOEither[E2, A]](f)
 }
 

iooption/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 iooption
+
+import (
+	G "github.com/IBM/fp-go/iooption/generic"
+)
+
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[S any](
+	empty S,
+) IOOption[S] {
+	return G.Do[IOOption[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) IOOption[T],
+) func(IOOption[S1]) IOOption[S2] {
+	return G.Bind[IOOption[S1], IOOption[S2], IOOption[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(IOOption[S1]) IOOption[S2] {
+	return G.Let[IOOption[S1], IOOption[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(IOOption[S1]) IOOption[S2] {
+	return G.LetTo[IOOption[S1], IOOption[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(IOOption[T]) IOOption[S1] {
+	return G.BindTo[IOOption[S1], IOOption[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 IOOption[T],
+) func(IOOption[S1]) IOOption[S2] {
+	return G.ApS[IOOption[S1], IOOption[S2], IOOption[T], S1, S2, T](setter, fa)
+}

iooption/bind_test.go

@@ -0,0 +1,57 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package iooption
+
+import (
+	"testing"
+
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/utils"
+	O "github.com/IBM/fp-go/option"
+	"github.com/stretchr/testify/assert"
+)
+
+func getLastName(s utils.Initial) IOOption[string] {
+	return Of("Doe")
+}
+
+func getGivenName(s utils.WithLastName) IOOption[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(), O.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(), O.Of("John Doe"))
+}

iooption/eq.go

@@ -0,0 +1,31 @@
+// 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 iooption
+
+import (
+	EQ "github.com/IBM/fp-go/eq"
+	G "github.com/IBM/fp-go/iooption/generic"
+)
+
+// Eq implements the equals predicate for values contained in the IO monad
+func Eq[A any](e EQ.Eq[A]) EQ.Eq[IOOption[A]] {
+	return G.Eq[IOOption[A]](e)
+}
+
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
+func FromStrictEquals[A comparable]() EQ.Eq[IOOption[A]] {
+	return G.FromStrictEquals[IOOption[A]]()
+}

iooption/generic/bind.go

@@ -0,0 +1,90 @@
+// 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"
+	O "github.com/IBM/fp-go/option"
+)
+
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[GS ~func() O.Option[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 ~func() O.Option[S1], GS2 ~func() O.Option[S2], GT ~func() O.Option[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 ~func() O.Option[S1], GS2 ~func() O.Option[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 ~func() O.Option[S1], GS2 ~func() O.Option[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 ~func() O.Option[S1], GT ~func() O.Option[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 ~func() O.Option[S1], GS2 ~func() O.Option[S2], GT ~func() O.Option[T], S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa GT,
+) func(GS1) GS2 {
+	return A.ApS(
+		Ap[GS2, func() O.Option[func(T) S2], GT, T, S2],
+		Map[GS1, func() O.Option[func(T) S2], S1, func(T) S2],
+		setter,
+		fa,
+	)
+}

iooption/generic/eq.go

@@ -0,0 +1,32 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	EQ "github.com/IBM/fp-go/eq"
+	G "github.com/IBM/fp-go/io/generic"
+	O "github.com/IBM/fp-go/option"
+)
+
+// Eq implements the equals predicate for values contained in the IO monad
+func Eq[GA ~func() O.Option[A], A any](e EQ.Eq[A]) EQ.Eq[GA] {
+	return G.Eq[GA](O.Eq(e))
+}
+
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
+func FromStrictEquals[GA ~func() O.Option[A], A comparable]() EQ.Eq[GA] {
+	return Eq[GA](EQ.FromStrictEquals[A]())
+}

iooption/generic/iooption.go

@@ -90,8 +90,8 @@ func MonadChainFirst[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](m
 // ChainFirst runs the monad returned by the function but returns the result of the original monad
 func ChainFirst[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](f func(A) GB) func(GA) GA {
 	return C.ChainFirst(
-		MonadChain[GA, GA, A, A],
-		MonadMap[GB, GA, B, A],
+		Chain[GA, GA, A, A],
+		Map[GB, GA, B, A],
 		f,
 	)
 }
@@ -110,15 +110,15 @@ func MonadChainFirstIOK[GA ~func() O.Option[A], GIOB ~func() B, A, B any](first
 // ChainFirstIOK runs the monad returned by the function but returns the result of the original monad
 func ChainFirstIOK[GA ~func() O.Option[A], GIOB ~func() B, A, B any](f func(A) GIOB) func(GA) GA {
 	return FI.ChainFirstIOK(
-		MonadChain[GA, GA, A, A],
-		MonadMap[func() O.Option[B], GA, B, A],
+		Chain[GA, GA, A, A],
+		Map[func() O.Option[B], GA, B, A],
 		FromIO[func() O.Option[B], GIOB, B],
 		f,
 	)
 }
 
 func Chain[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](f func(A) GB) func(GA) GB {
-	return optiont.Chain(IO.MonadChain[GA, GB, O.Option[A], O.Option[B]], IO.MonadOf[GB, O.Option[B]], f)
+	return optiont.Chain(IO.Chain[GA, GB, O.Option[A], O.Option[B]], IO.Of[GB, O.Option[B]], f)
 }
 
 func MonadChainOptionK[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](ma GA, f func(A) O.Option[B]) GB {
@@ -131,7 +131,11 @@ func MonadChainOptionK[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any]
 }
 
 func ChainOptionK[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](f func(A) O.Option[B]) func(GA) GB {
-	return F.Bind2nd(MonadChainOptionK[GA, GB, A, B], f)
+	return optiont.ChainOptionK(
+		IO.Chain[GA, GB, O.Option[A], O.Option[B]],
+		FromOption[GB, B],
+		f,
+	)
 }
 
 func MonadChainIOK[GA ~func() O.Option[A], GB ~func() O.Option[B], GR ~func() B, A, B any](ma GA, f func(A) GR) GB {
@@ -145,7 +149,7 @@ func MonadChainIOK[GA ~func() O.Option[A], GB ~func() O.Option[B], GR ~func() B,
 
 func ChainIOK[GA ~func() O.Option[A], GB ~func() O.Option[B], GR ~func() B, A, B any](f func(A) GR) func(GA) GB {
 	return FI.ChainIOK(
-		MonadChain[GA, GB, A, B],
+		Chain[GA, GB, A, B],
 		FromIO[GB, GR, B],
 		f,
 	)
@@ -159,7 +163,10 @@ func MonadAp[GB ~func() O.Option[B], GAB ~func() O.Option[func(A) B], GA ~func()
 }
 
 func Ap[GB ~func() O.Option[B], GAB ~func() O.Option[func(A) B], GA ~func() O.Option[A], A, B any](ma GA) func(GAB) GB {
-	return F.Bind2nd(MonadAp[GB, GAB, GA, A, B], ma)
+	return optiont.Ap(
+		IO.Ap[GB, func() func(O.Option[A]) O.Option[B], GA, O.Option[B], O.Option[A]],
+		IO.Map[GAB, func() func(O.Option[A]) O.Option[B], O.Option[func(A) B], func(O.Option[A]) O.Option[B]],
+		ma)
 }
 
 func Flatten[GA ~func() O.Option[A], GAA ~func() O.Option[GA], A any](mma GAA) GA {
@@ -236,7 +243,7 @@ func Defer[GA ~func() O.Option[A], A any](gen func() GA) GA {
 
 func MonadAlt[LAZY ~func() GIOA, GIOA ~func() O.Option[A], A any](first GIOA, second LAZY) GIOA {
 	return optiont.MonadAlt(
-		IO.Of[GIOA],
+		IO.MonadOf[GIOA],
 		IO.MonadChain[GIOA, GIOA],
 
 		first,
@@ -245,5 +252,10 @@ func MonadAlt[LAZY ~func() GIOA, GIOA ~func() O.Option[A], A any](first GIOA, se
 }
 
 func Alt[LAZY ~func() GIOA, GIOA ~func() O.Option[A], A any](second LAZY) func(GIOA) GIOA {
-	return F.Bind2nd(MonadAlt[LAZY], second)
+	return optiont.Alt(
+		IO.Of[GIOA],
+		IO.Chain[GIOA, GIOA],
+
+		second,
+	)
 }

iooption/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"
+
+	EQ "github.com/IBM/fp-go/eq"
+	L "github.com/IBM/fp-go/internal/monad/testing"
+	IOO "github.com/IBM/fp-go/iooption"
+)
+
+// AssertLaws asserts the apply monad laws for the `Either` 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,
+		IOO.Eq(eqa),
+		IOO.Eq(eqb),
+		IOO.Eq(eqc),
+
+		IOO.Of[A],
+		IOO.Of[B],
+		IOO.Of[C],
+
+		IOO.Of[func(A) A],
+		IOO.Of[func(A) B],
+		IOO.Of[func(B) C],
+		IOO.Of[func(func(A) B) B],
+
+		IOO.MonadMap[A, A],
+		IOO.MonadMap[A, B],
+		IOO.MonadMap[A, C],
+		IOO.MonadMap[B, C],
+
+		IOO.MonadMap[func(B) C, func(func(A) B) func(A) C],
+
+		IOO.MonadChain[A, A],
+		IOO.MonadChain[A, B],
+		IOO.MonadChain[A, C],
+		IOO.MonadChain[B, C],
+
+		IOO.MonadAp[A, A],
+		IOO.MonadAp[B, A],
+		IOO.MonadAp[C, B],
+		IOO.MonadAp[C, A],
+
+		IOO.MonadAp[B, func(A) B],
+		IOO.MonadAp[func(A) C, func(A) B],
+
+		ab,
+		bc,
+	)
+
+}

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

iterator/stateless/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 stateless
+
+import (
+	G "github.com/IBM/fp-go/iterator/stateless/generic"
+)
+
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[S any](
+	empty S,
+) Iterator[S] {
+	return G.Do[Iterator[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) Iterator[T],
+) func(Iterator[S1]) Iterator[S2] {
+	return G.Bind[Iterator[S1], Iterator[S2], Iterator[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(Iterator[S1]) Iterator[S2] {
+	return G.Let[Iterator[S1], Iterator[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(Iterator[S1]) Iterator[S2] {
+	return G.LetTo[Iterator[S1], Iterator[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(Iterator[T]) Iterator[S1] {
+	return G.BindTo[Iterator[S1], Iterator[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 Iterator[T],
+) func(Iterator[S1]) Iterator[S2] {
+	return G.ApS[Iterator[func(T) S2], Iterator[S1], Iterator[S2], Iterator[T], S1, S2, T](setter, fa)
+}

iterator/stateless/bind_test.go

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

iterator/stateless/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 (
+	"github.com/IBM/fp-go/internal/apply"
+	C "github.com/IBM/fp-go/internal/chain"
+	F "github.com/IBM/fp-go/internal/functor"
+	O "github.com/IBM/fp-go/option"
+	T "github.com/IBM/fp-go/tuple"
+)
+
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[GS ~func() O.Option[T.Tuple2[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 ~func() O.Option[T.Tuple2[GS1, S1]], GS2 ~func() O.Option[T.Tuple2[GS2, S2]], GA ~func() O.Option[T.Tuple2[GA, A]], S1, S2, A any](
+	setter func(A) func(S1) S2,
+	f func(S1) GA,
+) func(GS1) GS2 {
+
+	return C.Bind(
+		Chain[GS2, GS1, S1, S2],
+		Map[GS2, GA, func(A) S2, A, S2],
+		setter,
+		f,
+	)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[GS1 ~func() O.Option[T.Tuple2[GS1, S1]], GS2 ~func() O.Option[T.Tuple2[GS2, S2]], S1, S2, A any](
+	key func(A) func(S1) S2,
+	f func(S1) A,
+) func(GS1) GS2 {
+	return F.Let(
+		Map[GS2, GS1, func(S1) S2, S1, S2],
+		key,
+		f,
+	)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[GS1 ~func() O.Option[T.Tuple2[GS1, S1]], GS2 ~func() O.Option[T.Tuple2[GS2, S2]], S1, S2, B any](
+	key func(B) func(S1) S2,
+	b B,
+) func(GS1) GS2 {
+	return F.LetTo(
+		Map[GS2, GS1, func(S1) S2, S1, S2],
+		key,
+		b,
+	)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[GS1 ~func() O.Option[T.Tuple2[GS1, S1]], GA ~func() O.Option[T.Tuple2[GA, A]], S1, A any](
+	setter func(A) S1,
+) func(GA) GS1 {
+	return C.BindTo(
+		Map[GS1, GA, func(A) S1, A, 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[GAS2 ~func() O.Option[T.Tuple2[GAS2, func(A) S2]], GS1 ~func() O.Option[T.Tuple2[GS1, S1]], GS2 ~func() O.Option[T.Tuple2[GS2, S2]], GA ~func() O.Option[T.Tuple2[GA, A]], S1, S2, A any](
+	setter func(A) func(S1) S2,
+	fa GA,
+) func(GS1) GS2 {
+	return apply.ApS(
+		Ap[GAS2, GS2, GA, A, S2],
+		Map[GAS2, GS1, func(S1) func(A) S2, S1, func(A) S2],
+		setter,
+		fa,
+	)
+}

lazy/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 lazy
+
+import (
+	G "github.com/IBM/fp-go/io/generic"
+)
+
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[S any](
+	empty S,
+) Lazy[S] {
+	return G.Do[Lazy[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) Lazy[T],
+) func(Lazy[S1]) Lazy[S2] {
+	return G.Bind[Lazy[S1], Lazy[S2], Lazy[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(Lazy[S1]) Lazy[S2] {
+	return G.Let[Lazy[S1], Lazy[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(Lazy[S1]) Lazy[S2] {
+	return G.LetTo[Lazy[S1], Lazy[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(Lazy[T]) Lazy[S1] {
+	return G.BindTo[Lazy[S1], Lazy[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 Lazy[T],
+) func(Lazy[S1]) Lazy[S2] {
+	return G.ApS[Lazy[S1], Lazy[S2], Lazy[T], S1, S2, T](setter, fa)
+}

lazy/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 lazy
+
+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) Lazy[string] {
+	return Of("Doe")
+}
+
+func getGivenName(s utils.WithLastName) Lazy[string] {
+	return Of("John")
+}
+
+func TestBind(t *testing.T) {
+
+	res := F.Pipe3(
+		Do(utils.Empty),
+		Bind(utils.SetLastName, getLastName),
+		Bind(utils.SetGivenName, getGivenName),
+		Map(utils.GetFullName),
+	)
+
+	assert.Equal(t, res(), "John Doe")
+}
+
+func TestApS(t *testing.T) {
+
+	res := F.Pipe3(
+		Do(utils.Empty),
+		ApS(utils.SetLastName, Of("Doe")),
+		ApS(utils.SetGivenName, Of("John")),
+		Map(utils.GetFullName),
+	)
+
+	assert.Equal(t, res(), "John Doe")
+}

option/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 option
+
+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,
+) Option[S] {
+	return Of(empty)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[S1, S2, A any](
+	setter func(A) func(S1) S2,
+	f func(S1) Option[A],
+) func(Option[S1]) Option[S2] {
+	return C.Bind(
+		Chain[S1, S2],
+		Map[A, S2],
+		setter,
+		f,
+	)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[S1, S2, B any](
+	key func(B) func(S1) S2,
+	f func(S1) B,
+) func(Option[S1]) Option[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(Option[S1]) Option[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(Option[T]) Option[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 Option[T],
+) func(Option[S1]) Option[S2] {
+	return A.ApS(
+		Ap[S2, T],
+		Map[S1, func(T) S2],
+		setter,
+		fa,
+	)
+}

option/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 option
+
+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) Option[string] {
+	return Of("Doe")
+}
+
+func getGivenName(s utils.WithLastName) Option[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"))
+}

option/eq.go

@@ -31,7 +31,7 @@ func Eq[A any](a EQ.Eq[A]) EQ.Eq[Option[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[A comparable]() EQ.Eq[Option[A]] {
 	return Eq(EQ.FromStrictEquals[A]())
 }

option/option.go

@@ -156,5 +156,5 @@ func MonadFlap[B, A any](fab Option[func(A) B], a A) Option[B] {
 }
 
 func Flap[B, A any](a A) func(Option[func(A) B]) Option[B] {
-	return F.Bind2nd(MonadFlap[B, A], a)
+	return FC.Flap(Map[func(A) B, B], a)
 }

reader/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 reader
+
+import (
+	G "github.com/IBM/fp-go/reader/generic"
+)
+
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[R, S any](
+	empty S,
+) Reader[R, S] {
+	return G.Do[Reader[R, S], R, S](empty)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[R, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) Reader[R, T],
+) func(Reader[R, S1]) Reader[R, S2] {
+	return G.Bind[Reader[R, S1], Reader[R, S2], Reader[R, T], R, S1, S2, T](setter, f)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[R, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) T,
+) func(Reader[R, S1]) Reader[R, S2] {
+	return G.Let[Reader[R, S1], Reader[R, S2], R, S1, S2, T](setter, f)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[R, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	b T,
+) func(Reader[R, S1]) Reader[R, S2] {
+	return G.LetTo[Reader[R, S1], Reader[R, S2], R, S1, S2, T](setter, b)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[R, S1, T any](
+	setter func(T) S1,
+) func(Reader[R, T]) Reader[R, S1] {
+	return G.BindTo[Reader[R, S1], Reader[R, T], R, 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[R, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa Reader[R, T],
+) func(Reader[R, S1]) Reader[R, S2] {
+	return G.ApS[Reader[R, S1], Reader[R, S2], Reader[R, T], R, S1, S2, T](setter, fa)
+}

reader/bind_test.go

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

reader/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 ~func(R) S, R, S any](
+	empty S,
+) GS {
+	return Of[GS, R, S](empty)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[GS1 ~func(R) S1, GS2 ~func(R) S2, GT ~func(R) T, R, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) GT,
+) func(GS1) GS2 {
+	return C.Bind(
+		Chain[GS1, GS2, R, S1, S2],
+		Map[GT, GS2, R, T, S2],
+		setter,
+		f,
+	)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[GS1 ~func(R) S1, GS2 ~func(R) S2, R, S1, S2, T any](
+	key func(T) func(S1) S2,
+	f func(S1) T,
+) func(GS1) GS2 {
+	return F.Let(
+		Map[GS1, GS2, R, S1, S2],
+		key,
+		f,
+	)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[GS1 ~func(R) S1, GS2 ~func(R) S2, R, S1, S2, B any](
+	key func(B) func(S1) S2,
+	b B,
+) func(GS1) GS2 {
+	return F.LetTo(
+		Map[GS1, GS2, R, S1, S2],
+		key,
+		b,
+	)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[GS1 ~func(R) S1, GT ~func(R) T, R, S1, T any](
+	setter func(T) S1,
+) func(GT) GS1 {
+	return C.BindTo(
+		Map[GT, GS1, R, 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 ~func(R) S1, GS2 ~func(R) S2, GT ~func(R) T, R, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa GT,
+) func(GS1) GS2 {
+	return A.ApS(
+		Ap[GT, GS2, func(R) func(T) S2, R, T, S2],
+		Map[GS1, func(R) func(T) S2, R, S1, func(T) S2],
+		setter,
+		fa,
+	)
+}

reader/generic/reader.go

@@ -127,5 +127,5 @@ func MonadFlap[GAB ~func(R) func(A) B, GB ~func(R) B, R, A, B any](fab GAB, a A)
 }
 
 func Flap[GAB ~func(R) func(A) B, GB ~func(R) B, R, A, B any](a A) func(GAB) GB {
-	return FC.Flap(MonadMap[GAB, GB], a)
+	return FC.Flap(Map[GAB, GB], a)
 }

readereither/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 readereither
+
+import (
+	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[R, E, S any](
+	empty S,
+) ReaderEither[R, E, S] {
+	return G.Do[ReaderEither[R, E, S], R, E, S](empty)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[R, E, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) ReaderEither[R, E, T],
+) func(ReaderEither[R, E, S1]) ReaderEither[R, E, S2] {
+	return G.Bind[ReaderEither[R, E, S1], ReaderEither[R, E, S2], ReaderEither[R, E, T], R, E, S1, S2, T](setter, f)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[R, E, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) T,
+) func(ReaderEither[R, E, S1]) ReaderEither[R, E, S2] {
+	return G.Let[ReaderEither[R, E, S1], ReaderEither[R, E, S2], R, E, S1, S2, T](setter, f)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[R, E, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	b T,
+) func(ReaderEither[R, E, S1]) ReaderEither[R, E, S2] {
+	return G.LetTo[ReaderEither[R, E, S1], ReaderEither[R, E, S2], R, E, S1, S2, T](setter, b)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[R, E, S1, T any](
+	setter func(T) S1,
+) func(ReaderEither[R, E, T]) ReaderEither[R, E, S1] {
+	return G.BindTo[ReaderEither[R, E, S1], ReaderEither[R, E, T], R, E, 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[R, E, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa ReaderEither[R, E, T],
+) func(ReaderEither[R, E, S1]) ReaderEither[R, E, S2] {
+	return G.ApS[ReaderEither[R, E, S1], ReaderEither[R, E, S2], ReaderEither[R, E, T], R, E, S1, S2, T](setter, fa)
+}

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[context.Context, error, string] {
+	return Of[context.Context, error]("Doe")
+}
+
+func getGivenName(s utils.WithLastName) ReaderEither[context.Context, error, string] {
+	return Of[context.Context, error]("John")
+}
+
+func TestBind(t *testing.T) {
+
+	res := F.Pipe3(
+		Do[context.Context, error](utils.Empty),
+		Bind(utils.SetLastName, getLastName),
+		Bind(utils.SetGivenName, getGivenName),
+		Map[context.Context, error](utils.GetFullName),
+	)
+
+	assert.Equal(t, res(context.Background()), E.Of[error]("John Doe"))
+}
+
+func TestApS(t *testing.T) {
+
+	res := F.Pipe3(
+		Do[context.Context, error](utils.Empty),
+		ApS(utils.SetLastName, Of[context.Context, error]("Doe")),
+		ApS(utils.SetGivenName, Of[context.Context, error]("John")),
+		Map[context.Context, error](utils.GetFullName),
+	)
+
+	assert.Equal(t, res(context.Background()), E.Of[error]("John Doe"))
+}

readereither/generic/bind.go

@@ -0,0 +1,90 @@
+// 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 (
+	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[GS ~func(R) ET.Either[E, S], R, E, S any](
+	empty S,
+) GS {
+	return Of[GS, E, R, S](empty)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[GS1 ~func(R) ET.Either[E, S1], GS2 ~func(R) ET.Either[E, S2], GT ~func(R) ET.Either[E, T], R, E, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) GT,
+) func(GS1) GS2 {
+	return C.Bind(
+		Chain[GS1, GS2, E, R, S1, S2],
+		Map[GT, GS2, E, R, T, S2],
+		setter,
+		f,
+	)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[GS1 ~func(R) ET.Either[E, S1], GS2 ~func(R) ET.Either[E, S2], R, E, S1, S2, T any](
+	key func(T) func(S1) S2,
+	f func(S1) T,
+) func(GS1) GS2 {
+	return F.Let(
+		Map[GS1, GS2, E, R, S1, S2],
+		key,
+		f,
+	)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[GS1 ~func(R) ET.Either[E, S1], GS2 ~func(R) ET.Either[E, S2], R, E, S1, S2, B any](
+	key func(B) func(S1) S2,
+	b B,
+) func(GS1) GS2 {
+	return F.LetTo(
+		Map[GS1, GS2, E, R, S1, S2],
+		key,
+		b,
+	)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[GS1 ~func(R) ET.Either[E, S1], GT ~func(R) ET.Either[E, T], R, E, S1, T any](
+	setter func(T) S1,
+) func(GT) GS1 {
+	return C.BindTo(
+		Map[GT, GS1, E, R, 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 ~func(R) ET.Either[E, S1], GS2 ~func(R) ET.Either[E, S2], GT ~func(R) ET.Either[E, T], R, E, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa GT,
+) func(GS1) GS2 {
+	return A.ApS(
+		Ap[GT, GS2, func(R) ET.Either[E, func(T) S2], E, R, T, S2],
+		Map[GS1, func(R) ET.Either[E, func(T) S2], E, R, S1, func(T) S2],
+		setter,
+		fa,
+	)
+}

readereither/generic/reader.go

@@ -60,7 +60,7 @@ func MonadMap[GEA ~func(E) ET.Either[L, A], GEB ~func(E) ET.Either[L, B], L, E,
 }
 
 func Map[GEA ~func(E) ET.Either[L, A], GEB ~func(E) ET.Either[L, B], L, E, A, B any](f func(A) B) func(GEA) GEB {
-	return F.Bind2nd(MonadMap[GEA, GEB, L, E, A, B], f)
+	return readert.Map[GEA, GEB](ET.Map[L, A, B], f)
 }
 
 func MonadChain[GEA ~func(E) ET.Either[L, A], GEB ~func(E) ET.Either[L, B], L, E, A, B any](ma GEA, f func(A) GEB) GEB {
@@ -143,7 +143,7 @@ func MonadBiMap[GA ~func(E) ET.Either[E1, A], GB ~func(E) ET.Either[E2, B], E, E
 
 // BiMap maps a pair of functions over the two type arguments of the bifunctor.
 func BiMap[GA ~func(E) ET.Either[E1, A], GB ~func(E) ET.Either[E2, B], E, E1, E2, A, B any](f func(E1) E2, g func(A) B) func(GA) GB {
-	return eithert.BiMap(R.MonadMap[GA, GB, E, ET.Either[E1, A], ET.Either[E2, B]], f, g)
+	return eithert.BiMap(R.Map[GA, GB, E, ET.Either[E1, A], ET.Either[E2, B]], f, g)
 }
 
 // Local changes the value of the local context during the execution of the action `ma` (similar to `Contravariant`'s
@@ -162,5 +162,14 @@ func MonadFlap[GEFAB ~func(E) ET.Either[L, func(A) B], GEB ~func(E) ET.Either[L,
 }
 
 func Flap[GEFAB ~func(E) ET.Either[L, func(A) B], GEB ~func(E) ET.Either[L, B], L, E, A, B any](a A) func(GEFAB) GEB {
-	return FC.Flap(MonadMap[GEFAB, GEB], a)
+	return FC.Flap(Map[GEFAB, GEB], a)
+}
+
+func MonadMapLeft[GA1 ~func(C) ET.Either[E1, A], GA2 ~func(C) ET.Either[E2, A], C, E1, E2, A any](fa GA1, f func(E1) E2) GA2 {
+	return eithert.MonadMapLeft(R.MonadMap[GA1, GA2, C, ET.Either[E1, A], ET.Either[E2, A]], fa, f)
+}
+
+// MapLeft applies a mapping function to the error channel
+func MapLeft[GA1 ~func(C) ET.Either[E1, A], GA2 ~func(C) ET.Either[E2, A], C, E1, E2, A any](f func(E1) E2) func(GA1) GA2 {
+	return F.Bind2nd(MonadMapLeft[GA1, GA2, C, E1, E2, A], f)
 }

readereither/reader.go

@@ -151,3 +151,12 @@ func MonadFlap[L, E, A, B any](fab ReaderEither[L, E, func(A) B], a A) ReaderEit
 func Flap[L, E, B, A any](a A) func(ReaderEither[L, E, func(A) B]) ReaderEither[L, E, B] {
 	return G.Flap[ReaderEither[L, E, func(A) B], ReaderEither[L, E, B]](a)
 }
+
+func MonadMapLeft[C, E1, E2, A any](fa ReaderEither[C, E1, A], f func(E1) E2) ReaderEither[C, E2, A] {
+	return G.MonadMapLeft[ReaderEither[C, E1, A], ReaderEither[C, E2, A]](fa, f)
+}
+
+// MapLeft applies a mapping function to the error channel
+func MapLeft[C, E1, E2, A any](f func(E1) E2) func(ReaderEither[C, E1, A]) ReaderEither[C, E2, A] {
+	return G.MapLeft[ReaderEither[C, E1, A], ReaderEither[C, E2, A]](f)
+}

readerio/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 readerio
+
+import (
+	IO "github.com/IBM/fp-go/io"
+	G "github.com/IBM/fp-go/readerio/generic"
+)
+
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[R, S any](
+	empty S,
+) ReaderIO[R, S] {
+	return G.Do[ReaderIO[R, S], IO.IO[S], R, S](empty)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[R, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) ReaderIO[R, T],
+) func(ReaderIO[R, S1]) ReaderIO[R, S2] {
+	return G.Bind[ReaderIO[R, S1], ReaderIO[R, S2], ReaderIO[R, T], IO.IO[S1], IO.IO[S2], IO.IO[T], R, S1, S2, T](setter, f)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[R, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) T,
+) func(ReaderIO[R, S1]) ReaderIO[R, S2] {
+	return G.Let[ReaderIO[R, S1], ReaderIO[R, S2], IO.IO[S1], IO.IO[S2], R, S1, S2, T](setter, f)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[R, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	b T,
+) func(ReaderIO[R, S1]) ReaderIO[R, S2] {
+	return G.LetTo[ReaderIO[R, S1], ReaderIO[R, S2], IO.IO[S1], IO.IO[S2], R, S1, S2, T](setter, b)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[R, S1, T any](
+	setter func(T) S1,
+) func(ReaderIO[R, T]) ReaderIO[R, S1] {
+	return G.BindTo[ReaderIO[R, S1], ReaderIO[R, T], IO.IO[S1], IO.IO[T], R, 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[R, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa ReaderIO[R, T],
+) func(ReaderIO[R, S1]) ReaderIO[R, S2] {
+	return G.ApS[ReaderIO[R, func(T) S2], ReaderIO[R, S1], ReaderIO[R, S2], ReaderIO[R, T], IO.IO[func(T) S2], IO.IO[S1], IO.IO[S2], IO.IO[T], R, S1, S2, T](setter, fa)
+}

readerio/bind_test.go

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

readerio/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[GRS ~func(R) GS, GS ~func() S, R, S any](
+	empty S,
+) GRS {
+	return Of[GRS, GS, R, S](empty)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[GRS1 ~func(R) GS1, GRS2 ~func(R) GS2, GRT ~func(R) GT, GS1 ~func() S1, GS2 ~func() S2, GT ~func() T, R, 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, R, S1, S2],
+		Map[GRT, GRS2, GT, GS2, R, T, S2],
+		setter,
+		f,
+	)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[GRS1 ~func(R) GS1, GRS2 ~func(R) GS2, GS1 ~func() S1, GS2 ~func() S2, R, 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, R, S1, S2],
+		key,
+		f,
+	)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[GRS1 ~func(R) GS1, GRS2 ~func(R) GS2, GS1 ~func() S1, GS2 ~func() S2, R, S1, S2, B any](
+	key func(B) func(S1) S2,
+	b B,
+) func(GRS1) GRS2 {
+	return F.LetTo(
+		Map[GRS1, GRS2, GS1, GS2, R, S1, S2],
+		key,
+		b,
+	)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[GRS1 ~func(R) GS1, GRT ~func(R) GT, GS1 ~func() S1, GT ~func() T, R, S1, T any](
+	setter func(T) S1,
+) func(GRT) GRS1 {
+	return C.BindTo(
+		Map[GRT, GRS1, GT, GS1, R, 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(R) GTS1, GRS1 ~func(R) GS1, GRS2 ~func(R) GS2, GRT ~func(R) GT, GTS1 ~func() func(T) S2, GS1 ~func() S1, GS2 ~func() S2, GT ~func() T, R, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa GRT,
+) func(GRS1) GRS2 {
+	return A.ApS(
+		Ap[GRT, GRS2, GRTS1, GT, GS2, GTS1, R, T, S2],
+		Map[GRS1, GRTS1, GS1, GTS1, R, S1, func(T) S2],
+		setter,
+		fa,
+	)
+}

readerio/generic/reader.go

@@ -40,7 +40,7 @@ func MonadMap[GEA ~func(E) GIOA, GEB ~func(E) GIOB, GIOA ~func() A, GIOB ~func()
 }
 
 func Map[GEA ~func(E) GIOA, GEB ~func(E) GIOB, GIOA ~func() A, GIOB ~func() B, E, A, B any](f func(A) B) func(GEA) GEB {
-	return F.Bind2nd(MonadMap[GEA, GEB, GIOA, GIOB, E, A, B], f)
+	return readert.Map[GEA, GEB](IO.Map[GIOA, GIOB, A, B], f)
 }
 
 func MonadChain[GEA ~func(E) GIOA, GEB ~func(E) GIOB, GIOA ~func() A, GIOB ~func() B, E, A, B any](ma GEA, f func(A) GEB) GEB {
@@ -97,7 +97,7 @@ func MonadChainIOK[GEA ~func(E) GIOA, GEB ~func(E) GIOB, GIOA ~func() A, GIOB ~f
 
 func ChainIOK[GEA ~func(E) GIOA, GEB ~func(E) GIOB, GIOA ~func() A, GIOB ~func() B, E, A, B any](f func(A) GIOB) func(GEA) GEB {
 	return FIO.ChainIOK(
-		MonadChain[GEA, GEB],
+		Chain[GEA, GEB],
 		FromIO[GEB],
 		f,
 	)
@@ -114,8 +114,8 @@ func MonadChainFirstIOK[GEA ~func(E) GIOA, GEB ~func(E) GIOB, GIOA ~func() A, GI
 
 func ChainFirstIOK[GEA ~func(E) GIOA, GEB ~func(E) GIOB, GIOA ~func() A, GIOB ~func() B, E, A, B any](f func(A) GIOB) func(GEA) GEA {
 	return FIO.ChainFirstIOK(
-		MonadChain[GEA, GEA],
-		MonadMap[GEB, GEA],
+		Chain[GEA, GEA],
+		Map[GEB, GEA],
 		FromIO[GEB],
 		f,
 	)
@@ -162,5 +162,5 @@ func MonadFlap[GEFAB ~func(E) GIOFAB, GEB ~func(E) GIOB, GIOFAB ~func() func(A)
 }
 
 func Flap[GEFAB ~func(E) GIOFAB, GEB ~func(E) GIOB, GIOFAB ~func() func(A) B, GIOB ~func() B, E, A, B any](a A) func(GEFAB) GEB {
-	return FC.Flap(MonadMap[GEFAB, GEB], a)
+	return FC.Flap(Map[GEFAB, GEB], a)
 }

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

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[context.Context, error, string] {
+	return Of[context.Context, error]("Doe")
+}
+
+func getGivenName(s utils.WithLastName) ReaderIOEither[context.Context, error, string] {
+	return Of[context.Context, error]("John")
+}
+
+func TestBind(t *testing.T) {
+
+	res := F.Pipe3(
+		Do[context.Context, error](utils.Empty),
+		Bind(utils.SetLastName, getLastName),
+		Bind(utils.SetGivenName, getGivenName),
+		Map[context.Context, error](utils.GetFullName),
+	)
+
+	assert.Equal(t, res(context.Background())(), E.Of[error]("John Doe"))
+}
+
+func TestApS(t *testing.T) {
+
+	res := F.Pipe3(
+		Do[context.Context, error](utils.Empty),
+		ApS(utils.SetLastName, Of[context.Context, error]("Doe")),
+		ApS(utils.SetGivenName, Of[context.Context, error]("John")),
+		Map[context.Context, error](utils.GetFullName),
+	)
+
+	assert.Equal(t, res(context.Background())(), E.Of[error]("John Doe"))
+}

readerioeither/eq.go

@@ -26,7 +26,7 @@ func Eq[R, E, A any](eq EQ.Eq[ET.Either[E, A]]) func(R) EQ.Eq[ReaderIOEither[R,
 	return G.Eq[ReaderIOEither[R, E, A]](eq)
 }
 
-// FromStrictEquals constructs an `Eq` from the canonical comparison function
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
 func FromStrictEquals[R, E, A comparable]() func(R) EQ.Eq[ReaderIOEither[R, E, A]] {
 	return G.FromStrictEquals[ReaderIOEither[R, E, A]]()
 }

readerioeither/generic/bind.go

@@ -0,0 +1,90 @@
+// 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 (
+	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(R) GS, GS ~func() ET.Either[E, S], R, E, S any](
+	empty S,
+) GRS {
+	return Of[GRS, GS, R, E, S](empty)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[GRS1 ~func(R) GS1, GRS2 ~func(R) GS2, GRT ~func(R) GT, GS1 ~func() ET.Either[E, S1], GS2 ~func() ET.Either[E, S2], GT ~func() ET.Either[E, T], R, E, 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, R, E, S1, S2],
+		Map[GRT, GRS2, GT, GS2, R, E, T, S2],
+		setter,
+		f,
+	)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[GRS1 ~func(R) GS1, GRS2 ~func(R) GS2, GS1 ~func() ET.Either[E, S1], GS2 ~func() ET.Either[E, S2], R, E, 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, R, E, S1, S2],
+		key,
+		f,
+	)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[GRS1 ~func(R) GS1, GRS2 ~func(R) GS2, GS1 ~func() ET.Either[E, S1], GS2 ~func() ET.Either[E, S2], R, E, S1, S2, B any](
+	key func(B) func(S1) S2,
+	b B,
+) func(GRS1) GRS2 {
+	return F.LetTo(
+		Map[GRS1, GRS2, GS1, GS2, R, E, S1, S2],
+		key,
+		b,
+	)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[GRS1 ~func(R) GS1, GRT ~func(R) GT, GS1 ~func() ET.Either[E, S1], GT ~func() ET.Either[E, T], R, E, S1, T any](
+	setter func(T) S1,
+) func(GRT) GRS1 {
+	return C.BindTo(
+		Map[GRT, GRS1, GT, GS1, R, 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[GRTS1 ~func(R) GTS1, GRS1 ~func(R) GS1, GRS2 ~func(R) GS2, GRT ~func(R) GT, GTS1 ~func() ET.Either[E, func(T) S2], GS1 ~func() ET.Either[E, S1], GS2 ~func() ET.Either[E, S2], GT ~func() ET.Either[E, T], R, E, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa GRT,
+) func(GRS1) GRS2 {
+	return A.ApS(
+		Ap[GRT, GRS2, GRTS1, GT, GS2, GTS1, R, E, T, S2],
+		Map[GRS1, GRTS1, GS1, GTS1, R, E, S1, func(T) S2],
+		setter,
+		fa,
+	)
+}

readerioeither/generic/eq.go

@@ -26,7 +26,7 @@ func Eq[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](eq EQ.Eq[E
 	return G.Eq[GEA](eq)
 }
 
-// FromStrictEquals constructs an `Eq` from the canonical comparison function
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
 func FromStrictEquals[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R any, E, A comparable]() func(R) EQ.Eq[GEA] {
 	return Eq[GEA](ET.FromStrictEquals[E, A]())
 }

readerioeither/generic/reader.go

@@ -405,7 +405,7 @@ func MonadBiMap[GA ~func(R) GE1A, GB ~func(R) GE2B, GE1A ~func() ET.Either[E1, A
 
 // BiMap maps a pair of functions over the two type arguments of the bifunctor.
 func BiMap[GA ~func(R) GE1A, GB ~func(R) GE2B, GE1A ~func() ET.Either[E1, A], GE2B ~func() ET.Either[E2, B], R, E1, E2, A, B any](f func(E1) E2, g func(A) B) func(GA) GB {
-	return eithert.BiMap(G.MonadMap[GA, GB, GE1A, GE2B, R, ET.Either[E1, A], ET.Either[E2, B]], f, g)
+	return eithert.BiMap(G.Map[GA, GB, GE1A, GE2B, R, ET.Either[E1, A], ET.Either[E2, B]], f, g)
 }
 
 // Swap changes the order of type parameters
@@ -438,5 +438,14 @@ func MonadFlap[GREAB ~func(R) GEAB, GREB ~func(R) GEB, GEAB ~func() ET.Either[E,
 }
 
 func Flap[GREAB ~func(R) GEAB, GREB ~func(R) GEB, GEAB ~func() ET.Either[E, func(A) B], GEB ~func() ET.Either[E, B], R, E, B, A any](a A) func(GREAB) GREB {
-	return FC.Flap(MonadMap[GREAB, GREB], a)
+	return FC.Flap(Map[GREAB, GREB], a)
+}
+
+func MonadMapLeft[GREA1 ~func(R) GEA1, GREA2 ~func(R) GEA2, GEA1 ~func() ET.Either[E1, A], GEA2 ~func() ET.Either[E2, A], R, E1, E2, A any](fa GREA1, f func(E1) E2) GREA2 {
+	return eithert.MonadMapLeft(G.MonadMap[GREA1, GREA2], fa, f)
+}
+
+// MapLeft applies a mapping function to the error channel
+func MapLeft[GREA1 ~func(R) GEA1, GREA2 ~func(R) GEA2, GEA1 ~func() ET.Either[E1, A], GEA2 ~func() ET.Either[E2, A], R, E1, E2, A any](f func(E1) E2) func(GREA1) GREA2 {
+	return F.Bind2nd(MonadMapLeft[GREA1, GREA2], f)
 }

readerioeither/reader.go

@@ -280,3 +280,12 @@ func MonadFlap[R, E, B, A any](fab ReaderIOEither[R, E, func(A) B], a A) ReaderI
 func Flap[R, E, B, A any](a A) func(ReaderIOEither[R, E, func(A) B]) ReaderIOEither[R, E, B] {
 	return G.Flap[ReaderIOEither[R, E, func(A) B], ReaderIOEither[R, E, B]](a)
 }
+
+func MonadMapLeft[R, E1, E2, A any](fa ReaderIOEither[R, E1, A], f func(E1) E2) ReaderIOEither[R, E2, A] {
+	return G.MonadMapLeft[ReaderIOEither[R, E1, A], ReaderIOEither[R, E2, A]](fa, f)
+}
+
+// MapLeft applies a mapping function to the error channel
+func MapLeft[R, A, E1, E2 any](f func(E1) E2) func(ReaderIOEither[R, E1, A]) ReaderIOEither[R, E2, A] {
+	return G.MapLeft[ReaderIOEither[R, E1, A], ReaderIOEither[R, E2, A]](f)
+}

record/bind.go

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

record/generic/bind.go

@@ -0,0 +1,86 @@
+// 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"
+	Mo "github.com/IBM/fp-go/monoid"
+)
+
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[GS ~map[K]S, K comparable, S any]() GS {
+	return Empty[GS, K, S]()
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[GS1 ~map[K]S1, GS2 ~map[K]S2, GT ~map[K]T, K comparable, S1, S2, T any](m Mo.Monoid[GS2]) func(setter func(T) func(S1) S2, f func(S1) GT) func(GS1) GS2 {
+	c := Chain[GS1, GS2, K, S1, S2](m)
+	return func(setter func(T) func(S1) S2, f func(S1) GT) func(GS1) GS2 {
+		return C.Bind(
+			c,
+			Map[GT, GS2, K, T, S2],
+			setter,
+			f,
+		)
+	}
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[GS1 ~map[K]S1, GS2 ~map[K]S2, K comparable, S1, S2, T any](
+	key func(T) func(S1) S2,
+	f func(S1) T,
+) func(GS1) GS2 {
+	return F.Let(
+		Map[GS1, GS2, K, S1, S2],
+		key,
+		f,
+	)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[GS1 ~map[K]S1, GS2 ~map[K]S2, K comparable, S1, S2, B any](
+	key func(B) func(S1) S2,
+	b B,
+) func(GS1) GS2 {
+	return F.LetTo(
+		Map[GS1, GS2, K, S1, S2],
+		key,
+		b,
+	)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[GS1 ~map[K]S1, GT ~map[K]T, K comparable, S1, T any](setter func(T) S1) func(GT) GS1 {
+	return C.BindTo(
+		Map[GT, GS1, K, 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 ~map[K]S1, GS2 ~map[K]S2, GT ~map[K]T, K comparable, S1, S2, T any](m Mo.Monoid[GS2]) func(setter func(T) func(S1) S2, fa GT) func(GS1) GS2 {
+	a := Ap[GS2, map[K]func(T) S2, GT, K, S2, T](m)
+	return func(setter func(T) func(S1) S2, fa GT) func(GS1) GS2 {
+		return A.ApS(
+			a,
+			Map[GS1, map[K]func(T) S2, K, S1, func(T) S2],
+			setter,
+			fa,
+		)
+	}
+}

record/generic/record.go

@@ -132,6 +132,18 @@ func ReduceRefWithIndex[M ~map[K]V, K comparable, V, R any](f func(K, R, *V) R,
 	}
 }
 
+func MonadAp[BS ~map[K]B, ABS ~map[K]func(A) B, AS ~map[K]A, K comparable, B, A any](m Mo.Monoid[BS], fab ABS, fa AS) BS {
+	return MonadChain(m, fab, F.Bind1st(MonadMap[AS, BS, K, A, B], fa))
+}
+
+func Ap[BS ~map[K]B, ABS ~map[K]func(A) B, AS ~map[K]A, K comparable, B, A any](m Mo.Monoid[BS]) func(fa AS) func(ABS) BS {
+	return func(ma AS) func(ABS) BS {
+		return func(abs ABS) BS {
+			return MonadAp(m, abs, ma)
+		}
+	}
+}
+
 func MonadMap[M ~map[K]V, N ~map[K]R, K comparable, V, R any](r M, f func(V) R) N {
 	return MonadMapWithIndex[M, N](r, F.Ignore1of2[K](f))
 }
@@ -586,7 +598,7 @@ func MonadFlap[GFAB ~map[K]func(A) B, GB ~map[K]B, K comparable, A, B any](fab G
 }
 
 func Flap[GFAB ~map[K]func(A) B, GB ~map[K]B, K comparable, A, B any](a A) func(GFAB) GB {
-	return FC.Flap(MonadMap[GFAB, GB], a)
+	return FC.Flap(Map[GFAB, GB], a)
 }
 
 func Copy[M ~map[K]V, K comparable, V any](m M) M {

record/record.go

@@ -333,3 +333,11 @@ func FromArray[
 	V any](m Mg.Magma[V]) func(fa []T.Tuple2[K, V]) map[K]V {
 	return G.FromArray[[]T.Tuple2[K, V], map[K]V](m)
 }
+
+func MonadAp[A any, K comparable, B any](m Mo.Monoid[map[K]B], fab map[K]func(A) B, fa map[K]A) map[K]B {
+	return G.MonadAp[map[K]B, map[K]func(A) B, map[K]A](m, fab, fa)
+}
+
+func Ap[A any, K comparable, B any](m Mo.Monoid[map[K]B]) func(fa map[K]A) func(map[K]func(A) B) map[K]B {
+	return G.Ap[map[K]B, map[K]func(A) B, map[K]A](m)
+}

samples/getting-started-with-fp-ts/reader/example1/reader_test.go

@@ -0,0 +1,75 @@
+// 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 example1 implements the first example in [https://dev.to/gcanti/getting-started-with-fp-ts-reader-1ie5]
+package example1
+
+import (
+	"fmt"
+
+	F "github.com/IBM/fp-go/function"
+	N "github.com/IBM/fp-go/number"
+	I "github.com/IBM/fp-go/number/integer"
+	"github.com/IBM/fp-go/ord"
+	R "github.com/IBM/fp-go/reader"
+	S "github.com/IBM/fp-go/string"
+)
+
+type (
+	I18n struct {
+		True  string
+		False string
+	}
+
+	Dependencies struct {
+		I18n I18n
+	}
+)
+
+var (
+	// g: func(int) R.Reader[*Dependencies, string], note how the implementation does not depend on the dependencies
+	g = F.Flow2(
+		ord.Gt(I.Ord)(2),
+		f,
+	)
+
+	// h: func(string) R.Reader[*Dependencies, string], note how the implementation does not depend on the dependencies
+	h = F.Flow3(
+		S.Size,
+		N.Add(1),
+		g,
+	)
+)
+
+func f(b bool) R.Reader[*Dependencies, string] {
+	return func(deps *Dependencies) string {
+		if b {
+			return deps.I18n.True
+		}
+		return deps.I18n.False
+	}
+}
+
+func ExampleReader() {
+
+	deps := Dependencies{I18n: I18n{True: "vero", False: "falso"}}
+
+	fmt.Println(h("foo")(&deps))
+	fmt.Println(h("a")(&deps))
+
+	// Output:
+	// vero
+	// falso
+}

samples/getting-started-with-fp-ts/reader/example2/reader_test.go

@@ -0,0 +1,97 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package example2 implements the second example in [https://dev.to/gcanti/getting-started-with-fp-ts-reader-1ie5]
+package example2
+
+import (
+	"fmt"
+
+	F "github.com/IBM/fp-go/function"
+	ID "github.com/IBM/fp-go/identity"
+	N "github.com/IBM/fp-go/number"
+	I "github.com/IBM/fp-go/number/integer"
+	"github.com/IBM/fp-go/ord"
+	R "github.com/IBM/fp-go/reader"
+	S "github.com/IBM/fp-go/string"
+)
+
+type (
+	I18n struct {
+		True  string
+		False string
+	}
+
+	Dependencies struct {
+		I18n       I18n
+		LowerBound int
+	}
+)
+
+var (
+	// h: func(string) R.Reader[*Dependencies, string], note how the implementation does not depend on the dependencies
+	h = F.Flow3(
+		S.Size,
+		N.Add(1),
+		g,
+	)
+)
+
+func getLowerBound(deps *Dependencies) int {
+	return deps.LowerBound
+}
+
+func g(n int) R.Reader[*Dependencies, string] {
+	return F.Pipe1(
+		R.Ask[*Dependencies](),
+		R.Chain(F.Flow4(
+			getLowerBound,
+			ord.Gt(I.Ord),
+			ID.Flap[bool](n),
+			f,
+		)),
+	)
+}
+
+func f(b bool) R.Reader[*Dependencies, string] {
+	return func(deps *Dependencies) string {
+		if b {
+			return deps.I18n.True
+		}
+		return deps.I18n.False
+	}
+}
+
+func ExampleReader() {
+
+	deps1 := Dependencies{I18n: I18n{True: "vero", False: "falso"}, LowerBound: 2}
+
+	hFoo := h("foo")
+	hA := h("a")
+
+	fmt.Println(hFoo(&deps1))
+	fmt.Println(hA(&deps1))
+
+	deps2 := Dependencies{I18n: I18n{True: "vero", False: "falso"}, LowerBound: 4}
+
+	fmt.Println(hFoo(&deps2))
+	fmt.Println(hA(&deps2))
+
+	// Output:
+	// vero
+	// falso
+	// falso
+	// falso
+}

samples/readerioeither/example1/reader_test.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 example1
+
+import (
+	"os"
+
+	B "github.com/IBM/fp-go/bytes"
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	I "github.com/IBM/fp-go/identity"
+	IOE "github.com/IBM/fp-go/ioeither"
+	J "github.com/IBM/fp-go/json"
+	RIOE "github.com/IBM/fp-go/readerioeither"
+)
+
+type (
+	WriterType = func([]byte) IOE.IOEither[error, []byte]
+
+	Dependencies struct {
+		Writer WriterType
+	}
+)
+
+func getWriter(deps *Dependencies) WriterType {
+	return deps.Writer
+}
+
+// SerializeToWriter marshals the input to JSON and persists the result via the [Writer] passed in via the [*Dependencies]
+func SerializeToWriter[A any](data A) RIOE.ReaderIOEither[*Dependencies, error, []byte] {
+	return F.Pipe1(
+		RIOE.Ask[*Dependencies, error](),
+		RIOE.ChainIOEitherK[*Dependencies](F.Flow2(
+			getWriter,
+			F.Pipe2(
+				data,
+				J.Marshal[A],
+				E.Fold(F.Flow2(
+					IOE.Left[[]byte, error],
+					F.Constant1[WriterType, IOE.IOEither[error, []byte]],
+				), I.Ap[IOE.IOEither[error, []byte], []byte]),
+			),
+		)),
+	)
+}
+
+func ExampleReaderIOEither() {
+
+	// writeToStdOut implements a writer to stdout
+	writeToStdOut := func(data []byte) IOE.IOEither[error, []byte] {
+		return IOE.TryCatchError(func() ([]byte, error) {
+			_, err := os.Stdout.Write(data)
+			return data, err
+		})
+	}
+
+	deps := Dependencies{
+		Writer: writeToStdOut,
+	}
+
+	data := map[string]string{
+		"a": "b",
+		"c": "d",
+	}
+
+	// writeData will persist to a configurable target
+	writeData := F.Pipe1(
+		SerializeToWriter(data),
+		RIOE.Map[*Dependencies, error](B.ToString),
+	)
+
+	_ = writeData(&deps)()
+
+	// Output:
+	// {"a":"b","c":"d"}
+}

string/string.go

@@ -32,6 +32,9 @@ var (
 
 	// Ord implements the default ordering for strings
 	Ord = ord.FromStrictCompare[string]()
+
+	// Join joins strings
+	Join = F.Curry2(F.Bind2nd[[]string, string, string])(strings.Join)
 )
 
 func Eq(left string, right string) bool {

string/string_test.go

@@ -18,6 +18,7 @@ package string
 import (
 	"testing"
 
+	A "github.com/IBM/fp-go/array"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -25,3 +26,13 @@ func TestEmpty(t *testing.T) {
 	assert.True(t, IsEmpty(""))
 	assert.False(t, IsEmpty("Carsten"))
 }
+
+func TestJoin(t *testing.T) {
+
+	x := Join(",")(A.From("a", "b", "c"))
+	assert.Equal(t, x, x)
+
+	assert.Equal(t, "a,b,c", Join(",")(A.From("a", "b", "c")))
+	assert.Equal(t, "a", Join(",")(A.From("a")))
+	assert.Equal(t, "", Join(",")(A.Empty[string]()))
+}

writer/bind.go

@@ -0,0 +1,65 @@
+// 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 writer
+
+import (
+	M "github.com/IBM/fp-go/monoid"
+	G "github.com/IBM/fp-go/writer/generic"
+)
+
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[S, W any](m M.Monoid[W]) func(S) Writer[W, S] {
+	return G.Do[Writer[W, S], W, S](m)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[S1, S2, T, W any](
+	setter func(T) func(S1) S2,
+	f func(S1) Writer[W, T],
+) func(Writer[W, S1]) Writer[W, S2] {
+	return G.Bind[Writer[W, S1], Writer[W, S2], Writer[W, T], W, S1, S2, T](setter, f)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[W, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) T,
+) func(Writer[W, S1]) Writer[W, S2] {
+	return G.Let[Writer[W, S1], Writer[W, S2], W, S1, S2, T](setter, f)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[W, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	b T,
+) func(Writer[W, S1]) Writer[W, S2] {
+	return G.LetTo[Writer[W, S1], Writer[W, S2], W, S1, S2, T](setter, b)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[W, S1, T any](
+	setter func(T) S1,
+) func(Writer[W, T]) Writer[W, S1] {
+	return G.BindTo[Writer[W, S1], Writer[W, T], W, 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, W any](
+	setter func(T) func(S1) S2,
+	fa Writer[W, T],
+) func(Writer[W, S1]) Writer[W, S2] {
+	return G.ApS[Writer[W, S1], Writer[W, S2], Writer[W, T], W, S1, S2, T](setter, fa)
+}

writer/bind_test.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 writer
+
+import (
+	"testing"
+
+	A "github.com/IBM/fp-go/array"
+	EQ "github.com/IBM/fp-go/eq"
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/utils"
+	M "github.com/IBM/fp-go/monoid"
+	"github.com/stretchr/testify/assert"
+)
+
+var (
+	monoid = A.Monoid[string]()
+	sg     = M.ToSemigroup(monoid)
+
+	eq = Eq(A.Eq[string](EQ.FromStrictEquals[string]()), EQ.FromStrictEquals[string]())
+)
+
+func getLastName(s utils.Initial) Writer[[]string, string] {
+	return Of[string](monoid)("Doe")
+}
+
+func getGivenName(s utils.WithLastName) Writer[[]string, string] {
+	return Of[string](monoid)("John")
+}
+
+func TestBind(t *testing.T) {
+
+	res := F.Pipe3(
+		Do[utils.Initial](monoid)(utils.Empty),
+		Bind(utils.SetLastName, getLastName),
+		Bind(utils.SetGivenName, getGivenName),
+		Map[[]string](utils.GetFullName),
+	)
+
+	assert.True(t, eq.Equals(res, Of[string](monoid)("John Doe")))
+}
+
+func TestApS(t *testing.T) {
+
+	res := F.Pipe3(
+		Do[utils.Initial](monoid)(utils.Empty),
+		ApS(utils.SetLastName, Of[string](monoid)("Doe")),
+		ApS(utils.SetGivenName, Of[string](monoid)("John")),
+		Map[[]string](utils.GetFullName),
+	)
+
+	assert.True(t, eq.Equals(res, Of[string](monoid)("John Doe")))
+}

writer/eq.go

@@ -25,7 +25,7 @@ func Eq[W, A any](w EQ.Eq[W], a EQ.Eq[A]) EQ.Eq[Writer[W, A]] {
 	return G.Eq[Writer[W, A]](w, a)
 }
 
-// FromStrictEquals constructs an `Eq` from the canonical comparison function
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
 func FromStrictEquals[W, A comparable]() EQ.Eq[Writer[W, A]] {
 	return G.FromStrictEquals[Writer[W, A]]()
 }

writer/generic/bind.go

@@ -0,0 +1,90 @@
+// 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 (
+	"github.com/IBM/fp-go/internal/apply"
+	C "github.com/IBM/fp-go/internal/chain"
+	F "github.com/IBM/fp-go/internal/functor"
+	M "github.com/IBM/fp-go/monoid"
+	SG "github.com/IBM/fp-go/semigroup"
+	T "github.com/IBM/fp-go/tuple"
+)
+
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[GS ~func() T.Tuple3[S, W, SG.Semigroup[W]], W, S any](m M.Monoid[W]) func(S) GS {
+	return Of[GS, W, S](m)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[GS1 ~func() T.Tuple3[S1, W, SG.Semigroup[W]], GS2 ~func() T.Tuple3[S2, W, SG.Semigroup[W]], GT ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, S1, S2, A any](
+	setter func(A) func(S1) S2,
+	f func(S1) GT,
+) func(GS1) GS2 {
+	return C.Bind(
+		Chain[GS2, GS1, func(S1) GS2, W, S1, S2],
+		Map[GS2, GT, func(A) S2, W, A, S2],
+		setter,
+		f,
+	)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[GS1 ~func() T.Tuple3[S1, W, SG.Semigroup[W]], GS2 ~func() T.Tuple3[S2, W, SG.Semigroup[W]], W, S1, S2, A any](
+	key func(A) func(S1) S2,
+	f func(S1) A,
+) func(GS1) GS2 {
+	return F.Let(
+		Map[GS2, GS1, func(S1) S2, W, S1, S2],
+		key,
+		f,
+	)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[GS1 ~func() T.Tuple3[S1, W, SG.Semigroup[W]], GS2 ~func() T.Tuple3[S2, W, SG.Semigroup[W]], W, S1, S2, B any](
+	key func(B) func(S1) S2,
+	b B,
+) func(GS1) GS2 {
+	return F.LetTo(
+		Map[GS2, GS1, func(S1) S2, W, S1, S2],
+		key,
+		b,
+	)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[GS1 ~func() T.Tuple3[S1, W, SG.Semigroup[W]], GT ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, S1, A any](
+	setter func(A) S1,
+) func(GT) GS1 {
+	return C.BindTo(
+		Map[GS1, GT, func(A) S1, W, A, 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 ~func() T.Tuple3[S1, W, SG.Semigroup[W]], GS2 ~func() T.Tuple3[S2, W, SG.Semigroup[W]], GT ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, S1, S2, A any](
+	setter func(A) func(S1) S2,
+	fa GT,
+) func(GS1) GS2 {
+	return apply.ApS(
+		Ap[GS2, func() T.Tuple3[func(A) S2, W, SG.Semigroup[W]], GT, W, A, S2],
+		Map[func() T.Tuple3[func(A) S2, W, SG.Semigroup[W]], GS1, func(S1) func(A) S2],
+		setter,
+		fa,
+	)
+}

writer/generic/eq.go

@@ -17,11 +17,12 @@ package generic
 
 import (
 	EQ "github.com/IBM/fp-go/eq"
+	SG "github.com/IBM/fp-go/semigroup"
 	T "github.com/IBM/fp-go/tuple"
 )
 
 // Constructs an equal predicate for a [Writer]
-func Eq[GA ~func() T.Tuple2[A, W], W, A any](w EQ.Eq[W], a EQ.Eq[A]) EQ.Eq[GA] {
+func Eq[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A any](w EQ.Eq[W], a EQ.Eq[A]) EQ.Eq[GA] {
 	return EQ.FromEquals(func(l, r GA) bool {
 		ll := l()
 		rr := r()
@@ -30,7 +31,7 @@ func Eq[GA ~func() T.Tuple2[A, W], W, A any](w EQ.Eq[W], a EQ.Eq[A]) EQ.Eq[GA] {
 	})
 }
 
-// FromStrictEquals constructs an `Eq` from the canonical comparison function
-func FromStrictEquals[GA ~func() T.Tuple2[A, W], W, A comparable]() EQ.Eq[GA] {
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
+func FromStrictEquals[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A comparable]() EQ.Eq[GA] {
 	return Eq[GA](EQ.FromStrictEquals[W](), EQ.FromStrictEquals[A]())
 }

writer/generic/writer.go

@@ -17,105 +17,137 @@ package generic
 
 import (
 	F "github.com/IBM/fp-go/function"
+	C "github.com/IBM/fp-go/internal/chain"
+	FC "github.com/IBM/fp-go/internal/functor"
 	IO "github.com/IBM/fp-go/io/generic"
 	M "github.com/IBM/fp-go/monoid"
-	S "github.com/IBM/fp-go/semigroup"
+	SG "github.com/IBM/fp-go/semigroup"
 	T "github.com/IBM/fp-go/tuple"
 )
 
-func Of[GA ~func() T.Tuple2[A, W], W, A any](m M.Monoid[W]) func(A) GA {
+func Tell[GA ~func() T.Tuple3[any, W, SG.Semigroup[W]], W any](s SG.Semigroup[W]) func(W) GA {
 	return F.Flow2(
-		F.Bind2nd(T.MakeTuple2[A, W], m.Empty()),
+		F.Bind13of3(T.MakeTuple3[any, W, SG.Semigroup[W]])(nil, s),
 		IO.Of[GA],
 	)
 }
 
-func MonadMap[GB ~func() T.Tuple2[B, W], GA ~func() T.Tuple2[A, W], FCT ~func(A) B, W, A, B any](fa GA, f FCT) GB {
-	return IO.MonadMap[GA, GB](fa, T.Map2(f, F.Identity[W]))
+func Of[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A any](m M.Monoid[W]) func(A) GA {
+	return F.Flow2(
+		F.Bind23of3(T.MakeTuple3[A, W, SG.Semigroup[W]])(m.Empty(), M.ToSemigroup(m)),
+		IO.Of[GA],
+	)
 }
 
-func Map[GB ~func() T.Tuple2[B, W], GA ~func() T.Tuple2[A, W], FCT ~func(A) B, W, A, B any](f FCT) func(GA) GB {
-	return IO.Map[GA, GB](T.Map2(f, F.Identity[W]))
-}
-
-func MonadChain[GB ~func() T.Tuple2[B, W], GA ~func() T.Tuple2[A, W], FCT ~func(A) GB, W, A, B any](s S.Semigroup[W]) func(GA, FCT) GB {
-	return func(fa GA, f FCT) GB {
-
-		return func() T.Tuple2[B, W] {
-			a := fa()
-			b := f(a.F1)()
-
-			return T.MakeTuple2(b.F1, s.Concat(a.F2, b.F2))
-		}
+// Listen modifies the result to include the changes to the accumulator
+func Listen[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], GTA ~func() T.Tuple3[T.Tuple2[A, W], W, SG.Semigroup[W]], W, A any](fa GA) GTA {
+	return func() T.Tuple3[T.Tuple2[A, W], W, SG.Semigroup[W]] {
+		t := fa()
+		return T.MakeTuple3(T.MakeTuple2(t.F1, t.F2), t.F2, t.F3)
 	}
 }
 
-func Chain[GB ~func() T.Tuple2[B, W], GA ~func() T.Tuple2[A, W], FCT ~func(A) GB, W, A, B any](s S.Semigroup[W]) func(FCT) func(GA) GB {
-	return F.Curry2(F.Swap(MonadChain[GB, GA, FCT](s)))
-}
-
-func MonadAp[GB ~func() T.Tuple2[B, W], GAB ~func() T.Tuple2[func(A) B, W], GA ~func() T.Tuple2[A, W], W, A, B any](s S.Semigroup[W]) func(GAB, GA) GB {
-	return func(fab GAB, fa GA) GB {
-		return func() T.Tuple2[B, W] {
-			f := fab()
-			a := fa()
-
-			return T.MakeTuple2(f.F1(a.F1), s.Concat(f.F2, a.F2))
-		}
+// Pass applies the returned function to the accumulator
+func Pass[GFA ~func() T.Tuple3[T.Tuple2[A, FCT], W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], FCT ~func(W) W, W, A any](fa GFA) GA {
+	return func() T.Tuple3[A, W, SG.Semigroup[W]] {
+		t := fa()
+		return T.MakeTuple3(t.F1.F1, t.F1.F2(t.F2), t.F3)
 	}
 }
 
-func Ap[GB ~func() T.Tuple2[B, W], GAB ~func() T.Tuple2[func(A) B, W], GA ~func() T.Tuple2[A, W], W, A, B any](s S.Semigroup[W]) func(GA) func(GAB) GB {
-	return F.Curry2(F.Swap(MonadAp[GB, GAB, GA](s)))
+func MonadMap[GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], FCT ~func(A) B, W, A, B any](fa GA, f FCT) GB {
+	return IO.MonadMap[GA, GB](fa, T.Map3(f, F.Identity[W], F.Identity[SG.Semigroup[W]]))
 }
 
-func MonadChainFirst[GB ~func() T.Tuple2[B, W], GA ~func() T.Tuple2[A, W], FCT ~func(A) GB, W, A, B any](s S.Semigroup[W]) func(GA, FCT) GA {
-	chain := MonadChain[GA, GA, func(A) GA](s)
-	return func(ma GA, f FCT) GA {
-		return chain(ma, func(a A) GA {
-			return MonadMap[GA](f(a), F.Constant1[B](a))
-		})
+func Map[GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], FCT ~func(A) B, W, A, B any](f FCT) func(GA) GB {
+	return IO.Map[GA, GB](T.Map3(f, F.Identity[W], F.Identity[SG.Semigroup[W]]))
+}
+
+func MonadChain[GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], FCT ~func(A) GB, W, A, B any](fa GA, f FCT) GB {
+	return func() T.Tuple3[B, W, SG.Semigroup[W]] {
+		a := fa()
+		b := f(a.F1)()
+
+		return T.MakeTuple3(b.F1, b.F3.Concat(a.F2, b.F2), b.F3)
 	}
 }
 
-func ChainFirst[GB ~func() T.Tuple2[B, W], GA ~func() T.Tuple2[A, W], FCT ~func(A) GB, W, A, B any](s S.Semigroup[W]) func(FCT) func(GA) GA {
-	return F.Curry2(F.Swap(MonadChainFirst[GB, GA, FCT](s)))
+func Chain[GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], FCT ~func(A) GB, W, A, B any](f FCT) func(GA) GB {
+	return F.Bind2nd(MonadChain[GB, GA, FCT, W, A, B], f)
 }
 
-func Flatten[GAA ~func() T.Tuple2[GA, W], GA ~func() T.Tuple2[A, W], W, A any](s S.Semigroup[W]) func(GAA) GA {
-	chain := MonadChain[GA, GAA, func(GA) GA](s)
-	return func(mma GAA) GA {
-		return chain(mma, F.Identity[GA])
+func MonadAp[GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], GAB ~func() T.Tuple3[func(A) B, W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A, B any](fab GAB, fa GA) GB {
+	return func() T.Tuple3[B, W, SG.Semigroup[W]] {
+		f := fab()
+		a := fa()
+
+		return T.MakeTuple3(f.F1(a.F1), f.F3.Concat(f.F2, a.F2), f.F3)
 	}
 }
 
-func Execute[GA ~func() T.Tuple2[A, W], W, A any](fa GA) W {
-	return T.Second(fa())
+func Ap[GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], GAB ~func() T.Tuple3[func(A) B, W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A, B any](ga GA) func(GAB) GB {
+	return F.Bind2nd(MonadAp[GB, GAB, GA], ga)
 }
 
-func Evaluate[GA ~func() T.Tuple2[A, W], W, A any](fa GA) A {
-	return T.First(fa())
+func MonadChainFirst[GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], FCT ~func(A) GB, W, A, B any](ma GA, f FCT) GA {
+	return C.MonadChainFirst(
+		MonadChain[GA, GA, func(A) GA],
+		MonadMap[GA, GB, func(B) A],
+		ma,
+		f,
+	)
+}
+
+func ChainFirst[GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], FCT ~func(A) GB, W, A, B any](f FCT) func(GA) GA {
+	return C.ChainFirst(
+		Chain[GA, GA, func(A) GA],
+		Map[GA, GB, func(B) A],
+		f,
+	)
+}
+
+func Flatten[GAA ~func() T.Tuple3[GA, W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A any](mma GAA) GA {
+	return MonadChain[GA, GAA, func(GA) GA](mma, F.Identity[GA])
+}
+
+func Execute[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A any](fa GA) W {
+	return fa().F2
+}
+
+func Evaluate[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A any](fa GA) A {
+	return fa().F1
 }
 
 // MonadCensor modifies the final accumulator value by applying a function
-func MonadCensor[GA ~func() T.Tuple2[A, W], FCT ~func(W) W, W, A any](fa GA, f FCT) GA {
-	return IO.MonadMap[GA, GA](fa, T.Map2(F.Identity[A], f))
+func MonadCensor[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], FCT ~func(W) W, W, A any](fa GA, f FCT) GA {
+	return IO.MonadMap[GA, GA](fa, T.Map3(F.Identity[A], f, F.Identity[SG.Semigroup[W]]))
 }
 
 // Censor modifies the final accumulator value by applying a function
-func Censor[GA ~func() T.Tuple2[A, W], FCT ~func(W) W, W, A any](f FCT) func(GA) GA {
-	return IO.Map[GA, GA](T.Map2(F.Identity[A], f))
+func Censor[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], FCT ~func(W) W, W, A any](f FCT) func(GA) GA {
+	return IO.Map[GA, GA](T.Map3(F.Identity[A], f, F.Identity[SG.Semigroup[W]]))
 }
 
 // MonadListens projects a value from modifications made to the accumulator during an action
-func MonadListens[GA ~func() T.Tuple2[A, W], GAB ~func() T.Tuple2[T.Tuple2[A, B], W], FCT ~func(W) B, W, A, B any](fa GA, f FCT) GAB {
-	return func() T.Tuple2[T.Tuple2[A, B], W] {
+func MonadListens[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], GAB ~func() T.Tuple3[T.Tuple2[A, B], W, SG.Semigroup[W]], FCT ~func(W) B, W, A, B any](fa GA, f FCT) GAB {
+	return func() T.Tuple3[T.Tuple2[A, B], W, SG.Semigroup[W]] {
 		a := fa()
-		return T.MakeTuple2(T.MakeTuple2(a.F1, f(a.F2)), a.F2)
+		return T.MakeTuple3(T.MakeTuple2(a.F1, f(a.F2)), a.F2, a.F3)
 	}
 }
 
 // Listens projects a value from modifications made to the accumulator during an action
-func Listens[GA ~func() T.Tuple2[A, W], GAB ~func() T.Tuple2[T.Tuple2[A, B], W], FCT ~func(W) B, W, A, B any](f FCT) func(GA) GAB {
+func Listens[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], GAB ~func() T.Tuple3[T.Tuple2[A, B], W, SG.Semigroup[W]], FCT ~func(W) B, W, A, B any](f FCT) func(GA) GAB {
 	return F.Bind2nd(MonadListens[GA, GAB, FCT], f)
 }
+
+func MonadFlap[FAB ~func(A) B, GFAB ~func() T.Tuple3[FAB, W, SG.Semigroup[W]], GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], W, A, B any](fab GFAB, a A) GB {
+	return FC.MonadFlap(
+		MonadMap[GB, GFAB, func(FAB) B],
+		fab,
+		a)
+}
+
+func Flap[FAB ~func(A) B, GFAB ~func() T.Tuple3[FAB, W, SG.Semigroup[W]], GB ~func() T.Tuple3[B, W, SG.Semigroup[W]], W, A, B any](a A) func(GFAB) GB {
+	return FC.Flap(Map[GB, GFAB, func(FAB) B], a)
+}