@@ -3,36 +3,40 @@ package kategory
3
3
/* *
4
4
* https://www.youtube.com/watch?v=wvSP5qYiz4Y
5
5
*/
6
- interface ComposedType <out F , out G >
6
+ interface Nested <out F , out G >
7
+
8
+ typealias NestedType <F , G , A > = HK <Nested <F , G >, A >
9
+
10
+ typealias UnnestedType <F , G , A > = HK <F , HK <G , A >>
7
11
8
12
@Suppress(" UNCHECKED_CAST" )
9
- fun <F , G , A > HK <F , HK < G , A >>. lift (): HK < ComposedType < F , G > , A> = this as HK <ComposedType <F , G >, A >
13
+ fun <F , G , A > UnnestedType <F , G , A >. nest (): NestedType < F , G , A > = this as HK <Nested <F , G >, A >
10
14
11
15
@Suppress(" UNCHECKED_CAST" )
12
- fun <F , G , A , B > HK2 <F , HK2 < G , A , B >, HK2 < G , A , B >>. liftB (): HK2 < ComposedType < F , G > , A, B> = this as HK2 < ComposedType < F , G > , A , B >
16
+ fun <F , G , A > NestedType <F , G , A >. unnest (): HK < F , HK < G , A >> = this as HK < F , HK < G , A > >
13
17
14
18
@Suppress(" UNCHECKED_CAST" )
15
- fun <F , G , A > HK < ComposedType < F , G >, A>. lower (): HK < F , HK < G , A >> = this as HK < F , HK < G , A > >
19
+ fun <F , G , A , B > HK2 < F , HK2 < G , A , B >, HK2 < G , A , B >>. binest (): HK2 < Nested < F , G > , A, B> = this as HK2 < Nested < F , G > , A , B >
16
20
17
21
@Suppress(" UNCHECKED_CAST" )
18
- fun <F , G , A , B > HK2 <ComposedType <F , G >, A , B>.lowerB (): HK2 <F , HK2 <G , A , B >, HK2<G, A, B>> = this as HK2 <F , HK2 <G , A , B >, HK2 <G , A , B >>
22
+ fun <F , G , A , B > HK2 <Nested <F , G >, A , B>.biunnest (): HK2 <F , HK2 <G , A , B >, HK2<G, A, B>> = this as HK2 <F , HK2 <G , A , B >, HK2 <G , A , B >>
19
23
20
24
interface ComposedFoldable <F , G > :
21
- Foldable <ComposedType <F , G >> {
25
+ Foldable <Nested <F , G >> {
22
26
23
27
fun FF (): Foldable <F >
24
28
25
29
fun GF (): Foldable <G >
26
30
27
- override fun <A , B > foldL (fa : HK <ComposedType <F , G >, A >, b : B , f : (B , A ) -> B ): B =
28
- FF ().foldL(fa.lower (), b, { bb, aa -> GF ().foldL(aa, bb, f) })
31
+ override fun <A , B > foldL (fa : HK <Nested <F , G >, A >, b : B , f : (B , A ) -> B ): B =
32
+ FF ().foldL(fa.unnest (), b, { bb, aa -> GF ().foldL(aa, bb, f) })
29
33
30
- fun <A , B > foldLC (fa : HK <F , HK <G , A >>, b : B , f : (B , A ) -> B ): B = foldL(fa.lift (), b, f)
34
+ fun <A , B > foldLC (fa : HK <F , HK <G , A >>, b : B , f : (B , A ) -> B ): B = foldL(fa.nest (), b, f)
31
35
32
- override fun <A , B > foldR (fa : HK <ComposedType <F , G >, A >, lb : Eval <B >, f : (A , Eval <B >) -> Eval <B >): Eval <B > =
33
- FF ().foldR(fa.lower (), lb, { laa, lbb -> GF ().foldR(laa, lbb, f) })
36
+ override fun <A , B > foldR (fa : HK <Nested <F , G >, A >, lb : Eval <B >, f : (A , Eval <B >) -> Eval <B >): Eval <B > =
37
+ FF ().foldR(fa.unnest (), lb, { laa, lbb -> GF ().foldR(laa, lbb, f) })
34
38
35
- fun <A , B > foldRC (fa : HK <F , HK <G , A >>, lb : Eval <B >, f : (A , Eval <B >) -> Eval <B >): Eval <B > = foldR(fa.lift (), lb, f)
39
+ fun <A , B > foldRC (fa : HK <F , HK <G , A >>, lb : Eval <B >, f : (A , Eval <B >) -> Eval <B >): Eval <B > = foldR(fa.nest (), lb, f)
36
40
37
41
companion object {
38
42
operator fun <F , G > invoke (FF : Foldable <F >, GF : Foldable <G >): ComposedFoldable <F , G > =
@@ -52,7 +56,7 @@ inline fun <F, reified G> Foldable<F>.compose(GT: Foldable<G> = foldable<G>()):
52
56
}
53
57
54
58
interface ComposedTraverse <F , G > :
55
- Traverse <ComposedType <F , G >>,
59
+ Traverse <Nested <F , G >>,
56
60
ComposedFoldable <F , G > {
57
61
58
62
fun FT (): Traverse <F >
@@ -65,10 +69,10 @@ interface ComposedTraverse<F, G> :
65
69
66
70
override fun GF (): Foldable <G > = GT ()
67
71
68
- override fun <H , A , B > traverse (fa : HK <ComposedType <F , G >, A >, f : (A ) -> HK <H , B >, HA : Applicative <H >): HK <H , HK <ComposedType <F , G >, B>> =
69
- HA .map(FT ().traverse(fa.lower (), { ga -> GT ().traverse(ga, f, HA ) }, HA ), { it.lift () })
72
+ override fun <H , A , B > traverse (fa : HK <Nested <F , G >, A >, f : (A ) -> HK <H , B >, HA : Applicative <H >): HK <H , HK <Nested <F , G >, B>> =
73
+ HA .map(FT ().traverse(fa.unnest (), { ga -> GT ().traverse(ga, f, HA ) }, HA ), { it.nest () })
70
74
71
- fun <H , A , B > traverseC (fa : HK <F , HK <G , A >>, f : (A ) -> HK <H , B >, HA : Applicative <H >): HK <H , HK <ComposedType <F , G >, B>> = traverse(fa.lift (), f, HA )
75
+ fun <H , A , B > traverseC (fa : HK <F , HK <G , A >>, f : (A ) -> HK <H , B >, HA : Applicative <H >): HK <H , HK <Nested <F , G >, B>> = traverse(fa.nest (), f, HA )
72
76
73
77
companion object {
74
78
operator fun <F , G > invoke (
@@ -85,7 +89,7 @@ interface ComposedTraverse<F, G> :
85
89
}
86
90
}
87
91
88
- inline fun <reified F , reified G > Traverse<F>.compose (GT : Traverse <G > = traverse<G >(), GA : Applicative <G > = applicative<G >()): Traverse <ComposedType <F , G >> =
92
+ inline fun <reified F , reified G > Traverse<F>.compose (GT : Traverse <G > = traverse<G >(), GA : Applicative <G > = applicative<G >()): Traverse <Nested <F , G >> =
89
93
object :
90
94
ComposedTraverse <F , G > {
91
95
override fun FT (): Traverse <F > = this @compose
@@ -95,57 +99,57 @@ inline fun <reified F, reified G> Traverse<F>.compose(GT: Traverse<G> = traverse
95
99
override fun GA (): Applicative <G > = GA
96
100
}
97
101
98
- interface ComposedSemigroupK <F , G > : SemigroupK <ComposedType <F , G >> {
102
+ interface ComposedSemigroupK <F , G > : SemigroupK <Nested <F , G >> {
99
103
100
104
fun F (): SemigroupK <F >
101
105
102
- override fun <A > combineK (x : HK <ComposedType <F , G >, A >, y : HK <ComposedType <F , G >, A >): HK <ComposedType <F , G >, A> = F ().combineK(x.lower (), y.lower ()).lift ()
106
+ override fun <A > combineK (x : HK <Nested <F , G >, A >, y : HK <Nested <F , G >, A >): HK <Nested <F , G >, A> = F ().combineK(x.unnest (), y.unnest ()).nest ()
103
107
104
- fun <A > combineKC (x : HK <F , HK <G , A >>, y : HK <F , HK <G , A >>): HK <ComposedType <F , G >, A> = combineK(x.lift (), y.lift ())
108
+ fun <A > combineKC (x : HK <F , HK <G , A >>, y : HK <F , HK <G , A >>): HK <Nested <F , G >, A> = combineK(x.nest (), y.nest ())
105
109
106
110
companion object {
107
- operator fun <F , G > invoke (SF : SemigroupK <F >): SemigroupK <ComposedType <F , G >> =
111
+ operator fun <F , G > invoke (SF : SemigroupK <F >): SemigroupK <Nested <F , G >> =
108
112
object : ComposedSemigroupK <F , G > {
109
113
override fun F (): SemigroupK <F > = SF
110
114
}
111
115
}
112
116
}
113
117
114
- inline fun <F , G > SemigroupK<F>.compose (): SemigroupK <ComposedType <F , G >> = object : ComposedSemigroupK <F , G > {
118
+ inline fun <F , G > SemigroupK<F>.compose (): SemigroupK <Nested <F , G >> = object : ComposedSemigroupK <F , G > {
115
119
override fun F (): SemigroupK <F > = this @compose
116
120
}
117
121
118
- interface ComposedMonoidK <F , G > : MonoidK <ComposedType <F , G >>, ComposedSemigroupK <F , G > {
122
+ interface ComposedMonoidK <F , G > : MonoidK <Nested <F , G >>, ComposedSemigroupK <F , G > {
119
123
120
124
override fun F (): MonoidK <F >
121
125
122
- override fun <A > empty (): HK <ComposedType <F , G >, A> = F ().empty<HK <G , A >>().lift ()
126
+ override fun <A > empty (): HK <Nested <F , G >, A> = F ().empty<HK <G , A >>().nest ()
123
127
124
- fun <A > emptyC (): HK <F , HK <G , A >> = empty<A >().lower ()
128
+ fun <A > emptyC (): HK <F , HK <G , A >> = empty<A >().unnest ()
125
129
126
130
companion object {
127
- operator fun <F , G > invoke (MK : MonoidK <F >): MonoidK <ComposedType <F , G >> =
131
+ operator fun <F , G > invoke (MK : MonoidK <F >): MonoidK <Nested <F , G >> =
128
132
object : ComposedMonoidK <F , G > {
129
133
override fun F (): MonoidK <F > = MK
130
134
}
131
135
}
132
136
}
133
137
134
- fun <F , G > MonoidK<F>.compose (): MonoidK <ComposedType <F , G >> = object : ComposedMonoidK <F , G > {
138
+ fun <F , G > MonoidK<F>.compose (): MonoidK <Nested <F , G >> = object : ComposedMonoidK <F , G > {
135
139
override fun F (): MonoidK <F > = this @compose
136
140
}
137
141
138
- interface ComposedFunctor <F , G > : Functor <ComposedType <F , G >> {
142
+ interface ComposedFunctor <F , G > : Functor <Nested <F , G >> {
139
143
fun F (): Functor <F >
140
144
141
145
fun G (): Functor <G >
142
146
143
- override fun <A , B > map (fa : HK <ComposedType <F , G >, A >, f : (A ) -> B ): HK <ComposedType <F , G >, B> = F ().map(fa.lower (), { G ().map(it, f) }).lift ()
147
+ override fun <A , B > map (fa : HK <Nested <F , G >, A >, f : (A ) -> B ): HK <Nested <F , G >, B> = F ().map(fa.unnest (), { G ().map(it, f) }).nest ()
144
148
145
- fun <A , B > mapC (fa : HK <F , HK <G , A >>, f : (A ) -> B ): HK <F , HK <G , B >> = map(fa.lift (), f).lower ()
149
+ fun <A , B > mapC (fa : HK <F , HK <G , A >>, f : (A ) -> B ): HK <F , HK <G , B >> = map(fa.nest (), f).unnest ()
146
150
147
151
companion object {
148
- operator fun <F , G > invoke (FF : Functor <F >, GF : Functor <G >): Functor <ComposedType <F , G >> =
152
+ operator fun <F , G > invoke (FF : Functor <F >, GF : Functor <G >): Functor <Nested <F , G >> =
149
153
object : ComposedFunctor <F , G > {
150
154
override fun F (): Functor <F > = FF
151
155
@@ -154,25 +158,25 @@ interface ComposedFunctor<F, G> : Functor<ComposedType<F, G>> {
154
158
}
155
159
}
156
160
157
- inline fun <reified F , reified G > Functor<F>.compose (GF : Functor <G >): Functor <ComposedType <F , G >> = ComposedFunctor (this , GF )
161
+ inline fun <reified F , reified G > Functor<F>.compose (GF : Functor <G >): Functor <Nested <F , G >> = ComposedFunctor (this , GF )
158
162
159
- interface ComposedApplicative <F , G > : Applicative <ComposedType <F , G >>, ComposedFunctor <F , G > {
163
+ interface ComposedApplicative <F , G > : Applicative <Nested <F , G >>, ComposedFunctor <F , G > {
160
164
override fun F (): Applicative <F >
161
165
162
166
override fun G (): Applicative <G >
163
167
164
- override fun <A , B > map (fa : HK <ComposedType <F , G >, A >, f : (A ) -> B ): HK <ComposedType <F , G >, B> = ap(fa, pure(f))
168
+ override fun <A , B > map (fa : HK <Nested <F , G >, A >, f : (A ) -> B ): HK <Nested <F , G >, B> = ap(fa, pure(f))
165
169
166
- override fun <A > pure (a : A ): HK <ComposedType <F , G >, A> = F ().pure(G ().pure(a)).lift ()
170
+ override fun <A > pure (a : A ): HK <Nested <F , G >, A> = F ().pure(G ().pure(a)).nest ()
167
171
168
- override fun <A , B > ap (fa : HK <ComposedType <F , G >, A >, ff : HK <ComposedType <F , G >, (A ) -> B >):
169
- HK <ComposedType <F , G >, B > = F ().ap(fa.lower (), F ().map(ff.lower (), { gfa: HK <G , (A ) - > B > -> { ga: HK <G , A > -> G ().ap(ga, gfa) } })).lift ()
172
+ override fun <A , B > ap (fa : HK <Nested <F , G >, A >, ff : HK <Nested <F , G >, (A ) -> B >):
173
+ HK <Nested <F , G >, B > = F ().ap(fa.unnest (), F ().map(ff.unnest (), { gfa: HK <G , (A ) - > B > -> { ga: HK <G , A > -> G ().ap(ga, gfa) } })).nest ()
170
174
171
- fun <A , B > apC (fa : HK <F , HK <G , A >>, ff : HK <F , HK <G , (A ) - > B >>): HK <F , HK <G , B >> = ap(fa.lift (), ff.lift ()).lower ()
175
+ fun <A , B > apC (fa : HK <F , HK <G , A >>, ff : HK <F , HK <G , (A ) - > B >>): HK <F , HK <G , B >> = ap(fa.nest (), ff.nest ()).unnest ()
172
176
173
177
companion object {
174
178
operator fun <F , G > invoke (FF : Applicative <F >, GF : Applicative <G >)
175
- : Applicative <ComposedType <F , G >> =
179
+ : Applicative <Nested <F , G >> =
176
180
object : ComposedApplicative <F , G > {
177
181
override fun F (): Applicative <F > = FF
178
182
@@ -181,14 +185,14 @@ interface ComposedApplicative<F, G> : Applicative<ComposedType<F, G>>, ComposedF
181
185
}
182
186
}
183
187
184
- inline fun <reified F , reified G > Applicative<F>.compose (GA : Applicative <G > = applicative<G >()): Applicative <ComposedType <F , G >> = ComposedApplicative (this , GA )
188
+ inline fun <reified F , reified G > Applicative<F>.compose (GA : Applicative <G > = applicative<G >()): Applicative <Nested <F , G >> = ComposedApplicative (this , GA )
185
189
186
- interface ComposedAlternative <F , G > : Alternative <ComposedType <F , G >>, ComposedApplicative <F , G >, ComposedMonoidK <F , G > {
190
+ interface ComposedAlternative <F , G > : Alternative <Nested <F , G >>, ComposedApplicative <F , G >, ComposedMonoidK <F , G > {
187
191
override fun F (): Alternative <F >
188
192
189
193
companion object {
190
194
operator fun <F , G > invoke (AF : Alternative <F >, AG : Applicative <G >)
191
- : Alternative <ComposedType <F , G >> =
195
+ : Alternative <Nested <F , G >> =
192
196
object : ComposedAlternative <F , G > {
193
197
override fun F (): Alternative <F > = AF
194
198
@@ -197,19 +201,19 @@ interface ComposedAlternative<F, G> : Alternative<ComposedType<F, G>>, ComposedA
197
201
}
198
202
}
199
203
200
- inline fun <reified F , reified G > Alternative<F>.compose (GA : Applicative <G > = applicative<G >()): Alternative <ComposedType <F , G >> = ComposedAlternative (this , GA )
204
+ inline fun <reified F , reified G > Alternative<F>.compose (GA : Applicative <G > = applicative<G >()): Alternative <Nested <F , G >> = ComposedAlternative (this , GA )
201
205
202
- interface ComposedFunctorFilter <F , G > : FunctorFilter <ComposedType <F , G >>, ComposedFunctor <F , G > {
206
+ interface ComposedFunctorFilter <F , G > : FunctorFilter <Nested <F , G >>, ComposedFunctor <F , G > {
203
207
204
208
override fun F (): Functor <F >
205
209
206
210
override fun G (): FunctorFilter <G >
207
211
208
- override fun <A , B > mapFilter (fga : HK <ComposedType <F , G >, A >, f : (A ) -> Option <B >): HK <ComposedType <F , G >, B> =
209
- F ().map(fga.lower (), { G ().mapFilter(it, f) }).lift ()
212
+ override fun <A , B > mapFilter (fga : HK <Nested <F , G >, A >, f : (A ) -> Option <B >): HK <Nested <F , G >, B> =
213
+ F ().map(fga.unnest (), { G ().mapFilter(it, f) }).nest ()
210
214
211
215
fun <A , B > mapFilterC (fga : HK <F , HK <G , A >>, f : (A ) -> Option <B >): HK <F , HK <G , B >> =
212
- mapFilter(fga.lift (), f).lower ()
216
+ mapFilter(fga.nest (), f).unnest ()
213
217
214
218
companion object {
215
219
operator fun <F , G > invoke (FF : Functor <F >, FFG : FunctorFilter <G >): ComposedFunctorFilter <F , G > =
@@ -222,28 +226,28 @@ interface ComposedFunctorFilter<F, G> : FunctorFilter<ComposedType<F, G>>, Compo
222
226
}
223
227
224
228
inline fun <reified F , reified G > Functor<F>.composeFilter (FFG : FunctorFilter <G > = functorFilter()):
225
- FunctorFilter <ComposedType <F , G >> = ComposedFunctorFilter (this , FFG )
229
+ FunctorFilter <Nested <F , G >> = ComposedFunctorFilter (this , FFG )
226
230
227
- interface ComposedBifoldable <F , G > : Bifoldable <ComposedType <F , G >> {
231
+ interface ComposedBifoldable <F , G > : Bifoldable <Nested <F , G >> {
228
232
fun F (): Bifoldable <F >
229
233
230
234
fun G (): Bifoldable <G >
231
235
232
- override fun <A , B , C > bifoldLeft (fab : HK2 <ComposedType <F , G >, A , B >, c : C , f : (C , A ) -> C , g : (C , B ) -> C ): C =
233
- F ().bifoldLeft(fab.lowerB (), c,
236
+ override fun <A , B , C > bifoldLeft (fab : HK2 <Nested <F , G >, A , B >, c : C , f : (C , A ) -> C , g : (C , B ) -> C ): C =
237
+ F ().bifoldLeft(fab.biunnest (), c,
234
238
{ cc: C , gab: HK2 <G , A , B > -> G ().bifoldLeft(gab, cc, f, g) },
235
239
{ cc: C , gab: HK2 <G , A , B > -> G ().bifoldLeft(gab, cc, f, g) })
236
240
237
- override fun <A , B , C > bifoldRight (fab : HK2 <ComposedType <F , G >, A , B >, c : Eval <C >, f : (A , Eval <C >) -> Eval <C >, g : (B , Eval <C >) -> Eval <C >): Eval <C > =
238
- F ().bifoldRight(fab.lowerB (), c,
241
+ override fun <A , B , C > bifoldRight (fab : HK2 <Nested <F , G >, A , B >, c : Eval <C >, f : (A , Eval <C >) -> Eval <C >, g : (B , Eval <C >) -> Eval <C >): Eval <C > =
242
+ F ().bifoldRight(fab.biunnest (), c,
239
243
{ gab: HK2 <G , A , B >, cc: Eval <C > -> G ().bifoldRight(gab, cc, f, g) },
240
244
{ gab: HK2 <G , A , B >, cc: Eval <C > -> G ().bifoldRight(gab, cc, f, g) })
241
245
242
246
fun <A , B , C > bifoldLeftC (fab : HK2 <F , HK2 <G , A , B >, HK2 <G , A , B >>, c : C , f : (C , A ) -> C , g : (C , B ) -> C ): C =
243
- bifoldLeft(fab.liftB (), c, f, g)
247
+ bifoldLeft(fab.binest (), c, f, g)
244
248
245
249
fun <A , B , C > bifoldRightC (fab : HK2 <F , HK2 <G , A , B >, HK2 <G , A , B >>, c : Eval <C >, f : (A , Eval <C >) -> Eval <C >, g : (B , Eval <C >) -> Eval <C >): Eval <C > =
246
- bifoldRight(fab.liftB (), c, f, g)
250
+ bifoldRight(fab.binest (), c, f, g)
247
251
248
252
companion object {
249
253
operator fun <F , G > invoke (BF : Bifoldable <F >, BG : Bifoldable <G >): ComposedBifoldable <F , G > =
@@ -255,4 +259,4 @@ interface ComposedBifoldable<F, G> : Bifoldable<ComposedType<F, G>> {
255
259
}
256
260
}
257
261
258
- inline fun <reified F , reified G > Bifoldable<F>.compose (BG : Bifoldable <G > = bifoldable()): Bifoldable <ComposedType <F , G >> = ComposedBifoldable (this , BG )
262
+ inline fun <reified F , reified G > Bifoldable<F>.compose (BG : Bifoldable <G > = bifoldable()): Bifoldable <Nested <F , G >> = ComposedBifoldable (this , BG )
0 commit comments