h"LI@'      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                             None$%&()0 >symantic-parserLeftsymantic-parserRightsymantic-parserAssociate to the left: a  b  c == (a  b)  csymantic-parserAssociate to the right: a  b  c == a  (b  c)symantic-parser Associate to both sides, but to  when reading.symantic-parserGiven   and * of its parent operator, and the operand  it is in, return whether an  % operator needs to be enclosed by a .symantic-parserIf  is , enclose the given  by given , otherwise returns the same ."   !"     !None$%&()0 /2103456789:;<=>?DCBA@EFGHIJK?DCBA@EFGHI=>;<9:J785634K/210None$%&().0;lWsymantic-parserA newtype to disambiguate the f instance to any other interpreter when there is also one or more fs to other interpreters with a different interpretation than the generic one.Zsymantic-parser(Convenient type class synonym for using h]symantic-parser(Convenient type class synonym for using h`symantic-parser(Convenient type class synonym for using hcsymantic-parser(Convenient type class synonym for using hdsymantic-parser(Convenient type class synonym for using hesymantic-parserConvenient type class synonym. Note that this is not necessarily a bijective g lation, a g0 being not necessarily injective nor surjective.fsymantic-parserA glation from an interpreter (from) to an interpreter (to).WXYZ[\]^_`abcdefghijklmhfgedijcab`k^_]l[\ZmWXYNone$%&()0;6vsymantic-parserRemove  when non-recursive or unused.|symantic-parserTODO: unused so far, will it be useful somewhere at a later stage?}symantic-parser.Interpreter detecting some (Haskell embedded) let definitions used at least once and/or recursively, in order to replace them with the  and  combinators. See 'https://doi.org/10.1145/1596638.1596653'Type-safe observable sharing in Haskellsymantic-parser,Note that the observable sharing enabled by  is not perfect as it will not observe all the sharing explicitely done.Note also that the observed sharing could be different between ghc and ghci.symantic-parserThis class is not for manual usage like usual symantic operators, here  and  are introduced by .symantic-parser( letName x) let-binds  (letName) to be equal to (x).symantic-parser( isRec letName) is a reference to  (letName). (isRec) is  iif. this 2erence is recursive, ie. is reachable within its inition.symantic-parser( x) is like ( x)# but it also forces evaluation of (x) to ensure that the  is correct first time, which avoids to produce a tree bigger than needed.Note that this function uses  instead of returning in , this is apparently required to avoid infinite loops due to unstable / in compiled code, and sometimes also in ghci.Note that maybe  0https://gitlab.haskell.org/ghc/ghc/-/issues/2916pseq should be used here.vwxyz|{}~}~yz|{vwxNone$%&()0symantic-parserInitial encoding of .symantic-parserFinal encoding of some Haskell functions useful for some optimizations in  optimizeComb.symantic-parser Compile-time  and corresponding + (that can produce that value at runtime).%%9 09 9 09 None$%&()04;=$symantic-parser(rl  rr) parses (rl)6 and return its return value or, if it fails, parses (rr) from where (rl): has left the input stream, and returns its return value.symantic-parser(empty)2 parses nothing, always failing to return a value.symantic-parser( ra)6 records the input stream position, then parses like (ra) and either returns its value it it succeeds or fails if it fails but with a reset of the input stream to the recorded position. Generally used on the first alternative: ( rl  rr).symantic-parserLike () but with different returning types for the alternatives, and a return value wrapped in an  accordingly.symantic-parserThis is like the usual Functor and  Applicative type classes from the base package, but using ( a) instead of just (a) to be able to use and pattern match on some usual terms of type (a) (like &) and thus apply some optimizations. (repr) , for "representation", is the usual tagless-final abstraction over the many semantics that this syntax (formed by the methods of type class like this one) will be interpreted.symantic-parser(a2b  ra) parses like (ra)" but maps its returned value with (a2b).symantic-parserLike  but with its arguments -ped.symantic-parser(a  rb) parses like (rb)6 but discards its returned value by replacing it with (a).symantic-parser(ra  b) parses like (ra)6 but discards its returned value by replacing it with (b).symantic-parser( a)9 parses the empty string, always succeeding in returning (a).symantic-parser(ra2b  ra) parses sequentially (ra2b) and then (ra);, and returns the application of the function returned by (ra2b) to the value returned by (ra).symantic-parser( a2b2c ra rb) parses sequentially (ra) and then (rb)", and returns the application of (a2b2c)) to the values returned by those parsers.symantic-parser(ra  rb) parses sequentially (ra) and then (rb), and returns like (ra)!, discarding the return value of (rb).symantic-parser(ra  rb) parses sequentially (ra) and then (rb), and returns like (rb)!, discarding the return value of (ra).symantic-parserLike  but with its arguments -ped. 33444444444None!$%&()0%  None$%&'()0( symantic-parserPattern-matchable inators of the grammar. (repr) is not strictly necessary since it's only a phantom type (no constructor use it as a value), but having it: emphasizes that those inators will be gformed again (eg. in DumpComb or Instr uctions).(Avoid overlapping instances between (f ( repr) repr) and (f ( repr) ( letName repr))4344444 None$%&()0)Tsymantic-parserLike  but type-binding  (letName) to  to help type inference.}~}~ None$%&()0) None$%&().0*symantic-parserA usual pipeline to interpret  inators:  then  then a polymorphic (repr).symantic-parserA usual pipeline to show  inators:  then  then  then .  !}~ None$%&().0>8symantic-parser!Making the control-flow explicit.symantic-parser?Type-level natural numbers, using the Peano recursive encoding.symantic-parseructions for the .symantic-parser( x k) pushes (x) on the  valueStack and continues with the next uction (k).symantic-parser( k) pushes (x) on the  valueStack.symantic-parser( f k) pops two values from the  valueStack, and pushes the result of (f) applied to them.symantic-parser() raises an error from the  failStack.symantic-parser( k) removes a  FailHandler from the  failStack and continues with the next uction (k).symantic-parser( l r) tries the (l) ,uction in a new failure scope such that if (l) raises a failure, it is caught, then the input is pushed as it was before trying (l) on the  valueStack), and the control flow goes on with the (r) uction.symantic-parser( k) removes the input from the  valueStack and continues with the next uction (k) using that input.symantic-parser( k) pushes the input (inp) on the  valueStack and continues with the next uction (k).symantic-parser( l r).symantic-parser( k) pops two values on the  valueStack, pushes the first popped-out, then the second, and continues with the next uction (k).symantic-parser( ps bs d).symantic-parser( n v k) binds the  (n) to the  Instr'uctions (v), s (n) and continues with the next uction (k).symantic-parser( n k) pass the control-flow to the  named (n).symantic-parser( n k) pass the control-flow to the  named (n), and when it urns, continues with the next uction (k).symantic-parser()) returns the value stored in a singleton  valueStack.symantic-parser( expected p k) reads a Char (c) from the input, if (p c) is  then continues with the next uction (k) on, otherwise .symantic-parser( ok ko) pops a  from the  valueStack and continues either with the uction (ok) if it is  or (ko) otherwise.symantic-parser( k) pops (x) and (x2y) from the  valueStack , pushes (x2y x) and continues with the next uction (k).symantic-parser( f k).symantic-parserIf no input has been consumed by the failing alternative then continue with the given continuation. Otherwise, propagate the ure.symantic-parser( k f) factorizes (k) in (f), by introducing a . if necessary, and passing the corresponding  to (f), or (k)# as is when factorizing is useless.?? None$%&()04;#symantic-parser/This is a context only present at compile-time.symantic-parser Generate the  parsing the input.symantic-parser( input mach) generates TemplateHaskell code parsing given  according to given machine.((None$%&()0?DCB@AEFGHIJKNone$%&()0>  !/201013456789:;<=>?DCB@AEFGHIJK}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCCDDEEFGHHIIJKLMNOPQRSTUVWXYZ[\]^_`abbcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                             &symantic-parser-0.0.0.20210102-inplaceSymantic.Parser.Grammar.FixitySymantic.Parser.Machine.InputSymantic.Univariant.TransSymantic.Univariant.LetableSymantic.Parser.Haskell#Symantic.Parser.Grammar.CombinatorsSymantic.Parser.Grammar.Write Symantic.Parser.Grammar.Optimize&Symantic.Parser.Grammar.ObserveSharingSymantic.Parser.Grammar.DumpSymantic.Parser.Grammar$Symantic.Parser.Machine.Instructions Symantic.Parser.Machine.GenerateSymantic.Parser.Machine.DumpSymantic.Parser.MachineSymantic.ParserPairSideSideLSideR AssociativityAssocLAssocRAssocB PrecedenceOf precedence PrecedenceInfixinfix_associativityinfix_precedenceUnifixPrefixPostfixunifix_precedenceFixityFixity1Fixity2infixLinfixRinfixBinfixNinfixN0infixN5 isPairNeeded pairIfNeeded pairAngle pairBrace pairBracket pairParen$fPrecedenceOfUnifix$fPrecedenceOfInfix$fPrecedenceOfFixity $fEqFixity $fShowFixity $fEqInfix $fShowInfix$fEqAssociativity$fShowAssociativity$fEqSide $fShowSide $fEqUnifix $fShowUnifixInputCursor InputTokencursorOfUnpackedLazyByteStringOffWithStreamAndOffWithStream:>CharListText16 Cursorableoffset compareOffset lowerOffset sameOffset shiftRightshiftRightText shiftLeftTextshiftRightByteStringshiftLeftByteStringoffWithnomoreemptyUnpackedLazyByteString$fCursorableText$fCursorableInt$fCursorableOffWith$fShowUnpackedLazyByteString"$fCursorableUnpackedLazyByteString$fInputByteString$fInputByteString0 $fInputText $fInputUArray $fInput[] $fShowOffWithAnyunAny Liftable3Trans3trans3 Liftable2Trans2trans2 Liftable1Trans1trans1 UnliftableLiftableBiTransTranstransOutputliftunliftlift1lift2lift3$fTrans3reprAny$fTrans2reprAny$fTrans1reprAny$fTransreprAny$fTrans3Anyrepr$fTrans2Anyrepr$fTrans1Anyrepr$fTransAnyrepr CleanDefs unCleanDefsObserveSharingStateoss_refsoss_recsObserveSharingunObserveSharing SharingName MakeLetName makeLetNameLetabledefrefmakeSharingNameobserveSharingobserveSharingNode$fHashableSharingName$fEqSharingName$fLetableletNameCleanDefs$fTrans3reprCleanDefs$fTrans2reprCleanDefs$fTrans1reprCleanDefs$fTransreprCleanDefs$fLetableletNameObserveSharing$fTrans3CleanDefsObserveSharing$fTrans2CleanDefsObserveSharing$fTrans1CleanDefsObserveSharing$fTransCleanDefsObserveSharingHaskell:.:$:@ConsConstEqFlipIdUnit Haskellable.$.@boolcharconsconsteqflipidnilunitleftrightnothingjustValueunValue ValueCodevaluecodegetValuegetCode$fHaskellableCode$fHaskellableValue$fHaskellableValueCode$fHaskellableHaskell$fTransValueCodeHaskell$fTransHaskellValueCode$fTransHaskellCode$fTransHaskellValue $fShowHaskellLookablelooknegLookeof ErrorItemErrorItemTokenErrorItemLabel ErrorItemEnd SatisfiablesatisfyFoldablechainPre chainPost Matchable conditionalmatch Selectablebranch Alternable<|>emptytry<+> Applicable<$><&><$$>pure<*>liftA2<**><**> optionallyoptionaloptionchoicemaybePmanyTill<:>sequencetraverserepeatbetweenstringnoneOfofCharsmoreanyChartokentokensitemvoidpfoldrpfoldr1pfoldlpfoldl1chainl1'chainl1chainlmanymanyNsomeskipMany skipManyNskipSomesepBysepBy1endByendBy1sepEndBy sepEndBy1$fLiftLiftedRepErrorItem$fShowErrorItem$fOrdErrorItem $fEqErrorItem WriteCombInhwriteCombInh_indentwriteCombInh_opwriteCombInh_pair WriteComb unWriteCombemptyWriteCombInh writeCombpairWriteCombInh$fFoldableWriteComb$fLookableWriteComb$fMatchableWriteComb$fSelectableWriteComb$fSatisfiableWriteCombtok$fAlternableWriteComb$fApplicableWriteComb$fLetableletNameWriteComb$fIsStringWriteComb OptimizeCombunOptimizeCombCombPureSatisfyItemTryLookNegLookEof:<*>:<|>EmptyBranchMatchChainPre ChainPostDefRef:*>:<*:<$:$>:<$> optimizeComboptimizeCombNode$fMakeLetNameName$fTransCombrepr$fLetableNameComb$fLookableComb$fSatisfiableCombtok$fFoldableComb$fMatchableComb$fSelectableComb$fAlternableComb$fApplicableComb$fFoldableOptimizeComb$fLookableOptimizeComb$fMatchableOptimizeComb$fSelectableOptimizeComb$fSatisfiableOptimizeCombtok$fAlternableOptimizeComb$fApplicableOptimizeComb$fLetableletNameOptimizeComb$fTrans3CombOptimizeComb$fTrans2CombOptimizeComb$fTrans1CombOptimizeComb$fTransCombOptimizeComb$fTransOptimizeCombComb$fTransOptimizeCombrepr$fFoldableCleanDefs$fLookableCleanDefs$fMatchableCleanDefs$fSelectableCleanDefs$fSatisfiableCleanDefstok$fAlternableCleanDefs$fApplicableCleanDefs$fLookableObserveSharing$fFoldableObserveSharing$fMatchableObserveSharing$fSelectableObserveSharing$fApplicableObserveSharing$fAlternableObserveSharing$fSatisfiableObserveSharingtok$fHashableNameDumpComb unDumpCombdumpComb$fFoldableDumpComb$fLookableDumpComb$fMatchableDumpComb$fSelectableDumpComb$fSatisfiableDumpCombtok$fAlternableDumpComb$fApplicableDumpComb$fLetableletNameDumpComb$fIsStringDumpComb$fShowDumpCombGrammargrammar showGrammarMachine unMachinePeanoZeroSuccReadablereadJoinabledefJoinrefJoin Routinable subroutinecallretjump Inputable loadInput pushInputFailablefailpopFail catchFail Branchablecase_choices StackablepushpopliftI2swap ExecutableLetName unLetName InstrPureInstrPureHaskellInstrPureSameOffsetInstrPushPopLiftI2FailPopFail CatchFail LoadInput PushInputCaseSwapChoices SubroutineJumpCallRetReadDefJoinRefJoinIfAppFmap runMachinefailIfConsumedmakeJoin$fTransInstrPureCode$fShowInstrPure$fTransInstrrepr$fFoldableMachine$fLetableNameMachine$fLookableMachine$fMatchableMachine$fSelectableMachine$fSatisfiableMachinetok$fAlternableMachine$fApplicableMachine $fEqLetName $fShowLetName FailStackFailStackEmpty FailStackCons failStackHead failStackTail ValueStackValueStackEmptyValueStackConsvalueStackHeadvalueStackTailGenCtx valueStack failStackretCodeinput moreInput nextInput farthestInputfarthestExpecting FailHandler SubRoutineContOffset ParsingErrorParsingErrorStandardparsingErrorOffsetparsingErrorUnexpectedparsingErrorExpectingGenunGengeneratesuspendresumesatemitLengthCheckliftCode liftCode1 liftCode2$fReadableGenChar $fJoinableGen$fRoutinableGen$fInputableGen $fFailableGen$fBranchableGen$fStackableGen$fShowParsingError DumpInstr unDumpInstr dumpInstr dumpInstrCmd dumpInstrArg$fReadableDumpInstrinp$fJoinableDumpInstr$fRoutinableDumpInstr$fInputableDumpInstr$fFailableDumpInstr$fBranchableDumpInstr$fStackableDumpInstr$fIsStringDumpInstr$fShowDumpInstrParsermachine runParserghc-prim GHC.TypesTruebase Data.StringIsStringGHC.StableName StableNamemakeStableName GHC.IO.UnsafeunsafePerformIOIO Data.EitherEitherGHC.Basetemplate-haskellLanguage.Haskell.TH.SyntaxNameGHC.ShowshowBool Language.Haskell.TH.Lib.InternalCodeQ