^V      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !" # $ % & ' ( )!*!+!,!-!.!/!0!1!2!3!4!5!6!7!8!9!:!;"<#=#>#?$@%A%B%C%D&E&F&G'H(I(J)K)L)M*N*O*P*Q+R+S+T+U+.NoneThe 6 class identifies a type that can be used as terminal . identifier in a grammar definition. The type t itself is an C abstract identifier, identifying a certain type of terminals, but  any value of type t- can correspond to a possibly infinite numer  of values of type 'ConcreteToken t'". For example, if you use a lexer H in a simple arithmetic expressions grammar, your lexer would typically  return values like PLUS, MINUS , but also ' INTEGER 42' when a J number is lexed. In this case, a separate Token type t would be defined,  such that a value  INTEGER_T of the  type t could & correspond to all values of the form ' INTEGER n' (for n an Integer)  of type 'ConcreteToken t' . A production rule defined as  token5 INTEGER_T would then produce result values of type   t (e.g. INTEGER 42). The requirements on * types are relatively strict, but this is ? necessary to make it usable in table-based parser algorithms.  We reference the V! class to allow for compile-time C precalculation of tables using Template Haskell (See the LL1 and  RealLL1 parsers). CNote that in some cases it is inefficient to use Char directly as I token type, because of the big amount of tokens. For example when using  transformLeftCorner+, the new domain will contain O(n*t + n^2) C non-terminals where n is the amount of non-terminals and t is th J number of tokens, so when using this transformation, it is beneficial to . use a token type with less token values than W, at E least if you will use algorithms that fold over the full new grammar' s domain  (e.g.  printGrammar does, printReachableGrammar doesn't). The  function classifies a given  t into , the value of type t it is represented by. The ( function returns a (possibly infinite) % list of all concrete tokens of type 'ConcreteToken t' # corresponding to a given token of  type t XXNone SA generic wrapper type that restricts a semantic value family over a bigger domain  to a smaller domain. A decent Domain phi should instantiate the , ,  and . Avoid Y using this type class in constraints, use more specific type classes whenever possible. iNote: instances for this type class are not automatically derived, and you have to manually instantiate ( it with an empty implementation block.  A domain phi that is an instance of the  type class supports L overriding a function over the full domain at a single non-terminal using  the |overrideIdx| function. 5Test equality of two given non-terminal proof terms. COverride a function over the full domain at a single non-terminal.  A domain phi that is an instance of the  type class supports = conversion of non-terminal proof terms to Strings using the  function. DConvert a given non-terminal proof term to a String representation.  A domain phi that is an instance of the  type class supports 8 folding over all non-terminals in the domain using the  function. ;Fold a given function over all non-terminals in the domain phi. +Similar to the : function, but limited to functions whose result type is ! the same for all non-terminals. 1  !"#$%&'()*+,-YZ[\]^_*  !"#$%&'()*+,-*&%$# !"'+()*   ,-    !"#$%&'()*+,-YZ[\]^_None ./012`abc;defghijklmnopqrstuvwxyz{|}~./012012././012`abcNone4Left-biased choice 5Right-biased choice 8The 'BSuperProductionRule| type class is in an experimental state, and ) currently not intended for general use. :/Production rule interpretations supporting the : < type class allow for Kleene-star quantified references to & non-terminals (zero or more, see the ; function) as well  as :-quantified references to non-terminals (one or more, see  the < function). 6An instance can implement either manyRef or many1Ref, 4 both or neither. Not implementing either produces < old-style many and many1 combinator behaviour (discouraged  for most situations) ;/Match a given non-terminal zero or more times. <.Match a given non-terminal one or more times. =/Production rule interpretations supporting the = type class support references $ to non-terminals in a given domain phi;. The type of the result values of the rules is determined  by semantic value family r. >5Reference a given non-terminal in a production rule. A=Type class for production rules matching tokens of a certain  token type t.  t should be an instance of the  type class. BMatch a given token of type t and produce its concrete  value (of type  t). E9Epsilon rule. Always matches, consumes nothing, produces  the given value as result. GKEpsilon rule with lifted value. Always matches, consumes nothing, produces 8 the given value (with its lifted version) as result. HOptionally match a given rule. IGBase type class for production rule interpretations. A production rule + interpretation that is an instance of the I type class supports P sequencing and disjunction of rules, empty rules, dead rules and end-of-input  rules. JDSequence two rules. Result of the sequenced rule is the application > of the result of the first rule to the result of the second. KDisjunction of two rules. LCEnd of input rule. Matches only at end of input, consumes nothing,  produces '()' as result. MDead rule. Never matches. O6Sequence two rules, but drop the result of the first. P7Sequence two rules, but drop the result of the second. Q6Apply a given function to the result of a given rule. RReplace a rule'#s result value with a given value. S6Apply a given function to the result of a given rule. TReplace a rule'#s result value with a given value. U,Match any token in a given range of tokens. V]Consecutively match a given list of tokens and return their concrete token values as a list. W An old style many8 combinator. Produces an infinite rule similar to Parsec's many rule.  Prefer to use the ; function whenever possible. X An old style many8 combinator. Produces an infinite rule similar to Parsec's many rule.  Prefer to use the ; function whenever possible. &3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX&3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX&IJKLMFGHNDEABC?@OPQRST=>:;<89UVWX673453456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXNone.YZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~.YZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~.~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZY.YZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None;A trivial identity processor that keeps current production  rule results unmodified. 9Apply a given processor to a given context-free grammar. 9Apply a given processor to a given extended context-free  grammar. BApply a given processor to a given extended liftable context-free  grammar. =A trivial processor that throws everything away and returns  a value of the type K0 (). ,Nonedefghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~NoneRThis domain is intended to be reused in grammars where decimal integers are used. > You can refer to the DecimalInteger non-terminal using the 7 primitive from the 6 type class G and then obtain the combined grammar by combining your grammar with  using the  - function +The standard processing grammar for domain 4, intended to be combined with other grammars using  the - function. None   None% None None]Parse a given string according to a given grammar, starting from a given start non-terminal, ^ with a backtracking Packrat parser algorithm (like backtracking recursive descent, but with 1 linear performance in the length of the input). ) None-            None4Unfold loops in a given grammar, replacing calls to  ; idx by W (> idx) and likewise  for < 4Unfold loops in a given grammar, replacing calls to  ; idx by W (> idx) and likewise  for < 1Unfold loops in a given rule, replacing calls to  ; idx by W (> idx) and likewise  for < 1Unfold loops in a given rule, replacing calls to  ; idx by W (> idx) and likewise  for < 0Replace loops in a given rule by rules provided 3 in two provided sets of rules, replacing calls to  ;* by the corresponding rule from the first  set, and calls to ; by the corresponding rule $ from the second set. You likely don' t need this  and should be looking at  or   instead. None ?A value of type UnfoldDepth defines for each non-terminal in a 5 grammar how many times it should be unfolded by the   or  algorithms. =Unfold recursion in a given contextx-free grammar, replacing  calls to  > idx with the non-terminal'!s production rule. This produces D production rules similar to those in traditional parser combinator  libraries. ;Unfold recursion in a given extended context-free grammar,  replacing calls to  > idx with the non-terminal'!s production rule. This produces D production rules similar to those in traditional parser combinator  libraries. A value of type " phi indicating nothing should be E unfolded at all. This can be used as a start value and then further  modified with the  function. A value of type # phi indicating every non-terminal  should be unfolded once. A function modifying a given  phi by applying a given 1 function to the depth for a given non-terminal. A function modifying a given  phi by increasing * the depth for a given non-terminal by 1. A function modifying a given  phi by decreasing * the depth for a given non-terminal by 1. @Selectively unfold a given context-free grammar according to a  given . 9Selectively unfold a given extended context-free grammar  according to a given . @Unfold a given context-free rule by replacing all references to B non-terminals with the production rule for that non-terminal in * a given processing context-free grammar. ;Unfold a given extended context-free rule by replacing all  references to B non-terminals with the production rule for that non-terminal in 3 a given processing extended context-free grammar.  !"#$%&'()*+ !"#$%&'()*+None]Parse a given string according to a given grammar, starting from a given start non-terminal, @ with a simple backtracking recursive descent parser algorithm. ,-./01234,-./01234NoneQParse a given string according to a given regular grammar, starting from a given I start symbol using the UUParse error-correcting parsing library (always  produces a result) IParse a given string according to a given grammar, starting from a given I start symbol using the UUParse error-correcting parsing library (always  produces a result) MParse a given string according to a given regular production rule using the F UUParse error-correcting parsing library (always produces a result). RParse a given string according to a given extended grammar, starting from a given I start symbol using the UUParse error-correcting parsing library (always  produces a result) 56789:; 56789:;.None<=><=>None:FoldLoopsResultValue defines, for semantic value families 9 r and rr over base domain phi, a semantic value family   r rr over domain  r. 4 such that the semantic value for base non-terminal  C is a wrapped version of type rr ix, and for Kleene-* non-terminal   a wrapped version of type [r ix]. 4FoldLoopsValue defines, for a semantic value family 2 r over base domain phi, a semantic value family   r over domain  r, such / that the semantic value for base non-terminal  B is a wrapped version of type r ix, and for Kleene-* non-terminal   a wrapped version of type [r ix]. 5FoldLoopsDomain phi defines, for base domain phi, an 0 extended domain containing non-terminal types  , ix representing base non-terminal ix, and  , ix representing a Kleene-* version of base  non-terminal ix. A parametrised type such that  ix represents  the Kleene-?" version of base non-terminal ix. A parametrised type such that  ix represents  base non-terminal ix. :Construct a processor for a grammar transformed using the  algorithm, - given a processor for the original grammar. >Transform a given extended context-free grammar over a domain phi into a standard / context-free grammar over the extended domain  phi.  Calls to ;# idx are transformed into calls to > ( idx),  where , idx is a new non-terminal representing the - Kleene-* version of underlying non-terminal idx . Normal  calls to ># idx are transformed into calls to >  ( idx) where  idx represents the unmodified  underlying non-terminal idx. The  algorithm ; constructs appropriate production rules for both types of  new non-terminals.  Values are wrapped in the  r rr  semantic value family. 4Transform a given processing extended context-free  grammar over a domain phi into a standard context-free " grammar over the extended domain 'FoldLoopsDomain phi'.  Completely similar to , but wraps values in the   r semantic value family. @ABCDEFGHIJKLMNO PQRSTUVWX @ABCDEFGHIJKLMNO/NoneYYNoneZ[Z[NoneCCombine consecutive epsilon rules in a given grammar into a single  epsilon rule. 7Combine consecutive epsilon rules in a given extended % grammar into a single epsilon rule. \]^_`abcde \^]_`abcdeNoneGCombine two grammars into a single one. The argument grammars are over  different domains phiL and phiR$, but they are allowed to refer to  each other's non-terminals  using the 7 primitive from the 6 type class. 5 The resulting grammar is over the combined domain 'MergeDomain phiL phiR'. fghijklmnopqrstuvwxyfghijklmnopqrstuvwxyNone8Filter dead branches from a given context-free grammar. 8Filter dead branches from a given context-free grammar. AFilter dead branches from a given extended context-free grammar. 8Filter dead branches from a given context-free grammar. AFilter dead branches from a given extended context-free grammar. z{|}~z|{}~None None NoneOParse a given string according to a given grammar, starting from a given start R non-terminal, using the Parsec parser library. Currently uses backtracking for  every branch.  None, defines, for a base domain phi an extended 7 domain containing the non-terminals used by the left-  corner transform. aApply the left-corner transform to a given grammar, removing direct and indirect left recursion. 3Note that the new domain will contain O(n*t + n^2) C non-terminals where n is the amount of non-terminals and t is the N number of tokens, so when using this transformation, it can be beneficial to B use a token type with a more limited amount of token values than W, at E least if you will use algorithms that fold over the full new grammar' s domain  (e.g.  printGrammar does, printReachableGrammar doesn't). jApply the left-corner transform to a given extended grammar, removing direct and indirect left recursion. )  NonePApply a uniform variant of the classic Paull transformation to a given grammar, . removing direct and indirect left recursion.  YApply a uniform variant of the classic Paull transformation to a given extended grammar, . removing direct and indirect left recursion.  bApply a uniform variant of the classic Paull transformation to a given extended liftable grammar, . removing direct and indirect left recursion. 5         &   None        NoneADetect if a given non-terminal in a given extended context free @ grammar is a chain non-terminal. An NT is a chain NT if all of " its productions are chain rules. None/Unfold chain non-terminals in a given context-  free grammar. 2 A chain non-terminal is a terminal such that its 7 production rule is a numer of epsilons followed by a 2 single normal reference to another non-terminal. 0Unfold chain non-terminals in a given extended  context-free grammar. 2 A chain non-terminal is a terminal such that its 7 production rule is a numer of epsilons followed by a 2 single normal reference to another non-terminal.            None5Assess the size of a given grammar. Primitive rules (B, >, ;, <, E) , are counted as 1 point, combinators like K or J' just add the points of their left and ? right hand sides. Proposals for better metrics are welcome. None!>Combine two semantic processors into a single one that tuples  their respective values.  ! ! ! ! None "#$%&'("#$%&'(&#$%"'( "#$%&'(!None)*+,-./0123456789: !"#)*+,-./0123456789:345012-./,)*+6789:)*+,-./0123456789: !"#"None;>Detect if a given non-terminal in a given grammar is dead. A = non-terminal is dead if its production rule can never match  anything. $%&'()*+,-;./012345;;$%&'()*+,-;./012345#None<7Unfold dead non-terminals in a given extended context-  free grammar, such 7 that the unfolded references can be filtered with the   filterDies algorithm. This uses the ; algorithm  to detect dead non-terminals. =@Unfold dead non-terminals in a given extended liftable context-  free grammar, such 7 that the unfolded references can be filtered with the   filterDies algorithm. This uses the ; algorithm  to detect dead non-terminals. >.Unfold dead non-terminals in a given context-  free grammar, such 7 that the unfolded references can be filtered with the   filterDies algorithm. This uses the ; algorithm  to detect dead non-terminals. 678<=>9:;<=><=>><= 678<=>9:;<=>$None????%None@AFold a given function over all non-terminals that are reachable ? from a given non-terminal. This function is limited to proper  reachable rules (see C for what that means). AAFold a given function over all non-terminals that are reachable F from a given non-terminal. This function will at least fold over the  given non-terminal itself. BKCheck if a given non-terminal is reachable from a given other non-terminal A in a given extended context-free grammar. This function assumes 2 that all grammars are reachable from themselves. CKCheck if a given non-terminal is reachable from a given other non-terminal F in a given extended context-free grammar. For this function, a non- E terminal is not automatically considered reachable from itself, but A only if it has some production in which a submatch of itself is  present. ?@ABCDEFGHIJK@ALBCMNOPQRST@ABCA@BC?@ABCDEFGHIJK@ALBCMNOPQRST&NoneDREnumerate all tokens that can be present in any match of a given production rule. EYEnumerate all tokens that can be present in any match of any string that can be matched / by a given non-terminal in a given grammar. FYEnumerate all tokens that can be present in any match of any string that can be matched + by any non-terminal in a given grammar. UVWDXEFYZ[\]^DEFDEF UVWDXEFYZ[\]^'NoneG8Detect if a given context-free rule is an epsilon rule. _`aGbcdefgGG_`aGbcdefg(NoneH*Lift a given grammar to Template Haskell IOLift a given grammar to Template Haskell and replace recursion and loops with R infinite-tree style recursive calls to the grammar itself. This allows GHC to do P a much better optimization (x20 speed-ups in one realistic test, compared with  result of H). hijkHIlmnopqrHIHI hijkHIlmnopqr)NoneJ^Memoize the production rules of a regular grammar. Currently not sure if this is ever useful. KVMemoize the production rules of a grammar. Currently not sure if this is ever useful. L`Memoize the production rules of an extended grammar. Currently not sure if this is ever useful. stuJKLJKLJKLstuJKL*NoneM#Print out a single production rule NPrint out a full grammar. OHPrint out a grammar with a depth limit. Intended for infinite grammars. PMPrint out the part of a grammar that is reachable from a given non-terminal. vwxyMz{NOP|}~MNOPMNOPvwxyMz{NOP|}~+NoneQRSTUQRSTUQRSTUQRSTU0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^^__`abcdefghijklmnopqrstuvwxyz{|}~               -      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH I J K L M N O!P!Q!R!S!T!U!V!W!X!Y!Z![!\!]!^!_!`!a"b#c#d#e$f%g%h%i%j&k&l&m'n(o(p)q)r)s*t*u*v*w+x+y+z+{+|}~                                                                                       ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;<==>?@ABCDEFGHHIJKLMNOPQRSTUV.W.X.YZ[\]^_`abcdefghijklmnopqrs/tuvwxyz{|}~      !"#$%&'()* + , - . /!0!1!2!3!4!5!6!7"8"9":";"<"="">"?"@"A"B"C"D"E"F"G"H#I#J#K#L#M#N#O#P#Q%R%S%T%U%V%W%X%Y%Z%[%\%]%^%_%`%a%b%c%d%e%f%g&h&i&j&k&l&m&n&o&p&q'r's't'u'v'w'x'y'z({(|(}(~((((((()))**K*L***********+++++++++++++++++grammar-combinators-0.2.7"Text.GrammarCombinators.Base.Token#Text.GrammarCombinators.Base.Domain%Text.GrammarCombinators.Base.MultiRec+Text.GrammarCombinators.Base.ProductionRule$Text.GrammarCombinators.Base.Grammar&Text.GrammarCombinators.Base.Processor'Text.GrammarCombinators.Library.Numeric&Text.GrammarCombinators.Parser.TopDown"Text.GrammarCombinators.Parser.LL1$Text.GrammarCombinators.Parser.LL1TH&Text.GrammarCombinators.Parser.Packrat&Text.GrammarCombinators.Parser.RealLL1-Text.GrammarCombinators.Transform.UnfoldLoops1Text.GrammarCombinators.Transform.UnfoldRecursion/Text.GrammarCombinators.Parser.RecursiveDescent&Text.GrammarCombinators.Parser.UUParse+Text.GrammarCombinators.Transform.FoldLoops"Text.GrammarCombinators.TH.RealLL11Text.GrammarCombinators.Transform.CombineEpsilons1Text.GrammarCombinators.Transform.CombineGrammars,Text.GrammarCombinators.Transform.FilterDies'Text.GrammarCombinators.Utils.CalcFirst/Text.GrammarCombinators.Transform.IntroduceBias%Text.GrammarCombinators.Parser.Parsec,Text.GrammarCombinators.Transform.LeftCorner.Text.GrammarCombinators.Transform.UniformPaull0Text.GrammarCombinators.Transform.PenalizeErrors'Text.GrammarCombinators.Utils.IsChainNT0Text.GrammarCombinators.Transform.UnfoldChainNTs(Text.GrammarCombinators.Utils.AssessSize/Text.GrammarCombinators.Utils.CombineProcessors.Text.GrammarCombinators.Utils.EnumerateGrammar.Text.GrammarCombinators.Utils.UnfoldDepthFirst$Text.GrammarCombinators.Utils.IsDead,Text.GrammarCombinators.Transform.UnfoldDead1Text.GrammarCombinators.Transform.OptimizeGrammar)Text.GrammarCombinators.Utils.IsReachable(Text.GrammarCombinators.Utils.EnumTokens'Text.GrammarCombinators.Utils.IsEpsilon)Text.GrammarCombinators.Utils.LiftGrammar,Text.GrammarCombinators.Utils.MemoizeGrammar*Text.GrammarCombinators.Utils.PrintGrammar%Text.GrammarCombinators.Utils.ToGraphText.GrammarCombinators.BasecombineGrammarsText.GrammarCombinators.TH.Base$Text.GrammarCombinators.TH.FoldLoopsToken ConcreteTokenclassifyenumConcreteTokens EitherFunctorRightRLeftR MergeDomainRightIdxLeftIdxRightIxLeftIxLiftFamliftIdxEliftIdxPSubValMkSubValunSubValDomainEmbeddingsupPF DomainMapsupIxsubIxDomainEqFameqIdx overrideIdxShowFamshowIdxFoldFamfoldFamMemoFamMemofromMemotoMemo ApplyIxMapIxMapSeq IxMapBaseIxMapId memoFamily memoFamilyKtoMemoK fromMemoK overrideIdxKunLeftRunRightRSubPFILunILBiasedProductionRule>|||<|||ProductionRuleWithLibrarylibSuperProductionRulesubrefLoopProductionRulemanyRefmany1RefRecProductionRulerefPenaltyProductionRulepenaltyTokenProductionRuletokenanyTokenEpsProductionRuleepsilonLiftableProductionRuleepsilonL optionallyProductionRule>>>||| endOfInputdie epsilonLS*>>>>>>*$>>$>>*$|>>$|>>* tokenRangestringmanyInfmany1Inf+ProcessingLBiasedExtendedContextFreeGrammar%ProcessingLExtendedContextFreeGrammar*ProcessingBiasedExtendedContextFreeGrammar+ProcessingPenaltyExtendedContextFreeGrammar$ProcessingExtendedContextFreeGrammar"ProcessingBiasedContextFreeGrammar#ProcessingPenaltyContextFreeGrammarProcessingLContextFreeGrammarProcessingContextFreeGrammarProcessingBiasedRegularGrammarProcessingPenaltyRegularGrammarProcessingRegularGrammarLExtendedContextFreeGrammar BiasedExtendedContextFreeGrammar!PenaltyExtendedContextFreeGrammarExtendedContextFreeGrammarLContextFreeGrammarContextFreeGrammarGLExtendedContextFreeGrammarGLAnyExtendedContextFreeGrammarGAnyExtendedContextFreeGrammar!GBiasedExtendedContextFreeGrammar"GPenaltyExtendedContextFreeGrammarGExtendedContextFreeGrammarGBiasedContextFreeGrammarGPenaltyContextFreeGrammarGLContextFreeGrammarGContextFreeGrammarGRegularGrammarPGrammarAGrammarGGrammarExtendedLiftableContextFreeRuleLiftableContextFreeRuleLAnyExtendedContextFreeRuleAnyExtendedContextFreeRule%BiasedExtendedLiftableContextFreeRuleBiasedExtendedContextFreeRulePenaltyExtendedContextFreeRuleExtendedContextFreeRuleBiasedContextFreeRulePenaltyContextFreeRuleContextFreeRuleBiasedRegularRulePenaltyRegularRule RegularRule Processor GProcessoridentityProcessorapplyProcessor'applyProcessorapplyProcessorLapplyProcessorEapplyProcessorLEtrivialProcessor NumericValue NumericDomainDecimalIntegernumericGrammarprocNumericGrammarWrapLookaheadNBRWrapLNBR unWrapLNBRUnambiguousTopDownGrammarNonBranchingRuleMkNBRunNBR nbrEndOfInput parseTopDownLL1Table calcLL1TableparseLL1prepareLL1TableTHDerivsResultNoParseParsed parsePackrat RealLL1TableMkRealLL1TableBranchSelectorMemoFlipBSSplitBranchSelectorMemoLDefaultBranchSelectorMemoFirstSetFS firstTokens canBeEmptycanBeEOIprepareLL1Parser parseRealLL1 unfoldLoops unfoldLoopsPunfoldLoopsRulereplaceLoopsRule UnfoldDepthunfoldRecursionunfoldRecursionPunfoldRecursionBunfoldRecursionE selectNothing selectAllOncesumUDscaleUDmodifyUnfoldDepthselectNT unselectNTunfoldSelectiveunfoldSelectiveE unfoldRule unfoldRuleE parseRecDecparseUURparseUU parseUURuleparseUUEFoldLoopsResultValueFoldLoopsValueFoldLoopsDomainFLManyFLBaseFLManyIxFLBaseIxprocessFoldLoops foldLoopsfoldAndProcessLoopsliftRealLL1TablecombineEpsilonscombineEpsilonsE filterDies filterDiesP filterDiesE filterDiesPE filterDiesLEFirstSetGrammar FSCalculatorcalcFSfirstSet calcFirst introduceBiasintroduceBiasEintroduceBiasLE WrapGenParserunWGP parseParsec parseParsecRparseParsecBiasedLCValueLCDomainLCNTMinT LCNTMinNTLCBase LCNTMinTIx LCNTMinNTIxLCBaseIxtransformLeftCornertransformLeftCornerEUPValueUPDomainUPTailUPHeadUPBaseUPTailIxUPHeadIxUPBaseIxunUPTVunUPHVunUPBVtransformUniformPaulltransformUniformPaullPtransformUniformPaullEtransformUniformPaullLE IsJustAppIJAunIJAPBEHProductionRuleMkPBEHunPBEHMaybeSemanticTNothingVJustV fromJustVisJustVprocessPenalizedSimplepenalizeErrors'penalizeErrorsEpenalizeErrors isChainNTunfoldChainNTsunfoldChainNTsE assessSize CombineFamCombinecombineProcessorsEnumerateGrammarEnumerateProductionRuleIPPprintIPPEnumerateParserInternalGrammarenumerateGrammarenumerateGrammarEWrapURWURunWUR UDFGrammarUnfoldDepthFirstRuleMkFRRfoldReachableFromRuleSimpleLoopProductionRulemanyRef' many1Ref'SimpleRecProductionRuleref' cutRecursion declareDeadunfoldDepthFirst''unfoldDepthFirst'unfoldDepthFirstProperunfoldDepthFirstisDead unfoldDeadE unfoldDeadLE unfoldDeadoptimizeGrammarEfoldReachableProper foldReachable isReachableisReachableProperenumRuleTokens enumTokens enumAllTokens isEpsilon liftGrammarunfoldAndLiftGrammarmemoizeGrammarRmemoizeGrammarmemoizeGrammarE printRule printGrammarprintGrammarInfprintReachableGrammar ruleToGraphgraphToGraphvizfullGrammarToGraphreachableGrammarToGraph showGraphtemplate-haskellLanguage.Haskell.TH.SyntaxLiftghc-prim GHC.TypesChar $fTokenChar$fShowEitherFunctor$fShowEitherFunctor0$fDomainMergeDomain$fEqFamMergeDomain$fFoldFamMergeDomain$fShowFamMergeDomain$fMemoFamMergeDomainhmapAIL hmapSubPF$fHFunctorphiSubPF$fHFunctorphiILmultirec-0.7.3Generics.MultiRec.HFunctorhmapMhmaphmapAHFunctorGenerics.MultiRec.BaseindexunCunTagunIIunKKULR:+::*:Tag:>:unDD:.:CunI0I0unK0K0PFproofEltofromFameqSEqSGenerics.MultiRec.Constructor conFixityconName ConstructorPrefixInfixFixityLeftAssociativeRightAssociativeNotAssociative AssociativityGenerics.MultiRec.TEqcastRefl:=:baseGHC.Num+PFNumDecimalIntegerFDecimalNonZeroDigitF DecimalDigitFDecimalNonZeroDigit DecimalDigitprocessNumerics$fDomainNumericDomain$fEqFamNumericDomain$fMemoFamNumericDomain$fFoldFamNumericDomain$fShowFamNumericDomainNVI$fMonadNonBranchingRule$fFunctorNonBranchingRuleWrapNonBranchingRuleListWrapNBRL unWrapNBRLLLRuleMkLLRule llRuleAltsruleForTokenTableruleForEOITableruleForEmptyTableFirstSetGrammarRecMkFSCalculatorunionL fixFSGrammarll1Disambiguate$fRecProductionRuleLLRulephir$fTokenProductionRuleLLRulet$fLiftableProductionRuleLLRule$fEpsProductionRuleLLRule$fProductionRuleLLRule$fFunctorLLRule#$fRecProductionRuleFSCalculatorphir"$fTokenProductionRuleFSCalculatort$$fLiftableProductionRuleFSCalculator$fEpsProductionRuleFSCalculator$fProductionRuleFSCalculator liftLL1Table $fLiftMapPackratGrammar PackratRulerunParseInternalGrammarInternalPRRuleunDerivsPRResult unPRResult PackratValue PRBaseValuePREndOfInputValuePRPrimTokenValue PackratDomainPackratDomainEndOfInputPackratDomainPrimTokenPackratDomainBasePRBaseIxPREndOfInputIx PRPrimTokenIxunPRPrimTokenValue buildDerivstoInternalGrammarparsePackratAll#$fLoopProductionRulePackratRulephir"$fRecProductionRulePackratRulephir!$fTokenProductionRulePackratRulet#$fLiftableProductionRulePackratRule$fEpsProductionRulePackratRule$fProductionRulePackratRule$fMemoFamPackratDomain#$fDomainMapPackratDomainphiPRBaseIx$fFunctorResult $fShowResultunRealLL1TableRealLL1Grammar RealLL1Rule MkRealLL1Rule runLL1Rule BSCGrammarBranchSelectorComputerMkBSC branchDataBranchSelectorGrammar BranchDataMkBDbranchSelectorseqBSBranchSelectorMkBS selectBranchdefaultBranchSelectorunBranchSelectorMemofixBSC"$fRecProductionRuleRealLL1Rulephir!$fTokenProductionRuleRealLL1Rulet$fEpsProductionRuleRealLL1Rule#$fLiftableProductionRuleRealLL1Rule$fProductionRuleRealLL1Rule.$fLoopProductionRuleBranchSelectorComputerphir-$fRecProductionRuleBranchSelectorComputerphir,$fTokenProductionRuleBranchSelectorComputert)$fEpsProductionRuleBranchSelectorComputer.$fLiftableProductionRuleBranchSelectorComputer&$fProductionRuleBranchSelectorComputerunfoldLoopsRulePUnfoldLoopsWrapperULWrunULWreplaceLoopsRuleP*$fLoopProductionRuleUnfoldLoopsWrapperphir)$fRecProductionRuleUnfoldLoopsWrapperphir)$fPenaltyProductionRuleUnfoldLoopsWrapper($fTokenProductionRuleUnfoldLoopsWrappert%$fEpsProductionRuleUnfoldLoopsWrapper*$fLiftableProductionRuleUnfoldLoopsWrapper"$fProductionRuleUnfoldLoopsWrapper RPWGrammarRPWRule unRPWRuleunfoldSelective'$fLoopProductionRuleRPWRulephir$fRecProductionRuleRPWRulephir$fTokenProductionRuleRPWRulet$fEpsProductionRuleRPWRule$fBiasedProductionRuleRPWRule$fPenaltyProductionRuleRPWRule$fLiftableProductionRuleRPWRule$fProductionRuleRPWRule RecDecRulerunRDparseRecDecBase $fTokenProductionRuleRecDecRulet"$fLiftableProductionRuleRecDecRule$fEpsProductionRuleRecDecRule$fProductionRuleRecDecRule$fMonadPlusRecDecRuleWrapPWPunWP$fTokenProductionRuleWrapPt$fLiftableProductionRuleWrapP$fEpsProductionRuleWrapP$fProductionRuleWrapP $fLiftSubVal$fLiftK0 $fLiftSet*FLWrapFLWunFLW$fLoopProductionRuleFLWrapphir$fRecProductionRuleFLWrapphir$fTokenProductionRuleFLWrapt$fLiftableProductionRuleFLWrap$fEpsProductionRuleFLWrap$fProductionRuleFLWrap$fDomainFoldLoopsDomain$fMemoFamFoldLoopsDomain%$fDomainMapFoldLoopsDomainphiFLManyIx%$fDomainMapFoldLoopsDomainphiFLBaseIx$fEqFamFoldLoopsDomain$fShowFamFoldLoopsDomain$fFoldFamFoldLoopsDomainFLRMVunFLRMVFLRBVunFLRBVFLMVunFLMVFLBVunFLBVFLM $fLiftMemo$fLiftBranchSelectorMemo$fLiftFirstSetCombineEpsilonsRule CEEpsRuleCERule runCERule+$fLoopProductionRuleCombineEpsilonsRulephir*$fRecProductionRuleCombineEpsilonsRulephir)$fTokenProductionRuleCombineEpsilonsRulet+$fLiftableProductionRuleCombineEpsilonsRule&$fEpsProductionRuleCombineEpsilonsRule#$fProductionRuleCombineEpsilonsRuleIGWunIGWCGWMkCGWunCGW invertGrammar/$fLoopProductionRuleIGWMergeDomainEitherFunctor.$fRecProductionRuleIGWMergeDomainEitherFunctor$fProductionRuleIGW$fTokenProductionRuleIGWt$fLiftableProductionRuleIGW$fEpsProductionRuleIGW$fTokenProductionRuleCGWt$fEpsProductionRuleCGW$fLiftableProductionRuleCGW$fProductionRuleCGW$$fProductionRuleWithLibraryCGWphiRrR$fLoopProductionRuleCGWphiLrL$fRecProductionRuleCGWphiLrLFilterDiesRule FDDieRule FDBaseRule runFDRule&$fLoopProductionRuleFilterDiesRulephir%$fPenaltyProductionRuleFilterDiesRule%$fRecProductionRuleFilterDiesRulephir$$fTokenProductionRuleFilterDiesRulet&$fLiftableProductionRuleFilterDiesRule!$fEpsProductionRuleFilterDiesRule$fProductionRuleFilterDiesRuleWrapFSCWFSCunWFSC blockRecurse$$fLoopProductionRuleFSCalculatorphirIBWMkIBW firstSetRuleunWrap ambiguousmutuallyExclusive$fLoopProductionRuleIBWphir$fRecProductionRuleIBWphir$fTokenProductionRuleIBWt$fEpsProductionRuleIBW$fLiftableProductionRuleIBW$fProductionRuleIBWWGPnextPos#$fTokenProductionRuleWrapGenParsert%$fLiftableProductionRuleWrapGenParser $fEpsProductionRuleWrapGenParser#$fBiasedProductionRuleWrapGenParser$fProductionRuleWrapGenParser WrapNTMinNTPs WNTMinNTPs unWNTMinNTPs WrapNTMinNTP WNTMinNTP unWNTMinNTPTransformLCRuleMkTLCIRtlcEmptytlcFull tlcNTMinNT tlcNTMinT WrapFSectWFSunWFSWrapLCNTMinNTMemo WLCNTMNTM unWLCNTMNTtransformLeftCorner''$fLoopProductionRuleTransformLCRulephir&$fRecProductionRuleTransformLCRulephir%$fTokenProductionRuleTransformLCRulet'$fLiftableProductionRuleTransformLCRule"$fEpsProductionRuleTransformLCRule$fProductionRuleTransformLCRule$fDomainMapLCDomainphiLCBaseIx$fEqFamLCDomain$fDomainLCDomain$fMemoFamLCDomain$fFoldFamLCDomain$fShowFamLCDomain LCNTMinTV LCNTMinNTVLCBVWrapListOfTailHeadManysWLOTHMunWLOTHMWrapTransformUPWrapperWrapTUPW unWrapTUPWTransformUPGrammarTransformUPWrapperMkTUPWtUPRuleForGrammarTransformUPIntRuleMkTUPIRtlclwRecursionLimitActive tlclwEmpty tlclwHead tlclwTail tlclwFull mkSimpleTUPW mkEpsTUPW mkEpsLTUPW tlclTailReffailHeadRefsTosucceedTailRefs procTailRefstransformUniformPaull'*$fLoopProductionRuleTransformUPWrapperphir)$fRecProductionRuleTransformUPWrapperphir($fTokenProductionRuleTransformUPWrappert)$fPenaltyProductionRuleTransformUPWrapper*$fLiftableProductionRuleTransformUPWrapper%$fEpsProductionRuleTransformUPWrapper"$fProductionRuleTransformUPWrapper$fDomainUPDomain$fMemoFamUPDomain$fDomainMapUPDomainphiUPTailIx$fDomainMapUPDomainphiUPHeadIx$fDomainMapUPDomainphiUPBaseIx$fEqFamUPDomain$fLiftFamUPDomain$fShowFamUPDomain$fFoldFamUPDomainUPTVUPHVUPBV$fApplicativeIsJustApp$fFunctorIsJustApp($fTokenProductionRulePBEHProductionRulet7$fLoopProductionRulePBEHProductionRulephiMaybeSemanticT6$fRecProductionRulePBEHProductionRulephiMaybeSemanticT%$fEpsProductionRulePBEHProductionRule*$fLiftableProductionRulePBEHProductionRule"$fProductionRulePBEHProductionRule IsChainNTMkITR ruleIsEpsilon ruleIsChain!$fLoopProductionRuleIsChainNTphir $fRecProductionRuleIsChainNTphir$fTokenProductionRuleIsChainNTt!$fLiftableProductionRuleIsChainNT$fEpsProductionRuleIsChainNT$fProductionRuleIsChainNTRuleToManyWrapperRTMWruleToManyRuleruleToMany1RuleRTMEps)$fLoopProductionRuleRuleToManyWrapperphir($fRecProductionRuleRuleToManyWrapperphir'$fTokenProductionRuleRuleToManyWrappert)$fLiftableProductionRuleRuleToManyWrapper$$fEpsProductionRuleRuleToManyWrapper!$fProductionRuleRuleToManyWrapperAssessSizeProductionRuleASPRassessSizeRule0$fLoopProductionRuleAssessSizeProductionRulephir/$fRecProductionRuleAssessSizeProductionRulephir.$fTokenProductionRuleAssessSizeProductionRulet0$fLiftableProductionRuleAssessSizeProductionRule+$fEpsProductionRuleAssessSizeProductionRule($fProductionRuleAssessSizeProductionRule.$fRecProductionRuleEnumerateProductionRulephir-$fTokenProductionRuleEnumerateProductionRulet*$fEpsProductionRuleEnumerateProductionRule/$fLiftableProductionRuleEnumerateProductionRule'$fProductionRuleEnumerateProductionRule,$fLoopProductionRuleUnfoldDepthFirstRulephir+$fPenaltyProductionRuleUnfoldDepthFirstRule+$fRecProductionRuleUnfoldDepthFirstRulephir*$fTokenProductionRuleUnfoldDepthFirstRulet,$fLiftableProductionRuleUnfoldDepthFirstRule'$fEpsProductionRuleUnfoldDepthFirstRule*$fBiasedProductionRuleUnfoldDepthFirstRule$$fProductionRuleUnfoldDepthFirstRule IsDeadRuleMkIDR ruleIsDead KnownDeadMkKD knownDeadseqDeadaltDeadputDeath*$fSimpleLoopProductionRuleIsDeadRulephirrr)$fSimpleRecProductionRuleIsDeadRulephirrr $fBiasedProductionRuleIsDeadRule!$fPenaltyProductionRuleIsDeadRule $fTokenProductionRuleIsDeadRulet"$fLiftableProductionRuleIsDeadRule$fEpsProductionRuleIsDeadRule$fProductionRuleIsDeadRuleUnfoldDeadRuleUDRuleunUDRule&$fLoopProductionRuleUnfoldDeadRulephir%$fRecProductionRuleUnfoldDeadRulephir$$fTokenProductionRuleUnfoldDeadRulet&$fLiftableProductionRuleUnfoldDeadRule!$fEpsProductionRuleUnfoldDeadRule$fProductionRuleUnfoldDeadRuleFoldReachableIntRuleMkFRIRfoldRuleFolderSeenGramMkSGseenIdxsetSeen nothingSeenputSeen foldDeadEndfoldViafoldRef isReachable'4$fSimpleLoopProductionRuleFoldReachableIntRulephirrr3$fSimpleRecProductionRuleFoldReachableIntRulephirrr*$fTokenProductionRuleFoldReachableIntRulet,$fLiftableProductionRuleFoldReachableIntRule'$fEpsProductionRuleFoldReachableIntRule*$fBiasedProductionRuleFoldReachableIntRule+$fPenaltyProductionRuleFoldReachableIntRule$$fProductionRuleFoldReachableIntRuleEnumTokensRuleETRunETR enumTokens'&$fLoopProductionRuleEnumTokensRulephir%$fRecProductionRuleEnumTokensRulephir$$fTokenProductionRuleEnumTokensRulet!$fEpsProductionRuleEnumTokensRule&$fLiftableProductionRuleEnumTokensRule$fProductionRuleEnumTokensRule IsEpsilonRuleMkIERunIER%$fLoopProductionRuleIsEpsilonRulephir$$fRecProductionRuleIsEpsilonRulephir#$fTokenProductionRuleIsEpsilonRulet $fEpsProductionRuleIsEpsilonRule%$fLiftableProductionRuleIsEpsilonRule$fProductionRuleIsEpsilonRule LiftedRuleMkLRliftRule liftGrammar'"$fLoopProductionRuleLiftedRulephir!$fRecProductionRuleLiftedRulephir $fTokenProductionRuleLiftedRulet"$fLiftableProductionRuleLiftedRule!$fPenaltyProductionRuleLiftedRule $fBiasedProductionRuleLiftedRule$fProductionRuleLiftedRuleWrapCFGRWCFGRunWCFGRPrintProductionRule printIPPSub printGrammar'infinity+$fLoopProductionRulePrintProductionRulephir*$fRecProductionRulePrintProductionRulephir)$fTokenProductionRulePrintProductionRulet+$fLiftableProductionRulePrintProductionRule*$fPenaltyProductionRulePrintProductionRule&$fEpsProductionRulePrintProductionRule)$fBiasedProductionRulePrintProductionRule#$fProductionRulePrintProductionRuleGraphConstructorMkGCconstructContextsnewNodetell1leafNodeconstructContextsSubruleToContextsgraphvizParamsgrammarToContextsgrammarToGraph($fLoopProductionRuleGraphConstructorphir'$fRecProductionRuleGraphConstructorphir&$fTokenProductionRuleGraphConstructort($fLiftableProductionRuleGraphConstructor#$fEpsProductionRuleGraphConstructor $fProductionRuleGraphConstructor