git.iko.soy/rowtype-yoga/yoga-r3f
on main help sign in
rowtype-yoga/yoga-r3f/output/Control.Parallel.Class/index.js
327 lines 13 kB history raw
1// Generated by purs version 0.15.16
2import * as Control_Applicative from "../Control.Applicative/index.js";
3import * as Control_Bind from "../Control.Bind/index.js";
4import * as Control_Monad_Cont_Trans from "../Control.Monad.Cont.Trans/index.js";
5import * as Control_Monad_Except_Trans from "../Control.Monad.Except.Trans/index.js";
6import * as Control_Monad_Maybe_Trans from "../Control.Monad.Maybe.Trans/index.js";
7import * as Control_Monad_Reader_Trans from "../Control.Monad.Reader.Trans/index.js";
8import * as Control_Monad_Writer_Trans from "../Control.Monad.Writer.Trans/index.js";
9import * as Data_Either from "../Data.Either/index.js";
10import * as Data_Functor from "../Data.Functor/index.js";
11import * as Data_Functor_Compose from "../Data.Functor.Compose/index.js";
12import * as Data_Functor_Costar from "../Data.Functor.Costar/index.js";
13import * as Data_Maybe from "../Data.Maybe/index.js";
14import * as Data_Profunctor_Star from "../Data.Profunctor.Star/index.js";
15import * as Data_Unit from "../Data.Unit/index.js";
16import * as Effect_Class from "../Effect.Class/index.js";
17import * as Effect_Ref from "../Effect.Ref/index.js";
18var discard = /* #__PURE__ */ Control_Bind.discard(Control_Bind.discardUnit);
19var ParCont = function (x) {
20 return x;
21};
22var sequential = function (dict) {
23 return dict.sequential;
24};
25var parallel = function (dict) {
26 return dict.parallel;
27};
28var newtypeParCont = {
29 Coercible0: function () {
30 return undefined;
31 }
32};
33var monadParWriterT = function (dictMonoid) {
34 var applyWriterT = Control_Monad_Writer_Trans.applyWriterT(dictMonoid.Semigroup0());
35 return function (dictParallel) {
36 var applyWriterT1 = applyWriterT(dictParallel.Apply0());
37 var applyWriterT2 = applyWriterT(dictParallel.Apply1());
38 return {
39 parallel: Control_Monad_Writer_Trans.mapWriterT(parallel(dictParallel)),
40 sequential: Control_Monad_Writer_Trans.mapWriterT(sequential(dictParallel)),
41 Apply0: function () {
42 return applyWriterT1;
43 },
44 Apply1: function () {
45 return applyWriterT2;
46 }
47 };
48 };
49};
50var monadParStar = function (dictParallel) {
51 var parallel1 = parallel(dictParallel);
52 var sequential1 = sequential(dictParallel);
53 var applyStar = Data_Profunctor_Star.applyStar(dictParallel.Apply0());
54 var applyStar1 = Data_Profunctor_Star.applyStar(dictParallel.Apply1());
55 return {
56 parallel: function (v) {
57 return function ($124) {
58 return parallel1(v($124));
59 };
60 },
61 sequential: function (v) {
62 return function ($125) {
63 return sequential1(v($125));
64 };
65 },
66 Apply0: function () {
67 return applyStar;
68 },
69 Apply1: function () {
70 return applyStar1;
71 }
72 };
73};
74var monadParReaderT = function (dictParallel) {
75 var applyReaderT = Control_Monad_Reader_Trans.applyReaderT(dictParallel.Apply0());
76 var applyReaderT1 = Control_Monad_Reader_Trans.applyReaderT(dictParallel.Apply1());
77 return {
78 parallel: Control_Monad_Reader_Trans.mapReaderT(parallel(dictParallel)),
79 sequential: Control_Monad_Reader_Trans.mapReaderT(sequential(dictParallel)),
80 Apply0: function () {
81 return applyReaderT;
82 },
83 Apply1: function () {
84 return applyReaderT1;
85 }
86 };
87};
88var monadParMaybeT = function (dictParallel) {
89 var parallel1 = parallel(dictParallel);
90 var sequential1 = sequential(dictParallel);
91 var applyCompose = Data_Functor_Compose.applyCompose(dictParallel.Apply1())(Data_Maybe.applyMaybe);
92 return function (dictMonad) {
93 var applyMaybeT = Control_Monad_Maybe_Trans.applyMaybeT(dictMonad);
94 return {
95 parallel: function (v) {
96 return parallel1(v);
97 },
98 sequential: function (v) {
99 return sequential1(v);
100 },
101 Apply0: function () {
102 return applyMaybeT;
103 },
104 Apply1: function () {
105 return applyCompose;
106 }
107 };
108 };
109};
110var monadParExceptT = function (dictParallel) {
111 var parallel1 = parallel(dictParallel);
112 var sequential1 = sequential(dictParallel);
113 var applyCompose = Data_Functor_Compose.applyCompose(dictParallel.Apply1())(Data_Either.applyEither);
114 return function (dictMonad) {
115 var applyExceptT = Control_Monad_Except_Trans.applyExceptT(dictMonad);
116 return {
117 parallel: function (v) {
118 return parallel1(v);
119 },
120 sequential: function (v) {
121 return sequential1(v);
122 },
123 Apply0: function () {
124 return applyExceptT;
125 },
126 Apply1: function () {
127 return applyCompose;
128 }
129 };
130 };
131};
132var monadParCostar = function (dictParallel) {
133 var sequential1 = sequential(dictParallel);
134 var parallel1 = parallel(dictParallel);
135 return {
136 parallel: function (v) {
137 return function ($126) {
138 return v(sequential1($126));
139 };
140 },
141 sequential: function (v) {
142 return function ($127) {
143 return v(parallel1($127));
144 };
145 },
146 Apply0: function () {
147 return Data_Functor_Costar.applyCostar;
148 },
149 Apply1: function () {
150 return Data_Functor_Costar.applyCostar;
151 }
152 };
153};
154var monadParParCont = function (dictMonadEffect) {
155 var applyContT = Control_Monad_Cont_Trans.applyContT(((dictMonadEffect.Monad0()).Bind1()).Apply0());
156 return {
157 parallel: ParCont,
158 sequential: function (v) {
159 return v;
160 },
161 Apply0: function () {
162 return applyContT;
163 },
164 Apply1: function () {
165 return applyParCont(dictMonadEffect);
166 }
167 };
168};
169var functorParCont = function (dictMonadEffect) {
170 var map = Data_Functor.map(Control_Monad_Cont_Trans.functorContT((((dictMonadEffect.Monad0()).Bind1()).Apply0()).Functor0()));
171 return {
172 map: function (f) {
173 var $128 = parallel(monadParParCont(dictMonadEffect));
174 var $129 = map(f);
175 var $130 = sequential(monadParParCont(dictMonadEffect));
176 return function ($131) {
177 return $128($129($130($131)));
178 };
179 }
180 };
181};
182var applyParCont = function (dictMonadEffect) {
183 var Bind1 = (dictMonadEffect.Monad0()).Bind1();
184 var bind = Control_Bind.bind(Bind1);
185 var liftEffect = Effect_Class.liftEffect(dictMonadEffect);
186 var discard1 = discard(Bind1);
187 return {
188 apply: function (v) {
189 return function (v1) {
190 return function (k) {
191 return bind(liftEffect(Effect_Ref["new"](Data_Maybe.Nothing.value)))(function (ra) {
192 return bind(liftEffect(Effect_Ref["new"](Data_Maybe.Nothing.value)))(function (rb) {
193 return discard1(Control_Monad_Cont_Trans.runContT(v)(function (a) {
194 return bind(liftEffect(Effect_Ref.read(rb)))(function (mb) {
195 if (mb instanceof Data_Maybe.Nothing) {
196 return liftEffect(Effect_Ref.write(new Data_Maybe.Just(a))(ra));
197 };
198 if (mb instanceof Data_Maybe.Just) {
199 return k(a(mb.value0));
200 };
201 throw new Error("Failed pattern match at Control.Parallel.Class (line 83, column 7 - line 85, column 26): " + [ mb.constructor.name ]);
202 });
203 }))(function () {
204 return Control_Monad_Cont_Trans.runContT(v1)(function (b) {
205 return bind(liftEffect(Effect_Ref.read(ra)))(function (ma) {
206 if (ma instanceof Data_Maybe.Nothing) {
207 return liftEffect(Effect_Ref.write(new Data_Maybe.Just(b))(rb));
208 };
209 if (ma instanceof Data_Maybe.Just) {
210 return k(ma.value0(b));
211 };
212 throw new Error("Failed pattern match at Control.Parallel.Class (line 89, column 7 - line 91, column 26): " + [ ma.constructor.name ]);
213 });
214 });
215 });
216 });
217 });
218 };
219 };
220 },
221 Functor0: function () {
222 return functorParCont(dictMonadEffect);
223 }
224 };
225};
226var applicativeParCont = function (dictMonadEffect) {
227 var applyParCont1 = applyParCont(dictMonadEffect);
228 return {
229 pure: (function () {
230 var $132 = parallel(monadParParCont(dictMonadEffect));
231 var $133 = Control_Applicative.pure(Control_Monad_Cont_Trans.applicativeContT((dictMonadEffect.Monad0()).Applicative0()));
232 return function ($134) {
233 return $132($133($134));
234 };
235 })(),
236 Apply0: function () {
237 return applyParCont1;
238 }
239 };
240};
241var altParCont = function (dictMonadEffect) {
242 var Monad0 = dictMonadEffect.Monad0();
243 var Bind1 = Monad0.Bind1();
244 var bind = Control_Bind.bind(Bind1);
245 var liftEffect = Effect_Class.liftEffect(dictMonadEffect);
246 var discard1 = discard(Bind1);
247 var pure = Control_Applicative.pure(Monad0.Applicative0());
248 var functorParCont1 = functorParCont(dictMonadEffect);
249 return {
250 alt: function (v) {
251 return function (v1) {
252 return function (k) {
253 return bind(liftEffect(Effect_Ref["new"](false)))(function (done) {
254 return discard1(Control_Monad_Cont_Trans.runContT(v)(function (a) {
255 return bind(liftEffect(Effect_Ref.read(done)))(function (b) {
256 if (b) {
257 return pure(Data_Unit.unit);
258 };
259 return discard1(liftEffect(Effect_Ref.write(true)(done)))(function () {
260 return k(a);
261 });
262 });
263 }))(function () {
264 return Control_Monad_Cont_Trans.runContT(v1)(function (a) {
265 return bind(liftEffect(Effect_Ref.read(done)))(function (b) {
266 if (b) {
267 return pure(Data_Unit.unit);
268 };
269 return discard1(liftEffect(Effect_Ref.write(true)(done)))(function () {
270 return k(a);
271 });
272 });
273 });
274 });
275 });
276 };
277 };
278 },
279 Functor0: function () {
280 return functorParCont1;
281 }
282 };
283};
284var plusParCont = function (dictMonadEffect) {
285 var pure = Control_Applicative.pure((dictMonadEffect.Monad0()).Applicative0());
286 var altParCont1 = altParCont(dictMonadEffect);
287 return {
288 empty: function (v) {
289 return pure(Data_Unit.unit);
290 },
291 Alt0: function () {
292 return altParCont1;
293 }
294 };
295};
296var alternativeParCont = function (dictMonadEffect) {
297 var applicativeParCont1 = applicativeParCont(dictMonadEffect);
298 var plusParCont1 = plusParCont(dictMonadEffect);
299 return {
300 Applicative0: function () {
301 return applicativeParCont1;
302 },
303 Plus1: function () {
304 return plusParCont1;
305 }
306 };
307};
308export {
309 parallel,
310 sequential,
311 ParCont,
312 monadParExceptT,
313 monadParReaderT,
314 monadParWriterT,
315 monadParMaybeT,
316 monadParStar,
317 monadParCostar,
318 newtypeParCont,
319 functorParCont,
320 applyParCont,
321 applicativeParCont,
322 altParCont,
323 plusParCont,
324 alternativeParCont,
325 monadParParCont
326};
327//# sourceMappingURL=index.js.map