git.iko.soy/rowtype-yoga/yoga-r3f
on main help sign in
rowtype-yoga/yoga-r3f/output/Data.Lens.Fold/index.js
525 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_Category from "../Control.Category/index.js";
5import * as Data_Array from "../Data.Array/index.js";
6import * as Data_Either from "../Data.Either/index.js";
7import * as Data_Eq from "../Data.Eq/index.js";
8import * as Data_Foldable from "../Data.Foldable/index.js";
9import * as Data_Function from "../Data.Function/index.js";
10import * as Data_Functor from "../Data.Functor/index.js";
11import * as Data_HeytingAlgebra from "../Data.HeytingAlgebra/index.js";
12import * as Data_Lens_Internal_Forget from "../Data.Lens.Internal.Forget/index.js";
13import * as Data_Lens_Types from "../Data.Lens.Types/index.js";
14import * as Data_List_Types from "../Data.List.Types/index.js";
15import * as Data_Maybe from "../Data.Maybe/index.js";
16import * as Data_Maybe_First from "../Data.Maybe.First/index.js";
17import * as Data_Maybe_Last from "../Data.Maybe.Last/index.js";
18import * as Data_Monoid from "../Data.Monoid/index.js";
19import * as Data_Monoid_Additive from "../Data.Monoid.Additive/index.js";
20import * as Data_Monoid_Conj from "../Data.Monoid.Conj/index.js";
21import * as Data_Monoid_Disj from "../Data.Monoid.Disj/index.js";
22import * as Data_Monoid_Dual from "../Data.Monoid.Dual/index.js";
23import * as Data_Monoid_Endo from "../Data.Monoid.Endo/index.js";
24import * as Data_Monoid_Multiplicative from "../Data.Monoid.Multiplicative/index.js";
25import * as Data_Newtype from "../Data.Newtype/index.js";
26import * as Data_Ord from "../Data.Ord/index.js";
27import * as Data_Profunctor from "../Data.Profunctor/index.js";
28import * as Data_Profunctor_Choice from "../Data.Profunctor.Choice/index.js";
29import * as Data_Semigroup from "../Data.Semigroup/index.js";
30import * as Data_Tuple from "../Data.Tuple/index.js";
31import * as Data_Unit from "../Data.Unit/index.js";
32var $runtime_lazy = function (name, moduleName, init) {
33 var state = 0;
34 var val;
35 return function (lineNumber) {
36 if (state === 2) return val;
37 if (state === 1) throw new ReferenceError(name + " was needed before it finished initializing (module " + moduleName + ", line " + lineNumber + ")", moduleName, lineNumber);
38 state = 1;
39 val = init();
40 state = 2;
41 return val;
42 };
43};
44var unwrap = /* #__PURE__ */ Data_Newtype.unwrap();
45var identity = /* #__PURE__ */ Control_Category.identity(Control_Category.categoryFn);
46var fromFoldable = /* #__PURE__ */ Data_Array.fromFoldable(Data_List_Types.foldableList);
47var unfolded = function (dictMonoid) {
48 var mempty = Data_Monoid.mempty(dictMonoid);
49 var append = Data_Semigroup.append(dictMonoid.Semigroup0());
50 return function (f) {
51 return function (p) {
52 var $lazy_go = $runtime_lazy("go", "Data.Lens.Fold", function () {
53 var $89 = Data_Maybe.maybe(mempty)(function (v) {
54 return append(unwrap(p)(v.value0))($lazy_go(232)(v.value1));
55 });
56 return function ($90) {
57 return $89(f($90));
58 };
59 });
60 var go = $lazy_go(232);
61 return go;
62 };
63 };
64};
65var replicated = function (dictMonoid) {
66 var mempty = Data_Monoid.mempty(Data_Monoid.monoidFn(dictMonoid));
67 var append = Data_Semigroup.append(Data_Semigroup.semigroupFn(dictMonoid.Semigroup0()));
68 return function (i) {
69 return function (v) {
70 var go = function (v1) {
71 return function (v2) {
72 if (v1 === 0) {
73 return mempty;
74 };
75 return append(v2)(go(v1 - 1 | 0)(v2));
76 };
77 };
78 return go(i)(v);
79 };
80 };
81};
82var ifoldMapOf = function (p) {
83 return function (f) {
84 return unwrap(p(Data_Tuple.uncurry(f)));
85 };
86};
87var ifoldlOf = function (p) {
88 return function (f) {
89 return function (r) {
90 var $91 = Data_Function.flip(unwrap)(r);
91 var $92 = ifoldMapOf(p)(function (i) {
92 var $94 = Data_Function.flip(f(i));
93 return function ($95) {
94 return Data_Monoid_Dual.Dual(Data_Monoid_Endo.Endo($94($95)));
95 };
96 });
97 return function ($93) {
98 return $91(unwrap($92($93)));
99 };
100 };
101 };
102};
103var ifoldrOf = function (p) {
104 return function (f) {
105 return function (r) {
106 var $96 = Data_Function.flip(unwrap)(r);
107 var $97 = ifoldMapOf(p)(function (i) {
108 var $99 = f(i);
109 return function ($100) {
110 return Data_Monoid_Endo.Endo($99($100));
111 };
112 });
113 return function ($98) {
114 return $96($97($98));
115 };
116 };
117 };
118};
119var itoListOf = function (p) {
120 return ifoldrOf(p)(function (i) {
121 return function (x) {
122 return function (xs) {
123 return new Data_List_Types.Cons(new Data_Tuple.Tuple(i, x), xs);
124 };
125 };
126 })(Data_List_Types.Nil.value);
127};
128var itraverseOf_ = function (dictApplicative) {
129 var Apply0 = dictApplicative.Apply0();
130 var applySecond = Control_Apply.applySecond(Apply0);
131 var $$void = Data_Functor["void"](Apply0.Functor0());
132 var pure = Control_Applicative.pure(dictApplicative);
133 return function (p) {
134 return function (f) {
135 return ifoldrOf(p)(function (i) {
136 return function (a) {
137 return function (fu) {
138 return applySecond($$void(f(i)(a)))(fu);
139 };
140 };
141 })(pure(Data_Unit.unit));
142 };
143 };
144};
145var iforOf_ = function (dictApplicative) {
146 var $101 = itraverseOf_(dictApplicative);
147 return function ($102) {
148 return Data_Function.flip($101($102));
149 };
150};
151var ifindOf = function (p) {
152 return function (f) {
153 return ifoldrOf(p)(function (i) {
154 return function (a) {
155 return Data_Maybe.maybe((function () {
156 var $83 = f(i)(a);
157 if ($83) {
158 return new Data_Maybe.Just(a);
159 };
160 return Data_Maybe.Nothing.value;
161 })())(Data_Maybe.Just.create);
162 };
163 })(Data_Maybe.Nothing.value);
164 };
165};
166var ianyOf = function (dictHeytingAlgebra) {
167 return function (p) {
168 return function (f) {
169 var $103 = ifoldMapOf(p)(function (i) {
170 var $105 = f(i);
171 return function ($106) {
172 return Data_Monoid_Disj.Disj($105($106));
173 };
174 });
175 return function ($104) {
176 return unwrap($103($104));
177 };
178 };
179 };
180};
181var iallOf = function (dictHeytingAlgebra) {
182 return function (p) {
183 return function (f) {
184 var $107 = ifoldMapOf(p)(function (i) {
185 var $109 = f(i);
186 return function ($110) {
187 return Data_Monoid_Conj.Conj($109($110));
188 };
189 });
190 return function ($108) {
191 return unwrap($107($108));
192 };
193 };
194 };
195};
196var folded = function (dictMonoid) {
197 return function (dictFoldable) {
198 var foldMap = Data_Foldable.foldMap(dictFoldable)(dictMonoid);
199 return function (v) {
200 return foldMap(v);
201 };
202 };
203};
204var foldMapOf = /* #__PURE__ */ Data_Newtype.under()()(Data_Lens_Internal_Forget.Forget);
205var foldOf = function (p) {
206 return foldMapOf(p)(identity);
207};
208var foldlOf = function (p) {
209 return function (f) {
210 return function (r) {
211 var $111 = Data_Function.flip(unwrap)(r);
212 var $112 = foldMapOf(p)((function () {
213 var $114 = Data_Function.flip(f);
214 return function ($115) {
215 return Data_Monoid_Dual.Dual(Data_Monoid_Endo.Endo($114($115)));
216 };
217 })());
218 return function ($113) {
219 return $111(unwrap($112($113)));
220 };
221 };
222 };
223};
224var foldrOf = function (p) {
225 return function (f) {
226 return function (r) {
227 var $116 = Data_Function.flip(unwrap)(r);
228 var $117 = foldMapOf(p)(function ($119) {
229 return Data_Monoid_Endo.Endo(f($119));
230 });
231 return function ($118) {
232 return $116($117($118));
233 };
234 };
235 };
236};
237var maximumOf = function (dictOrd) {
238 var greaterThan = Data_Ord.greaterThan(dictOrd);
239 return function (p) {
240 var max = function (a) {
241 return function (b) {
242 var $85 = greaterThan(a)(b);
243 if ($85) {
244 return a;
245 };
246 return b;
247 };
248 };
249 return foldrOf(p)(function (a) {
250 var $120 = Data_Maybe.maybe(a)(max(a));
251 return function ($121) {
252 return Data_Maybe.Just.create($120($121));
253 };
254 })(Data_Maybe.Nothing.value);
255 };
256};
257var minimumOf = function (dictOrd) {
258 var lessThan = Data_Ord.lessThan(dictOrd);
259 return function (p) {
260 var min = function (a) {
261 return function (b) {
262 var $86 = lessThan(a)(b);
263 if ($86) {
264 return a;
265 };
266 return b;
267 };
268 };
269 return foldrOf(p)(function (a) {
270 var $122 = Data_Maybe.maybe(a)(min(a));
271 return function ($123) {
272 return Data_Maybe.Just.create($122($123));
273 };
274 })(Data_Maybe.Nothing.value);
275 };
276};
277var toListOf = function (p) {
278 return foldrOf(p)(Data_List_Types.Cons.create)(Data_List_Types.Nil.value);
279};
280var toArrayOf = function (p) {
281 var $124 = toListOf(p);
282 return function ($125) {
283 return fromFoldable($124($125));
284 };
285};
286var toArrayOfOn = function (s) {
287 return function (p) {
288 return toArrayOf(p)(s);
289 };
290};
291var toListOfOn = function (s) {
292 return function (p) {
293 return toListOf(p)(s);
294 };
295};
296var traverseOf_ = function (dictApplicative) {
297 var Apply0 = dictApplicative.Apply0();
298 var applySecond = Control_Apply.applySecond(Apply0);
299 var $$void = Data_Functor["void"](Apply0.Functor0());
300 var pure = Control_Applicative.pure(dictApplicative);
301 return function (p) {
302 return function (f) {
303 return foldrOf(p)(function (a) {
304 return function (fu) {
305 return applySecond($$void(f(a)))(fu);
306 };
307 })(pure(Data_Unit.unit));
308 };
309 };
310};
311var has = function (dictHeytingAlgebra) {
312 var tt = Data_HeytingAlgebra.tt(dictHeytingAlgebra);
313 return function (p) {
314 var $126 = foldMapOf(p)(Data_Function["const"](tt));
315 return function ($127) {
316 return unwrap($126($127));
317 };
318 };
319};
320var hasn$primet = function (dictHeytingAlgebra) {
321 var ff = Data_HeytingAlgebra.ff(dictHeytingAlgebra);
322 return function (p) {
323 var $128 = foldMapOf(p)(Data_Function["const"](ff));
324 return function ($129) {
325 return unwrap($128($129));
326 };
327 };
328};
329var lastOf = function (p) {
330 var $130 = foldMapOf(p)(function ($132) {
331 return Data_Maybe_Last.Last(Data_Maybe.Just.create($132));
332 });
333 return function ($131) {
334 return unwrap($130($131));
335 };
336};
337var lengthOf = function (p) {
338 var $133 = foldMapOf(p)(Data_Function["const"](1));
339 return function ($134) {
340 return unwrap($133($134));
341 };
342};
343var preview = function (p) {
344 var $135 = foldMapOf(p)(function ($137) {
345 return Data_Maybe_First.First(Data_Maybe.Just.create($137));
346 });
347 return function ($136) {
348 return unwrap($135($136));
349 };
350};
351var previewOn = function (s) {
352 return function (p) {
353 return preview(p)(s);
354 };
355};
356var productOf = function (dictSemiring) {
357 return function (p) {
358 var $138 = foldMapOf(p)(Data_Monoid_Multiplicative.Multiplicative);
359 return function ($139) {
360 return unwrap($138($139));
361 };
362 };
363};
364var sequenceOf_ = function (dictApplicative) {
365 var pure = Control_Applicative.pure(dictApplicative);
366 var applySecond = Control_Apply.applySecond(dictApplicative.Apply0());
367 return function (p) {
368 var $140 = Data_Function.flip(unwrap)(pure(Data_Unit.unit));
369 var $141 = foldMapOf(p)(function (f) {
370 return function (v) {
371 return applySecond(f)(v);
372 };
373 });
374 return function ($142) {
375 return $140($141($142));
376 };
377 };
378};
379var sumOf = function (dictSemiring) {
380 return function (p) {
381 var $143 = foldMapOf(p)(Data_Monoid_Additive.Additive);
382 return function ($144) {
383 return unwrap($143($144));
384 };
385 };
386};
387var firstOf = function (p) {
388 var $145 = foldMapOf(p)(function ($147) {
389 return Data_Maybe_First.First(Data_Maybe.Just.create($147));
390 });
391 return function ($146) {
392 return unwrap($145($146));
393 };
394};
395var findOf = function (p) {
396 return function (f) {
397 return foldrOf(p)(function (a) {
398 return Data_Maybe.maybe((function () {
399 var $87 = f(a);
400 if ($87) {
401 return new Data_Maybe.Just(a);
402 };
403 return Data_Maybe.Nothing.value;
404 })())(Data_Maybe.Just.create);
405 })(Data_Maybe.Nothing.value);
406 };
407};
408var filtered = function (dictChoice) {
409 var right = Data_Profunctor_Choice.right(dictChoice);
410 var dimap = Data_Profunctor.dimap(dictChoice.Profunctor0());
411 return function (f) {
412 var $148 = dimap(function (x) {
413 var $88 = f(x);
414 if ($88) {
415 return new Data_Either.Right(x);
416 };
417 return new Data_Either.Left(x);
418 })(Data_Either.either(identity)(identity));
419 return function ($149) {
420 return $148(right($149));
421 };
422 };
423};
424var anyOf = function (dictHeytingAlgebra) {
425 return function (p) {
426 return function (f) {
427 var $150 = foldMapOf(p)(function ($152) {
428 return Data_Monoid_Disj.Disj(f($152));
429 });
430 return function ($151) {
431 return unwrap($150($151));
432 };
433 };
434 };
435};
436var anyOf1 = /* #__PURE__ */ anyOf(Data_HeytingAlgebra.heytingAlgebraBoolean);
437var elemOf = function (dictEq) {
438 var eq = Data_Eq.eq(dictEq);
439 return function (p) {
440 return function (a) {
441 return anyOf1(p)(function (v) {
442 return eq(v)(a);
443 });
444 };
445 };
446};
447var orOf = function (dictHeytingAlgebra) {
448 var anyOf2 = anyOf(dictHeytingAlgebra);
449 return function (p) {
450 return anyOf2(p)(identity);
451 };
452};
453var allOf = function (dictHeytingAlgebra) {
454 return function (p) {
455 return function (f) {
456 var $153 = foldMapOf(p)(function ($155) {
457 return Data_Monoid_Conj.Conj(f($155));
458 });
459 return function ($154) {
460 return unwrap($153($154));
461 };
462 };
463 };
464};
465var allOf1 = /* #__PURE__ */ allOf(Data_HeytingAlgebra.heytingAlgebraBoolean);
466var andOf = function (dictHeytingAlgebra) {
467 var allOf2 = allOf(dictHeytingAlgebra);
468 return function (p) {
469 return allOf2(p)(identity);
470 };
471};
472var notElemOf = function (dictEq) {
473 var notEq = Data_Eq.notEq(dictEq);
474 return function (p) {
475 return function (a) {
476 return allOf1(p)(function (v) {
477 return notEq(v)(a);
478 });
479 };
480 };
481};
482export {
483 previewOn,
484 toListOfOn,
485 preview,
486 foldOf,
487 foldMapOf,
488 foldrOf,
489 foldlOf,
490 toListOf,
491 firstOf,
492 lastOf,
493 maximumOf,
494 minimumOf,
495 allOf,
496 anyOf,
497 andOf,
498 orOf,
499 elemOf,
500 notElemOf,
501 sumOf,
502 productOf,
503 lengthOf,
504 findOf,
505 sequenceOf_,
506 traverseOf_,
507 has,
508 hasn$primet,
509 replicated,
510 filtered,
511 folded,
512 unfolded,
513 toArrayOf,
514 toArrayOfOn,
515 ifoldMapOf,
516 ifoldrOf,
517 ifoldlOf,
518 iallOf,
519 ianyOf,
520 ifindOf,
521 itoListOf,
522 itraverseOf_,
523 iforOf_
524};
525//# sourceMappingURL=index.js.map