@@ -2,7 +2,7 @@ package kategory
2
2
3
3
@Suppress(" UNCHECKED_CAST" ) inline fun <F , W , A > WriterTKind <F , W , A >.value (): HK <F , Tuple2 <W , A >> = this .ev().value
4
4
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> {
6
6
7
7
companion object {
8
8
@@ -12,17 +12,17 @@ package kategory
12
12
13
13
inline fun <reified F , W , A > fromTuple (z : Tuple2 <W , A >, MF : Monad <F > = kategory.monad()) = WriterT (MF .pure(z), MF )
14
14
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)
16
16
17
17
inline fun <reified F , reified W > functor (FF : Functor <F > = kategory.functor<F >()): WriterTFunctor <F , W > =
18
18
object : WriterTFunctor <F , W > {
19
19
override fun F0 (): Functor <F > = FF
20
20
}
21
21
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 >(),
23
23
MW : Monoid <W > = kategory.monoid<W >()): WriterTApplicative <F , W > =
24
24
object : WriterTApplicative <F , W > {
25
- override fun F0 (): Monad <F > = MF
25
+ override fun F0 (): Applicative <F > = AP
26
26
override fun L0 (): Monoid <W > = MW
27
27
}
28
28
@@ -59,13 +59,13 @@ package kategory
59
59
}
60
60
61
61
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) }))
63
63
64
64
inline fun <reified F , W , A > put (a : A , w : W , applicativeF : Applicative <F > = kategory.applicative()): WriterT <F , W , A > =
65
65
WriterT .putT(applicativeF.pure(a), w)
66
66
67
67
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) }))
69
69
70
70
fun <F , W , A > put2 (a : A , w : W , MF : Monad <F >): WriterT <F , W , A > =
71
71
WriterT .putT2(MF .pure(a), w, MF )
@@ -80,31 +80,38 @@ package kategory
80
80
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 > =
81
81
WriterT .putT(vf, monoidW.empty())
82
82
}
83
+ }
83
84
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) }
85
86
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 })
87
88
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 })
89
90
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() }
91
92
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) }))
93
95
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 }
95
98
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) }
97
101
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 }
99
103
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 }) }))
102
106
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))
104
109
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 }))
106
112
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)) })
108
115
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) })
0 commit comments