git.iko.soy/rowtype-yoga/yoga-r3f
on main help sign in
rowtype-yoga/yoga-r3f/output/Control.Monad.Except.Trans/index.js
483 lines 17 kB history raw
1// Generated by purs version 0.15.16
2import * as Control_Applicative from "../Control.Applicative/index.js";
3import * as Control_Apply from "../Control.Apply/index.js";
4import * as Control_Bind from "../Control.Bind/index.js";
5import * as Control_Category from "../Control.Category/index.js";
6import * as Control_Monad from "../Control.Monad/index.js";
7import * as Control_Monad_Cont_Class from "../Control.Monad.Cont.Class/index.js";
8import * as Control_Monad_Error_Class from "../Control.Monad.Error.Class/index.js";
9import * as Control_Monad_Reader_Class from "../Control.Monad.Reader.Class/index.js";
10import * as Control_Monad_Rec_Class from "../Control.Monad.Rec.Class/index.js";
11import * as Control_Monad_ST_Class from "../Control.Monad.ST.Class/index.js";
12import * as Control_Monad_State_Class from "../Control.Monad.State.Class/index.js";
13import * as Control_Monad_Trans_Class from "../Control.Monad.Trans.Class/index.js";
14import * as Control_Monad_Writer_Class from "../Control.Monad.Writer.Class/index.js";
15import * as Data_Either from "../Data.Either/index.js";
16import * as Data_Functor from "../Data.Functor/index.js";
17import * as Data_Monoid from "../Data.Monoid/index.js";
18import * as Data_Semigroup from "../Data.Semigroup/index.js";
19import * as Data_Tuple from "../Data.Tuple/index.js";
20import * as Effect_Class from "../Effect.Class/index.js";
21var map = /* #__PURE__ */ Data_Functor.map(Data_Either.functorEither);
22var identity = /* #__PURE__ */ Control_Category.identity(Control_Category.categoryFn);
23var ExceptT = function (x) {
24 return x;
25};
26var withExceptT = function (dictFunctor) {
27 var map1 = Data_Functor.map(dictFunctor);
28 return function (f) {
29 return function (v) {
30 var mapLeft = function (v1) {
31 return function (v2) {
32 if (v2 instanceof Data_Either.Right) {
33 return new Data_Either.Right(v2.value0);
34 };
35 if (v2 instanceof Data_Either.Left) {
36 return new Data_Either.Left(v1(v2.value0));
37 };
38 throw new Error("Failed pattern match at Control.Monad.Except.Trans (line 43, column 3 - line 43, column 32): " + [ v1.constructor.name, v2.constructor.name ]);
39 };
40 };
41 return map1(mapLeft(f))(v);
42 };
43 };
44};
45var runExceptT = function (v) {
46 return v;
47};
48var newtypeExceptT = {
49 Coercible0: function () {
50 return undefined;
51 }
52};
53var monadTransExceptT = {
54 lift: function (dictMonad) {
55 var bind = Control_Bind.bind(dictMonad.Bind1());
56 var pure = Control_Applicative.pure(dictMonad.Applicative0());
57 return function (m) {
58 return bind(m)(function (a) {
59 return pure(new Data_Either.Right(a));
60 });
61 };
62 }
63};
64var lift = /* #__PURE__ */ Control_Monad_Trans_Class.lift(monadTransExceptT);
65var mapExceptT = function (f) {
66 return function (v) {
67 return f(v);
68 };
69};
70var functorExceptT = function (dictFunctor) {
71 var map1 = Data_Functor.map(dictFunctor);
72 return {
73 map: function (f) {
74 return mapExceptT(map1(map(f)));
75 }
76 };
77};
78var except = function (dictApplicative) {
79 var $191 = Control_Applicative.pure(dictApplicative);
80 return function ($192) {
81 return ExceptT($191($192));
82 };
83};
84var monadExceptT = function (dictMonad) {
85 return {
86 Applicative0: function () {
87 return applicativeExceptT(dictMonad);
88 },
89 Bind1: function () {
90 return bindExceptT(dictMonad);
91 }
92 };
93};
94var bindExceptT = function (dictMonad) {
95 var bind = Control_Bind.bind(dictMonad.Bind1());
96 var pure = Control_Applicative.pure(dictMonad.Applicative0());
97 return {
98 bind: function (v) {
99 return function (k) {
100 return bind(v)(Data_Either.either(function ($193) {
101 return pure(Data_Either.Left.create($193));
102 })(function (a) {
103 var v1 = k(a);
104 return v1;
105 }));
106 };
107 },
108 Apply0: function () {
109 return applyExceptT(dictMonad);
110 }
111 };
112};
113var applyExceptT = function (dictMonad) {
114 var functorExceptT1 = functorExceptT(((dictMonad.Bind1()).Apply0()).Functor0());
115 return {
116 apply: Control_Monad.ap(monadExceptT(dictMonad)),
117 Functor0: function () {
118 return functorExceptT1;
119 }
120 };
121};
122var applicativeExceptT = function (dictMonad) {
123 return {
124 pure: (function () {
125 var $194 = Control_Applicative.pure(dictMonad.Applicative0());
126 return function ($195) {
127 return ExceptT($194(Data_Either.Right.create($195)));
128 };
129 })(),
130 Apply0: function () {
131 return applyExceptT(dictMonad);
132 }
133 };
134};
135var semigroupExceptT = function (dictMonad) {
136 var lift2 = Control_Apply.lift2(applyExceptT(dictMonad));
137 return function (dictSemigroup) {
138 return {
139 append: lift2(Data_Semigroup.append(dictSemigroup))
140 };
141 };
142};
143var monadAskExceptT = function (dictMonadAsk) {
144 var Monad0 = dictMonadAsk.Monad0();
145 var monadExceptT1 = monadExceptT(Monad0);
146 return {
147 ask: lift(Monad0)(Control_Monad_Reader_Class.ask(dictMonadAsk)),
148 Monad0: function () {
149 return monadExceptT1;
150 }
151 };
152};
153var monadReaderExceptT = function (dictMonadReader) {
154 var local = Control_Monad_Reader_Class.local(dictMonadReader);
155 var monadAskExceptT1 = monadAskExceptT(dictMonadReader.MonadAsk0());
156 return {
157 local: function (f) {
158 return mapExceptT(local(f));
159 },
160 MonadAsk0: function () {
161 return monadAskExceptT1;
162 }
163 };
164};
165var monadContExceptT = function (dictMonadCont) {
166 var callCC = Control_Monad_Cont_Class.callCC(dictMonadCont);
167 var monadExceptT1 = monadExceptT(dictMonadCont.Monad0());
168 return {
169 callCC: function (f) {
170 return callCC(function (c) {
171 var v = f(function (a) {
172 return c(new Data_Either.Right(a));
173 });
174 return v;
175 });
176 },
177 Monad0: function () {
178 return monadExceptT1;
179 }
180 };
181};
182var monadEffectExceptT = function (dictMonadEffect) {
183 var Monad0 = dictMonadEffect.Monad0();
184 var monadExceptT1 = monadExceptT(Monad0);
185 return {
186 liftEffect: (function () {
187 var $196 = lift(Monad0);
188 var $197 = Effect_Class.liftEffect(dictMonadEffect);
189 return function ($198) {
190 return $196($197($198));
191 };
192 })(),
193 Monad0: function () {
194 return monadExceptT1;
195 }
196 };
197};
198var monadRecExceptT = function (dictMonadRec) {
199 var tailRecM = Control_Monad_Rec_Class.tailRecM(dictMonadRec);
200 var Monad0 = dictMonadRec.Monad0();
201 var bind = Control_Bind.bind(Monad0.Bind1());
202 var pure = Control_Applicative.pure(Monad0.Applicative0());
203 var monadExceptT1 = monadExceptT(Monad0);
204 return {
205 tailRecM: function (f) {
206 var $199 = tailRecM(function (a) {
207 var v = f(a);
208 return bind(v)(function (m$prime) {
209 return pure((function () {
210 if (m$prime instanceof Data_Either.Left) {
211 return new Control_Monad_Rec_Class.Done(new Data_Either.Left(m$prime.value0));
212 };
213 if (m$prime instanceof Data_Either.Right && m$prime.value0 instanceof Control_Monad_Rec_Class.Loop) {
214 return new Control_Monad_Rec_Class.Loop(m$prime.value0.value0);
215 };
216 if (m$prime instanceof Data_Either.Right && m$prime.value0 instanceof Control_Monad_Rec_Class.Done) {
217 return new Control_Monad_Rec_Class.Done(new Data_Either.Right(m$prime.value0.value0));
218 };
219 throw new Error("Failed pattern match at Control.Monad.Except.Trans (line 75, column 14 - line 78, column 43): " + [ m$prime.constructor.name ]);
220 })());
221 });
222 });
223 return function ($200) {
224 return ExceptT($199($200));
225 };
226 },
227 Monad0: function () {
228 return monadExceptT1;
229 }
230 };
231};
232var monadStateExceptT = function (dictMonadState) {
233 var Monad0 = dictMonadState.Monad0();
234 var lift1 = lift(Monad0);
235 var state = Control_Monad_State_Class.state(dictMonadState);
236 var monadExceptT1 = monadExceptT(Monad0);
237 return {
238 state: function (f) {
239 return lift1(state(f));
240 },
241 Monad0: function () {
242 return monadExceptT1;
243 }
244 };
245};
246var monadTellExceptT = function (dictMonadTell) {
247 var Monad1 = dictMonadTell.Monad1();
248 var Semigroup0 = dictMonadTell.Semigroup0();
249 var monadExceptT1 = monadExceptT(Monad1);
250 return {
251 tell: (function () {
252 var $201 = lift(Monad1);
253 var $202 = Control_Monad_Writer_Class.tell(dictMonadTell);
254 return function ($203) {
255 return $201($202($203));
256 };
257 })(),
258 Semigroup0: function () {
259 return Semigroup0;
260 },
261 Monad1: function () {
262 return monadExceptT1;
263 }
264 };
265};
266var monadWriterExceptT = function (dictMonadWriter) {
267 var MonadTell1 = dictMonadWriter.MonadTell1();
268 var Monad1 = MonadTell1.Monad1();
269 var bind = Control_Bind.bind(Monad1.Bind1());
270 var listen = Control_Monad_Writer_Class.listen(dictMonadWriter);
271 var pure = Control_Applicative.pure(Monad1.Applicative0());
272 var pass = Control_Monad_Writer_Class.pass(dictMonadWriter);
273 var Monoid0 = dictMonadWriter.Monoid0();
274 var monadTellExceptT1 = monadTellExceptT(MonadTell1);
275 return {
276 listen: mapExceptT(function (m) {
277 return bind(listen(m))(function (v) {
278 return pure(map(function (r) {
279 return new Data_Tuple.Tuple(r, v.value1);
280 })(v.value0));
281 });
282 }),
283 pass: mapExceptT(function (m) {
284 return pass(bind(m)(function (a) {
285 return pure((function () {
286 if (a instanceof Data_Either.Left) {
287 return new Data_Tuple.Tuple(new Data_Either.Left(a.value0), identity);
288 };
289 if (a instanceof Data_Either.Right) {
290 return new Data_Tuple.Tuple(new Data_Either.Right(a.value0.value0), a.value0.value1);
291 };
292 throw new Error("Failed pattern match at Control.Monad.Except.Trans (line 135, column 10 - line 137, column 45): " + [ a.constructor.name ]);
293 })());
294 }));
295 }),
296 Monoid0: function () {
297 return Monoid0;
298 },
299 MonadTell1: function () {
300 return monadTellExceptT1;
301 }
302 };
303};
304var monadThrowExceptT = function (dictMonad) {
305 var monadExceptT1 = monadExceptT(dictMonad);
306 return {
307 throwError: (function () {
308 var $204 = Control_Applicative.pure(dictMonad.Applicative0());
309 return function ($205) {
310 return ExceptT($204(Data_Either.Left.create($205)));
311 };
312 })(),
313 Monad0: function () {
314 return monadExceptT1;
315 }
316 };
317};
318var monadErrorExceptT = function (dictMonad) {
319 var bind = Control_Bind.bind(dictMonad.Bind1());
320 var pure = Control_Applicative.pure(dictMonad.Applicative0());
321 var monadThrowExceptT1 = monadThrowExceptT(dictMonad);
322 return {
323 catchError: function (v) {
324 return function (k) {
325 return bind(v)(Data_Either.either(function (a) {
326 var v1 = k(a);
327 return v1;
328 })(function ($206) {
329 return pure(Data_Either.Right.create($206));
330 }));
331 };
332 },
333 MonadThrow0: function () {
334 return monadThrowExceptT1;
335 }
336 };
337};
338var monadSTExceptT = function (dictMonadST) {
339 var Monad0 = dictMonadST.Monad0();
340 var monadExceptT1 = monadExceptT(Monad0);
341 return {
342 liftST: (function () {
343 var $207 = lift(Monad0);
344 var $208 = Control_Monad_ST_Class.liftST(dictMonadST);
345 return function ($209) {
346 return $207($208($209));
347 };
348 })(),
349 Monad0: function () {
350 return monadExceptT1;
351 }
352 };
353};
354var monoidExceptT = function (dictMonad) {
355 var pure = Control_Applicative.pure(applicativeExceptT(dictMonad));
356 var semigroupExceptT1 = semigroupExceptT(dictMonad);
357 return function (dictMonoid) {
358 var semigroupExceptT2 = semigroupExceptT1(dictMonoid.Semigroup0());
359 return {
360 mempty: pure(Data_Monoid.mempty(dictMonoid)),
361 Semigroup0: function () {
362 return semigroupExceptT2;
363 }
364 };
365 };
366};
367var altExceptT = function (dictSemigroup) {
368 var append = Data_Semigroup.append(dictSemigroup);
369 return function (dictMonad) {
370 var Bind1 = dictMonad.Bind1();
371 var bind = Control_Bind.bind(Bind1);
372 var pure = Control_Applicative.pure(dictMonad.Applicative0());
373 var functorExceptT1 = functorExceptT((Bind1.Apply0()).Functor0());
374 return {
375 alt: function (v) {
376 return function (v1) {
377 return bind(v)(function (rm) {
378 if (rm instanceof Data_Either.Right) {
379 return pure(new Data_Either.Right(rm.value0));
380 };
381 if (rm instanceof Data_Either.Left) {
382 return bind(v1)(function (rn) {
383 if (rn instanceof Data_Either.Right) {
384 return pure(new Data_Either.Right(rn.value0));
385 };
386 if (rn instanceof Data_Either.Left) {
387 return pure(new Data_Either.Left(append(rm.value0)(rn.value0)));
388 };
389 throw new Error("Failed pattern match at Control.Monad.Except.Trans (line 87, column 9 - line 89, column 49): " + [ rn.constructor.name ]);
390 });
391 };
392 throw new Error("Failed pattern match at Control.Monad.Except.Trans (line 83, column 5 - line 89, column 49): " + [ rm.constructor.name ]);
393 });
394 };
395 },
396 Functor0: function () {
397 return functorExceptT1;
398 }
399 };
400 };
401};
402var plusExceptT = function (dictMonoid) {
403 var mempty = Data_Monoid.mempty(dictMonoid);
404 var altExceptT1 = altExceptT(dictMonoid.Semigroup0());
405 return function (dictMonad) {
406 var altExceptT2 = altExceptT1(dictMonad);
407 return {
408 empty: Control_Monad_Error_Class.throwError(monadThrowExceptT(dictMonad))(mempty),
409 Alt0: function () {
410 return altExceptT2;
411 }
412 };
413 };
414};
415var alternativeExceptT = function (dictMonoid) {
416 var plusExceptT1 = plusExceptT(dictMonoid);
417 return function (dictMonad) {
418 var applicativeExceptT1 = applicativeExceptT(dictMonad);
419 var plusExceptT2 = plusExceptT1(dictMonad);
420 return {
421 Applicative0: function () {
422 return applicativeExceptT1;
423 },
424 Plus1: function () {
425 return plusExceptT2;
426 }
427 };
428 };
429};
430var monadPlusExceptT = function (dictMonoid) {
431 var alternativeExceptT1 = alternativeExceptT(dictMonoid);
432 return function (dictMonad) {
433 var monadExceptT1 = monadExceptT(dictMonad);
434 var alternativeExceptT2 = alternativeExceptT1(dictMonad);
435 return {
436 Monad0: function () {
437 return monadExceptT1;
438 },
439 Alternative1: function () {
440 return alternativeExceptT2;
441 }
442 };
443 };
444};
445export {
446 ExceptT,
447 runExceptT,
448 withExceptT,
449 mapExceptT,
450 except,
451 newtypeExceptT,
452 functorExceptT,
453 applyExceptT,
454 applicativeExceptT,
455 bindExceptT,
456 monadExceptT,
457 monadRecExceptT,
458 altExceptT,
459 plusExceptT,
460 alternativeExceptT,
461 monadPlusExceptT,
462 monadTransExceptT,
463 monadEffectExceptT,
464 monadContExceptT,
465 monadThrowExceptT,
466 monadErrorExceptT,
467 monadAskExceptT,
468 monadReaderExceptT,
469 monadStateExceptT,
470 monadTellExceptT,
471 monadWriterExceptT,
472 semigroupExceptT,
473 monoidExceptT,
474 monadSTExceptT
475};
476export {
477 catchError,
478 throwError
479} from "../Control.Monad.Error.Class/index.js";
480export {
481 lift
482} from "../Control.Monad.Trans.Class/index.js";
483//# sourceMappingURL=index.js.map