fix: add Do and Bind support to Monads

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 FC.Flap(Map[GFAB, GB], a)
+	return F.Bind2nd(MonadFlap[FAB, GFAB, GB, A, B], a)
 }
 
 func Prepend[ENDO ~func(AS) AS, AS []A, A any](head A) ENDO {

cli/pipe.go

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

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

function/binds.go

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

function/gen.go

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

identity/generic/identity.go

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

internal/apply/ap.go

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

internal/chain/chain.go

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

internal/eithert/either.go

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

internal/fromeither/either.go

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

internal/fromio/io.go

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

internal/fromioeither/ioeither.go

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

internal/functor/flap.go

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

internal/functor/functor.go

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

internal/optiont/option.go

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

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

ioeither/generic/ioeither.go

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

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

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 FC.Flap(Map[func(A) B, B], a)
+	return F.Bind2nd(MonadFlap[B, A], 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(Map[GAB, GB], a)
+	return FC.Flap(MonadMap[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.Map[GA, GB, E, ET.Either[E1, A], ET.Either[E2, B]], f, g)
+	return eithert.BiMap(R.MonadMap[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(Map[GEFAB, GEB], a)
+	return FC.Flap(MonadMap[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(
-		Chain[GEA, GEA],
-		Map[GEB, GEA],
+		MonadChain[GEA, GEA],
+		MonadMap[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(Map[GEFAB, GEB], a)
+	return FC.Flap(MonadMap[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.Map[GA, GB, GE1A, GE2B, R, ET.Either[E1, A], ET.Either[E2, B]], f, g)
+	return eithert.BiMap(G.MonadMap[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(Map[GREAB, GREB], a)
+	return FC.Flap(MonadMap[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(Map[GFAB, GB], a)
+	return FC.Flap(MonadMap[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

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

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

samples/readerioeither/example1/reader_test.go

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

writer/bind.go

@@ -17,6 +17,7 @@ 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"
 )
 
@@ -26,11 +27,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](
+func Bind[S1, S2, T, W any](s S.Semigroup[W]) func(
 	setter func(T) func(S1) S2,
 	f func(S1) Writer[W, T],
 ) func(Writer[W, S1]) Writer[W, S2] {
-	return G.Bind[Writer[W, S1], Writer[W, S2], Writer[W, T], W, S1, S2, T](setter, f)
+	return G.Bind[Writer[W, S1], Writer[W, S2], Writer[W, T], W, S1, S2, T](s)
 }
 
 // Let attaches the result of a computation to a context [S1] to produce a context [S2]
@@ -57,9 +58,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](
+func ApS[S1, S2, T, W any](s S.Semigroup[W]) func(
 	setter func(T) func(S1) S2,
 	fa Writer[W, T],
 ) func(Writer[W, S1]) Writer[W, S2] {
-	return G.ApS[Writer[W, S1], Writer[W, S2], Writer[W, T], W, S1, S2, T](setter, fa)
+	return G.ApS[Writer[W, S1], Writer[W, S2], Writer[W, T], W, S1, S2, T](s)
 }

writer/bind_test.go

@@ -19,7 +19,6 @@ 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"
@@ -29,8 +28,6 @@ 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] {
@@ -45,22 +42,22 @@ func TestBind(t *testing.T) {
 
 	res := F.Pipe3(
 		Do[utils.Initial](monoid)(utils.Empty),
-		Bind(utils.SetLastName, getLastName),
-		Bind(utils.SetGivenName, getGivenName),
+		Bind[utils.Initial, utils.WithLastName, string](sg)(utils.SetLastName, getLastName),
+		Bind[utils.WithLastName, utils.WithGivenName, string](sg)(utils.SetGivenName, getGivenName),
 		Map[[]string](utils.GetFullName),
 	)
 
-	assert.True(t, eq.Equals(res, Of[string](monoid)("John Doe")))
+	assert.Equal(t, res(), Of[string](monoid)("John Doe")())
 }
 
 func TestApS(t *testing.T) {
 
 	res := F.Pipe3(
 		Do[utils.Initial](monoid)(utils.Empty),
-		ApS(utils.SetLastName, Of[string](monoid)("Doe")),
-		ApS(utils.SetGivenName, Of[string](monoid)("John")),
+		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")),
 		Map[[]string](utils.GetFullName),
 	)
 
-	assert.True(t, eq.Equals(res, Of[string](monoid)("John Doe")))
+	assert.Equal(t, res(), Of[string](monoid)("John Doe")())
 }

writer/generic/bind.go

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

writer/generic/eq.go

@@ -17,12 +17,11 @@ 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.Tuple3[A, W, SG.Semigroup[W]], W, A any](w EQ.Eq[W], a EQ.Eq[A]) EQ.Eq[GA] {
+func Eq[GA ~func() T.Tuple2[A, 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()
@@ -32,6 +31,6 @@ func Eq[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A any](w EQ.Eq[W], a EQ.E
 }
 
 // FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
-func FromStrictEquals[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A comparable]() EQ.Eq[GA] {
+func FromStrictEquals[GA ~func() T.Tuple2[A, W], W, A comparable]() EQ.Eq[GA] {
 	return Eq[GA](EQ.FromStrictEquals[W](), EQ.FromStrictEquals[A]())
 }

writer/generic/writer.go

@@ -17,137 +17,121 @@ 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"
-	SG "github.com/IBM/fp-go/semigroup"
+	S "github.com/IBM/fp-go/semigroup"
 	T "github.com/IBM/fp-go/tuple"
 )
 
-func Tell[GA ~func() T.Tuple3[any, W, SG.Semigroup[W]], W any](s SG.Semigroup[W]) func(W) GA {
+func Of[GA ~func() T.Tuple2[A, W], W, A any](m M.Monoid[W]) func(A) GA {
 	return F.Flow2(
-		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)),
+		F.Bind2nd(T.MakeTuple2[A, W], m.Empty()),
 		IO.Of[GA],
 	)
 }
 
 // Listen modifies the result to include the changes to the accumulator
-func Listen[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], GTA ~func() T.Tuple3[T.Tuple2[A, W], W, SG.Semigroup[W]], W, A any](fa GA) GTA {
-	return func() T.Tuple3[T.Tuple2[A, W], W, SG.Semigroup[W]] {
+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] {
 		t := fa()
-		return T.MakeTuple3(T.MakeTuple2(t.F1, t.F2), t.F2, t.F3)
+		return T.MakeTuple2(T.MakeTuple2(t.F1, t.F2), t.F2)
 	}
 }
 
 // Pass applies the returned function to the accumulator
-func Pass[GFA ~func() T.Tuple3[T.Tuple2[A, FCT], W, SG.Semigroup[W]], GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], FCT ~func(W) W, W, A any](fa GFA) GA {
-	return func() T.Tuple3[A, W, SG.Semigroup[W]] {
+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] {
 		t := fa()
-		return T.MakeTuple3(t.F1.F1, t.F1.F2(t.F2), t.F3)
+		return T.MakeTuple2(t.F1.F1, t.F1.F2(t.F2))
 	}
 }
 
-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 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 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 Map[GB ~func() T.Tuple2[B, W], GA ~func() T.Tuple2[A, W], FCT ~func(A) B, W, A, B any](f FCT) func(GA) GB {
+	return IO.Map[GA, GB](T.Map2(f, F.Identity[W]))
 }
 
-func MonadChain[GB ~func() T.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)()
+func MonadChain[GB ~func() T.Tuple2[B, W], GA ~func() T.Tuple2[A, W], FCT ~func(A) GB, W, A, B any](s S.Semigroup[W]) func(GA, FCT) GB {
+	return func(fa GA, f FCT) GB {
 
-		return T.MakeTuple3(b.F1, b.F3.Concat(a.F2, b.F2), b.F3)
+		return func() T.Tuple2[B, W] {
+			a := fa()
+			b := f(a.F1)()
+
+			return T.MakeTuple2(b.F1, s.Concat(a.F2, b.F2))
+		}
 	}
 }
 
-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 Chain[GB ~func() T.Tuple2[B, W], GA ~func() T.Tuple2[A, W], FCT ~func(A) GB, W, A, B any](s S.Semigroup[W]) func(FCT) func(GA) GB {
+	return F.Curry2(F.Swap(MonadChain[GB, GA, FCT](s)))
 }
 
-func MonadAp[GB ~func() T.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()
+func MonadAp[GB ~func() T.Tuple2[B, W], GAB ~func() T.Tuple2[func(A) B, W], GA ~func() T.Tuple2[A, W], W, A, B any](s S.Semigroup[W]) func(GAB, GA) GB {
+	return func(fab GAB, fa GA) GB {
+		return func() T.Tuple2[B, W] {
+			f := fab()
+			a := fa()
 
-		return T.MakeTuple3(f.F1(a.F1), f.F3.Concat(f.F2, a.F2), f.F3)
+			return T.MakeTuple2(f.F1(a.F1), s.Concat(f.F2, a.F2))
+		}
 	}
 }
 
-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 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 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 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 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 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 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 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 Execute[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A any](fa GA) W {
-	return fa().F2
+func Execute[GA ~func() T.Tuple2[A, W], W, A any](fa GA) W {
+	return T.Second(fa())
 }
 
-func Evaluate[GA ~func() T.Tuple3[A, W, SG.Semigroup[W]], W, A any](fa GA) A {
-	return fa().F1
+func Evaluate[GA ~func() T.Tuple2[A, W], W, A any](fa GA) A {
+	return T.First(fa())
 }
 
 // MonadCensor modifies the final accumulator value by applying a function
-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]]))
+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))
 }
 
 // Censor modifies the final accumulator value by applying a function
-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]]))
+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))
 }
 
 // MonadListens projects a value from modifications made to the accumulator during an action
-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]] {
+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] {
 		a := fa()
-		return T.MakeTuple3(T.MakeTuple2(a.F1, f(a.F2)), a.F2, a.F3)
+		return T.MakeTuple2(T.MakeTuple2(a.F1, f(a.F2)), a.F2)
 	}
 }
 
 // Listens projects a value from modifications made to the accumulator during an action
-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 {
+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 {
 	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,6 +37,8 @@ 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),
@@ -58,18 +60,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],
-		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.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.MonadAp[A, A, W],
-		WRT.MonadAp[B, A, W],
-		WRT.MonadAp[C, B, W],
-		WRT.MonadAp[C, A, W],
+		WRT.MonadAp[A, A](s),
+		WRT.MonadAp[B, A](s),
+		WRT.MonadAp[C, B](s),
+		WRT.MonadAp[C, A](s),
 
-		WRT.MonadAp[B, func(A) B, W],
-		WRT.MonadAp[func(A) C, func(A) B, W],
+		WRT.MonadAp[B, func(A) B](s),
+		WRT.MonadAp[func(A) C, func(A) B](s),
 
 		ab,
 		bc,

writer/writer.go

@@ -24,12 +24,7 @@ import (
 	G "github.com/IBM/fp-go/writer/generic"
 )
 
-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)
-}
+type Writer[W, A any] IO.IO[T.Tuple2[A, W]]
 
 func Of[A, W any](m M.Monoid[W]) func(A) Writer[W, A] {
 	return G.Of[Writer[W, A]](m)
@@ -53,32 +48,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](fa Writer[W, A], fct FCT) Writer[W, B] {
-	return G.MonadChain[Writer[W, B], Writer[W, A], FCT](fa, fct)
+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 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 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 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 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 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 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 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 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 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 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 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)
+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)
 }
 
 // Execute extracts the accumulator
@@ -92,29 +87,21 @@ func Evaluate[W, A any](fa Writer[W, A]) A {
 }
 
 // MonadCensor modifies the final accumulator value by applying a function
-func MonadCensor[A any, FCT ~func(W) W, W any](fa Writer[W, A], f FCT) Writer[W, A] {
+func MonadCensor[FCT ~func(W) W, W, A 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[A any, FCT ~func(W) W, W any](f FCT) func(Writer[W, A]) Writer[W, A] {
+func Censor[FCT ~func(W) W, W, A 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[A any, FCT ~func(W) B, W, B any](fa Writer[W, A], f FCT) Writer[W, T.Tuple2[A, B]] {
+func MonadListens[FCT ~func(W) B, W, A, 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[A any, FCT ~func(W) B, W, B any](f FCT) func(Writer[W, A]) Writer[W, T.Tuple2[A, B]] {
+func Listens[FCT ~func(W) B, W, A, 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,28 +20,30 @@ import (
 
 	A "github.com/IBM/fp-go/array"
 	F "github.com/IBM/fp-go/function"
-	S "github.com/IBM/fp-go/semigroup"
+	M "github.com/IBM/fp-go/monoid"
 	T "github.com/IBM/fp-go/tuple"
 )
 
 func doubleAndLog(data int) Writer[[]string, int] {
-	return func() T.Tuple3[int, []string, S.Semigroup[[]string]] {
+	return func() T.Tuple2[int, []string] {
 		result := data * 2
-		return T.MakeTuple3(result, A.Of(fmt.Sprintf("Doubled %d -> %d", data, result)), sg)
+		return T.MakeTuple2(result, A.Of(fmt.Sprintf("Doubled %d -> %d", data, result)))
 	}
 }
 
 func ExampleWriter_logging() {
 
-	res := F.Pipe4(
+	m := A.Monoid[string]()
+	s := M.ToSemigroup(m)
+
+	res := F.Pipe3(
 		10,
-		Of[int](monoid),
-		Chain(doubleAndLog),
-		Chain(doubleAndLog),
-		Execute[[]string, int],
+		Of[int](m),
+		Chain[int, int](s)(doubleAndLog),
+		Chain[int, int](s)(doubleAndLog),
 	)
 
-	fmt.Println(res)
+	fmt.Println(res())
 
-	// Output: [Doubled 10 -> 20 Doubled 20 -> 40]
+	// Output: Tuple2[int, []string](40, [Doubled 10 -> 20 Doubled 20 -> 40])
 }