Merge pull request #72 from IBM/cleue-improve-with-lock

Cleanup Either, context.Reader and context.ReaderIO
fix: remove Reader and ReaderEither for context since they do not make sense
2025-09-03 20:06:08 +02:00 · 2023-10-23 09:06:22 +02:00 · 2023-10-23 09:05:10 +02:00 · 2023-10-23 08:36:32 +02:00 · 2023-10-22 21:08:06 +02:00 · 2023-10-22 21:07:40 +02:00
71 changed files with 11738 additions and 12290 deletions
--- a/cli/either.go
+++ b/cli/either.go
@@ -115,16 +115,14 @@ func generateEitherize(f *os.File, i int) {
 		fmt.Fprintf(f, "t%d T%d", j, j)
 	}
 	fmt.Fprintf(f, ") Either[error, R] {\n")
-	fmt.Fprintf(f, "    return TryCatchError(func() (R, error) {\n")
-	fmt.Fprintf(f, "      return f(")
+	fmt.Fprintf(f, "    return TryCatchError(f(")
 	for j := 0; j < i; j++ {
 		if j > 0 {
 			fmt.Fprintf(f, ", ")
 		}
 		fmt.Fprintf(f, "t%d", j)
 	}
-	fmt.Fprintln(f, ")")
-	fmt.Fprintln(f, "    })")
+	fmt.Fprintln(f, "))")
 	fmt.Fprintln(f, "  }")
 	fmt.Fprintln(f, "}")
 }
--- a/context/ioeither/generic/ioeither.go
+++ b/context/ioeither/generic/ioeither.go
@@ -19,15 +19,14 @@ import (
 	"context"

 	E "github.com/IBM/fp-go/either"
-	ET "github.com/IBM/fp-go/either"
 	IOE "github.com/IBM/fp-go/ioeither/generic"
 )

-// withContext wraps an existing IOEither and performs a context check for cancellation before delegating
+// WithContext wraps an existing IOEither and performs a context check for cancellation before delegating
 func WithContext[GIO ~func() E.Either[error, A], A any](ctx context.Context, ma GIO) GIO {
 	return IOE.MakeIO[GIO](func() E.Either[error, A] {
 		if err := context.Cause(ctx); err != nil {
-			return ET.Left[A](err)
+			return E.Left[A](err)
 		}
 		return ma()
 	})
--- a/context/reader/array.go
+++ b/context/reader/array.go
@@ -1,35 +0,0 @@
-//   Copyright (c) 2023 IBM Corp.
-//   All rights reserved.
-//
-//   Licensed under the Apache License, Version 2.0 (the "License");
-//   you may not use this file except in compliance with the License.
-//   You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-//   Unless required by applicable law or agreed to in writing, software
-//   distributed under the License is distributed on an "AS IS" BASIS,
-//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//   See the License for the specific language governing permissions and
-//   limitations under the License.
-
-package reader
-
-import (
-	R "github.com/IBM/fp-go/reader/generic"
-)
-
-// TraverseArray transforms an array
-func TraverseArray[A, B any](f func(A) Reader[B]) func([]A) Reader[[]B] {
-	return R.TraverseArray[Reader[B], Reader[[]B], []A](f)
-}
-
-// TraverseArrayWithIndex transforms an array
-func TraverseArrayWithIndex[A, B any](f func(int, A) Reader[B]) func([]A) Reader[[]B] {
-	return R.TraverseArrayWithIndex[Reader[B], Reader[[]B], []A](f)
-}
-
-// SequenceArray converts a homogeneous sequence of either into an either of sequence
-func SequenceArray[A any](ma []Reader[A]) Reader[[]A] {
-	return R.SequenceArray[Reader[A], Reader[[]A]](ma)
-}
--- a/context/reader/curry.go
+++ b/context/reader/curry.go
@@ -1,53 +0,0 @@
-//   Copyright (c) 2023 IBM Corp.
-//   All rights reserved.
-//
-//   Licensed under the Apache License, Version 2.0 (the "License");
-//   you may not use this file except in compliance with the License.
-//   You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-//   Unless required by applicable law or agreed to in writing, software
-//   distributed under the License is distributed on an "AS IS" BASIS,
-//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//   See the License for the specific language governing permissions and
-//   limitations under the License.
-
-package reader
-
-import (
-	"context"
-
-	R "github.com/IBM/fp-go/reader/generic"
-)
-
-// these functions curry a golang function with the context as the firsr parameter into a either reader with the context as the last parameter
-// this goes back to the advice in https://pkg.go.dev/context to put the context as a first parameter as a convention
-
-func Curry0[A any](f func(context.Context) A) Reader[A] {
-	return R.Curry0[Reader[A]](f)
-}
-
-func Curry1[T1, A any](f func(context.Context, T1) A) func(T1) Reader[A] {
-	return R.Curry1[Reader[A]](f)
-}
-
-func Curry2[T1, T2, A any](f func(context.Context, T1, T2) A) func(T1) func(T2) Reader[A] {
-	return R.Curry2[Reader[A]](f)
-}
-
-func Curry3[T1, T2, T3, A any](f func(context.Context, T1, T2, T3) A) func(T1) func(T2) func(T3) Reader[A] {
-	return R.Curry3[Reader[A]](f)
-}
-
-func Uncurry1[T1, A any](f func(T1) Reader[A]) func(context.Context, T1) A {
-	return R.Uncurry1(f)
-}
-
-func Uncurry2[T1, T2, A any](f func(T1) func(T2) Reader[A]) func(context.Context, T1, T2) A {
-	return R.Uncurry2(f)
-}
-
-func Uncurry3[T1, T2, T3, A any](f func(T1) func(T2) func(T3) Reader[A]) func(context.Context, T1, T2, T3) A {
-	return R.Uncurry3(f)
-}
--- a/context/reader/from.go
+++ b/context/reader/from.go
@@ -1,41 +0,0 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package reader
-
-import (
-	"context"
-
-	R "github.com/IBM/fp-go/reader/generic"
-)
-
-// these functions curry a golang function with the context as the firsr parameter into a either reader with the context as the last parameter
-// this goes back to the advice in https://pkg.go.dev/context to put the context as a first parameter as a convention
-
-func From0[A any](f func(context.Context) A) func() Reader[A] {
-	return R.From0[Reader[A]](f)
-}
-
-func From1[T1, A any](f func(context.Context, T1) A) func(T1) Reader[A] {
-	return R.From1[Reader[A]](f)
-}
-
-func From2[T1, T2, A any](f func(context.Context, T1, T2) A) func(T1, T2) Reader[A] {
-	return R.From2[Reader[A]](f)
-}
-
-func From3[T1, T2, T3, A any](f func(context.Context, T1, T2, T3) A) func(T1, T2, T3) Reader[A] {
-	return R.From3[Reader[A]](f)
-}
--- a/context/reader/reader.go
+++ b/context/reader/reader.go
@@ -1,66 +0,0 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package reader
-
-import (
-	"context"
-
-	R "github.com/IBM/fp-go/reader/generic"
-)
-
-func MonadMap[A, B any](fa Reader[A], f func(A) B) Reader[B] {
-	return R.MonadMap[Reader[A], Reader[B]](fa, f)
-}
-
-func Map[A, B any](f func(A) B) func(Reader[A]) Reader[B] {
-	return R.Map[Reader[A], Reader[B]](f)
-}
-
-func MonadChain[A, B any](ma Reader[A], f func(A) Reader[B]) Reader[B] {
-	return R.MonadChain(ma, f)
-}
-
-func Chain[A, B any](f func(A) Reader[B]) func(Reader[A]) Reader[B] {
-	return R.Chain[Reader[A]](f)
-}
-
-func Of[A any](a A) Reader[A] {
-	return R.Of[Reader[A]](a)
-}
-
-func MonadAp[A, B any](fab Reader[func(A) B], fa Reader[A]) Reader[B] {
-	return R.MonadAp[Reader[A], Reader[B]](fab, fa)
-}
-
-func Ap[A, B any](fa Reader[A]) func(Reader[func(A) B]) Reader[B] {
-	return R.Ap[Reader[A], Reader[B], Reader[func(A) B]](fa)
-}
-
-func Ask() Reader[context.Context] {
-	return R.Ask[Reader[context.Context]]()
-}
-
-func Asks[A any](r Reader[A]) Reader[A] {
-	return R.Asks(r)
-}
-
-func MonadFlap[B, A any](fab Reader[func(A) B], a A) Reader[B] {
-	return R.MonadFlap[Reader[func(A) B], Reader[B]](fab, a)
-}
-
-func Flap[B, A any](a A) func(Reader[func(A) B]) Reader[B] {
-	return R.Flap[Reader[func(A) B], Reader[B]](a)
-}
--- a/context/reader/reader_test.go
+++ b/context/reader/reader_test.go
@@ -1,75 +0,0 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package reader
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"testing"
-
-	F "github.com/IBM/fp-go/function"
-	T "github.com/IBM/fp-go/tuple"
-	"github.com/stretchr/testify/assert"
-)
-
-func GoFunction(ctx context.Context, data string) string {
-	return strings.ToUpper(data)
-}
-
-func GoIntFunction(ctx context.Context, data string, number int) string {
-	return fmt.Sprintf("%s: %d", data, number)
-}
-
-func TestReaderFrom(t *testing.T) {
-	ctx := context.Background()
-	f := From1(GoFunction)
-
-	result := f("input")(ctx)
-
-	assert.Equal(t, result, "INPUT")
-
-}
-
-func MyFinalResult(left, right string) string {
-	return fmt.Sprintf("%s-%s", left, right)
-}
-
-func TestReadersFrom(t *testing.T) {
-	ctx := context.Background()
-
-	f1 := From1(GoFunction)
-	f2 := From2(GoIntFunction)
-
-	result1 := f1("input")(ctx)
-	result2 := f2("input", 10)(ctx)
-
-	result3 := MyFinalResult(result1, result2)
-
-	h := F.Pipe1(
-		SequenceT2(f1("input"), f2("input", 10)),
-		Map(T.Tupled2(MyFinalResult)),
-	)
-
-	composedResult := h(ctx)
-
-	assert.Equal(t, result1, "INPUT")
-	assert.Equal(t, result2, "input: 10")
-	assert.Equal(t, result3, "INPUT-input: 10")
-
-	assert.Equal(t, composedResult, "INPUT-input: 10")
-
-}
--- a/context/reader/sequence.go
+++ b/context/reader/sequence.go
@@ -1,57 +0,0 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package reader
-
-import (
-	R "github.com/IBM/fp-go/reader/generic"
-	T "github.com/IBM/fp-go/tuple"
-)
-
-// SequenceT converts n inputs of higher kinded types into a higher kinded types of n strongly typed values, represented as a tuple
-
-func SequenceT1[A any](a Reader[A]) Reader[T.Tuple1[A]] {
-	return R.SequenceT1[
-		Reader[A],
-		Reader[T.Tuple1[A]],
-	](a)
-}
-
-func SequenceT2[A, B any](a Reader[A], b Reader[B]) Reader[T.Tuple2[A, B]] {
-	return R.SequenceT2[
-		Reader[A],
-		Reader[B],
-		Reader[T.Tuple2[A, B]],
-	](a, b)
-}
-
-func SequenceT3[A, B, C any](a Reader[A], b Reader[B], c Reader[C]) Reader[T.Tuple3[A, B, C]] {
-	return R.SequenceT3[
-		Reader[A],
-		Reader[B],
-		Reader[C],
-		Reader[T.Tuple3[A, B, C]],
-	](a, b, c)
-}
-
-func SequenceT4[A, B, C, D any](a Reader[A], b Reader[B], c Reader[C], d Reader[D]) Reader[T.Tuple4[A, B, C, D]] {
-	return R.SequenceT4[
-		Reader[A],
-		Reader[B],
-		Reader[C],
-		Reader[D],
-		Reader[T.Tuple4[A, B, C, D]],
-	](a, b, c, d)
-}
--- a/context/readereither/exec/exec.go
+++ b/context/readereither/exec/exec.go
@@ -34,8 +34,6 @@ var (

 func command(name string, args []string, in []byte) RE.ReaderEither[exec.CommandOutput] {
 	return func(ctx context.Context) E.Either[error, exec.CommandOutput] {
-		return E.TryCatchError(func() (exec.CommandOutput, error) {
-			return GE.Exec(ctx, name, args, in)
-		})
+		return E.TryCatchError(GE.Exec(ctx, name, args, in))
 	}
 }
--- a/context/readereither/reader.go
+++ b/context/readereither/reader.go
@@ -18,7 +18,6 @@ package readereither
 import (
 	"context"

-	R "github.com/IBM/fp-go/context/reader"
 	ET "github.com/IBM/fp-go/either"
 	O "github.com/IBM/fp-go/option"
 	RE "github.com/IBM/fp-go/readereither/generic"
@@ -32,14 +31,6 @@ func FromEither[A any](e ET.Either[error, A]) ReaderEither[A] {
 	return RE.FromEither[ReaderEither[A]](e)
 }

-func RightReader[A any](r R.Reader[A]) ReaderEither[A] {
-	return RE.RightReader[R.Reader[A], ReaderEither[A]](r)
-}
-
-func LeftReader[A any](l R.Reader[error]) ReaderEither[A] {
-	return RE.LeftReader[R.Reader[error], ReaderEither[A]](l)
-}
-
 func Left[A any](l error) ReaderEither[A] {
 	return RE.Left[ReaderEither[A]](l)
 }
@@ -48,10 +39,6 @@ func Right[A any](r A) ReaderEither[A] {
 	return RE.Right[ReaderEither[A]](r)
 }

-func FromReader[A any](r R.Reader[A]) ReaderEither[A] {
-	return RE.FromReader[R.Reader[A], ReaderEither[A]](r)
-}
-
 func MonadMap[A, B any](fa ReaderEither[A], f func(A) B) ReaderEither[B] {
 	return RE.MonadMap[ReaderEither[A], ReaderEither[B]](fa, f)
 }
@@ -84,30 +71,14 @@ func FromPredicate[A any](pred func(A) bool, onFalse func(A) error) func(A) Read
 	return RE.FromPredicate[ReaderEither[A]](pred, onFalse)
 }

-func Fold[A, B any](onLeft func(error) R.Reader[B], onRight func(A) R.Reader[B]) func(ReaderEither[A]) R.Reader[B] {
-	return RE.Fold[ReaderEither[A]](onLeft, onRight)
-}
-
-func GetOrElse[A any](onLeft func(error) R.Reader[A]) func(ReaderEither[A]) R.Reader[A] {
-	return RE.GetOrElse[ReaderEither[A]](onLeft)
-}
-
 func OrElse[A any](onLeft func(error) ReaderEither[A]) func(ReaderEither[A]) ReaderEither[A] {
 	return RE.OrElse[ReaderEither[A]](onLeft)
 }

-func OrLeft[A any](onLeft func(error) R.Reader[error]) func(ReaderEither[A]) ReaderEither[A] {
-	return RE.OrLeft[ReaderEither[A], ReaderEither[A]](onLeft)
-}
-
 func Ask() ReaderEither[context.Context] {
 	return RE.Ask[ReaderEither[context.Context]]()
 }

-func Asks[A any](r R.Reader[A]) ReaderEither[A] {
-	return RE.Asks[R.Reader[A], ReaderEither[A]](r)
-}
-
 func MonadChainEitherK[A, B any](ma ReaderEither[A], f func(A) ET.Either[error, B]) ReaderEither[B] {
 	return RE.MonadChainEitherK[ReaderEither[A], ReaderEither[B]](ma, f)
 }
--- a/context/readerio/array.go
+++ b/context/readerio/array.go
@@ -1,36 +0,0 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package readerio
-
-import (
-	IO "github.com/IBM/fp-go/io"
-	R "github.com/IBM/fp-go/readerio/generic"
-)
-
-// TraverseArray transforms an array
-func TraverseArray[A, B any](f func(A) ReaderIO[B]) func([]A) ReaderIO[[]B] {
-	return R.TraverseArray[ReaderIO[B], ReaderIO[[]B], IO.IO[B], IO.IO[[]B], []A](f)
-}
-
-// TraverseArrayWithIndex transforms an array
-func TraverseArrayWithIndex[A, B any](f func(int, A) ReaderIO[B]) func([]A) ReaderIO[[]B] {
-	return R.TraverseArrayWithIndex[ReaderIO[B], ReaderIO[[]B], IO.IO[B], IO.IO[[]B], []A](f)
-}
-
-// SequenceArray converts a homogeneous sequence of either into an either of sequence
-func SequenceArray[A any](ma []ReaderIO[A]) ReaderIO[[]A] {
-	return R.SequenceArray[ReaderIO[A], ReaderIO[[]A]](ma)
-}
--- a/context/readerio/from.go
+++ b/context/readerio/from.go
@@ -1,42 +0,0 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package readerio
-
-import (
-	"context"
-
-	IO "github.com/IBM/fp-go/io"
-	R "github.com/IBM/fp-go/readerio/generic"
-)
-
-// these functions curry a golang function with the context as the firsr parameter into a either reader with the context as the last parameter
-// this goes back to the advice in https://pkg.go.dev/context to put the context as a first parameter as a convention
-
-func From0[A any](f func(context.Context) IO.IO[A]) func() ReaderIO[A] {
-	return R.From0[ReaderIO[A]](f)
-}
-
-func From1[T1, A any](f func(context.Context, T1) IO.IO[A]) func(T1) ReaderIO[A] {
-	return R.From1[ReaderIO[A]](f)
-}
-
-func From2[T1, T2, A any](f func(context.Context, T1, T2) IO.IO[A]) func(T1, T2) ReaderIO[A] {
-	return R.From2[ReaderIO[A]](f)
-}
-
-func From3[T1, T2, T3, A any](f func(context.Context, T1, T2, T3) IO.IO[A]) func(T1, T2, T3) ReaderIO[A] {
-	return R.From3[ReaderIO[A]](f)
-}
--- a/context/readerio/reader.go
+++ b/context/readerio/reader.go
@@ -1,102 +0,0 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package readerio
-
-import (
-	"context"
-
-	IO "github.com/IBM/fp-go/io"
-	L "github.com/IBM/fp-go/lazy"
-	R "github.com/IBM/fp-go/readerio/generic"
-)
-
-// FromIO converts an [IO.IO] to a [ReaderIO]
-func FromIO[A any](a IO.IO[A]) ReaderIO[A] {
-	return R.FromIO[ReaderIO[A]](a)
-}
-
-func MonadMap[A, B any](fa ReaderIO[A], f func(A) B) ReaderIO[B] {
-	return R.MonadMap[ReaderIO[A], ReaderIO[B]](fa, f)
-}
-
-func Map[A, B any](f func(A) B) func(ReaderIO[A]) ReaderIO[B] {
-	return R.Map[ReaderIO[A], ReaderIO[B]](f)
-}
-
-func MonadChain[A, B any](ma ReaderIO[A], f func(A) ReaderIO[B]) ReaderIO[B] {
-	return R.MonadChain(ma, f)
-}
-
-func Chain[A, B any](f func(A) ReaderIO[B]) func(ReaderIO[A]) ReaderIO[B] {
-	return R.Chain[ReaderIO[A]](f)
-}
-
-func MonadChainIOK[A, B any](fa ReaderIO[A], f func(A) IO.IO[B]) ReaderIO[B] {
-	return R.MonadChainIOK[ReaderIO[A], ReaderIO[B]](fa, f)
-}
-
-func ChainIOK[A, B any](f func(A) IO.IO[B]) func(ReaderIO[A]) ReaderIO[B] {
-	return R.ChainIOK[ReaderIO[A], ReaderIO[B]](f)
-}
-
-func MonadChainFirstIOK[A, B any](fa ReaderIO[A], f func(A) IO.IO[B]) ReaderIO[A] {
-	return R.MonadChainFirstIOK[ReaderIO[A], ReaderIO[B]](fa, f)
-}
-
-func ChainFirstIOK[A, B any](f func(A) IO.IO[B]) func(ReaderIO[A]) ReaderIO[A] {
-	return R.ChainFirstIOK[ReaderIO[A], ReaderIO[B]](f)
-}
-
-func Of[A any](a A) ReaderIO[A] {
-	return R.Of[ReaderIO[A]](a)
-}
-
-func MonadAp[A, B any](fab ReaderIO[func(A) B], fa ReaderIO[A]) ReaderIO[B] {
-	return R.MonadAp[ReaderIO[A], ReaderIO[B]](fab, fa)
-}
-
-func Ap[A, B any](fa ReaderIO[A]) func(ReaderIO[func(A) B]) ReaderIO[B] {
-	return R.Ap[ReaderIO[A], ReaderIO[B], ReaderIO[func(A) B]](fa)
-}
-
-func Ask() ReaderIO[context.Context] {
-	return R.Ask[ReaderIO[context.Context]]()
-}
-
-// Defer creates an IO by creating a brand new IO via a generator function, each time
-func Defer[A any](gen L.Lazy[ReaderIO[A]]) ReaderIO[A] {
-	return R.Defer[ReaderIO[A]](gen)
-}
-
-// Memoize computes the value of the provided [ReaderIO] monad lazily but exactly once
-// The context used to compute the value is the context of the first call, so do not use this
-// method if the value has a functional dependency on the content of the context
-func Memoize[A any](rdr ReaderIO[A]) ReaderIO[A] {
-	return R.Memoize[ReaderIO[A]](rdr)
-}
-
-// Flatten converts a nested [ReaderIO] into a [ReaderIO]
-func Flatten[A any](mma ReaderIO[ReaderIO[A]]) ReaderIO[A] {
-	return R.Flatten[ReaderIO[A]](mma)
-}
-
-func MonadFlap[B, A any](fab ReaderIO[func(A) B], a A) ReaderIO[B] {
-	return R.MonadFlap[ReaderIO[func(A) B], ReaderIO[B]](fab, a)
-}
-
-func Flap[B, A any](a A) func(ReaderIO[func(A) B]) ReaderIO[B] {
-	return R.Flap[ReaderIO[func(A) B], ReaderIO[B]](a)
-}
--- a/context/readerio/reader_test.go
+++ b/context/readerio/reader_test.go
@@ -1,80 +0,0 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package readerio
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"testing"
-
-	F "github.com/IBM/fp-go/function"
-	IO "github.com/IBM/fp-go/io"
-	T "github.com/IBM/fp-go/tuple"
-	"github.com/stretchr/testify/assert"
-)
-
-func GoFunction(ctx context.Context, data string) IO.IO[string] {
-	return func() string {
-		return strings.ToUpper(data)
-	}
-}
-
-func GoIntFunction(ctx context.Context, data string, number int) IO.IO[string] {
-	return func() string {
-		return fmt.Sprintf("%s: %d", data, number)
-	}
-}
-
-func TestReaderFrom(t *testing.T) {
-	ctx := context.Background()
-	f := From1(GoFunction)
-
-	result := f("input")(ctx)
-
-	assert.Equal(t, result(), "INPUT")
-
-}
-
-func MyFinalResult(left, right string) string {
-	return fmt.Sprintf("%s-%s", left, right)
-}
-
-func TestReadersFrom(t *testing.T) {
-	ctx := context.Background()
-
-	f1 := From1(GoFunction)
-	f2 := From2(GoIntFunction)
-
-	result1 := f1("input")(ctx)
-	result2 := f2("input", 10)(ctx)
-
-	result3 := MyFinalResult(result1(), result2())
-
-	h := F.Pipe1(
-		SequenceT2(f1("input"), f2("input", 10)),
-		Map(T.Tupled2(MyFinalResult)),
-	)
-
-	composedResult := h(ctx)
-
-	assert.Equal(t, result1(), "INPUT")
-	assert.Equal(t, result2(), "input: 10")
-	assert.Equal(t, result3, "INPUT-input: 10")
-
-	assert.Equal(t, composedResult(), "INPUT-input: 10")
-
-}
--- a/context/readerio/sequence.go
+++ b/context/readerio/sequence.go
@@ -1,57 +0,0 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package readerio
-
-import (
-	R "github.com/IBM/fp-go/readerio/generic"
-	T "github.com/IBM/fp-go/tuple"
-)
-
-// SequenceT converts n inputs of higher kinded types into a higher kinded types of n strongly typed values, represented as a tuple
-
-func SequenceT1[A any](a ReaderIO[A]) ReaderIO[T.Tuple1[A]] {
-	return R.SequenceT1[
-		ReaderIO[A],
-		ReaderIO[T.Tuple1[A]],
-	](a)
-}
-
-func SequenceT2[A, B any](a ReaderIO[A], b ReaderIO[B]) ReaderIO[T.Tuple2[A, B]] {
-	return R.SequenceT2[
-		ReaderIO[A],
-		ReaderIO[B],
-		ReaderIO[T.Tuple2[A, B]],
-	](a, b)
-}
-
-func SequenceT3[A, B, C any](a ReaderIO[A], b ReaderIO[B], c ReaderIO[C]) ReaderIO[T.Tuple3[A, B, C]] {
-	return R.SequenceT3[
-		ReaderIO[A],
-		ReaderIO[B],
-		ReaderIO[C],
-		ReaderIO[T.Tuple3[A, B, C]],
-	](a, b, c)
-}
-
-func SequenceT4[A, B, C, D any](a ReaderIO[A], b ReaderIO[B], c ReaderIO[C], d ReaderIO[D]) ReaderIO[T.Tuple4[A, B, C, D]] {
-	return R.SequenceT4[
-		ReaderIO[A],
-		ReaderIO[B],
-		ReaderIO[C],
-		ReaderIO[D],
-		ReaderIO[T.Tuple4[A, B, C, D]],
-	](a, b, c, d)
-}
--- a/context/readerioeither/bracket.go
+++ b/context/readerioeither/bracket.go
@@ -0,0 +1,37 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerioeither
+
+import (
+	G "github.com/IBM/fp-go/context/readerioeither/generic"
+	E "github.com/IBM/fp-go/either"
+)
+
+// Bracket makes sure that a resource is cleaned up in the event of an error. The release action is called regardless of
+// whether the body action returns and error or not.
+func Bracket[
+	A, B, ANY any](
+
+	acquire ReaderIOEither[A],
+	use func(A) ReaderIOEither[B],
+	release func(A, E.Either[error, B]) ReaderIOEither[ANY],
+) ReaderIOEither[B] {
+	return G.Bracket[ReaderIOEither[A], ReaderIOEither[B], ReaderIOEither[ANY]](
+		acquire,
+		use,
+		release,
+	)
+}
--- a/context/readerioeither/file/file_test.go
+++ b/context/readerioeither/file/file_test.go
@@ -19,9 +19,7 @@ import (
 	"context"
 	"fmt"

-	RIO "github.com/IBM/fp-go/context/readerio"
 	R "github.com/IBM/fp-go/context/readerioeither"
-	"github.com/IBM/fp-go/errors"
 	F "github.com/IBM/fp-go/function"
 	IO "github.com/IBM/fp-go/io"
 	J "github.com/IBM/fp-go/json"
@@ -37,20 +35,17 @@ func getData(r RecordType) string {

 func ExampleReadFile() {

-	data := F.Pipe4(
+	data := F.Pipe3(
 		ReadFile("./data/file.json"),
 		R.ChainEitherK(J.Unmarshal[RecordType]),
 		R.ChainFirstIOK(IO.Logf[RecordType]("Log: %v")),
 		R.Map(getData),
-		R.GetOrElse(F.Flow2(
-			errors.ToString,
-			RIO.Of[string],
-		)),
 	)

 	result := data(context.Background())

 	fmt.Println(result())

-	// Output: Carsten
+	// Output:
+	// Right[<nil>, string](Carsten)
 }
--- a/context/readerioeither/gen.go
+++ b/context/readerioeither/gen.go
@@ -2,7 +2,8 @@ package readerioeither

 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-09-12 13:44:14.1022311 +0200 CEST m=+0.017763401
+// 2023-10-23 08:30:39.012572 +0200 CEST m=+0.008846101
+

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

 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-09-12 13:44:14.1036885 +0200 CEST m=+0.019220801
+// 2023-10-23 08:30:39.012572 +0200 CEST m=+0.008846101
+

 import (
 	"context"

 	E "github.com/IBM/fp-go/either"
-	A "github.com/IBM/fp-go/internal/apply"
 	RE "github.com/IBM/fp-go/readerioeither/generic"
+	A "github.com/IBM/fp-go/internal/apply"
 	T "github.com/IBM/fp-go/tuple"
 )

--- a/context/readerioeither/generic/reader.go
+++ b/context/readerioeither/generic/reader.go
@@ -432,10 +432,10 @@ func FromIOEither[

 func FromIO[
 	GRA ~func(context.Context) GIOA,
-	GIOA ~func() E.Either[error, A],
-
 	GIOB ~func() A,

+	GIOA ~func() E.Either[error, A],
+
 	A any](t GIOB) GRA {
 	return RIE.FromIO[GRA](t)
 }
@@ -571,7 +571,7 @@ func Timer[
 ](delay time.Duration) GRA {
 	return F.Pipe2(
 		IO.Now[func() time.Time](),
-		FromIO[GRA, GIOA, func() time.Time],
+		FromIO[GRA, func() time.Time],
 		Delay[GRA](delay),
 	)
 }
--- a/context/readerioeither/generic/sync.go
+++ b/context/readerioeither/generic/sync.go
@@ -0,0 +1,44 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	"context"
+
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	IO "github.com/IBM/fp-go/io/generic"
+)
+
+// WithLock executes the provided IO operation in the scope of a lock
+func WithLock[
+	GRA ~func(context.Context) GIOA,
+	GIOA ~func() E.Either[error, A],
+	GRCANCEL ~func(context.Context) GIOCANCEL,
+	GIOCANCEL ~func() E.Either[error, context.CancelFunc],
+	A any](lock GRCANCEL) func(fa GRA) GRA {
+
+	type GRANY func(ctx context.Context) func() E.Either[error, any]
+	type IOANY func() any
+
+	return F.Flow2(
+		F.Constant1[context.CancelFunc, GRA],
+		WithResource[GRA, GRCANCEL, GRANY](lock, F.Flow2(
+			IO.FromImpure[IOANY, context.CancelFunc],
+			FromIO[GRANY, IOANY],
+		)),
+	)
+}
--- a/context/readerioeither/reader.go
+++ b/context/readerioeither/reader.go
@@ -19,8 +19,6 @@ import (
 	"context"
 	"time"

-	R "github.com/IBM/fp-go/context/reader"
-	RIO "github.com/IBM/fp-go/context/readerio"
 	G "github.com/IBM/fp-go/context/readerioeither/generic"
 	ET "github.com/IBM/fp-go/either"
 	IO "github.com/IBM/fp-go/io"
@@ -33,14 +31,6 @@ func FromEither[A any](e ET.Either[error, A]) ReaderIOEither[A] {
 	return G.FromEither[ReaderIOEither[A]](e)
 }

-func RightReader[A any](r R.Reader[A]) ReaderIOEither[A] {
-	return G.RightReader[ReaderIOEither[A]](r)
-}
-
-func LeftReader[A any](l R.Reader[error]) ReaderIOEither[A] {
-	return G.LeftReader[ReaderIOEither[A]](l)
-}
-
 func Left[A any](l error) ReaderIOEither[A] {
 	return G.Left[ReaderIOEither[A]](l)
 }
@@ -49,10 +39,6 @@ func Right[A any](r A) ReaderIOEither[A] {
 	return G.Right[ReaderIOEither[A]](r)
 }

-func FromReader[A any](r R.Reader[A]) ReaderIOEither[A] {
-	return G.FromReader[ReaderIOEither[A]](r)
-}
-
 func MonadMap[A, B any](fa ReaderIOEither[A], f func(A) B) ReaderIOEither[B] {
 	return G.MonadMap[ReaderIOEither[A], ReaderIOEither[B]](fa, f)
 }
@@ -103,30 +89,14 @@ func FromPredicate[A any](pred func(A) bool, onFalse func(A) error) func(A) Read
 	return G.FromPredicate[ReaderIOEither[A]](pred, onFalse)
 }

-func Fold[A, B any](onLeft func(error) RIO.ReaderIO[B], onRight func(A) RIO.ReaderIO[B]) func(ReaderIOEither[A]) RIO.ReaderIO[B] {
-	return G.Fold[RIO.ReaderIO[B], ReaderIOEither[A]](onLeft, onRight)
-}
-
-func GetOrElse[A any](onLeft func(error) RIO.ReaderIO[A]) func(ReaderIOEither[A]) RIO.ReaderIO[A] {
-	return G.GetOrElse[RIO.ReaderIO[A], ReaderIOEither[A]](onLeft)
-}
-
 func OrElse[A any](onLeft func(error) ReaderIOEither[A]) func(ReaderIOEither[A]) ReaderIOEither[A] {
 	return G.OrElse[ReaderIOEither[A]](onLeft)
 }

-func OrLeft[A any](onLeft func(error) RIO.ReaderIO[error]) func(ReaderIOEither[A]) ReaderIOEither[A] {
-	return G.OrLeft[ReaderIOEither[A], RIO.ReaderIO[error]](onLeft)
-}
-
 func Ask() ReaderIOEither[context.Context] {
 	return G.Ask[ReaderIOEither[context.Context]]()
 }

-func Asks[A any](r R.Reader[A]) ReaderIOEither[A] {
-	return G.Asks[ReaderIOEither[A]](r)
-}
-
 func MonadChainEitherK[A, B any](ma ReaderIOEither[A], f func(A) ET.Either[error, B]) ReaderIOEither[B] {
 	return G.MonadChainEitherK[ReaderIOEither[A], ReaderIOEither[B]](ma, f)
 }
@@ -164,14 +134,6 @@ func Never[A any]() ReaderIOEither[A] {
 	return G.Never[ReaderIOEither[A]]()
 }

-func MonadChainReaderIOK[A, B any](ma ReaderIOEither[A], f func(A) RIO.ReaderIO[B]) ReaderIOEither[B] {
-	return G.MonadChainReaderIOK[ReaderIOEither[B], ReaderIOEither[A]](ma, f)
-}
-
-func ChainReaderIOK[A, B any](f func(A) RIO.ReaderIO[B]) func(ma ReaderIOEither[A]) ReaderIOEither[B] {
-	return G.ChainReaderIOK[ReaderIOEither[B], ReaderIOEither[A]](f)
-}
-
 func MonadChainIOK[A, B any](ma ReaderIOEither[A], f func(A) IO.IO[B]) ReaderIOEither[B] {
 	return G.MonadChainIOK[ReaderIOEither[B], ReaderIOEither[A]](ma, f)
 }
@@ -235,22 +197,6 @@ func Flatten[
 	return G.Flatten[ReaderIOEither[ReaderIOEither[A]]](rdr)
 }

-func MonadFromReaderIO[A any](a A, f func(A) RIO.ReaderIO[A]) ReaderIOEither[A] {
-	return G.MonadFromReaderIO[ReaderIOEither[A]](a, f)
-}
-
-func FromReaderIO[A any](f func(A) RIO.ReaderIO[A]) func(A) ReaderIOEither[A] {
-	return G.FromReaderIO[ReaderIOEither[A]](f)
-}
-
-func RightReaderIO[A any](ma RIO.ReaderIO[A]) ReaderIOEither[A] {
-	return G.RightReaderIO[ReaderIOEither[A]](ma)
-}
-
-func LeftReaderIO[A any](ma RIO.ReaderIO[error]) ReaderIOEither[A] {
-	return G.LeftReaderIO[ReaderIOEither[A]](ma)
-}
-
 func MonadFlap[B, A any](fab ReaderIOEither[func(A) B], a A) ReaderIOEither[B] {
 	return G.MonadFlap[ReaderIOEither[func(A) B], ReaderIOEither[B]](fab, a)
 }
--- a/context/readerioeither/sync.go
+++ b/context/readerioeither/sync.go
@@ -13,14 +13,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-// Package reader implements a specialization of the Reader monad assuming a golang context as the context of the monad
-package reader
+package readerioeither

 import (
 	"context"

-	R "github.com/IBM/fp-go/reader"
+	G "github.com/IBM/fp-go/context/readerioeither/generic"
 )

-// Reader is a specialization of the Reader monad assuming a golang context as the context of the monad
-type Reader[A any] R.Reader[context.Context, A]
+// WithLock executes the provided IO operation in the scope of a lock
+func WithLock[A any](lock ReaderIOEither[context.CancelFunc]) func(fa ReaderIOEither[A]) ReaderIOEither[A] {
+	return G.WithLock[ReaderIOEither[A]](lock)
+}
--- a/either/either.go
+++ b/either/either.go
@@ -120,16 +120,15 @@ func Flatten[E, A any](mma Either[E, Either[E, A]]) Either[E, A] {
 	return MonadChain(mma, F.Identity[Either[E, A]])
 }

-func TryCatch[FA ~func() (A, error), FE func(error) E, E, A any](f FA, onThrow FE) Either[E, A] {
-	val, err := f()
+func TryCatch[FE func(error) E, E, A any](val A, err error, onThrow FE) Either[E, A] {
 	if err != nil {
 		return F.Pipe2(err, onThrow, Left[A, E])
 	}
 	return F.Pipe1(val, Right[E, A])
 }

-func TryCatchError[F ~func() (A, error), A any](f F) Either[error, A] {
-	return TryCatch(f, E.IdentityError)
+func TryCatchError[A any](val A, err error) Either[error, A] {
+	return TryCatch(val, err, E.IdentityError)
 }

 func Sequence2[E, T1, T2, R any](f func(T1, T2) Either[E, R]) func(Either[E, T1], Either[E, T2]) Either[E, R] {
@@ -154,9 +153,7 @@ func ToOption[E, A any](ma Either[E, A]) O.Option[A] {

 func FromError[A any](f func(a A) error) func(A) Either[error, A] {
 	return func(a A) Either[error, A] {
-		return TryCatchError(func() (A, error) {
-			return a, f(a)
-		})
+		return TryCatchError(a, f(a))
 	}
 }

--- a/either/exec/exec.go
+++ b/either/exec/exec.go
@@ -32,7 +32,5 @@ var (
 )

 func command(name string, args []string, in []byte) E.Either[error, exec.CommandOutput] {
-	return E.TryCatchError(func() (exec.CommandOutput, error) {
-		return GE.Exec(context.Background(), name, args, in)
-	})
+	return E.TryCatchError(GE.Exec(context.Background(), name, args, in))
 }
--- a/either/gen.go
+++ b/either/gen.go
@@ -1,9 +1,10 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-09-12 13:44:15.6356542 +0200 CEST m=+0.009418901
+// 2023-10-23 08:30:40.410373 +0200 CEST m=+0.010337601

 package either

+
 import (
 	A "github.com/IBM/fp-go/internal/apply"
 	T "github.com/IBM/fp-go/tuple"
@@ -13,9 +14,7 @@ import (
 // The inverse function is [Uneitherize0]
 func Eitherize0[F ~func() (R, error), R any](f F) func() Either[error, R] {
  return func() Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f()
-		})
+    return TryCatchError(f())
  }
 }

@@ -31,9 +30,7 @@ func Uneitherize0[F ~func() Either[error, R], R any](f F) func() (R, error) {
 // The inverse function is [Uneitherize1]
 func Eitherize1[F ~func(T0) (R, error), T0, R any](f F) func(T0) Either[error, R] {
  return func(t0 T0) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0)
-		})
+    return TryCatchError(f(t0))
  }
 }

@@ -76,9 +73,7 @@ func TraverseTuple1[F1 ~func(A1) Either[E, T1], E, A1, T1 any](f1 F1) func(T.Tup
 // The inverse function is [Uneitherize2]
 func Eitherize2[F ~func(T0, T1) (R, error), T0, T1, R any](f F) func(T0, T1) Either[error, R] {
  return func(t0 T0, t1 T1) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1)
-		})
+    return TryCatchError(f(t0, t1))
  }
 }

@@ -126,9 +121,7 @@ func TraverseTuple2[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], E, A
 // The inverse function is [Uneitherize3]
 func Eitherize3[F ~func(T0, T1, T2) (R, error), T0, T1, T2, R any](f F) func(T0, T1, T2) Either[error, R] {
  return func(t0 T0, t1 T1, t2 T2) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2)
-		})
+    return TryCatchError(f(t0, t1, t2))
  }
 }

@@ -181,9 +174,7 @@ func TraverseTuple3[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
 // The inverse function is [Uneitherize4]
 func Eitherize4[F ~func(T0, T1, T2, T3) (R, error), T0, T1, T2, T3, R any](f F) func(T0, T1, T2, T3) Either[error, R] {
  return func(t0 T0, t1 T1, t2 T2, t3 T3) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3)
-		})
+    return TryCatchError(f(t0, t1, t2, t3))
  }
 }

@@ -241,9 +232,7 @@ func TraverseTuple4[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
 // The inverse function is [Uneitherize5]
 func Eitherize5[F ~func(T0, T1, T2, T3, T4) (R, error), T0, T1, T2, T3, T4, R any](f F) func(T0, T1, T2, T3, T4) Either[error, R] {
  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3, t4)
-		})
+    return TryCatchError(f(t0, t1, t2, t3, t4))
  }
 }

@@ -306,9 +295,7 @@ func TraverseTuple5[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
 // The inverse function is [Uneitherize6]
 func Eitherize6[F ~func(T0, T1, T2, T3, T4, T5) (R, error), T0, T1, T2, T3, T4, T5, R any](f F) func(T0, T1, T2, T3, T4, T5) Either[error, R] {
  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3, t4, t5)
-		})
+    return TryCatchError(f(t0, t1, t2, t3, t4, t5))
  }
 }

@@ -376,9 +363,7 @@ func TraverseTuple6[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
 // The inverse function is [Uneitherize7]
 func Eitherize7[F ~func(T0, T1, T2, T3, T4, T5, T6) (R, error), T0, T1, T2, T3, T4, T5, T6, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) Either[error, R] {
  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3, t4, t5, t6)
-		})
+    return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6))
  }
 }

@@ -451,9 +436,7 @@ func TraverseTuple7[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
 // The inverse function is [Uneitherize8]
 func Eitherize8[F ~func(T0, T1, T2, T3, T4, T5, T6, T7) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) Either[error, R] {
  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3, t4, t5, t6, t7)
-		})
+    return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6, t7))
  }
 }

@@ -531,9 +514,7 @@ func TraverseTuple8[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
 // The inverse function is [Uneitherize9]
 func Eitherize9[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) Either[error, R] {
  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3, t4, t5, t6, t7, t8)
-		})
+    return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8))
  }
 }

@@ -616,9 +597,7 @@ func TraverseTuple9[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
 // The inverse function is [Uneitherize10]
 func Eitherize10[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) Either[error, R] {
  return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
-		})
+    return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9))
  }
 }

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

 func noBodyRequest(method string) func(string) E.Either[error, *http.Request] {
 	return func(url string) E.Either[error, *http.Request] {
-		return E.TryCatchError(func() (*http.Request, error) {
-			return http.NewRequest(method, url, nil)
-		})
+		return E.TryCatchError(http.NewRequest(method, url, nil))
 	}
 }
--- a/either/resource_test.go
+++ b/either/resource_test.go
@@ -25,20 +25,14 @@ import (

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

--- a/either/variadic.go
+++ b/either/variadic.go
@@ -17,80 +17,60 @@ package either

 func Variadic0[V, R any](f func([]V) (R, error)) func(...V) Either[error, R] {
 	return func(v ...V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(v)
-		})
+		return TryCatchError(f(v))
 	}
 }

 func Variadic1[T1, V, R any](f func(T1, []V) (R, error)) func(T1, ...V) Either[error, R] {
 	return func(t1 T1, v ...V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t1, v)
-		})
+		return TryCatchError(f(t1, v))
 	}
 }

 func Variadic2[T1, T2, V, R any](f func(T1, T2, []V) (R, error)) func(T1, T2, ...V) Either[error, R] {
 	return func(t1 T1, t2 T2, v ...V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t1, t2, v)
-		})
+		return TryCatchError(f(t1, t2, v))
 	}
 }

 func Variadic3[T1, T2, T3, V, R any](f func(T1, T2, T3, []V) (R, error)) func(T1, T2, T3, ...V) Either[error, R] {
 	return func(t1 T1, t2 T2, t3 T3, v ...V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t1, t2, t3, v)
-		})
+		return TryCatchError(f(t1, t2, t3, v))
 	}
 }

 func Variadic4[T1, T2, T3, T4, V, R any](f func(T1, T2, T3, T4, []V) (R, error)) func(T1, T2, T3, T4, ...V) Either[error, R] {
 	return func(t1 T1, t2 T2, t3 T3, t4 T4, v ...V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t1, t2, t3, t4, v)
-		})
+		return TryCatchError(f(t1, t2, t3, t4, v))
 	}
 }

 func Unvariadic0[V, R any](f func(...V) (R, error)) func([]V) Either[error, R] {
 	return func(v []V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(v...)
-		})
+		return TryCatchError(f(v...))
 	}
 }

 func Unvariadic1[T1, V, R any](f func(T1, ...V) (R, error)) func(T1, []V) Either[error, R] {
 	return func(t1 T1, v []V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t1, v...)
-		})
+		return TryCatchError(f(t1, v...))
 	}
 }

 func Unvariadic2[T1, T2, V, R any](f func(T1, T2, ...V) (R, error)) func(T1, T2, []V) Either[error, R] {
 	return func(t1 T1, t2 T2, v []V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t1, t2, v...)
-		})
+		return TryCatchError(f(t1, t2, v...))
 	}
 }

 func Unvariadic3[T1, T2, T3, V, R any](f func(T1, T2, T3, ...V) (R, error)) func(T1, T2, T3, []V) Either[error, R] {
 	return func(t1 T1, t2 T2, t3 T3, v []V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t1, t2, t3, v...)
-		})
+		return TryCatchError(f(t1, t2, t3, v...))
 	}
 }

 func Unvariadic4[T1, T2, T3, T4, V, R any](f func(T1, T2, T3, T4, ...V) (R, error)) func(T1, T2, T3, T4, []V) Either[error, R] {
 	return func(t1 T1, t2 T2, t3 T3, t4 T4, v []V) Either[error, R] {
-		return TryCatchError(func() (R, error) {
-			return f(t1, t2, t3, t4, v...)
-		})
+		return TryCatchError(f(t1, t2, t3, t4, v...))
 	}
 }
--- a/function/binds.go
+++ b/function/binds.go
@@ -1,9 +1,8 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-09-12 13:44:23.4226437 +0200 CEST m=+0.011841001
+// 2023-10-23 08:30:44.6474482 +0200 CEST m=+0.150851901

 package function
-
 // Combinations for a total of 1 arguments

 // Bind1of1 takes a function with 1 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
@@ -22,7 +21,6 @@ func Ignore1of1[T1 any, F ~func() R, R any](f F) func(T1) R {
      return f()
  }
 }
-
 // Combinations for a total of 2 arguments

 // Bind1of2 takes a function with 2 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
@@ -75,7 +73,6 @@ func Ignore12of2[T1, T2 any, F ~func() R, R any](f F) func(T1, T2) R {
      return f()
  }
 }
-
 // Combinations for a total of 3 arguments

 // Bind1of3 takes a function with 3 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
@@ -196,7 +193,6 @@ func Ignore123of3[T1, T2, T3 any, F ~func() R, R any](f F) func(T1, T2, T3) R {
      return f()
  }
 }
-
 // Combinations for a total of 4 arguments

 // Bind1of4 takes a function with 4 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
--- a/function/gen.go
+++ b/function/gen.go
@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-09-12 13:44:17.0002767 +0200 CEST m=+0.008233101
+// 2023-10-23 08:30:41.7972101 +0200 CEST m=+0.008029101

 package function

--- a/http/utils.go
+++ b/http/utils.go
@@ -68,10 +68,8 @@ const (

 // ParseMediaType parses a media type into a tuple
 func ParseMediaType(mediaType string) E.Either[error, ParsedMediaType] {
-	return E.TryCatchError(func() (ParsedMediaType, error) {
 	m, p, err := mime.ParseMediaType(mediaType)
-		return T.MakeTuple2(m, p), err
-	})
+	return E.TryCatchError(T.MakeTuple2(m, p), err)
 }

 func GetHeader(resp *H.Response) H.Header {
--- a/identity/gen.go
+++ b/identity/gen.go
@@ -1,9 +1,10 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-09-12 13:44:24.9409324 +0200 CEST m=+0.008573601
+// 2023-10-23 08:30:50.5492271 +0200 CEST m=+0.023274501

 package identity

+
 import (
 	A "github.com/IBM/fp-go/internal/apply"
 	T "github.com/IBM/fp-go/tuple"
--- a/internal/apply/gen.go
+++ b/internal/apply/gen.go
@@ -1,9 +1,10 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-09-12 13:44:26.2499883 +0200 CEST m=+0.007601301
+// 2023-10-23 08:30:54.1909432 +0200 CEST m=+0.014252201

 package apply

+
 import (
 	F "github.com/IBM/fp-go/function"
 	T "github.com/IBM/fp-go/tuple"
--- a/internal/bracket/bracket.go
+++ b/internal/bracket/bracket.go
--- a/internal/file/file.go
+++ b/internal/file/file.go
@@ -46,9 +46,7 @@ func MakeReader(ctx context.Context, rdr io.Reader) io.Reader {

 // ReadAll reads the content of a reader and allows it to be canceled
 func ReadAll(ctx context.Context, rdr io.Reader) E.Either[error, []byte] {
-	return E.TryCatchError(func() ([]byte, error) {
 	var buffer bytes.Buffer
 	_, err := io.Copy(&buffer, MakeReader(ctx, rdr))
-		return buffer.Bytes(), err
-	})
+	return E.TryCatchError(buffer.Bytes(), err)
 }
--- a/io/bracket.go
+++ b/io/bracket.go
@@ -0,0 +1,30 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package io
+
+import (
+	G "github.com/IBM/fp-go/io/generic"
+)
+
+// Bracket makes sure that a resource is cleaned up in the event of an error. The release action is called regardless of
+// whether the body action returns and error or not.
+func Bracket[A, B, ANY any](
+	acquire IO[A],
+	use func(A) IO[B],
+	release func(A, B) IO[ANY],
+) IO[B] {
+	return G.Bracket(acquire, use, release)
+}
--- a/io/gen.go
+++ b/io/gen.go
@@ -1,9 +1,10 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-09-12 13:44:27.9813739 +0200 CEST m=+0.011088001
+// 2023-10-23 08:30:56.7105551 +0200 CEST m=+0.011255201

 package io

+
 import (
 	G "github.com/IBM/fp-go/io/generic"	
 	T "github.com/IBM/fp-go/tuple"
--- a/io/generic/bracket.go
+++ b/io/generic/bracket.go
@@ -0,0 +1,44 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	G "github.com/IBM/fp-go/internal/bracket"
+)
+
+// Bracket makes sure that a resource is cleaned up in the event of an error. The release action is called regardless of
+// whether the body action returns and error or not.
+func Bracket[
+	GA ~func() A,
+	GB ~func() B,
+	GANY ~func() ANY,
+	A, B, ANY any](
+
+	acquire GA,
+	use func(A) GB,
+	release func(A, B) GANY,
+) GB {
+	return G.Bracket[GA, GB, GANY, B, A, B](
+		Of[GB, B],
+		MonadChain[GA, GB, A, B],
+		MonadChain[GB, GB, B, B],
+		MonadChain[GANY, GB, ANY, B],
+
+		acquire,
+		use,
+		release,
+	)
+}
--- a/io/generic/gen.go
+++ b/io/generic/gen.go
@@ -1,11 +1,12 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-09-12 13:44:27.9813739 +0200 CEST m=+0.011088001
+// 2023-10-23 08:30:56.7105551 +0200 CEST m=+0.011255201
 package generic

+
 import (
-	A "github.com/IBM/fp-go/internal/apply"
 	T "github.com/IBM/fp-go/tuple"
+	A "github.com/IBM/fp-go/internal/apply"
 )

 // SequenceT1 converts 1 [func() T] into a [func() T.Tuple1[T1]]
--- a/io/generic/sync.go
+++ b/io/generic/sync.go
@@ -0,0 +1,30 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	"context"
+)
+
+// WithLock executes the provided IO operation in the scope of a lock
+func WithLock[GA ~func() A, A any](lock func() context.CancelFunc) func(fa GA) GA {
+	return func(fa GA) GA {
+		return func() A {
+			defer lock()()
+			return fa()
+		}
+	}
+}
--- a/io/sync.go
+++ b/io/sync.go
@@ -0,0 +1,27 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES 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 (
+	"context"
+
+	G "github.com/IBM/fp-go/io/generic"
+)
+
+// WithLock executes the provided [IO] operation in the scope of a lock
+func WithLock[A any](lock IO[context.CancelFunc]) func(fa IO[A]) IO[A] {
+	return G.WithLock[IO[A]](lock)
+}
--- a/ioeither/gen.go
+++ b/ioeither/gen.go
@@ -1,9 +1,10 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-09-12 13:44:29.4935658 +0200 CEST m=+0.015377401
+// 2023-10-23 08:30:58.6457744 +0200 CEST m=+0.080336501

 package ioeither

+
 import (
 	G "github.com/IBM/fp-go/ioeither/generic"	
 	T "github.com/IBM/fp-go/tuple"
--- a/ioeither/generic/bracket.go
+++ b/ioeither/generic/bracket.go
@@ -17,7 +17,7 @@ package generic

 import (
 	ET "github.com/IBM/fp-go/either"
-	G "github.com/IBM/fp-go/internal/file"
+	G "github.com/IBM/fp-go/internal/bracket"
 	I "github.com/IBM/fp-go/io/generic"
 )

--- a/ioeither/generic/gen.go
+++ b/ioeither/generic/gen.go
@@ -1,12 +1,13 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-09-12 13:44:29.4935658 +0200 CEST m=+0.015377401
+// 2023-10-23 08:30:58.6556525 +0200 CEST m=+0.090214601
 package generic

+
 import (
 	ET "github.com/IBM/fp-go/either"
-	A "github.com/IBM/fp-go/internal/apply"
 	T "github.com/IBM/fp-go/tuple"
+	A "github.com/IBM/fp-go/internal/apply"
 )

 // Eitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning a [GIOA]
@@ -15,8 +16,7 @@ func Eitherize0[GIOA ~func() ET.Either[error, R], F ~func() (R, error), R any](f
  return func() GIOA {
    return func() ET.Either[error, R] {
      return e()
-		}
-	}
+    }}
 }

 // Uneitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning a [GIOA]
@@ -32,8 +32,7 @@ func Eitherize1[GIOA ~func() ET.Either[error, R], F ~func(T1) (R, error), T1, R
  return func(t1 T1) GIOA {
    return func() ET.Either[error, R] {
      return e(t1)
-		}
-	}
+    }}
 }

 // Uneitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning a [GIOA]
@@ -86,8 +85,7 @@ func Eitherize2[GIOA ~func() ET.Either[error, R], F ~func(T1, T2) (R, error), T1
  return func(t1 T1, t2 T2) GIOA {
    return func() ET.Either[error, R] {
      return e(t1, t2)
-		}
-	}
+    }}
 }

 // Uneitherize2 converts a function with 2 parameters returning a tuple into a function with 2 parameters returning a [GIOA]
@@ -150,8 +148,7 @@ func Eitherize3[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3) (R, error)
  return func(t1 T1, t2 T2, t3 T3) GIOA {
    return func() ET.Either[error, R] {
      return e(t1, t2, t3)
-		}
-	}
+    }}
 }

 // Uneitherize3 converts a function with 3 parameters returning a tuple into a function with 3 parameters returning a [GIOA]
@@ -224,8 +221,7 @@ func Eitherize4[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4) (R, er
  return func(t1 T1, t2 T2, t3 T3, t4 T4) GIOA {
    return func() ET.Either[error, R] {
      return e(t1, t2, t3, t4)
-		}
-	}
+    }}
 }

 // Uneitherize4 converts a function with 4 parameters returning a tuple into a function with 4 parameters returning a [GIOA]
@@ -308,8 +304,7 @@ func Eitherize5[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5) (R
  return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) GIOA {
    return func() ET.Either[error, R] {
      return e(t1, t2, t3, t4, t5)
-		}
-	}
+    }}
 }

 // Uneitherize5 converts a function with 5 parameters returning a tuple into a function with 5 parameters returning a [GIOA]
@@ -402,8 +397,7 @@ func Eitherize6[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6
  return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) GIOA {
    return func() ET.Either[error, R] {
      return e(t1, t2, t3, t4, t5, t6)
-		}
-	}
+    }}
 }

 // Uneitherize6 converts a function with 6 parameters returning a tuple into a function with 6 parameters returning a [GIOA]
@@ -506,8 +500,7 @@ func Eitherize7[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6
  return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) GIOA {
    return func() ET.Either[error, R] {
      return e(t1, t2, t3, t4, t5, t6, t7)
-		}
-	}
+    }}
 }

 // Uneitherize7 converts a function with 7 parameters returning a tuple into a function with 7 parameters returning a [GIOA]
@@ -620,8 +613,7 @@ func Eitherize8[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6
  return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) GIOA {
    return func() ET.Either[error, R] {
      return e(t1, t2, t3, t4, t5, t6, t7, t8)
-		}
-	}
+    }}
 }

 // Uneitherize8 converts a function with 8 parameters returning a tuple into a function with 8 parameters returning a [GIOA]
@@ -744,8 +736,7 @@ func Eitherize9[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6
  return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) GIOA {
    return func() ET.Either[error, R] {
      return e(t1, t2, t3, t4, t5, t6, t7, t8, t9)
-		}
-	}
+    }}
 }

 // Uneitherize9 converts a function with 9 parameters returning a tuple into a function with 9 parameters returning a [GIOA]
@@ -878,8 +869,7 @@ func Eitherize10[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T
  return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10) GIOA {
    return func() ET.Either[error, R] {
      return e(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
-		}
-	}
+    }}
 }

 // Uneitherize10 converts a function with 10 parameters returning a tuple into a function with 10 parameters returning a [GIOA]
--- a/ioeither/generic/ioeither.go
+++ b/ioeither/generic/ioeither.go
@@ -19,7 +19,6 @@ import (
 	"time"

 	ET "github.com/IBM/fp-go/either"
-	"github.com/IBM/fp-go/errors"
 	F "github.com/IBM/fp-go/function"
 	C "github.com/IBM/fp-go/internal/chain"
 	"github.com/IBM/fp-go/internal/eithert"
@@ -184,12 +183,15 @@ func Flatten[GA ~func() ET.Either[E, A], GAA ~func() ET.Either[E, GA], E, A any]

 func TryCatch[GA ~func() ET.Either[E, A], E, A any](f func() (A, error), onThrow func(error) E) GA {
 	return MakeIO(func() ET.Either[E, A] {
-		return ET.TryCatch(f, onThrow)
+		a, err := f()
+		return ET.TryCatch(a, err, onThrow)
 	})
 }

 func TryCatchError[GA ~func() ET.Either[error, A], A any](f func() (A, error)) GA {
-	return TryCatch[GA](f, errors.IdentityError)
+	return MakeIO(func() ET.Either[error, A] {
+		return ET.TryCatchError(f())
+	})
 }

 // Memoize computes the value of the provided IO monad lazily but exactly once
--- a/ioeither/generic/sync.go
+++ b/ioeither/generic/sync.go
@@ -0,0 +1,28 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	"context"
+
+	ET "github.com/IBM/fp-go/either"
+	G "github.com/IBM/fp-go/io/generic"
+)
+
+// WithLock executes the provided IO operation in the scope of a lock
+func WithLock[GA ~func() ET.Either[E, A], E, A any](lock func() context.CancelFunc) func(fa GA) GA {
+	return G.WithLock[GA](lock)
+}
--- a/ioeither/sync.go
+++ b/ioeither/sync.go
@@ -0,0 +1,28 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ioeither
+
+import (
+	"context"
+
+	IO "github.com/IBM/fp-go/io"
+	G "github.com/IBM/fp-go/ioeither/generic"
+)
+
+// WithLock executes the provided IO operation in the scope of a lock
+func WithLock[E, A any](lock IO.IO[context.CancelFunc]) func(fa IOEither[E, A]) IOEither[E, A] {
+	return G.WithLock[IOEither[E, A]](lock)
+}
--- a/iooption/bracket.go
+++ b/iooption/bracket.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 (
+	G "github.com/IBM/fp-go/iooption/generic"
+	O "github.com/IBM/fp-go/option"
+)
+
+// Bracket makes sure that a resource is cleaned up in the event of an error. The release action is called regardless of
+// whether the body action returns and error or not.
+func Bracket[E, A, B, ANY any](
+	acquire IOOption[A],
+	use func(A) IOOption[B],
+	release func(A, O.Option[B]) IOOption[ANY],
+) IOOption[B] {
+	return G.Bracket(acquire, use, release)
+}
--- a/iooption/gen.go
+++ b/iooption/gen.go
@@ -1,9 +1,10 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-09-12 13:44:32.1514823 +0200 CEST m=+0.098931001
+// 2023-10-23 08:31:01.9227118 +0200 CEST m=+0.009977901

 package iooption

+
 import (
 	G "github.com/IBM/fp-go/iooption/generic"	
 	T "github.com/IBM/fp-go/tuple"
--- a/iooption/generic/bracket.go
+++ b/iooption/generic/bracket.go
@@ -0,0 +1,46 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	G "github.com/IBM/fp-go/internal/bracket"
+	I "github.com/IBM/fp-go/io/generic"
+	O "github.com/IBM/fp-go/option"
+)
+
+// Bracket makes sure that a resource is cleaned up in the event of an error. The release action is called regardless of
+// whether the body action returns and error or not.
+func Bracket[
+	GA ~func() O.Option[A],
+	GB ~func() O.Option[B],
+	GANY ~func() O.Option[ANY],
+	A, B, ANY any](
+
+	acquire GA,
+	use func(A) GB,
+	release func(A, O.Option[B]) GANY,
+) GB {
+	return G.Bracket[GA, GB, GANY, O.Option[B], A, B](
+		I.Of[GB, O.Option[B]],
+		MonadChain[GA, GB, A, B],
+		I.MonadChain[GB, GB, O.Option[B], O.Option[B]],
+		MonadChain[GANY, GB, ANY, B],
+
+		acquire,
+		use,
+		release,
+	)
+}
--- a/iooption/generic/gen.go
+++ b/iooption/generic/gen.go
@@ -1,12 +1,13 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-09-12 13:44:32.1546277 +0200 CEST m=+0.102076401
+// 2023-10-23 08:31:01.9227118 +0200 CEST m=+0.009977901
 package generic

+
 import (
-	A "github.com/IBM/fp-go/internal/apply"
-	O "github.com/IBM/fp-go/option"
 	T "github.com/IBM/fp-go/tuple"
+	O "github.com/IBM/fp-go/option"
+	A "github.com/IBM/fp-go/internal/apply"
 )

 // SequenceT1 converts 1 [func() O.Option[T]] into a [func() O.Option[T.Tuple1[T1]]]
--- a/iooption/generic/sync.go
+++ b/iooption/generic/sync.go
@@ -0,0 +1,28 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	"context"
+
+	G "github.com/IBM/fp-go/io/generic"
+	O "github.com/IBM/fp-go/option"
+)
+
+// WithLock executes the provided IO operation in the scope of a lock
+func WithLock[GA ~func() O.Option[A], A any](lock func() context.CancelFunc) func(fa GA) GA {
+	return G.WithLock[GA](lock)
+}
--- a/iooption/sync.go
+++ b/iooption/sync.go
@@ -0,0 +1,28 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package iooption
+
+import (
+	"context"
+
+	IO "github.com/IBM/fp-go/io"
+	G "github.com/IBM/fp-go/iooption/generic"
+)
+
+// WithLock executes the provided IO operation in the scope of a lock
+func WithLock[E, A any](lock IO.IO[context.CancelFunc]) func(fa IOOption[A]) IOOption[A] {
+	return G.WithLock[IOOption[A]](lock)
+}
--- a/json/json.go
+++ b/json/json.go
@@ -23,16 +23,12 @@ import (

 // Unmarshal parses a JSON data structure from bytes
 func Unmarshal[A any](data []byte) E.Either[error, A] {
-	return E.TryCatchError(func() (A, error) {
 	var result A
 	err := json.Unmarshal(data, &result)
-		return result, err
-	})
+	return E.TryCatchError(result, err)
 }

 // Marshal converts a data structure to json
 func Marshal[A any](a A) E.Either[error, []byte] {
-	return E.TryCatchError(func() ([]byte, error) {
-		return json.Marshal(a)
-	})
+	return E.TryCatchError(json.Marshal(a))
 }
--- a/option/gen.go
+++ b/option/gen.go
@@ -1,14 +1,14 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-09-12 13:44:34.2077257 +0200 CEST m=+0.023541001
+// 2023-10-23 08:31:07.8687134 +0200 CEST m=+0.012222901

 package option

+
 import (
 	A "github.com/IBM/fp-go/internal/apply"
 	T "github.com/IBM/fp-go/tuple"
 )
-
 // optionize converts a nullary function to an option
 func optionize[R any](f func() (R, bool)) Option[R] {
 	if r, ok := f(); ok {
--- a/reader/gen.go
+++ b/reader/gen.go
@@ -1,9 +1,10 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-09-12 13:44:36.1655251 +0200 CEST m=+0.010000501
+// 2023-10-23 08:31:13.0131834 +0200 CEST m=+0.010996501

 package reader

+
 import (
 	G "github.com/IBM/fp-go/reader/generic"	
 )
--- a/reader/generic/gen.go
+++ b/reader/generic/gen.go
@@ -1,8 +1,9 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-09-12 13:44:36.166526 +0200 CEST m=+0.011001401
+// 2023-10-23 08:31:13.0131834 +0200 CEST m=+0.010996501
 package generic

+
 // From0 converts a function with 1 parameters returning a [R] into a function with 0 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From0[GRA ~func(C) R, F ~func(C) R, C, R any](f F) func() GRA {
--- a/readereither/sequence_test.go
+++ b/readereither/sequence_test.go
@@ -25,58 +25,58 @@ import (
 )

 var (
-	testError = fmt.Errorf("error")
+	errFoo = fmt.Errorf("error")
 )

 func TestSequenceT1(t *testing.T) {

 	t1 := Of[MyContext, error]("s1")
-	e1 := Left[MyContext, string](testError)
+	e1 := Left[MyContext, string](errFoo)

 	res1 := SequenceT1(t1)
 	assert.Equal(t, E.Of[error](T.MakeTuple1("s1")), res1(defaultContext))

 	res2 := SequenceT1(e1)
-	assert.Equal(t, E.Left[T.Tuple1[string]](testError), res2(defaultContext))
+	assert.Equal(t, E.Left[T.Tuple1[string]](errFoo), res2(defaultContext))
 }

 func TestSequenceT2(t *testing.T) {

 	t1 := Of[MyContext, error]("s1")
-	e1 := Left[MyContext, string](testError)
+	e1 := Left[MyContext, string](errFoo)
 	t2 := Of[MyContext, error](2)
-	e2 := Left[MyContext, int](testError)
+	e2 := Left[MyContext, int](errFoo)

 	res1 := SequenceT2(t1, t2)
 	assert.Equal(t, E.Of[error](T.MakeTuple2("s1", 2)), res1(defaultContext))

 	res2 := SequenceT2(e1, t2)
-	assert.Equal(t, E.Left[T.Tuple2[string, int]](testError), res2(defaultContext))
+	assert.Equal(t, E.Left[T.Tuple2[string, int]](errFoo), res2(defaultContext))

 	res3 := SequenceT2(t1, e2)
-	assert.Equal(t, E.Left[T.Tuple2[string, int]](testError), res3(defaultContext))
+	assert.Equal(t, E.Left[T.Tuple2[string, int]](errFoo), res3(defaultContext))
 }

 func TestSequenceT3(t *testing.T) {

 	t1 := Of[MyContext, error]("s1")
-	e1 := Left[MyContext, string](testError)
+	e1 := Left[MyContext, string](errFoo)
 	t2 := Of[MyContext, error](2)
-	e2 := Left[MyContext, int](testError)
+	e2 := Left[MyContext, int](errFoo)
 	t3 := Of[MyContext, error](true)
-	e3 := Left[MyContext, bool](testError)
+	e3 := Left[MyContext, bool](errFoo)

 	res1 := SequenceT3(t1, t2, t3)
 	assert.Equal(t, E.Of[error](T.MakeTuple3("s1", 2, true)), res1(defaultContext))

 	res2 := SequenceT3(e1, t2, t3)
-	assert.Equal(t, E.Left[T.Tuple3[string, int, bool]](testError), res2(defaultContext))
+	assert.Equal(t, E.Left[T.Tuple3[string, int, bool]](errFoo), res2(defaultContext))

 	res3 := SequenceT3(t1, e2, t3)
-	assert.Equal(t, E.Left[T.Tuple3[string, int, bool]](testError), res3(defaultContext))
+	assert.Equal(t, E.Left[T.Tuple3[string, int, bool]](errFoo), res3(defaultContext))

 	res4 := SequenceT3(t1, t2, e3)
-	assert.Equal(t, E.Left[T.Tuple3[string, int, bool]](testError), res4(defaultContext))
+	assert.Equal(t, E.Left[T.Tuple3[string, int, bool]](errFoo), res4(defaultContext))
 }

 func TestSequenceT4(t *testing.T) {
--- a/readerio/generic/sync.go
+++ b/readerio/generic/sync.go
@@ -0,0 +1,34 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	"context"
+
+	F "github.com/IBM/fp-go/function"
+	G "github.com/IBM/fp-go/io/generic"
+)
+
+// WithLock executes the provided IO operation in the scope of a lock
+func WithLock[GEA ~func(R) GIOA, GIOA ~func() A, R, A any](lock func() context.CancelFunc) func(fa GEA) GEA {
+	l := G.WithLock[GIOA](lock)
+	return func(fa GEA) GEA {
+		return F.Flow2(
+			fa,
+			l,
+		)
+	}
+}
--- a/context/readerio/type.go
+++ b/context/readerio/type.go
@@ -13,14 +13,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-// Package readerio implements a specialization of the ReaderIO monad assuming a golang context as the context of the monad
 package readerio

 import (
 	"context"

-	R "github.com/IBM/fp-go/readerio"
+	G "github.com/IBM/fp-go/readerio/generic"
 )

-// ReaderIO is a specialization of the ReaderIO monad assuming a golang context as the context of the monad
-type ReaderIO[A any] R.ReaderIO[context.Context, A]
+// WithLock executes the provided IO operation in the scope of a lock
+func WithLock[R, A any](lock func() context.CancelFunc) func(fa ReaderIO[R, A]) ReaderIO[R, A] {
+	return G.WithLock[ReaderIO[R, A]](lock)
+}
--- a/readerioeither/gen.go
+++ b/readerioeither/gen.go
@@ -1,9 +1,10 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-09-12 13:44:37.5566477 +0200 CEST m=+0.009011201
+// 2023-10-23 08:31:16.2414489 +0200 CEST m=+0.013052301

 package readerioeither

+
 import (
 	G "github.com/IBM/fp-go/readerioeither/generic"	
 )
--- a/readerioeither/generic/bracket.go
+++ b/readerioeither/generic/bracket.go
@@ -17,7 +17,7 @@ package generic

 import (
 	ET "github.com/IBM/fp-go/either"
-	G "github.com/IBM/fp-go/internal/file"
+	G "github.com/IBM/fp-go/internal/bracket"
 	I "github.com/IBM/fp-go/readerio/generic"
 )

--- a/readerioeither/generic/gen.go
+++ b/readerioeither/generic/gen.go
@@ -1,8 +1,9 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-09-12 13:44:37.5566477 +0200 CEST m=+0.009011201
+// 2023-10-23 08:31:16.241979 +0200 CEST m=+0.013582401
 package generic

+
 import (
 	E "github.com/IBM/fp-go/either"
 	RD "github.com/IBM/fp-go/reader/generic"
@@ -22,8 +23,7 @@ func Eitherize0[GRA ~func(C) GIOA, F ~func(C) (R, error), GIOA ~func() E.Either[
  return From0[GRA](func(r C) func() (R, error) {
    return func() (R, error) {
      return f(r)
-		}
-	})
+    }})
 }

 // From1 converts a function with 2 parameters returning a tuple into a function with 1 parameters returning a [GRA]
@@ -40,8 +40,7 @@ func Eitherize1[GRA ~func(C) GIOA, F ~func(C, T0) (R, error), GIOA ~func() E.Eit
  return From1[GRA](func(r C, t0 T0) func() (R, error) {
    return func() (R, error) {
      return f(r, t0)
-		}
-	})
+    }})
 }

 // From2 converts a function with 3 parameters returning a tuple into a function with 2 parameters returning a [GRA]
@@ -58,8 +57,7 @@ func Eitherize2[GRA ~func(C) GIOA, F ~func(C, T0, T1) (R, error), GIOA ~func() E
  return From2[GRA](func(r C, t0 T0, t1 T1) func() (R, error) {
    return func() (R, error) {
      return f(r, t0, t1)
-		}
-	})
+    }})
 }

 // From3 converts a function with 4 parameters returning a tuple into a function with 3 parameters returning a [GRA]
@@ -76,8 +74,7 @@ func Eitherize3[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2) (R, error), GIOA ~func
  return From3[GRA](func(r C, t0 T0, t1 T1, t2 T2) func() (R, error) {
    return func() (R, error) {
      return f(r, t0, t1, t2)
-		}
-	})
+    }})
 }

 // From4 converts a function with 5 parameters returning a tuple into a function with 4 parameters returning a [GRA]
@@ -94,8 +91,7 @@ func Eitherize4[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3) (R, error), GIOA ~
  return From4[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3) func() (R, error) {
    return func() (R, error) {
      return f(r, t0, t1, t2, t3)
-		}
-	})
+    }})
 }

 // From5 converts a function with 6 parameters returning a tuple into a function with 5 parameters returning a [GRA]
@@ -112,8 +108,7 @@ func Eitherize5[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4) (R, error), GI
  return From5[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) func() (R, error) {
    return func() (R, error) {
      return f(r, t0, t1, t2, t3, t4)
-		}
-	})
+    }})
 }

 // From6 converts a function with 7 parameters returning a tuple into a function with 6 parameters returning a [GRA]
@@ -130,8 +125,7 @@ func Eitherize6[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5) (R, error)
  return From6[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) func() (R, error) {
    return func() (R, error) {
      return f(r, t0, t1, t2, t3, t4, t5)
-		}
-	})
+    }})
 }

 // From7 converts a function with 8 parameters returning a tuple into a function with 7 parameters returning a [GRA]
@@ -148,8 +142,7 @@ func Eitherize7[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6) (R, er
  return From7[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) func() (R, error) {
    return func() (R, error) {
      return f(r, t0, t1, t2, t3, t4, t5, t6)
-		}
-	})
+    }})
 }

 // From8 converts a function with 9 parameters returning a tuple into a function with 8 parameters returning a [GRA]
@@ -166,8 +159,7 @@ func Eitherize8[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R
  return From8[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) func() (R, error) {
    return func() (R, error) {
      return f(r, t0, t1, t2, t3, t4, t5, t6, t7)
-		}
-	})
+    }})
 }

 // From9 converts a function with 10 parameters returning a tuple into a function with 9 parameters returning a [GRA]
@@ -184,8 +176,7 @@ func Eitherize9[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8
  return From9[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) func() (R, error) {
    return func() (R, error) {
      return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8)
-		}
-	})
+    }})
 }

 // From10 converts a function with 11 parameters returning a tuple into a function with 10 parameters returning a [GRA]
@@ -202,6 +193,5 @@ func Eitherize10[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T
  return From10[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) func() (R, error) {
    return func() (R, error) {
      return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
-		}
-	})
+    }})
 }
--- a/readerioeither/generic/sync.go
+++ b/readerioeither/generic/sync.go
@@ -0,0 +1,28 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	"context"
+
+	ET "github.com/IBM/fp-go/either"
+	G "github.com/IBM/fp-go/readerio/generic"
+)
+
+// WithLock executes the provided IO operation in the scope of a lock
+func WithLock[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](lock func() context.CancelFunc) func(fa GEA) GEA {
+	return G.WithLock[GEA](lock)
+}
--- a/readerioeither/sync.go
+++ b/readerioeither/sync.go
@@ -0,0 +1,27 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES 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"
+
+	G "github.com/IBM/fp-go/readerioeither/generic"
+)
+
+// WithLock executes the provided IO operation in the scope of a lock
+func WithLock[R, E, A any](lock func() context.CancelFunc) func(fa ReaderIOEither[R, E, A]) ReaderIOEither[R, E, A] {
+	return G.WithLock[ReaderIOEither[R, E, A]](lock)
+}
--- a/samples/mostly-adequate/chapter08_tupperware_test.go
+++ b/samples/mostly-adequate/chapter08_tupperware_test.go
@@ -105,7 +105,7 @@ var (
 	)

 	// checkActive :: User -> Either error User
-	checkActive = E.FromPredicate(Chapter08User.isActive, F.Constant1[Chapter08User](fmt.Errorf("Your account is not active")))
+	checkActive = E.FromPredicate(Chapter08User.isActive, F.Constant1[Chapter08User](fmt.Errorf("your account is not active")))

 	// validateUser :: (User -> Either String ()) -> User -> Either String User
 	validateUser = F.Curry2(func(validate func(Chapter08User) E.Either[error, any], user Chapter08User) E.Either[error, Chapter08User] {
@@ -235,7 +235,7 @@ func Example_solution08C() {
 	fmt.Println(eitherWelcome(theresa08))

 	// Output:
-	// Left[*errors.errorString, string](Your account is not active)
+	// Left[*errors.errorString, string](your account is not active)
 	// Right[<nil>, string](Welcome Theresa)
 }

--- a/samples/tuples/tuple_test.go
+++ b/samples/tuples/tuple_test.go
@@ -58,10 +58,8 @@ func TestSampleConvertDocx2(t *testing.T) {
 	// The disadvantage is that its input has to exist in memory which is probably not a good
 	// idea for large inputs
 	convertDocx := func(data []byte) E.Either[error, T.Tuple2[string, map[string]string]] {
-		return E.TryCatchError(func() (T.Tuple2[string, map[string]string], error) {
 		text, meta, err := sampleConvertDocx(bytes.NewReader(data))
-			return T.MakeTuple2(text, meta), err
-		})
+		return E.TryCatchError(T.MakeTuple2(text, meta), err)
 	}

 	resE := convertDocx([]byte("abc"))
--- a/test.bat
+++ b/test.bat
@@ -1,3 +1,3 @@
@echo off
 mkdir build 2> NUL
-gotip test .\... && go1.20.1 test .\... && go test -v -coverprofile build/cover.out -coverpkg=./... -covermode=atomic .\...
+gotip test .\... && go1.20.5 test .\... && go test -v -coverprofile build/cover.out -coverpkg=./... -covermode=atomic .\...
--- a/tuple/gen.go
+++ b/tuple/gen.go
@@ -1,12 +1,13 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-09-12 13:44:39.7573676 +0200 CEST m=+0.040374701
+// 2023-10-23 08:31:19.0449107 +0200 CEST m=+0.023307601

 package tuple

+
 import (
-	"encoding/json"
 	"fmt"
+	"encoding/json"
 	M "github.com/IBM/fp-go/monoid"
 	O "github.com/IBM/fp-go/ord"	
 )
@@ -137,9 +138,7 @@ func Monoid1[T1 any](m1 M.Monoid[T1]) M.Monoid[Tuple1[T1]] {
 // Ord1 creates n [Ord] for a [Tuple1] based on 1 [Ord]s for the contained types
 func Ord1[T1 any](o1 O.Ord[T1]) O.Ord[Tuple1[T1]] {
  return O.MakeOrd(func(l, r Tuple1[T1]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
    return 0
  }, func(l, r Tuple1[T1]) bool {
    return o1.Equals(l.F1, r.F1)
@@ -173,14 +172,10 @@ func (t Tuple1[T1]) MarshalJSON() ([]byte, error) {
 // UnmarshalJSON unmarshals a JSON array into a [Tuple1]
 func (t *Tuple1[T1]) UnmarshalJSON(data []byte) error {
  var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
+  if err := json.Unmarshal(data, &tmp); err != nil {return err}
  l := len(tmp)
  if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
+  if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
  }
  return nil
 }
@@ -243,12 +238,8 @@ func Monoid2[T1, T2 any](m1 M.Monoid[T1], m2 M.Monoid[T2]) M.Monoid[Tuple2[T1, T
 // Ord2 creates n [Ord] for a [Tuple2] based on 2 [Ord]s for the contained types
 func Ord2[T1, T2 any](o1 O.Ord[T1], o2 O.Ord[T2]) O.Ord[Tuple2[T1, T2]] {
  return O.MakeOrd(func(l, r Tuple2[T1, T2]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
    return 0
  }, func(l, r Tuple2[T1, T2]) bool {
    return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2)
@@ -283,20 +274,13 @@ func (t Tuple2[T1, T2]) MarshalJSON() ([]byte, error) {
 // UnmarshalJSON unmarshals a JSON array into a [Tuple2]
 func (t *Tuple2[T1, T2]) UnmarshalJSON(data []byte) error {
  var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
+  if err := json.Unmarshal(data, &tmp); err != nil {return err}
  l := len(tmp)
  if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
+  if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
  if l > 1 {
-			if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
-				return err
-			}
-		}
-	}
+  if err := json.Unmarshal(tmp[1], &t.F2); err != nil {return err}
+  }}
  return nil
 }

@@ -360,15 +344,9 @@ func Monoid3[T1, T2, T3 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3])
 // Ord3 creates n [Ord] for a [Tuple3] based on 3 [Ord]s for the contained types
 func Ord3[T1, T2, T3 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3]) O.Ord[Tuple3[T1, T2, T3]] {
  return O.MakeOrd(func(l, r Tuple3[T1, T2, T3]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
    return 0
  }, func(l, r Tuple3[T1, T2, T3]) bool {
    return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3)
@@ -404,25 +382,15 @@ func (t Tuple3[T1, T2, T3]) MarshalJSON() ([]byte, error) {
 // UnmarshalJSON unmarshals a JSON array into a [Tuple3]
 func (t *Tuple3[T1, T2, T3]) UnmarshalJSON(data []byte) error {
  var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
+  if err := json.Unmarshal(data, &tmp); err != nil {return err}
  l := len(tmp)
  if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
+  if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
  if l > 1 {
-			if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
-				return err
-			}
+  if err := json.Unmarshal(tmp[1], &t.F2); err != nil {return err}
  if l > 2 {
-				if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
-					return err
-				}
-			}
-		}
-	}
+  if err := json.Unmarshal(tmp[2], &t.F3); err != nil {return err}
+  }}}
  return nil
 }

@@ -488,18 +456,10 @@ func Monoid4[T1, T2, T3, T4 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T
 // Ord4 creates n [Ord] for a [Tuple4] based on 4 [Ord]s for the contained types
 func Ord4[T1, T2, T3, T4 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4]) O.Ord[Tuple4[T1, T2, T3, T4]] {
  return O.MakeOrd(func(l, r Tuple4[T1, T2, T3, T4]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
    return 0
  }, func(l, r Tuple4[T1, T2, T3, T4]) bool {
    return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4)
@@ -536,30 +496,17 @@ func (t Tuple4[T1, T2, T3, T4]) MarshalJSON() ([]byte, error) {
 // UnmarshalJSON unmarshals a JSON array into a [Tuple4]
 func (t *Tuple4[T1, T2, T3, T4]) UnmarshalJSON(data []byte) error {
  var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
+  if err := json.Unmarshal(data, &tmp); err != nil {return err}
  l := len(tmp)
  if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
+  if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
  if l > 1 {
-			if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
-				return err
-			}
+  if err := json.Unmarshal(tmp[1], &t.F2); err != nil {return err}
  if l > 2 {
-				if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
-					return err
-				}
+  if err := json.Unmarshal(tmp[2], &t.F3); err != nil {return err}
  if l > 3 {
-					if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
-						return err
-					}
-				}
-			}
-		}
-	}
+  if err := json.Unmarshal(tmp[3], &t.F4); err != nil {return err}
+  }}}}
  return nil
 }

@@ -627,21 +574,11 @@ func Monoid5[T1, T2, T3, T4, T5 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Mono
 // Ord5 creates n [Ord] for a [Tuple5] based on 5 [Ord]s for the contained types
 func Ord5[T1, T2, T3, T4, T5 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5]) O.Ord[Tuple5[T1, T2, T3, T4, T5]] {
  return O.MakeOrd(func(l, r Tuple5[T1, T2, T3, T4, T5]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
-		if c := o5.Compare(l.F5, r.F5); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
+    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
    return 0
  }, func(l, r Tuple5[T1, T2, T3, T4, T5]) bool {
    return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5)
@@ -679,35 +616,19 @@ func (t Tuple5[T1, T2, T3, T4, T5]) MarshalJSON() ([]byte, error) {
 // UnmarshalJSON unmarshals a JSON array into a [Tuple5]
 func (t *Tuple5[T1, T2, T3, T4, T5]) UnmarshalJSON(data []byte) error {
  var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
+  if err := json.Unmarshal(data, &tmp); err != nil {return err}
  l := len(tmp)
  if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
+  if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
  if l > 1 {
-			if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
-				return err
-			}
+  if err := json.Unmarshal(tmp[1], &t.F2); err != nil {return err}
  if l > 2 {
-				if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
-					return err
-				}
+  if err := json.Unmarshal(tmp[2], &t.F3); err != nil {return err}
  if l > 3 {
-					if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
-						return err
-					}
+  if err := json.Unmarshal(tmp[3], &t.F4); err != nil {return err}
  if l > 4 {
-						if err := json.Unmarshal(tmp[4], &t.F5); err != nil {
-							return err
-						}
-					}
-				}
-			}
-		}
-	}
+  if err := json.Unmarshal(tmp[4], &t.F5); err != nil {return err}
+  }}}}}
  return nil
 }

@@ -777,24 +698,12 @@ func Monoid6[T1, T2, T3, T4, T5, T6 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.
 // Ord6 creates n [Ord] for a [Tuple6] based on 6 [Ord]s for the contained types
 func Ord6[T1, T2, T3, T4, T5, T6 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6]) O.Ord[Tuple6[T1, T2, T3, T4, T5, T6]] {
  return O.MakeOrd(func(l, r Tuple6[T1, T2, T3, T4, T5, T6]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
-		if c := o5.Compare(l.F5, r.F5); c != 0 {
-			return c
-		}
-		if c := o6.Compare(l.F6, r.F6); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
+    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
+    if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
    return 0
  }, func(l, r Tuple6[T1, T2, T3, T4, T5, T6]) bool {
    return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6)
@@ -833,40 +742,21 @@ func (t Tuple6[T1, T2, T3, T4, T5, T6]) MarshalJSON() ([]byte, error) {
 // UnmarshalJSON unmarshals a JSON array into a [Tuple6]
 func (t *Tuple6[T1, T2, T3, T4, T5, T6]) UnmarshalJSON(data []byte) error {
  var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
+  if err := json.Unmarshal(data, &tmp); err != nil {return err}
  l := len(tmp)
  if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
+  if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
  if l > 1 {
-			if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
-				return err
-			}
+  if err := json.Unmarshal(tmp[1], &t.F2); err != nil {return err}
  if l > 2 {
-				if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
-					return err
-				}
+  if err := json.Unmarshal(tmp[2], &t.F3); err != nil {return err}
  if l > 3 {
-					if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
-						return err
-					}
+  if err := json.Unmarshal(tmp[3], &t.F4); err != nil {return err}
  if l > 4 {
-						if err := json.Unmarshal(tmp[4], &t.F5); err != nil {
-							return err
-						}
+  if err := json.Unmarshal(tmp[4], &t.F5); err != nil {return err}
  if l > 5 {
-							if err := json.Unmarshal(tmp[5], &t.F6); err != nil {
-								return err
-							}
-						}
-					}
-				}
-			}
-		}
-	}
+  if err := json.Unmarshal(tmp[5], &t.F6); err != nil {return err}
+  }}}}}}
  return nil
 }

@@ -938,27 +828,13 @@ func Monoid7[T1, T2, T3, T4, T5, T6, T7 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m
 // Ord7 creates n [Ord] for a [Tuple7] based on 7 [Ord]s for the contained types
 func Ord7[T1, T2, T3, T4, T5, T6, T7 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7]) O.Ord[Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
  return O.MakeOrd(func(l, r Tuple7[T1, T2, T3, T4, T5, T6, T7]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
-		if c := o5.Compare(l.F5, r.F5); c != 0 {
-			return c
-		}
-		if c := o6.Compare(l.F6, r.F6); c != 0 {
-			return c
-		}
-		if c := o7.Compare(l.F7, r.F7); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
+    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
+    if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
+    if c:= o7.Compare(l.F7, r.F7); c != 0 {return c}
    return 0
  }, func(l, r Tuple7[T1, T2, T3, T4, T5, T6, T7]) bool {
    return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7)
@@ -998,45 +874,23 @@ func (t Tuple7[T1, T2, T3, T4, T5, T6, T7]) MarshalJSON() ([]byte, error) {
 // UnmarshalJSON unmarshals a JSON array into a [Tuple7]
 func (t *Tuple7[T1, T2, T3, T4, T5, T6, T7]) UnmarshalJSON(data []byte) error {
  var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
+  if err := json.Unmarshal(data, &tmp); err != nil {return err}
  l := len(tmp)
  if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
+  if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
  if l > 1 {
-			if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
-				return err
-			}
+  if err := json.Unmarshal(tmp[1], &t.F2); err != nil {return err}
  if l > 2 {
-				if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
-					return err
-				}
+  if err := json.Unmarshal(tmp[2], &t.F3); err != nil {return err}
  if l > 3 {
-					if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
-						return err
-					}
+  if err := json.Unmarshal(tmp[3], &t.F4); err != nil {return err}
  if l > 4 {
-						if err := json.Unmarshal(tmp[4], &t.F5); err != nil {
-							return err
-						}
+  if err := json.Unmarshal(tmp[4], &t.F5); err != nil {return err}
  if l > 5 {
-							if err := json.Unmarshal(tmp[5], &t.F6); err != nil {
-								return err
-							}
+  if err := json.Unmarshal(tmp[5], &t.F6); err != nil {return err}
  if l > 6 {
-								if err := json.Unmarshal(tmp[6], &t.F7); err != nil {
-									return err
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-	}
+  if err := json.Unmarshal(tmp[6], &t.F7); err != nil {return err}
+  }}}}}}}
  return nil
 }

@@ -1110,30 +964,14 @@ func Monoid8[T1, T2, T3, T4, T5, T6, T7, T8 any](m1 M.Monoid[T1], m2 M.Monoid[T2
 // Ord8 creates n [Ord] for a [Tuple8] based on 8 [Ord]s for the contained types
 func Ord8[T1, T2, T3, T4, T5, T6, T7, T8 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7], o8 O.Ord[T8]) O.Ord[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
  return O.MakeOrd(func(l, r Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
-		if c := o5.Compare(l.F5, r.F5); c != 0 {
-			return c
-		}
-		if c := o6.Compare(l.F6, r.F6); c != 0 {
-			return c
-		}
-		if c := o7.Compare(l.F7, r.F7); c != 0 {
-			return c
-		}
-		if c := o8.Compare(l.F8, r.F8); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
+    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
+    if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
+    if c:= o7.Compare(l.F7, r.F7); c != 0 {return c}
+    if c:= o8.Compare(l.F8, r.F8); c != 0 {return c}
    return 0
  }, func(l, r Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) bool {
    return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7) && o8.Equals(l.F8, r.F8)
@@ -1174,50 +1012,25 @@ func (t Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) MarshalJSON() ([]byte, error) {
 // UnmarshalJSON unmarshals a JSON array into a [Tuple8]
 func (t *Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) UnmarshalJSON(data []byte) error {
  var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
+  if err := json.Unmarshal(data, &tmp); err != nil {return err}
  l := len(tmp)
  if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
+  if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
  if l > 1 {
-			if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
-				return err
-			}
+  if err := json.Unmarshal(tmp[1], &t.F2); err != nil {return err}
  if l > 2 {
-				if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
-					return err
-				}
+  if err := json.Unmarshal(tmp[2], &t.F3); err != nil {return err}
  if l > 3 {
-					if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
-						return err
-					}
+  if err := json.Unmarshal(tmp[3], &t.F4); err != nil {return err}
  if l > 4 {
-						if err := json.Unmarshal(tmp[4], &t.F5); err != nil {
-							return err
-						}
+  if err := json.Unmarshal(tmp[4], &t.F5); err != nil {return err}
  if l > 5 {
-							if err := json.Unmarshal(tmp[5], &t.F6); err != nil {
-								return err
-							}
+  if err := json.Unmarshal(tmp[5], &t.F6); err != nil {return err}
  if l > 6 {
-								if err := json.Unmarshal(tmp[6], &t.F7); err != nil {
-									return err
-								}
+  if err := json.Unmarshal(tmp[6], &t.F7); err != nil {return err}
  if l > 7 {
-									if err := json.Unmarshal(tmp[7], &t.F8); err != nil {
-										return err
-									}
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-	}
+  if err := json.Unmarshal(tmp[7], &t.F8); err != nil {return err}
+  }}}}}}}}
  return nil
 }

@@ -1293,33 +1106,15 @@ func Monoid9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](m1 M.Monoid[T1], m2 M.Monoi
 // Ord9 creates n [Ord] for a [Tuple9] based on 9 [Ord]s for the contained types
 func Ord9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7], o8 O.Ord[T8], o9 O.Ord[T9]) O.Ord[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
  return O.MakeOrd(func(l, r Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
-		if c := o5.Compare(l.F5, r.F5); c != 0 {
-			return c
-		}
-		if c := o6.Compare(l.F6, r.F6); c != 0 {
-			return c
-		}
-		if c := o7.Compare(l.F7, r.F7); c != 0 {
-			return c
-		}
-		if c := o8.Compare(l.F8, r.F8); c != 0 {
-			return c
-		}
-		if c := o9.Compare(l.F9, r.F9); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
+    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
+    if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
+    if c:= o7.Compare(l.F7, r.F7); c != 0 {return c}
+    if c:= o8.Compare(l.F8, r.F8); c != 0 {return c}
+    if c:= o9.Compare(l.F9, r.F9); c != 0 {return c}
    return 0
  }, func(l, r Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) bool {
    return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7) && o8.Equals(l.F8, r.F8) && o9.Equals(l.F9, r.F9)
@@ -1361,55 +1156,27 @@ func (t Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) MarshalJSON() ([]byte, error
 // UnmarshalJSON unmarshals a JSON array into a [Tuple9]
 func (t *Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) UnmarshalJSON(data []byte) error {
  var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
+  if err := json.Unmarshal(data, &tmp); err != nil {return err}
  l := len(tmp)
  if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
+  if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
  if l > 1 {
-			if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
-				return err
-			}
+  if err := json.Unmarshal(tmp[1], &t.F2); err != nil {return err}
  if l > 2 {
-				if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
-					return err
-				}
+  if err := json.Unmarshal(tmp[2], &t.F3); err != nil {return err}
  if l > 3 {
-					if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
-						return err
-					}
+  if err := json.Unmarshal(tmp[3], &t.F4); err != nil {return err}
  if l > 4 {
-						if err := json.Unmarshal(tmp[4], &t.F5); err != nil {
-							return err
-						}
+  if err := json.Unmarshal(tmp[4], &t.F5); err != nil {return err}
  if l > 5 {
-							if err := json.Unmarshal(tmp[5], &t.F6); err != nil {
-								return err
-							}
+  if err := json.Unmarshal(tmp[5], &t.F6); err != nil {return err}
  if l > 6 {
-								if err := json.Unmarshal(tmp[6], &t.F7); err != nil {
-									return err
-								}
+  if err := json.Unmarshal(tmp[6], &t.F7); err != nil {return err}
  if l > 7 {
-									if err := json.Unmarshal(tmp[7], &t.F8); err != nil {
-										return err
-									}
+  if err := json.Unmarshal(tmp[7], &t.F8); err != nil {return err}
  if l > 8 {
-										if err := json.Unmarshal(tmp[8], &t.F9); err != nil {
-											return err
-										}
-									}
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-	}
+  if err := json.Unmarshal(tmp[8], &t.F9); err != nil {return err}
+  }}}}}}}}}
  return nil
 }

@@ -1487,36 +1254,16 @@ func Monoid10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](m1 M.Monoid[T1], m2 M
 // Ord10 creates n [Ord] for a [Tuple10] based on 10 [Ord]s for the contained types
 func Ord10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7], o8 O.Ord[T8], o9 O.Ord[T9], o10 O.Ord[T10]) O.Ord[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
  return O.MakeOrd(func(l, r Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
-		if c := o5.Compare(l.F5, r.F5); c != 0 {
-			return c
-		}
-		if c := o6.Compare(l.F6, r.F6); c != 0 {
-			return c
-		}
-		if c := o7.Compare(l.F7, r.F7); c != 0 {
-			return c
-		}
-		if c := o8.Compare(l.F8, r.F8); c != 0 {
-			return c
-		}
-		if c := o9.Compare(l.F9, r.F9); c != 0 {
-			return c
-		}
-		if c := o10.Compare(l.F10, r.F10); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
+    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
+    if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
+    if c:= o7.Compare(l.F7, r.F7); c != 0 {return c}
+    if c:= o8.Compare(l.F8, r.F8); c != 0 {return c}
+    if c:= o9.Compare(l.F9, r.F9); c != 0 {return c}
+    if c:= o10.Compare(l.F10, r.F10); c != 0 {return c}
    return 0
  }, func(l, r Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) bool {
    return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7) && o8.Equals(l.F8, r.F8) && o9.Equals(l.F9, r.F9) && o10.Equals(l.F10, r.F10)
@@ -1559,60 +1306,29 @@ func (t Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) MarshalJSON() ([]byte,
 // UnmarshalJSON unmarshals a JSON array into a [Tuple10]
 func (t *Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) UnmarshalJSON(data []byte) error {
  var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
+  if err := json.Unmarshal(data, &tmp); err != nil {return err}
  l := len(tmp)
  if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
+  if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
  if l > 1 {
-			if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
-				return err
-			}
+  if err := json.Unmarshal(tmp[1], &t.F2); err != nil {return err}
  if l > 2 {
-				if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
-					return err
-				}
+  if err := json.Unmarshal(tmp[2], &t.F3); err != nil {return err}
  if l > 3 {
-					if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
-						return err
-					}
+  if err := json.Unmarshal(tmp[3], &t.F4); err != nil {return err}
  if l > 4 {
-						if err := json.Unmarshal(tmp[4], &t.F5); err != nil {
-							return err
-						}
+  if err := json.Unmarshal(tmp[4], &t.F5); err != nil {return err}
  if l > 5 {
-							if err := json.Unmarshal(tmp[5], &t.F6); err != nil {
-								return err
-							}
+  if err := json.Unmarshal(tmp[5], &t.F6); err != nil {return err}
  if l > 6 {
-								if err := json.Unmarshal(tmp[6], &t.F7); err != nil {
-									return err
-								}
+  if err := json.Unmarshal(tmp[6], &t.F7); err != nil {return err}
  if l > 7 {
-									if err := json.Unmarshal(tmp[7], &t.F8); err != nil {
-										return err
-									}
+  if err := json.Unmarshal(tmp[7], &t.F8); err != nil {return err}
  if l > 8 {
-										if err := json.Unmarshal(tmp[8], &t.F9); err != nil {
-											return err
-										}
+  if err := json.Unmarshal(tmp[8], &t.F9); err != nil {return err}
  if l > 9 {
-											if err := json.Unmarshal(tmp[9], &t.F10); err != nil {
-												return err
-											}
-										}
-									}
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-	}
+  if err := json.Unmarshal(tmp[9], &t.F10); err != nil {return err}
+  }}}}}}}}}}
  return nil
 }
Author	SHA1	Message	Date
Carsten Leue	88bf35c4af	Merge pull request #72 from IBM/cleue-improve-with-lock Cleanup Either, context.Reader and context.ReaderIO	2023-10-23 09:06:22 +02:00
Dr. Carsten Leue	da3c9683eb	fix: remove Reader and ReaderEither for context since they do not make sense Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2023-10-23 09:05:10 +02:00
Dr. Carsten Leue	08d9fed9af	fix: remove unnecesary indirection in E.TryCatch Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2023-10-23 08:36:32 +02:00
Carsten Leue	83a0c6cdef	Merge pull request #71 from IBM/cleue-add-mutex-to-io fix: add WithLock to limit concurrency	2023-10-22 21:08:06 +02:00
Dr. Carsten Leue	9da484b79e	fix: add WithLock to limit concurrency Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2023-10-22 21:07:40 +02:00
Carsten Leue	e46cfd89d4	Merge pull request #70 from IBM/cleue-add-bool-package fix: add monoid for bool	2023-10-12 21:39:03 +02:00