fix: add Do and Bind support to Monads

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

.github/workflows/build.yml

@@ -26,7 +26,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-version: [ '1.20.x', '1.21.x', '1.22.x']
+        go-version: [ '1.20.x', '1.21.x']
     steps:
       # full checkout for semantic-release
       - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
@@ -60,7 +60,7 @@ jobs:
           fetch-depth: 0
 
       - name: Set up Node.js ${{ env.NODE_VERSION }}
-        uses: actions/setup-node@60edb5dd545a775178f52524783378180af0d1f8 # v4.0.2
+        uses: actions/setup-node@b39b52d1213e96004bfcb1c61a8a6fa8ab84f3e8 # v4.0.1
         with:
           node-version: ${{ env.NODE_VERSION }}
 

array/array.go

@@ -58,7 +58,7 @@ func MapWithIndex[A, B any](f func(int, A) B) func([]A) []B {
 }
 
 func Map[A, B any](f func(a A) B) func([]A) []B {
-	return G.Map[[]A, []B, A, B](f)
+	return F.Bind2nd(MonadMap[A, B], f)
 }
 
 func MapRef[A, B any](f func(a *A) B) func([]A) []B {

array/generic/array.go

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

array/generic/monad.go

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

array/monad.go

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

array/nonempty/array.go

@@ -44,11 +44,11 @@ func From[A any](first A, data ...A) NonEmptyArray[A] {
 	return buffer
 }
 
-func IsEmpty[A any](_ NonEmptyArray[A]) bool {
+func IsEmpty[A any](as NonEmptyArray[A]) bool {
 	return false
 }
 
-func IsNonEmpty[A any](_ NonEmptyArray[A]) bool {
+func IsNonEmpty[A any](as NonEmptyArray[A]) bool {
 	return true
 }
 

bounded/bounded.go

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

bytes/bytes.go

@@ -15,10 +15,6 @@
 
 package bytes
 
-func Empty() []byte {
-	return Monoid.Empty()
-}
-
 func ToString(a []byte) string {
 	return string(a)
 }

cli/pipe.go

@@ -265,15 +265,10 @@ func generatePipe(f *os.File, i int) {
 		fmt.Fprintf(f, ", f%d F%d", j, j)
 	}
 	fmt.Fprintf(f, ") T%d {\n", i)
-	fmt.Fprintf(f, "  return ")
-	for j := i; j >= 1; j-- {
-		fmt.Fprintf(f, "f%d(", j)
-	}
-	fmt.Fprintf(f, "t0")
 	for j := 1; j <= i; j++ {
-		fmt.Fprintf(f, ")")
+		fmt.Fprintf(f, "  t%d := f%d(t%d)\n", j, j, j-1)
 	}
-	fmt.Fprintf(f, "\n")
+	fmt.Fprintf(f, "  return t%d\n", i)
 	fmt.Fprintln(f, "}")
 }
 

cli/tuple.go

@@ -405,6 +405,8 @@ func generateTupleHelpers(filename string, count int) error {
 
 	fmt.Fprintf(f, `
 import (
+	"fmt"
+	"encoding/json"
 	M "github.com/IBM/fp-go/monoid"
 	O "github.com/IBM/fp-go/ord"	
 )
@@ -455,7 +457,7 @@ func generateTupleMarshal(f *os.File, i int) {
 	fmt.Fprintf(f, "func (t ")
 	writeTupleType(f, "T", i)
 	fmt.Fprintf(f, ") MarshalJSON() ([]byte, error) {\n")
-	fmt.Fprintf(f, "  return tupleMarshalJSON(")
+	fmt.Fprintf(f, "  return json.Marshal([]any{")
 	// function prototypes
 	for j := 1; j <= i; j++ {
 		if j > 1 {
@@ -463,7 +465,7 @@ func generateTupleMarshal(f *os.File, i int) {
 		}
 		fmt.Fprintf(f, "t.F%d", j)
 	}
-	fmt.Fprintf(f, ")\n")
+	fmt.Fprintf(f, "})\n")
 	fmt.Fprintf(f, "}\n")
 }
 
@@ -473,12 +475,19 @@ func generateTupleUnmarshal(f *os.File, i int) {
 	fmt.Fprintf(f, "func (t *")
 	writeTupleType(f, "T", i)
 	fmt.Fprintf(f, ") UnmarshalJSON(data []byte) error {\n")
-	fmt.Fprintf(f, "  return tupleUnmarshalJSON(data")
-	// function prototypes
+	fmt.Fprintf(f, "  var tmp []json.RawMessage\n")
+	fmt.Fprintf(f, "  if err := json.Unmarshal(data, &tmp); err != nil {return err}\n")
+	fmt.Fprintf(f, "  l := len(tmp)\n")
+	// unmarshal fields
 	for j := 1; j <= i; j++ {
-		fmt.Fprintf(f, ", &t.F%d", j)
+		fmt.Fprintf(f, "  if l > %d {\n", j-1)
+		fmt.Fprintf(f, "  if err := json.Unmarshal(tmp[%d], &t.F%d); err != nil {return err}\n", j-1, j)
 	}
-	fmt.Fprintf(f, ")\n")
+	fmt.Fprintf(f, "  ")
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, "}")
+	}
+	fmt.Fprintf(f, "\n  return nil\n")
 	fmt.Fprintf(f, "}\n")
 }
 
@@ -561,13 +570,30 @@ func generateTupleString(f *os.File, i int) {
 	writeTupleType(f, "T", i)
 	fmt.Fprintf(f, ") String() string {\n")
 	// convert to string
-	fmt.Fprint(f, "  return tupleString(")
+	fmt.Fprintf(f, "  return fmt.Sprintf(\"Tuple%d[", i)
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "%s", "%T")
+	}
+	fmt.Fprintf(f, "](")
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "%s", "%v")
+	}
+	fmt.Fprintf(f, ")\", ")
 	for j := 1; j <= i; j++ {
 		if j > 1 {
 			fmt.Fprintf(f, ", ")
 		}
 		fmt.Fprintf(f, "t.F%d", j)
 	}
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, ", t.F%d", j)
+	}
 	fmt.Fprintf(f, ")\n")
 	fmt.Fprintf(f, "}\n")
 }

constant/const.go

@@ -37,7 +37,7 @@ func Of[E, A any](m M.Monoid[E]) func(A) Const[E, A] {
 	return F.Constant1[A](Make[E, A](m.Empty()))
 }
 
-func MonadMap[E, A, B any](fa Const[E, A], _ func(A) B) Const[E, B] {
+func MonadMap[E, A, B any](fa Const[E, A], f func(A) B) Const[E, B] {
 	return Make[E, B](fa.value)
 }
 

context/readerioeither/file/file_test.go

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

context/readerioeither/file/write.go

@@ -26,7 +26,7 @@ import (
 func onWriteAll[W io.Writer](data []byte) func(w W) RIOE.ReaderIOEither[[]byte] {
 	return func(w W) RIOE.ReaderIOEither[[]byte] {
 		return F.Pipe1(
-			RIOE.TryCatch(func(_ context.Context) func() ([]byte, error) {
+			RIOE.TryCatch(func(ctx context.Context) func() ([]byte, error) {
 				return func() ([]byte, error) {
 					_, err := w.Write(data)
 					return data, err

context/readerioeither/generic/reader.go

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

context/readerioeither/http/builder/builder.go

@@ -61,7 +61,7 @@ func Requester(builder *R.Builder) RIOEH.Requester {
 	return F.Pipe5(
 		builder.GetBody(),
 		O.Fold(LZ.Of(E.Of[error](withoutBody)), E.Map[error](withBody)),
-		E.Ap[func(string) RIOE.ReaderIOEither[*http.Request]](builder.GetTargetURL()),
+		E.Ap[func(string) RIOE.ReaderIOEither[*http.Request]](builder.GetTargetUrl()),
 		E.Flap[error, RIOE.ReaderIOEither[*http.Request]](builder.GetMethod()),
 		E.GetOrElse(RIOE.Left[*http.Request]),
 		RIOE.Map(func(req *http.Request) *http.Request {

context/readerioeither/http/builder/builder_test.go

@@ -32,12 +32,12 @@ import (
 func TestBuilderWithQuery(t *testing.T) {
 	// add some query
 	withLimit := R.WithQueryArg("limit")("10")
-	withURL := R.WithURL("http://www.example.org?a=b")
+	withUrl := R.WithUrl("http://www.example.org?a=b")
 
 	b := F.Pipe2(
 		R.Default,
 		withLimit,
-		withURL,
+		withUrl,
 	)
 
 	req := F.Pipe3(

context/readerioeither/http/request.go

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

context/readerioeither/http/request_test.go

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

di/erasure/injector.go

@@ -127,7 +127,7 @@ func MakeInjector(providers []Provider) InjectableFactory {
 	var resolved sync.Map
 
 	// provide a mapping for all providers
-	factoryByID := assembleProviders(providers)
+	factoryById := assembleProviders(providers)
 
 	// the actual factory, we need lazy initialization
 	var injFct InjectableFactory
@@ -149,7 +149,7 @@ func MakeInjector(providers []Provider) InjectableFactory {
 					T.Map2(F.Flow3(
 						Dependency.Id,
 						R.Lookup[ProviderFactory, string],
-						I.Ap[O.Option[ProviderFactory]](factoryByID),
+						I.Ap[O.Option[ProviderFactory]](factoryById),
 					), handleMissingProvider),
 					T.Tupled2(O.MonadGetOrElse[ProviderFactory]),
 					IG.Ap[ProviderFactory](injFct),

di/provider.go

@@ -41,7 +41,7 @@ func eraseTuple[A, R any](f func(A) IOE.IOEither[error, R]) func(E.Either[error,
 }
 
 func eraseProviderFactory0[R any](f IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] {
-	return func(_ ...any) IOE.IOEither[error, any] {
+	return func(params ...any) IOE.IOEither[error, any] {
 		return F.Pipe1(
 			f,
 			IOE.Map[error](F.ToAny[R]),

di/token.go

@@ -65,38 +65,34 @@ type MultiInjectionToken[T any] interface {
 }
 
 // makeID creates a generator of unique string IDs
-func makeID() IO.IO[string] {
+func makeId() IO.IO[string] {
 	var count atomic.Int64
 	return IO.MakeIO(func() string {
 		return strconv.FormatInt(count.Add(1), 16)
 	})
 }
 
-// genID is the common generator of unique string IDs
-var genID = makeID()
+// genId is the common generator of unique string IDs
+var genId = makeId()
 
-type tokenBase struct {
+type token[T any] struct {
 	name            string
 	id              string
 	flag            int
+	toType          func(val any) E.Either[error, T]
 	providerFactory O.Option[DIE.ProviderFactory]
 }
 
-type token[T any] struct {
-	base   *tokenBase
-	toType func(val any) E.Either[error, T]
-}
-
 func (t *token[T]) Id() string {
-	return t.base.id
+	return t.id
 }
 
 func (t *token[T]) Flag() int {
-	return t.base.flag
+	return t.flag
 }
 
 func (t *token[T]) String() string {
-	return t.base.name
+	return t.name
 }
 
 func (t *token[T]) Unerase(val any) E.Either[error, T] {
@@ -104,14 +100,11 @@ func (t *token[T]) Unerase(val any) E.Either[error, T] {
 }
 
 func (t *token[T]) ProviderFactory() O.Option[DIE.ProviderFactory] {
-	return t.base.providerFactory
-}
-func makeTokenBase(name string, id string, typ int, providerFactory O.Option[DIE.ProviderFactory]) *tokenBase {
-	return &tokenBase{name, id, typ, providerFactory}
+	return t.providerFactory
 }
 
 func makeToken[T any](name string, id string, typ int, unerase func(val any) E.Either[error, T], providerFactory O.Option[DIE.ProviderFactory]) Dependency[T] {
-	return &token[T]{makeTokenBase(name, id, typ, providerFactory), unerase}
+	return &token[T]{name, id, typ, unerase, providerFactory}
 }
 
 type injectionToken[T any] struct {
@@ -143,7 +136,7 @@ func (i *injectionToken[T]) IOOption() Dependency[IOO.IOOption[T]] {
 }
 
 func (i *injectionToken[T]) ProviderFactory() O.Option[DIE.ProviderFactory] {
-	return i.base.providerFactory
+	return i.providerFactory
 }
 
 func (m *multiInjectionToken[T]) Container() InjectionToken[[]T] {
@@ -156,10 +149,10 @@ func (m *multiInjectionToken[T]) Item() InjectionToken[T] {
 
 // makeToken create a unique [InjectionToken] for a specific type
 func makeInjectionToken[T any](name string, providerFactory O.Option[DIE.ProviderFactory]) InjectionToken[T] {
-	id := genID()
+	id := genId()
 	toIdentity := toType[T]()
 	return &injectionToken[T]{
-		token[T]{makeTokenBase(name, id, DIE.Identity, providerFactory), toIdentity},
+		token[T]{name, id, DIE.Identity, toIdentity, providerFactory},
 		makeToken[O.Option[T]](fmt.Sprintf("Option[%s]", name), id, DIE.Option, toOptionType(toIdentity), providerFactory),
 		makeToken[IOE.IOEither[error, T]](fmt.Sprintf("IOEither[%s]", name), id, DIE.IOEither, toIOEitherType(toIdentity), providerFactory),
 		makeToken[IOO.IOOption[T]](fmt.Sprintf("IOOption[%s]", name), id, DIE.IOOption, toIOOptionType(toIdentity), providerFactory),
@@ -178,7 +171,7 @@ func MakeTokenWithDefault[T any](name string, providerFactory DIE.ProviderFactor
 
 // MakeMultiToken creates a [MultiInjectionToken]
 func MakeMultiToken[T any](name string) MultiInjectionToken[T] {
-	id := genID()
+	id := genId()
 	toItem := toType[T]()
 	toContainer := toArrayType(toItem)
 	containerName := fmt.Sprintf("Container[%s]", name)
@@ -187,14 +180,14 @@ func MakeMultiToken[T any](name string) MultiInjectionToken[T] {
 	providerFactory := O.None[DIE.ProviderFactory]()
 	// container
 	container := &injectionToken[[]T]{
-		token[[]T]{makeTokenBase(containerName, id, DIE.Multi|DIE.Identity, providerFactory), toContainer},
+		token[[]T]{containerName, id, DIE.Multi | DIE.Identity, toContainer, providerFactory},
 		makeToken[O.Option[[]T]](fmt.Sprintf("Option[%s]", containerName), id, DIE.Multi|DIE.Option, toOptionType(toContainer), providerFactory),
 		makeToken[IOE.IOEither[error, []T]](fmt.Sprintf("IOEither[%s]", containerName), id, DIE.Multi|DIE.IOEither, toIOEitherType(toContainer), providerFactory),
 		makeToken[IOO.IOOption[[]T]](fmt.Sprintf("IOOption[%s]", containerName), id, DIE.Multi|DIE.IOOption, toIOOptionType(toContainer), providerFactory),
 	}
 	// item
 	item := &injectionToken[T]{
-		token[T]{makeTokenBase(itemName, id, DIE.Item|DIE.Identity, providerFactory), toItem},
+		token[T]{itemName, id, DIE.Item | DIE.Identity, toItem, providerFactory},
 		makeToken[O.Option[T]](fmt.Sprintf("Option[%s]", itemName), id, DIE.Item|DIE.Option, toOptionType(toItem), providerFactory),
 		makeToken[IOE.IOEither[error, T]](fmt.Sprintf("IOEither[%s]", itemName), id, DIE.Item|DIE.IOEither, toIOEitherType(toItem), providerFactory),
 		makeToken[IOO.IOOption[T]](fmt.Sprintf("IOOption[%s]", itemName), id, DIE.Item|DIE.IOOption, toIOOptionType(toItem), providerFactory),

di/utils.go

@@ -25,13 +25,6 @@ import (
 	O "github.com/IBM/fp-go/option"
 )
 
-var (
-	toOptionAny   = toType[O.Option[any]]()
-	toIOEitherAny = toType[IOE.IOEither[error, any]]()
-	toIOOptionAny = toType[IOO.IOOption[any]]()
-	toArrayAny    = toType[[]any]()
-)
-
 // asDependency converts a generic type to a [DIE.Dependency]
 func asDependency[T DIE.Dependency](t T) DIE.Dependency {
 	return t
@@ -45,7 +38,7 @@ func toType[T any]() func(t any) E.Either[error, T] {
 // toOptionType converts an any to an Option[any] and then to an Option[T]
 func toOptionType[T any](item func(any) E.Either[error, T]) func(t any) E.Either[error, O.Option[T]] {
 	return F.Flow2(
-		toOptionAny,
+		toType[O.Option[any]](),
 		E.Chain(O.Fold(
 			F.Nullary2(O.None[T], E.Of[error, O.Option[T]]),
 			F.Flow2(
@@ -59,7 +52,7 @@ func toOptionType[T any](item func(any) E.Either[error, T]) func(t any) E.Either
 // toIOEitherType converts an any to an IOEither[error, any] and then to an IOEither[error, T]
 func toIOEitherType[T any](item func(any) E.Either[error, T]) func(t any) E.Either[error, IOE.IOEither[error, T]] {
 	return F.Flow2(
-		toIOEitherAny,
+		toType[IOE.IOEither[error, any]](),
 		E.Map[error](IOE.ChainEitherK(item)),
 	)
 }
@@ -67,7 +60,7 @@ func toIOEitherType[T any](item func(any) E.Either[error, T]) func(t any) E.Eith
 // toIOOptionType converts an any to an IOOption[any] and then to an IOOption[T]
 func toIOOptionType[T any](item func(any) E.Either[error, T]) func(t any) E.Either[error, IOO.IOOption[T]] {
 	return F.Flow2(
-		toIOOptionAny,
+		toType[IOO.IOOption[any]](),
 		E.Map[error](IOO.ChainOptionK(F.Flow2(
 			item,
 			E.ToOption[error, T],
@@ -78,7 +71,7 @@ func toIOOptionType[T any](item func(any) E.Either[error, T]) func(t any) E.Eith
 // toArrayType converts an any to a []T
 func toArrayType[T any](item func(any) E.Either[error, T]) func(t any) E.Either[error, []T] {
 	return F.Flow2(
-		toArrayAny,
+		toType[[]any](),
 		E.Chain(E.TraverseArray(item)),
 	)
 }

either/core.go

@@ -20,45 +20,30 @@ import (
 )
 
 type (
-	either struct {
-		isLeft bool
-		value  any
-	}
-
 	// Either defines a data structure that logically holds either an E or an A. The flag discriminates the cases
-	Either[E, A any] either
+	Either[E, A any] struct {
+		isLeft bool
+		left   E
+		right  A
+	}
 )
 
-// String prints some debug info for the object
-//
-// go:noinline
-func eitherString(s *either) string {
-	if s.isLeft {
-		return fmt.Sprintf("Left[%T](%v)", s.value, s.value)
-	}
-	return fmt.Sprintf("Right[%T](%v)", s.value, s.value)
-}
-
-// Format prints some debug info for the object
-//
-// go:noinline
-func eitherFormat(e *either, f fmt.State, c rune) {
-	switch c {
-	case 's':
-		fmt.Fprint(f, eitherString(e))
-	default:
-		fmt.Fprint(f, eitherString(e))
-	}
-}
-
 // String prints some debug info for the object
 func (s Either[E, A]) String() string {
-	return eitherString((*either)(&s))
+	if s.isLeft {
+		return fmt.Sprintf("Left[%T, %T](%v)", s.left, s.right, s.left)
+	}
+	return fmt.Sprintf("Right[%T, %T](%v)", s.left, s.right, s.right)
 }
 
 // Format prints some debug info for the object
 func (s Either[E, A]) Format(f fmt.State, c rune) {
-	eitherFormat((*either)(&s), f, c)
+	switch c {
+	case 's':
+		fmt.Fprint(f, s.String())
+	default:
+		fmt.Fprint(f, s.String())
+	}
 }
 
 // IsLeft tests if the [Either] is a left value. Rather use [Fold] if you need to access the values. Inverse is [IsRight].
@@ -73,29 +58,23 @@ func IsRight[E, A any](val Either[E, A]) bool {
 
 // Left creates a new instance of an [Either] representing the left value.
 func Left[A, E any](value E) Either[E, A] {
-	return Either[E, A]{true, value}
+	return Either[E, A]{isLeft: true, left: value}
 }
 
 // Right creates a new instance of an [Either] representing the right value.
 func Right[E, A any](value A) Either[E, A] {
-	return Either[E, A]{false, value}
+	return Either[E, A]{isLeft: false, right: value}
 }
 
 // MonadFold extracts the values from an [Either] by invoking the [onLeft] callback or the [onRight] callback depending on the case
 func MonadFold[E, A, B any](ma Either[E, A], onLeft func(e E) B, onRight func(a A) B) B {
 	if ma.isLeft {
-		return onLeft(ma.value.(E))
+		return onLeft(ma.left)
 	}
-	return onRight(ma.value.(A))
+	return onRight(ma.right)
 }
 
 // Unwrap converts an [Either] into the idiomatic tuple
 func Unwrap[E, A any](ma Either[E, A]) (A, E) {
-	if ma.isLeft {
-		var a A
-		return a, ma.value.(E)
-	} else {
-		var e E
-		return ma.value.(A), e
-	}
+	return ma.right, ma.left
 }

either/either.go

@@ -22,7 +22,6 @@ package either
 import (
 	E "github.com/IBM/fp-go/errors"
 	F "github.com/IBM/fp-go/function"
-	C "github.com/IBM/fp-go/internal/chain"
 	FC "github.com/IBM/fp-go/internal/functor"
 	L "github.com/IBM/fp-go/lazy"
 	O "github.com/IBM/fp-go/option"
@@ -65,7 +64,7 @@ func MonadMapTo[E, A, B any](fa Either[E, A], b B) Either[E, B] {
 }
 
 func MapTo[E, A, B any](b B) func(Either[E, A]) Either[E, B] {
-	return Map[E](F.Constant1[A](b))
+	return F.Bind2nd(MonadMapTo[E, A, B], b)
 }
 
 func MonadMapLeft[E1, A, E2 any](fa Either[E1, A], f func(E1) E2) Either[E2, A] {
@@ -78,7 +77,7 @@ func Map[E, A, B any](f func(a A) B) func(fa Either[E, A]) Either[E, B] {
 
 // MapLeft applies a mapping function to the error channel
 func MapLeft[A, E1, E2 any](f func(E1) E2) func(fa Either[E1, A]) Either[E2, A] {
-	return Fold(F.Flow2(f, Left[A, E2]), Right[E2, A])
+	return F.Bind2nd(MonadMapLeft[E1, A, E2], f)
 }
 
 func MonadChain[E, A, B any](fa Either[E, A], f func(a A) Either[E, B]) Either[E, B] {
@@ -86,15 +85,12 @@ func MonadChain[E, A, B any](fa Either[E, A], f func(a A) Either[E, B]) Either[E
 }
 
 func MonadChainFirst[E, A, B any](ma Either[E, A], f func(a A) Either[E, B]) Either[E, A] {
-	return C.MonadChainFirst(
-		MonadChain[E, A, A],
-		MonadMap[E, B, A],
-		ma,
-		f,
-	)
+	return MonadChain(ma, func(a A) Either[E, A] {
+		return MonadMap(f(a), F.Constant1[B](a))
+	})
 }
 
-func MonadChainTo[A, E, B any](_ Either[E, A], mb Either[E, B]) Either[E, B] {
+func MonadChainTo[A, E, B any](ma Either[E, A], mb Either[E, B]) Either[E, B] {
 	return mb
 }
 
@@ -110,19 +106,15 @@ func ChainOptionK[A, B, E any](onNone func() E) func(func(A) O.Option[B]) func(E
 }
 
 func ChainTo[A, E, B any](mb Either[E, B]) func(Either[E, A]) Either[E, B] {
-	return F.Constant1[Either[E, A]](mb)
+	return F.Bind2nd(MonadChainTo[A, E, B], mb)
 }
 
 func Chain[E, A, B any](f func(a A) Either[E, B]) func(Either[E, A]) Either[E, B] {
-	return Fold(Left[B, E], f)
+	return F.Bind2nd(MonadChain[E, A, B], f)
 }
 
 func ChainFirst[E, A, B any](f func(a A) Either[E, B]) func(Either[E, A]) Either[E, A] {
-	return C.ChainFirst(
-		Chain[E, A, A],
-		Map[E, B, A],
-		f,
-	)
+	return F.Bind2nd(MonadChainFirst[E, A, B], f)
 }
 
 func Flatten[E, A any](mma Either[E, Either[E, A]]) Either[E, A] {
@@ -259,7 +251,7 @@ func MonadFlap[E, B, A any](fab Either[E, func(A) B], a A) Either[E, B] {
 }
 
 func Flap[E, B, A any](a A) func(Either[E, func(A) B]) Either[E, B] {
-	return FC.Flap(Map[E, func(A) B, B], a)
+	return F.Bind2nd(MonadFlap[E, B, A], a)
 }
 
 func MonadAlt[E, A any](fa Either[E, A], that L.Lazy[Either[E, A]]) Either[E, A] {

either/either_test.go

@@ -17,7 +17,6 @@ package either
 
 import (
 	"errors"
-	"fmt"
 	"testing"
 
 	F "github.com/IBM/fp-go/function"
@@ -27,6 +26,12 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+func TestDefault(t *testing.T) {
+	var e Either[error, string]
+
+	assert.Equal(t, Of[error](""), e)
+}
+
 func TestIsLeft(t *testing.T) {
 	err := errors.New("Some error")
 	withError := Left[string](err)
@@ -110,13 +115,3 @@ func TestFromOption(t *testing.T) {
 	assert.Equal(t, Left[int]("none"), FromOption[int](F.Constant("none"))(O.None[int]()))
 	assert.Equal(t, Right[string](1), FromOption[int](F.Constant("none"))(O.Some(1)))
 }
-
-func TestStringer(t *testing.T) {
-	e := Of[error]("foo")
-	exp := "Right[string](foo)"
-
-	assert.Equal(t, exp, e.String())
-
-	var s fmt.Stringer = e
-	assert.Equal(t, exp, s.String())
-}

either/examples_create_test.go

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

either/examples_extract_test.go

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

either/monad.go

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

either/traverse.go

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

eq/eq.go

@@ -27,8 +27,8 @@ type eq[T any] struct {
 	c func(x, y T) bool
 }
 
-func (e eq[T]) Equals(x, y T) bool {
-	return e.c(x, y)
+func (self eq[T]) Equals(x, y T) bool {
+	return self.c(x, y)
 }
 
 func strictEq[A comparable](a, b A) bool {

function/binds.go

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

function/cache.go

@@ -25,13 +25,13 @@ func Memoize[K comparable, T any](f func(K) T) func(K) T {
 }
 
 // ContramapMemoize converts a unary function into a unary function that caches the value depending on the parameter
-func ContramapMemoize[T, A any, K comparable](kf func(A) K) func(func(A) T) func(A) T {
+func ContramapMemoize[A any, K comparable, T any](kf func(A) K) func(func(A) T) func(A) T {
 	return G.ContramapMemoize[func(A) T](kf)
 }
 
 // CacheCallback converts a unary function into a unary function that caches the value depending on the parameter
 func CacheCallback[
-	T, A any, K comparable](kf func(A) K, getOrCreate func(K, func() func() T) func() T) func(func(A) T) func(A) T {
+	A any, K comparable, T any](kf func(A) K, getOrCreate func(K, func() func() T) func() T) func(func(A) T) func(A) T {
 	return G.CacheCallback[func(func(A) T) func(A) T](kf, getOrCreate)
 }
 

function/gen.go

@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2024-01-31 21:44:55.7538323 +0100 CET m=+0.013067701
+// 2023-12-18 09:38:51.4946446 +0100 CET m=+0.008838401
 
 package function
 
@@ -34,7 +34,8 @@ func Unsliced0[F ~func([]T) R, T, R any](f F) func() R {
 // Pipe1 takes an initial value t0 and successively applies 1 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe1[F1 ~func(T0) T1, T0, T1 any](t0 T0, f1 F1) T1 {
-	return f1(t0)
+	t1 := f1(t0)
+	return t1
 }
 
 // Flow1 creates a function that takes an initial value t0 and successively applies 1 functions where the input of a function is the return value of the previous function
@@ -92,7 +93,9 @@ func Unsliced1[F ~func([]T) R, T, R any](f F) func(T) R {
 // Pipe2 takes an initial value t0 and successively applies 2 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe2[F1 ~func(T0) T1, F2 ~func(T1) T2, T0, T1, T2 any](t0 T0, f1 F1, f2 F2) T2 {
-	return f2(f1(t0))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	return t2
 }
 
 // Flow2 creates a function that takes an initial value t0 and successively applies 2 functions where the input of a function is the return value of the previous function
@@ -152,7 +155,10 @@ func Unsliced2[F ~func([]T) R, T, R any](f F) func(T, T) R {
 // Pipe3 takes an initial value t0 and successively applies 3 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe3[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, T0, T1, T2, T3 any](t0 T0, f1 F1, f2 F2, f3 F3) T3 {
-	return f3(f2(f1(t0)))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	return t3
 }
 
 // Flow3 creates a function that takes an initial value t0 and successively applies 3 functions where the input of a function is the return value of the previous function
@@ -214,7 +220,11 @@ func Unsliced3[F ~func([]T) R, T, R any](f F) func(T, T, T) R {
 // Pipe4 takes an initial value t0 and successively applies 4 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe4[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, T0, T1, T2, T3, T4 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4) T4 {
-	return f4(f3(f2(f1(t0))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	return t4
 }
 
 // Flow4 creates a function that takes an initial value t0 and successively applies 4 functions where the input of a function is the return value of the previous function
@@ -278,7 +288,12 @@ func Unsliced4[F ~func([]T) R, T, R any](f F) func(T, T, T, T) R {
 // Pipe5 takes an initial value t0 and successively applies 5 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe5[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, T0, T1, T2, T3, T4, T5 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) T5 {
-	return f5(f4(f3(f2(f1(t0)))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	return t5
 }
 
 // Flow5 creates a function that takes an initial value t0 and successively applies 5 functions where the input of a function is the return value of the previous function
@@ -344,7 +359,13 @@ func Unsliced5[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T) R {
 // Pipe6 takes an initial value t0 and successively applies 6 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe6[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, T0, T1, T2, T3, T4, T5, T6 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) T6 {
-	return f6(f5(f4(f3(f2(f1(t0))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	return t6
 }
 
 // Flow6 creates a function that takes an initial value t0 and successively applies 6 functions where the input of a function is the return value of the previous function
@@ -412,7 +433,14 @@ func Unsliced6[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T) R {
 // Pipe7 takes an initial value t0 and successively applies 7 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe7[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, T0, T1, T2, T3, T4, T5, T6, T7 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) T7 {
-	return f7(f6(f5(f4(f3(f2(f1(t0)))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	return t7
 }
 
 // Flow7 creates a function that takes an initial value t0 and successively applies 7 functions where the input of a function is the return value of the previous function
@@ -482,7 +510,15 @@ func Unsliced7[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T) R {
 // Pipe8 takes an initial value t0 and successively applies 8 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe8[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, T0, T1, T2, T3, T4, T5, T6, T7, T8 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) T8 {
-	return f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	return t8
 }
 
 // Flow8 creates a function that takes an initial value t0 and successively applies 8 functions where the input of a function is the return value of the previous function
@@ -554,7 +590,16 @@ func Unsliced8[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T) R {
 // Pipe9 takes an initial value t0 and successively applies 9 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe9[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) T9 {
-	return f9(f8(f7(f6(f5(f4(f3(f2(f1(t0)))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	return t9
 }
 
 // Flow9 creates a function that takes an initial value t0 and successively applies 9 functions where the input of a function is the return value of the previous function
@@ -628,7 +673,17 @@ func Unsliced9[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T) R
 // Pipe10 takes an initial value t0 and successively applies 10 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe10[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) T10 {
-	return f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	return t10
 }
 
 // Flow10 creates a function that takes an initial value t0 and successively applies 10 functions where the input of a function is the return value of the previous function
@@ -704,7 +759,18 @@ func Unsliced10[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe11 takes an initial value t0 and successively applies 11 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe11[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11) T11 {
-	return f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0)))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	return t11
 }
 
 // Flow11 creates a function that takes an initial value t0 and successively applies 11 functions where the input of a function is the return value of the previous function
@@ -782,7 +848,19 @@ func Unsliced11[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe12 takes an initial value t0 and successively applies 12 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe12[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12) T12 {
-	return f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	t12 := f12(t11)
+	return t12
 }
 
 // Flow12 creates a function that takes an initial value t0 and successively applies 12 functions where the input of a function is the return value of the previous function
@@ -862,7 +940,20 @@ func Unsliced12[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe13 takes an initial value t0 and successively applies 13 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe13[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13) T13 {
-	return f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0)))))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	t12 := f12(t11)
+	t13 := f13(t12)
+	return t13
 }
 
 // Flow13 creates a function that takes an initial value t0 and successively applies 13 functions where the input of a function is the return value of the previous function
@@ -944,7 +1035,21 @@ func Unsliced13[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe14 takes an initial value t0 and successively applies 14 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe14[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14) T14 {
-	return f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	t12 := f12(t11)
+	t13 := f13(t12)
+	t14 := f14(t13)
+	return t14
 }
 
 // Flow14 creates a function that takes an initial value t0 and successively applies 14 functions where the input of a function is the return value of the previous function
@@ -1028,7 +1133,22 @@ func Unsliced14[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe15 takes an initial value t0 and successively applies 15 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe15[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15) T15 {
-	return f15(f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0)))))))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	t12 := f12(t11)
+	t13 := f13(t12)
+	t14 := f14(t13)
+	t15 := f15(t14)
+	return t15
 }
 
 // Flow15 creates a function that takes an initial value t0 and successively applies 15 functions where the input of a function is the return value of the previous function
@@ -1114,7 +1234,23 @@ func Unsliced15[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe16 takes an initial value t0 and successively applies 16 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe16[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16) T16 {
-	return f16(f15(f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	t12 := f12(t11)
+	t13 := f13(t12)
+	t14 := f14(t13)
+	t15 := f15(t14)
+	t16 := f16(t15)
+	return t16
 }
 
 // Flow16 creates a function that takes an initial value t0 and successively applies 16 functions where the input of a function is the return value of the previous function
@@ -1202,7 +1338,24 @@ func Unsliced16[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe17 takes an initial value t0 and successively applies 17 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe17[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17) T17 {
-	return f17(f16(f15(f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0)))))))))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	t12 := f12(t11)
+	t13 := f13(t12)
+	t14 := f14(t13)
+	t15 := f15(t14)
+	t16 := f16(t15)
+	t17 := f17(t16)
+	return t17
 }
 
 // Flow17 creates a function that takes an initial value t0 and successively applies 17 functions where the input of a function is the return value of the previous function
@@ -1292,7 +1445,25 @@ func Unsliced17[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe18 takes an initial value t0 and successively applies 18 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe18[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18) T18 {
-	return f18(f17(f16(f15(f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	t12 := f12(t11)
+	t13 := f13(t12)
+	t14 := f14(t13)
+	t15 := f15(t14)
+	t16 := f16(t15)
+	t17 := f17(t16)
+	t18 := f18(t17)
+	return t18
 }
 
 // Flow18 creates a function that takes an initial value t0 and successively applies 18 functions where the input of a function is the return value of the previous function
@@ -1384,7 +1555,26 @@ func Unsliced18[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe19 takes an initial value t0 and successively applies 19 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe19[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, F19 ~func(T18) T19, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18, f19 F19) T19 {
-	return f19(f18(f17(f16(f15(f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0)))))))))))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	t12 := f12(t11)
+	t13 := f13(t12)
+	t14 := f14(t13)
+	t15 := f15(t14)
+	t16 := f16(t15)
+	t17 := f17(t16)
+	t18 := f18(t17)
+	t19 := f19(t18)
+	return t19
 }
 
 // Flow19 creates a function that takes an initial value t0 and successively applies 19 functions where the input of a function is the return value of the previous function
@@ -1478,7 +1668,27 @@ func Unsliced19[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe20 takes an initial value t0 and successively applies 20 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe20[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, F19 ~func(T18) T19, F20 ~func(T19) T20, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18, f19 F19, f20 F20) T20 {
-	return f20(f19(f18(f17(f16(f15(f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))))))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	t12 := f12(t11)
+	t13 := f13(t12)
+	t14 := f14(t13)
+	t15 := f15(t14)
+	t16 := f16(t15)
+	t17 := f17(t16)
+	t18 := f18(t17)
+	t19 := f19(t18)
+	t20 := f20(t19)
+	return t20
 }
 
 // Flow20 creates a function that takes an initial value t0 and successively applies 20 functions where the input of a function is the return value of the previous function

http/builder/builder.go

@@ -16,14 +16,9 @@
 package builder
 
 import (
-	"bytes"
-	"crypto/sha256"
-	"fmt"
 	"net/http"
 	"net/url"
 
-	A "github.com/IBM/fp-go/array"
-	B "github.com/IBM/fp-go/bytes"
 	E "github.com/IBM/fp-go/either"
 	ENDO "github.com/IBM/fp-go/endomorphism"
 	F "github.com/IBM/fp-go/function"
@@ -34,7 +29,6 @@ import (
 	LZ "github.com/IBM/fp-go/lazy"
 	L "github.com/IBM/fp-go/optics/lens"
 	O "github.com/IBM/fp-go/option"
-	R "github.com/IBM/fp-go/record"
 	S "github.com/IBM/fp-go/string"
 	T "github.com/IBM/fp-go/tuple"
 )
@@ -62,11 +56,7 @@ var (
 	Monoid = ENDO.Monoid[*Builder]()
 
 	// Url is a [L.Lens] for the URL
-	//
-	// Deprecated: use [URL] instead
-	Url = L.MakeLensRef((*Builder).GetURL, (*Builder).SetURL)
-	// URL is a [L.Lens] for the URL
-	URL = L.MakeLensRef((*Builder).GetURL, (*Builder).SetURL)
+	Url = L.MakeLensRef((*Builder).GetUrl, (*Builder).SetUrl)
 	// Method is a [L.Lens] for the HTTP method
 	Method = L.MakeLensRef((*Builder).GetMethod, (*Builder).SetMethod)
 	// Body is a [L.Lens] for the request body
@@ -86,19 +76,15 @@ var (
 	noBody     = O.None[E.Either[error, []byte]]()
 	noQueryArg = O.None[string]()
 
-	parseURL   = E.Eitherize1(url.Parse)
+	parseUrl   = E.Eitherize1(url.Parse)
 	parseQuery = E.Eitherize1(url.ParseQuery)
 
 	// WithQuery creates a [Endomorphism] for a complete set of query parameters
 	WithQuery = Query.Set
 	// WithMethod creates a [Endomorphism] for a certain method
 	WithMethod = Method.Set
-	// WithUrl creates a [Endomorphism] for the URL
-	//
-	// Deprecated: use [WithURL] instead
-	WithUrl = URL.Set
-	// WithURL creates a [Endomorphism] for the URL
-	WithURL = URL.Set
+	// WithUrl creates a [Endomorphism] for a certain method
+	WithUrl = Url.Set
 	// WithHeaders creates a [Endomorphism] for a set of headers
 	WithHeaders = Headers.Set
 	// WithBody creates a [Endomorphism] for a request body
@@ -144,9 +130,6 @@ var (
 		WithBytes,
 		ENDO.Chain(WithContentType(C.FormEncoded)),
 	)
-
-	// bodyAsBytes returns a []byte with a fallback to the empty array
-	bodyAsBytes = O.Fold(B.Empty, E.Fold(F.Ignore1of1[error](B.Empty), F.Identity[[]byte]))
 )
 
 func setRawQuery(u *url.URL, raw string) *url.URL {
@@ -165,19 +148,12 @@ func (builder *Builder) clone() *Builder {
 }
 
 // GetTargetUrl constructs a full URL with query parameters on top of the provided URL string
-//
-// Deprecated: use [GetTargetURL] instead
 func (builder *Builder) GetTargetUrl() E.Either[error, string] {
-	return builder.GetTargetURL()
-}
-
-// GetTargetURL constructs a full URL with query parameters on top of the provided URL string
-func (builder *Builder) GetTargetURL() E.Either[error, string] {
 	// construct the final URL
 	return F.Pipe3(
 		builder,
 		Url.Get,
-		parseURL,
+		parseUrl,
 		E.Chain(F.Flow4(
 			T.Replicate2[*url.URL],
 			T.Map2(
@@ -200,15 +176,10 @@ func (builder *Builder) GetTargetURL() E.Either[error, string] {
 	)
 }
 
-// Deprecated: use [GetURL] instead
 func (builder *Builder) GetUrl() string {
 	return builder.url
 }
 
-func (builder *Builder) GetURL() string {
-	return builder.url
-}
-
 func (builder *Builder) GetMethod() string {
 	return F.Pipe1(
 		builder.method,
@@ -238,17 +209,11 @@ func (builder *Builder) SetMethod(method string) *Builder {
 	return builder
 }
 
-// Deprecated: use [SetURL] instead
 func (builder *Builder) SetUrl(url string) *Builder {
 	builder.url = url
 	return builder
 }
 
-func (builder *Builder) SetURL(url string) *Builder {
-	builder.url = url
-	return builder
-}
-
 func (builder *Builder) SetHeaders(headers http.Header) *Builder {
 	builder.headers = headers
 	return builder
@@ -281,11 +246,6 @@ func (builder *Builder) GetHeaderValues(name string) []string {
 	return builder.headers.Values(name)
 }
 
-// GetHash returns a hash value for the builder that can be used as a cache key
-func (builder *Builder) GetHash() string {
-	return MakeHash(builder)
-}
-
 // Header returns a [L.Lens] for a single header
 func Header(name string) L.Lens[*Builder, O.Option[string]] {
 	get := getHeader(name)
@@ -318,21 +278,14 @@ func WithoutHeader(name string) Endomorphism {
 }
 
 // WithJson creates a [Endomorphism] to send JSON payload
-//
-// Deprecated: use [WithJSON] instead
 func WithJson[T any](data T) Endomorphism {
-	return WithJSON[T](data)
-}
-
-// WithJSON creates a [Endomorphism] to send JSON payload
-func WithJSON[T any](data T) Endomorphism {
 	return Monoid.Concat(
 		F.Pipe2(
 			data,
 			J.Marshal[T],
 			WithBody,
 		),
-		WithContentType(C.JSON),
+		WithContentType(C.Json),
 	)
 }
 
@@ -356,32 +309,3 @@ func WithQueryArg(name string) func(value string) Endomorphism {
 func WithoutQueryArg(name string) Endomorphism {
 	return QueryArg(name).Set(noQueryArg)
 }
-
-func hashWriteValue(buf *bytes.Buffer, value string) *bytes.Buffer {
-	buf.WriteString(value)
-	return buf
-}
-
-func hashWriteQuery(name string, buf *bytes.Buffer, values []string) *bytes.Buffer {
-	buf.WriteString(name)
-	return A.Reduce(hashWriteValue, buf)(values)
-}
-
-func makeBytes(b *Builder) []byte {
-	var buf bytes.Buffer
-
-	buf.WriteString(b.GetMethod())
-	buf.WriteString(b.GetURL())
-	b.GetHeaders().Write(&buf) // #nosec: G104
-
-	R.ReduceOrdWithIndex[[]string, *bytes.Buffer](S.Ord)(hashWriteQuery, &buf)(b.GetQuery())
-
-	buf.Write(bodyAsBytes(b.GetBody()))
-
-	return buf.Bytes()
-}
-
-// MakeHash converts a [Builder] into a hash string, convenient to use as a cache key
-func MakeHash(b *Builder) string {
-	return fmt.Sprintf("%x", sha256.Sum256(makeBytes(b)))
-}

http/builder/builder_test.go

@@ -16,7 +16,6 @@
 package builder
 
 import (
-	"fmt"
 	"testing"
 
 	F "github.com/IBM/fp-go/function"
@@ -35,7 +34,7 @@ func TestBuilder(t *testing.T) {
 
 	b1 := F.Pipe1(
 		Default,
-		withContentType(C.JSON),
+		withContentType(C.Json),
 	)
 
 	b2 := F.Pipe1(
@@ -49,7 +48,7 @@ func TestBuilder(t *testing.T) {
 	)
 
 	assert.Equal(t, O.None[string](), Default.GetHeader(name))
-	assert.Equal(t, O.Of(C.JSON), b1.GetHeader(name))
+	assert.Equal(t, O.Of(C.Json), b1.GetHeader(name))
 	assert.Equal(t, O.Of(C.TextPlain), b2.GetHeader(name))
 	assert.Equal(t, O.None[string](), b3.GetHeader(name))
 }
@@ -67,27 +66,3 @@ func TestWithFormData(t *testing.T) {
 
 	assert.Equal(t, C.FormEncoded, Headers.Get(res).Get(H.ContentType))
 }
-
-func TestHash(t *testing.T) {
-
-	b1 := F.Pipe4(
-		Default,
-		WithContentType(C.JSON),
-		WithHeader(H.Accept)(C.JSON),
-		WithURL("http://www.example.com"),
-		WithJSON(map[string]string{"a": "b"}),
-	)
-
-	b2 := F.Pipe4(
-		Default,
-		WithURL("http://www.example.com"),
-		WithHeader(H.Accept)(C.JSON),
-		WithContentType(C.JSON),
-		WithJSON(map[string]string{"a": "b"}),
-	)
-
-	assert.Equal(t, MakeHash(b1), MakeHash(b2))
-	assert.NotEqual(t, MakeHash(Default), MakeHash(b2))
-
-	fmt.Println(MakeHash(b1))
-}

http/content/content.go

@@ -17,7 +17,6 @@ package content
 
 const (
 	TextPlain   = "text/plain"
-	JSON        = "application/json"
-	Json        = JSON // Deprecated: use [JSON] instead
+	Json        = "application/json"
 	FormEncoded = "application/x-www-form-urlencoded"
 )

http/utils.go

@@ -45,33 +45,29 @@ type (
 
 var (
 	// mime type to check if a media type matches
-	reJSONMimeType = regexp.MustCompile(`application/(?:\w+\+)?json`)
+	reJsonMimeType = regexp.MustCompile(`application/(?:\w+\+)?json`)
 	// ValidateResponse validates an HTTP response and returns an [E.Either] if the response is not a success
 	ValidateResponse = E.FromPredicate(isValidStatus, StatusCodeError)
 	// alidateJsonContentTypeString parses a content type a validates that it is valid JSON
-	validateJSONContentTypeString = F.Flow2(
+	validateJsonContentTypeString = F.Flow2(
 		ParseMediaType,
 		E.ChainFirst(F.Flow2(
 			T.First[string, map[string]string],
-			E.FromPredicate(reJSONMimeType.MatchString, func(mimeType string) error {
+			E.FromPredicate(reJsonMimeType.MatchString, func(mimeType string) error {
 				return fmt.Errorf("mimetype [%s] is not a valid JSON content type", mimeType)
 			}),
 		)),
 	)
-	// ValidateJSONResponse checks if an HTTP response is a valid JSON response
-	ValidateJSONResponse = F.Flow2(
+	// ValidateJsonResponse checks if an HTTP response is a valid JSON response
+	ValidateJsonResponse = F.Flow2(
 		E.Of[error, *H.Response],
 		E.ChainFirst(F.Flow5(
 			GetHeader,
 			R.Lookup[H.Header](HeaderContentType),
 			O.Chain(A.First[string]),
 			E.FromOption[string](errors.OnNone("unable to access the [%s] header", HeaderContentType)),
-			E.ChainFirst(validateJSONContentTypeString),
+			E.ChainFirst(validateJsonContentTypeString),
 		)))
-	// ValidateJsonResponse checks if an HTTP response is a valid JSON response
-	//
-	// Deprecated: use [ValidateJSONResponse] instead
-	ValidateJsonResponse = ValidateJSONResponse
 )
 
 const (

http/utils_test.go

@@ -39,7 +39,7 @@ func Error[A any](t *testing.T) func(E.Either[error, A]) bool {
 func TestValidateJsonContentTypeString(t *testing.T) {
 
 	res := F.Pipe1(
-		validateJSONContentTypeString(C.JSON),
+		validateJsonContentTypeString(C.Json),
 		NoError[ParsedMediaType](t),
 	)
 
@@ -49,7 +49,7 @@ func TestValidateJsonContentTypeString(t *testing.T) {
 func TestValidateInvalidJsonContentTypeString(t *testing.T) {
 
 	res := F.Pipe1(
-		validateJSONContentTypeString("application/xml"),
+		validateJsonContentTypeString("application/xml"),
 		Error[ParsedMediaType](t),
 	)
 

identity/generic/identity.go

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

identity/identity.go

@@ -36,7 +36,7 @@ func Map[A, B any](f func(A) B) func(A) B {
 	return G.Map(f)
 }
 
-func MonadMapTo[A, B any](_ A, b B) B {
+func MonadMapTo[A, B any](fa A, b B) B {
 	return b
 }
 

identity/monad.go

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

internal/applicative/testing/law.go

@@ -20,19 +20,13 @@ import (
 
 	E "github.com/IBM/fp-go/eq"
 	F "github.com/IBM/fp-go/function"
-	"github.com/IBM/fp-go/internal/applicative"
-	"github.com/IBM/fp-go/internal/apply"
 	L "github.com/IBM/fp-go/internal/apply/testing"
-	"github.com/IBM/fp-go/internal/functor"
-	"github.com/IBM/fp-go/internal/pointed"
 	"github.com/stretchr/testify/assert"
 )
 
 // Applicative identity law
 //
 // A.ap(A.of(a => a), fa) <-> fa
-//
-// Deprecated: use [ApplicativeAssertIdentity]
 func AssertIdentity[HKTA, HKTAA, A any](t *testing.T,
 	eq E.Eq[HKTA],
 
@@ -40,9 +34,6 @@ func AssertIdentity[HKTA, HKTAA, A any](t *testing.T,
 
 	fap func(HKTAA, HKTA) HKTA,
 ) func(fa HKTA) bool {
-	// mark as test helper
-	t.Helper()
-
 	return func(fa HKTA) bool {
 
 		left := fap(fof(F.Identity[A]), fa)
@@ -52,33 +43,9 @@ func AssertIdentity[HKTA, HKTAA, A any](t *testing.T,
 	}
 }
 
-// Applicative identity law
-//
-// A.ap(A.of(a => a), fa) <-> fa
-func ApplicativeAssertIdentity[HKTA, HKTFAA, A any](t *testing.T,
-	eq E.Eq[HKTA],
-
-	ap applicative.Applicative[A, A, HKTA, HKTA, HKTFAA],
-	paa pointed.Pointed[func(A) A, HKTFAA],
-
-) func(fa HKTA) bool {
-	// mark as test helper
-	t.Helper()
-
-	return func(fa HKTA) bool {
-
-		left := ap.Ap(fa)(paa.Of(F.Identity[A]))
-		right := fa
-
-		return assert.True(t, eq.Equals(left, right), "Applicative identity")
-	}
-}
-
 // Applicative homomorphism law
 //
 // A.ap(A.of(ab), A.of(a)) <-> A.of(ab(a))
-//
-// Deprecated: use [ApplicativeAssertHomomorphism]
 func AssertHomomorphism[HKTA, HKTB, HKTAB, A, B any](t *testing.T,
 	eq E.Eq[HKTB],
 
@@ -90,9 +57,6 @@ func AssertHomomorphism[HKTA, HKTB, HKTAB, A, B any](t *testing.T,
 
 	ab func(A) B,
 ) func(a A) bool {
-	// mark as test helper
-	t.Helper()
-
 	return func(a A) bool {
 
 		left := fap(fofab(ab), fofa(a))
@@ -102,39 +66,14 @@ func AssertHomomorphism[HKTA, HKTB, HKTAB, A, B any](t *testing.T,
 	}
 }
 
-// Applicative homomorphism law
-//
-// A.ap(A.of(ab), A.of(a)) <-> A.of(ab(a))
-func ApplicativeAssertHomomorphism[HKTA, HKTB, HKTFAB, A, B any](t *testing.T,
-	eq E.Eq[HKTB],
-
-	apab applicative.Applicative[A, B, HKTA, HKTB, HKTFAB],
-	pb pointed.Pointed[B, HKTB],
-	pfab pointed.Pointed[func(A) B, HKTFAB],
-
-	ab func(A) B,
-) func(a A) bool {
-	// mark as test helper
-	t.Helper()
-
-	return func(a A) bool {
-
-		left := apab.Ap(apab.Of(a))(pfab.Of(ab))
-		right := pb.Of(ab(a))
-
-		return assert.True(t, eq.Equals(left, right), "Applicative homomorphism")
-	}
-}
-
 // Applicative interchange law
 //
 // A.ap(fab, A.of(a)) <-> A.ap(A.of(ab => ab(a)), fab)
-//
-// Deprecated: use [ApplicativeAssertInterchange]
 func AssertInterchange[HKTA, HKTB, HKTAB, HKTABB, A, B any](t *testing.T,
 	eq E.Eq[HKTB],
 
 	fofa func(A) HKTA,
+	fofb func(B) HKTB,
 	fofab func(func(A) B) HKTAB,
 	fofabb func(func(func(A) B) B) HKTABB,
 
@@ -143,9 +82,6 @@ func AssertInterchange[HKTA, HKTB, HKTAB, HKTABB, A, B any](t *testing.T,
 
 	ab func(A) B,
 ) func(a A) bool {
-	// mark as test helper
-	t.Helper()
-
 	return func(a A) bool {
 
 		fab := fofab(ab)
@@ -159,38 +95,7 @@ func AssertInterchange[HKTA, HKTB, HKTAB, HKTABB, A, B any](t *testing.T,
 	}
 }
 
-// Applicative interchange law
-//
-// A.ap(fab, A.of(a)) <-> A.ap(A.of(ab => ab(a)), fab)
-func ApplicativeAssertInterchange[HKTA, HKTB, HKTFAB, HKTABB, A, B any](t *testing.T,
-	eq E.Eq[HKTB],
-
-	apab applicative.Applicative[A, B, HKTA, HKTB, HKTFAB],
-	apabb applicative.Applicative[func(A) B, B, HKTFAB, HKTB, HKTABB],
-	pabb pointed.Pointed[func(func(A) B) B, HKTABB],
-
-	ab func(A) B,
-) func(a A) bool {
-	// mark as test helper
-	t.Helper()
-
-	return func(a A) bool {
-
-		fab := apabb.Of(ab)
-
-		left := apab.Ap(apab.Of(a))(fab)
-
-		right := apabb.Ap(fab)(pabb.Of(func(ab func(A) B) B {
-			return ab(a)
-		}))
-
-		return assert.True(t, eq.Equals(left, right), "Applicative homomorphism")
-	}
-}
-
 // AssertLaws asserts the apply laws `identity`, `composition`, `associative composition`, 'applicative identity', 'homomorphism', 'interchange'
-//
-// Deprecated: use [ApplicativeAssertLaws] instead
 func AssertLaws[HKTA, HKTB, HKTC, HKTAA, HKTAB, HKTBC, HKTAC, HKTABB, HKTABAC, A, B, C any](t *testing.T,
 	eqa E.Eq[HKTA],
 	eqb E.Eq[HKTB],
@@ -222,62 +127,15 @@ func AssertLaws[HKTA, HKTB, HKTC, HKTAA, HKTAB, HKTBC, HKTAC, HKTABB, HKTABAC, A
 	ab func(A) B,
 	bc func(B) C,
 ) func(a A) bool {
-	// mark as test helper
-	t.Helper()
-
 	// apply laws
 	apply := L.AssertLaws(t, eqa, eqc, fofab, fofbc, faa, fab, fac, fbc, fmap, fapab, fapbc, fapac, fapabac, ab, bc)
 	// applicative laws
 	identity := AssertIdentity(t, eqa, fofaa, fapaa)
 	homomorphism := AssertHomomorphism(t, eqb, fofa, fofb, fofab, fapab, ab)
-	interchange := AssertInterchange(t, eqb, fofa, fofab, fofabb, fapab, fapabb, ab)
+	interchange := AssertInterchange(t, eqb, fofa, fofb, fofab, fofabb, fapab, fapabb, ab)
 
 	return func(a A) bool {
 		fa := fofa(a)
 		return apply(fa) && identity(fa) && homomorphism(a) && interchange(a)
 	}
 }
-
-// ApplicativeAssertLaws asserts the apply laws `identity`, `composition`, `associative composition`, 'applicative identity', 'homomorphism', 'interchange'
-func ApplicativeAssertLaws[HKTA, HKTB, HKTC, HKTAA, HKTAB, HKTBC, HKTAC, HKTABB, HKTABAC, A, B, C any](t *testing.T,
-	eqa E.Eq[HKTA],
-	eqb E.Eq[HKTB],
-	eqc E.Eq[HKTC],
-
-	fofb pointed.Pointed[B, HKTB],
-
-	fofaa pointed.Pointed[func(A) A, HKTAA],
-	fofbc pointed.Pointed[func(B) C, HKTBC],
-
-	fofabb pointed.Pointed[func(func(A) B) B, HKTABB],
-
-	faa functor.Functor[A, A, HKTA, HKTA],
-
-	fmap functor.Functor[func(B) C, func(func(A) B) func(A) C, HKTBC, HKTABAC],
-
-	fapaa applicative.Applicative[A, A, HKTA, HKTA, HKTAA],
-	fapab applicative.Applicative[A, B, HKTA, HKTB, HKTAB],
-	fapbc apply.Apply[B, C, HKTB, HKTC, HKTBC],
-	fapac apply.Apply[A, C, HKTA, HKTC, HKTAC],
-
-	fapabb applicative.Applicative[func(A) B, B, HKTAB, HKTB, HKTABB],
-	fapabac applicative.Applicative[func(A) B, func(A) C, HKTAB, HKTAC, HKTABAC],
-
-	ab func(A) B,
-	bc func(B) C,
-) func(a A) bool {
-	// mark as test helper
-	t.Helper()
-
-	// apply laws
-	apply := L.ApplyAssertLaws(t, eqa, eqc, applicative.ToPointed(fapabac), fofbc, faa, fmap, applicative.ToApply(fapab), fapbc, fapac, applicative.ToApply(fapabac), ab, bc)
-	// applicative laws
-	identity := ApplicativeAssertIdentity(t, eqa, fapaa, fofaa)
-	homomorphism := ApplicativeAssertHomomorphism(t, eqb, fapab, fofb, applicative.ToPointed(fapabb), ab)
-	interchange := ApplicativeAssertInterchange(t, eqb, fapab, fapabb, fofabb, ab)
-
-	return func(a A) bool {
-		fa := fapaa.Of(a)
-		return apply(fa) && identity(fa) && homomorphism(a) && interchange(a)
-	}
-}

internal/applicative/types.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 applicative
-
-import (
-	"github.com/IBM/fp-go/internal/apply"
-	"github.com/IBM/fp-go/internal/functor"
-	"github.com/IBM/fp-go/internal/pointed"
-)
-
-type Applicative[A, B, HKTA, HKTB, HKTFAB any] interface {
-	apply.Apply[A, B, HKTA, HKTB, HKTFAB]
-	pointed.Pointed[A, HKTA]
-}
-
-// ToFunctor converts from [Applicative] to [functor.Functor]
-func ToFunctor[A, B, HKTA, HKTB, HKTFAB any](ap Applicative[A, B, HKTA, HKTB, HKTFAB]) functor.Functor[A, B, HKTA, HKTB] {
-	return ap
-}
-
-// ToApply converts from [Applicative] to [apply.Apply]
-func ToApply[A, B, HKTA, HKTB, HKTFAB any](ap Applicative[A, B, HKTA, HKTB, HKTFAB]) apply.Apply[A, B, HKTA, HKTB, HKTFAB] {
-	return ap
-}
-
-// ToPointed converts from [Applicative] to [pointed.Pointed]
-func ToPointed[A, B, HKTA, HKTB, HKTFAB any](ap Applicative[A, B, HKTA, HKTB, HKTFAB]) pointed.Pointed[A, HKTA] {
-	return ap
-}

internal/apply/ap.go

@@ -19,6 +19,13 @@ import (
 	F "github.com/IBM/fp-go/function"
 )
 
+// HKTFGA  = HKT<F, HKT<G, A>>
+// HKTFGB  = HKT<F, HKT<G, B>>
+// HKTFGAB = HKT<F, HKT<G, (a: A) => B>>
+
+// HKTGA   = HKT<G, A>
+// HKTGB   = HKT<G, B>
+// HKTGAB  = HKT<G, (a: A) => B>
 func MonadAp[HKTGA, HKTGB, HKTGAB, HKTFGAB, HKTFGGAB, HKTFGA, HKTFGB any](
 	fap func(HKTFGGAB, HKTFGA) HKTFGB,
 	fmap func(HKTFGAB, func(HKTGAB) func(HKTGA) HKTGB) HKTFGGAB,
@@ -30,19 +37,6 @@ func MonadAp[HKTGA, HKTGB, HKTGAB, HKTFGAB, HKTFGGAB, HKTFGA, HKTFGB any](
 	return fap(fmap(fab, F.Bind1st(F.Bind1st[HKTGAB, HKTGA, HKTGB], gap)), fa)
 }
 
-func Ap[HKTGA, HKTGB, HKTGAB, HKTFGAB, HKTFGGAB, HKTFGA, HKTFGB any](
-	fap func(HKTFGA) func(HKTFGGAB) HKTFGB,
-	fmap func(func(HKTGAB) func(HKTGA) HKTGB) func(HKTFGAB) HKTFGGAB,
-	gap func(HKTGA) func(HKTGAB) HKTGB,
-
-	fa HKTFGA) func(HKTFGAB) HKTFGB {
-
-	return F.Flow2(
-		fmap(F.Flip(gap)),
-		fap(fa),
-	)
-}
-
 // func Ap[HKTGA, HKTGB, HKTGAB, HKTFGAB, HKTFGGAB, HKTFGA, HKTFGB any](
 // 	fap func(HKTFGA) func(HKTFGGAB) HKTFGB,
 // 	fmap func(func(HKTGAB) func(HKTGA) HKTGB) func(HKTFGAB) HKTFGGAB,

internal/apply/testing/laws.go

@@ -19,18 +19,13 @@ import (
 	"testing"
 
 	E "github.com/IBM/fp-go/eq"
-	"github.com/IBM/fp-go/internal/apply"
-	"github.com/IBM/fp-go/internal/functor"
 	FCT "github.com/IBM/fp-go/internal/functor/testing"
-	"github.com/IBM/fp-go/internal/pointed"
 	"github.com/stretchr/testify/assert"
 )
 
 // Apply associative composition law
 //
 // F.ap(F.ap(F.map(fbc, bc => ab => a => bc(ab(a))), fab), fa) <-> F.ap(fbc, F.ap(fab, fa))
-//
-// Deprecated: use [ApplyAssertAssociativeComposition] instead
 func AssertAssociativeComposition[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *testing.T,
 	eq E.Eq[HKTC],
 
@@ -48,7 +43,6 @@ func AssertAssociativeComposition[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC
 	ab func(A) B,
 	bc func(B) C,
 ) func(fa HKTA) bool {
-	t.Helper()
 	return func(fa HKTA) bool {
 
 		fab := fofab(ab)
@@ -68,49 +62,7 @@ func AssertAssociativeComposition[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC
 	}
 }
 
-// Apply associative composition law
-//
-// F.ap(F.ap(F.map(fbc, bc => ab => a => bc(ab(a))), fab), fa) <-> F.ap(fbc, F.ap(fab, fa))
-func ApplyAssertAssociativeComposition[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *testing.T,
-	eq E.Eq[HKTC],
-
-	fofab pointed.Pointed[func(A) B, HKTAB],
-	fofbc pointed.Pointed[func(B) C, HKTBC],
-
-	fmap functor.Functor[func(B) C, func(func(A) B) func(A) C, HKTBC, HKTABAC],
-
-	fapab apply.Apply[A, B, HKTA, HKTB, HKTAB],
-	fapbc apply.Apply[B, C, HKTB, HKTC, HKTBC],
-	fapac apply.Apply[A, C, HKTA, HKTC, HKTAC],
-
-	fapabac apply.Apply[func(A) B, func(A) C, HKTAB, HKTAC, HKTABAC],
-
-	ab func(A) B,
-	bc func(B) C,
-) func(fa HKTA) bool {
-	t.Helper()
-	return func(fa HKTA) bool {
-
-		fab := fofab.Of(ab)
-		fbc := fofbc.Of(bc)
-
-		left := fapac.Ap(fa)(fapabac.Ap(fab)(fmap.Map(func(bc func(B) C) func(func(A) B) func(A) C {
-			return func(ab func(A) B) func(A) C {
-				return func(a A) C {
-					return bc(ab(a))
-				}
-			}
-		})(fbc)))
-
-		right := fapbc.Ap(fapab.Ap(fa)(fab))(fbc)
-
-		return assert.True(t, eq.Equals(left, right), "Apply associative composition")
-	}
-}
-
 // AssertLaws asserts the apply laws `identity`, `composition` and `associative composition`
-//
-// Deprecated: use [ApplyAssertLaws] instead
 func AssertLaws[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *testing.T,
 	eqa E.Eq[HKTA],
 	eqc E.Eq[HKTC],
@@ -134,8 +86,6 @@ func AssertLaws[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *
 	ab func(A) B,
 	bc func(B) C,
 ) func(fa HKTA) bool {
-	// mark as test helper
-	t.Helper()
 	// functor laws
 	functor := FCT.AssertLaws(t, eqa, eqc, faa, fab, fac, fbc, ab, bc)
 	// associative composition laws
@@ -145,36 +95,3 @@ func AssertLaws[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *
 		return functor(fa) && composition(fa)
 	}
 }
-
-// ApplyAssertLaws asserts the apply laws `identity`, `composition` and `associative composition`
-func ApplyAssertLaws[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *testing.T,
-	eqa E.Eq[HKTA],
-	eqc E.Eq[HKTC],
-
-	fofab pointed.Pointed[func(A) B, HKTAB],
-	fofbc pointed.Pointed[func(B) C, HKTBC],
-
-	faa functor.Functor[A, A, HKTA, HKTA],
-
-	fmap functor.Functor[func(B) C, func(func(A) B) func(A) C, HKTBC, HKTABAC],
-
-	fapab apply.Apply[A, B, HKTA, HKTB, HKTAB],
-	fapbc apply.Apply[B, C, HKTB, HKTC, HKTBC],
-	fapac apply.Apply[A, C, HKTA, HKTC, HKTAC],
-
-	fapabac apply.Apply[func(A) B, func(A) C, HKTAB, HKTAC, HKTABAC],
-
-	ab func(A) B,
-	bc func(B) C,
-) func(fa HKTA) bool {
-	// mark as test helper
-	t.Helper()
-	// functor laws
-	functor := FCT.FunctorAssertLaws(t, eqa, eqc, faa, apply.ToFunctor(fapab), apply.ToFunctor(fapac), apply.ToFunctor(fapbc), ab, bc)
-	// associative composition laws
-	composition := ApplyAssertAssociativeComposition(t, eqc, fofab, fofbc, fmap, fapab, fapbc, fapac, fapabac, ab, bc)
-
-	return func(fa HKTA) bool {
-		return functor(fa) && composition(fa)
-	}
-}

internal/apply/types.go

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

internal/array/array.go

@@ -106,12 +106,6 @@ func MonadMap[GA ~[]A, GB ~[]B, A, B any](as GA, f func(a A) B) GB {
 	return bs
 }
 
-func Map[GA ~[]A, GB ~[]B, A, B any](f func(a A) B) func(GA) GB {
-	return func(as GA) GB {
-		return MonadMap[GA, GB](as, f)
-	}
-}
-
 func MonadMapWithIndex[GA ~[]A, GB ~[]B, A, B any](as GA, f func(idx int, a A) B) GB {
 	count := len(as)
 	bs := make(GB, count)

internal/chain/chain.go

@@ -43,11 +43,11 @@ func MonadChain[A, B, HKTA, HKTB any](
 // HKTA=HKT[A]
 // HKTB=HKT[B]
 func ChainFirst[A, B, HKTA, HKTB any](
-	mchain func(func(A) HKTA) func(HKTA) HKTA,
-	mmap func(func(B) A) func(HKTB) HKTA,
+	mchain func(HKTA, func(A) HKTA) HKTA,
+	mmap func(HKTB, func(B) A) HKTA,
 	f func(A) HKTB) func(HKTA) HKTA {
-	return mchain(func(a A) HKTA {
-		return mmap(F.Constant1[B](a))(f(a))
+	return F.Bind2nd(mchain, func(a A) HKTA {
+		return mmap(f(a), F.Constant1[B](a))
 	})
 }
 

internal/chain/testing/laws.go

@@ -20,22 +20,17 @@ import (
 
 	E "github.com/IBM/fp-go/eq"
 	F "github.com/IBM/fp-go/function"
-	"github.com/IBM/fp-go/internal/apply"
 	L "github.com/IBM/fp-go/internal/apply/testing"
-	"github.com/IBM/fp-go/internal/chain"
-	"github.com/IBM/fp-go/internal/functor"
-	"github.com/IBM/fp-go/internal/pointed"
 	"github.com/stretchr/testify/assert"
 )
 
 // Chain associativity law
 //
 // F.chain(F.chain(fa, afb), bfc) <-> F.chain(fa, a => F.chain(afb(a), bfc))
-//
-// Deprecated: use [ChainAssertAssociativity] instead
 func AssertAssociativity[HKTA, HKTB, HKTC, A, B, C any](t *testing.T,
 	eq E.Eq[HKTC],
 
+	fofa func(A) HKTA,
 	fofb func(B) HKTB,
 	fofc func(C) HKTC,
 
@@ -61,44 +56,12 @@ func AssertAssociativity[HKTA, HKTB, HKTC, A, B, C any](t *testing.T,
 	}
 }
 
-// Chain associativity law
-//
-// F.chain(F.chain(fa, afb), bfc) <-> F.chain(fa, a => F.chain(afb(a), bfc))
-func ChainAssertAssociativity[HKTA, HKTB, HKTC, HKTAB, HKTAC, HKTBC, A, B, C any](t *testing.T,
-	eq E.Eq[HKTC],
-
-	fofb pointed.Pointed[B, HKTB],
-	fofc pointed.Pointed[C, HKTC],
-
-	chainab chain.Chainable[A, B, HKTA, HKTB, HKTAB],
-	chainac chain.Chainable[A, C, HKTA, HKTC, HKTAC],
-	chainbc chain.Chainable[B, C, HKTB, HKTC, HKTBC],
-
-	ab func(A) B,
-	bc func(B) C,
-) func(fa HKTA) bool {
-	return func(fa HKTA) bool {
-
-		afb := F.Flow2(ab, fofb.Of)
-		bfc := F.Flow2(bc, fofc.Of)
-
-		left := chainbc.Chain(bfc)(chainab.Chain(afb)(fa))
-
-		right := chainac.Chain(func(a A) HKTC {
-			return chainbc.Chain(bfc)(afb(a))
-		})(fa)
-
-		return assert.True(t, eq.Equals(left, right), "Chain associativity")
-	}
-}
-
 // AssertLaws asserts the apply laws `identity`, `composition`, `associative composition` and `associativity`
-//
-// Deprecated: use [ChainAssertLaws] instead
 func AssertLaws[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *testing.T,
 	eqa E.Eq[HKTA],
 	eqc E.Eq[HKTC],
 
+	fofa func(A) HKTA,
 	fofb func(B) HKTB,
 	fofc func(C) HKTC,
 
@@ -128,41 +91,7 @@ func AssertLaws[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *
 	// apply laws
 	apply := L.AssertLaws(t, eqa, eqc, fofab, fofbc, faa, fab, fac, fbc, fmap, fapab, fapbc, fapac, fapabac, ab, bc)
 	// chain laws
-	associativity := AssertAssociativity(t, eqc, fofb, fofc, chainab, chainac, chainbc, ab, bc)
-
-	return func(fa HKTA) bool {
-		return apply(fa) && associativity(fa)
-	}
-}
-
-// ChainAssertLaws asserts the apply laws `identity`, `composition`, `associative composition` and `associativity`
-func ChainAssertLaws[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *testing.T,
-	eqa E.Eq[HKTA],
-	eqc E.Eq[HKTC],
-
-	fofb pointed.Pointed[B, HKTB],
-	fofc pointed.Pointed[C, HKTC],
-
-	fofab pointed.Pointed[func(A) B, HKTAB],
-	fofbc pointed.Pointed[func(B) C, HKTBC],
-
-	faa functor.Functor[A, A, HKTA, HKTA],
-
-	fmap functor.Functor[func(B) C, func(func(A) B) func(A) C, HKTBC, HKTABAC],
-
-	chainab chain.Chainable[A, B, HKTA, HKTB, HKTAB],
-	chainac chain.Chainable[A, C, HKTA, HKTC, HKTAC],
-	chainbc chain.Chainable[B, C, HKTB, HKTC, HKTBC],
-
-	fapabac apply.Apply[func(A) B, func(A) C, HKTAB, HKTAC, HKTABAC],
-
-	ab func(A) B,
-	bc func(B) C,
-) func(fa HKTA) bool {
-	// apply laws
-	apply := L.ApplyAssertLaws(t, eqa, eqc, fofab, fofbc, faa, fmap, chain.ToApply(chainab), chain.ToApply(chainbc), chain.ToApply(chainac), fapabac, ab, bc)
-	// chain laws
-	associativity := ChainAssertAssociativity(t, eqc, fofb, fofc, chainab, chainac, chainbc, ab, bc)
+	associativity := AssertAssociativity(t, eqc, fofa, fofb, fofc, chainab, chainac, chainbc, ab, bc)
 
 	return func(fa HKTA) bool {
 		return apply(fa) && associativity(fa)

internal/chain/types.go

@@ -1,36 +0,0 @@
-// Copyright (c) 2024 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package chain
-
-import (
-	"github.com/IBM/fp-go/internal/apply"
-	"github.com/IBM/fp-go/internal/functor"
-)
-
-type Chainable[A, B, HKTA, HKTB, HKTFAB any] interface {
-	apply.Apply[A, B, HKTA, HKTB, HKTFAB]
-	Chain(func(A) HKTB) func(HKTA) HKTB
-}
-
-// ToFunctor converts from [Chainable] to [functor.Functor]
-func ToFunctor[A, B, HKTA, HKTB, HKTFAB any](ap Chainable[A, B, HKTA, HKTB, HKTFAB]) functor.Functor[A, B, HKTA, HKTB] {
-	return ap
-}
-
-// ToApply converts from [Chainable] to [functor.Functor]
-func ToApply[A, B, HKTA, HKTB, HKTFAB any](ap Chainable[A, B, HKTA, HKTB, HKTFAB]) apply.Apply[A, B, HKTA, HKTB, HKTFAB] {
-	return ap
-}

internal/eithert/either.go

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

internal/foldable/types.go

@@ -1,26 +0,0 @@
-// Copyright (c) 2024 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package foldable
-
-import (
-	M "github.com/IBM/fp-go/monoid"
-)
-
-type Foldable[A, B, HKTA any] interface {
-	Reduce(func(B, A) B, B) func(HKTA) B
-	ReduceRight(func(B, A) B, B) func(HKTA) B
-	FoldMap(m M.Monoid[B]) func(func(A) B) func(HKTA) B
-}

internal/fromeither/either.go

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

internal/fromeither/types.go

@@ -1,24 +0,0 @@
-// Copyright (c) 2024 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package fromeither
-
-import (
-	ET "github.com/IBM/fp-go/either"
-)
-
-type FromEither[E, A, HKTA any] interface {
-	FromEither(ET.Either[E, A]) HKTA
-}

internal/fromio/io.go

@@ -30,8 +30,8 @@ func MonadChainFirstIOK[A, B, HKTA, HKTB any, GIOB ~func() B](
 }
 
 func ChainFirstIOK[A, B, HKTA, HKTB any, GIOB ~func() B](
-	mchain func(func(A) HKTA) func(HKTA) HKTA,
-	mmap func(func(B) A) func(HKTB) HKTA,
+	mchain func(HKTA, func(A) HKTA) HKTA,
+	mmap func(HKTB, func(B) A) HKTA,
 	fromio func(GIOB) HKTB,
 	f func(A) GIOB) func(HKTA) HKTA {
 	// chain

internal/fromio/types.go

@@ -1,20 +0,0 @@
-// Copyright (c) 2024 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package fromio
-
-type FromIO[A, GA ~func() A, HKTA any] interface {
-	FromIO(GA) HKTA
-}

internal/fromioeither/ioeither.go

@@ -31,8 +31,8 @@ func MonadChainFirstIOEitherK[GIOB ~func() ET.Either[E, B], E, A, B, HKTA, HKTB
 }
 
 func ChainFirstIOEitherK[GIOB ~func() ET.Either[E, B], E, A, B, HKTA, HKTB any](
-	mchain func(func(A) HKTA) func(HKTA) HKTA,
-	mmap func(func(B) A) func(HKTB) HKTA,
+	mchain func(HKTA, func(A) HKTA) HKTA,
+	mmap func(HKTB, func(B) A) HKTA,
 	fromio func(GIOB) HKTB,
 	f func(A) GIOB) func(HKTA) HKTA {
 	// chain

internal/functor/flap.go

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

internal/functor/functor.go

@@ -33,7 +33,11 @@ func Map[A, B, HKTGA, HKTGB, HKTFGA, HKTFGB any](
 	fmap func(func(HKTGA) HKTGB) func(HKTFGA) HKTFGB,
 	gmap func(func(A) B) func(HKTGA) HKTGB,
 	f func(A) B) func(HKTFGA) HKTFGB {
-	return fmap(gmap(f))
+	return F.Pipe2(
+		f,
+		gmap,
+		fmap,
+	)
 }
 
 func MonadLet[S1, S2, B, HKTS1, HKTS2 any](
@@ -62,5 +66,9 @@ func LetTo[S1, S2, B, HKTS1, HKTS2 any](
 	key func(B) func(S1) S2,
 	b B,
 ) func(HKTS1) HKTS2 {
-	return mmap(key(b))
+	return F.Pipe2(
+		b,
+		key,
+		mmap,
+	)
 }

internal/functor/testing/laws.go

@@ -20,44 +20,21 @@ import (
 
 	E "github.com/IBM/fp-go/eq"
 	F "github.com/IBM/fp-go/function"
-	"github.com/IBM/fp-go/internal/functor"
 	"github.com/stretchr/testify/assert"
 )
 
 // Functor identity law
 //
 // F.map(fa, a => a) <-> fa
-//
-// Deprecated: use [FunctorAssertIdentity]
 func AssertIdentity[HKTA, A any](t *testing.T, eq E.Eq[HKTA], fmap func(HKTA, func(A) A) HKTA) func(fa HKTA) bool {
-	t.Helper()
 	return func(fa HKTA) bool {
 		return assert.True(t, eq.Equals(fa, fmap(fa, F.Identity[A])), "Functor identity law")
 	}
 }
 
-// Functor identity law
-//
-// F.map(fa, a => a) <-> fa
-func FunctorAssertIdentity[HKTA, A any](
-	t *testing.T,
-	eq E.Eq[HKTA],
-
-	fca functor.Functor[A, A, HKTA, HKTA],
-) func(fa HKTA) bool {
-
-	t.Helper()
-	return func(fa HKTA) bool {
-
-		return assert.True(t, eq.Equals(fa, fca.Map(F.Identity[A])(fa)), "Functor identity law")
-	}
-}
-
 // Functor composition law
 //
 // F.map(fa, a => bc(ab(a))) <-> F.map(F.map(fa, ab), bc)
-//
-// Deprecated: use [FunctorAssertComposition] instead
 func AssertComposition[HKTA, HKTB, HKTC, A, B, C any](
 	t *testing.T,
 
@@ -69,36 +46,12 @@ func AssertComposition[HKTA, HKTB, HKTC, A, B, C any](
 	ab func(A) B,
 	bc func(B) C,
 ) func(fa HKTA) bool {
-	t.Helper()
 	return func(fa HKTA) bool {
 		return assert.True(t, eq.Equals(fac(fa, F.Flow2(ab, bc)), fbc(fab(fa, ab), bc)), "Functor composition law")
 	}
 }
 
-// Functor composition law
-//
-// F.map(fa, a => bc(ab(a))) <-> F.map(F.map(fa, ab), bc)
-func FunctorAssertComposition[HKTA, HKTB, HKTC, A, B, C any](
-	t *testing.T,
-
-	eq E.Eq[HKTC],
-
-	fab functor.Functor[A, B, HKTA, HKTB],
-	fac functor.Functor[A, C, HKTA, HKTC],
-	fbc functor.Functor[B, C, HKTB, HKTC],
-
-	ab func(A) B,
-	bc func(B) C,
-) func(fa HKTA) bool {
-	t.Helper()
-	return func(fa HKTA) bool {
-		return assert.True(t, eq.Equals(fac.Map(F.Flow2(ab, bc))(fa), fbc.Map(bc)(fab.Map(ab)(fa))), "Functor composition law")
-	}
-}
-
 // AssertLaws asserts the functor laws `identity` and `composition`
-//
-// Deprecated: use [FunctorAssertLaws] instead
 func AssertLaws[HKTA, HKTB, HKTC, A, B, C any](t *testing.T,
 	eqa E.Eq[HKTA],
 	eqc E.Eq[HKTC],
@@ -107,11 +60,9 @@ func AssertLaws[HKTA, HKTB, HKTC, A, B, C any](t *testing.T,
 	fab func(HKTA, func(A) B) HKTB,
 	fac func(HKTA, func(A) C) HKTC,
 	fbc func(HKTB, func(B) C) HKTC,
-
 	ab func(A) B,
 	bc func(B) C,
 ) func(fa HKTA) bool {
-	t.Helper()
 	identity := AssertIdentity(t, eqa, faa)
 	composition := AssertComposition(t, eqc, fab, fac, fbc, ab, bc)
 
@@ -119,25 +70,3 @@ func AssertLaws[HKTA, HKTB, HKTC, A, B, C any](t *testing.T,
 		return identity(fa) && composition(fa)
 	}
 }
-
-// FunctorAssertLaws asserts the functor laws `identity` and `composition`
-func FunctorAssertLaws[HKTA, HKTB, HKTC, A, B, C any](t *testing.T,
-	eqa E.Eq[HKTA],
-	eqc E.Eq[HKTC],
-
-	faa functor.Functor[A, A, HKTA, HKTA],
-	fab functor.Functor[A, B, HKTA, HKTB],
-	fac functor.Functor[A, C, HKTA, HKTC],
-	fbc functor.Functor[B, C, HKTB, HKTC],
-
-	ab func(A) B,
-	bc func(B) C,
-) func(fa HKTA) bool {
-	t.Helper()
-	identity := FunctorAssertIdentity(t, eqa, faa)
-	composition := FunctorAssertComposition(t, eqc, fab, fac, fbc, ab, bc)
-
-	return func(fa HKTA) bool {
-		return identity(fa) && composition(fa)
-	}
-}

internal/functor/types.go

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

internal/monad/monad.go

@@ -1,54 +0,0 @@
-// Copyright (c) 2024 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package monad
-
-import (
-	"github.com/IBM/fp-go/internal/applicative"
-	"github.com/IBM/fp-go/internal/apply"
-	"github.com/IBM/fp-go/internal/chain"
-	"github.com/IBM/fp-go/internal/functor"
-	"github.com/IBM/fp-go/internal/pointed"
-)
-
-type Monad[A, B, HKTA, HKTB, HKTFAB any] interface {
-	applicative.Applicative[A, B, HKTA, HKTB, HKTFAB]
-	chain.Chainable[A, B, HKTA, HKTB, HKTFAB]
-}
-
-// ToFunctor converts from [Monad] to [functor.Functor]
-func ToFunctor[A, B, HKTA, HKTB, HKTFAB any](ap Monad[A, B, HKTA, HKTB, HKTFAB]) functor.Functor[A, B, HKTA, HKTB] {
-	return ap
-}
-
-// ToApply converts from [Monad] to [apply.Apply]
-func ToApply[A, B, HKTA, HKTB, HKTFAB any](ap Monad[A, B, HKTA, HKTB, HKTFAB]) apply.Apply[A, B, HKTA, HKTB, HKTFAB] {
-	return ap
-}
-
-// ToPointed converts from [Monad] to [pointed.Pointed]
-func ToPointed[A, B, HKTA, HKTB, HKTFAB any](ap Monad[A, B, HKTA, HKTB, HKTFAB]) pointed.Pointed[A, HKTA] {
-	return ap
-}
-
-// ToApplicative converts from [Monad] to [applicative.Applicative]
-func ToApplicative[A, B, HKTA, HKTB, HKTFAB any](ap Monad[A, B, HKTA, HKTB, HKTFAB]) applicative.Applicative[A, B, HKTA, HKTB, HKTFAB] {
-	return ap
-}
-
-// ToChainable converts from [Monad] to [chain.Chainable]
-func ToChainable[A, B, HKTA, HKTB, HKTFAB any](ap Monad[A, B, HKTA, HKTB, HKTFAB]) chain.Chainable[A, B, HKTA, HKTB, HKTFAB] {
-	return ap
-}

internal/monad/testing/laws.go

@@ -19,21 +19,14 @@ import (
 	"testing"
 
 	E "github.com/IBM/fp-go/eq"
-	"github.com/IBM/fp-go/internal/applicative"
 	LA "github.com/IBM/fp-go/internal/applicative/testing"
-	"github.com/IBM/fp-go/internal/chain"
 	LC "github.com/IBM/fp-go/internal/chain/testing"
-	"github.com/IBM/fp-go/internal/functor"
-	"github.com/IBM/fp-go/internal/monad"
-	"github.com/IBM/fp-go/internal/pointed"
 	"github.com/stretchr/testify/assert"
 )
 
 // Apply monad left identity law
 //
 // M.chain(M.of(a), f) <-> f(a)
-//
-// Deprecated: use [MonadAssertLeftIdentity] instead
 func AssertLeftIdentity[HKTA, HKTB, A, B any](t *testing.T,
 	eq E.Eq[HKTB],
 
@@ -57,36 +50,9 @@ func AssertLeftIdentity[HKTA, HKTB, A, B any](t *testing.T,
 	}
 }
 
-// Apply monad left identity law
-//
-// M.chain(M.of(a), f) <-> f(a)
-func MonadAssertLeftIdentity[HKTA, HKTB, HKTFAB, A, B any](t *testing.T,
-	eq E.Eq[HKTB],
-
-	fofb pointed.Pointed[B, HKTB],
-
-	ma monad.Monad[A, B, HKTA, HKTB, HKTFAB],
-
-	ab func(A) B,
-) func(a A) bool {
-	return func(a A) bool {
-
-		f := func(a A) HKTB {
-			return fofb.Of(ab(a))
-		}
-
-		left := ma.Chain(f)(ma.Of(a))
-		right := f(a)
-
-		return assert.True(t, eq.Equals(left, right), "Monad left identity")
-	}
-}
-
 // Apply monad right identity law
 //
 // M.chain(fa, M.of) <-> fa
-//
-// Deprecated: use [MonadAssertRightIdentity] instead
 func AssertRightIdentity[HKTA, A any](t *testing.T,
 	eq E.Eq[HKTA],
 
@@ -103,27 +69,7 @@ func AssertRightIdentity[HKTA, A any](t *testing.T,
 	}
 }
 
-// Apply monad right identity law
-//
-// M.chain(fa, M.of) <-> fa
-func MonadAssertRightIdentity[HKTA, HKTAA, A any](t *testing.T,
-	eq E.Eq[HKTA],
-
-	ma monad.Monad[A, A, HKTA, HKTA, HKTAA],
-
-) func(fa HKTA) bool {
-	return func(fa HKTA) bool {
-
-		left := ma.Chain(ma.Of)(fa)
-		right := fa
-
-		return assert.True(t, eq.Equals(left, right), "Monad right identity")
-	}
-}
-
 // AssertLaws asserts the apply laws `identity`, `composition`, `associative composition`, 'applicative identity', 'homomorphism', 'interchange', `associativity`, `left identity`, `right identity`
-//
-// Deprecated: use [MonadAssertLaws] instead
 func AssertLaws[HKTA, HKTB, HKTC, HKTAA, HKTAB, HKTBC, HKTAC, HKTABB, HKTABAC, A, B, C any](t *testing.T,
 	eqa E.Eq[HKTA],
 	eqb E.Eq[HKTB],
@@ -164,7 +110,7 @@ func AssertLaws[HKTA, HKTB, HKTC, HKTAA, HKTAB, HKTBC, HKTAC, HKTABB, HKTABAC, A
 	// applicative laws
 	applicative := LA.AssertLaws(t, eqa, eqb, eqc, fofa, fofb, fofaa, fofab, fofbc, fofabb, faa, fab, fac, fbc, fmap, fapaa, fapab, fapbc, fapac, fapabb, fapabac, ab, bc)
 	// chain laws
-	chain := LC.AssertLaws(t, eqa, eqc, fofb, fofc, fofab, fofbc, faa, fab, fac, fbc, fmap, chainab, chainac, chainbc, fapab, fapbc, fapac, fapabac, ab, bc)
+	chain := LC.AssertLaws(t, eqa, eqc, fofa, fofb, fofc, fofab, fofbc, faa, fab, fac, fbc, fmap, chainab, chainac, chainbc, fapab, fapbc, fapac, fapabac, ab, bc)
 	// monad laws
 	leftIdentity := AssertLeftIdentity(t, eqb, fofa, fofb, chainab, ab)
 	rightIdentity := AssertRightIdentity(t, eqa, fofa, chainaa)
@@ -174,55 +120,3 @@ func AssertLaws[HKTA, HKTB, HKTC, HKTAA, HKTAB, HKTBC, HKTAC, HKTABB, HKTABAC, A
 		return applicative(a) && chain(fa) && leftIdentity(a) && rightIdentity(fa)
 	}
 }
-
-// MonadAssertLaws asserts the apply laws `identity`, `composition`, `associative composition`, 'applicative identity', 'homomorphism', 'interchange', `associativity`, `left identity`, `right identity`
-func MonadAssertLaws[HKTA, HKTB, HKTC, HKTAA, HKTAB, HKTBC, HKTAC, HKTABB, HKTABAC, A, B, C any](t *testing.T,
-	eqa E.Eq[HKTA],
-	eqb E.Eq[HKTB],
-	eqc E.Eq[HKTC],
-
-	fofc pointed.Pointed[C, HKTC],
-	fofaa pointed.Pointed[func(A) A, HKTAA],
-	fofbc pointed.Pointed[func(B) C, HKTBC],
-	fofabb pointed.Pointed[func(func(A) B) B, HKTABB],
-
-	fmap functor.Functor[func(B) C, func(func(A) B) func(A) C, HKTBC, HKTABAC],
-
-	fapabb applicative.Applicative[func(A) B, B, HKTAB, HKTB, HKTABB],
-	fapabac applicative.Applicative[func(A) B, func(A) C, HKTAB, HKTAC, HKTABAC],
-
-	maa monad.Monad[A, A, HKTA, HKTA, HKTAA],
-	mab monad.Monad[A, B, HKTA, HKTB, HKTAB],
-	mac monad.Monad[A, C, HKTA, HKTC, HKTAC],
-	mbc monad.Monad[B, C, HKTB, HKTC, HKTBC],
-
-	ab func(A) B,
-	bc func(B) C,
-) func(a A) bool {
-	// derivations
-	fofa := monad.ToPointed(maa)
-	fofb := monad.ToPointed(mbc)
-	fofab := applicative.ToPointed(fapabb)
-	fapaa := monad.ToApplicative(maa)
-	fapab := monad.ToApplicative(mab)
-	chainab := monad.ToChainable(mab)
-	chainac := monad.ToChainable(mac)
-	chainbc := monad.ToChainable(mbc)
-	fapbc := chain.ToApply(chainbc)
-	fapac := chain.ToApply(chainac)
-
-	faa := monad.ToFunctor(maa)
-
-	// applicative laws
-	apLaw := LA.ApplicativeAssertLaws(t, eqa, eqb, eqc, fofb, fofaa, fofbc, fofabb, faa, fmap, fapaa, fapab, fapbc, fapac, fapabb, fapabac, ab, bc)
-	// chain laws
-	chainLaw := LC.ChainAssertLaws(t, eqa, eqc, fofb, fofc, fofab, fofbc, faa, fmap, chainab, chainac, chainbc, applicative.ToApply(fapabac), ab, bc)
-	// monad laws
-	leftIdentity := MonadAssertLeftIdentity(t, eqb, fofb, mab, ab)
-	rightIdentity := MonadAssertRightIdentity(t, eqa, maa)
-
-	return func(a A) bool {
-		fa := fofa.Of(a)
-		return apLaw(a) && chainLaw(fa) && leftIdentity(a) && rightIdentity(fa)
-	}
-}

internal/optiont/option.go

@@ -40,12 +40,6 @@ func MonadMap[A, B, HKTFA, HKTFB any](fmap func(HKTFA, func(O.Option[A]) O.Optio
 	return FC.MonadMap(fmap, O.MonadMap[A, B], fa, f)
 }
 
-func Map[A, B, HKTFA, HKTFB any](fmap func(func(O.Option[A]) O.Option[B]) func(HKTFA) HKTFB, f func(A) B) func(HKTFA) HKTFB {
-	// HKTGA = Either[E, A]
-	// HKTGB = Either[E, B]
-	return FC.Map(fmap, O.Map[A, B], f)
-}
-
 func MonadChain[A, B, HKTFA, HKTFB any](
 	fchain func(HKTFA, func(O.Option[A]) HKTFB) HKTFB,
 	fof func(O.Option[B]) HKTFB,
@@ -56,11 +50,13 @@ func MonadChain[A, B, HKTFA, HKTFB any](
 }
 
 func Chain[A, B, HKTFA, HKTFB any](
-	fchain func(func(O.Option[A]) HKTFB) func(HKTFA) HKTFB,
+	fchain func(HKTFA, func(O.Option[A]) HKTFB) HKTFB,
 	fof func(O.Option[B]) HKTFB,
 	f func(A) HKTFB) func(ma HKTFA) HKTFB {
 	// dispatch to the even more generic implementation
-	return fchain(O.Fold(F.Nullary2(O.None[B], fof), f))
+	return func(ma HKTFA) HKTFB {
+		return MonadChain(fchain, fof, ma, f)
+	}
 }
 
 func MonadAp[A, B, HKTFAB, HKTFGAB, HKTFA, HKTFB any](
@@ -71,13 +67,6 @@ func MonadAp[A, B, HKTFAB, HKTFGAB, HKTFA, HKTFB any](
 	return apply.MonadAp(fap, fmap, O.MonadAp[B, A], fab, fa)
 }
 
-func Ap[A, B, HKTFAB, HKTFGAB, HKTFA, HKTFB any](
-	fap func(HKTFA) func(HKTFGAB) HKTFB,
-	fmap func(func(O.Option[func(A) B]) func(O.Option[A]) O.Option[B]) func(HKTFAB) HKTFGAB,
-	fa HKTFA) func(HKTFAB) HKTFB {
-	return apply.Ap(fap, fmap, O.Ap[B, A], fa)
-}
-
 func MatchE[A, HKTEA, HKTB any](mchain func(HKTEA, func(O.Option[A]) HKTB) HKTB, onNone func() HKTB, onSome func(A) HKTB) func(HKTEA) HKTB {
 	return F.Bind2nd(mchain, O.Fold(onNone, onSome))
 }
@@ -97,14 +86,6 @@ func MonadChainOptionK[A, B, HKTA, HKTB any](
 	return MonadChain(fchain, fof, ma, FromOptionK(fof, f))
 }
 
-func ChainOptionK[A, B, HKTA, HKTB any](
-	fchain func(func(O.Option[A]) HKTB) func(HKTA) HKTB,
-	fof func(O.Option[B]) HKTB,
-	f func(A) O.Option[B],
-) func(HKTA) HKTB {
-	return Chain(fchain, fof, FromOptionK(fof, f))
-}
-
 func MonadAlt[LAZY ~func() HKTFA, A, HKTFA any](
 	fof func(O.Option[A]) HKTFA,
 	fchain func(HKTFA, func(O.Option[A]) HKTFA) HKTFA,
@@ -117,9 +98,11 @@ func MonadAlt[LAZY ~func() HKTFA, A, HKTFA any](
 
 func Alt[LAZY ~func() HKTFA, A, HKTFA any](
 	fof func(O.Option[A]) HKTFA,
-	fchain func(func(O.Option[A]) HKTFA) func(HKTFA) HKTFA,
+	fchain func(HKTFA, func(O.Option[A]) HKTFA) HKTFA,
 
 	second LAZY) func(HKTFA) HKTFA {
 
-	return fchain(O.Fold(second, F.Flow2(O.Of[A], fof)))
+	return func(fa HKTFA) HKTFA {
+		return MonadAlt(fof, fchain, fa, second)
+	}
 }

internal/pointed/types.go

@@ -1,21 +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 pointed
-
-type Pointed[A, HKTA any] interface {
-	// Of lifts a value into its higher kinded type
-	Of(A) HKTA
-}

io/generic/io.go

@@ -25,11 +25,6 @@ import (
 	T "github.com/IBM/fp-go/tuple"
 )
 
-var (
-	// undefined represents an undefined value
-	undefined = struct{}{}
-)
-
 // type IO[A any] = func() A
 
 func MakeIO[GA ~func() A, A any](f func() A) GA {
@@ -48,7 +43,7 @@ func FromIO[GA ~func() A, A any](a GA) GA {
 func FromImpure[GA ~func() any, IMP ~func()](f IMP) GA {
 	return MakeIO[GA](func() any {
 		f()
-		return undefined
+		return nil
 	})
 }
 
@@ -58,7 +53,7 @@ func MonadOf[GA ~func() A, A any](a A) GA {
 
 func MonadMap[GA ~func() A, GB ~func() B, A, B any](fa GA, f func(A) B) GB {
 	return MakeIO[GB](func() B {
-		return f(fa())
+		return F.Pipe1(fa(), f)
 	})
 }
 
@@ -71,13 +66,13 @@ func MonadMapTo[GA ~func() A, GB ~func() B, A, B any](fa GA, b B) GB {
 }
 
 func MapTo[GA ~func() A, GB ~func() B, A, B any](b B) func(GA) GB {
-	return Map[GA, GB](F.Constant1[A](b))
+	return F.Bind2nd(MonadMapTo[GA, GB, A, B], b)
 }
 
 // MonadChain composes computations in sequence, using the return value of one computation to determine the next computation.
 func MonadChain[GA ~func() A, GB ~func() B, A, B any](fa GA, f func(A) GB) GB {
 	return MakeIO[GB](func() B {
-		return f(fa())()
+		return F.Pipe1(fa(), f)()
 	})
 }
 
@@ -93,7 +88,7 @@ func MonadChainTo[GA ~func() A, GB ~func() B, A, B any](fa GA, fb GB) GB {
 
 // ChainTo composes computations in sequence, ignoring the return value of the first computation
 func ChainTo[GA ~func() A, GB ~func() B, A, B any](fb GB) func(GA) GB {
-	return Chain[GA, GB](F.Constant1[A](fb))
+	return F.Bind2nd(MonadChainTo[GA, GB, A, B], fb)
 }
 
 // MonadChainFirst composes computations in sequence, using the return value of one computation to determine the next computation and
@@ -105,11 +100,7 @@ func MonadChainFirst[GA ~func() A, GB ~func() B, A, B any](fa GA, f func(A) GB)
 // ChainFirst composes computations in sequence, using the return value of one computation to determine the next computation and
 // keeping only the result of the first.
 func ChainFirst[GA ~func() A, GB ~func() B, A, B any](f func(A) GB) func(GA) GA {
-	return C.ChainFirst(
-		Chain[GA, GA, A, A],
-		Map[GB, GA, B, A],
-		f,
-	)
+	return C.ChainFirst(MonadChain[GA, GA, A, A], MonadMap[GB, GA, B, A], f)
 }
 
 func ApSeq[GB ~func() B, GAB ~func() func(A) B, GA ~func() A, B, A any](ma GA) func(GAB) GB {
@@ -183,7 +174,7 @@ func MonadFlap[FAB ~func(A) B, GFAB ~func() FAB, GB ~func() B, A, B any](fab GFA
 }
 
 func Flap[FAB ~func(A) B, GFAB ~func() FAB, GB ~func() B, A, B any](a A) func(GFAB) GB {
-	return FC.Flap(Map[GFAB, GB, FAB, B], a)
+	return F.Bind2nd(MonadFlap[FAB, GFAB, GB, A, B], a)
 }
 
 // WithTime returns an operation that measures the start and end timestamp of the operation

io/generic/monad.go

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

io/logging_test.go

@@ -27,7 +27,7 @@ func TestLogger(t *testing.T) {
 
 	lio := l("out")
 
-	assert.NotPanics(t, func() { lio(10)() })
+	assert.Equal(t, nil, lio(10)())
 }
 
 func TestLogf(t *testing.T) {
@@ -36,5 +36,5 @@ func TestLogf(t *testing.T) {
 
 	lio := l("Value is %d")
 
-	assert.NotPanics(t, func() { lio(10)() })
+	assert.Equal(t, nil, lio(10)())
 }

io/monad.go

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

ioeither/examples_create_test.go

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

ioeither/examples_do_test.go

@@ -53,5 +53,5 @@ func ExampleIOEither_do() {
 	fmt.Println(b())
 
 	// Output:
-	// Right[int](8)
+	// Right[<nil>, int](8)
 }

ioeither/examples_extract_test.go

@@ -38,7 +38,7 @@ func ExampleIOEither_extraction() {
 	fmt.Println(valueFromIO)
 
 	// Output:
-	// Right[int](42)
+	// Right[<nil>, int](42)
 	// 42
 	// 42
 

ioeither/generic/ioeither.go

@@ -87,7 +87,7 @@ func MonadMap[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B an
 }
 
 func Map[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](f func(A) B) func(GA) GB {
-	return eithert.Map(IO.Map[GA, GB, ET.Either[E, A], ET.Either[E, B]], f)
+	return F.Bind2nd(MonadMap[GA, GB, E, A, B], f)
 }
 
 func MonadMapTo[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](fa GA, b B) GB {
@@ -95,7 +95,7 @@ func MonadMapTo[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B
 }
 
 func MapTo[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](b B) func(GA) GB {
-	return Map[GA, GB](F.Constant1[A](b))
+	return F.Bind2nd(MonadMapTo[GA, GB, E, A, B], b)
 }
 
 func MonadChain[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](fa GA, f func(A) GB) GB {
@@ -103,7 +103,7 @@ func MonadChain[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B
 }
 
 func Chain[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](f func(A) GB) func(GA) GB {
-	return eithert.Chain(IO.Chain[GA, GB, ET.Either[E, A], ET.Either[E, B]], IO.Of[GB, ET.Either[E, B]], f)
+	return F.Bind2nd(MonadChain[GA, GB, E, A, B], f)
 }
 
 func MonadChainTo[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](fa GA, fb GB) GB {
@@ -111,7 +111,7 @@ func MonadChainTo[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A,
 }
 
 func ChainTo[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](fb GB) func(GA) GB {
-	return Chain[GA, GB, E, A, B](F.Constant1[A](fb))
+	return F.Bind2nd(MonadChainTo[GA, GB, E, A, B], fb)
 }
 
 func MonadChainEitherK[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](ma GA, f func(A) ET.Either[E, B]) GB {
@@ -141,11 +141,7 @@ func ChainIOK[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GR ~func()
 }
 
 func ChainEitherK[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](f func(A) ET.Either[E, B]) func(GA) GB {
-	return FE.ChainEitherK(
-		Chain[GA, GB, E, A, B],
-		FromEither[GB, E, B],
-		f,
-	)
+	return F.Bind2nd(MonadChainEitherK[GA, GB, E, A, B], f)
 }
 
 func MonadAp[GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], GA ~func() ET.Either[E, A], E, A, B any](mab GAB, ma GA) GB {
@@ -156,10 +152,7 @@ func MonadAp[GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], GA
 }
 
 func Ap[GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], GA ~func() ET.Either[E, A], E, A, B any](ma GA) func(GAB) GB {
-	return eithert.Ap(
-		IO.Ap[GB, func() func(ET.Either[E, A]) ET.Either[E, B], GA, ET.Either[E, B], ET.Either[E, A]],
-		IO.Map[GAB, func() func(ET.Either[E, A]) ET.Either[E, B], ET.Either[E, func(A) B], func(ET.Either[E, A]) ET.Either[E, B]],
-		ma)
+	return F.Bind2nd(MonadAp[GB, GAB, GA], ma)
 }
 
 func MonadApSeq[GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], GA ~func() ET.Either[E, A], E, A, B any](mab GAB, ma GA) GB {
@@ -170,10 +163,7 @@ func MonadApSeq[GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B],
 }
 
 func ApSeq[GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], GA ~func() ET.Either[E, A], E, A, B any](ma GA) func(GAB) GB {
-	return eithert.Ap(
-		IO.ApSeq[GB, func() func(ET.Either[E, A]) ET.Either[E, B], GA, ET.Either[E, B], ET.Either[E, A]],
-		IO.Map[GAB, func() func(ET.Either[E, A]) ET.Either[E, B], ET.Either[E, func(A) B], func(ET.Either[E, A]) ET.Either[E, B]],
-		ma)
+	return F.Bind2nd(MonadApSeq[GB, GAB, GA], ma)
 }
 
 func MonadApPar[GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], GA ~func() ET.Either[E, A], E, A, B any](mab GAB, ma GA) GB {
@@ -184,10 +174,7 @@ func MonadApPar[GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B],
 }
 
 func ApPar[GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B], GA ~func() ET.Either[E, A], E, A, B any](ma GA) func(GAB) GB {
-	return eithert.Ap(
-		IO.ApPar[GB, func() func(ET.Either[E, A]) ET.Either[E, B], GA, ET.Either[E, B], ET.Either[E, A]],
-		IO.Map[GAB, func() func(ET.Either[E, A]) ET.Either[E, B], ET.Either[E, func(A) B], func(ET.Either[E, A]) ET.Either[E, B]],
-		ma)
+	return F.Bind2nd(MonadApPar[GB, GAB, GA], ma)
 }
 
 func Flatten[GA ~func() ET.Either[E, A], GAA ~func() ET.Either[E, GA], E, A any](mma GAA) GA {
@@ -213,18 +200,11 @@ func Memoize[GA ~func() ET.Either[E, A], E, A any](ma GA) GA {
 }
 
 func MonadMapLeft[GA1 ~func() ET.Either[E1, A], GA2 ~func() ET.Either[E2, A], E1, E2, A any](fa GA1, f func(E1) E2) GA2 {
-	return eithert.MonadMapLeft(
-		IO.MonadMap[GA1, GA2, ET.Either[E1, A], ET.Either[E2, A]],
-		fa,
-		f,
-	)
+	return eithert.MonadMapLeft(IO.MonadMap[GA1, GA2, ET.Either[E1, A], ET.Either[E2, A]], fa, f)
 }
 
 func MapLeft[GA1 ~func() ET.Either[E1, A], GA2 ~func() ET.Either[E2, A], E1, E2, A any](f func(E1) E2) func(GA1) GA2 {
-	return eithert.MapLeft(
-		IO.Map[GA1, GA2, ET.Either[E1, A], ET.Either[E2, A]],
-		f,
-	)
+	return F.Bind2nd(MonadMapLeft[GA1, GA2, E1, E2, A], f)
 }
 
 // Delay creates an operation that passes in the value after some [time.Duration]
@@ -243,7 +223,7 @@ func MonadBiMap[GA ~func() ET.Either[E1, A], GB ~func() ET.Either[E2, B], E1, E2
 
 // BiMap maps a pair of functions over the two type arguments of the bifunctor.
 func BiMap[GA ~func() ET.Either[E1, A], GB ~func() ET.Either[E2, B], E1, E2, A, B any](f func(E1) E2, g func(A) B) func(GA) GB {
-	return eithert.BiMap(IO.Map[GA, GB, ET.Either[E1, A], ET.Either[E2, B]], f, g)
+	return eithert.BiMap(IO.MonadMap[GA, GB, ET.Either[E1, A], ET.Either[E2, B]], f, g)
 }
 
 // Fold convers an IOEither into an IO
@@ -273,8 +253,8 @@ func MonadChainFirst[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E,
 // ChainFirst runs the monad returned by the function but returns the result of the original monad
 func ChainFirst[GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], E, A, B any](f func(A) GB) func(GA) GA {
 	return C.ChainFirst(
-		Chain[GA, GA, E, A, A],
-		Map[GB, GA, E, B, A],
+		MonadChain[GA, GA, E, A, A],
+		MonadMap[GB, GA, E, B, A],
 		f,
 	)
 }
@@ -293,8 +273,8 @@ func MonadChainFirstIOK[GA ~func() ET.Either[E, A], GIOB ~func() B, E, A, B any]
 // ChainFirstIOK runs the monad returned by the function but returns the result of the original monad
 func ChainFirstIOK[GA ~func() ET.Either[E, A], GIOB ~func() B, E, A, B any](f func(A) GIOB) func(GA) GA {
 	return FI.ChainFirstIOK(
-		Chain[GA, GA, E, A, A],
-		Map[func() ET.Either[E, B], GA, E, B, A],
+		MonadChain[GA, GA, E, A, A],
+		MonadMap[func() ET.Either[E, B], GA, E, B, A],
 		FromIO[func() ET.Either[E, B], GIOB, E, B],
 		f,
 	)
@@ -314,8 +294,8 @@ func MonadChainFirstEitherK[GA ~func() ET.Either[E, A], E, A, B any](first GA, f
 // ChainFirstEitherK runs the monad returned by the function but returns the result of the original monad
 func ChainFirstEitherK[GA ~func() ET.Either[E, A], E, A, B any](f func(A) ET.Either[E, B]) func(GA) GA {
 	return FE.ChainFirstEitherK(
-		Chain[GA, GA, E, A, A],
-		Map[func() ET.Either[E, B], GA, E, B, A],
+		MonadChain[GA, GA, E, A, A],
+		MonadMap[func() ET.Either[E, B], GA, E, B, A],
 		FromEither[func() ET.Either[E, B], E, B],
 		f,
 	)
@@ -359,7 +339,7 @@ func MonadFlap[GEAB ~func() ET.Either[E, func(A) B], GEB ~func() ET.Either[E, B]
 }
 
 func Flap[GEAB ~func() ET.Either[E, func(A) B], GEB ~func() ET.Either[E, B], E, B, A any](a A) func(GEAB) GEB {
-	return FC.Flap(Map[GEAB, GEB], a)
+	return FC.Flap(MonadMap[GEAB, GEB], a)
 }
 
 func ToIOOption[GA ~func() O.Option[A], GEA ~func() ET.Either[E, A], E, A any](ioe GEA) GA {

ioeither/generic/logging.go

@@ -24,9 +24,9 @@ import (
 	F "github.com/IBM/fp-go/function"
 )
 
-// LogJSON converts the argument to JSON and then logs it via the format string
+// LogJson converts the argument to JSON and then logs it via the format string
 // Can be used with [ChainFirst]
-func LogJSON[GA ~func() ET.Either[error, any], A any](prefix string) func(A) GA {
+func LogJson[GA ~func() ET.Either[error, any], A any](prefix string) func(A) GA {
 	return func(a A) GA {
 		// log this
 		return F.Pipe3(
@@ -41,11 +41,3 @@ func LogJSON[GA ~func() ET.Either[error, any], A any](prefix string) func(A) GA
 		)
 	}
 }
-
-// LogJson converts the argument to JSON and then logs it via the format string
-// Can be used with [ChainFirst]
-//
-// Deprecated: use [LogJSON] instead
-func LogJson[GA ~func() ET.Either[error, any], A any](prefix string) func(A) GA {
-	return LogJSON[GA, A](prefix)
-}

ioeither/http/builder/builder.go

@@ -56,7 +56,7 @@ func Requester(builder *R.Builder) IOEH.Requester {
 	return F.Pipe5(
 		builder.GetBody(),
 		O.Fold(LZ.Of(E.Of[error](withoutBody)), E.Map[error](withBody)),
-		E.Ap[func(string) IOE.IOEither[error, *http.Request]](builder.GetTargetURL()),
+		E.Ap[func(string) IOE.IOEither[error, *http.Request]](builder.GetTargetUrl()),
 		E.Flap[error, IOE.IOEither[error, *http.Request]](builder.GetMethod()),
 		E.GetOrElse(IOE.Left[*http.Request, error]),
 		IOE.Map[error](func(req *http.Request) *http.Request {

ioeither/http/builder/builder_test.go

@@ -31,12 +31,12 @@ import (
 func TestBuilderWithQuery(t *testing.T) {
 	// add some query
 	withLimit := R.WithQueryArg("limit")("10")
-	withURL := R.WithUrl("http://www.example.org?a=b")
+	withUrl := R.WithUrl("http://www.example.org?a=b")
 
 	b := F.Pipe2(
 		R.Default,
 		withLimit,
-		withURL,
+		withUrl,
 	)
 
 	req := F.Pipe3(

ioeither/http/request.go

@@ -118,28 +118,16 @@ func ReadText(client Client) func(Requester) IOE.IOEither[error, string] {
 }
 
 // ReadJson sends a request, reads the response and parses the response as JSON
-//
-// Deprecated: use [ReadJSON] instead
 func ReadJson[A any](client Client) func(Requester) IOE.IOEither[error, A] {
-	return ReadJSON[A](client)
-}
-
-// readJSON sends a request, reads the response and parses the response as a []byte
-func readJSON(client Client) func(Requester) IOE.IOEither[error, []byte] {
 	return F.Flow3(
 		ReadFullResponse(client),
 		IOE.ChainFirstEitherK(F.Flow2(
 			H.Response,
-			H.ValidateJSONResponse,
+			H.ValidateJsonResponse,
+		)),
+		IOE.ChainEitherK(F.Flow2(
+			H.Body,
+			J.Unmarshal[A],
 		)),
-		IOE.Map[error](H.Body),
-	)
-}
-
-// ReadJSON sends a request, reads the response and parses the response as JSON
-func ReadJSON[A any](client Client) func(Requester) IOE.IOEither[error, A] {
-	return F.Flow2(
-		readJSON(client),
-		IOE.ChainEitherK[error](J.Unmarshal[A]),
 	)
 }

ioeither/http/retry_test.go

@@ -40,7 +40,7 @@ var testLogPolicy = R.CapDelay(
 )
 
 type PostItem struct {
-	UserID uint   `json:"userId"`
+	UserId uint   `json:"userId"`
 	Id     uint   `json:"id"`
 	Title  string `json:"title"`
 	Body   string `json:"body"`
@@ -54,7 +54,7 @@ func TestRetryHttp(t *testing.T) {
 	action := func(status R.RetryStatus) IOE.IOEither[error, *PostItem] {
 		return F.Pipe1(
 			MakeGetRequest(urls[status.IterNumber]),
-			ReadJSON[*PostItem](client),
+			ReadJson[*PostItem](client),
 		)
 	}
 

ioeither/logging.go

@@ -21,14 +21,6 @@ import (
 
 // LogJson converts the argument to pretty printed JSON and then logs it via the format string
 // Can be used with [ChainFirst]
-//
-// Deprecated: use [LogJSON] instead
 func LogJson[A any](prefix string) func(A) IOEither[error, any] {
 	return G.LogJson[IOEither[error, any], A](prefix)
 }
-
-// LogJSON converts the argument to pretty printed JSON and then logs it via the format string
-// Can be used with [ChainFirst]
-func LogJSON[A any](prefix string) func(A) IOEither[error, any] {
-	return G.LogJSON[IOEither[error, any], A](prefix)
-}

ioeither/logging_test.go

@@ -34,7 +34,7 @@ func TestLogging(t *testing.T) {
 
 	res := F.Pipe1(
 		Of[error](src),
-		ChainFirst(LogJSON[*SomeData]("Data: \n%s")),
+		ChainFirst(LogJson[*SomeData]("Data: \n%s")),
 	)
 
 	dst := res()

iooption/generic/iooption.go

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

iterator/stateless/generic/iterator.go

@@ -18,7 +18,6 @@ package generic
 import (
 	A "github.com/IBM/fp-go/array/generic"
 	F "github.com/IBM/fp-go/function"
-	C "github.com/IBM/fp-go/internal/chain"
 	"github.com/IBM/fp-go/internal/utils"
 	IO "github.com/IBM/fp-go/iooption/generic"
 	M "github.com/IBM/fp-go/monoid"
@@ -147,23 +146,6 @@ func MonadChain[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tupl
 	return Chain[GV, GU](f)(ma)
 }
 
-func MonadChainFirst[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](ma GU, f func(U) GV) GU {
-	return C.MonadChainFirst(
-		MonadChain[GU, GU, U, U],
-		MonadMap[GU, GV, V, U],
-		ma,
-		f,
-	)
-}
-
-func ChainFirst[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](f func(U) GV) func(GU) GU {
-	return C.ChainFirst(
-		Chain[GU, GU, U, U],
-		Map[GU, GV, func(V) U, V, U],
-		f,
-	)
-}
-
 func Flatten[GV ~func() O.Option[T.Tuple2[GV, GU]], GU ~func() O.Option[T.Tuple2[GU, U]], U any](ma GV) GU {
 	return MonadChain(ma, F.Identity[GU])
 }

iterator/stateless/generic/monad.go

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

iterator/stateless/iterator.go

@@ -144,11 +144,3 @@ func FoldMap[U, V any](m M.Monoid[V]) func(func(U) V) func(ma Iterator[U]) V {
 func Fold[U any](m M.Monoid[U]) func(Iterator[U]) U {
 	return G.Fold[Iterator[U]](m)
 }
-
-func MonadChainFirst[U, V any](ma Iterator[U], f func(U) Iterator[V]) Iterator[U] {
-	return G.MonadChainFirst[Iterator[V], Iterator[U], U, V](ma, f)
-}
-
-func ChainFirst[U, V any](f func(U) Iterator[V]) func(Iterator[U]) Iterator[U] {
-	return G.ChainFirst[Iterator[V], Iterator[U], U, V](f)
-}

iterator/stateless/iterator_test.go

@@ -67,8 +67,8 @@ func isPrimeNumber(num int) bool {
 	if num <= 2 {
 		return true
 	}
-	sqRoot := int(math.Sqrt(float64(num)))
-	for i := 2; i <= sqRoot; i++ {
+	sq_root := int(math.Sqrt(float64(num)))
+	for i := 2; i <= sq_root; i++ {
 		if num%i == 0 {
 			return false
 		}

iterator/stateless/monad.go

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

magma/magma.go

@@ -23,8 +23,8 @@ type magma[A any] struct {
 	c func(A, A) A
 }
 
-func (m magma[A]) Concat(x A, y A) A {
-	return m.c(x, y)
+func (self magma[A]) Concat(x A, y A) A {
+	return self.c(x, y)
 }
 
 func MakeMagma[A any](c func(A, A) A) Magma[A] {
@@ -63,17 +63,17 @@ func FilterFirst[A any](p func(A) bool) func(Magma[A]) Magma[A] {
 func FilterSecond[A any](p func(A) bool) func(Magma[A]) Magma[A] {
 	return func(m Magma[A]) Magma[A] {
 		c := m.Concat
-		return MakeMagma(func(x, y A) A {
+		return MakeMagma(func(x A, y A) A {
 			return filterSecond(p, c, x, y)
 		})
 	}
 }
 
-func first[A any](x, _ A) A {
+func first[A any](x A, y A) A {
 	return x
 }
 
-func second[A any](_, y A) A {
+func second[A any](x A, y A) A {
 	return y
 }
 
@@ -85,7 +85,7 @@ func Second[A any]() Magma[A] {
 	return MakeMagma(second[A])
 }
 
-func endo[A any](f func(A) A, c func(A, A) A, x, y A) A {
+func endo[A any](f func(A) A, c func(A, A) A, x A, y A) A {
 	return c(f(x), f(y))
 }
 

monoid/function.go

@@ -21,9 +21,9 @@ import (
 )
 
 // FunctionMonoid forms a monoid as long as you can provide a monoid for the codomain.
-func FunctionMonoid[A, B any](m Monoid[B]) Monoid[func(A) B] {
+func FunctionMonoid[A, B any](M Monoid[B]) Monoid[func(A) B] {
 	return MakeMonoid(
-		S.FunctionSemigroup[A, B](m).Concat,
-		F.Constant1[A](m.Empty()),
+		S.FunctionSemigroup[A, B](M).Concat,
+		F.Constant1[A](M.Empty()),
 	)
 }

monoid/monoid.go

@@ -29,12 +29,12 @@ type monoid[A any] struct {
 	e A
 }
 
-func (m monoid[A]) Concat(x, y A) A {
-	return m.c(x, y)
+func (self monoid[A]) Concat(x A, y A) A {
+	return self.c(x, y)
 }
 
-func (m monoid[A]) Empty() A {
-	return m.e
+func (self monoid[A]) Empty() A {
+	return self.e
 }
 
 // MakeMonoid creates a monoid given a concat function and an empty element

optics/lens/lens.go

@@ -34,8 +34,8 @@ type (
 // modifying that copy
 func setCopy[SET ~func(*S, A) *S, S, A any](setter SET) func(s *S, a A) *S {
 	return func(s *S, a A) *S {
-		cpy := *s
-		return setter(&cpy, a)
+		copy := *s
+		return setter(&copy, a)
 	}
 }
 
@@ -45,8 +45,8 @@ func setCopyCurried[SET ~func(A) EM.Endomorphism[*S], S, A any](setter SET) func
 	return func(a A) EM.Endomorphism[*S] {
 		seta := setter(a)
 		return func(s *S) *S {
-			cpy := *s
-			return seta(&cpy)
+			copy := *s
+			return seta(&copy)
 		}
 	}
 }

optics/optional/lens/lens_test.go

@@ -36,8 +36,8 @@ func (inner *Inner) getA() int {
 	return inner.A
 }
 
-func (inner *Inner) setA(a int) *Inner {
-	inner.A = a
+func (inner *Inner) setA(A int) *Inner {
+	inner.A = A
 	return inner
 }
 

optics/optional/optional.go

@@ -33,8 +33,8 @@ type Optional[S, A any] struct {
 // modifying that copy
 func setCopy[SET ~func(*S, A) *S, S, A any](setter SET) func(s *S, a A) *S {
 	return func(s *S, a A) *S {
-		cpy := *s
-		return setter(&cpy, a)
+		copy := *s
+		return setter(&copy, a)
 	}
 }
 
@@ -113,7 +113,7 @@ func fromPredicate[S, A any](creator func(get func(S) O.Option[A], set func(S, A
 	return func(get func(S) A, set func(S, A) S) Optional[S, A] {
 		return creator(
 			F.Flow2(get, fromPred),
-			func(s S, _ A) S {
+			func(s S, a A) S {
 				return F.Pipe3(
 					s,
 					get,

optics/optional/prism/prism.go

@@ -22,8 +22,8 @@ import (
 	O "github.com/IBM/fp-go/option"
 )
 
-// AsOptional converts a prism into an optional
-func AsOptional[S, A any](sa P.Prism[S, A]) OPT.Optional[S, A] {
+// PrismAsOptional converts a prism into an optional
+func PrismAsOptional[S, A any](sa P.Prism[S, A]) OPT.Optional[S, A] {
 	return OPT.MakeOptional(
 		sa.GetOption,
 		func(s S, a A) S {
@@ -38,5 +38,5 @@ func PrismSome[A any]() P.Prism[O.Option[A], A] {
 
 // Some returns a `Optional` from a `Optional` focused on the `Some` of a `Option` type.
 func Some[S, A any](soa OPT.Optional[S, O.Option[A]]) OPT.Optional[S, A] {
-	return OPT.Compose[S](AsOptional(PrismSome[A]()))(soa)
+	return OPT.Compose[S](PrismAsOptional(PrismSome[A]()))(soa)
 }

option/core.go

@@ -19,79 +19,52 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
-	"reflect"
 )
 
 var (
-	// jsonNull is the cached representation of the `null` serialization in JSON
 	jsonNull = []byte("null")
 )
 
 // Option defines a data structure that logically holds a value or not
 type Option[A any] struct {
 	isSome bool
-	value  A
-}
-
-// optString prints some debug info for the object
-//
-// go:noinline
-func optString(isSome bool, value any) string {
-	if isSome {
-		return fmt.Sprintf("Some[%T](%v)", value, value)
-	}
-	return fmt.Sprintf("None[%T]", value)
-}
-
-// optFormat prints some debug info for the object
-//
-// go:noinline
-func optFormat(isSome bool, value any, f fmt.State, c rune) {
-	switch c {
-	case 's':
-		fmt.Fprint(f, optString(isSome, value))
-	default:
-		fmt.Fprint(f, optString(isSome, value))
-	}
+	some   A
 }
 
 // String prints some debug info for the object
 func (s Option[A]) String() string {
-	return optString(s.isSome, s.value)
+	if s.isSome {
+		return fmt.Sprintf("Some[%T](%v)", s.some, s.some)
+	}
+	return fmt.Sprintf("None[%T]", s.some)
 }
 
 // Format prints some debug info for the object
 func (s Option[A]) Format(f fmt.State, c rune) {
-	optFormat(s.isSome, s.value, f, c)
+	switch c {
+	case 's':
+		fmt.Fprint(f, s.String())
+	default:
+		fmt.Fprint(f, s.String())
+	}
 }
 
-func optMarshalJSON(isSome bool, value any) ([]byte, error) {
-	if isSome {
-		return json.Marshal(value)
+func (s Option[A]) MarshalJSON() ([]byte, error) {
+	if IsSome(s) {
+		return json.Marshal(s.some)
 	}
 	return jsonNull, nil
 }
 
-func (s Option[A]) MarshalJSON() ([]byte, error) {
-	return optMarshalJSON(s.isSome, s.value)
-}
-
-// optUnmarshalJSON unmarshals the [Option] from a JSON string
-//
-// go:noinline
-func optUnmarshalJSON(isSome *bool, value any, data []byte) error {
+func (s *Option[A]) UnmarshalJSON(data []byte) error {
 	// decode the value
 	if bytes.Equal(data, jsonNull) {
-		*isSome = false
-		reflect.ValueOf(value).Elem().SetZero()
+		s.isSome = false
+		s.some = *new(A)
 		return nil
 	}
-	*isSome = true
-	return json.Unmarshal(data, value)
-}
-
-func (s *Option[A]) UnmarshalJSON(data []byte) error {
-	return optUnmarshalJSON(&s.isSome, &s.value, data)
+	s.isSome = true
+	return json.Unmarshal(data, &s.some)
 }
 
 func IsNone[T any](val Option[T]) bool {
@@ -99,7 +72,7 @@ func IsNone[T any](val Option[T]) bool {
 }
 
 func Some[T any](value T) Option[T] {
-	return Option[T]{isSome: true, value: value}
+	return Option[T]{isSome: true, some: value}
 }
 
 func Of[T any](value T) Option[T] {
@@ -116,11 +89,11 @@ func IsSome[T any](val Option[T]) bool {
 
 func MonadFold[A, B any](ma Option[A], onNone func() B, onSome func(A) B) B {
 	if IsSome(ma) {
-		return onSome(ma.value)
+		return onSome(ma.some)
 	}
 	return onNone()
 }
 
 func Unwrap[A any](ma Option[A]) (A, bool) {
-	return ma.value, ma.isSome
+	return ma.some, ma.isSome
 }

option/monad.go

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

option/option.go

@@ -18,7 +18,6 @@ package option
 
 import (
 	F "github.com/IBM/fp-go/function"
-	C "github.com/IBM/fp-go/internal/chain"
 	FC "github.com/IBM/fp-go/internal/functor"
 )
 
@@ -96,10 +95,10 @@ func MonadChain[A, B any](fa Option[A], f func(A) Option[B]) Option[B] {
 }
 
 func Chain[A, B any](f func(A) Option[B]) func(Option[A]) Option[B] {
-	return Fold(None[B], f)
+	return F.Bind2nd(MonadChain[A, B], f)
 }
 
-func MonadChainTo[A, B any](_ Option[A], mb Option[B]) Option[B] {
+func MonadChainTo[A, B any](ma Option[A], mb Option[B]) Option[B] {
 	return mb
 }
 
@@ -108,20 +107,13 @@ func ChainTo[A, B any](mb Option[B]) func(Option[A]) Option[B] {
 }
 
 func MonadChainFirst[A, B any](ma Option[A], f func(A) Option[B]) Option[A] {
-	return C.MonadChainFirst(
-		MonadChain[A, A],
-		MonadMap[B, A],
-		ma,
-		f,
-	)
+	return MonadChain(ma, func(a A) Option[A] {
+		return MonadMap(f(a), F.Constant1[B](a))
+	})
 }
 
 func ChainFirst[A, B any](f func(A) Option[B]) func(Option[A]) Option[A] {
-	return C.ChainFirst(
-		Chain[A, A],
-		Map[B, A],
-		f,
-	)
+	return F.Bind2nd(MonadChainFirst[A, B], f)
 }
 
 func Flatten[A any](mma Option[Option[A]]) Option[A] {
@@ -164,5 +156,5 @@ func MonadFlap[B, A any](fab Option[func(A) B], a A) Option[B] {
 }
 
 func Flap[B, A any](a A) func(Option[func(A) B]) Option[B] {
-	return FC.Flap(Map[func(A) B, B], a)
+	return F.Bind2nd(MonadFlap[B, A], a)
 }

ord/monoid.go

@@ -42,11 +42,11 @@ func Monoid[A any]() M.Monoid[Ord[A]] {
 }
 
 // MaxSemigroup returns a semigroup where `concat` will return the maximum, based on the provided order.
-func MaxSemigroup[A any](o Ord[A]) S.Semigroup[A] {
-	return S.MakeSemigroup(Max(o))
+func MaxSemigroup[A any](O Ord[A]) S.Semigroup[A] {
+	return S.MakeSemigroup(Max(O))
 }
 
 // MaxSemigroup returns a semigroup where `concat` will return the minimum, based on the provided order.
-func MinSemigroup[A any](o Ord[A]) S.Semigroup[A] {
-	return S.MakeSemigroup(Min(o))
+func MinSemigroup[A any](O Ord[A]) S.Semigroup[A] {
+	return S.MakeSemigroup(Min(O))
 }

ord/ord.go

@@ -132,10 +132,10 @@ func FromStrictCompare[A C.Ordered]() Ord[A] {
 }
 
 // Lt tests whether one value is strictly less than another
-func Lt[A any](o Ord[A]) func(A) func(A) bool {
+func Lt[A any](O Ord[A]) func(A) func(A) bool {
 	return func(second A) func(A) bool {
 		return func(first A) bool {
-			return o.Compare(first, second) < 0
+			return O.Compare(first, second) < 0
 		}
 	}
 }

pair/eq.go

@@ -1,33 +0,0 @@
-// Copyright (c) 2024 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package pair
-
-import (
-	EQ "github.com/IBM/fp-go/eq"
-)
-
-// Constructs an equal predicate for an `Either`
-func Eq[A, B any](a EQ.Eq[A], b EQ.Eq[B]) EQ.Eq[Pair[A, B]] {
-	return EQ.FromEquals(func(l, r Pair[A, B]) bool {
-		return a.Equals(Head(l), Head(r)) && b.Equals(Tail(l), Tail(r))
-	})
-
-}
-
-// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
-func FromStrictEquals[A, B comparable]() EQ.Eq[Pair[A, B]] {
-	return Eq(EQ.FromStrictEquals[A](), EQ.FromStrictEquals[B]())
-}

pair/monad.go

@@ -1,193 +0,0 @@
-// Copyright (c) 2024 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package pair
-
-import (
-	"github.com/IBM/fp-go/internal/applicative"
-	"github.com/IBM/fp-go/internal/functor"
-	"github.com/IBM/fp-go/internal/monad"
-	"github.com/IBM/fp-go/internal/pointed"
-	M "github.com/IBM/fp-go/monoid"
-	Sg "github.com/IBM/fp-go/semigroup"
-)
-
-type (
-	pairPointedHead[A, B any] struct {
-		m M.Monoid[B]
-	}
-
-	pairFunctorHead[A, B, A1 any] struct {
-	}
-
-	pairApplicativeHead[A, B, A1 any] struct {
-		s Sg.Semigroup[B]
-		m M.Monoid[B]
-	}
-
-	pairMonadHead[A, B, A1 any] struct {
-		s Sg.Semigroup[B]
-		m M.Monoid[B]
-	}
-
-	pairPointedTail[A, B any] struct {
-		m M.Monoid[A]
-	}
-
-	pairFunctorTail[A, B, B1 any] struct {
-	}
-
-	pairApplicativeTail[A, B, B1 any] struct {
-		s Sg.Semigroup[A]
-		m M.Monoid[A]
-	}
-
-	pairMonadTail[A, B, B1 any] struct {
-		s Sg.Semigroup[A]
-		m M.Monoid[A]
-	}
-)
-
-func (o *pairMonadHead[A, B, A1]) Of(a A) Pair[A, B] {
-	return MakePair(a, o.m.Empty())
-}
-
-func (o *pairMonadHead[A, B, A1]) Map(f func(A) A1) func(Pair[A, B]) Pair[A1, B] {
-	return Map[B](f)
-}
-
-func (o *pairMonadHead[A, B, A1]) Chain(f func(A) Pair[A1, B]) func(Pair[A, B]) Pair[A1, B] {
-	return Chain[B, A, A1](o.s, f)
-}
-
-func (o *pairMonadHead[A, B, A1]) Ap(fa Pair[A, B]) func(Pair[func(A) A1, B]) Pair[A1, B] {
-	return Ap[B, A, A1](o.s, fa)
-}
-
-func (o *pairPointedHead[A, B]) Of(a A) Pair[A, B] {
-	return MakePair(a, o.m.Empty())
-}
-
-func (o *pairFunctorHead[A, B, A1]) Map(f func(A) A1) func(Pair[A, B]) Pair[A1, B] {
-	return Map[B, A, A1](f)
-}
-
-func (o *pairApplicativeHead[A, B, A1]) Map(f func(A) A1) func(Pair[A, B]) Pair[A1, B] {
-	return Map[B, A, A1](f)
-}
-
-func (o *pairApplicativeHead[A, B, A1]) Ap(fa Pair[A, B]) func(Pair[func(A) A1, B]) Pair[A1, B] {
-	return Ap[B, A, A1](o.s, fa)
-}
-
-func (o *pairApplicativeHead[A, B, A1]) Of(a A) Pair[A, B] {
-	return MakePair(a, o.m.Empty())
-}
-
-// Monad implements the monadic operations for [Pair]
-func Monad[A, B, A1 any](m M.Monoid[B]) monad.Monad[A, A1, Pair[A, B], Pair[A1, B], Pair[func(A) A1, B]] {
-	return &pairMonadHead[A, B, A1]{s: M.ToSemigroup(m), m: m}
-}
-
-// Pointed implements the pointed operations for [Pair]
-func Pointed[A, B any](m M.Monoid[B]) pointed.Pointed[A, Pair[A, B]] {
-	return &pairPointedHead[A, B]{m: m}
-}
-
-// Functor implements the functor operations for [Pair]
-func Functor[A, B, A1 any]() functor.Functor[A, A1, Pair[A, B], Pair[A1, B]] {
-	return &pairFunctorHead[A, B, A1]{}
-}
-
-// Applicative implements the applicative operations for [Pair]
-func Applicative[A, B, A1 any](m M.Monoid[B]) applicative.Applicative[A, A1, Pair[A, B], Pair[A1, B], Pair[func(A) A1, B]] {
-	return &pairApplicativeHead[A, B, A1]{s: M.ToSemigroup(m), m: m}
-}
-
-// MonadHead implements the monadic operations for [Pair]
-func MonadHead[A, B, A1 any](m M.Monoid[B]) monad.Monad[A, A1, Pair[A, B], Pair[A1, B], Pair[func(A) A1, B]] {
-	return Monad[A, B, A1](m)
-}
-
-// PointedHead implements the pointed operations for [Pair]
-func PointedHead[A, B any](m M.Monoid[B]) pointed.Pointed[A, Pair[A, B]] {
-	return PointedHead[A, B](m)
-}
-
-// FunctorHead implements the functor operations for [Pair]
-func FunctorHead[A, B, A1 any]() functor.Functor[A, A1, Pair[A, B], Pair[A1, B]] {
-	return Functor[A, B, A1]()
-}
-
-// ApplicativeHead implements the applicative operations for [Pair]
-func ApplicativeHead[A, B, A1 any](m M.Monoid[B]) applicative.Applicative[A, A1, Pair[A, B], Pair[A1, B], Pair[func(A) A1, B]] {
-	return Applicative[A, B, A1](m)
-}
-
-func (o *pairMonadTail[A, B, B1]) Of(b B) Pair[A, B] {
-	return MakePair(o.m.Empty(), b)
-}
-
-func (o *pairMonadTail[A, B, B1]) Map(f func(B) B1) func(Pair[A, B]) Pair[A, B1] {
-	return MapTail[A, B, B1](f)
-}
-
-func (o *pairMonadTail[A, B, B1]) Chain(f func(B) Pair[A, B1]) func(Pair[A, B]) Pair[A, B1] {
-	return ChainTail[A, B, B1](o.s, f)
-}
-
-func (o *pairMonadTail[A, B, B1]) Ap(fa Pair[A, B]) func(Pair[A, func(B) B1]) Pair[A, B1] {
-	return ApTail[A, B, B1](o.s, fa)
-}
-
-func (o *pairPointedTail[A, B]) Of(b B) Pair[A, B] {
-	return MakePair(o.m.Empty(), b)
-}
-
-func (o *pairFunctorTail[A, B, B1]) Map(f func(B) B1) func(Pair[A, B]) Pair[A, B1] {
-	return MapTail[A, B, B1](f)
-}
-
-func (o *pairApplicativeTail[A, B, B1]) Map(f func(B) B1) func(Pair[A, B]) Pair[A, B1] {
-	return MapTail[A, B, B1](f)
-}
-
-func (o *pairApplicativeTail[A, B, B1]) Ap(fa Pair[A, B]) func(Pair[A, func(B) B1]) Pair[A, B1] {
-	return ApTail[A, B, B1](o.s, fa)
-}
-
-func (o *pairApplicativeTail[A, B, B1]) Of(b B) Pair[A, B] {
-	return MakePair(o.m.Empty(), b)
-}
-
-// MonadTail implements the monadic operations for [Pair]
-func MonadTail[B, A, B1 any](m M.Monoid[A]) monad.Monad[B, B1, Pair[A, B], Pair[A, B1], Pair[A, func(B) B1]] {
-	return &pairMonadTail[A, B, B1]{s: M.ToSemigroup(m), m: m}
-}
-
-// PointedTail implements the pointed operations for [Pair]
-func PointedTail[B, A any](m M.Monoid[A]) pointed.Pointed[B, Pair[A, B]] {
-	return &pairPointedTail[A, B]{m: m}
-}
-
-// FunctorTail implements the functor operations for [Pair]
-func FunctorTail[B, A, B1 any]() functor.Functor[B, B1, Pair[A, B], Pair[A, B1]] {
-	return &pairFunctorTail[A, B, B1]{}
-}
-
-// ApplicativeTail implements the applicative operations for [Pair]
-func ApplicativeTail[B, A, B1 any](m M.Monoid[A]) applicative.Applicative[B, B1, Pair[A, B], Pair[A, B1], Pair[A, func(B) B1]] {
-	return &pairApplicativeTail[A, B, B1]{s: M.ToSemigroup(m), m: m}
-}