h"`)SD      !"#$%&'()*+,-./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 Z/2103456789:;<=>?DCBA@EFGHIJK?DCBA@EFGHI=>;<9:J785634K/210None$%&().0;Wsymantic-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; vsymantic-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-parser$Useful on golden unit tests because  change often when changing unrelated source code or even changing basic GHC or executable flags.symantic-parserThis class is not for end-users 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.symantic-parserAlways return " hidden",symantic-parserLike .vwxyz|{}~}~yz|{vwxNone$%&()0;symantic-parser*Single-out some Haskell terms in order to symantic-parserApplication, aka. unabstract.symantic-parserLambda term abstraction, in HOAS (Higher-Order Abstract Syntax) style.symantic-parserLike  but whose argument is used only once, hence safe to beta-reduce (inline) without duplicating work.9 9 0None$%&'()0symantic-parserInitial encoding of some . symantics, useful for some optimizations in .symantic-parserBlack-box for all terms neither interpreted nor pattern-matched.symantic-parserBeta-reduce the left-most outer-most lambda abstraction (aka. normal-order reduction), but to avoid duplication of work, only those manually marked as using their variable at most once. This is mainly to get prettier splices.DOC: Demonstrating Lambda Calculus Reduction, Peter Sestoft, 2001, >https://www.itu.dk/people/sestoft/papers/sestoft-lamreduce.pdf  9 None!$%&()04>'  None$%&()0+None$%&()04;=)isymantic-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. 33444444444 None!$%&()0+2   None$%&()0+ None$%&'()0/ symantic-parserSome inator existentialized over the actual combinator symantic class. Useful to handle a list of inators without requiring impredicative quantification. Must be used by pattern-matching on the 6 data-constructor, to bring the constraints in scope.The optimizations are directly applied within it, to avoid introducing an extra newtype, this also give a more comprehensible code.symantic-parserinators of the Grammar#. This is an extensible data-type.symantic-parser&Convenient utility to pattern-match a .symantic-parser(unSomeComb c ::  ( comb repr a)). extract the data-constructor from the given  iif. it belongs to the ( comb repr a) data-instance.3444 None$%&()00{symantic-parserLike  but type-binding  (letName) to ( to avoid the trouble to always set it.symantic-parser Needed by .vwxyz{|}~vwxyz{|}~ None$%&().01symantic-parserA usual pipeline to interpret  inators:  then  then a polymorphic (repr).symantic-parserAn usual pipeline to show  inators:  then  then  then .  !vwxyz{|}~None$%&().0>66symantic-parser( ok ko) pops a  from the  valueStack and continues either with the Instruction (ok) if it is  or (ko) otherwise.symantic-parser( f k).symantic-parser( k) pops (x) and (x2y) from the  valueStack , pushes (x2y x) and continues with the next Instruction (k).symantic-parser of a  or / indexed by the return type of the factorized Instr&uctions. This helps type-inferencing.symantic-parserAll the Instructions.symantic-parserType-level natural numbers, using the Peano recursive encoding.%%None$%&()07nsymantic-parserHelper to view a command.symantic-parserHelper to view an argument.None$%&'()0Csymantic-parserSome uction existantialized over the actual instruction symantic class. Useful to handle a list of uctions without requiring impredicative quantification. Must be used by pattern-matching on the 6 data-constructor, to bring the constraints in scope.As in , a first pass of optimizations is directly applied in it to avoid introducing an extra newtype, this also give a more comprehensible code.symantic-parseructions of the #. This is an extensible data-type.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( 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() 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( l r).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( 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( k) pops two values on the  valueStack, pushes the first popped-out, then the second, and continues with the next uction (k).symantic-parser&Convenient utility to pattern-match a .symantic-parser(unSomeInstr i ::  ( comb repr inp vs es a)). extract the data-constructor from the given  iif. it belongs to the ( comb repr a) data-instance.None$%&()0Gsymantic-parserA  is a tree of uctions, where each uction is built by a continuation to be able to introspect, duplicate and/or change the next uction.symantic-parserBuild an interpreter of the  of the given .symantic-parserIf no input has been consumed by the failing alternative then continue with the given continuation. Otherwise, propagate the ure.symantic-parser( m) factorize the next uction to be able to reuse it multiple times without duplication. It does so by introducing a  and passing the corresponding  as next  uction to (m)2, unless factorizing is useless because the next uction is already a  or a (. It should be used each time the next uction is used multiple times.None$%&()04N& symantic-parserThis is an inherited (top-down) context only present at compile-time, to build TemplateHaskell splices.symantic-parser/Remaining horizon already checked. Updated by " and reset elsewhere when needed.symantic-parserMinimal horizon for each  or 7. This can be done as an inherited attribute because OverserveSharing introduces def! as an ancestor node of all the refs pointing to it. Same for  and its s.symantic-parserSynthetized minimal input length required for a successful parsing. Used with  to factorize input length checks, instead of checking the input length one 1 at a time at each .symantic-parserNote that if an  greater than 1 is amongst the  then this is only the 1" at the begining of the expected .symantic-parser Generate the  parsing the input.symantic-parserSynthetized (bottom-up) minimal input length required by the parser to not fail. This requires a  containing the minimal  s of all the s this parser s, s or s to.symantic-parser( input mach) generates TemplateHaskell code parsing the given  according to the given .symantic-parser*Generate a continuation to be called with  , used when  urns. The return value is  ed on the .symantic-parserGenerate a call to the  continuation. Used when  urns.))None$%&()0Osymantic-parserLike a  but not bound to the  interpreter.symantic-parserBuild a  able to  for the given ./201013456789:;<=>?DCB@AEFGHIJKNone$%&()0P  !/201013456789:;<=>?DCB@AEFGHIJKvwxyz{|}~ !!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHHIIJJKLMMNNOPQRSTUVWXYZ[\]^_`abcdefgghijklmnopqrstuvwxyz{|}~                                                                                                   &symantic-parser-0.1.0.20210201-inplaceSymantic.Parser.Grammar.FixitySymantic.Parser.Machine.InputSymantic.Univariant.TransSymantic.Univariant.LetableSymantic.Parser.Haskell.Term Symantic.Parser.Haskell.OptimizeSymantic.Parser.Haskell.View#Symantic.Parser.Grammar.CombinatorsSymantic.Parser.Grammar.WriteSymantic.Parser.Grammar.View Symantic.Parser.Grammar.Optimize&Symantic.Parser.Grammar.ObserveSharingSymantic.Parser.Grammar$Symantic.Parser.Machine.InstructionsSymantic.Parser.Machine.View Symantic.Parser.Machine.OptimizeSymantic.Parser.Machine.Program Symantic.Parser.Machine.GenerateSymantic.Parser.MachineSymantic.ParserSymantic.Parser.HaskellPairSideSideLSideR 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 ShowLetName showLetName MakeLetName makeLetNameLetabledefrefmakeSharingNameobserveSharingobserveSharingNode$fShowLetNameFalseletName$fShowLetNameTrueletName$fHashableSharingName$fEqSharingName$fLetableletNameCleanDefs$fTrans3reprCleanDefs$fTrans2reprCleanDefs$fTrans1reprCleanDefs$fTransreprCleanDefs$fLetableletNameObserveSharing$fTrans3CleanDefsObserveSharing$fTrans2CleanDefsObserveSharing$fTrans1CleanDefsObserveSharing$fTransCleanDefsObserveSharing ValueCodevaluecodeTermable.@lamlam1boolcharconsnilequnitleftrightnothingjustconstflipid.$$fTermableCode$fTermableIdentity$fTermableValueCodeTerm:@LamLam1VarCharConsEqunTerm optimizeTerm$fTransTermTerm$fTransTermTerm0$fTransTermValueCode$fTransTermCode$fTransTermIdentity$fTermableTerm$fTransreprTerm ViewTermInhviewTermInh_opviewTermInh_pairviewTermInh_lamDepthViewTerm unViewTerm pairViewTerm $fShowTerm$fShowViewTerm$fIsStringViewTermLookablelooknegLookeof ErrorItemErrorItemTokenErrorItemLabelErrorItemHorizon ErrorItemEnd SatisfiablesatisfyitemFoldablechainPre chainPost Matchable conditionalmatch Selectablebranch Alternable<|>emptytry<+> Applicable<$><&><$$>pure<*>liftA2<**><**> TermGrammar optionallyoptionaloptionchoicemaybePmanyTill<:>sequencetraverserepeatbetweenstringoneOfnoneOfofCharsmoreanyChartokentokensvoidpfoldrpfoldr1pfoldlpfoldl1chainl1'chainl1chainlmanymanyNsomeskipMany skipManyNskipSomesepBysepBy1endByendBy1sepEndBy sepEndBy1$fLiftLiftedRepErrorItem$fShowErrorItem$fOrdErrorItem $fEqErrorItemWriteGrammarInhwriteGrammarInh_indentwriteGrammarInh_opwriteGrammarInh_pair WriteGrammarunWriteGrammaremptyWriteGrammarInh writeGrammarpairWriteGrammarInh$fFoldableWriteGrammar$fLookableWriteGrammar$fMatchableWriteGrammar$fSelectableWriteGrammar$fSatisfiabletokWriteGrammar$fAlternableWriteGrammar$fApplicableWriteGrammar$fLetableletNameWriteGrammar$fIsStringWriteGrammar ViewGrammar unViewGrammar viewGrammar$fFoldableViewGrammar$fLookableViewGrammar$fMatchableViewGrammar$fSelectableViewGrammar$fSatisfiabletokViewGrammar$fAlternableViewGrammar$fApplicableViewGrammar$fLetableletNameViewGrammar$fIsStringViewGrammar$fShowViewGrammarSomeCombReprCombCombOptimizeGrammarDefRefSatisfyItemLookNegLookEof ChainPreC ChainPostC ConditionalBranchEmpty:<|>:TryPure:<*>::<*::*>::$>::<$>:optimizeGrammar unSomeComb$fMakeLetNameName$fTransCombrepr$fTransCombrepr0$fTransCombrepr1$fTransCombrepr2$fTransCombrepr3$fTransCombrepr4$fTransCombrepr5$fTransCombrepr6$fLetableletNameSomeComb$fSatisfiabletokSomeComb$fLookableSomeComb$fFoldableSomeComb$fMatchableSomeComb$fSelectableSomeComb$fAlternableSomeComb$fApplicableSomeComb$fTransSomeCombrepr$fFoldableCleanDefs$fLookableCleanDefs$fMatchableCleanDefs$fSelectableCleanDefs$fSatisfiabletokCleanDefs$fAlternableCleanDefs$fApplicableCleanDefs$fLookableObserveSharing$fFoldableObserveSharing$fMatchableObserveSharing$fSelectableObserveSharing$fApplicableObserveSharing$fAlternableObserveSharing$fSatisfiabletokObserveSharing$fHashableNameGrammargrammar showGrammarReadablereadJoinabledefJoinrefJoin Inputable loadInput pushInputFailablefailpopFail catchFail BranchablecaseIchoicesifI Routinable subroutinecallretjump StackablepushpopliftI2swapmapIappILetName unLetName ReprInstrMachinePeanoZeroSucc TermInstr $fEqLetName $fShowLetName ViewMachine unViewMachine viewMachine viewInstrCmd viewInstrArg$fReadabletokViewMachine$fJoinableViewMachine$fRoutinableViewMachine$fInputableViewMachine$fFailableViewMachine$fBranchableViewMachine$fStackableViewMachine$fIsStringViewMachine$fShowViewMachine SomeInstrInstrReadDefJoinRefJoin LoadInput PushInputFailPopFail CatchFailCaseChoices SubroutineJumpCallRetPushPopLiftI2Swap unSomeInstr$fTransInstrrepr$fTransInstrrepr0$fTransInstrrepr1$fTransInstrrepr2$fTransInstrrepr3$fTransInstrrepr4$fTransInstrrepr5$fReadabletokSomeInstr$fJoinableSomeInstr$fInputableSomeInstr$fFailableSomeInstr$fBranchableSomeInstr$fRoutinableSomeInstr$fStackableSomeInstr$fTransSomeInstrreprProgram unProgramoptimizeMachinefailIfConsumedjoinNext$fFoldableProgram$fLetableNameProgram$fLookableProgram$fMatchableProgram$fSelectableProgram$fSatisfiabletokProgram$fAlternableProgram$fApplicableProgram FailStackFailStackEmpty FailStackCons failStackHead failStackTail ValueStackValueStackEmptyValueStackConsvalueStackHeadvalueStackTailGenCtx valueStack failStackretCodeinput moreInput nextInput farthestInputfarthestExpectingcheckedHorizonminHorizonByName FailHandlerContHorizonOffset ParsingErrorParsingErrorStandardparsingErrorOffsetparsingErrorUnexpectedparsingErrorExpectingGen minHorizonunGengenCode generateCodegenerateSuspendgenerateResume checkHorizon checkToken$fReadableCharGen $fJoinableGen$fRoutinableGen$fInputableGen $fFailableGen$fBranchableGen$fStackableGen$fShowParsingError ParserReprParsermachine runParserghc-prim GHC.TypesTruebase Data.StringIsStringGHC.StableName StableNamemakeStableName GHC.IO.UnsafeunsafePerformIOIOGHC.ShowShow Data.EitherEitherGHC.Base GHC.MaybeMaybetemplate-haskellLanguage.Haskell.TH.SyntaxNameshowBool Language.Haskell.TH.Lib.InternalCodeQ