fix: optimize strings package

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

array/generic/array.go

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

array/generic/monad.go

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

array/monad.go

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

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_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"`

either/either.go

@@ -64,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 F.Bind2nd(MonadMapTo[E, A, B], b)
+	return Map[E](F.Constant1[A](b))
 }
 
 func MonadMapLeft[E1, A, E2 any](fa Either[E1, A], f func(E1) E2) Either[E2, A] {
@@ -77,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 F.Bind2nd(MonadMapLeft[E1, A, E2], f)
+	return Fold(F.Flow2(f, Left[A, E2]), Right[E2, A])
 }
 
 func MonadChain[E, A, B any](fa Either[E, A], f func(a A) Either[E, B]) Either[E, B] {
@@ -106,11 +106,11 @@ func ChainOptionK[A, B, E any](onNone func() E) func(func(A) O.Option[B]) func(E
 }
 
 func ChainTo[A, E, B any](mb Either[E, B]) func(Either[E, A]) Either[E, B] {
-	return F.Bind2nd(MonadChainTo[A, E, B], mb)
+	return F.Constant1[Either[E, A]](mb)
 }
 
 func Chain[E, A, B any](f func(a A) Either[E, B]) func(Either[E, A]) Either[E, B] {
-	return F.Bind2nd(MonadChain[E, A, B], f)
+	return Fold(Left[B, E], f)
 }
 
 func ChainFirst[E, A, B any](f func(a A) Either[E, B]) func(Either[E, A]) Either[E, A] {
@@ -251,7 +251,7 @@ func MonadFlap[E, B, A any](fab Either[E, func(A) B], a A) Either[E, B] {
 }
 
 func Flap[E, B, A any](a A) func(Either[E, func(A) B]) Either[E, B] {
-	return F.Bind2nd(MonadFlap[E, B, A], a)
+	return FC.Flap(Map[E, func(A) B, B], a)
 }
 
 func MonadAlt[E, A any](fa Either[E, A], that L.Lazy[Either[E, A]]) Either[E, A] {

either/monad.go

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

function/binds.go

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

http/builder/builder.go

@@ -76,7 +76,7 @@ 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
@@ -153,7 +153,7 @@ func (builder *Builder) GetTargetUrl() E.Either[error, string] {
 	return F.Pipe3(
 		builder,
 		Url.Get,
-		parseUrl,
+		parseURL,
 		E.Chain(F.Flow4(
 			T.Replicate2[*url.URL],
 			T.Map2(

identity/generic/identity.go

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

identity/monad.go

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

internal/applicative/types.go

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

internal/apply/ap.go

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

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

internal/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(HKTA, func(A) HKTA) HKTA,
-	mmap func(HKTB, func(B) A) HKTA,
+	mchain func(func(A) HKTA) func(HKTA) HKTA,
+	mmap func(func(B) A) func(HKTB) HKTA,
 	f func(A) HKTB) func(HKTA) HKTA {
-	return F.Bind2nd(mchain, func(a A) HKTA {
-		return mmap(f(a), F.Constant1[B](a))
+	return mchain(func(a A) HKTA {
+		return mmap(F.Constant1[B](a))(f(a))
 	})
 }
 

internal/chain/types.go

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

internal/eithert/either.go

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

internal/foldable/types.go

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

internal/fromeither/either.go

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

internal/fromeither/types.go

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

internal/fromio/io.go

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

internal/fromio/types.go

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

internal/fromioeither/ioeither.go

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

internal/functor/flap.go

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

internal/functor/functor.go

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

internal/functor/types.go

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

internal/monad/monad.go

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

internal/optiont/option.go

@@ -50,13 +50,11 @@ func MonadChain[A, B, HKTFA, HKTFB any](
 }
 
 func Chain[A, B, HKTFA, HKTFB any](
-	fchain func(HKTFA, func(O.Option[A]) HKTFB) HKTFB,
+	fchain func(func(O.Option[A]) HKTFB) func(HKTFA) HKTFB,
 	fof func(O.Option[B]) HKTFB,
 	f func(A) HKTFB) func(ma HKTFA) HKTFB {
 	// dispatch to the even more generic implementation
-	return func(ma HKTFA) HKTFB {
-		return MonadChain(fchain, fof, ma, f)
-	}
+	return fchain(O.Fold(F.Nullary2(O.None[B], fof), f))
 }
 
 func MonadAp[A, B, HKTFAB, HKTFGAB, HKTFA, HKTFB any](
@@ -67,6 +65,13 @@ 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))
 }
@@ -86,6 +91,14 @@ func MonadChainOptionK[A, B, HKTA, HKTB any](
 	return MonadChain(fchain, fof, ma, FromOptionK(fof, f))
 }
 
+func ChainOptionK[A, B, HKTA, HKTB any](
+	fchain func(func(O.Option[A]) HKTB) func(HKTA) HKTB,
+	fof func(O.Option[B]) HKTB,
+	f func(A) O.Option[B],
+) func(HKTA) HKTB {
+	return Chain(fchain, fof, FromOptionK(fof, f))
+}
+
 func MonadAlt[LAZY ~func() HKTFA, A, HKTFA any](
 	fof func(O.Option[A]) HKTFA,
 	fchain func(HKTFA, func(O.Option[A]) HKTFA) HKTFA,
@@ -98,11 +111,9 @@ func MonadAlt[LAZY ~func() HKTFA, A, HKTFA any](
 
 func Alt[LAZY ~func() HKTFA, A, HKTFA any](
 	fof func(O.Option[A]) HKTFA,
-	fchain func(HKTFA, func(O.Option[A]) HKTFA) HKTFA,
+	fchain func(func(O.Option[A]) HKTFA) func(HKTFA) HKTFA,
 
 	second LAZY) func(HKTFA) HKTFA {
 
-	return func(fa HKTFA) HKTFA {
-		return MonadAlt(fof, fchain, fa, second)
-	}
+	return fchain(O.Fold(second, F.Flow2(O.Of[A], fof)))
 }

internal/pointed/types.go

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

@@ -53,7 +53,7 @@ func MonadOf[GA ~func() A, A any](a A) GA {
 
 func MonadMap[GA ~func() A, GB ~func() B, A, B any](fa GA, f func(A) B) GB {
 	return MakeIO[GB](func() B {
-		return F.Pipe1(fa(), f)
+		return f(fa())
 	})
 }
 
@@ -66,13 +66,13 @@ func MonadMapTo[GA ~func() A, GB ~func() B, A, B any](fa GA, b B) GB {
 }
 
 func MapTo[GA ~func() A, GB ~func() B, A, B any](b B) func(GA) GB {
-	return F.Bind2nd(MonadMapTo[GA, GB, A, B], b)
+	return Map[GA, GB](F.Constant1[A](b))
 }
 
 // MonadChain composes computations in sequence, using the return value of one computation to determine the next computation.
 func MonadChain[GA ~func() A, GB ~func() B, A, B any](fa GA, f func(A) GB) GB {
 	return MakeIO[GB](func() B {
-		return F.Pipe1(fa(), f)()
+		return f(fa())()
 	})
 }
 
@@ -88,7 +88,7 @@ func MonadChainTo[GA ~func() A, GB ~func() B, A, B any](fa GA, fb GB) GB {
 
 // ChainTo composes computations in sequence, ignoring the return value of the first computation
 func ChainTo[GA ~func() A, GB ~func() B, A, B any](fb GB) func(GA) GB {
-	return F.Bind2nd(MonadChainTo[GA, GB, A, B], fb)
+	return Chain[GA, GB](F.Constant1[A](fb))
 }
 
 // MonadChainFirst composes computations in sequence, using the return value of one computation to determine the next computation and
@@ -100,7 +100,11 @@ func MonadChainFirst[GA ~func() A, GB ~func() B, A, B any](fa GA, f func(A) GB)
 // ChainFirst composes computations in sequence, using the return value of one computation to determine the next computation and
 // keeping only the result of the first.
 func ChainFirst[GA ~func() A, GB ~func() B, A, B any](f func(A) GB) func(GA) GA {
-	return C.ChainFirst(MonadChain[GA, GA, A, A], MonadMap[GB, GA, B, A], f)
+	return C.ChainFirst(
+		Chain[GA, GA, A, A],
+		Map[GB, GA, B, A],
+		f,
+	)
 }
 
 func ApSeq[GB ~func() B, GAB ~func() func(A) B, GA ~func() A, B, A any](ma GA) func(GAB) GB {
@@ -174,7 +178,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 F.Bind2nd(MonadFlap[FAB, GFAB, GB, A, B], a)
+	return FC.Flap(Map[GFAB, GB, FAB, B], a)
 }
 
 // WithTime returns an operation that measures the start and end timestamp of the operation

io/generic/monad.go

@@ -0,0 +1,43 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	"github.com/IBM/fp-go/internal/monad"
+)
+
+type 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/monad.go

@@ -0,0 +1,26 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package 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/generic/ioeither.go

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

ioeither/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/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"`

iooption/generic/iooption.go

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

iterator/stateless/generic/monad.go

@@ -0,0 +1,45 @@
+// 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_test.go

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

iterator/stateless/monad.go

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

option/monad.go

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

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

reader/generic/reader.go

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

readereither/generic/reader.go

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

readerio/generic/reader.go

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

readerioeither/generic/reader.go

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

record/generic/record.go

@@ -598,7 +598,7 @@ func MonadFlap[GFAB ~map[K]func(A) B, GB ~map[K]B, K comparable, A, B any](fab G
 }
 
 func Flap[GFAB ~map[K]func(A) B, GB ~map[K]B, K comparable, A, B any](a A) func(GFAB) GB {
-	return FC.Flap(MonadMap[GFAB, GB], a)
+	return FC.Flap(Map[GFAB, GB], a)
 }
 
 func Copy[M ~map[K]V, K comparable, V any](m M) M {

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

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

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

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

samples/http/http_test.go

@@ -33,8 +33,8 @@ import (
 )
 
 type PostItem struct {
-	UserId uint   `json:"userId"`
-	Id     uint   `json:"id"`
+	UserID uint   `json:"userId"`
+	ID     uint   `json:"id"`
 	Title  string `json:"title"`
 	Body   string `json:"body"`
 }
@@ -43,7 +43,7 @@ type CatFact struct {
 	Fact string `json:"fact"`
 }
 
-func idxToUrl(idx int) string {
+func idxToURL(idx int) string {
 	return fmt.Sprintf("https://jsonplaceholder.typicode.com/posts/%d", idx+1)
 }
 
@@ -59,7 +59,7 @@ func TestMultipleHttpRequests(t *testing.T) {
 	count := 10
 
 	data := F.Pipe3(
-		A.MakeBy(count, idxToUrl),
+		A.MakeBy(count, idxToURL),
 		R.TraverseArray(F.Flow3(
 			H.MakeGetRequest,
 			readSinglePost,
@@ -74,7 +74,7 @@ func TestMultipleHttpRequests(t *testing.T) {
 	assert.Equal(t, E.Of[error](count), result())
 }
 
-func heterogeneousHttpRequests() R.ReaderIOEither[T.Tuple2[PostItem, CatFact]] {
+func heterogeneousHTTPRequests() R.ReaderIOEither[T.Tuple2[PostItem, CatFact]] {
 	// prepare the http client
 	client := H.MakeClient(HTTP.DefaultClient)
 	// readSinglePost sends a GET request and parses the response as [PostItem]
@@ -97,7 +97,7 @@ func heterogeneousHttpRequests() R.ReaderIOEither[T.Tuple2[PostItem, CatFact]] {
 // TestHeterogeneousHttpRequests shows how to execute multiple HTTP requests in parallel when
 // the response structure of these requests is different. We use [R.TraverseTuple2] to account for the different types
 func TestHeterogeneousHttpRequests(t *testing.T) {
-	data := heterogeneousHttpRequests()
+	data := heterogeneousHTTPRequests()
 
 	result := data(context.Background())
 
@@ -108,6 +108,6 @@ func TestHeterogeneousHttpRequests(t *testing.T) {
 // the response structure of these requests is different. We use [R.TraverseTuple2] to account for the different types
 func BenchmarkHeterogeneousHttpRequests(b *testing.B) {
 	for n := 0; n < b.N; n++ {
-		heterogeneousHttpRequests()(context.Background())()
+		heterogeneousHTTPRequests()(context.Background())()
 	}
 }

samples/mostly-adequate/chapter06_exampleapplication_test.go

@@ -67,26 +67,26 @@ func Example_application() {
 		S.Format[string](fmt.Sprintf("https://%s%s%%s", host, path)),
 	)
 	// flick returns jsonP, we extract the JSON body, this is handled by jquery in the original code
-	sanitizeJsonP := Replace(regexp.MustCompile(`(?s)^\s*\((.*)\)\s*$`))("$1")
+	sanitizeJSONP := Replace(regexp.MustCompile(`(?s)^\s*\((.*)\)\s*$`))("$1")
 	// parse jsonP
-	parseJsonP := F.Flow3(
-		sanitizeJsonP,
+	parseJSONP := F.Flow3(
+		sanitizeJSONP,
 		S.ToBytes,
 		J.Unmarshal[FlickrFeed],
 	)
 	// markup
 	img := S.Format[string]("<img src='%s'/>")
 	// lenses
-	mediaUrl := F.Flow2(
+	mediaURL := F.Flow2(
 		FlickrItem.getMedia,
 		FlickrMedia.getLink,
 	)
-	mediaUrls := F.Flow2(
+	mediaURLs := F.Flow2(
 		FlickrFeed.getItems,
-		A.Map(mediaUrl),
+		A.Map(mediaURL),
 	)
 	images := F.Flow2(
-		mediaUrls,
+		mediaURLs,
 		A.Map(img),
 	)
 
@@ -97,7 +97,7 @@ func Example_application() {
 		url,
 		H.MakeGetRequest,
 		H.ReadText(client),
-		R.ChainEitherK(parseJsonP),
+		R.ChainEitherK(parseJSONP),
 		R.Map(images),
 	)
 

samples/mostly-adequate/chapter10_applicativefunctor_test.go

@@ -32,7 +32,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"`
@@ -77,7 +77,7 @@ func (player Player) getName() string {
 	return player.Name
 }
 
-func (player Player) getId() int {
+func (player Player) getID() int {
 	return player.Id
 }
 
@@ -85,7 +85,7 @@ func (item PostItem) getTitle() string {
 	return item.Title
 }
 
-func idxToUrl(idx int) string {
+func idxToURL(idx int) string {
 	return fmt.Sprintf("https://jsonplaceholder.typicode.com/posts/%d", idx+1)
 }
 
@@ -101,7 +101,7 @@ func Example_renderPage() {
 
 	// get returns the title of the nth item from the REST service
 	get := F.Flow4(
-		idxToUrl,
+		idxToURL,
 		H.MakeGetRequest,
 		H.ReadJson[PostItem](client),
 		R.Map(PostItem.getTitle),

samples/mostly-adequate/chapter11_transformagain_test.go

@@ -26,7 +26,7 @@ import (
 	S "github.com/IBM/fp-go/string"
 )
 
-func findUserById(id int) IOE.IOEither[error, Chapter08User] {
+func findUserByID(id int) IOE.IOEither[error, Chapter08User] {
 	switch id {
 	case 1:
 		return IOE.Of[error](albert08)
@@ -52,15 +52,15 @@ func Example_solution11A() {
 }
 
 func Example_solution11B() {
-	findByNameId := F.Flow2(
-		findUserById,
+	findByNameID := F.Flow2(
+		findUserByID,
 		IOE.Map[error](Chapter08User.getName),
 	)
 
-	fmt.Println(findByNameId(1)())
-	fmt.Println(findByNameId(2)())
-	fmt.Println(findByNameId(3)())
-	fmt.Println(findByNameId(4)())
+	fmt.Println(findByNameID(1)())
+	fmt.Println(findByNameID(2)())
+	fmt.Println(findByNameID(3)())
+	fmt.Println(findByNameID(4)())
 
 	// Output:
 	// Right[<nil>, string](Albert)

samples/mostly-adequate/chapter12_traversing_test.go

@@ -42,7 +42,7 @@ var (
 	}
 
 	// validate :: Player -> Either error Player
-	validatePlayer = E.FromPredicate(P.ContraMap(Player.getName)(S.IsNonEmpty), F.Flow2(Player.getId, errors.OnSome[int]("player %d must have a name")))
+	validatePlayer = E.FromPredicate(P.ContraMap(Player.getName)(S.IsNonEmpty), F.Flow2(Player.getID, errors.OnSome[int]("player %d must have a name")))
 
 	// readfile :: String -> String -> Task Error String
 	readfile = F.Curry2(func(encoding, file string) IOE.IOEither[error, string] {

samples/presentation/benchmarks/http_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"`
@@ -41,7 +41,7 @@ type CatFact struct {
 	Fact string `json:"fact"`
 }
 
-func heterogeneousHttpRequests(count int) R.ReaderIOEither[[]T.Tuple2[PostItem, CatFact]] {
+func heterogeneousHTTPRequests(count int) R.ReaderIOEither[[]T.Tuple2[PostItem, CatFact]] {
 	// prepare the http client
 	client := H.MakeClient(HTTP.DefaultClient)
 	// readSinglePost sends a GET request and parses the response as [PostItem]
@@ -64,7 +64,7 @@ func heterogeneousHttpRequests(count int) R.ReaderIOEither[[]T.Tuple2[PostItem,
 	)
 }
 
-func heterogeneousHttpRequestsIdiomatic(count int) ([]T.Tuple2[PostItem, CatFact], error) {
+func heterogeneousHTTPRequestsIdiomatic(count int) ([]T.Tuple2[PostItem, CatFact], error) {
 	// prepare the http client
 	var result []T.Tuple2[PostItem, CatFact]
 
@@ -109,13 +109,13 @@ func BenchmarkHeterogeneousHttpRequests(b *testing.B) {
 
 	b.Run("functional", func(b *testing.B) {
 		for n := 0; n < b.N; n++ {
-			benchResults = heterogeneousHttpRequests(count)(context.Background())()
+			benchResults = heterogeneousHTTPRequests(count)(context.Background())()
 		}
 	})
 
 	b.Run("idiomatic", func(b *testing.B) {
 		for n := 0; n < b.N; n++ {
-			benchResults, _ = heterogeneousHttpRequestsIdiomatic(count)
+			benchResults, _ = heterogeneousHTTPRequestsIdiomatic(count)
 		}
 	})
 

samples/readerioeither/example1/reader_test.go

@@ -0,0 +1,89 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package example1
+
+import (
+	"os"
+
+	B "github.com/IBM/fp-go/bytes"
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	I "github.com/IBM/fp-go/identity"
+	IOE "github.com/IBM/fp-go/ioeither"
+	J "github.com/IBM/fp-go/json"
+	RIOE "github.com/IBM/fp-go/readerioeither"
+)
+
+type (
+	WriterType = func([]byte) IOE.IOEither[error, []byte]
+
+	Dependencies struct {
+		Writer WriterType
+	}
+)
+
+func getWriter(deps *Dependencies) WriterType {
+	return deps.Writer
+}
+
+// SerializeToWriter marshals the input to JSON and persists the result via the [Writer] passed in via the [*Dependencies]
+func SerializeToWriter[A any](data A) RIOE.ReaderIOEither[*Dependencies, error, []byte] {
+	return F.Pipe1(
+		RIOE.Ask[*Dependencies, error](),
+		RIOE.ChainIOEitherK[*Dependencies](F.Flow2(
+			getWriter,
+			F.Pipe2(
+				data,
+				J.Marshal[A],
+				E.Fold(F.Flow2(
+					IOE.Left[[]byte, error],
+					F.Constant1[WriterType, IOE.IOEither[error, []byte]],
+				), I.Ap[IOE.IOEither[error, []byte], []byte]),
+			),
+		)),
+	)
+}
+
+func ExampleReaderIOEither() {
+
+	// writeToStdOut implements a writer to stdout
+	writeToStdOut := func(data []byte) IOE.IOEither[error, []byte] {
+		return IOE.TryCatchError(func() ([]byte, error) {
+			_, err := os.Stdout.Write(data)
+			return data, err
+		})
+	}
+
+	deps := Dependencies{
+		Writer: writeToStdOut,
+	}
+
+	data := map[string]string{
+		"a": "b",
+		"c": "d",
+	}
+
+	// writeData will persist to a configurable target
+	writeData := F.Pipe1(
+		SerializeToWriter(data),
+		RIOE.Map[*Dependencies, error](B.ToString),
+	)
+
+	_ = writeData(&deps)()
+
+	// Output:
+	// {"a":"b","c":"d"}
+}

string/string.go

@@ -35,6 +35,12 @@ var (
 
 	// Join joins strings
 	Join = F.Curry2(F.Bind2nd[[]string, string, string])(strings.Join)
+
+	// Equals returns a predicate that tests if a string is equal
+	Equals = F.Curry2(Eq)
+
+	// Includes returns a predicate that tests for the existence of the search string
+	Includes = F.Curry2(F.Swap(strings.Contains))
 )
 
 func Eq(left string, right string) bool {
@@ -61,16 +67,6 @@ func Size(s string) int {
 	return len(s)
 }
 
-// Includes returns a predicate that tests for the existence of the search string
-func Includes(searchString string) func(string) bool {
-	return F.Bind2nd(strings.Contains, searchString)
-}
-
-// Equals returns a predicate that tests if a string is equal
-func Equals(other string) func(string) bool {
-	return F.Bind2nd(Eq, other)
-}
-
 // Format applies a format string to an arbitrary value
 func Format[T any](format string) func(t T) string {
 	return func(t T) string {

string/string_test.go

@@ -36,3 +36,15 @@ func TestJoin(t *testing.T) {
 	assert.Equal(t, "a", Join(",")(A.From("a")))
 	assert.Equal(t, "", Join(",")(A.Empty[string]()))
 }
+
+func TestEquals(t *testing.T) {
+	assert.True(t, Equals("a")("a"))
+	assert.False(t, Equals("a")("b"))
+	assert.False(t, Equals("b")("a"))
+}
+
+func TestIncludes(t *testing.T) {
+	assert.True(t, Includes("a")("bab"))
+	assert.False(t, Includes("bab")("a"))
+	assert.False(t, Includes("b")("a"))
+}

writer/bind.go

@@ -17,7 +17,6 @@ package writer
 
 import (
 	M "github.com/IBM/fp-go/monoid"
-	S "github.com/IBM/fp-go/semigroup"
 	G "github.com/IBM/fp-go/writer/generic"
 )
 
@@ -27,11 +26,11 @@ func Do[S, W any](m M.Monoid[W]) func(S) Writer[W, S] {
 }
 
 // Bind attaches the result of a computation to a context [S1] to produce a context [S2]
-func Bind[S1, S2, T, W any](s S.Semigroup[W]) func(
+func Bind[S1, S2, T, W any](
 	setter func(T) func(S1) S2,
 	f func(S1) Writer[W, T],
 ) func(Writer[W, S1]) Writer[W, S2] {
-	return G.Bind[Writer[W, S1], Writer[W, S2], Writer[W, T], W, S1, S2, T](s)
+	return G.Bind[Writer[W, S1], Writer[W, S2], Writer[W, T], W, S1, S2, T](setter, f)
 }
 
 // Let attaches the result of a computation to a context [S1] to produce a context [S2]
@@ -58,9 +57,9 @@ func BindTo[W, S1, T any](
 }
 
 // ApS attaches a value to a context [S1] to produce a context [S2] by considering the context and the value concurrently
-func ApS[S1, S2, T, W any](s S.Semigroup[W]) func(
+func ApS[S1, S2, T, W any](
 	setter func(T) func(S1) S2,
 	fa Writer[W, T],
 ) func(Writer[W, S1]) Writer[W, S2] {
-	return G.ApS[Writer[W, S1], Writer[W, S2], Writer[W, T], W, S1, S2, T](s)
+	return G.ApS[Writer[W, S1], Writer[W, S2], Writer[W, T], W, S1, S2, T](setter, fa)
 }

writer/bind_test.go

@@ -19,6 +19,7 @@ import (
 	"testing"
 
 	A "github.com/IBM/fp-go/array"
+	EQ "github.com/IBM/fp-go/eq"
 	F "github.com/IBM/fp-go/function"
 	"github.com/IBM/fp-go/internal/utils"
 	M "github.com/IBM/fp-go/monoid"
@@ -28,6 +29,8 @@ import (
 var (
 	monoid = A.Monoid[string]()
 	sg     = M.ToSemigroup(monoid)
+
+	eq = Eq(A.Eq[string](EQ.FromStrictEquals[string]()), EQ.FromStrictEquals[string]())
 )
 
 func getLastName(s utils.Initial) Writer[[]string, string] {
@@ -42,22 +45,22 @@ func TestBind(t *testing.T) {
 
 	res := F.Pipe3(
 		Do[utils.Initial](monoid)(utils.Empty),
-		Bind[utils.Initial, utils.WithLastName, string](sg)(utils.SetLastName, getLastName),
-		Bind[utils.WithLastName, utils.WithGivenName, string](sg)(utils.SetGivenName, getGivenName),
+		Bind(utils.SetLastName, getLastName),
+		Bind(utils.SetGivenName, getGivenName),
 		Map[[]string](utils.GetFullName),
 	)
 
-	assert.Equal(t, res(), Of[string](monoid)("John Doe")())
+	assert.True(t, eq.Equals(res, Of[string](monoid)("John Doe")))
 }
 
 func TestApS(t *testing.T) {
 
 	res := F.Pipe3(
 		Do[utils.Initial](monoid)(utils.Empty),
-		ApS[utils.Initial, utils.WithLastName, string](sg)(utils.SetLastName, Of[string](monoid)("Doe")),
-		ApS[utils.WithLastName, utils.WithGivenName, string](sg)(utils.SetGivenName, Of[string](monoid)("John")),
+		ApS(utils.SetLastName, Of[string](monoid)("Doe")),
+		ApS(utils.SetGivenName, Of[string](monoid)("John")),
 		Map[[]string](utils.GetFullName),
 	)
 
-	assert.Equal(t, res(), Of[string](monoid)("John Doe")())
+	assert.True(t, eq.Equals(res, Of[string](monoid)("John Doe")))
 }

writer/generic/bind.go

@@ -20,36 +20,30 @@ import (
 	C "github.com/IBM/fp-go/internal/chain"
 	F "github.com/IBM/fp-go/internal/functor"
 	M "github.com/IBM/fp-go/monoid"
-	S "github.com/IBM/fp-go/semigroup"
+	SG "github.com/IBM/fp-go/semigroup"
 	T "github.com/IBM/fp-go/tuple"
 )
 
 // Bind creates an empty context of type [S] to be used with the [Bind] operation
-func Do[GS ~func() T.Tuple2[S, W], W, S any](m M.Monoid[W]) func(S) GS {
+func Do[GS ~func() T.Tuple3[S, W, SG.Semigroup[W]], W, S any](m M.Monoid[W]) func(S) GS {
 	return Of[GS, W, S](m)
 }
 
 // Bind attaches the result of a computation to a context [S1] to produce a context [S2]
-func Bind[GS1 ~func() T.Tuple2[S1, W], GS2 ~func() T.Tuple2[S2, W], GT ~func() T.Tuple2[A, W], W, S1, S2, A any](s S.Semigroup[W]) func(
+func Bind[GS1 ~func() T.Tuple3[S1, W, SG.Semigroup[W]], GS2 ~func() T.Tuple3[S2, W, SG.Semigroup[W]], GT ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, S1, S2, A any](
 	setter func(A) func(S1) S2,
 	f func(S1) GT,
 ) func(GS1) GS2 {
-	ch := Chain[GS2, GS1, func(S1) GS2, W, S1, S2](s)
-	return func(
-		setter func(A) func(S1) S2,
-		f func(S1) GT,
-	) func(GS1) GS2 {
-		return C.Bind(
-			ch,
-			Map[GS2, GT, func(A) S2, W, A, S2],
-			setter,
-			f,
-		)
-	}
+	return C.Bind(
+		Chain[GS2, GS1, func(S1) GS2, W, S1, S2],
+		Map[GS2, GT, func(A) S2, W, A, S2],
+		setter,
+		f,
+	)
 }
 
 // Let attaches the result of a computation to a context [S1] to produce a context [S2]
-func Let[GS1 ~func() T.Tuple2[S1, W], GS2 ~func() T.Tuple2[S2, W], W, S1, S2, A any](
+func Let[GS1 ~func() T.Tuple3[S1, W, SG.Semigroup[W]], GS2 ~func() T.Tuple3[S2, W, SG.Semigroup[W]], W, S1, S2, A any](
 	key func(A) func(S1) S2,
 	f func(S1) A,
 ) func(GS1) GS2 {
@@ -61,7 +55,7 @@ func Let[GS1 ~func() T.Tuple2[S1, W], GS2 ~func() T.Tuple2[S2, W], W, S1, S2, A
 }
 
 // LetTo attaches the a value to a context [S1] to produce a context [S2]
-func LetTo[GS1 ~func() T.Tuple2[S1, W], GS2 ~func() T.Tuple2[S2, W], W, S1, S2, B any](
+func LetTo[GS1 ~func() T.Tuple3[S1, W, SG.Semigroup[W]], GS2 ~func() T.Tuple3[S2, W, SG.Semigroup[W]], W, S1, S2, B any](
 	key func(B) func(S1) S2,
 	b B,
 ) func(GS1) GS2 {
@@ -73,7 +67,7 @@ func LetTo[GS1 ~func() T.Tuple2[S1, W], GS2 ~func() T.Tuple2[S2, W], W, S1, S2,
 }
 
 // BindTo initializes a new state [S1] from a value [T]
-func BindTo[GS1 ~func() T.Tuple2[S1, W], GT ~func() T.Tuple2[A, W], W, S1, A any](
+func BindTo[GS1 ~func() T.Tuple3[S1, W, SG.Semigroup[W]], GT ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, S1, A any](
 	setter func(A) S1,
 ) func(GT) GS1 {
 	return C.BindTo(
@@ -83,20 +77,14 @@ func BindTo[GS1 ~func() T.Tuple2[S1, W], GT ~func() T.Tuple2[A, W], W, S1, A any
 }
 
 // ApS attaches a value to a context [S1] to produce a context [S2] by considering the context and the value concurrently
-func ApS[GS1 ~func() T.Tuple2[S1, W], GS2 ~func() T.Tuple2[S2, W], GT ~func() T.Tuple2[A, W], W, S1, S2, A any](s S.Semigroup[W]) func(
+func ApS[GS1 ~func() T.Tuple3[S1, W, SG.Semigroup[W]], GS2 ~func() T.Tuple3[S2, W, SG.Semigroup[W]], GT ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, S1, S2, A any](
 	setter func(A) func(S1) S2,
 	fa GT,
 ) func(GS1) GS2 {
-	ap := Ap[GS2, func() T.Tuple2[func(A) S2, W], GT, W, A, S2](s)
-	return func(
-		setter func(A) func(S1) S2,
-		fa GT,
-	) func(GS1) GS2 {
-		return apply.ApS(
-			ap,
-			Map[func() T.Tuple2[func(A) S2, W], GS1, func(S1) func(A) S2],
-			setter,
-			fa,
-		)
-	}
+	return apply.ApS(
+		Ap[GS2, func() T.Tuple3[func(A) S2, W, SG.Semigroup[W]], GT, W, A, S2],
+		Map[func() T.Tuple3[func(A) S2, W, SG.Semigroup[W]], GS1, func(S1) func(A) S2],
+		setter,
+		fa,
+	)
 }

writer/generic/eq.go

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

writer/generic/writer.go

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

writer/testing/laws.go

@@ -37,8 +37,6 @@ func AssertLaws[W, A, B, C any](t *testing.T,
 	bc func(B) C,
 ) func(a A) bool {
 
-	s := M.ToSemigroup(m)
-
 	return L.AssertLaws(t,
 		WRT.Eq(eqw, eqa),
 		WRT.Eq(eqw, eqb),
@@ -60,18 +58,18 @@ func AssertLaws[W, A, B, C any](t *testing.T,
 
 		WRT.MonadMap[func(func(B) C) func(func(A) B) func(A) C, W, func(B) C, func(func(A) B) func(A) C],
 
-		WRT.MonadChain[func(A) WRT.Writer[W, A], W, A, A](m),
-		WRT.MonadChain[func(A) WRT.Writer[W, B], W, A, B](m),
-		WRT.MonadChain[func(A) WRT.Writer[W, C], W, A, C](m),
-		WRT.MonadChain[func(B) WRT.Writer[W, C], W, B, C](m),
+		WRT.MonadChain[func(A) WRT.Writer[W, A], W, A, A],
+		WRT.MonadChain[func(A) WRT.Writer[W, B], W, A, B],
+		WRT.MonadChain[func(A) WRT.Writer[W, C], W, A, C],
+		WRT.MonadChain[func(B) WRT.Writer[W, C], W, B, C],
 
-		WRT.MonadAp[A, A](s),
-		WRT.MonadAp[B, A](s),
-		WRT.MonadAp[C, B](s),
-		WRT.MonadAp[C, A](s),
+		WRT.MonadAp[A, A, W],
+		WRT.MonadAp[B, A, W],
+		WRT.MonadAp[C, B, W],
+		WRT.MonadAp[C, A, W],
 
-		WRT.MonadAp[B, func(A) B](s),
-		WRT.MonadAp[func(A) C, func(A) B](s),
+		WRT.MonadAp[B, func(A) B, W],
+		WRT.MonadAp[func(A) C, func(A) B, W],
 
 		ab,
 		bc,

writer/writer.go

@@ -24,7 +24,12 @@ import (
 	G "github.com/IBM/fp-go/writer/generic"
 )
 
-type Writer[W, A any] IO.IO[T.Tuple2[A, W]]
+type Writer[W, A any] IO.IO[T.Tuple3[A, W, S.Semigroup[W]]]
+
+// Tell appends a value to the accumulator
+func Tell[W any](s S.Semigroup[W]) func(W) Writer[W, any] {
+	return G.Tell[Writer[W, any]](s)
+}
 
 func Of[A, W any](m M.Monoid[W]) func(A) Writer[W, A] {
 	return G.Of[Writer[W, A]](m)
@@ -48,32 +53,32 @@ func Map[W any, FCT ~func(A) B, A, B any](f FCT) func(Writer[W, A]) Writer[W, B]
 	return G.Map[Writer[W, B], Writer[W, A]](f)
 }
 
-func MonadChain[FCT ~func(A) Writer[W, B], W, A, B any](s S.Semigroup[W]) func(Writer[W, A], FCT) Writer[W, B] {
-	return G.MonadChain[Writer[W, B], Writer[W, A], FCT](s)
+func MonadChain[FCT ~func(A) Writer[W, B], W, A, B any](fa Writer[W, A], fct FCT) Writer[W, B] {
+	return G.MonadChain[Writer[W, B], Writer[W, A], FCT](fa, fct)
 }
 
-func Chain[A, B, W any](s S.Semigroup[W]) func(func(A) Writer[W, B]) func(Writer[W, A]) Writer[W, B] {
-	return G.Chain[Writer[W, B], Writer[W, A], func(A) Writer[W, B]](s)
+func Chain[A, B, W any](fa func(A) Writer[W, B]) func(Writer[W, A]) Writer[W, B] {
+	return G.Chain[Writer[W, B], Writer[W, A], func(A) Writer[W, B]](fa)
 }
 
-func MonadAp[B, A, W any](s S.Semigroup[W]) func(Writer[W, func(A) B], Writer[W, A]) Writer[W, B] {
-	return G.MonadAp[Writer[W, B], Writer[W, func(A) B], Writer[W, A]](s)
+func MonadAp[B, A, W any](fab Writer[W, func(A) B], fa Writer[W, A]) Writer[W, B] {
+	return G.MonadAp[Writer[W, B], Writer[W, func(A) B], Writer[W, A]](fab, fa)
 }
 
-func Ap[B, A, W any](s S.Semigroup[W]) func(Writer[W, A]) func(Writer[W, func(A) B]) Writer[W, B] {
-	return G.Ap[Writer[W, B], Writer[W, func(A) B], Writer[W, A]](s)
+func Ap[B, A, W any](fa Writer[W, A]) func(Writer[W, func(A) B]) Writer[W, B] {
+	return G.Ap[Writer[W, B], Writer[W, func(A) B], Writer[W, A]](fa)
 }
 
-func MonadChainFirst[FCT ~func(A) Writer[W, B], W, A, B any](s S.Semigroup[W]) func(Writer[W, A], FCT) Writer[W, A] {
-	return G.MonadChainFirst[Writer[W, B], Writer[W, A], FCT](s)
+func MonadChainFirst[FCT ~func(A) Writer[W, B], W, A, B any](fa Writer[W, A], fct FCT) Writer[W, A] {
+	return G.MonadChainFirst[Writer[W, B], Writer[W, A], FCT](fa, fct)
 }
 
-func ChainFirst[FCT ~func(A) Writer[W, B], W, A, B any](s S.Semigroup[W]) func(FCT) func(Writer[W, A]) Writer[W, A] {
-	return G.ChainFirst[Writer[W, B], Writer[W, A], FCT](s)
+func ChainFirst[FCT ~func(A) Writer[W, B], W, A, B any](fct FCT) func(Writer[W, A]) Writer[W, A] {
+	return G.ChainFirst[Writer[W, B], Writer[W, A], FCT](fct)
 }
 
-func Flatten[W, A any](s S.Semigroup[W]) func(Writer[W, Writer[W, A]]) Writer[W, A] {
-	return G.Flatten[Writer[W, Writer[W, A]], Writer[W, A]](s)
+func Flatten[W, A any](mma Writer[W, Writer[W, A]]) Writer[W, A] {
+	return G.Flatten[Writer[W, Writer[W, A]], Writer[W, A]](mma)
 }
 
 // Execute extracts the accumulator
@@ -87,21 +92,29 @@ func Evaluate[W, A any](fa Writer[W, A]) A {
 }
 
 // MonadCensor modifies the final accumulator value by applying a function
-func MonadCensor[FCT ~func(W) W, W, A any](fa Writer[W, A], f FCT) Writer[W, A] {
+func MonadCensor[A any, FCT ~func(W) W, W any](fa Writer[W, A], f FCT) Writer[W, A] {
 	return G.MonadCensor[Writer[W, A]](fa, f)
 }
 
 // Censor modifies the final accumulator value by applying a function
-func Censor[FCT ~func(W) W, W, A any](f FCT) func(Writer[W, A]) Writer[W, A] {
+func Censor[A any, FCT ~func(W) W, W any](f FCT) func(Writer[W, A]) Writer[W, A] {
 	return G.Censor[Writer[W, A]](f)
 }
 
 // MonadListens projects a value from modifications made to the accumulator during an action
-func MonadListens[FCT ~func(W) B, W, A, B any](fa Writer[W, A], f FCT) Writer[W, T.Tuple2[A, B]] {
+func MonadListens[A any, FCT ~func(W) B, W, B any](fa Writer[W, A], f FCT) Writer[W, T.Tuple2[A, B]] {
 	return G.MonadListens[Writer[W, A], Writer[W, T.Tuple2[A, B]]](fa, f)
 }
 
 // Listens projects a value from modifications made to the accumulator during an action
-func Listens[FCT ~func(W) B, W, A, B any](f FCT) func(Writer[W, A]) Writer[W, T.Tuple2[A, B]] {
+func Listens[A any, FCT ~func(W) B, W, B any](f FCT) func(Writer[W, A]) Writer[W, T.Tuple2[A, B]] {
 	return G.Listens[Writer[W, A], Writer[W, T.Tuple2[A, B]]](f)
 }
+
+func MonadFlap[W, B, A any](fab Writer[W, func(A) B], a A) Writer[W, B] {
+	return G.MonadFlap[func(A) B, Writer[W, func(A) B], Writer[W, B]](fab, a)
+}
+
+func Flap[W, B, A any](a A) func(Writer[W, func(A) B]) Writer[W, B] {
+	return G.Flap[func(A) B, Writer[W, func(A) B], Writer[W, B]](a)
+}

writer/writer_test.go

@@ -20,30 +20,28 @@ import (
 
 	A "github.com/IBM/fp-go/array"
 	F "github.com/IBM/fp-go/function"
-	M "github.com/IBM/fp-go/monoid"
+	S "github.com/IBM/fp-go/semigroup"
 	T "github.com/IBM/fp-go/tuple"
 )
 
 func doubleAndLog(data int) Writer[[]string, int] {
-	return func() T.Tuple2[int, []string] {
+	return func() T.Tuple3[int, []string, S.Semigroup[[]string]] {
 		result := data * 2
-		return T.MakeTuple2(result, A.Of(fmt.Sprintf("Doubled %d -> %d", data, result)))
+		return T.MakeTuple3(result, A.Of(fmt.Sprintf("Doubled %d -> %d", data, result)), sg)
 	}
 }
 
 func ExampleWriter_logging() {
 
-	m := A.Monoid[string]()
-	s := M.ToSemigroup(m)
-
-	res := F.Pipe3(
+	res := F.Pipe4(
 		10,
-		Of[int](m),
-		Chain[int, int](s)(doubleAndLog),
-		Chain[int, int](s)(doubleAndLog),
+		Of[int](monoid),
+		Chain(doubleAndLog),
+		Chain(doubleAndLog),
+		Execute[[]string, int],
 	)
 
-	fmt.Println(res())
+	fmt.Println(res)
 
-	// Output: Tuple2[int, []string](40, [Doubled 10 -> 20 Doubled 20 -> 40])
+	// Output: [Doubled 10 -> 20 Doubled 20 -> 40]
 }