Skip to content

Commit 55081c5

Browse files
JorgeCastilloPrzJorgeCastilloPrz
committed
move WriterT methods to extension functions
1 parent 4780e0b commit 55081c5

File tree

2 files changed

+40
-31
lines changed

2 files changed

+40
-31
lines changed

‎kategory/src/main/kotlin/kategory/data/WriterT.kt

+28-21
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@ package kategory
22

33
@Suppress("UNCHECKED_CAST") inline fun <F, W, A> WriterTKind<F, W, A>.value(): HK<F, Tuple2<W, A>> = this.ev().value
44

5-
@higherkind data class WriterT<F, W, A>(val MF: Monad<F>, val value: HK<F, Tuple2<W, A>>) : WriterTKind<F, W, A> {
5+
@higherkind data class WriterT<F, W, A>(val value: HK<F, Tuple2<W, A>>) : WriterTKind<F, W, A> {
66

77
companion object {
88

@@ -12,17 +12,17 @@ package kategory
1212

1313
inline fun <reified F, W, A> fromTuple(z: Tuple2<W, A>, MF: Monad<F> = kategory.monad()) = WriterT(MF.pure(z), MF)
1414

15-
inline operator fun <reified F, W, A> invoke(value: HK<F, Tuple2<W, A>>, MF: Monad<F> = kategory.monad()) = WriterT(MF, value)
15+
inline operator fun <reified F, W, A> invoke(value: HK<F, Tuple2<W, A>>, MF: Monad<F> = kategory.monad()) = WriterT(value)
1616

1717
inline fun <reified F, reified W> functor(FF: Functor<F> = kategory.functor<F>()): WriterTFunctor<F, W> =
1818
object : WriterTFunctor<F, W> {
1919
override fun F0(): Functor<F> = FF
2020
}
2121

22-
inline fun <reified F, reified W> applicative(MF: Monad<F> = kategory.monad<F>(),
22+
inline fun <reified F, reified W> applicative(AP: Applicative<F> = kategory.applicative<F>(),
2323
MW: Monoid<W> = kategory.monoid<W>()): WriterTApplicative<F, W> =
2424
object : WriterTApplicative<F, W> {
25-
override fun F0(): Monad<F> = MF
25+
override fun F0(): Applicative<F> = AP
2626
override fun L0(): Monoid<W> = MW
2727
}
2828

@@ -59,13 +59,13 @@ package kategory
5959
}
6060

6161
inline fun <reified F, W, A> putT(vf: HK<F, A>, w: W, MF: Monad<F> = kategory.monad()): WriterT<F, W, A> =
62-
WriterT(MF, MF.map(vf, { v -> Tuple2(w, v) }))
62+
WriterT(MF.map(vf, { v -> Tuple2(w, v) }))
6363

6464
inline fun <reified F, W, A> put(a: A, w: W, applicativeF: Applicative<F> = kategory.applicative()): WriterT<F, W, A> =
6565
WriterT.putT(applicativeF.pure(a), w)
6666

6767
fun <F, W, A> putT2(vf: HK<F, A>, w: W, MF: Monad<F>): WriterT<F, W, A> =
68-
WriterT(MF, MF.map(vf, { v -> Tuple2(w, v) }))
68+
WriterT(MF.map(vf, { v -> Tuple2(w, v) }))
6969

7070
fun <F, W, A> put2(a: A, w: W, MF: Monad<F>): WriterT<F, W, A> =
7171
WriterT.putT2(MF.pure(a), w, MF)
@@ -80,31 +80,38 @@ package kategory
8080
inline fun <reified F, reified W, A> valueT(vf: HK<F, A>, functorF: Functor<F> = kategory.functor(), monoidW: Monoid<W> = monoid()): WriterT<F, W, A> =
8181
WriterT.putT(vf, monoidW.empty())
8282
}
83+
}
8384

84-
fun tell(w: W, SG: Semigroup<W>): WriterT<F, W, A> = mapAcc { SG.combine(it, w) }
85+
inline fun <reified F, W, A> WriterT<F, W, A>.tell(w: W, SG: Semigroup<W>, FF: Functor<F> = functor()): WriterT<F, W, A> = mapWritten { SG.combine(it, w) }
8586

86-
fun content(): HK<F, A> = MF.map(value, { it.b })
87+
inline fun <reified F, W, A> WriterT<F, W, A>.written(FF: Functor<F> = functor()): HK<F, W> = FF.map(value, { it.a })
8788

88-
fun write(): HK<F, W> = MF.map(value, { it.a })
89+
inline fun <reified F, W, A> WriterT<F, W, A>.value(FF: Functor<F> = functor()): HK<F, A> = FF.map(value, { it.b })
8990

90-
fun reset(MM: Monoid<W>): WriterT<F, W, A> = mapAcc { MM.empty() }
91+
inline fun <reified F, reified W, A> WriterT<F, W, A>.reset(MM: Monoid<W> = monoid(), FF: Functor<F>): WriterT<F, W, A> = mapWritten { MM.empty() }
9192

92-
inline fun <B> map(crossinline f: (A) -> B): WriterT<F, W, B> = WriterT(MF, MF.map(value, { it.a toT f(it.b) }))
93+
inline fun <reified F, W, A, B> WriterT<F, W, A>.map(crossinline f: (A) -> B, FF: Functor<F> = functor()): WriterT<F, W, B> =
94+
WriterT(FF.map(value, { it.a toT f(it.b) }))
9395

94-
inline fun <U> mapAcc(crossinline f: (W) -> U): WriterT<F, U, A> = transform { f(it.a) toT it.b }
96+
inline fun <reified F, W, A, U> WriterT<F, W, A>.mapWritten(FF: Functor<F> = functor(), crossinline f: (W) -> U): WriterT<F, U, A> =
97+
mapBoth { f(it.a) toT it.b }
9598

96-
inline fun <C, U> bimap(crossinline g: (W) -> U, crossinline f: (A) -> C): WriterT<F, U, C> = transform { g(it.a) toT f(it.b) }
99+
inline fun <reified F, W, A, C, U> WriterT<F, W, A>.bimap(FF: Functor<F> = functor(), crossinline g: (W) -> U, crossinline f: (A) -> C): WriterT<F, U, C> =
100+
mapBoth { g(it.a) toT f(it.b) }
97101

98-
fun swap(): WriterT<F, A, W> = transform { it.b toT it.a }
102+
inline fun <reified F, W, A> WriterT<F, W, A>.swap(FF: Functor<F> = functor()): WriterT<F, A, W> = mapBoth { it.b toT it.a }
99103

100-
inline fun <B> flatMap(crossinline f: (A) -> WriterT<F, W, B>, SG: Semigroup<W>): WriterT<F, W, B> =
101-
WriterT(MF, MF.flatMap(value, { value -> MF.map(f(value.b).value, { SG.combine(it.a, value.a) toT it.b }) }))
104+
inline fun <reified F, W, A, B> WriterT<F, W, A>.flatMap(SG: Semigroup<W>, MF: Monad<F> = monad(), crossinline f: (A) -> WriterT<F, W, B>): WriterT<F, W, B> =
105+
WriterT(MF.flatMap(value, { value -> MF.map(f(value.b).value, { SG.combine(it.a, value.a) toT it.b }) }))
102106

103-
inline fun <B, U> transform(crossinline f: (Tuple2<W, A>) -> Tuple2<U, B>): WriterT<F, U, B> = WriterT(MF, MF.flatMap(value, { MF.pure(f(it)) }))
107+
inline fun <reified F, W, A, B, U> WriterT<F, W, A>.mapBoth(FF: Functor<F> = functor(), noinline f: (Tuple2<W, A>) -> Tuple2<U, B>): WriterT<F, U, B> =
108+
WriterT(FF.map(value, f))
104109

105-
fun <B> liftF(fa: HK<F, B>): WriterT<F, W, B> = WriterT(MF, MF.map2(fa, value, { it.b.a toT it.a }))
110+
inline fun <reified F, W, A, B> WriterT<F, W, A>.liftF(MF: Monad<F> = monad(), fa: HK<F, B>): WriterT<F, W, B> =
111+
WriterT(MF.map2(fa, value, { it.b.a toT it.a }))
106112

107-
inline fun <C> semiflatMap(crossinline f: (A) -> HK<F, C>, SG: Semigroup<W>): WriterT<F, W, C> = flatMap({ liftF(f(it)) }, SG)
113+
inline fun <reified F, W, A, C> WriterT<F, W, A>.semiflatMap(MF: Monad<F> = monad(), crossinline f: (A) -> HK<F, C>, SG: Semigroup<W>): WriterT<F, W, C> =
114+
flatMap(SG, MF, { liftF(MF, f(it)) })
108115

109-
inline fun <B> subflatMap(crossinline f: (A) -> Tuple2<W, B>): WriterT<F, W, B> = transform({ f(it.b) })
110-
}
116+
inline fun <reified F, W, A, B> WriterT<F, W, A>.subflatMap(FF: Functor<F> = functor(), crossinline f: (A) -> Tuple2<W, B>): WriterT<F, W, B> =
117+
mapBoth(FF, { f(it.b) })

‎kategory/src/main/kotlin/kategory/instances/WriterTInstances.kt

+12-10
Original file line numberDiff line numberDiff line change
@@ -4,10 +4,10 @@ import kategory.typeclasses.Alternative
44

55
interface WriterTApplicative<F, W> : Applicative<WriterTKindPartial<F, W>>, WriterTFunctor<F, W> {
66

7-
override fun F0(): Monad<F>
7+
override fun F0(): Applicative<F>
88
fun L0(): Monoid<W>
99

10-
override fun <A> pure(a: A): HK<WriterTKindPartial<F, W>, A> = WriterT(F0(), F0().pure(L0().empty() toT a))
10+
override fun <A> pure(a: A): HK<WriterTKindPartial<F, W>, A> = WriterT(F0().pure(L0().empty() toT a))
1111

1212
override fun <A, B> ap(fa: HK<WriterTKindPartial<F, W>, A>, ff: HK<WriterTKindPartial<F, W>, (A) -> B>): HK<WriterTKindPartial<F, W>, B> =
1313
ap(fa, ff)
@@ -16,10 +16,12 @@ interface WriterTApplicative<F, W> : Applicative<WriterTKindPartial<F, W>>, Writ
1616
}
1717

1818
interface WriterTMonad<F, W> : WriterTApplicative<F, W>, Monad<WriterTKindPartial<F, W>> {
19-
override fun <A, B> flatMap(fa: WriterTKind<F, W, A>, f: (A) -> HK<WriterTKindPartial<F, W>, B>): WriterT<F, W, B> = fa.ev().flatMap({ f(it).ev() }, L0())
19+
override fun F0(): Monad<F>
20+
21+
override fun <A, B> flatMap(fa: WriterTKind<F, W, A>, f: (A) -> HK<WriterTKindPartial<F, W>, B>): WriterT<F, W, B> = fa.ev().flatMap(L0(), F0(), { f(it).ev() })
2022

2123
override fun <A, B> tailRecM(a: A, f: (A) -> HK<WriterTKindPartial<F, W>, Either<A, B>>): WriterT<F, W, B> =
22-
WriterT(F0(), F0().tailRecM(a, {
24+
WriterT(F0().tailRecM(a, {
2325
F0().map(f(it).ev().value) {
2426
when (it.b) {
2527
is Either.Left<A, B> -> Either.Left(it.b.a)
@@ -39,13 +41,13 @@ interface WriterTFunctor<F, W> : Functor<WriterTKindPartial<F, W>> {
3941
}
4042

4143
interface WriterTAlternative<F, W> : WriterTMonoidK<F, W>, WriterTApplicative<F, W>, Alternative<WriterTKindPartial<F, W>> {
42-
// override implicit def F0: Alternative[F]
44+
override fun F0(): Alternative<F>
4345
}
4446

4547
interface WriterTMonadFilter<F, W> : WriterTMonad<F, W>, MonadFilter<WriterTKindPartial<F, W>> {
4648
override fun F0(): MonadFilter<F>
4749

48-
override fun <A> empty(): HK<WriterTKindPartial<F, W>, A> = WriterT(F0(), F0().empty())
50+
override fun <A> empty(): HK<WriterTKindPartial<F, W>, A> = WriterT(F0().empty())
4951
}
5052

5153
interface WriterTSemigroupK<F, W> : SemigroupK<WriterTKindPartial<F, W>> {
@@ -55,23 +57,23 @@ interface WriterTSemigroupK<F, W> : SemigroupK<WriterTKindPartial<F, W>> {
5557
fun F0(): SemigroupK<F>
5658

5759
override fun <A> combineK(x: HK<WriterTKindPartial<F, W>, A>, y: HK<WriterTKindPartial<F, W>, A>):
58-
WriterT<F, W, A> = WriterT(MF(), F0().combineK(x.ev().value, y.ev().value))
60+
WriterT<F, W, A> = WriterT(F0().combineK(x.ev().value, y.ev().value))
5961
}
6062

6163
interface WriterTMonoidK<F, W> : MonoidK<WriterTKindPartial<F, W>>, WriterTSemigroupK<F, W> {
6264

6365
override fun F0(): MonoidK<F>
6466

65-
override fun <A> empty(): HK<WriterTKindPartial<F, W>, A> = WriterT(MF(), F0().empty())
67+
override fun <A> empty(): HK<WriterTKindPartial<F, W>, A> = WriterT(F0().empty())
6668
}
6769

6870
interface WriterTMonadWriter<F, W> : MonadWriter<WriterTKindPartial<F, W>, W>, WriterTMonad<F, W> {
6971

7072
override fun <A> listen(fa: HK<WriterTKindPartial<F, W>, A>): HK<WriterTKindPartial<F, W>, Tuple2<W, A>> =
71-
WriterT(F0(), F0().flatMap(fa.ev().content(), { a -> F0().map(fa.ev().write(), { l -> Tuple2(l, Tuple2(l, a)) }) }))
73+
WriterT(F0().flatMap(fa.ev().value(), { a -> F0().map(fa.ev().written(), { l -> Tuple2(l, Tuple2(l, a)) }) }))
7274

7375
override fun <A> pass(fa: HK<WriterTKindPartial<F, W>, Tuple2<(W) -> W, A>>): HK<WriterTKindPartial<F, W>, A> =
74-
WriterT(F0(), F0().flatMap(fa.ev().content(), { tuple2FA -> F0().map(fa.ev().write(), { l -> Tuple2(tuple2FA.a(l), tuple2FA.b) }) }))
76+
WriterT(F0().flatMap(fa.ev().value(), { tuple2FA -> F0().map(fa.ev().written(), { l -> Tuple2(tuple2FA.a(l), tuple2FA.b) }) }))
7577

7678
override fun <A> writer(aw: Tuple2<W, A>): HK<WriterTKindPartial<F, W>, A> = WriterT.put2(aw.b, aw.a, F0())
7779

0 commit comments

Comments
 (0)