/
sequence.kt
129 lines (98 loc) · 4.19 KB
/
sequence.kt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
package arrow.instances
import arrow.Kind
import arrow.core.Either
import arrow.core.Eval
import arrow.core.Tuple2
import arrow.data.*
import arrow.instance
import arrow.typeclasses.*
import arrow.data.combineK as sequenceCombineK
@instance(SequenceK::class)
interface SequenceKSemigroupInstance<A> : Semigroup<SequenceK<A>> {
override fun SequenceK<A>.combine(b: SequenceK<A>): SequenceK<A> = (this.sequence + b.sequence).k()
}
@instance(SequenceK::class)
interface SequenceKMonoidInstance<A> : Monoid<SequenceK<A>> {
override fun SequenceK<A>.combine(b: SequenceK<A>): SequenceK<A> = (this.sequence + b.sequence).k()
override fun empty(): SequenceK<A> = emptySequence<A>().k()
}
@instance(SequenceK::class)
interface SequenceKEqInstance<A> : Eq<SequenceK<A>> {
fun EQ(): Eq<A>
override fun SequenceK<A>.eqv(b: SequenceK<A>): Boolean =
zip(b) { aa, bb -> EQ().run { aa.eqv(bb) } }.fold(true) { acc, bool ->
acc && bool
}
}
@instance(SequenceK::class)
interface SequenceKShowInstance<A> : Show<SequenceK<A>> {
override fun SequenceK<A>.show(): String =
toString()
}
@instance(SequenceK::class)
interface SequenceKFunctorInstance : Functor<ForSequenceK> {
override fun <A, B> Kind<ForSequenceK, A>.map(f: (A) -> B): SequenceK<B> =
fix().map(f)
}
@instance(SequenceK::class)
interface SequenceKApplicativeInstance : Applicative<ForSequenceK> {
override fun <A, B> Kind<ForSequenceK, A>.ap(ff: Kind<ForSequenceK, (A) -> B>): SequenceK<B> =
fix().ap(ff)
override fun <A, B> Kind<ForSequenceK, A>.map(f: (A) -> B): SequenceK<B> =
fix().map(f)
override fun <A, B, Z> Kind<ForSequenceK, A>.map2(fb: Kind<ForSequenceK, B>, f: (Tuple2<A, B>) -> Z): SequenceK<Z> =
fix().map2(fb, f)
override fun <A> just(a: A): SequenceK<A> =
SequenceK.just(a)
}
@instance(SequenceK::class)
interface SequenceKMonadInstance : Monad<ForSequenceK> {
override fun <A, B> Kind<ForSequenceK, A>.ap(ff: Kind<ForSequenceK, (A) -> B>): SequenceK<B> =
fix().ap(ff)
override fun <A, B> Kind<ForSequenceK, A>.flatMap(f: (A) -> Kind<ForSequenceK, B>): SequenceK<B> =
fix().flatMap(f)
override fun <A, B> tailRecM(a: A, f: kotlin.Function1<A, SequenceKOf<Either<A, B>>>): SequenceK<B> =
SequenceK.tailRecM(a, f)
override fun <A, B> Kind<ForSequenceK, A>.map(f: (A) -> B): SequenceK<B> =
fix().map(f)
override fun <A, B, Z> Kind<ForSequenceK, A>.map2(fb: Kind<ForSequenceK, B>, f: (Tuple2<A, B>) -> Z): SequenceK<Z> =
fix().map2(fb, f)
override fun <A> just(a: A): SequenceK<A> =
SequenceK.just(a)
}
@instance(SequenceK::class)
interface SequenceKFoldableInstance : Foldable<ForSequenceK> {
override fun <A, B> Kind<ForSequenceK, A>.foldLeft(b: B, f: (B, A) -> B): B =
fix().foldLeft(b, f)
override fun <A, B> Kind<ForSequenceK, A>.foldRight(lb: Eval<B>, f: (A, Eval<B>) -> Eval<B>): Eval<B> =
fix().foldRight(lb, f)
}
@instance(SequenceK::class)
interface SequenceKTraverseInstance : Traverse<ForSequenceK> {
override fun <A, B> Kind<ForSequenceK, A>.map(f: (A) -> B): SequenceK<B> =
fix().map(f)
override fun <G, A, B> Kind<ForSequenceK, A>.traverse(AP: Applicative<G>, f: (A) -> Kind<G, B>): Kind<G, SequenceK<B>> =
fix().traverse(AP, f)
override fun <A, B> Kind<ForSequenceK, A>.foldLeft(b: B, f: (B, A) -> B): B =
fix().foldLeft(b, f)
override fun <A, B> Kind<ForSequenceK, A>.foldRight(lb: Eval<B>, f: (A, Eval<B>) -> Eval<B>): Eval<B> =
fix().foldRight(lb, f)
}
@instance(SequenceK::class)
interface SequenceKSemigroupKInstance : SemigroupK<ForSequenceK> {
override fun <A> Kind<ForSequenceK, A>.combineK(y: Kind<ForSequenceK, A>): SequenceK<A> =
fix().sequenceCombineK(y)
}
@instance(SequenceK::class)
interface SequenceKMonoidKInstance : MonoidK<ForSequenceK> {
override fun <A> empty(): SequenceK<A> =
SequenceK.empty()
override fun <A> Kind<ForSequenceK, A>.combineK(y: Kind<ForSequenceK, A>): SequenceK<A> =
fix().sequenceCombineK(y)
}
object SequenceKContext : SequenceKMonadInstance, SequenceKTraverseInstance, SequenceKMonoidKInstance {
override fun <A, B> Kind<ForSequenceK, A>.map(f: (A) -> B): SequenceK<B> =
fix().map(f)
}
infix fun <A> ForSequenceK.Companion.extensions(f: SequenceKContext.() -> A): A =
f(SequenceKContext)