git.iko.soy/rowtype-yoga/yoga-r3f
on main help sign in
rowtype-yoga/yoga-r3f/output/Data.Enum/index.js
631 lines 23 kB history raw
1// Generated by purs version 0.15.16
2import * as $foreign from "./foreign.js";
3import * as Control_Alternative from "../Control.Alternative/index.js";
4import * as Control_Apply from "../Control.Apply/index.js";
5import * as Control_Bind from "../Control.Bind/index.js";
6import * as Data_Boolean from "../Data.Boolean/index.js";
7import * as Data_Bounded from "../Data.Bounded/index.js";
8import * as Data_Either from "../Data.Either/index.js";
9import * as Data_Eq from "../Data.Eq/index.js";
10import * as Data_Function from "../Data.Function/index.js";
11import * as Data_Functor from "../Data.Functor/index.js";
12import * as Data_Maybe from "../Data.Maybe/index.js";
13import * as Data_Ord from "../Data.Ord/index.js";
14import * as Data_Ordering from "../Data.Ordering/index.js";
15import * as Data_Show from "../Data.Show/index.js";
16import * as Data_Tuple from "../Data.Tuple/index.js";
17import * as Data_Unfoldable from "../Data.Unfoldable/index.js";
18import * as Data_Unfoldable1 from "../Data.Unfoldable1/index.js";
19import * as Data_Unit from "../Data.Unit/index.js";
20var apply = /* #__PURE__ */ Control_Apply.apply(Control_Apply.applyFn);
21var show = /* #__PURE__ */ Data_Show.show(Data_Show.showInt);
22var map = /* #__PURE__ */ Data_Functor.map(Data_Maybe.functorMaybe);
23var top = /* #__PURE__ */ Data_Bounded.top(Data_Bounded.boundedInt);
24var bottom = /* #__PURE__ */ Data_Bounded.bottom(Data_Bounded.boundedInt);
25var bind = /* #__PURE__ */ Control_Bind.bind(Data_Maybe.bindMaybe);
26var voidLeft = /* #__PURE__ */ Data_Functor.voidLeft(Data_Maybe.functorMaybe);
27var guard = /* #__PURE__ */ Control_Alternative.guard(Data_Maybe.alternativeMaybe);
28var fromJust = /* #__PURE__ */ Data_Maybe.fromJust();
29var bottom1 = /* #__PURE__ */ Data_Bounded.bottom(Data_Bounded.boundedChar);
30var top1 = /* #__PURE__ */ Data_Bounded.top(Data_Bounded.boundedChar);
31var Cardinality = function (x) {
32 return x;
33};
34var toEnum = function (dict) {
35 return dict.toEnum;
36};
37var succ = function (dict) {
38 return dict.succ;
39};
40var upFromIncluding = function (dictEnum) {
41 var succ1 = succ(dictEnum);
42 return function (dictUnfoldable1) {
43 return Data_Unfoldable1.unfoldr1(dictUnfoldable1)(apply(Data_Tuple.Tuple.create)(succ1));
44 };
45};
46var showCardinality = {
47 show: function (v) {
48 return "(Cardinality " + (show(v) + ")");
49 }
50};
51var pred = function (dict) {
52 return dict.pred;
53};
54var ordCardinality = Data_Ord.ordInt;
55var newtypeCardinality = {
56 Coercible0: function () {
57 return undefined;
58 }
59};
60var fromEnum = function (dict) {
61 return dict.fromEnum;
62};
63var toEnumWithDefaults = function (dictBoundedEnum) {
64 var toEnum1 = toEnum(dictBoundedEnum);
65 var fromEnum1 = fromEnum(dictBoundedEnum);
66 var bottom2 = Data_Bounded.bottom(dictBoundedEnum.Bounded0());
67 return function (low) {
68 return function (high) {
69 return function (x) {
70 var v = toEnum1(x);
71 if (v instanceof Data_Maybe.Just) {
72 return v.value0;
73 };
74 if (v instanceof Data_Maybe.Nothing) {
75 var $140 = x < fromEnum1(bottom2);
76 if ($140) {
77 return low;
78 };
79 return high;
80 };
81 throw new Error("Failed pattern match at Data.Enum (line 158, column 33 - line 160, column 62): " + [ v.constructor.name ]);
82 };
83 };
84 };
85};
86var eqCardinality = Data_Eq.eqInt;
87var enumUnit = /* #__PURE__ */ (function () {
88 return {
89 succ: Data_Function["const"](Data_Maybe.Nothing.value),
90 pred: Data_Function["const"](Data_Maybe.Nothing.value),
91 Ord0: function () {
92 return Data_Ord.ordUnit;
93 }
94 };
95})();
96var enumTuple = function (dictEnum) {
97 var succ1 = succ(dictEnum);
98 var pred1 = pred(dictEnum);
99 var ordTuple = Data_Tuple.ordTuple(dictEnum.Ord0());
100 return function (dictBoundedEnum) {
101 var Bounded0 = dictBoundedEnum.Bounded0();
102 var bottom2 = Data_Bounded.bottom(Bounded0);
103 var Enum1 = dictBoundedEnum.Enum1();
104 var succ2 = succ(Enum1);
105 var top2 = Data_Bounded.top(Bounded0);
106 var pred2 = pred(Enum1);
107 var ordTuple1 = ordTuple(Enum1.Ord0());
108 return {
109 succ: function (v) {
110 return Data_Maybe.maybe(map(Data_Function.flip(Data_Tuple.Tuple.create)(bottom2))(succ1(v.value0)))((function () {
111 var $183 = Data_Tuple.Tuple.create(v.value0);
112 return function ($184) {
113 return Data_Maybe.Just.create($183($184));
114 };
115 })())(succ2(v.value1));
116 },
117 pred: function (v) {
118 return Data_Maybe.maybe(map(Data_Function.flip(Data_Tuple.Tuple.create)(top2))(pred1(v.value0)))((function () {
119 var $185 = Data_Tuple.Tuple.create(v.value0);
120 return function ($186) {
121 return Data_Maybe.Just.create($185($186));
122 };
123 })())(pred2(v.value1));
124 },
125 Ord0: function () {
126 return ordTuple1;
127 }
128 };
129 };
130};
131var enumOrdering = {
132 succ: function (v) {
133 if (v instanceof Data_Ordering.LT) {
134 return new Data_Maybe.Just(Data_Ordering.EQ.value);
135 };
136 if (v instanceof Data_Ordering.EQ) {
137 return new Data_Maybe.Just(Data_Ordering.GT.value);
138 };
139 if (v instanceof Data_Ordering.GT) {
140 return Data_Maybe.Nothing.value;
141 };
142 throw new Error("Failed pattern match at Data.Enum (line 72, column 1 - line 78, column 20): " + [ v.constructor.name ]);
143 },
144 pred: function (v) {
145 if (v instanceof Data_Ordering.LT) {
146 return Data_Maybe.Nothing.value;
147 };
148 if (v instanceof Data_Ordering.EQ) {
149 return new Data_Maybe.Just(Data_Ordering.LT.value);
150 };
151 if (v instanceof Data_Ordering.GT) {
152 return new Data_Maybe.Just(Data_Ordering.EQ.value);
153 };
154 throw new Error("Failed pattern match at Data.Enum (line 72, column 1 - line 78, column 20): " + [ v.constructor.name ]);
155 },
156 Ord0: function () {
157 return Data_Ord.ordOrdering;
158 }
159};
160var enumMaybe = function (dictBoundedEnum) {
161 var bottom2 = Data_Bounded.bottom(dictBoundedEnum.Bounded0());
162 var Enum1 = dictBoundedEnum.Enum1();
163 var succ1 = succ(Enum1);
164 var pred1 = pred(Enum1);
165 var ordMaybe = Data_Maybe.ordMaybe(Enum1.Ord0());
166 return {
167 succ: function (v) {
168 if (v instanceof Data_Maybe.Nothing) {
169 return new Data_Maybe.Just(new Data_Maybe.Just(bottom2));
170 };
171 if (v instanceof Data_Maybe.Just) {
172 return map(Data_Maybe.Just.create)(succ1(v.value0));
173 };
174 throw new Error("Failed pattern match at Data.Enum (line 80, column 1 - line 84, column 32): " + [ v.constructor.name ]);
175 },
176 pred: function (v) {
177 if (v instanceof Data_Maybe.Nothing) {
178 return Data_Maybe.Nothing.value;
179 };
180 if (v instanceof Data_Maybe.Just) {
181 return new Data_Maybe.Just(pred1(v.value0));
182 };
183 throw new Error("Failed pattern match at Data.Enum (line 80, column 1 - line 84, column 32): " + [ v.constructor.name ]);
184 },
185 Ord0: function () {
186 return ordMaybe;
187 }
188 };
189};
190var enumInt = {
191 succ: function (n) {
192 var $153 = n < top;
193 if ($153) {
194 return new Data_Maybe.Just(n + 1 | 0);
195 };
196 return Data_Maybe.Nothing.value;
197 },
198 pred: function (n) {
199 var $154 = n > bottom;
200 if ($154) {
201 return new Data_Maybe.Just(n - 1 | 0);
202 };
203 return Data_Maybe.Nothing.value;
204 },
205 Ord0: function () {
206 return Data_Ord.ordInt;
207 }
208};
209var enumFromTo = function (dictEnum) {
210 var Ord0 = dictEnum.Ord0();
211 var eq1 = Data_Eq.eq(Ord0.Eq0());
212 var lessThan1 = Data_Ord.lessThan(Ord0);
213 var succ1 = succ(dictEnum);
214 var lessThanOrEq1 = Data_Ord.lessThanOrEq(Ord0);
215 var pred1 = pred(dictEnum);
216 var greaterThanOrEq1 = Data_Ord.greaterThanOrEq(Ord0);
217 return function (dictUnfoldable1) {
218 var singleton = Data_Unfoldable1.singleton(dictUnfoldable1);
219 var unfoldr1 = Data_Unfoldable1.unfoldr1(dictUnfoldable1);
220 var go = function (step) {
221 return function (op) {
222 return function (to) {
223 return function (a) {
224 return new Data_Tuple.Tuple(a, bind(step(a))(function (a$prime) {
225 return voidLeft(guard(op(a$prime)(to)))(a$prime);
226 }));
227 };
228 };
229 };
230 };
231 return function (v) {
232 return function (v1) {
233 if (eq1(v)(v1)) {
234 return singleton(v);
235 };
236 if (lessThan1(v)(v1)) {
237 return unfoldr1(go(succ1)(lessThanOrEq1)(v1))(v);
238 };
239 if (Data_Boolean.otherwise) {
240 return unfoldr1(go(pred1)(greaterThanOrEq1)(v1))(v);
241 };
242 throw new Error("Failed pattern match at Data.Enum (line 186, column 14 - line 190, column 51): " + [ v.constructor.name, v1.constructor.name ]);
243 };
244 };
245 };
246};
247var enumFromThenTo = function (dictUnfoldable) {
248 var unfoldr = Data_Unfoldable.unfoldr(dictUnfoldable);
249 return function (dictFunctor) {
250 var map1 = Data_Functor.map(dictFunctor);
251 return function (dictBoundedEnum) {
252 var fromEnum1 = fromEnum(dictBoundedEnum);
253 var toEnum1 = toEnum(dictBoundedEnum);
254 var go = function (step) {
255 return function (to) {
256 return function (e) {
257 if (e <= to) {
258 return new Data_Maybe.Just(new Data_Tuple.Tuple(e, e + step | 0));
259 };
260 if (Data_Boolean.otherwise) {
261 return Data_Maybe.Nothing.value;
262 };
263 throw new Error("Failed pattern match at Data.Enum (line 217, column 5 - line 219, column 28): " + [ step.constructor.name, to.constructor.name, e.constructor.name ]);
264 };
265 };
266 };
267 return function (a) {
268 return function (b) {
269 return function (c) {
270 var c$prime = fromEnum1(c);
271 var b$prime = fromEnum1(b);
272 var a$prime = fromEnum1(a);
273 return map1(function ($187) {
274 return fromJust(toEnum1($187));
275 })(unfoldr(go(b$prime - a$prime | 0)(c$prime))(a$prime));
276 };
277 };
278 };
279 };
280 };
281};
282var enumEither = function (dictBoundedEnum) {
283 var Enum1 = dictBoundedEnum.Enum1();
284 var succ1 = succ(Enum1);
285 var pred1 = pred(Enum1);
286 var top2 = Data_Bounded.top(dictBoundedEnum.Bounded0());
287 var ordEither = Data_Either.ordEither(Enum1.Ord0());
288 return function (dictBoundedEnum1) {
289 var bottom2 = Data_Bounded.bottom(dictBoundedEnum1.Bounded0());
290 var Enum11 = dictBoundedEnum1.Enum1();
291 var succ2 = succ(Enum11);
292 var pred2 = pred(Enum11);
293 var ordEither1 = ordEither(Enum11.Ord0());
294 return {
295 succ: function (v) {
296 if (v instanceof Data_Either.Left) {
297 return Data_Maybe.maybe(new Data_Maybe.Just(new Data_Either.Right(bottom2)))(function ($188) {
298 return Data_Maybe.Just.create(Data_Either.Left.create($188));
299 })(succ1(v.value0));
300 };
301 if (v instanceof Data_Either.Right) {
302 return Data_Maybe.maybe(Data_Maybe.Nothing.value)(function ($189) {
303 return Data_Maybe.Just.create(Data_Either.Right.create($189));
304 })(succ2(v.value0));
305 };
306 throw new Error("Failed pattern match at Data.Enum (line 86, column 1 - line 90, column 69): " + [ v.constructor.name ]);
307 },
308 pred: function (v) {
309 if (v instanceof Data_Either.Left) {
310 return Data_Maybe.maybe(Data_Maybe.Nothing.value)(function ($190) {
311 return Data_Maybe.Just.create(Data_Either.Left.create($190));
312 })(pred1(v.value0));
313 };
314 if (v instanceof Data_Either.Right) {
315 return Data_Maybe.maybe(new Data_Maybe.Just(new Data_Either.Left(top2)))(function ($191) {
316 return Data_Maybe.Just.create(Data_Either.Right.create($191));
317 })(pred2(v.value0));
318 };
319 throw new Error("Failed pattern match at Data.Enum (line 86, column 1 - line 90, column 69): " + [ v.constructor.name ]);
320 },
321 Ord0: function () {
322 return ordEither1;
323 }
324 };
325 };
326};
327var enumBoolean = {
328 succ: function (v) {
329 if (!v) {
330 return new Data_Maybe.Just(true);
331 };
332 return Data_Maybe.Nothing.value;
333 },
334 pred: function (v) {
335 if (v) {
336 return new Data_Maybe.Just(false);
337 };
338 return Data_Maybe.Nothing.value;
339 },
340 Ord0: function () {
341 return Data_Ord.ordBoolean;
342 }
343};
344var downFromIncluding = function (dictEnum) {
345 var pred1 = pred(dictEnum);
346 return function (dictUnfoldable1) {
347 return Data_Unfoldable1.unfoldr1(dictUnfoldable1)(apply(Data_Tuple.Tuple.create)(pred1));
348 };
349};
350var diag = function (a) {
351 return new Data_Tuple.Tuple(a, a);
352};
353var downFrom = function (dictEnum) {
354 var pred1 = pred(dictEnum);
355 return function (dictUnfoldable) {
356 return Data_Unfoldable.unfoldr(dictUnfoldable)((function () {
357 var $192 = map(diag);
358 return function ($193) {
359 return $192(pred1($193));
360 };
361 })());
362 };
363};
364var upFrom = function (dictEnum) {
365 var succ1 = succ(dictEnum);
366 return function (dictUnfoldable) {
367 return Data_Unfoldable.unfoldr(dictUnfoldable)((function () {
368 var $194 = map(diag);
369 return function ($195) {
370 return $194(succ1($195));
371 };
372 })());
373 };
374};
375var defaultToEnum = function (dictBounded) {
376 var bottom2 = Data_Bounded.bottom(dictBounded);
377 return function (dictEnum) {
378 var succ1 = succ(dictEnum);
379 return function (i$prime) {
380 var go = function ($copy_i) {
381 return function ($copy_x) {
382 var $tco_var_i = $copy_i;
383 var $tco_done = false;
384 var $tco_result;
385 function $tco_loop(i, x) {
386 var $168 = i === 0;
387 if ($168) {
388 $tco_done = true;
389 return new Data_Maybe.Just(x);
390 };
391 var v = succ1(x);
392 if (v instanceof Data_Maybe.Just) {
393 $tco_var_i = i - 1 | 0;
394 $copy_x = v.value0;
395 return;
396 };
397 if (v instanceof Data_Maybe.Nothing) {
398 $tco_done = true;
399 return Data_Maybe.Nothing.value;
400 };
401 throw new Error("Failed pattern match at Data.Enum (line 296, column 12 - line 298, column 33): " + [ v.constructor.name ]);
402 };
403 while (!$tco_done) {
404 $tco_result = $tco_loop($tco_var_i, $copy_x);
405 };
406 return $tco_result;
407 };
408 };
409 var $171 = i$prime < 0;
410 if ($171) {
411 return Data_Maybe.Nothing.value;
412 };
413 return go(i$prime)(bottom2);
414 };
415 };
416};
417var defaultSucc = function (toEnum$prime) {
418 return function (fromEnum$prime) {
419 return function (a) {
420 return toEnum$prime(fromEnum$prime(a) + 1 | 0);
421 };
422 };
423};
424var defaultPred = function (toEnum$prime) {
425 return function (fromEnum$prime) {
426 return function (a) {
427 return toEnum$prime(fromEnum$prime(a) - 1 | 0);
428 };
429 };
430};
431var defaultFromEnum = function (dictEnum) {
432 var pred1 = pred(dictEnum);
433 var go = function ($copy_i) {
434 return function ($copy_x) {
435 var $tco_var_i = $copy_i;
436 var $tco_done = false;
437 var $tco_result;
438 function $tco_loop(i, x) {
439 var v = pred1(x);
440 if (v instanceof Data_Maybe.Just) {
441 $tco_var_i = i + 1 | 0;
442 $copy_x = v.value0;
443 return;
444 };
445 if (v instanceof Data_Maybe.Nothing) {
446 $tco_done = true;
447 return i;
448 };
449 throw new Error("Failed pattern match at Data.Enum (line 309, column 5 - line 311, column 19): " + [ v.constructor.name ]);
450 };
451 while (!$tco_done) {
452 $tco_result = $tco_loop($tco_var_i, $copy_x);
453 };
454 return $tco_result;
455 };
456 };
457 return go(0);
458};
459var defaultCardinality = function (dictBounded) {
460 var bottom2 = Data_Bounded.bottom(dictBounded);
461 return function (dictEnum) {
462 var succ1 = succ(dictEnum);
463 var go = function ($copy_i) {
464 return function ($copy_x) {
465 var $tco_var_i = $copy_i;
466 var $tco_done = false;
467 var $tco_result;
468 function $tco_loop(i, x) {
469 var v = succ1(x);
470 if (v instanceof Data_Maybe.Just) {
471 $tco_var_i = i + 1 | 0;
472 $copy_x = v.value0;
473 return;
474 };
475 if (v instanceof Data_Maybe.Nothing) {
476 $tco_done = true;
477 return i;
478 };
479 throw new Error("Failed pattern match at Data.Enum (line 276, column 5 - line 278, column 19): " + [ v.constructor.name ]);
480 };
481 while (!$tco_done) {
482 $tco_result = $tco_loop($tco_var_i, $copy_x);
483 };
484 return $tco_result;
485 };
486 };
487 return go(1)(bottom2);
488 };
489};
490var charToEnum = function (v) {
491 if (v >= $foreign.toCharCode(bottom1) && v <= $foreign.toCharCode(top1)) {
492 return new Data_Maybe.Just($foreign.fromCharCode(v));
493 };
494 return Data_Maybe.Nothing.value;
495};
496var enumChar = {
497 succ: /* #__PURE__ */ defaultSucc(charToEnum)($foreign.toCharCode),
498 pred: /* #__PURE__ */ defaultPred(charToEnum)($foreign.toCharCode),
499 Ord0: function () {
500 return Data_Ord.ordChar;
501 }
502};
503var cardinality = function (dict) {
504 return dict.cardinality;
505};
506var boundedEnumUnit = {
507 cardinality: 1,
508 toEnum: function (v) {
509 if (v === 0) {
510 return new Data_Maybe.Just(Data_Unit.unit);
511 };
512 return Data_Maybe.Nothing.value;
513 },
514 fromEnum: /* #__PURE__ */ Data_Function["const"](0),
515 Bounded0: function () {
516 return Data_Bounded.boundedUnit;
517 },
518 Enum1: function () {
519 return enumUnit;
520 }
521};
522var boundedEnumOrdering = {
523 cardinality: 3,
524 toEnum: function (v) {
525 if (v === 0) {
526 return new Data_Maybe.Just(Data_Ordering.LT.value);
527 };
528 if (v === 1) {
529 return new Data_Maybe.Just(Data_Ordering.EQ.value);
530 };
531 if (v === 2) {
532 return new Data_Maybe.Just(Data_Ordering.GT.value);
533 };
534 return Data_Maybe.Nothing.value;
535 },
536 fromEnum: function (v) {
537 if (v instanceof Data_Ordering.LT) {
538 return 0;
539 };
540 if (v instanceof Data_Ordering.EQ) {
541 return 1;
542 };
543 if (v instanceof Data_Ordering.GT) {
544 return 2;
545 };
546 throw new Error("Failed pattern match at Data.Enum (line 137, column 1 - line 145, column 18): " + [ v.constructor.name ]);
547 },
548 Bounded0: function () {
549 return Data_Bounded.boundedOrdering;
550 },
551 Enum1: function () {
552 return enumOrdering;
553 }
554};
555var boundedEnumChar = /* #__PURE__ */ (function () {
556 return {
557 cardinality: $foreign.toCharCode(top1) - $foreign.toCharCode(bottom1) | 0,
558 toEnum: charToEnum,
559 fromEnum: $foreign.toCharCode,
560 Bounded0: function () {
561 return Data_Bounded.boundedChar;
562 },
563 Enum1: function () {
564 return enumChar;
565 }
566 };
567})();
568var boundedEnumBoolean = {
569 cardinality: 2,
570 toEnum: function (v) {
571 if (v === 0) {
572 return new Data_Maybe.Just(false);
573 };
574 if (v === 1) {
575 return new Data_Maybe.Just(true);
576 };
577 return Data_Maybe.Nothing.value;
578 },
579 fromEnum: function (v) {
580 if (!v) {
581 return 0;
582 };
583 if (v) {
584 return 1;
585 };
586 throw new Error("Failed pattern match at Data.Enum (line 118, column 1 - line 124, column 20): " + [ v.constructor.name ]);
587 },
588 Bounded0: function () {
589 return Data_Bounded.boundedBoolean;
590 },
591 Enum1: function () {
592 return enumBoolean;
593 }
594};
595export {
596 succ,
597 pred,
598 cardinality,
599 toEnum,
600 fromEnum,
601 toEnumWithDefaults,
602 Cardinality,
603 enumFromTo,
604 enumFromThenTo,
605 upFrom,
606 upFromIncluding,
607 downFrom,
608 downFromIncluding,
609 defaultSucc,
610 defaultPred,
611 defaultCardinality,
612 defaultToEnum,
613 defaultFromEnum,
614 enumBoolean,
615 enumInt,
616 enumChar,
617 enumUnit,
618 enumOrdering,
619 enumMaybe,
620 enumEither,
621 enumTuple,
622 boundedEnumBoolean,
623 boundedEnumChar,
624 boundedEnumUnit,
625 boundedEnumOrdering,
626 newtypeCardinality,
627 eqCardinality,
628 ordCardinality,
629 showCardinality
630};
631//# sourceMappingURL=index.js.map