fix: add writer

Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>
2025-08-10 22:31:32 +02:00 · 2023-07-23 21:45:32 +02:00
parent 205b728bda
commit 9e14cd1c00
21 changed files with 8249 additions and 7731 deletions
--- a/writer/eq.go
+++ b/writer/eq.go
@@ -0,0 +1,16 @@
+package writer
+
+import (
+	EQ "github.com/IBM/fp-go/eq"
+	G "github.com/IBM/fp-go/writer/generic"
+)
+
+// Constructs an equal predicate for a [Writer]
+func Eq[W, A any](w EQ.Eq[W], a EQ.Eq[A]) EQ.Eq[Writer[W, A]] {
+	return G.Eq[Writer[W, A]](w, a)
+}
+
+// FromStrictEquals constructs an `Eq` from the canonical comparison function
+func FromStrictEquals[W, A comparable]() EQ.Eq[Writer[W, A]] {
+	return G.FromStrictEquals[Writer[W, A]]()
+}
--- a/writer/generic/eq.go
+++ b/writer/generic/eq.go
@@ -0,0 +1,21 @@
+package generic
+
+import (
+	EQ "github.com/IBM/fp-go/eq"
+	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] {
+	return EQ.FromEquals(func(l, r GA) bool {
+		ll := l()
+		rr := r()
+
+		return a.Equals(ll.F1, rr.F1) && w.Equals(ll.F2, rr.F2)
+	})
+}
+
+// FromStrictEquals constructs an `Eq` from the canonical comparison function
+func FromStrictEquals[GA ~func() T.Tuple2[A, W], W, A comparable]() EQ.Eq[GA] {
+	return Eq[GA](EQ.FromStrictEquals[W](), EQ.FromStrictEquals[A]())
+}
--- a/writer/generic/writer.go
+++ b/writer/generic/writer.go
@@ -0,0 +1,106 @@
+package generic
+
+import (
+	F "github.com/IBM/fp-go/function"
+	IO "github.com/IBM/fp-go/io/generic"
+	M "github.com/IBM/fp-go/monoid"
+	S "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 {
+	return F.Flow2(
+		F.Bind2nd(T.MakeTuple2[A, W], m.Empty()),
+		IO.Of[GA],
+	)
+}
+
+func MonadMap[GB ~func() T.Tuple2[B, W], GA ~func() T.Tuple2[A, W], FCT ~func(A) B, W, A, B any](fa GA, f FCT) GB {
+	return IO.MonadMap[GA, GB](fa, T.Map2(f, F.Identity[W]))
+}
+
+func Map[GB ~func() T.Tuple2[B, W], GA ~func() T.Tuple2[A, W], FCT ~func(A) B, W, A, B any](f FCT) func(GA) GB {
+	return IO.Map[GA, GB](T.Map2(f, F.Identity[W]))
+}
+
+func MonadChain[GB ~func() T.Tuple2[B, W], GA ~func() T.Tuple2[A, W], FCT ~func(A) GB, W, A, B any](s S.Semigroup[W]) func(GA, FCT) GB {
+	return func(fa GA, f FCT) GB {
+
+		return func() T.Tuple2[B, W] {
+			a := fa()
+			b := f(a.F1)()
+
+			return T.MakeTuple2(b.F1, s.Concat(a.F2, b.F2))
+		}
+	}
+}
+
+func Chain[GB ~func() T.Tuple2[B, W], GA ~func() T.Tuple2[A, W], FCT ~func(A) GB, W, A, B any](s S.Semigroup[W]) func(FCT) func(GA) GB {
+	return F.Curry2(F.Swap(MonadChain[GB, GA, FCT](s)))
+}
+
+func MonadAp[GB ~func() T.Tuple2[B, W], GAB ~func() T.Tuple2[func(A) B, W], GA ~func() T.Tuple2[A, W], W, A, B any](s S.Semigroup[W]) func(GAB, GA) GB {
+	return func(fab GAB, fa GA) GB {
+		return func() T.Tuple2[B, W] {
+			f := fab()
+			a := fa()
+
+			return T.MakeTuple2(f.F1(a.F1), s.Concat(f.F2, a.F2))
+		}
+	}
+}
+
+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.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.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.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.Tuple2[A, W], W, A any](fa GA) W {
+	return T.Second(fa())
+}
+
+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.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.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.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.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.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)
+}
--- a/writer/testing/laws.go
+++ b/writer/testing/laws.go
@@ -0,0 +1,65 @@
+package testing
+
+import (
+	"testing"
+
+	EQ "github.com/IBM/fp-go/eq"
+	L "github.com/IBM/fp-go/internal/monad/testing"
+	M "github.com/IBM/fp-go/monoid"
+	WRT "github.com/IBM/fp-go/writer"
+)
+
+// AssertLaws asserts the apply monad laws for the `Either` monad
+func AssertLaws[W, A, B, C any](t *testing.T,
+	m M.Monoid[W],
+
+	eqw EQ.Eq[W],
+	eqa EQ.Eq[A],
+	eqb EQ.Eq[B],
+	eqc EQ.Eq[C],
+
+	ab func(A) B,
+	bc func(B) C,
+) func(a A) bool {
+
+	s := M.ToSemigroup(m)
+
+	return L.AssertLaws(t,
+		WRT.Eq(eqw, eqa),
+		WRT.Eq(eqw, eqb),
+		WRT.Eq(eqw, eqc),
+
+		WRT.Of[A](m),
+		WRT.Of[B](m),
+		WRT.Of[C](m),
+
+		WRT.Of[func(A) A](m),
+		WRT.Of[func(A) B](m),
+		WRT.Of[func(B) C](m),
+		WRT.Of[func(func(A) B) B](m),
+
+		WRT.MonadMap[func(A) A, W, A, A],
+		WRT.MonadMap[func(A) B, W, A, B],
+		WRT.MonadMap[func(A) C, W, A, C],
+		WRT.MonadMap[func(B) C, W, B, C],
+
+		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.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](s),
+		WRT.MonadAp[func(A) C, func(A) B](s),
+
+		ab,
+		bc,
+	)
+
+}
--- a/writer/testing/laws_test.go
+++ b/writer/testing/laws_test.go
@@ -0,0 +1,35 @@
+package testing
+
+import (
+	"fmt"
+	"testing"
+
+	A "github.com/IBM/fp-go/array"
+	EQ "github.com/IBM/fp-go/eq"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMonadLaws(t *testing.T) {
+	// some comparison
+	m := A.Monoid[string]()
+	eqw := A.Eq[string](EQ.FromStrictEquals[string]())
+	eqa := EQ.FromStrictEquals[bool]()
+	eqb := EQ.FromStrictEquals[int]()
+	eqc := EQ.FromStrictEquals[string]()
+
+	ab := func(a bool) int {
+		if a {
+			return 1
+		}
+		return 0
+	}
+
+	bc := func(b int) string {
+		return fmt.Sprintf("value %d", b)
+	}
+
+	laws := AssertLaws(t, m, eqw, eqa, eqb, eqc, ab, bc)
+
+	assert.True(t, laws(true))
+	assert.True(t, laws(false))
+}
--- a/writer/writer.go
+++ b/writer/writer.go
@@ -0,0 +1,78 @@
+package writer
+
+import (
+	M "github.com/IBM/fp-go/monoid"
+	S "github.com/IBM/fp-go/semigroup"
+	T "github.com/IBM/fp-go/tuple"
+	G "github.com/IBM/fp-go/writer/generic"
+)
+
+type Writer[W, A any] func() 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)
+}
+
+func MonadMap[FCT ~func(A) B, W, A, B any](fa Writer[W, A], f FCT) Writer[W, B] {
+	return G.MonadMap[Writer[W, B], Writer[W, A]](fa, f)
+}
+
+func Map[FCT ~func(A) B, W, 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 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](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](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](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](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](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 Execute[W, A any](fa Writer[W, A]) W {
+	return G.Execute(fa)
+}
+
+func Evaluate[W, A any](fa Writer[W, A]) A {
+	return G.Evaluate(fa)
+}
+
+// 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] {
+	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] {
+	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]] {
+	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]] {
+	return G.Listens[Writer[W, A], Writer[W, T.Tuple2[A, B]]](f)
+}
--- a/writer/writer_test.go
+++ b/writer/writer_test.go
@@ -0,0 +1,35 @@
+package writer
+
+import (
+	"fmt"
+
+	A "github.com/IBM/fp-go/array"
+	F "github.com/IBM/fp-go/function"
+	M "github.com/IBM/fp-go/monoid"
+	T "github.com/IBM/fp-go/tuple"
+)
+
+func doubleAndLog(data int) Writer[[]string, int] {
+	return func() T.Tuple2[int, []string] {
+		result := data * 2
+		return T.MakeTuple2(result, A.Of(fmt.Sprintf("Doubled %d -> %d", data, result)))
+	}
+}
+
+func ExampleLoggingWriter() {
+
+	m := A.Monoid[string]()
+	s := M.ToSemigroup(m)
+
+	res := F.Pipe3(
+		10,
+		Of[int](m),
+		Chain[int, int](s)(doubleAndLog),
+		Chain[int, int](s)(doubleAndLog),
+	)
+
+	fmt.Println(res())
+
+	// Output: test
+
+}