rQSV      !"#$%&'()*+,-./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+.The ( function returns a (possibly infinite) % list of all concrete tokens of type 'ConcreteToken t' # corresponding to a given token of  type t The  function classifies a given  t into , the value of type t it is represented by. The 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). * ;Fold a given function over all non-terminals in the domain phi.  A domain phi that is an instance of the   type class supports 8 folding over all non-terminals in the domain 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 = conversion of non-terminal proof terms to Strings using the  function. COverride a function over the full domain at a single non-terminal. 5Test equality of two given non-terminal proof terms.  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. 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. SA generic wrapper type that restricts a semantic value family over a bigger domain  to a smaller domain.  !"#$%&'()*+Similar to the : function, but limited to functions whose result type is ! the same for all non-terminals. ,-*  !"#$%&'()*+,-* ' +()* #!"&$%,-*     !"#!"$%&$%'()*+,-./012XY8Z[\]^_`abcdefghijklmnopqrstuvwxyz{|}~./012012././/01212&34Left-biased choice 5Right-biased choice 678The 'BSuperProductionRule| type class is in an experimental state, and ) currently not intended for general use. 9:/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). CDE9Epsilon rule. Always matches, consumes nothing, produces  the given value as result. FGKEpsilon 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. NO6Sequence 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&IJKLMFGHNDEABC?@OPQRST=>:;<89UVWX67345&34545677899:;<;<=>>?@@ABCBCDEEFGHGHIJKLMJKLMNOPQRSTUVWX.YZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~.YZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~.~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZY.YZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ ;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 (). ,Z[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~RThis 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  AText.GrammarCombinators.Transform.CombineGrammars.combineGrammars function +The standard processing grammar for domain 4, intended to be combined with other grammars using  the AText.GrammarCombinators.Transform.CombineGrammars.combineGrammars function.     ]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).  "  4Unfold 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. ?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. ]Parse a given string according to a given grammar, starting from a given start non-terminal, @ with a simple backtracking recursive descent parser algorithm. QParse 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) - A parametrised type such that  ix represents  base non-terminal ix. A parametrised type such that  ix represents  the Kleene-" version of base non-terminal 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. 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]. :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]. :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.   .CCombine 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. GCombine 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'.    8Filter 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.      OParse 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. , 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. +,- %./0123456789:;<=>?@ABCDEFPApply 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. GHI                  JKLMADetect 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. NOPQR/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. STU5Assess 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.  !>Combine two semantic processors into a single one that tuples  their respective values.  ! !  ! "#$%&'("#$%&'(&#$%"'("#$%$%&'(!)*+,-./0123456789:)*+,-./0123456789:345012-./,)*+6789:)*+*+,-././01212345456789:" VWXYZ[\]^_;>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. ;;;#`ab<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. <=>><=<=>$????%cdefghijklmnopqrst@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. uBKCheck 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. @ABCA@BC@ABC&vwxDREnumerate all tokens that can be present in any match of a given production rule. yEYEnumerate 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. DEFDEFDEF'z{|G8Detect if a given context-free rule is an epsilon rule. GGG(}~H*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). HIHIHI)J^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. JKLJKLJKL* M#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. MNOPMNOPMNOP+QRSTUQRSTUQRSTUQRSTU/0123456789:;<=>?@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+{+|}~                                                                               !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn"o"p"q"r"s"t""u"v"w#x#y#z%{%|%}%~%%%%%%%%%%%%%%%&&&&'''(((()))**K*L***+++++++++++grammar-combinators-0.2.3"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.BaseText.GrammarCombinators.TH.Base$Text.GrammarCombinators.TH.FoldLoopsenumConcreteTokensclassify ConcreteTokenTokenIxMapId IxMapBaseIxMapSeq ApplyIxMaptoMemofromMemoMemoMemoFamfoldFamFoldFamshowIdxShowFam overrideIdxeqIdxEqFamDomainsubIxsupIx DomainMapsupPFDomainEmbeddingunSubValMkSubValSubValliftIdxPliftIdxELiftFamLeftIxRightIxLeftIdxRightIdx MergeDomainLeftRRightR EitherFunctor memoFamily memoFamilyKtoMemoK fromMemoK overrideIdxKunLeftRunRightRSubPFILunILBiasedProductionRule>|||<|||ProductionRuleWithLibrarylibSuperProductionRulesubrefLoopProductionRulemanyRefmany1RefRecProductionRulerefPenaltyProductionRulepenaltyTokenProductionRuletokenanyTokenEpsProductionRuleepsilonLiftableProductionRuleepsilonL optionallyProductionRule>>>||| endOfInputdie epsilonLS*>>>>>>*$>>$>>*$|>>$|>>* tokenRangestringmanyInfmany1Inf+ProcessingLBiasedExtendedContextFreeGrammar%ProcessingLExtendedContextFreeGrammar*ProcessingBiasedExtendedContextFreeGrammar+ProcessingPenaltyExtendedContextFreeGrammar$ProcessingExtendedContextFreeGrammar"ProcessingBiasedContextFreeGrammar#ProcessingPenaltyContextFreeGrammarProcessingLContextFreeGrammarProcessingContextFreeGrammarProcessingBiasedRegularGrammarProcessingPenaltyRegularGrammarProcessingRegularGrammarLExtendedContextFreeGrammar BiasedExtendedContextFreeGrammar!PenaltyExtendedContextFreeGrammarExtendedContextFreeGrammarLContextFreeGrammarContextFreeGrammarGLExtendedContextFreeGrammarGLAnyExtendedContextFreeGrammarGAnyExtendedContextFreeGrammar!GBiasedExtendedContextFreeGrammar"GPenaltyExtendedContextFreeGrammarGExtendedContextFreeGrammarGBiasedContextFreeGrammarGPenaltyContextFreeGrammarGLContextFreeGrammarGContextFreeGrammarGRegularGrammarPGrammarAGrammarGGrammarExtendedLiftableContextFreeRuleLiftableContextFreeRuleLAnyExtendedContextFreeRuleAnyExtendedContextFreeRule%BiasedExtendedLiftableContextFreeRuleBiasedExtendedContextFreeRulePenaltyExtendedContextFreeRuleExtendedContextFreeRuleBiasedContextFreeRulePenaltyContextFreeRuleContextFreeRuleBiasedRegularRulePenaltyRegularRule RegularRule Processor GProcessoridentityProcessorapplyProcessor'applyProcessorapplyProcessorLapplyProcessorEapplyProcessorLEtrivialProcessorDecimalInteger NumericDomain NumericValuenumericGrammarprocNumericGrammarWrapLookaheadNBRWrapLNBR unWrapLNBRUnambiguousTopDownGrammarNonBranchingRuleMkNBRunNBR nbrEndOfInput parseTopDownLL1Table calcLL1TableparseLL1prepareLL1TableTHParsedNoParseResultDerivs parsePackrat RealLL1TableMkRealLL1TableBranchSelectorMemoFlipBSSplitBranchSelectorMemoLDefaultBranchSelectorMemoFirstSetFS firstTokens canBeEmptycanBeEOIprepareLL1Parser parseRealLL1 unfoldLoops unfoldLoopsPunfoldLoopsRulereplaceLoopsRule UnfoldDepthunfoldRecursionunfoldRecursionPunfoldRecursionBunfoldRecursionE selectNothing selectAllOncesumUDscaleUDmodifyUnfoldDepthselectNT unselectNTunfoldSelectiveunfoldSelectiveE unfoldRule unfoldRuleE parseRecDecparseUURparseUU parseUURuleparseUUEFLBaseIxFLManyIxFLBaseFLManyFoldLoopsDomainFoldLoopsValueFoldLoopsResultValueprocessFoldLoops foldLoopsfoldAndProcessLoopsliftRealLL1TablecombineEpsilonscombineEpsilonsEcombineGrammars filterDies filterDiesP filterDiesE filterDiesPE filterDiesLEFirstSetGrammar FSCalculatorcalcFSfirstSet calcFirst introduceBiasintroduceBiasEintroduceBiasLE WrapGenParserunWGP parseParsec parseParsecRparseParsecBiasedLCBaseIx LCNTMinNTIx LCNTMinTIxLCBase LCNTMinNTLCNTMinTLCDomainLCValuetransformLeftCornertransformLeftCornerEUPBaseIxUPHeadIxUPTailIxUPBaseUPHeadUPTailUPDomainUPValueunUPTVunUPHVunUPBVtransformUniformPaulltransformUniformPaullPtransformUniformPaullEtransformUniformPaullLE 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.TypesCharhmapAIL hmapSubPF multirec-0.5Generics.MultiRec.HFunctorhmapMhmaphmapAHFunctorGenerics.MultiRec.BaseindexunCunTagunIIunKKULR:+::*:Tag:>:CunI0I0unK0K0PFproofEltofromFameqSEqSGenerics.MultiRec.Constructor conFixityconName ConstructorPrefixInfixFixityLeftAssociativeRightAssociativeNotAssociative AssociativityGenerics.MultiRec.TEqcastRefl:=:baseGHC.Num+ DecimalDigitDecimalNonZeroDigit DecimalDigitFDecimalNonZeroDigitFDecimalIntegerFPFNumprocessNumericsNVIWrapNonBranchingRuleListWrapNBRL unWrapNBRLLLRuleMkLLRule llRuleAltsruleForTokenTableruleForEOITableruleForEmptyTableFirstSetGrammarRecMkFSCalculatorunionL fixFSGrammarll1Disambiguate liftLL1Table PRPrimTokenIxPREndOfInputIxPRBaseIxPackratDomainBasePackratDomainPrimTokenPackratDomainEndOfInput PackratDomainPRPrimTokenValuePREndOfInputValue PRBaseValue PackratValue unPRResultPRResultunDerivsInternalPRRuleInternalGrammarrunParse PackratRulePackratGrammarunPRPrimTokenValue buildDerivstoInternalGrammarparsePackratAllunRealLL1TableRealLL1Grammar RealLL1Rule MkRealLL1Rule runLL1Rule BSCGrammarBranchSelectorComputerMkBSC branchDataBranchSelectorGrammar BranchDataMkBDbranchSelectorseqBSBranchSelectorMkBS selectBranchdefaultBranchSelectorunBranchSelectorMemofixBSCUnfoldLoopsWrapperULWrunULWunfoldLoopsRulePreplaceLoopsRuleP RPWGrammarRPWRule unRPWRuleunfoldSelective' RecDecRulerunRDparseRecDecBaseWrapPWPunWP*FLWFLWrapunFLWFLRMVunFLRMVFLRBVunFLRBVFLMVunFLMVFLBVunFLBVFLMCombineEpsilonsRule CEEpsRuleCERule runCERuleIGWunIGWCGWMkCGWunCGW invertGrammarFilterDiesRule FDDieRule FDBaseRule runFDRuleWrapFSCWFSCunWFSC blockRecurseIBWMkIBW firstSetRuleunWrap ambiguousmutuallyExclusiveWGPnextPos unWLCNTMNT WLCNTMNTMWrapLCNTMinNTMemounWFSWFS WrapFSect tlcNTMinT tlcNTMinNTtlcFulltlcEmptyMkTLCIRTransformLCRule unWNTMinNTP WNTMinNTP WrapNTMinNTP unWNTMinNTPs WNTMinNTPs WrapNTMinNTPstransformLeftCorner' LCNTMinTV LCNTMinNTVLCBV tlclwFull tlclwTail tlclwHead tlclwEmptytlclwRecursionLimitActiveMkTUPIRTransformUPIntRuletUPRuleForGrammarMkTUPWTransformUPWrapperTransformUPGrammar unWrapTUPWWrapTUPWWrapTransformUPWrapperunWLOTHMWLOTHMWrapListOfTailHeadManys mkSimpleTUPW mkEpsTUPW mkEpsLTUPW tlclTailReffailHeadRefsTosucceedTailRefs procTailRefstransformUniformPaull'UPTVUPHVUPBV IsChainNTMkITR ruleIsEpsilon ruleIsChainRuleToManyWrapperRTMWruleToManyRuleruleToMany1RuleRTMEpsAssessSizeProductionRuleASPRassessSizeRule IsDeadRuleMkIDR ruleIsDead KnownDeadMkKD knownDeadseqDeadaltDeadputDeathUnfoldDeadRuleUDRuleunUDRuleFoldReachableIntRuleMkFRIRfoldRuleFolderMkFFfoldIdxsSeenGramMkSGseenIdxcombineFolders foldDeadEndfoldViasetSeenputSeennoFoldfoldIdxfoldRef nothingSeen isReachable'EnumTokensRuleETRunETR enumTokens' IsEpsilonRuleMkIERunIER LiftedRuleMkLRliftRule liftGrammar'WrapCFGRWCFGRunWCFGRPrintProductionRule printIPPSub printGrammar'infinityGraphConstructorMkGCconstructContextsnewNodetell1leafNodeconstructContextsSubruleToContextsgraphvizParamsgrammarToContextsgrammarToGraph