C('      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqr s t u v w x y z { | } ~   !!!"####$$$$$'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 ! 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 , 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  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.   !"#   # !"       !"#$%&'(8      !"#$%&'()*+,-./0$%&'(&'($%$%%&'('()The '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 1:-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. 0=Type class for production rules matching tokens of a certain  token type t.  t should be an instance of the  type class. 1Match a given token of type t and produce its concrete  value (of type  t). 239Epsilon rule. Always matches, consumes nothing, produces  the given value as result. 45KEpsilon rule with lifted value. Always matches, consumes nothing, produces 8 the given value (with its lifted version) as result. 6Optionally match a given rule. 7GBase type class for production rule interpretations. A production rule + interpretation that is an instance of the 7 type class supports P sequencing and disjunction of rules, empty rules, dead rules and end-of-input  rules. 8DSequence two rules. Result of the sequenced rule is the application > of the result of the first rule to the result of the second. 9Disjunction of two rules. :CEnd of input rule. Matches only at end of input, consumes nothing,  produces '()' as result. ;Dead rule. Never matches. <=6Sequence two rules, but drop the result of the first. >7Sequence two rules, but drop the result of the second. ?6Apply a given function to the result of a given rule. @Replace a rule'#s result value with a given value. A6Apply a given function to the result of a given rule. BReplace a rule'#s result value with a given value. C,Match any token in a given range of tokens. D]Consecutively match a given list of tokens and return their concrete token values as a list. E An old style many8 combinator. Produces an infinite rule similar to Parsec's many rule.  Prefer to use the , function whenever possible. F An old style many8 combinator. Produces an infinite rule similar to Parsec's many rule.  Prefer to use the , function whenever possible. )*+,-./0123456789:;<=>?@ABCDEF789:;456<2301=>?@AB./+,-)*CDEF)**+,-,-.//01123345656789:;89:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\GHIJKLMNOPQRSTUVWXYZ[\\[ZYXWVUTSRQPONMLKJIHGGHIJKLMNOPQRSTUVWXYZ[\ ]^_;A trivial identity processor that keeps current production  rule results unmodified. 2`9Apply a given processor to a given context-free grammar. ab9Apply a given processor to a given extended context-free  grammar. cBApply a given processor to a given extended liftable context-free  grammar. d=A trivial processor that throws everything away and returns  a value of the type K0 (). ]^_`abcd^]_d`acb]^_`abcd%      !"#$%&'()*+,-/0  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd efghijklm efghijklm ijklhefgm efgfghijkjklm345678no9:;<=>?@ABCDEFGpHqnopqnopqnoopq rIrrr JKLMNOsPQRSTUVWXYZ[\]^_tuv`abcdw]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). stuvwtvuswstvuuvw "xyefghijklmnopqrsz{|}tuv~wxy xyz{|}~ ~z}|{xy xyyz}|{{|}~ z{|4Unfold loops in a given grammar, replacing calls to  , idx by E (/ idx) and likewise  for - 1Unfold loops in a given rule, replacing calls to  , idx by E (/ 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. @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. 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. 6It is probably possible to automatically approximate U branches where backtracking is required, which would be neat and really go beyond 7 what is currently possible in Parsec. Help welcome! ]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) & :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.  '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. 8Filter dead branches from a given context-free grammar. AFilter dead branches from a given extended context-free grammar. AFilter dead branches from a given extended context-free grammar. , 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 , 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.  #PApply 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.  ADetect 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. /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. 5Assess the size of a given grammar. Primitive rules (1, /, ,, -, 3) , are counted as 1 point, combinators like 9 or 8' just add the points of their left and ? right hand sides. Proposals for better metrics are welcome.  >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. 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.  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  for what that means). AFold 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. BCheck if a given terminal is reachable from a given other grammar A in a given extended context-free grammar. This function assumes 2 that all grammars are reachable from themselves. BCheck if a given terminal is reachable from a given other grammar 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. !REnumerate all tokens that can be present in any match of a given production rule.  YEnumerate 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. YEnumerate all tokens that can be present in any match of any string that can be matched + by any non-terminal in a given grammar. "   8Detect if a given context-free rule is an epsilon rule. #  #Print out a single production rule Print out a full grammar. HPrint out a grammar with a depth limit. Intended for infinite grammars. MPrint out the part of a grammar that is reachable from a given non-terminal. $()*+,-./0123456789:;<=>?@ABCDEFGHIJKLLMMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                   !!!"####$$$$$ !"#$%#$&#$'#$(#)*#)+#),#)-#).#).#)/#)0#)0#)1#)1#)2#)3#)4#)5#)5#)6#)7#)8#)8#)9#):#):#);#)<#)<#)=#)>#)?#)@#)A#)B#)C#)D#EF#EG#EH#EI#EJ#EK#EL#EM#EN#EO#PQ#PR#PSTUVWXYZ[\]^_`abcdefgh i j k k l m n  o p p q r s t u v w x y z { | } ~                               TUebcdQ                   !!!!"" "!#"#####$#%$&$'$($)$*$+$,$-$.$/$0$12grammar-combinators-0.1"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.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.Parsec/Text.GrammarCombinators.Parser.RecursiveDescent&Text.GrammarCombinators.Parser.UUParse+Text.GrammarCombinators.Transform.FoldLoops"Text.GrammarCombinators.TH.RealLL11Text.GrammarCombinators.Transform.CombineEpsilons,Text.GrammarCombinators.Transform.FilterDies'Text.GrammarCombinators.Utils.CalcFirst,Text.GrammarCombinators.Transform.LeftCorner.Text.GrammarCombinators.Transform.UniformPaull'Text.GrammarCombinators.Utils.IsChainNT0Text.GrammarCombinators.Transform.UnfoldChainNTs(Text.GrammarCombinators.Utils.AssessSize.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.PrintGrammar%Text.GrammarCombinators.Utils.ToGraphText.GrammarCombinators.BaseText.GrammarCombinators.TH.Base$Text.GrammarCombinators.TH.FoldLoopsToken ConcreteTokenclassifyenumConcreteTokensLiftFamliftIdxEliftIdxPSubValMkSubValunSubValDomainEmbeddingsupPF DomainMapsupIxsubIxDomainEqFameqIdx overrideIdxShowFamshowIdxFoldFamfoldFamMemoFamMemofromMemotoMemo ApplyIxMapIxMapSeq IxMapBaseIxMapId memoFamily memoFamilyKtoMemoK fromMemoK overrideIdxKSubPFILunILSuperProductionRulesubrefLoopProductionRulemanyRefmany1RefRecProductionRulerefTokenProductionRuletokenEpsProductionRuleepsilonLiftableProductionRuleepsilonL optionallyProductionRule>>>||| endOfInputdie epsilonLS*>>>>>>*$>>$>>*$|>>$|>>* tokenRangestringmanyInfmany1Inf%ProcessingLExtendedContextFreeGrammar$ProcessingExtendedContextFreeGrammarProcessingLContextFreeGrammarProcessingContextFreeGrammarProcessingRegularGrammarLExtendedContextFreeGrammarExtendedContextFreeGrammarLContextFreeGrammarContextFreeGrammarGLExtendedContextFreeGrammarGExtendedContextFreeGrammarGLContextFreeGrammarGContextFreeGrammarGRegularGrammarPGrammarAGrammarGGrammarExtendedLiftableContextFreeRuleLiftableContextFreeRuleExtendedContextFreeRuleContextFreeRule RegularRule Processor GProcessoridentityProcessorapplyProcessorapplyProcessorLapplyProcessorEapplyProcessorLEtrivialProcessorWrapLookaheadNBRWrapLNBR unWrapLNBRUnambiguousTopDownGrammarNonBranchingRuleMkNBRunNBR nbrEndOfInput parseTopDownLL1Table calcLL1TableparseLL1prepareLL1TableTHDerivsResultNoParseParsed parsePackrat RealLL1TableMkRealLL1TableBranchSelectorMemoFlipBSSplitBranchSelectorMemoLDefaultBranchSelectorMemoFirstSetFS firstTokens canBeEmptycanBeEOIprepareLL1Parser parseRealLL1 unfoldLoopsunfoldLoopsRulereplaceLoopsRule UnfoldDepthunfoldRecursionunfoldRecursionE selectNothing selectAllOncemodifyUnfoldDepthselectNTunfoldSelectiveunfoldSelectiveE unfoldRule unfoldRuleE parseParsec parseRecDecparseUURparseUU parseUURuleparseUUEFoldLoopsResultValueFoldLoopsValueFoldLoopsDomainFLManyFLBaseFLManyIxFLBaseIxprocessFoldLoops foldLoopsfoldAndProcessLoopsliftRealLL1TablecombineEpsilonscombineEpsilonsE filterDies filterDiesE filterDiesLEfirstSet calcFirstLCValueLCDomainLCNTMinT LCNTMinNTLCBase LCNTMinTIx LCNTMinNTIxLCBaseIxtransformLeftCornertransformLeftCornerEUPValueUPDomainUPTailUPHeadUPBaseUPTailIxUPHeadIxUPBaseIxunUPTVunUPHVunUPBVtransformUniformPaulltransformUniformPaullEtransformUniformPaullLE isChainNTunfoldChainNTsunfoldChainNTsE assessSizeEnumerateGrammarEnumerateProductionRuleIPPprintIPPEnumerateParserInternalGrammarenumerateGrammarenumerateGrammarEWrapURWURunWUR UDFGrammarUnfoldDepthFirstRuleMkFRRfoldReachableFromRuleSimpleLoopProductionRulemanyRef' many1Ref'SimpleRecProductionRuleref' cutRecursion declareDeadunfoldDepthFirst''unfoldDepthFirst'unfoldDepthFirstProperunfoldDepthFirstisDead unfoldDeadE unfoldDeadLE unfoldDeadoptimizeGrammarEfoldReachableProper foldReachable isReachableisReachableProperenumRuleTokens enumTokens enumAllTokens isEpsilon printRule printGrammarprintGrammarInfprintReachableGrammar ruleToGraphgraphToGraphvizfullGrammarToGraphreachableGrammarToGraph showGraphtemplate-haskellLanguage.Haskell.TH.SyntaxLiftghc-prim GHC.TypesCharhmapAIL hmapSubPFmultirec-0.4.1Generics.MultiRec.HFunctorhmapMhmaphmapAHFunctorGenerics.MultiRec.BaseindexunCunTagunIIunKKULR:+::*:Tag:>:CunI0I0unK0K0PFproofEltofromFameqSEqSGenerics.MultiRec.Constructor conFixityconName ConstructorPrefixInfixFixityLeftAssociativeRightAssociativeNotAssociative AssociativityGenerics.MultiRec.TEqcastRefl:=:baseGHC.Num+applyProcessor'WrapNonBranchingRuleListWrapNBRL unWrapNBRLLLRuleMkLLRule llRuleAltsruleForTokenTableruleForEOITableruleForEmptyTableFirstSetGrammarRec FSCalculatorMkFSCalculatorcalcFSFirstSetGrammarunionL fixFSGrammarll1Disambiguate liftLL1TablePackratGrammar PackratRulerunParseInternalGrammarInternalPRRuleunDerivsPRResult unPRResult PackratValue PRBaseValuePREndOfInputValuePRPrimTokenValue PackratDomainPackratDomainEndOfInputPackratDomainPrimTokenPackratDomainBasePRBaseIxPREndOfInputIx PRPrimTokenIxunPRPrimTokenValue buildDerivstoInternalGrammarparsePackratAllprSubRefunRealLL1TableRealLL1Grammar RealLL1Rule MkRealLL1Rule runLL1Rule BSCGrammarBranchSelectorComputerMkBSC branchDataBranchSelectorGrammar BranchDataMkBDbranchSelectorseqBSBranchSelectorMkBS selectBranchdefaultBranchSelectorunBranchSelectorMemofixBSCUnfoldLoopsWrapperULWrunULW RPWGrammarRPWRule unRPWRuleunfoldSelective' WrapGenParserWGPunWGP RecDecRulerunRDparseRecDecBaseWrapPWPunWPFLWrapFLW*unFLWFLRMVunFLRMVFLRBVunFLRBVFLMVunFLMVFLBVunFLBVFLMCombineEpsilonsRule CEEpsRuleCERule runCERuleFilterDiesRule FDDieRule FDBaseRule runFDRuleWrapFSCWFSCunWFSC blockRecurse WrapNTMinNTPs WNTMinNTPs unWNTMinNTPs WrapNTMinNTP WNTMinNTP unWNTMinNTPTransformLCRuleMkTLCIRtlcEmptytlcFull tlcNTMinNT tlcNTMinT WrapFSectWFSunWFSWrapLCNTMinNTMemo WLCNTMNTM unWLCNTMNTtransformLeftCorner' LCNTMinTV LCNTMinNTVLCBVWrapListOfTailHeadManysWLOTHMunWLOTHMWrapTransformUPWrapperWrapTUPW unWrapTUPWTransformUPGrammarTransformUPWrapperMkTUPWtUPRuleForGrammarTransformUPIntRuleMkTUPIRtlclwRecursionLimitActive tlclwEmpty tlclwHead tlclwTail tlclwFull mkSimpleTUPW mkEpsTUPW mkEpsLTUPW tlclTailReffailHeadRefsTosucceedTailRefstransformUniformPaull'UPTVUPHVUPBV IsChainNTMkITR ruleIsEpsilon ruleIsChainRuleToManyWrapperRTMWruleToManyRuleruleToMany1RuleRTMEpsAssessSizeProductionRuleASPRassessSizeRule IsDeadRuleMkIDR ruleIsDead KnownDeadMkKD knownDeadseqDeadaltDeadputDeathUnfoldDeadRuleUDRuleunUDRuleFoldReachableIntRuleMkFRIRfoldRuleFolderMkFFfoldIdxsSeenGramMkSGseenIdxcombineFolders foldDeadEndfoldViasetSeenputSeennoFoldfoldIdxfoldRef nothingSeen isReachable'EnumTokensRuleETRunETR enumTokens' IsEpsilonRuleMkIERunIERPrintProductionRule printIPPSub printGrammar'infinityGraphConstructorMkGCconstructContextsnewNodetell1leafNodeconstructContextsSubruleToContextsgraphvizParamsgrammarToContextsgrammarToGraphvoid