go/fp-go
1
0
Fork 0
mirror of https://github.com/IBM/fp-go.git synced 2025-08-10 22:31:32 +02:00
Code Issues Releases Activity

fix: refactor Writer monad

Browse Source 
Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>
This commit is contained in:
Dr. Carsten Leue
2024-02-13 10:44:57 +01:00
parent d0e4984b60
commit 01786a054b
10 changed files with 302 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
writer/generic/writer.go
View File

@@ -21,133 +21,133 @@ import (
FC "github.com/IBM/fp-go/internal/functor"
IO "github.com/IBM/fp-go/io/generic"
M "github.com/IBM/fp-go/monoid"
P "github.com/IBM/fp-go/pair"
SG "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 {
return F.Flow2(
F.Bind13of3(T.MakeTuple3[any, W, SG.Semigroup[W]])(nil, s),
IO.Of[GA],
)
func Tell[GA ~func() P.Pair[any, W], W any](w W) GA {
return IO.Of[GA](P.MakePair[any](w, w))
}
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],
)
func Of[GA ~func() P.Pair[A, W], W, A any](m M.Monoid[W], a A) GA {
return IO.Of[GA](P.MakePair(a, m.Empty()))
}
// 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() P.Pair[A, W], GTA ~func() P.Pair[P.Pair[A, W], W], W, A any](fa GA) GTA {
return func() P.Pair[P.Pair[A, W], W] {
t := fa()
return T.MakeTuple3(T.MakeTuple2(t.F1, t.F2), t.F2, t.F3)
return P.MakePair(t, P.Tail(t))
}
}
// 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() P.Pair[P.Pair[A, FCT], W], GA ~func() P.Pair[A, W], FCT ~func(W) W, W, A any](fa GFA) GA {
return func() P.Pair[A, W] {
t := fa()
return T.MakeTuple3(t.F1.F1, t.F1.F2(t.F2), t.F3)
a := P.Head(t)
return P.MakePair(P.Head(a), P.Tail(a)(P.Tail(t)))
}
}
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() P.Pair[B, W], GA ~func() P.Pair[A, W], FCT ~func(A) B, W, A, B any](fa GA, f FCT) GB {
return IO.MonadMap[GA, GB](fa, P.Map[W](f))
}
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() P.Pair[B, W], GA ~func() P.Pair[A, W], FCT ~func(A) B, W, A, B any](f FCT) func(GA) GB {
return IO.Map[GA, GB](P.Map[W](f))
}
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]] {
func MonadChain[GB ~func() P.Pair[B, W], GA ~func() P.Pair[A, W], FCT ~func(A) GB, W, A, B any](s SG.Semigroup[W], fa GA, f FCT) GB {
return func() P.Pair[B, W] {
a := fa()
b := f(a.F1)()
b := f(P.Head(a))()
return T.MakeTuple3(b.F1, b.F3.Concat(a.F2, b.F2), b.F3)
return P.MakePair(P.Head(b), s.Concat(P.Tail(a), P.Tail(b)))
}
}
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() P.Pair[B, W], GA ~func() P.Pair[A, W], FCT ~func(A) GB, W, A, B any](s SG.Semigroup[W], f FCT) func(GA) GB {
return func(fa GA) GB {
return MonadChain(s, fa, f)
}
}
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]] {
func MonadAp[GB ~func() P.Pair[B, W], GAB ~func() P.Pair[func(A) B, W], GA ~func() P.Pair[A, W], W, A, B any](s SG.Semigroup[W], fab GAB, fa GA) GB {
return func() P.Pair[B, W] {
f := fab()
a := fa()
return T.MakeTuple3(f.F1(a.F1), f.F3.Concat(f.F2, a.F2), f.F3)
return P.MakePair(P.Head(f)(P.Head(a)), s.Concat(P.Tail(f), P.Tail(a)))
}
}
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() P.Pair[B, W], GAB ~func() P.Pair[func(A) B, W], GA ~func() P.Pair[A, W], W, A, B any](s SG.Semigroup[W], ga GA) func(GAB) GB {
return func(fab GAB) GB {
return MonadAp[GB](s, fab, ga)
}
}
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 {
func MonadChainFirst[GB ~func() P.Pair[B, W], GA ~func() P.Pair[A, W], FCT ~func(A) GB, W, A, B any](s SG.Semigroup[W], ma GA, f FCT) GA {
return C.MonadChainFirst(
MonadChain[GA, GA, func(A) GA],
F.Bind1of3(MonadChain[GA, GA, func(A) GA])(s),
MonadMap[GA, GB, func(B) A],
ma,
f,
)
}
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 {
func ChainFirst[GB ~func() P.Pair[B, W], GA ~func() P.Pair[A, W], FCT ~func(A) GB, W, A, B any](s SG.Semigroup[W], f FCT) func(GA) GA {
return C.ChainFirst(
Chain[GA, GA, func(A) GA],
F.Bind1st(Chain[GA, GA, func(A) GA], s),
Map[GA, GB, func(B) A],
f,
)
}
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() P.Pair[GA, W], GA ~func() P.Pair[A, W], W, A any](s SG.Semigroup[W], mma GAA) GA {
return MonadChain[GA, GAA, func(GA) GA](s, 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() P.Pair[A, W], W, A any](fa GA) W {
return P.Tail(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() P.Pair[A, W], W, A any](fa GA) A {
return P.Head(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() P.Pair[A, W], FCT ~func(W) W, W, A any](fa GA, f FCT) GA {
return IO.MonadMap[GA, GA](fa, P.MapTail[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() P.Pair[A, W], FCT ~func(W) W, W, A any](f FCT) func(GA) GA {
return IO.Map[GA, GA](P.MapTail[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() P.Pair[A, W], GAB ~func() P.Pair[P.Pair[A, B], W], FCT ~func(W) B, W, A, B any](fa GA, f FCT) GAB {
return func() P.Pair[P.Pair[A, B], W] {
a := fa()
return T.MakeTuple3(T.MakeTuple2(a.F1, f(a.F2)), a.F2, a.F3)
t := P.Tail(a)
return P.MakePair(P.MakePair(P.Head(a), f(t)), t)
}
}
// 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() P.Pair[A, W], GAB ~func() P.Pair[P.Pair[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 {
func MonadFlap[FAB ~func(A) B, GFAB ~func() P.Pair[FAB, W], GB ~func() P.Pair[B, 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 {
func Flap[FAB ~func(A) B, GFAB ~func() P.Pair[FAB, W], GB ~func() P.Pair[B, W], W, A, B any](a A) func(GFAB) GB {
return FC.Flap(Map[GB, GFAB, func(FAB) B], a)
}