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