]> Git — Sourcephile - haskell/symantic-parser.git/blob - test/Golden/Splice/G14.expected.txt
sourcephile / git / haskell / symantic-parser.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
rename Symantic.{Univariant => Typed}
[haskell/symantic-parser.git] / test / Golden / Splice / G14.expected.txt
1 \(input :: inp) ->
2 let !(#
3 init,
4 readMore,
5 readNext
6 #) =
7 let _ = "cursorOf"
8 in let next
9 ( t@( Data.Text.Internal.Text
10 arr
11 off
12 unconsumed
13 )
14 ) =
15 let !( Data.Text.Unsafe.Iter
16 c
17 d
18 ) = Data.Text.Unsafe.iter t 0
19 in (#
20 c,
21 Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)
22 #)
23 more
24 ( Data.Text.Internal.Text
25 _
26 _
27 unconsumed
28 ) = unconsumed GHC.Classes.> 0
29 in (# input, more, next #)
30 finalRet = \_farInp _farExp v _inp -> Data.Either.Right v
31 finalRaise ::
32 forall b.
33 Symantic.Parser.Machine.Generate.Catcher
34 inp
35 b = \(!exn) _failInp (!farInp) (!farExp) ->
36 Data.Either.Left
37 Symantic.Parser.Machine.Generate.ParsingErrorStandard
38 { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,
39 Symantic.Parser.Machine.Generate.parsingErrorException = exn,
40 Symantic.Parser.Machine.Generate.parsingErrorUnexpected =
41 if readMore farInp
42 then
43 GHC.Maybe.Just
44 ( let (#
45 c,
46 _
47 #) = readNext farInp
48 in c
49 )
50 else GHC.Maybe.Nothing,
51 Symantic.Parser.Machine.Generate.parsingErrorExpecting = farExp
52 }
53 in let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)
54 in let name = \(!ok) (!inp) (!koByLabel) ->
55 name
56 ( let _ = "suspend"
57 in \farInp farExp v (!inp) ->
58 name
59 ( let _ = "suspend"
60 in \farInp farExp v (!inp) ->
61 name
62 ( let _ = "suspend"
63 in \farInp farExp v (!inp) ->
64 name
65 ( let _ = "suspend"
66 in \farInp farExp v (!inp) ->
67 let _ = "resume"
68 in ok
69 farInp
70 farExp
71 ( let _ = "resume.genCode"
72 in v
73 )
74 inp
75 )
76 inp
77 Data.Map.Internal.Tip
78 )
79 inp
80 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)
81 )
82 inp
83 Data.Map.Internal.Tip
84 )
85 inp
86 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)
87 name = \(!ok) (!inp) (!koByLabel) ->
88 name
89 ( let _ = "suspend"
90 in \farInp farExp v (!inp) ->
91 name
92 ( let _ = "suspend"
93 in \farInp farExp v (!inp) ->
94 let _ = "resume"
95 in ok
96 farInp
97 farExp
98 ( let _ = "resume.genCode"
99 in GHC.Tuple . ()
100 )
101 inp
102 )
103 inp
104 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)
105 )
106 inp
107 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)
108 name = \(!ok) (!inp) (!koByLabel) ->
109 name
110 ( let _ = "suspend"
111 in \farInp farExp v (!inp) ->
112 let join = \farInp farExp v (!inp) ->
113 let _ = "resume"
114 in ok
115 farInp
116 farExp
117 ( let _ = "resume.genCode"
118 in v
119 )
120 inp
121 in let _ = "catch ExceptionFailure"
122 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
123 let _ = "catch.ko ExceptionFailure"
124 in if ( \( Data.Text.Internal.Text
125 _
126 i
127 _
128 )
129 ( Data.Text.Internal.Text
130 _
131 j
132 _
133 ) -> i GHC.Classes.== j
134 )
135 inp
136 failInp
137 then
138 let _ = "choicesBranch.then"
139 in name
140 ( let _ = "suspend"
141 in \farInp farExp v (!inp) ->
142 let _ = "resume"
143 in join
144 farInp
145 farExp
146 ( let _ = "resume.genCode"
147 in v
148 )
149 inp
150 )
151 failInp
152 Data.Map.Internal.Tip
153 else
154 let _ = "choicesBranch.else"
155 in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
156 in name
157 ( let _ = "suspend"
158 in \farInp farExp v (!inp) ->
159 let _ = "resume"
160 in join
161 farInp
162 farExp
163 ( let _ = "resume.genCode"
164 in GHC.Tuple . ()
165 )
166 inp
167 )
168 inp
169 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
170 )
171 inp
172 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)
173 name = \(!ok) (!inp) (!koByLabel) ->
174 let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel
175 in if readMore inp
176 then
177 let !(#
178 c,
179 cs
180 #) = readNext inp
181 in if GHC.Unicode.isSpace c
182 then
183 name
184 ( let _ = "suspend"
185 in \farInp farExp v (!inp) ->
186 let _ = "resume"
187 in ok
188 farInp
189 farExp
190 ( let _ = "resume.genCode"
191 in v
192 )
193 inp
194 )
195 cs
196 Data.Map.Internal.Tip
197 else
198 let _ = "checkToken.else"
199 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp init Data.Set.Internal.empty
200 else
201 let _ = "checkHorizon.else"
202 in let failExp =
203 Data.Set.Internal.Bin
204 1
205 ( Symantic.Parser.Grammar.Combinators.SomeFailure
206 ( case inputToken of
207 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1
208 )
209 )
210 Data.Set.Internal.Tip
211 Data.Set.Internal.Tip
212 in let (#
213 farInp,
214 farExp
215 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
216 GHC.Types.LT ->
217 (#
218 inp,
219 failExp
220 #)
221 GHC.Types.EQ ->
222 (#
223 init,
224 failExp GHC.Base.<> Data.Set.Internal.empty
225 #)
226 GHC.Types.GT ->
227 (#
228 init,
229 Data.Set.Internal.empty
230 #)
231 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
232 name = \(!ok) (!inp) (!koByLabel) ->
233 let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel
234 in if readMore inp
235 then
236 let !(#
237 c,
238 cs
239 #) = readNext inp
240 in if (\t -> ('0' GHC.Classes.== t) GHC.Classes.|| (('1' GHC.Classes.== t) GHC.Classes.|| (('2' GHC.Classes.== t) GHC.Classes.|| (('3' GHC.Classes.== t) GHC.Classes.|| (('4' GHC.Classes.== t) GHC.Classes.|| (('5' GHC.Classes.== t) GHC.Classes.|| (('6' GHC.Classes.== t) GHC.Classes.|| (('7' GHC.Classes.== t) GHC.Classes.|| (('8' GHC.Classes.== t) GHC.Classes.|| (('9' GHC.Classes.== t) GHC.Classes.|| GHC.Types.False)))))))))) c
241 then
242 let _ = "resume"
243 in ok
244 init
245 Data.Set.Internal.empty
246 ( let _ = "resume.genCode"
247 in c
248 )
249 cs
250 else
251 let _ = "checkToken.else"
252 in let failExp =
253 Data.Set.Internal.Bin
254 1
255 ( Symantic.Parser.Grammar.Combinators.SomeFailure
256 ( case inputToken of
257 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '9'
258 )
259 )
260 Data.Set.Internal.Tip
261 Data.Set.Internal.Tip
262 in let (#
263 farInp,
264 farExp
265 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
266 GHC.Types.LT ->
267 (#
268 inp,
269 failExp
270 #)
271 GHC.Types.EQ ->
272 (#
273 init,
274 failExp GHC.Base.<> Data.Set.Internal.empty
275 #)
276 GHC.Types.GT ->
277 (#
278 init,
279 Data.Set.Internal.empty
280 #)
281 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
282 else
283 let _ = "checkHorizon.else"
284 in let failExp =
285 Data.Set.Internal.Bin
286 1
287 ( Symantic.Parser.Grammar.Combinators.SomeFailure
288 ( case inputToken of
289 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1
290 )
291 )
292 Data.Set.Internal.Tip
293 Data.Set.Internal.Tip
294 in let (#
295 farInp,
296 farExp
297 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
298 GHC.Types.LT ->
299 (#
300 inp,
301 failExp
302 #)
303 GHC.Types.EQ ->
304 (#
305 init,
306 failExp GHC.Base.<> Data.Set.Internal.empty
307 #)
308 GHC.Types.GT ->
309 (#
310 init,
311 Data.Set.Internal.empty
312 #)
313 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
314 name = \(!ok) (!inp) (!koByLabel) ->
315 let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel
316 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
317 then
318 let !(#
319 c,
320 cs
321 #) = readNext inp
322 in if (GHC.Classes.==) '(' c
323 then
324 name
325 ( let _ = "suspend"
326 in \farInp farExp v (!inp) ->
327 let _ = "resume"
328 in ok
329 farInp
330 farExp
331 ( let _ = "resume.genCode"
332 in '('
333 )
334 inp
335 )
336 cs
337 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
338 else
339 let _ = "checkToken.else"
340 in let failExp =
341 Data.Set.Internal.Bin
342 1
343 ( Symantic.Parser.Grammar.Combinators.SomeFailure
344 ( case inputToken of
345 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '('
346 )
347 )
348 Data.Set.Internal.Tip
349 Data.Set.Internal.Tip
350 in let (#
351 farInp,
352 farExp
353 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
354 GHC.Types.LT ->
355 (#
356 inp,
357 failExp
358 #)
359 GHC.Types.EQ ->
360 (#
361 init,
362 failExp GHC.Base.<> Data.Set.Internal.empty
363 #)
364 GHC.Types.GT ->
365 (#
366 init,
367 Data.Set.Internal.empty
368 #)
369 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
370 else
371 let _ = "checkHorizon.else"
372 in let failExp =
373 Data.Set.Internal.Bin
374 1
375 ( Symantic.Parser.Grammar.Combinators.SomeFailure
376 ( case inputToken of
377 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
378 )
379 )
380 Data.Set.Internal.Tip
381 Data.Set.Internal.Tip
382 in let (#
383 farInp,
384 farExp
385 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
386 GHC.Types.LT ->
387 (#
388 inp,
389 failExp
390 #)
391 GHC.Types.EQ ->
392 (#
393 init,
394 failExp GHC.Base.<> Data.Set.Internal.empty
395 #)
396 GHC.Types.GT ->
397 (#
398 init,
399 Data.Set.Internal.empty
400 #)
401 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
402 name = \(!ok) (!inp) (!koByLabel) ->
403 let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel
404 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
405 then
406 let !(#
407 c,
408 cs
409 #) = readNext inp
410 in if (GHC.Classes.==) ')' c
411 then
412 name
413 ( let _ = "suspend"
414 in \farInp farExp v (!inp) ->
415 let _ = "resume"
416 in ok
417 farInp
418 farExp
419 ( let _ = "resume.genCode"
420 in ')'
421 )
422 inp
423 )
424 cs
425 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
426 else
427 let _ = "checkToken.else"
428 in let failExp =
429 Data.Set.Internal.Bin
430 1
431 ( Symantic.Parser.Grammar.Combinators.SomeFailure
432 ( case inputToken of
433 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ')'
434 )
435 )
436 Data.Set.Internal.Tip
437 Data.Set.Internal.Tip
438 in let (#
439 farInp,
440 farExp
441 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
442 GHC.Types.LT ->
443 (#
444 inp,
445 failExp
446 #)
447 GHC.Types.EQ ->
448 (#
449 init,
450 failExp GHC.Base.<> Data.Set.Internal.empty
451 #)
452 GHC.Types.GT ->
453 (#
454 init,
455 Data.Set.Internal.empty
456 #)
457 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
458 else
459 let _ = "checkHorizon.else"
460 in let failExp =
461 Data.Set.Internal.Bin
462 1
463 ( Symantic.Parser.Grammar.Combinators.SomeFailure
464 ( case inputToken of
465 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
466 )
467 )
468 Data.Set.Internal.Tip
469 Data.Set.Internal.Tip
470 in let (#
471 farInp,
472 farExp
473 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
474 GHC.Types.LT ->
475 (#
476 inp,
477 failExp
478 #)
479 GHC.Types.EQ ->
480 (#
481 init,
482 failExp GHC.Base.<> Data.Set.Internal.empty
483 #)
484 GHC.Types.GT ->
485 (#
486 init,
487 Data.Set.Internal.empty
488 #)
489 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
490 name = \(!ok) (!inp) (!koByLabel) ->
491 let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel
492 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
493 then
494 let !(#
495 c,
496 cs
497 #) = readNext inp
498 in if (GHC.Classes.==) ',' c
499 then
500 name
501 ( let _ = "suspend"
502 in \farInp farExp v (!inp) ->
503 let _ = "resume"
504 in ok
505 farInp
506 farExp
507 ( let _ = "resume.genCode"
508 in ','
509 )
510 inp
511 )
512 cs
513 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
514 else
515 let _ = "checkToken.else"
516 in let failExp =
517 Data.Set.Internal.Bin
518 1
519 ( Symantic.Parser.Grammar.Combinators.SomeFailure
520 ( case inputToken of
521 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ','
522 )
523 )
524 Data.Set.Internal.Tip
525 Data.Set.Internal.Tip
526 in let (#
527 farInp,
528 farExp
529 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
530 GHC.Types.LT ->
531 (#
532 inp,
533 failExp
534 #)
535 GHC.Types.EQ ->
536 (#
537 init,
538 failExp GHC.Base.<> Data.Set.Internal.empty
539 #)
540 GHC.Types.GT ->
541 (#
542 init,
543 Data.Set.Internal.empty
544 #)
545 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
546 else
547 let _ = "checkHorizon.else"
548 in let failExp =
549 Data.Set.Internal.Bin
550 1
551 ( Symantic.Parser.Grammar.Combinators.SomeFailure
552 ( case inputToken of
553 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
554 )
555 )
556 Data.Set.Internal.Tip
557 Data.Set.Internal.Tip
558 in let (#
559 farInp,
560 farExp
561 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
562 GHC.Types.LT ->
563 (#
564 inp,
565 failExp
566 #)
567 GHC.Types.EQ ->
568 (#
569 init,
570 failExp GHC.Base.<> Data.Set.Internal.empty
571 #)
572 GHC.Types.GT ->
573 (#
574 init,
575 Data.Set.Internal.empty
576 #)
577 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
578 name = \(!ok) (!inp) (!koByLabel) ->
579 let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel
580 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
581 then
582 let !(#
583 c,
584 cs
585 #) = readNext inp
586 in if (GHC.Classes.==) ';' c
587 then
588 name
589 ( let _ = "suspend"
590 in \farInp farExp v (!inp) ->
591 let _ = "resume"
592 in ok
593 farInp
594 farExp
595 ( let _ = "resume.genCode"
596 in ';'
597 )
598 inp
599 )
600 cs
601 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
602 else
603 let _ = "checkToken.else"
604 in let failExp =
605 Data.Set.Internal.Bin
606 1
607 ( Symantic.Parser.Grammar.Combinators.SomeFailure
608 ( case inputToken of
609 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ';'
610 )
611 )
612 Data.Set.Internal.Tip
613 Data.Set.Internal.Tip
614 in let (#
615 farInp,
616 farExp
617 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
618 GHC.Types.LT ->
619 (#
620 inp,
621 failExp
622 #)
623 GHC.Types.EQ ->
624 (#
625 init,
626 failExp GHC.Base.<> Data.Set.Internal.empty
627 #)
628 GHC.Types.GT ->
629 (#
630 init,
631 Data.Set.Internal.empty
632 #)
633 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
634 else
635 let _ = "checkHorizon.else"
636 in let failExp =
637 Data.Set.Internal.Bin
638 1
639 ( Symantic.Parser.Grammar.Combinators.SomeFailure
640 ( case inputToken of
641 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
642 )
643 )
644 Data.Set.Internal.Tip
645 Data.Set.Internal.Tip
646 in let (#
647 farInp,
648 farExp
649 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
650 GHC.Types.LT ->
651 (#
652 inp,
653 failExp
654 #)
655 GHC.Types.EQ ->
656 (#
657 init,
658 failExp GHC.Base.<> Data.Set.Internal.empty
659 #)
660 GHC.Types.GT ->
661 (#
662 init,
663 Data.Set.Internal.empty
664 #)
665 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
666 name = \(!ok) (!inp) (!koByLabel) ->
667 let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel
668 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)
669 then
670 let !(#
671 c,
672 cs
673 #) = readNext inp
674 in if (GHC.Classes.==) '{' c
675 then
676 name
677 ( let _ = "suspend"
678 in \farInp farExp v (!inp) ->
679 name
680 ( let _ = "suspend"
681 in \farInp farExp v (!inp) ->
682 name
683 ( let _ = "suspend"
684 in \farInp farExp v (!inp) ->
685 name
686 ( let _ = "suspend"
687 in \farInp farExp v (!inp) ->
688 let readFail = readFail
689 in if readMore inp
690 then
691 let !(#
692 c,
693 cs
694 #) = readNext inp
695 in if (GHC.Classes.==) '}' c
696 then
697 name
698 ( let _ = "suspend"
699 in \farInp farExp v (!inp) ->
700 let _ = "resume"
701 in ok
702 farInp
703 farExp
704 ( let _ = "resume.genCode"
705 in v
706 )
707 inp
708 )
709 cs
710 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
711 else
712 let _ = "checkToken.else"
713 in let failExp =
714 Data.Set.Internal.Bin
715 1
716 ( Symantic.Parser.Grammar.Combinators.SomeFailure
717 ( case inputToken of
718 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '}'
719 )
720 )
721 Data.Set.Internal.Tip
722 Data.Set.Internal.Tip
723 in let (#
724 farInp,
725 farExp
726 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
727 GHC.Types.LT ->
728 (#
729 inp,
730 failExp
731 #)
732 GHC.Types.EQ ->
733 (#
734 farInp,
735 failExp GHC.Base.<> farExp
736 #)
737 GHC.Types.GT ->
738 (#
739 farInp,
740 farExp
741 #)
742 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
743 else
744 let _ = "checkHorizon.else"
745 in let failExp =
746 Data.Set.Internal.Bin
747 1
748 ( Symantic.Parser.Grammar.Combinators.SomeFailure
749 ( case inputToken of
750 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1
751 )
752 )
753 Data.Set.Internal.Tip
754 Data.Set.Internal.Tip
755 in let (#
756 farInp,
757 farExp
758 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
759 GHC.Types.LT ->
760 (#
761 inp,
762 failExp
763 #)
764 GHC.Types.EQ ->
765 (#
766 farInp,
767 failExp GHC.Base.<> farExp
768 #)
769 GHC.Types.GT ->
770 (#
771 farInp,
772 farExp
773 #)
774 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
775 )
776 inp
777 Data.Map.Internal.Tip
778 )
779 inp
780 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
781 )
782 inp
783 Data.Map.Internal.Tip
784 )
785 cs
786 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
787 else
788 let _ = "checkToken.else"
789 in let failExp =
790 Data.Set.Internal.Bin
791 1
792 ( Symantic.Parser.Grammar.Combinators.SomeFailure
793 ( case inputToken of
794 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '{'
795 )
796 )
797 Data.Set.Internal.Tip
798 Data.Set.Internal.Tip
799 in let (#
800 farInp,
801 farExp
802 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
803 GHC.Types.LT ->
804 (#
805 inp,
806 failExp
807 #)
808 GHC.Types.EQ ->
809 (#
810 init,
811 failExp GHC.Base.<> Data.Set.Internal.empty
812 #)
813 GHC.Types.GT ->
814 (#
815 init,
816 Data.Set.Internal.empty
817 #)
818 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
819 else
820 let _ = "checkHorizon.else"
821 in let failExp =
822 Data.Set.Internal.Bin
823 1
824 ( Symantic.Parser.Grammar.Combinators.SomeFailure
825 ( case inputToken of
826 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4
827 )
828 )
829 Data.Set.Internal.Tip
830 Data.Set.Internal.Tip
831 in let (#
832 farInp,
833 farExp
834 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
835 GHC.Types.LT ->
836 (#
837 inp,
838 failExp
839 #)
840 GHC.Types.EQ ->
841 (#
842 init,
843 failExp GHC.Base.<> Data.Set.Internal.empty
844 #)
845 GHC.Types.GT ->
846 (#
847 init,
848 Data.Set.Internal.empty
849 #)
850 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
851 name = \(!ok) (!inp) (!koByLabel) ->
852 let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel
853 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 4 inp)
854 then
855 let !(#
856 c,
857 cs
858 #) = readNext inp
859 in if (GHC.Classes.==) '[' c
860 then
861 name
862 ( let _ = "suspend"
863 in \farInp farExp v (!inp) ->
864 name
865 ( let _ = "suspend"
866 in \farInp farExp v (!inp) ->
867 name
868 ( let _ = "suspend"
869 in \farInp farExp v (!inp) ->
870 let readFail = readFail
871 in if readMore inp
872 then
873 let !(#
874 c,
875 cs
876 #) = readNext inp
877 in if (GHC.Classes.==) ']' c
878 then
879 name
880 ( let _ = "suspend"
881 in \farInp farExp v (!inp) ->
882 let _ = "resume"
883 in ok
884 farInp
885 farExp
886 ( let _ = "resume.genCode"
887 in GHC.Tuple . ()
888 )
889 inp
890 )
891 cs
892 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
893 else
894 let _ = "checkToken.else"
895 in let failExp =
896 Data.Set.Internal.Bin
897 1
898 ( Symantic.Parser.Grammar.Combinators.SomeFailure
899 ( case inputToken of
900 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ']'
901 )
902 )
903 Data.Set.Internal.Tip
904 Data.Set.Internal.Tip
905 in let (#
906 farInp,
907 farExp
908 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
909 GHC.Types.LT ->
910 (#
911 inp,
912 failExp
913 #)
914 GHC.Types.EQ ->
915 (#
916 farInp,
917 failExp GHC.Base.<> farExp
918 #)
919 GHC.Types.GT ->
920 (#
921 farInp,
922 farExp
923 #)
924 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
925 else
926 let _ = "checkHorizon.else"
927 in let failExp =
928 Data.Set.Internal.Bin
929 1
930 ( Symantic.Parser.Grammar.Combinators.SomeFailure
931 ( case inputToken of
932 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1
933 )
934 )
935 Data.Set.Internal.Tip
936 Data.Set.Internal.Tip
937 in let (#
938 farInp,
939 farExp
940 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
941 GHC.Types.LT ->
942 (#
943 inp,
944 failExp
945 #)
946 GHC.Types.EQ ->
947 (#
948 farInp,
949 failExp GHC.Base.<> farExp
950 #)
951 GHC.Types.GT ->
952 (#
953 farInp,
954 farExp
955 #)
956 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
957 )
958 inp
959 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
960 )
961 inp
962 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
963 )
964 cs
965 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
966 else
967 let _ = "checkToken.else"
968 in let failExp =
969 Data.Set.Internal.Bin
970 1
971 ( Symantic.Parser.Grammar.Combinators.SomeFailure
972 ( case inputToken of
973 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '['
974 )
975 )
976 Data.Set.Internal.Tip
977 Data.Set.Internal.Tip
978 in let (#
979 farInp,
980 farExp
981 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
982 GHC.Types.LT ->
983 (#
984 inp,
985 failExp
986 #)
987 GHC.Types.EQ ->
988 (#
989 init,
990 failExp GHC.Base.<> Data.Set.Internal.empty
991 #)
992 GHC.Types.GT ->
993 (#
994 init,
995 Data.Set.Internal.empty
996 #)
997 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
998 else
999 let _ = "checkHorizon.else"
1000 in let failExp =
1001 Data.Set.Internal.Bin
1002 1
1003 ( Symantic.Parser.Grammar.Combinators.SomeFailure
1004 ( case inputToken of
1005 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 5
1006 )
1007 )
1008 Data.Set.Internal.Tip
1009 Data.Set.Internal.Tip
1010 in let (#
1011 farInp,
1012 farExp
1013 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
1014 GHC.Types.LT ->
1015 (#
1016 inp,
1017 failExp
1018 #)
1019 GHC.Types.EQ ->
1020 (#
1021 init,
1022 failExp GHC.Base.<> Data.Set.Internal.empty
1023 #)
1024 GHC.Types.GT ->
1025 (#
1026 init,
1027 Data.Set.Internal.empty
1028 #)
1029 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
1030 name = \(!ok) (!inp) (!koByLabel) ->
1031 let _ = "catch ExceptionFailure"
1032 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
1033 let _ = "catch.ko ExceptionFailure"
1034 in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
1035 in let readFail = catchHandler
1036 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
1037 then
1038 let !(#
1039 c,
1040 cs
1041 #) = readNext inp
1042 in if Parsers.Nandlang.nandIdentStart c
1043 then
1044 name
1045 ( let _ = "suspend"
1046 in \farInp farExp v (!inp) ->
1047 name
1048 ( let _ = "suspend"
1049 in \farInp farExp v (!inp) ->
1050 name
1051 ( let _ = "suspend"
1052 in \farInp farExp v (!inp) ->
1053 name
1054 ( let _ = "suspend"
1055 in \farInp farExp v (!inp) ->
1056 let _ = "resume"
1057 in ok
1058 farInp
1059 farExp
1060 ( let _ = "resume.genCode"
1061 in v
1062 )
1063 inp
1064 )
1065 inp
1066 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)
1067 )
1068 inp
1069 Data.Map.Internal.Tip
1070 )
1071 inp
1072 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
1073 )
1074 cs
1075 Data.Map.Internal.Tip
1076 else
1077 let _ = "checkToken.else"
1078 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp init Data.Set.Internal.empty
1079 else
1080 let _ = "checkHorizon.else"
1081 in let failExp =
1082 Data.Set.Internal.Bin
1083 1
1084 ( Symantic.Parser.Grammar.Combinators.SomeFailure
1085 ( case inputToken of
1086 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
1087 )
1088 )
1089 Data.Set.Internal.Tip
1090 Data.Set.Internal.Tip
1091 in let (#
1092 farInp,
1093 farExp
1094 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
1095 GHC.Types.LT ->
1096 (#
1097 inp,
1098 failExp
1099 #)
1100 GHC.Types.EQ ->
1101 (#
1102 init,
1103 failExp GHC.Base.<> Data.Set.Internal.empty
1104 #)
1105 GHC.Types.GT ->
1106 (#
1107 init,
1108 Data.Set.Internal.empty
1109 #)
1110 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
1111 name = \(!ok) (!inp) (!koByLabel) ->
1112 let _ = "catch ExceptionFailure"
1113 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
1114 let _ = "catch.ko ExceptionFailure"
1115 in if ( \( Data.Text.Internal.Text
1116 _
1117 i
1118 _
1119 )
1120 ( Data.Text.Internal.Text
1121 _
1122 j
1123 _
1124 ) -> i GHC.Classes.== j
1125 )
1126 inp
1127 failInp
1128 then
1129 let _ = "choicesBranch.then"
1130 in name
1131 ( let _ = "suspend"
1132 in \farInp farExp v (!inp) ->
1133 let join = \farInp farExp v (!inp) ->
1134 let _ = "resume"
1135 in ok
1136 farInp
1137 farExp
1138 ( let _ = "resume.genCode"
1139 in v
1140 )
1141 inp
1142 in let _ = "catch ExceptionFailure"
1143 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
1144 let _ = "catch.ko ExceptionFailure"
1145 in if ( \( Data.Text.Internal.Text
1146 _
1147 i
1148 _
1149 )
1150 ( Data.Text.Internal.Text
1151 _
1152 j
1153 _
1154 ) -> i GHC.Classes.== j
1155 )
1156 inp
1157 failInp
1158 then
1159 let _ = "choicesBranch.then"
1160 in name
1161 ( let _ = "suspend"
1162 in \farInp farExp v (!inp) ->
1163 let _ = "resume"
1164 in join
1165 farInp
1166 farExp
1167 ( let _ = "resume.genCode"
1168 in v
1169 )
1170 inp
1171 )
1172 failInp
1173 Data.Map.Internal.Tip
1174 else
1175 let _ = "choicesBranch.else"
1176 in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
1177 in let join = \farInp farExp v (!inp) ->
1178 let _ = "resume"
1179 in join
1180 farInp
1181 farExp
1182 ( let _ = "resume.genCode"
1183 in GHC.Tuple . ()
1184 )
1185 inp
1186 in let _ = "catch ExceptionFailure"
1187 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
1188 let _ = "catch.ko ExceptionFailure"
1189 in if ( \( Data.Text.Internal.Text
1190 _
1191 i
1192 _
1193 )
1194 ( Data.Text.Internal.Text
1195 _
1196 j
1197 _
1198 ) -> i GHC.Classes.== j
1199 )
1200 inp
1201 failInp
1202 then
1203 let _ = "choicesBranch.then"
1204 in name
1205 ( let _ = "suspend"
1206 in \farInp farExp v (!inp) ->
1207 let _ = "resume"
1208 in join
1209 farInp
1210 farExp
1211 ( let _ = "resume.genCode"
1212 in v
1213 )
1214 inp
1215 )
1216 failInp
1217 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
1218 else
1219 let _ = "choicesBranch.else"
1220 in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
1221 in name
1222 ( let _ = "suspend"
1223 in \farInp farExp v (!inp) ->
1224 let join = \farInp farExp v (!inp) ->
1225 name
1226 ( let _ = "suspend"
1227 in \farInp farExp v (!inp) ->
1228 let _ = "resume"
1229 in join
1230 farInp
1231 farExp
1232 ( let _ = "resume.genCode"
1233 in v
1234 )
1235 inp
1236 )
1237 inp
1238 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
1239 in let _ = "catch ExceptionFailure"
1240 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
1241 let _ = "catch.ko ExceptionFailure"
1242 in if ( \( Data.Text.Internal.Text
1243 _
1244 i
1245 _
1246 )
1247 ( Data.Text.Internal.Text
1248 _
1249 j
1250 _
1251 ) -> i GHC.Classes.== j
1252 )
1253 inp
1254 failInp
1255 then
1256 let _ = "choicesBranch.then"
1257 in name
1258 ( let _ = "suspend"
1259 in \farInp farExp v (!inp) ->
1260 let _ = "resume"
1261 in join
1262 farInp
1263 farExp
1264 ( let _ = "resume.genCode"
1265 in v
1266 )
1267 inp
1268 )
1269 failInp
1270 Data.Map.Internal.Tip
1271 else
1272 let _ = "choicesBranch.else"
1273 in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
1274 in name
1275 ( let _ = "suspend"
1276 in \farInp farExp v (!inp) ->
1277 name
1278 ( let _ = "suspend"
1279 in \farInp farExp v (!inp) ->
1280 name
1281 ( let _ = "suspend"
1282 in \farInp farExp v (!inp) ->
1283 name
1284 ( let _ = "suspend"
1285 in \farInp farExp v (!inp) ->
1286 let _ = "resume"
1287 in join
1288 farInp
1289 farExp
1290 ( let _ = "resume.genCode"
1291 in GHC.Tuple . ()
1292 )
1293 inp
1294 )
1295 inp
1296 Data.Map.Internal.Tip
1297 )
1298 inp
1299 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
1300 )
1301 inp
1302 Data.Map.Internal.Tip
1303 )
1304 inp
1305 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
1306 )
1307 inp
1308 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
1309 )
1310 failInp
1311 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)
1312 else
1313 let _ = "choicesBranch.else"
1314 in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
1315 in let join = \farInp farExp v (!inp) ->
1316 let _ = "resume"
1317 in ok
1318 farInp
1319 farExp
1320 ( let _ = "resume.genCode"
1321 in v
1322 )
1323 inp
1324 in let _ = "catch ExceptionFailure"
1325 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
1326 let _ = "catch.ko ExceptionFailure"
1327 in if ( \( Data.Text.Internal.Text
1328 _
1329 i
1330 _
1331 )
1332 ( Data.Text.Internal.Text
1333 _
1334 j
1335 _
1336 ) -> i GHC.Classes.== j
1337 )
1338 inp
1339 failInp
1340 then
1341 let _ = "choicesBranch.then"
1342 in let readFail = catchHandler
1343 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 failInp)
1344 then
1345 let !(#
1346 c,
1347 cs
1348 #) = readNext failInp
1349 in if (GHC.Classes.==) '\'' c
1350 then
1351 let join = \farInp farExp v (!inp) ->
1352 let readFail = readFail
1353 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
1354 then
1355 let !(#
1356 c,
1357 cs
1358 #) = readNext inp
1359 in if (GHC.Classes.==) '\'' c
1360 then
1361 name
1362 ( let _ = "suspend"
1363 in \farInp farExp v (!inp) ->
1364 let _ = "resume"
1365 in join
1366 farInp
1367 farExp
1368 ( let _ = "resume.genCode"
1369 in v
1370 )
1371 inp
1372 )
1373 cs
1374 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
1375 else
1376 let _ = "checkToken.else"
1377 in let failExp =
1378 Data.Set.Internal.Bin
1379 1
1380 ( Symantic.Parser.Grammar.Combinators.SomeFailure
1381 ( case inputToken of
1382 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '\''
1383 )
1384 )
1385 Data.Set.Internal.Tip
1386 Data.Set.Internal.Tip
1387 in let (#
1388 farInp,
1389 farExp
1390 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
1391 GHC.Types.LT ->
1392 (#
1393 inp,
1394 failExp
1395 #)
1396 GHC.Types.EQ ->
1397 (#
1398 farInp,
1399 failExp GHC.Base.<> farExp
1400 #)
1401 GHC.Types.GT ->
1402 (#
1403 farInp,
1404 farExp
1405 #)
1406 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
1407 else
1408 let _ = "checkHorizon.else"
1409 in let failExp =
1410 Data.Set.Internal.Bin
1411 1
1412 ( Symantic.Parser.Grammar.Combinators.SomeFailure
1413 ( case inputToken of
1414 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
1415 )
1416 )
1417 Data.Set.Internal.Tip
1418 Data.Set.Internal.Tip
1419 in let (#
1420 farInp,
1421 farExp
1422 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
1423 GHC.Types.LT ->
1424 (#
1425 inp,
1426 failExp
1427 #)
1428 GHC.Types.EQ ->
1429 (#
1430 farInp,
1431 failExp GHC.Base.<> farExp
1432 #)
1433 GHC.Types.GT ->
1434 (#
1435 farInp,
1436 farExp
1437 #)
1438 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
1439 in let _ = "catch ExceptionFailure"
1440 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
1441 let _ = "catch.ko ExceptionFailure"
1442 in if ( \( Data.Text.Internal.Text
1443 _
1444 i
1445 _
1446 )
1447 ( Data.Text.Internal.Text
1448 _
1449 j
1450 _
1451 ) -> i GHC.Classes.== j
1452 )
1453 cs
1454 failInp
1455 then
1456 let _ = "choicesBranch.then"
1457 in let readFail = readFail
1458 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 failInp)
1459 then
1460 let !(#
1461 c,
1462 cs
1463 #) = readNext failInp
1464 in if (GHC.Classes.==) '\\' c
1465 then
1466 let readFail = readFail
1467 in let !(#
1468 c,
1469 cs
1470 #) = readNext cs
1471 in if (\t -> ('0' GHC.Classes.== t) GHC.Classes.|| (('t' GHC.Classes.== t) GHC.Classes.|| (('n' GHC.Classes.== t) GHC.Classes.|| (('v' GHC.Classes.== t) GHC.Classes.|| (('f' GHC.Classes.== t) GHC.Classes.|| (('r' GHC.Classes.== t) GHC.Classes.|| GHC.Types.False)))))) c
1472 then
1473 name
1474 ( let _ = "suspend"
1475 in \farInp farExp v (!inp) ->
1476 let _ = "resume"
1477 in join
1478 farInp
1479 farExp
1480 ( let _ = "resume.genCode"
1481 in v
1482 )
1483 inp
1484 )
1485 cs
1486 Data.Map.Internal.Tip
1487 else
1488 let _ = "checkToken.else"
1489 in let failExp =
1490 Data.Set.Internal.Bin
1491 1
1492 ( Symantic.Parser.Grammar.Combinators.SomeFailure
1493 ( case inputToken of
1494 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'r'
1495 )
1496 )
1497 Data.Set.Internal.Tip
1498 Data.Set.Internal.Tip
1499 in let (#
1500 farInp,
1501 farExp
1502 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
1503 GHC.Types.LT ->
1504 (#
1505 cs,
1506 failExp
1507 #)
1508 GHC.Types.EQ ->
1509 (#
1510 farInp,
1511 failExp GHC.Base.<> farExp
1512 #)
1513 GHC.Types.GT ->
1514 (#
1515 farInp,
1516 farExp
1517 #)
1518 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
1519 else
1520 let _ = "checkToken.else"
1521 in let failExp =
1522 Data.Set.Internal.Bin
1523 1
1524 ( Symantic.Parser.Grammar.Combinators.SomeFailure
1525 ( case inputToken of
1526 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '\\'
1527 )
1528 )
1529 Data.Set.Internal.Tip
1530 Data.Set.Internal.Tip
1531 in let (#
1532 farInp,
1533 farExp
1534 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1535 GHC.Types.LT ->
1536 (#
1537 failInp,
1538 failExp
1539 #)
1540 GHC.Types.EQ ->
1541 (#
1542 farInp,
1543 failExp GHC.Base.<> farExp
1544 #)
1545 GHC.Types.GT ->
1546 (#
1547 farInp,
1548 farExp
1549 #)
1550 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
1551 else
1552 let _ = "checkHorizon.else"
1553 in let failExp =
1554 Data.Set.Internal.Bin
1555 1
1556 ( Symantic.Parser.Grammar.Combinators.SomeFailure
1557 ( case inputToken of
1558 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4
1559 )
1560 )
1561 Data.Set.Internal.Tip
1562 Data.Set.Internal.Tip
1563 in let (#
1564 farInp,
1565 farExp
1566 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1567 GHC.Types.LT ->
1568 (#
1569 failInp,
1570 failExp
1571 #)
1572 GHC.Types.EQ ->
1573 (#
1574 farInp,
1575 failExp GHC.Base.<> farExp
1576 #)
1577 GHC.Types.GT ->
1578 (#
1579 farInp,
1580 farExp
1581 #)
1582 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
1583 else
1584 let _ = "choicesBranch.else"
1585 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
1586 in let readFail = catchHandler
1587 in let !(#
1588 c,
1589 cs
1590 #) = readNext cs
1591 in if Parsers.Nandlang.nandStringLetter c
1592 then
1593 name
1594 ( let _ = "suspend"
1595 in \farInp farExp v (!inp) ->
1596 let _ = "resume"
1597 in join
1598 farInp
1599 farExp
1600 ( let _ = "resume.genCode"
1601 in v
1602 )
1603 inp
1604 )
1605 cs
1606 Data.Map.Internal.Tip
1607 else
1608 let _ = "checkToken.else"
1609 in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
1610 else
1611 let _ = "checkToken.else"
1612 in let failExp =
1613 Data.Set.Internal.Bin
1614 1
1615 ( Symantic.Parser.Grammar.Combinators.SomeFailure
1616 ( case inputToken of
1617 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '\''
1618 )
1619 )
1620 Data.Set.Internal.Tip
1621 Data.Set.Internal.Tip
1622 in let (#
1623 farInp,
1624 farExp
1625 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1626 GHC.Types.LT ->
1627 (#
1628 failInp,
1629 failExp
1630 #)
1631 GHC.Types.EQ ->
1632 (#
1633 farInp,
1634 failExp GHC.Base.<> farExp
1635 #)
1636 GHC.Types.GT ->
1637 (#
1638 farInp,
1639 farExp
1640 #)
1641 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
1642 else
1643 let _ = "checkHorizon.else"
1644 in let failExp =
1645 Data.Set.Internal.Bin
1646 1
1647 ( Symantic.Parser.Grammar.Combinators.SomeFailure
1648 ( case inputToken of
1649 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4
1650 )
1651 )
1652 Data.Set.Internal.Tip
1653 Data.Set.Internal.Tip
1654 in let (#
1655 farInp,
1656 farExp
1657 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1658 GHC.Types.LT ->
1659 (#
1660 failInp,
1661 failExp
1662 #)
1663 GHC.Types.EQ ->
1664 (#
1665 farInp,
1666 failExp GHC.Base.<> farExp
1667 #)
1668 GHC.Types.GT ->
1669 (#
1670 farInp,
1671 farExp
1672 #)
1673 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
1674 else
1675 let _ = "choicesBranch.else"
1676 in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
1677 in let join = \farInp farExp v (!inp) ->
1678 name
1679 ( let _ = "suspend"
1680 in \farInp farExp v (!inp) ->
1681 let _ = "resume"
1682 in join
1683 farInp
1684 farExp
1685 ( let _ = "resume.genCode"
1686 in v
1687 )
1688 inp
1689 )
1690 inp
1691 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
1692 in let _ = "catch ExceptionFailure"
1693 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
1694 let _ = "catch.ko ExceptionFailure"
1695 in if ( \( Data.Text.Internal.Text
1696 _
1697 i
1698 _
1699 )
1700 ( Data.Text.Internal.Text
1701 _
1702 j
1703 _
1704 ) -> i GHC.Classes.== j
1705 )
1706 inp
1707 failInp
1708 then
1709 let _ = "choicesBranch.then"
1710 in let readFail = catchHandler
1711 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 failInp)
1712 then
1713 let !(#
1714 c,
1715 cs
1716 #) = readNext failInp
1717 in if (GHC.Classes.==) '1' c
1718 then
1719 let _ = "resume"
1720 in join
1721 farInp
1722 farExp
1723 ( let _ = "resume.genCode"
1724 in '1'
1725 )
1726 cs
1727 else
1728 let _ = "checkToken.else"
1729 in let failExp =
1730 Data.Set.Internal.Bin
1731 1
1732 ( Symantic.Parser.Grammar.Combinators.SomeFailure
1733 ( case inputToken of
1734 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '1'
1735 )
1736 )
1737 Data.Set.Internal.Tip
1738 Data.Set.Internal.Tip
1739 in let (#
1740 farInp,
1741 farExp
1742 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1743 GHC.Types.LT ->
1744 (#
1745 failInp,
1746 failExp
1747 #)
1748 GHC.Types.EQ ->
1749 (#
1750 farInp,
1751 failExp GHC.Base.<> farExp
1752 #)
1753 GHC.Types.GT ->
1754 (#
1755 farInp,
1756 farExp
1757 #)
1758 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
1759 else
1760 let _ = "checkHorizon.else"
1761 in let failExp =
1762 Data.Set.Internal.Bin
1763 1
1764 ( Symantic.Parser.Grammar.Combinators.SomeFailure
1765 ( case inputToken of
1766 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
1767 )
1768 )
1769 Data.Set.Internal.Tip
1770 Data.Set.Internal.Tip
1771 in let (#
1772 farInp,
1773 farExp
1774 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1775 GHC.Types.LT ->
1776 (#
1777 failInp,
1778 failExp
1779 #)
1780 GHC.Types.EQ ->
1781 (#
1782 farInp,
1783 failExp GHC.Base.<> farExp
1784 #)
1785 GHC.Types.GT ->
1786 (#
1787 farInp,
1788 farExp
1789 #)
1790 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
1791 else
1792 let _ = "choicesBranch.else"
1793 in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
1794 in let readFail = catchHandler
1795 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
1796 then
1797 let !(#
1798 c,
1799 cs
1800 #) = readNext inp
1801 in if (GHC.Classes.==) '0' c
1802 then
1803 let _ = "resume"
1804 in join
1805 init
1806 Data.Set.Internal.empty
1807 ( let _ = "resume.genCode"
1808 in '0'
1809 )
1810 cs
1811 else
1812 let _ = "checkToken.else"
1813 in let failExp =
1814 Data.Set.Internal.Bin
1815 1
1816 ( Symantic.Parser.Grammar.Combinators.SomeFailure
1817 ( case inputToken of
1818 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '0'
1819 )
1820 )
1821 Data.Set.Internal.Tip
1822 Data.Set.Internal.Tip
1823 in let (#
1824 farInp,
1825 farExp
1826 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
1827 GHC.Types.LT ->
1828 (#
1829 inp,
1830 failExp
1831 #)
1832 GHC.Types.EQ ->
1833 (#
1834 init,
1835 failExp GHC.Base.<> Data.Set.Internal.empty
1836 #)
1837 GHC.Types.GT ->
1838 (#
1839 init,
1840 Data.Set.Internal.empty
1841 #)
1842 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
1843 else
1844 let _ = "checkHorizon.else"
1845 in let failExp =
1846 Data.Set.Internal.Bin
1847 1
1848 ( Symantic.Parser.Grammar.Combinators.SomeFailure
1849 ( case inputToken of
1850 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
1851 )
1852 )
1853 Data.Set.Internal.Tip
1854 Data.Set.Internal.Tip
1855 in let (#
1856 farInp,
1857 farExp
1858 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
1859 GHC.Types.LT ->
1860 (#
1861 inp,
1862 failExp
1863 #)
1864 GHC.Types.EQ ->
1865 (#
1866 init,
1867 failExp GHC.Base.<> Data.Set.Internal.empty
1868 #)
1869 GHC.Types.GT ->
1870 (#
1871 init,
1872 Data.Set.Internal.empty
1873 #)
1874 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
1875 name = \(!ok) (!inp) (!koByLabel) ->
1876 let _ = "catch ExceptionFailure"
1877 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
1878 let _ = "catch.ko ExceptionFailure"
1879 in if ( \( Data.Text.Internal.Text
1880 _
1881 i
1882 _
1883 )
1884 ( Data.Text.Internal.Text
1885 _
1886 j
1887 _
1888 ) -> i GHC.Classes.== j
1889 )
1890 inp
1891 failInp
1892 then
1893 let _ = "choicesBranch.then"
1894 in let _ = "jump"
1895 in name ok failInp Data.Map.Internal.Tip
1896 else
1897 let _ = "choicesBranch.else"
1898 in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
1899 in name
1900 ( let _ = "suspend"
1901 in \farInp farExp v (!inp) ->
1902 name
1903 ( let _ = "suspend"
1904 in \farInp farExp v (!inp) ->
1905 name
1906 ( let _ = "suspend"
1907 in \farInp farExp v (!inp) ->
1908 name
1909 ( let _ = "suspend"
1910 in \farInp farExp v (!inp) ->
1911 let _ = "resume"
1912 in ok
1913 farInp
1914 farExp
1915 ( let _ = "resume.genCode"
1916 in GHC.Tuple . ()
1917 )
1918 inp
1919 )
1920 inp
1921 Data.Map.Internal.Tip
1922 )
1923 inp
1924 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
1925 )
1926 inp
1927 Data.Map.Internal.Tip
1928 )
1929 inp
1930 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
1931 name = \(!ok) (!inp) (!koByLabel) ->
1932 let _ = "catch ExceptionFailure"
1933 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
1934 let _ = "catch.ko ExceptionFailure"
1935 in if ( \( Data.Text.Internal.Text
1936 _
1937 i
1938 _
1939 )
1940 ( Data.Text.Internal.Text
1941 _
1942 j
1943 _
1944 ) -> i GHC.Classes.== j
1945 )
1946 inp
1947 failInp
1948 then
1949 let _ = "choicesBranch.then"
1950 in let _ = "resume"
1951 in ok
1952 farInp
1953 farExp
1954 ( let _ = "resume.genCode"
1955 in \x -> x
1956 )
1957 failInp
1958 else
1959 let _ = "choicesBranch.else"
1960 in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
1961 in name
1962 ( let _ = "suspend"
1963 in \farInp farExp v (!inp) ->
1964 name
1965 ( let _ = "suspend"
1966 in \farInp farExp v (!inp) ->
1967 name
1968 ( let _ = "suspend"
1969 in \farInp farExp v (!inp) ->
1970 name
1971 ( let _ = "suspend"
1972 in \farInp farExp v (!inp) ->
1973 let _ = "resume"
1974 in ok
1975 farInp
1976 farExp
1977 ( let _ = "resume.genCode"
1978 in \x -> v v (v x)
1979 )
1980 inp
1981 )
1982 inp
1983 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
1984 )
1985 inp
1986 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
1987 )
1988 inp
1989 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
1990 )
1991 inp
1992 Data.Map.Internal.Tip
1993 name = \(!ok) (!inp) (!koByLabel) ->
1994 let _ = "catch ExceptionFailure"
1995 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
1996 let _ = "catch.ko ExceptionFailure"
1997 in if ( \( Data.Text.Internal.Text
1998 _
1999 i
2000 _
2001 )
2002 ( Data.Text.Internal.Text
2003 _
2004 j
2005 _
2006 ) -> i GHC.Classes.== j
2007 )
2008 inp
2009 failInp
2010 then
2011 let _ = "choicesBranch.then"
2012 in let _ = "resume"
2013 in ok
2014 farInp
2015 farExp
2016 ( let _ = "resume.genCode"
2017 in \x -> x
2018 )
2019 failInp
2020 else
2021 let _ = "choicesBranch.else"
2022 in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
2023 in name
2024 ( let _ = "suspend"
2025 in \farInp farExp v (!inp) ->
2026 name
2027 ( let _ = "suspend"
2028 in \farInp farExp v (!inp) ->
2029 name
2030 ( let _ = "suspend"
2031 in \farInp farExp v (!inp) ->
2032 name
2033 ( let _ = "suspend"
2034 in \farInp farExp v (!inp) ->
2035 let _ = "resume"
2036 in ok
2037 farInp
2038 farExp
2039 ( let _ = "resume.genCode"
2040 in \x -> v v (v x)
2041 )
2042 inp
2043 )
2044 inp
2045 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2046 )
2047 inp
2048 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2049 )
2050 inp
2051 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2052 )
2053 inp
2054 Data.Map.Internal.Tip
2055 name = \(!ok) (!inp) (!koByLabel) ->
2056 let _ = "catch ExceptionFailure"
2057 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
2058 let _ = "catch.ko ExceptionFailure"
2059 in if ( \( Data.Text.Internal.Text
2060 _
2061 i
2062 _
2063 )
2064 ( Data.Text.Internal.Text
2065 _
2066 j
2067 _
2068 ) -> i GHC.Classes.== j
2069 )
2070 inp
2071 failInp
2072 then
2073 let _ = "choicesBranch.then"
2074 in let _ = "resume"
2075 in ok
2076 farInp
2077 farExp
2078 ( let _ = "resume.genCode"
2079 in \x -> x
2080 )
2081 failInp
2082 else
2083 let _ = "choicesBranch.else"
2084 in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
2085 in name
2086 ( let _ = "suspend"
2087 in \farInp farExp v (!inp) ->
2088 name
2089 ( let _ = "suspend"
2090 in \farInp farExp v (!inp) ->
2091 name
2092 ( let _ = "suspend"
2093 in \farInp farExp v (!inp) ->
2094 name
2095 ( let _ = "suspend"
2096 in \farInp farExp v (!inp) ->
2097 let _ = "resume"
2098 in ok
2099 farInp
2100 farExp
2101 ( let _ = "resume.genCode"
2102 in \x -> v v (v x)
2103 )
2104 inp
2105 )
2106 inp
2107 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2108 )
2109 inp
2110 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2111 )
2112 inp
2113 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2114 )
2115 inp
2116 Data.Map.Internal.Tip
2117 name = \(!ok) (!inp) (!koByLabel) ->
2118 let _ = "catch ExceptionFailure"
2119 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
2120 let _ = "catch.ko ExceptionFailure"
2121 in if ( \( Data.Text.Internal.Text
2122 _
2123 i
2124 _
2125 )
2126 ( Data.Text.Internal.Text
2127 _
2128 j
2129 _
2130 ) -> i GHC.Classes.== j
2131 )
2132 inp
2133 failInp
2134 then
2135 let _ = "choicesBranch.then"
2136 in let _ = "resume"
2137 in ok
2138 farInp
2139 farExp
2140 ( let _ = "resume.genCode"
2141 in \x -> x
2142 )
2143 failInp
2144 else
2145 let _ = "choicesBranch.else"
2146 in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
2147 in name
2148 ( let _ = "suspend"
2149 in \farInp farExp v (!inp) ->
2150 name
2151 ( let _ = "suspend"
2152 in \farInp farExp v (!inp) ->
2153 name
2154 ( let _ = "suspend"
2155 in \farInp farExp v (!inp) ->
2156 name
2157 ( let _ = "suspend"
2158 in \farInp farExp v (!inp) ->
2159 let _ = "resume"
2160 in ok
2161 farInp
2162 farExp
2163 ( let _ = "resume.genCode"
2164 in \x -> v v (v x)
2165 )
2166 inp
2167 )
2168 inp
2169 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2170 )
2171 inp
2172 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2173 )
2174 inp
2175 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2176 )
2177 inp
2178 Data.Map.Internal.Tip
2179 name = \(!ok) (!inp) (!koByLabel) ->
2180 let _ = "catch ExceptionFailure"
2181 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
2182 let _ = "catch.ko ExceptionFailure"
2183 in if ( \( Data.Text.Internal.Text
2184 _
2185 i
2186 _
2187 )
2188 ( Data.Text.Internal.Text
2189 _
2190 j
2191 _
2192 ) -> i GHC.Classes.== j
2193 )
2194 inp
2195 failInp
2196 then
2197 let _ = "choicesBranch.then"
2198 in let _ = "resume"
2199 in ok
2200 farInp
2201 farExp
2202 ( let _ = "resume.genCode"
2203 in \x -> x
2204 )
2205 failInp
2206 else
2207 let _ = "choicesBranch.else"
2208 in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
2209 in name
2210 ( let _ = "suspend"
2211 in \farInp farExp v (!inp) ->
2212 name
2213 ( let _ = "suspend"
2214 in \farInp farExp v (!inp) ->
2215 let _ = "resume"
2216 in ok
2217 farInp
2218 farExp
2219 ( let _ = "resume.genCode"
2220 in \x -> v x
2221 )
2222 inp
2223 )
2224 inp
2225 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2226 )
2227 inp
2228 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2229 name = \(!ok) (!inp) (!koByLabel) ->
2230 let _ = "catch ExceptionFailure"
2231 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
2232 let _ = "catch.ko ExceptionFailure"
2233 in if ( \( Data.Text.Internal.Text
2234 _
2235 i
2236 _
2237 )
2238 ( Data.Text.Internal.Text
2239 _
2240 j
2241 _
2242 ) -> i GHC.Classes.== j
2243 )
2244 inp
2245 failInp
2246 then
2247 let _ = "choicesBranch.then"
2248 in let _ = "resume"
2249 in ok
2250 farInp
2251 farExp
2252 ( let _ = "resume.genCode"
2253 in \x -> x
2254 )
2255 failInp
2256 else
2257 let _ = "choicesBranch.else"
2258 in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
2259 in name
2260 ( let _ = "suspend"
2261 in \farInp farExp v (!inp) ->
2262 name
2263 ( let _ = "suspend"
2264 in \farInp farExp v (!inp) ->
2265 let _ = "resume"
2266 in ok
2267 farInp
2268 farExp
2269 ( let _ = "resume.genCode"
2270 in \x -> v x
2271 )
2272 inp
2273 )
2274 inp
2275 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2276 )
2277 inp
2278 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2279 name = \(!ok) (!inp) (!koByLabel) ->
2280 let _ = "catch ExceptionFailure"
2281 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
2282 let _ = "catch.ko ExceptionFailure"
2283 in if ( \( Data.Text.Internal.Text
2284 _
2285 i
2286 _
2287 )
2288 ( Data.Text.Internal.Text
2289 _
2290 j
2291 _
2292 ) -> i GHC.Classes.== j
2293 )
2294 inp
2295 failInp
2296 then
2297 let _ = "choicesBranch.then"
2298 in let _ = "resume"
2299 in ok
2300 farInp
2301 farExp
2302 ( let _ = "resume.genCode"
2303 in \x -> x
2304 )
2305 failInp
2306 else
2307 let _ = "choicesBranch.else"
2308 in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
2309 in let join = \farInp farExp v (!inp) ->
2310 name
2311 ( let _ = "suspend"
2312 in \farInp farExp v (!inp) ->
2313 let _ = "resume"
2314 in ok
2315 farInp
2316 farExp
2317 ( let _ = "resume.genCode"
2318 in \x -> v x
2319 )
2320 inp
2321 )
2322 inp
2323 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2324 in let _ = "catch ExceptionFailure"
2325 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
2326 let _ = "catch.ko ExceptionFailure"
2327 in if ( \( Data.Text.Internal.Text
2328 _
2329 i
2330 _
2331 )
2332 ( Data.Text.Internal.Text
2333 _
2334 j
2335 _
2336 ) -> i GHC.Classes.== j
2337 )
2338 inp
2339 failInp
2340 then
2341 let _ = "choicesBranch.then"
2342 in name
2343 ( let _ = "suspend"
2344 in \farInp farExp v (!inp) ->
2345 name
2346 ( let _ = "suspend"
2347 in \farInp farExp v (!inp) ->
2348 let _ = "resume"
2349 in join
2350 farInp
2351 farExp
2352 ( let _ = "resume.genCode"
2353 in v
2354 )
2355 inp
2356 )
2357 inp
2358 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2359 )
2360 failInp
2361 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2362 else
2363 let _ = "choicesBranch.else"
2364 in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
2365 in let join = \farInp farExp v (!inp) ->
2366 let _ = "resume"
2367 in join
2368 farInp
2369 farExp
2370 ( let _ = "resume.genCode"
2371 in v
2372 )
2373 inp
2374 in let _ = "catch ExceptionFailure"
2375 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
2376 let _ = "catch.ko ExceptionFailure"
2377 in if ( \( Data.Text.Internal.Text
2378 _
2379 i
2380 _
2381 )
2382 ( Data.Text.Internal.Text
2383 _
2384 j
2385 _
2386 ) -> i GHC.Classes.== j
2387 )
2388 inp
2389 failInp
2390 then
2391 let _ = "choicesBranch.then"
2392 in let _ = "catch ExceptionFailure"
2393 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
2394 let _ = "catch.ko ExceptionFailure"
2395 in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
2396 in let join = \farInp farExp v (!inp) ->
2397 name
2398 ( let _ = "suspend"
2399 in \farInp farExp v (!inp) ->
2400 name
2401 ( let _ = "suspend"
2402 in \farInp farExp v (!inp) ->
2403 name
2404 ( let _ = "suspend"
2405 in \farInp farExp v (!inp) ->
2406 name
2407 ( let _ = "suspend"
2408 in \farInp farExp v (!inp) ->
2409 let readFail = catchHandler
2410 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)
2411 then
2412 let !(#
2413 c,
2414 cs
2415 #) = readNext inp
2416 in if (GHC.Classes.==) '=' c
2417 then
2418 name
2419 ( let _ = "suspend"
2420 in \farInp farExp v (!inp) ->
2421 name
2422 ( let _ = "suspend"
2423 in \farInp farExp v (!inp) ->
2424 name
2425 ( let _ = "suspend"
2426 in \farInp farExp v (!inp) ->
2427 name
2428 ( let _ = "suspend"
2429 in \farInp farExp v (!inp) ->
2430 name
2431 ( let _ = "suspend"
2432 in \farInp farExp v (!inp) ->
2433 name
2434 ( let _ = "suspend"
2435 in \farInp farExp v (!inp) ->
2436 let _ = "resume"
2437 in join
2438 farInp
2439 farExp
2440 ( let _ = "resume.genCode"
2441 in v
2442 )
2443 inp
2444 )
2445 inp
2446 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
2447 )
2448 inp
2449 Data.Map.Internal.Tip
2450 )
2451 inp
2452 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
2453 )
2454 inp
2455 Data.Map.Internal.Tip
2456 )
2457 inp
2458 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
2459 )
2460 cs
2461 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
2462 else
2463 let _ = "checkToken.else"
2464 in let failExp =
2465 Data.Set.Internal.Bin
2466 1
2467 ( Symantic.Parser.Grammar.Combinators.SomeFailure
2468 ( case inputToken of
2469 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '='
2470 )
2471 )
2472 Data.Set.Internal.Tip
2473 Data.Set.Internal.Tip
2474 in let (#
2475 farInp,
2476 farExp
2477 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
2478 GHC.Types.LT ->
2479 (#
2480 inp,
2481 failExp
2482 #)
2483 GHC.Types.EQ ->
2484 (#
2485 farInp,
2486 failExp GHC.Base.<> farExp
2487 #)
2488 GHC.Types.GT ->
2489 (#
2490 farInp,
2491 farExp
2492 #)
2493 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
2494 else
2495 let _ = "checkHorizon.else"
2496 in let failExp =
2497 Data.Set.Internal.Bin
2498 1
2499 ( Symantic.Parser.Grammar.Combinators.SomeFailure
2500 ( case inputToken of
2501 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4
2502 )
2503 )
2504 Data.Set.Internal.Tip
2505 Data.Set.Internal.Tip
2506 in let (#
2507 farInp,
2508 farExp
2509 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
2510 GHC.Types.LT ->
2511 (#
2512 inp,
2513 failExp
2514 #)
2515 GHC.Types.EQ ->
2516 (#
2517 farInp,
2518 failExp GHC.Base.<> farExp
2519 #)
2520 GHC.Types.GT ->
2521 (#
2522 farInp,
2523 farExp
2524 #)
2525 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
2526 )
2527 inp
2528 Data.Map.Internal.Tip
2529 )
2530 inp
2531 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2532 )
2533 inp
2534 Data.Map.Internal.Tip
2535 )
2536 inp
2537 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2538 in let _ = "catch ExceptionFailure"
2539 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
2540 let _ = "catch.ko ExceptionFailure"
2541 in if ( \( Data.Text.Internal.Text
2542 _
2543 i
2544 _
2545 )
2546 ( Data.Text.Internal.Text
2547 _
2548 j
2549 _
2550 ) -> i GHC.Classes.== j
2551 )
2552 failInp
2553 failInp
2554 then
2555 let _ = "choicesBranch.then"
2556 in name
2557 ( let _ = "suspend"
2558 in \farInp farExp v (!inp) ->
2559 let _ = "resume"
2560 in join
2561 farInp
2562 farExp
2563 ( let _ = "resume.genCode"
2564 in v
2565 )
2566 inp
2567 )
2568 failInp
2569 Data.Map.Internal.Tip
2570 else
2571 let _ = "choicesBranch.else"
2572 in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
2573 in let _ = "catch ExceptionFailure"
2574 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
2575 let _ = "catch.ko ExceptionFailure"
2576 in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
2577 in let readFail = catchHandler
2578 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 10 failInp)
2579 then
2580 let !(#
2581 c,
2582 cs
2583 #) = readNext failInp
2584 in if (GHC.Classes.==) 'v' c
2585 then
2586 let readFail = readFail
2587 in let !(#
2588 c,
2589 cs
2590 #) = readNext cs
2591 in if (GHC.Classes.==) 'a' c
2592 then
2593 let readFail = readFail
2594 in let !(#
2595 c,
2596 cs
2597 #) = readNext cs
2598 in if (GHC.Classes.==) 'r' c
2599 then
2600 name
2601 ( let _ = "suspend"
2602 in \farInp farExp v (!inp) ->
2603 let _ = "resume"
2604 in join
2605 farInp
2606 farExp
2607 ( let _ = "resume.genCode"
2608 in GHC.Tuple . ()
2609 )
2610 inp
2611 )
2612 cs
2613 Data.Map.Internal.Tip
2614 else
2615 let _ = "checkToken.else"
2616 in let failExp =
2617 Data.Set.Internal.Bin
2618 1
2619 ( Symantic.Parser.Grammar.Combinators.SomeFailure
2620 ( case inputToken of
2621 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'r'
2622 )
2623 )
2624 Data.Set.Internal.Tip
2625 Data.Set.Internal.Tip
2626 in let (#
2627 farInp,
2628 farExp
2629 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
2630 GHC.Types.LT ->
2631 (#
2632 cs,
2633 failExp
2634 #)
2635 GHC.Types.EQ ->
2636 (#
2637 farInp,
2638 failExp GHC.Base.<> farExp
2639 #)
2640 GHC.Types.GT ->
2641 (#
2642 farInp,
2643 farExp
2644 #)
2645 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
2646 else
2647 let _ = "checkToken.else"
2648 in let failExp =
2649 Data.Set.Internal.Bin
2650 1
2651 ( Symantic.Parser.Grammar.Combinators.SomeFailure
2652 ( case inputToken of
2653 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'
2654 )
2655 )
2656 Data.Set.Internal.Tip
2657 Data.Set.Internal.Tip
2658 in let (#
2659 farInp,
2660 farExp
2661 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
2662 GHC.Types.LT ->
2663 (#
2664 cs,
2665 failExp
2666 #)
2667 GHC.Types.EQ ->
2668 (#
2669 farInp,
2670 failExp GHC.Base.<> farExp
2671 #)
2672 GHC.Types.GT ->
2673 (#
2674 farInp,
2675 farExp
2676 #)
2677 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
2678 else
2679 let _ = "checkToken.else"
2680 in let failExp =
2681 Data.Set.Internal.Bin
2682 1
2683 ( Symantic.Parser.Grammar.Combinators.SomeFailure
2684 ( case inputToken of
2685 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'v'
2686 )
2687 )
2688 Data.Set.Internal.Tip
2689 Data.Set.Internal.Tip
2690 in let (#
2691 farInp,
2692 farExp
2693 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
2694 GHC.Types.LT ->
2695 (#
2696 failInp,
2697 failExp
2698 #)
2699 GHC.Types.EQ ->
2700 (#
2701 farInp,
2702 failExp GHC.Base.<> farExp
2703 #)
2704 GHC.Types.GT ->
2705 (#
2706 farInp,
2707 farExp
2708 #)
2709 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
2710 else
2711 let _ = "checkHorizon.else"
2712 in let failExp =
2713 Data.Set.Internal.Bin
2714 1
2715 ( Symantic.Parser.Grammar.Combinators.SomeFailure
2716 ( case inputToken of
2717 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 11
2718 )
2719 )
2720 Data.Set.Internal.Tip
2721 Data.Set.Internal.Tip
2722 in let (#
2723 farInp,
2724 farExp
2725 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
2726 GHC.Types.LT ->
2727 (#
2728 failInp,
2729 failExp
2730 #)
2731 GHC.Types.EQ ->
2732 (#
2733 farInp,
2734 failExp GHC.Base.<> farExp
2735 #)
2736 GHC.Types.GT ->
2737 (#
2738 farInp,
2739 farExp
2740 #)
2741 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
2742 else
2743 let _ = "choicesBranch.else"
2744 in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
2745 in let join = \farInp farExp v (!inp) ->
2746 let _ = "resume"
2747 in join
2748 farInp
2749 farExp
2750 ( let _ = "resume.genCode"
2751 in v
2752 )
2753 inp
2754 in let _ = "catch ExceptionFailure"
2755 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
2756 let _ = "catch.ko ExceptionFailure"
2757 in if ( \( Data.Text.Internal.Text
2758 _
2759 i
2760 _
2761 )
2762 ( Data.Text.Internal.Text
2763 _
2764 j
2765 _
2766 ) -> i GHC.Classes.== j
2767 )
2768 inp
2769 failInp
2770 then
2771 let _ = "choicesBranch.then"
2772 in let _ = "catch ExceptionFailure"
2773 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
2774 let _ = "catch.ko ExceptionFailure"
2775 in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
2776 in let readFail = catchHandler
2777 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 10 failInp)
2778 then
2779 let !(#
2780 c,
2781 cs
2782 #) = readNext failInp
2783 in if (GHC.Classes.==) 'w' c
2784 then
2785 let readFail = readFail
2786 in let !(#
2787 c,
2788 cs
2789 #) = readNext cs
2790 in if (GHC.Classes.==) 'h' c
2791 then
2792 let readFail = readFail
2793 in let !(#
2794 c,
2795 cs
2796 #) = readNext cs
2797 in if (GHC.Classes.==) 'i' c
2798 then
2799 let readFail = readFail
2800 in let !(#
2801 c,
2802 cs
2803 #) = readNext cs
2804 in if (GHC.Classes.==) 'l' c
2805 then
2806 let readFail = readFail
2807 in let !(#
2808 c,
2809 cs
2810 #) = readNext cs
2811 in if (GHC.Classes.==) 'e' c
2812 then
2813 name
2814 ( let _ = "suspend"
2815 in \farInp farExp v (!inp) ->
2816 name
2817 ( let _ = "suspend"
2818 in \farInp farExp v (!inp) ->
2819 name
2820 ( let _ = "suspend"
2821 in \farInp farExp v (!inp) ->
2822 let _ = "resume"
2823 in join
2824 farInp
2825 farExp
2826 ( let _ = "resume.genCode"
2827 in v
2828 )
2829 inp
2830 )
2831 inp
2832 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2833 )
2834 inp
2835 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2836 )
2837 cs
2838 Data.Map.Internal.Tip
2839 else
2840 let _ = "checkToken.else"
2841 in let failExp =
2842 Data.Set.Internal.Bin
2843 1
2844 ( Symantic.Parser.Grammar.Combinators.SomeFailure
2845 ( case inputToken of
2846 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'e'
2847 )
2848 )
2849 Data.Set.Internal.Tip
2850 Data.Set.Internal.Tip
2851 in let (#
2852 farInp,
2853 farExp
2854 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
2855 GHC.Types.LT ->
2856 (#
2857 cs,
2858 failExp
2859 #)
2860 GHC.Types.EQ ->
2861 (#
2862 farInp,
2863 failExp GHC.Base.<> farExp
2864 #)
2865 GHC.Types.GT ->
2866 (#
2867 farInp,
2868 farExp
2869 #)
2870 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
2871 else
2872 let _ = "checkToken.else"
2873 in let failExp =
2874 Data.Set.Internal.Bin
2875 1
2876 ( Symantic.Parser.Grammar.Combinators.SomeFailure
2877 ( case inputToken of
2878 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'l'
2879 )
2880 )
2881 Data.Set.Internal.Tip
2882 Data.Set.Internal.Tip
2883 in let (#
2884 farInp,
2885 farExp
2886 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
2887 GHC.Types.LT ->
2888 (#
2889 cs,
2890 failExp
2891 #)
2892 GHC.Types.EQ ->
2893 (#
2894 farInp,
2895 failExp GHC.Base.<> farExp
2896 #)
2897 GHC.Types.GT ->
2898 (#
2899 farInp,
2900 farExp
2901 #)
2902 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
2903 else
2904 let _ = "checkToken.else"
2905 in let failExp =
2906 Data.Set.Internal.Bin
2907 1
2908 ( Symantic.Parser.Grammar.Combinators.SomeFailure
2909 ( case inputToken of
2910 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'i'
2911 )
2912 )
2913 Data.Set.Internal.Tip
2914 Data.Set.Internal.Tip
2915 in let (#
2916 farInp,
2917 farExp
2918 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
2919 GHC.Types.LT ->
2920 (#
2921 cs,
2922 failExp
2923 #)
2924 GHC.Types.EQ ->
2925 (#
2926 farInp,
2927 failExp GHC.Base.<> farExp
2928 #)
2929 GHC.Types.GT ->
2930 (#
2931 farInp,
2932 farExp
2933 #)
2934 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
2935 else
2936 let _ = "checkToken.else"
2937 in let failExp =
2938 Data.Set.Internal.Bin
2939 1
2940 ( Symantic.Parser.Grammar.Combinators.SomeFailure
2941 ( case inputToken of
2942 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'h'
2943 )
2944 )
2945 Data.Set.Internal.Tip
2946 Data.Set.Internal.Tip
2947 in let (#
2948 farInp,
2949 farExp
2950 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
2951 GHC.Types.LT ->
2952 (#
2953 cs,
2954 failExp
2955 #)
2956 GHC.Types.EQ ->
2957 (#
2958 farInp,
2959 failExp GHC.Base.<> farExp
2960 #)
2961 GHC.Types.GT ->
2962 (#
2963 farInp,
2964 farExp
2965 #)
2966 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
2967 else
2968 let _ = "checkToken.else"
2969 in let failExp =
2970 Data.Set.Internal.Bin
2971 1
2972 ( Symantic.Parser.Grammar.Combinators.SomeFailure
2973 ( case inputToken of
2974 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'w'
2975 )
2976 )
2977 Data.Set.Internal.Tip
2978 Data.Set.Internal.Tip
2979 in let (#
2980 farInp,
2981 farExp
2982 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
2983 GHC.Types.LT ->
2984 (#
2985 failInp,
2986 failExp
2987 #)
2988 GHC.Types.EQ ->
2989 (#
2990 farInp,
2991 failExp GHC.Base.<> farExp
2992 #)
2993 GHC.Types.GT ->
2994 (#
2995 farInp,
2996 farExp
2997 #)
2998 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
2999 else
3000 let _ = "checkHorizon.else"
3001 in let failExp =
3002 Data.Set.Internal.Bin
3003 1
3004 ( Symantic.Parser.Grammar.Combinators.SomeFailure
3005 ( case inputToken of
3006 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 11
3007 )
3008 )
3009 Data.Set.Internal.Tip
3010 Data.Set.Internal.Tip
3011 in let (#
3012 farInp,
3013 farExp
3014 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
3015 GHC.Types.LT ->
3016 (#
3017 failInp,
3018 failExp
3019 #)
3020 GHC.Types.EQ ->
3021 (#
3022 farInp,
3023 failExp GHC.Base.<> farExp
3024 #)
3025 GHC.Types.GT ->
3026 (#
3027 farInp,
3028 farExp
3029 #)
3030 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
3031 else
3032 let _ = "choicesBranch.else"
3033 in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
3034 in let _ = "catch ExceptionFailure"
3035 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
3036 let _ = "catch.ko ExceptionFailure"
3037 in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
3038 in let readFail = catchHandler
3039 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
3040 then
3041 let !(#
3042 c,
3043 cs
3044 #) = readNext inp
3045 in if (GHC.Classes.==) 'i' c
3046 then
3047 let readFail = readFail
3048 in let !(#
3049 c,
3050 cs
3051 #) = readNext cs
3052 in if (GHC.Classes.==) 'f' c
3053 then
3054 name
3055 ( let _ = "suspend"
3056 in \farInp farExp v (!inp) ->
3057 let _ = "resume"
3058 in join
3059 farInp
3060 farExp
3061 ( let _ = "resume.genCode"
3062 in v
3063 )
3064 inp
3065 )
3066 cs
3067 Data.Map.Internal.Tip
3068 else
3069 let _ = "checkToken.else"
3070 in let failExp =
3071 Data.Set.Internal.Bin
3072 1
3073 ( Symantic.Parser.Grammar.Combinators.SomeFailure
3074 ( case inputToken of
3075 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'f'
3076 )
3077 )
3078 Data.Set.Internal.Tip
3079 Data.Set.Internal.Tip
3080 in let (#
3081 farInp,
3082 farExp
3083 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
3084 GHC.Types.LT ->
3085 (#
3086 cs,
3087 failExp
3088 #)
3089 GHC.Types.EQ ->
3090 (#
3091 init,
3092 failExp GHC.Base.<> Data.Set.Internal.empty
3093 #)
3094 GHC.Types.GT ->
3095 (#
3096 init,
3097 Data.Set.Internal.empty
3098 #)
3099 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
3100 else
3101 let _ = "checkToken.else"
3102 in let failExp =
3103 Data.Set.Internal.Bin
3104 1
3105 ( Symantic.Parser.Grammar.Combinators.SomeFailure
3106 ( case inputToken of
3107 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'i'
3108 )
3109 )
3110 Data.Set.Internal.Tip
3111 Data.Set.Internal.Tip
3112 in let (#
3113 farInp,
3114 farExp
3115 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
3116 GHC.Types.LT ->
3117 (#
3118 inp,
3119 failExp
3120 #)
3121 GHC.Types.EQ ->
3122 (#
3123 init,
3124 failExp GHC.Base.<> Data.Set.Internal.empty
3125 #)
3126 GHC.Types.GT ->
3127 (#
3128 init,
3129 Data.Set.Internal.empty
3130 #)
3131 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
3132 else
3133 let _ = "checkHorizon.else"
3134 in let failExp =
3135 Data.Set.Internal.Bin
3136 1
3137 ( Symantic.Parser.Grammar.Combinators.SomeFailure
3138 ( case inputToken of
3139 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
3140 )
3141 )
3142 Data.Set.Internal.Tip
3143 Data.Set.Internal.Tip
3144 in let (#
3145 farInp,
3146 farExp
3147 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
3148 GHC.Types.LT ->
3149 (#
3150 inp,
3151 failExp
3152 #)
3153 GHC.Types.EQ ->
3154 (#
3155 init,
3156 failExp GHC.Base.<> Data.Set.Internal.empty
3157 #)
3158 GHC.Types.GT ->
3159 (#
3160 init,
3161 Data.Set.Internal.empty
3162 #)
3163 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
3164 name = \(!ok) (!inp) (!koByLabel) ->
3165 let _ = "catch ExceptionFailure"
3166 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
3167 let _ = "catch.ko ExceptionFailure"
3168 in if ( \( Data.Text.Internal.Text
3169 _
3170 i
3171 _
3172 )
3173 ( Data.Text.Internal.Text
3174 _
3175 j
3176 _
3177 ) -> i GHC.Classes.== j
3178 )
3179 inp
3180 failInp
3181 then
3182 let _ = "choicesBranch.then"
3183 in let _ = "resume"
3184 in ok
3185 farInp
3186 farExp
3187 ( let _ = "resume.genCode"
3188 in \x -> x
3189 )
3190 failInp
3191 else
3192 let _ = "choicesBranch.else"
3193 in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
3194 in let readFail = catchHandler
3195 in if readMore inp
3196 then
3197 let !(#
3198 c,
3199 cs
3200 #) = readNext inp
3201 in if Parsers.Nandlang.nandIdentLetter c
3202 then
3203 name
3204 ( let _ = "suspend"
3205 in \farInp farExp v (!inp) ->
3206 let _ = "resume"
3207 in ok
3208 farInp
3209 farExp
3210 ( let _ = "resume.genCode"
3211 in \x -> v x
3212 )
3213 inp
3214 )
3215 cs
3216 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
3217 else
3218 let _ = "checkToken.else"
3219 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp init Data.Set.Internal.empty
3220 else
3221 let _ = "checkHorizon.else"
3222 in let failExp =
3223 Data.Set.Internal.Bin
3224 1
3225 ( Symantic.Parser.Grammar.Combinators.SomeFailure
3226 ( case inputToken of
3227 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1
3228 )
3229 )
3230 Data.Set.Internal.Tip
3231 Data.Set.Internal.Tip
3232 in let (#
3233 farInp,
3234 farExp
3235 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
3236 GHC.Types.LT ->
3237 (#
3238 inp,
3239 failExp
3240 #)
3241 GHC.Types.EQ ->
3242 (#
3243 init,
3244 failExp GHC.Base.<> Data.Set.Internal.empty
3245 #)
3246 GHC.Types.GT ->
3247 (#
3248 init,
3249 Data.Set.Internal.empty
3250 #)
3251 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
3252 name = \(!ok) (!inp) (!koByLabel) ->
3253 let _ = "catch ExceptionFailure"
3254 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
3255 let _ = "catch.ko ExceptionFailure"
3256 in if ( \( Data.Text.Internal.Text
3257 _
3258 i
3259 _
3260 )
3261 ( Data.Text.Internal.Text
3262 _
3263 j
3264 _
3265 ) -> i GHC.Classes.== j
3266 )
3267 inp
3268 failInp
3269 then
3270 let _ = "choicesBranch.then"
3271 in let _ = "resume"
3272 in ok
3273 farInp
3274 farExp
3275 ( let _ = "resume.genCode"
3276 in \x -> x
3277 )
3278 failInp
3279 else
3280 let _ = "choicesBranch.else"
3281 in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
3282 in let readFail = catchHandler
3283 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)
3284 then
3285 let !(#
3286 c,
3287 cs
3288 #) = readNext inp
3289 in if (GHC.Classes.==) '!' c
3290 then
3291 name
3292 ( let _ = "suspend"
3293 in \farInp farExp v (!inp) ->
3294 name
3295 ( let _ = "suspend"
3296 in \farInp farExp v (!inp) ->
3297 name
3298 ( let _ = "suspend"
3299 in \farInp farExp v (!inp) ->
3300 let _ = "resume"
3301 in ok
3302 farInp
3303 farExp
3304 ( let _ = "resume.genCode"
3305 in \x -> v x
3306 )
3307 inp
3308 )
3309 inp
3310 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
3311 )
3312 inp
3313 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
3314 )
3315 cs
3316 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
3317 else
3318 let _ = "checkToken.else"
3319 in let failExp =
3320 Data.Set.Internal.Bin
3321 1
3322 ( Symantic.Parser.Grammar.Combinators.SomeFailure
3323 ( case inputToken of
3324 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '!'
3325 )
3326 )
3327 Data.Set.Internal.Tip
3328 Data.Set.Internal.Tip
3329 in let (#
3330 farInp,
3331 farExp
3332 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
3333 GHC.Types.LT ->
3334 (#
3335 inp,
3336 failExp
3337 #)
3338 GHC.Types.EQ ->
3339 (#
3340 init,
3341 failExp GHC.Base.<> Data.Set.Internal.empty
3342 #)
3343 GHC.Types.GT ->
3344 (#
3345 init,
3346 Data.Set.Internal.empty
3347 #)
3348 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
3349 else
3350 let _ = "checkHorizon.else"
3351 in let failExp =
3352 Data.Set.Internal.Bin
3353 1
3354 ( Symantic.Parser.Grammar.Combinators.SomeFailure
3355 ( case inputToken of
3356 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4
3357 )
3358 )
3359 Data.Set.Internal.Tip
3360 Data.Set.Internal.Tip
3361 in let (#
3362 farInp,
3363 farExp
3364 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
3365 GHC.Types.LT ->
3366 (#
3367 inp,
3368 failExp
3369 #)
3370 GHC.Types.EQ ->
3371 (#
3372 init,
3373 failExp GHC.Base.<> Data.Set.Internal.empty
3374 #)
3375 GHC.Types.GT ->
3376 (#
3377 init,
3378 Data.Set.Internal.empty
3379 #)
3380 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
3381 name = \(!ok) (!inp) (!koByLabel) ->
3382 let _ = "catch ExceptionFailure"
3383 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
3384 let _ = "catch.ko ExceptionFailure"
3385 in if ( \( Data.Text.Internal.Text
3386 _
3387 i
3388 _
3389 )
3390 ( Data.Text.Internal.Text
3391 _
3392 j
3393 _
3394 ) -> i GHC.Classes.== j
3395 )
3396 inp
3397 failInp
3398 then
3399 let _ = "choicesBranch.then"
3400 in let _ = "resume"
3401 in ok
3402 farInp
3403 farExp
3404 ( let _ = "resume.genCode"
3405 in \x -> x
3406 )
3407 failInp
3408 else
3409 let _ = "choicesBranch.else"
3410 in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
3411 in let _ = "catch ExceptionFailure"
3412 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
3413 let _ = "catch.ko ExceptionFailure"
3414 in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
3415 in let readFail = catchHandler
3416 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 17 inp)
3417 then
3418 let !(#
3419 c,
3420 cs
3421 #) = readNext inp
3422 in if (GHC.Classes.==) 'f' c
3423 then
3424 let readFail = readFail
3425 in let !(#
3426 c,
3427 cs
3428 #) = readNext cs
3429 in if (GHC.Classes.==) 'u' c
3430 then
3431 let readFail = readFail
3432 in let !(#
3433 c,
3434 cs
3435 #) = readNext cs
3436 in if (GHC.Classes.==) 'n' c
3437 then
3438 let readFail = readFail
3439 in let !(#
3440 c,
3441 cs
3442 #) = readNext cs
3443 in if (GHC.Classes.==) 'c' c
3444 then
3445 let readFail = readFail
3446 in let !(#
3447 c,
3448 cs
3449 #) = readNext cs
3450 in if (GHC.Classes.==) 't' c
3451 then
3452 let readFail = readFail
3453 in let !(#
3454 c,
3455 cs
3456 #) = readNext cs
3457 in if (GHC.Classes.==) 'i' c
3458 then
3459 let readFail = readFail
3460 in let !(#
3461 c,
3462 cs
3463 #) = readNext cs
3464 in if (GHC.Classes.==) 'o' c
3465 then
3466 let readFail = readFail
3467 in let !(#
3468 c,
3469 cs
3470 #) = readNext cs
3471 in if (GHC.Classes.==) 'n' c
3472 then
3473 name
3474 ( let _ = "suspend"
3475 in \farInp farExp v (!inp) ->
3476 name
3477 ( let _ = "suspend"
3478 in \farInp farExp v (!inp) ->
3479 name
3480 ( let _ = "suspend"
3481 in \farInp farExp v (!inp) ->
3482 name
3483 ( let _ = "suspend"
3484 in \farInp farExp v (!inp) ->
3485 let join = \farInp farExp v (!inp) ->
3486 name
3487 ( let _ = "suspend"
3488 in \farInp farExp v (!inp) ->
3489 name
3490 ( let _ = "suspend"
3491 in \farInp farExp v (!inp) ->
3492 name
3493 ( let _ = "suspend"
3494 in \farInp farExp v (!inp) ->
3495 let _ = "resume"
3496 in ok
3497 farInp
3498 farExp
3499 ( let _ = "resume.genCode"
3500 in \x -> v x
3501 )
3502 inp
3503 )
3504 inp
3505 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
3506 )
3507 inp
3508 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
3509 )
3510 inp
3511 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
3512 in let _ = "catch ExceptionFailure"
3513 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
3514 let _ = "catch.ko ExceptionFailure"
3515 in if ( \( Data.Text.Internal.Text
3516 _
3517 i
3518 _
3519 )
3520 ( Data.Text.Internal.Text
3521 _
3522 j
3523 _
3524 ) -> i GHC.Classes.== j
3525 )
3526 inp
3527 failInp
3528 then
3529 let _ = "choicesBranch.then"
3530 in name
3531 ( let _ = "suspend"
3532 in \farInp farExp v (!inp) ->
3533 let _ = "resume"
3534 in join
3535 farInp
3536 farExp
3537 ( let _ = "resume.genCode"
3538 in v
3539 )
3540 inp
3541 )
3542 failInp
3543 Data.Map.Internal.Tip
3544 else
3545 let _ = "choicesBranch.else"
3546 in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
3547 in let readFail = catchHandler
3548 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
3549 then
3550 let !(#
3551 c,
3552 cs
3553 #) = readNext inp
3554 in if (GHC.Classes.==) ':' c
3555 then
3556 name
3557 ( let _ = "suspend"
3558 in \farInp farExp v (!inp) ->
3559 name
3560 ( let _ = "suspend"
3561 in \farInp farExp v (!inp) ->
3562 let _ = "resume"
3563 in join
3564 farInp
3565 farExp
3566 ( let _ = "resume.genCode"
3567 in GHC.Tuple . ()
3568 )
3569 inp
3570 )
3571 inp
3572 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
3573 )
3574 cs
3575 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
3576 else
3577 let _ = "checkToken.else"
3578 in let failExp =
3579 Data.Set.Internal.Bin
3580 1
3581 ( Symantic.Parser.Grammar.Combinators.SomeFailure
3582 ( case inputToken of
3583 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ':'
3584 )
3585 )
3586 Data.Set.Internal.Tip
3587 Data.Set.Internal.Tip
3588 in let (#
3589 farInp,
3590 farExp
3591 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
3592 GHC.Types.LT ->
3593 (#
3594 inp,
3595 failExp
3596 #)
3597 GHC.Types.EQ ->
3598 (#
3599 farInp,
3600 failExp GHC.Base.<> farExp
3601 #)
3602 GHC.Types.GT ->
3603 (#
3604 farInp,
3605 farExp
3606 #)
3607 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
3608 else
3609 let _ = "checkHorizon.else"
3610 in let failExp =
3611 Data.Set.Internal.Bin
3612 1
3613 ( Symantic.Parser.Grammar.Combinators.SomeFailure
3614 ( case inputToken of
3615 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
3616 )
3617 )
3618 Data.Set.Internal.Tip
3619 Data.Set.Internal.Tip
3620 in let (#
3621 farInp,
3622 farExp
3623 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
3624 GHC.Types.LT ->
3625 (#
3626 inp,
3627 failExp
3628 #)
3629 GHC.Types.EQ ->
3630 (#
3631 farInp,
3632 failExp GHC.Base.<> farExp
3633 #)
3634 GHC.Types.GT ->
3635 (#
3636 farInp,
3637 farExp
3638 #)
3639 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
3640 )
3641 inp
3642 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
3643 )
3644 inp
3645 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
3646 )
3647 inp
3648 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
3649 )
3650 cs
3651 Data.Map.Internal.Tip
3652 else
3653 let _ = "checkToken.else"
3654 in let failExp =
3655 Data.Set.Internal.Bin
3656 1
3657 ( Symantic.Parser.Grammar.Combinators.SomeFailure
3658 ( case inputToken of
3659 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'n'
3660 )
3661 )
3662 Data.Set.Internal.Tip
3663 Data.Set.Internal.Tip
3664 in let (#
3665 farInp,
3666 farExp
3667 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
3668 GHC.Types.LT ->
3669 (#
3670 cs,
3671 failExp
3672 #)
3673 GHC.Types.EQ ->
3674 (#
3675 init,
3676 failExp GHC.Base.<> Data.Set.Internal.empty
3677 #)
3678 GHC.Types.GT ->
3679 (#
3680 init,
3681 Data.Set.Internal.empty
3682 #)
3683 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
3684 else
3685 let _ = "checkToken.else"
3686 in let failExp =
3687 Data.Set.Internal.Bin
3688 1
3689 ( Symantic.Parser.Grammar.Combinators.SomeFailure
3690 ( case inputToken of
3691 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'o'
3692 )
3693 )
3694 Data.Set.Internal.Tip
3695 Data.Set.Internal.Tip
3696 in let (#
3697 farInp,
3698 farExp
3699 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
3700 GHC.Types.LT ->
3701 (#
3702 cs,
3703 failExp
3704 #)
3705 GHC.Types.EQ ->
3706 (#
3707 init,
3708 failExp GHC.Base.<> Data.Set.Internal.empty
3709 #)
3710 GHC.Types.GT ->
3711 (#
3712 init,
3713 Data.Set.Internal.empty
3714 #)
3715 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
3716 else
3717 let _ = "checkToken.else"
3718 in let failExp =
3719 Data.Set.Internal.Bin
3720 1
3721 ( Symantic.Parser.Grammar.Combinators.SomeFailure
3722 ( case inputToken of
3723 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'i'
3724 )
3725 )
3726 Data.Set.Internal.Tip
3727 Data.Set.Internal.Tip
3728 in let (#
3729 farInp,
3730 farExp
3731 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
3732 GHC.Types.LT ->
3733 (#
3734 cs,
3735 failExp
3736 #)
3737 GHC.Types.EQ ->
3738 (#
3739 init,
3740 failExp GHC.Base.<> Data.Set.Internal.empty
3741 #)
3742 GHC.Types.GT ->
3743 (#
3744 init,
3745 Data.Set.Internal.empty
3746 #)
3747 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
3748 else
3749 let _ = "checkToken.else"
3750 in let failExp =
3751 Data.Set.Internal.Bin
3752 1
3753 ( Symantic.Parser.Grammar.Combinators.SomeFailure
3754 ( case inputToken of
3755 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 't'
3756 )
3757 )
3758 Data.Set.Internal.Tip
3759 Data.Set.Internal.Tip
3760 in let (#
3761 farInp,
3762 farExp
3763 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
3764 GHC.Types.LT ->
3765 (#
3766 cs,
3767 failExp
3768 #)
3769 GHC.Types.EQ ->
3770 (#
3771 init,
3772 failExp GHC.Base.<> Data.Set.Internal.empty
3773 #)
3774 GHC.Types.GT ->
3775 (#
3776 init,
3777 Data.Set.Internal.empty
3778 #)
3779 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
3780 else
3781 let _ = "checkToken.else"
3782 in let failExp =
3783 Data.Set.Internal.Bin
3784 1
3785 ( Symantic.Parser.Grammar.Combinators.SomeFailure
3786 ( case inputToken of
3787 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'
3788 )
3789 )
3790 Data.Set.Internal.Tip
3791 Data.Set.Internal.Tip
3792 in let (#
3793 farInp,
3794 farExp
3795 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
3796 GHC.Types.LT ->
3797 (#
3798 cs,
3799 failExp
3800 #)
3801 GHC.Types.EQ ->
3802 (#
3803 init,
3804 failExp GHC.Base.<> Data.Set.Internal.empty
3805 #)
3806 GHC.Types.GT ->
3807 (#
3808 init,
3809 Data.Set.Internal.empty
3810 #)
3811 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
3812 else
3813 let _ = "checkToken.else"
3814 in let failExp =
3815 Data.Set.Internal.Bin
3816 1
3817 ( Symantic.Parser.Grammar.Combinators.SomeFailure
3818 ( case inputToken of
3819 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'n'
3820 )
3821 )
3822 Data.Set.Internal.Tip
3823 Data.Set.Internal.Tip
3824 in let (#
3825 farInp,
3826 farExp
3827 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
3828 GHC.Types.LT ->
3829 (#
3830 cs,
3831 failExp
3832 #)
3833 GHC.Types.EQ ->
3834 (#
3835 init,
3836 failExp GHC.Base.<> Data.Set.Internal.empty
3837 #)
3838 GHC.Types.GT ->
3839 (#
3840 init,
3841 Data.Set.Internal.empty
3842 #)
3843 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
3844 else
3845 let _ = "checkToken.else"
3846 in let failExp =
3847 Data.Set.Internal.Bin
3848 1
3849 ( Symantic.Parser.Grammar.Combinators.SomeFailure
3850 ( case inputToken of
3851 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'u'
3852 )
3853 )
3854 Data.Set.Internal.Tip
3855 Data.Set.Internal.Tip
3856 in let (#
3857 farInp,
3858 farExp
3859 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
3860 GHC.Types.LT ->
3861 (#
3862 cs,
3863 failExp
3864 #)
3865 GHC.Types.EQ ->
3866 (#
3867 init,
3868 failExp GHC.Base.<> Data.Set.Internal.empty
3869 #)
3870 GHC.Types.GT ->
3871 (#
3872 init,
3873 Data.Set.Internal.empty
3874 #)
3875 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
3876 else
3877 let _ = "checkToken.else"
3878 in let failExp =
3879 Data.Set.Internal.Bin
3880 1
3881 ( Symantic.Parser.Grammar.Combinators.SomeFailure
3882 ( case inputToken of
3883 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'f'
3884 )
3885 )
3886 Data.Set.Internal.Tip
3887 Data.Set.Internal.Tip
3888 in let (#
3889 farInp,
3890 farExp
3891 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
3892 GHC.Types.LT ->
3893 (#
3894 inp,
3895 failExp
3896 #)
3897 GHC.Types.EQ ->
3898 (#
3899 init,
3900 failExp GHC.Base.<> Data.Set.Internal.empty
3901 #)
3902 GHC.Types.GT ->
3903 (#
3904 init,
3905 Data.Set.Internal.empty
3906 #)
3907 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
3908 else
3909 let _ = "checkHorizon.else"
3910 in let failExp =
3911 Data.Set.Internal.Bin
3912 1
3913 ( Symantic.Parser.Grammar.Combinators.SomeFailure
3914 ( case inputToken of
3915 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 18
3916 )
3917 )
3918 Data.Set.Internal.Tip
3919 Data.Set.Internal.Tip
3920 in let (#
3921 farInp,
3922 farExp
3923 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
3924 GHC.Types.LT ->
3925 (#
3926 inp,
3927 failExp
3928 #)
3929 GHC.Types.EQ ->
3930 (#
3931 init,
3932 failExp GHC.Base.<> Data.Set.Internal.empty
3933 #)
3934 GHC.Types.GT ->
3935 (#
3936 init,
3937 Data.Set.Internal.empty
3938 #)
3939 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
3940 name = \(!ok) (!inp) (!koByLabel) ->
3941 let _ = "resume"
3942 in ok
3943 init
3944 Data.Set.Internal.empty
3945 ( let _ = "resume.genCode"
3946 in GHC.Tuple . ()
3947 )
3948 inp
3949 name = \(!ok) (!inp) (!koByLabel) ->
3950 let _ = "resume"
3951 in ok
3952 init
3953 Data.Set.Internal.empty
3954 ( let _ = "resume.genCode"
3955 in GHC.Tuple . ()
3956 )
3957 inp
3958 name = \(!ok) (!inp) (!koByLabel) ->
3959 let _ = "resume"
3960 in ok
3961 init
3962 Data.Set.Internal.empty
3963 ( let _ = "resume.genCode"
3964 in \x -> \x -> x
3965 )
3966 inp
3967 in name
3968 ( let _ = "suspend"
3969 in \farInp farExp v (!inp) ->
3970 name
3971 ( let _ = "suspend"
3972 in \farInp farExp v (!inp) ->
3973 name
3974 ( let _ = "suspend"
3975 in \farInp farExp v (!inp) ->
3976 name
3977 ( let _ = "suspend"
3978 in \farInp farExp v (!inp) ->
3979 let join = \farInp farExp v (!inp) ->
3980 let _ = "resume"
3981 in finalRet
3982 farInp
3983 farExp
3984 ( let _ = "resume.genCode"
3985 in GHC.Show.show v
3986 )
3987 inp
3988 in let _ = "catch ExceptionFailure"
3989 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
3990 let _ = "catch.ko ExceptionFailure"
3991 in if ( \( Data.Text.Internal.Text
3992 _
3993 i
3994 _
3995 )
3996 ( Data.Text.Internal.Text
3997 _
3998 j
3999 _
4000 ) -> i GHC.Classes.== j
4001 )
4002 inp
4003 failInp
4004 then
4005 let _ = "choicesBranch.then"
4006 in let failExp = Data.Set.Internal.Bin 1 (Symantic.Parser.Grammar.Combinators.SomeFailure Symantic.Parser.Grammar.Combinators.FailureEnd) Data.Set.Internal.Tip Data.Set.Internal.Tip
4007 in let (#
4008 farInp,
4009 farExp
4010 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
4011 GHC.Types.LT ->
4012 (#
4013 failInp,
4014 failExp
4015 #)
4016 GHC.Types.EQ ->
4017 (#
4018 farInp,
4019 failExp GHC.Base.<> farExp
4020 #)
4021 GHC.Types.GT ->
4022 (#
4023 farInp,
4024 farExp
4025 #)
4026 in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
4027 else
4028 let _ = "choicesBranch.else"
4029 in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
4030 in let _ = "catch ExceptionFailure"
4031 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
4032 let _ = "catch.ko ExceptionFailure"
4033 in let _ = "resume"
4034 in join
4035 farInp
4036 farExp
4037 ( let _ = "resume.genCode"
4038 in GHC.Tuple . ()
4039 )
4040 inp
4041 in let readFail = catchHandler
4042 in if readMore inp
4043 then
4044 let !(#
4045 c,
4046 cs
4047 #) = readNext inp
4048 in if (\x -> GHC.Types.True) c
4049 then catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
4050 else
4051 let _ = "checkToken.else"
4052 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
4053 else
4054 let _ = "checkHorizon.else"
4055 in let failExp =
4056 Data.Set.Internal.Bin
4057 1
4058 ( Symantic.Parser.Grammar.Combinators.SomeFailure
4059 ( case inputToken of
4060 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1
4061 )
4062 )
4063 Data.Set.Internal.Tip
4064 Data.Set.Internal.Tip
4065 in let (#
4066 farInp,
4067 farExp
4068 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
4069 GHC.Types.LT ->
4070 (#
4071 inp,
4072 failExp
4073 #)
4074 GHC.Types.EQ ->
4075 (#
4076 farInp,
4077 failExp GHC.Base.<> farExp
4078 #)
4079 GHC.Types.GT ->
4080 (#
4081 farInp,
4082 farExp
4083 #)
4084 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
4085 )
4086 inp
4087 Data.Map.Internal.Tip
4088 )
4089 inp
4090 Data.Map.Internal.Tip
4091 )
4092 inp
4093 Data.Map.Internal.Tip
4094 )
4095 init
4096 Data.Map.Internal.Tip
Library for parsing