Skip to content

Commit e3256e1

Browse files
pakoitopakoito
authored
Merge pull request #278 from anstaendig/master
#266: Alias constructors for applicative builders for Try, Eval, IO
2 parents 0580ec7 + 4a48f7f commit e3256e1

File tree

6 files changed

+544
-101
lines changed

6 files changed

+544
-101
lines changed

‎gradle/wrapper/gradle-wrapper.jar

0 Bytes
Binary file not shown.

‎gradle/wrapper/gradle-wrapper.properties

+1-1
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
#Sun Jun 25 18:21:54 BST 2017
1+
#Mon Sep 11 16:05:40 EEST 2017
22
distributionBase=GRADLE_USER_HOME
33
distributionPath=wrapper/dists
44
zipStoreBase=GRADLE_USER_HOME

‎kategory-core/src/main/kotlin/kategory/data/Eval.kt

+183-40
Original file line numberDiff line numberDiff line change
@@ -31,6 +31,189 @@ package kategory
3131
@deriving(Functor::class, Applicative::class, Monad::class)
3232
sealed class Eval<out A> : EvalKind<A> {
3333

34+
companion object {
35+
36+
fun <A, B> tailRecM(a: A, f: (A) -> EvalKind<Either<A, B>>): Eval<B> =
37+
f(a).ev().flatMap { eval: Either<A, B> ->
38+
when (eval) {
39+
is Either.Left -> tailRecM(eval.a, f)
40+
is Either.Right -> pure(eval.b)
41+
}
42+
}
43+
44+
fun <A> pure(a: A): Eval<A> = Eval.now(a)
45+
46+
@JvmStatic
47+
fun <A> now(a: A) = Now(a)
48+
49+
@JvmStatic
50+
fun <A> later(f: () -> A) = Later(f)
51+
52+
@JvmStatic
53+
fun <A> always(f: () -> A) = Always(f)
54+
55+
@JvmStatic
56+
fun <A> defer(f: () -> Eval<A>): Eval<A> = Call(f)
57+
58+
@JvmStatic
59+
fun raise(t: Throwable): Eval<Nothing> = defer { throw t }
60+
61+
@JvmStatic
62+
val Unit: Eval<Unit> = Now(kotlin.Unit)
63+
@JvmStatic
64+
val True: Eval<Boolean> = Now(true)
65+
@JvmStatic
66+
val False: Eval<Boolean> = Now(false)
67+
@JvmStatic
68+
val Zero: Eval<Int> = Now(0)
69+
@JvmStatic
70+
val One: Eval<Int> = Now(1)
71+
72+
fun <A, B> merge(
73+
op1: () -> A,
74+
op2: () -> B): Eval<Tuple2<A, B>> =
75+
applicative().tupled(
76+
later(op1),
77+
later(op2)
78+
).ev()
79+
80+
fun <A, B, C> merge(
81+
op1: () -> A,
82+
op2: () -> B,
83+
op3: () -> C): Eval<Tuple3<A, B, C>> =
84+
applicative().tupled(
85+
later(op1),
86+
later(op2),
87+
later(op3)
88+
).ev()
89+
90+
fun <A, B, C, D> merge(
91+
op1: () -> A,
92+
op2: () -> B,
93+
op3: () -> C,
94+
op4: () -> D): Eval<Tuple4<A, B, C, D>> =
95+
applicative().tupled(
96+
later(op1),
97+
later(op2),
98+
later(op3),
99+
later(op4)
100+
).ev()
101+
102+
fun <A, B, C, D, E> merge(
103+
op1: () -> A,
104+
op2: () -> B,
105+
op3: () -> C,
106+
op4: () -> D,
107+
op5: () -> E): Eval<Tuple5<A, B, C, D, E>> =
108+
applicative().tupled(
109+
later(op1),
110+
later(op2),
111+
later(op3),
112+
later(op4),
113+
later(op5)
114+
).ev()
115+
116+
fun <A, B, C, D, E, F> merge(
117+
op1: () -> A,
118+
op2: () -> B,
119+
op3: () -> C,
120+
op4: () -> D,
121+
op5: () -> E,
122+
op6: () -> F): Eval<Tuple6<A, B, C, D, E, F>> =
123+
applicative().tupled(
124+
later(op1),
125+
later(op2),
126+
later(op3),
127+
later(op4),
128+
later(op5),
129+
later(op6)
130+
).ev()
131+
132+
fun <A, B, C, D, E, F, G> merge(
133+
op1: () -> A,
134+
op2: () -> B,
135+
op3: () -> C,
136+
op4: () -> D,
137+
op5: () -> E,
138+
op6: () -> F,
139+
op7: () -> G): Eval<Tuple7<A, B, C, D, E, F, G>> =
140+
applicative().tupled(
141+
later(op1),
142+
later(op2),
143+
later(op3),
144+
later(op4),
145+
later(op5),
146+
later(op6),
147+
later(op7)
148+
).ev()
149+
150+
fun <A, B, C, D, E, F, G, H> merge(
151+
op1: () -> A,
152+
op2: () -> B,
153+
op3: () -> C,
154+
op4: () -> D,
155+
op5: () -> E,
156+
op6: () -> F,
157+
op7: () -> G,
158+
op8: () -> H): Eval<Tuple8<A, B, C, D, E, F, G, H>> =
159+
applicative().tupled(
160+
later(op1),
161+
later(op2),
162+
later(op3),
163+
later(op4),
164+
later(op5),
165+
later(op6),
166+
later(op7),
167+
later(op8)
168+
).ev()
169+
170+
fun <A, B, C, D, E, F, G, H, I> merge(
171+
op1: () -> A,
172+
op2: () -> B,
173+
op3: () -> C,
174+
op4: () -> D,
175+
op5: () -> E,
176+
op6: () -> F,
177+
op7: () -> G,
178+
op8: () -> H,
179+
op9: () -> I): Eval<Tuple9<A, B, C, D, E, F, G, H, I>> =
180+
applicative().tupled(
181+
later(op1),
182+
later(op2),
183+
later(op3),
184+
later(op4),
185+
later(op5),
186+
later(op6),
187+
later(op7),
188+
later(op8),
189+
later(op9)
190+
).ev()
191+
192+
fun <A, B, C, D, E, F, G, H, I, J> merge(
193+
op1: () -> A,
194+
op2: () -> B,
195+
op3: () -> C,
196+
op4: () -> D,
197+
op5: () -> E,
198+
op6: () -> F,
199+
op7: () -> G,
200+
op8: () -> H,
201+
op9: () -> I,
202+
op10: () -> J): Eval<Tuple10<A, B, C, D, E, F, G, H, I, J>> =
203+
applicative().tupled(
204+
later(op1),
205+
later(op2),
206+
later(op3),
207+
later(op4),
208+
later(op5),
209+
later(op6),
210+
later(op7),
211+
later(op8),
212+
later(op9),
213+
later(op10)
214+
).ev()
215+
}
216+
34217
abstract fun value(): A
35218

36219
abstract fun memoize(): Eval<A>
@@ -182,44 +365,4 @@ sealed class Eval<out A> : EvalKind<A> {
182365
return curr.value()
183366
}
184367
}
185-
186-
companion object {
187-
188-
fun <A, B> tailRecM(a: A, f: (A) -> EvalKind<Either<A, B>>): Eval<B> =
189-
f(a).ev().flatMap { eval: Either<A, B> ->
190-
when (eval) {
191-
is Either.Left -> tailRecM(eval.a, f)
192-
is Either.Right -> pure(eval.b)
193-
}
194-
}
195-
196-
fun <A> pure(a: A): Eval<A> = Eval.now(a)
197-
198-
@JvmStatic
199-
fun <A> now(a: A) = Now(a)
200-
201-
@JvmStatic
202-
fun <A> later(f: () -> A) = Later(f)
203-
204-
@JvmStatic
205-
fun <A> always(f: () -> A) = Always(f)
206-
207-
@JvmStatic
208-
fun <A> defer(f: () -> Eval<A>): Eval<A> = Call(f)
209-
210-
@JvmStatic
211-
fun raise(t: Throwable): Eval<Nothing> = defer { throw t }
212-
213-
@JvmStatic
214-
val Unit: Eval<Unit> = Now(kotlin.Unit)
215-
@JvmStatic
216-
val True: Eval<Boolean> = Now(true)
217-
@JvmStatic
218-
val False: Eval<Boolean> = Now(false)
219-
@JvmStatic
220-
val Zero: Eval<Int> = Now(0)
221-
@JvmStatic
222-
val One: Eval<Int> = Now(1)
223-
224-
}
225368
}

‎kategory-core/src/main/kotlin/kategory/data/Try.kt

+143
Original file line numberDiff line numberDiff line change
@@ -34,6 +34,149 @@ sealed class Try<out A> : TryKind<A> {
3434
fun monadError(): TryMonadErrorInstance =
3535
TryMonadErrorInstanceImplicits.instance()
3636

37+
fun <A, B> merge(
38+
op1: () -> A,
39+
op2: () -> B): Try<Tuple2<A, B>> =
40+
applicative().tupled(
41+
invoke(op1),
42+
invoke(op2)
43+
).ev()
44+
45+
fun <A, B, C> merge(
46+
op1: () -> A,
47+
op2: () -> B,
48+
op3: () -> C): Try<Tuple3<A, B, C>> =
49+
applicative().tupled(
50+
invoke(op1),
51+
invoke(op2),
52+
invoke(op3)
53+
).ev()
54+
55+
fun <A, B, C, D> merge(
56+
op1: () -> A,
57+
op2: () -> B,
58+
op3: () -> C,
59+
op4: () -> D): Try<Tuple4<A, B, C, D>> =
60+
applicative().tupled(
61+
invoke(op1),
62+
invoke(op2),
63+
invoke(op3),
64+
invoke(op4)
65+
).ev()
66+
67+
fun <A, B, C, D, E> merge(
68+
op1: () -> A,
69+
op2: () -> B,
70+
op3: () -> C,
71+
op4: () -> D,
72+
op5: () -> E): Try<Tuple5<A, B, C, D, E>> =
73+
applicative().tupled(
74+
invoke(op1),
75+
invoke(op2),
76+
invoke(op3),
77+
invoke(op4),
78+
invoke(op5)
79+
).ev()
80+
81+
fun <A, B, C, D, E, F> merge(
82+
op1: () -> A,
83+
op2: () -> B,
84+
op3: () -> C,
85+
op4: () -> D,
86+
op5: () -> E,
87+
op6: () -> F): Try<Tuple6<A, B, C, D, E, F>> =
88+
applicative().tupled(
89+
invoke(op1),
90+
invoke(op2),
91+
invoke(op3),
92+
invoke(op4),
93+
invoke(op5),
94+
invoke(op6)
95+
).ev()
96+
97+
fun <A, B, C, D, E, F, G> merge(
98+
op1: () -> A,
99+
op2: () -> B,
100+
op3: () -> C,
101+
op4: () -> D,
102+
op5: () -> E,
103+
op6: () -> F,
104+
op7: () -> G): Try<Tuple7<A, B, C, D, E, F, G>> =
105+
applicative().tupled(
106+
invoke(op1),
107+
invoke(op2),
108+
invoke(op3),
109+
invoke(op4),
110+
invoke(op5),
111+
invoke(op6),
112+
invoke(op7)
113+
).ev()
114+
115+
fun <A, B, C, D, E, F, G, H> merge(
116+
op1: () -> A,
117+
op2: () -> B,
118+
op3: () -> C,
119+
op4: () -> D,
120+
op5: () -> E,
121+
op6: () -> F,
122+
op7: () -> G,
123+
op8: () -> H): Try<Tuple8<A, B, C, D, E, F, G, H>> =
124+
applicative().tupled(
125+
invoke(op1),
126+
invoke(op2),
127+
invoke(op3),
128+
invoke(op4),
129+
invoke(op5),
130+
invoke(op6),
131+
invoke(op7),
132+
invoke(op8)
133+
).ev()
134+
135+
fun <A, B, C, D, E, F, G, H, I> merge(
136+
op1: () -> A,
137+
op2: () -> B,
138+
op3: () -> C,
139+
op4: () -> D,
140+
op5: () -> E,
141+
op6: () -> F,
142+
op7: () -> G,
143+
op8: () -> H,
144+
op9: () -> I): Try<Tuple9<A, B, C, D, E, F, G, H, I>> =
145+
applicative().tupled(
146+
invoke(op1),
147+
invoke(op2),
148+
invoke(op3),
149+
invoke(op4),
150+
invoke(op5),
151+
invoke(op6),
152+
invoke(op7),
153+
invoke(op8),
154+
invoke(op9)
155+
).ev()
156+
157+
fun <A, B, C, D, E, F, G, H, I, J> merge(
158+
op1: () -> A,
159+
op2: () -> B,
160+
op3: () -> C,
161+
op4: () -> D,
162+
op5: () -> E,
163+
op6: () -> F,
164+
op7: () -> G,
165+
op8: () -> H,
166+
op9: () -> I,
167+
op10: () -> J): Try<Tuple10<A, B, C, D, E, F, G, H, I, J>> =
168+
applicative().tupled(
169+
invoke(op1),
170+
invoke(op2),
171+
invoke(op3),
172+
invoke(op4),
173+
invoke(op5),
174+
invoke(op6),
175+
invoke(op7),
176+
invoke(op8),
177+
invoke(op9),
178+
invoke(op10)
179+
).ev()
37180
}
38181

39182
fun <G, B> traverse(f: (A) -> HK<G, B>, GA: Applicative<G>): HK<G, Try<B>> =

0 commit comments

Comments
 (0)