%7o      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn  Safe-Inferred*24JKM 9Class that captures elements of an input string (tokens). is the end-of-string symbol  is the empty-string symbolBoth  and  must be distinct from eachother and from all tokens in the input string. The show instance is required to throw error messages.This function is used for matching grammar tokens and input tokens. Override this method if, for example, your input tokens store lexemes while the grammar tokens do noto A list of sA datatype for representing tokens with some builtins and an aribitrary Token constructor. This datatype stores (optional) lexemes. A list of sA X is either a nonterminal or a terminal, where a terminal contains some arbitrary token.dA grammar slot acts as a label to identify progress of matching a production. As such, a slot is a Prod with its right-hand side split in two: a part before and a part after 'the dot'. The dot indicates which part of the right-hand side has been processed thus far.7A grammar is a start symbol and a list of productions.  A list of s.{A production binds a nonterminal identifier (left-hand side) to a list of symbols (the right-hand side of the production).pIdentifier for nonterminals.o pqro p o pqr Safe-Inferred*24JKMAn SPPFNodeI is either a symbol node, an intermediate node, a packed node or a dummy.!Stores edges, potentially costly.'Stores intermediate nodes using nested  Data.IntMaps, nesting is as follows: left extent right extent set of slots !Stores symbol nodes using nested  Data.IntMaps, nesting is as follows: left extent right extentset of symbols !Stores packed nodes using nested  Data.IntMaps, nesting is as follows: left extent right extent!dot position (from left to right))mapping from productions to set of pivots!An ! contains symbol nodes, intermediate nodes, packed nodes and edges between them. See Scott and Johnstone (2013) for an explanation of the !./stuvwxyz{ !|}~"-stuvwxyz{ !|}~"+stuvwxyz{ !|}~" Safe-Inferred24JKM#The  ParseResult datatype contains the SPPF/ and some other information about the parse:! Whether the parse was successful2The number of descriptors that have been processed5The number of symbol nodes (nonterminal and terminal)The number of intermediate noesThe number of packed nodesThe number of GSS nodesThe number of GSS edges0 A list of  ParserOptions1%An option updates the current set of ./Flags to influence the behaviour of the parser.$Monad for implicitly passing around contextConnecting it allPop-setGSS representationThe worklist and descriptor set Types for "Representation of the input string5The default flags: * Do not add symbol nodes to the !*. * Do not add intermediate nodes to the !. * Do not add edges to the !`. * Flexible binarisation. * The three furthest discoveries of a token mismatch are reported. Execute the given Options in left-to-right order on .2 Create the !> with all nodes and edges, not necessarily strictly binarised.3-Create all nodes, but no edges between nodes.4Create packed-nodes only.5/Fully binarise the SPPF, resulting in a larger ! and possibly slower runtimes. When this flag is on, packed nodes can only have a single symbol node child or one intermediate node child and one symbol node child. With the flag disabled a packed node can have two symbol node children.6HSet the maximum number of errors shown in case of an unsuccessful parse.7Run the GLL parser given a  t and a list of t s, where t6 is an arbitrary token-type. All token-types must be .8)Run the GLL parser given some options, a  t and a list of ts."If no options are given a minimal ! will be created:only packed nodes are createdthe resulting ! is not strictly binarisedL#$%&'()*+,-./012345678/ !"#$%&'()*+,-./012345678/780152346#$%&'()*+,-./! "/# $%&'()*+,-./012345678 Safe-Inferred24JKMAssumes  and '#'" never appear in the inpur string.None24JKM9An impure reference to a :.:A : maps left-extent l to right-extent r to some results a, indicating the the substring ranging from l to r is derived with parse result a.; Clears the :% to which the given reference refers.<Create a reference to a fresh :.9:;<9:;<9:;< Safe-Inferred24JKM  Safe-Inferred24JKM =A single option.> A list of =(s for evaluating combinator expressions.CombinatorOptions datatype * left_biased_choice: see function leftBiased * pivot_select: provide a filtering function on pivots'The default options: no disambiguation.? Enables a 'longest-match' at production level. Enables a 'shortest-match' at production level.@Enables 'longest-match' at non-terminal level. AHSet the maximum number of errors shown in case of an unsuccessful parse.BIf there are no parse results, the default behaviour is to return an empty list. If this option is used, a runtime error will be reported, with debugging information.CTurns all occurrences of <||> into a 'left biased' variant: only return results of the second alternate if the first alternate does not have any results.DOWhether to use unsafe memoisation to speed up the enumeration of parse results.rFilter a list such that the only remaining elements are equal to the maximum element, given an ordering operator.=>?@ABCD=>?@ABCD=>?@ABCD  Safe-Inferred24JKMNone24JKM'EClass for lifting to M. GClass for lifting to L. IClass for lifting to O.K Synonym of J for creating derived combinators. L@A list of alternatives represents the right-hand side of a rule.M[A combinator expression representing an alternative: the right-hand side of a production.N^A combinator expression representing a BNF-grammar. The terminals of the grammar are of type tF. When used to parse, the expression yields semantic results of type a. O2A combinator expression representing a symbol. A Oj either represents a terminal or a nonterminal. In the latter case it is constructed with (a variant of) UZ and adds a rule to the grammar of which the represented symbol is the left-hand side.The grammar of a given parser.P Runs a parser given a string of [s and returns a list of semantic results, corresponding to all finitely many derivations.QRun the parser with some >.RRun the parser with some >j and return either an error or the results. Any returned results will be a list of length greater than 0.SGet the #, containing an !?, produced by parsing the given input with the given parser.TGet the # given some 0 and >. UvForm a rule by giving the name of the left-hand side of the new rule. Use this combinator on recursive non-terminals.V Variant of Ul for recursive non-terminals that have a potentially infinite number of derivations for some input string.A non-terminal yields infinitely many derivations if and only if it is left-recursive and would be left-recursive if all the right-hand sides of the productions of the grammar are reversed.WForm an MJ by mapping some semantic action overy the result of the second argument.XAdd a O* to the right-hand side represented by an M creating a new M]. The semantic result of the first argument is applied to the second as a cross-product. YAdd an M to a list of MD The resuling '[] :. AltExpr' forms the right-hand side of a rule.Z+Create a symbol-parse for a terminal given:The # token represented by the terminal.A function from that  to a semantic result.[Parse a single character. char c = term_parser c id Currently, this is the only character-level combinator exported by this module. Please use token-level combinators for practical parsing. Might change in the future.\$Parse a single character, using the  datatype.]$Parse a single character, using the  datatype.^"Parse a single integer, using the 9 datatype. Returns the lexeme interpreted as an integer._"Parse a single Boolean, using the 8 datatype. Returns the lexeme interpreter as a Boolean.`)Parse a single String literal, using the ? datatype. Returns the lexeme interpreted as a String literal.a%Parse a single identifier, using the * datatype. Returns the lexeme as a Stringb*Parse a single arbitrary token, using the  datatype. Returns the lexeme.cQThe empty right-hand side that yields its first argument as a semantic result.d'This function memoises a parser, given:A 9 pointing to a fresh :, created using <.The O to memoise.Use d on all parsers that are expected to derive the same substring multiple times. If the same combinator expression is used to parse multiple times the 9 needs to be cleared using ;.d relies on 2 and is therefore potentially unsafe. The option D5 enables memoisation. It is off by default, even if d$ is used in a combinator expression.e3Helper function for defining new combinators. Use eH to form a new unique non-terminal name based on the symbol of a given O and a 1 that is unique to the newly defined combinator.Specialised fmap for altparsersf Version of W: that ignores the semantic result of its second argument. g Version of X8 that ignores the semantic result of the first argument.h Version of X9 that ignores the semantic result of the second argument.iLeft-biased version of ijTry to apply a parser j7 (0 or more) times. The results are returned in a list.kTry to apply a parser k7 (1 or more) times. The results are returned in a list.lDTry to apply a parser once, but proceed if unsuccessful (yielding  as a result in that case).9EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklS #$%&'()*+,-./23459:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklSZc\]^_`ab[XYWUVNOML PQ>=C?@AB2345RST#$%&'()*+,-./efghiljkGHIJKEFd<;:9D3EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkl UVWXYfghiNone24JKMm%Defines and executes some unit-tests mnmmnmn None24JKMS #$%&'()*+,-./23459:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkl    !"#$%&'()*+,,-./0123456789:;<=>?@ABCD E F G H > I J KLMNOPQRSTUV?@WXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}#%~s      TV gll-0.3.0.1 GLL.ParserGLL.Combinators.InterfaceGLL.Combinators.Test.InterfaceGLL.Types.AbstractGLL.Types.GrammarGLL.Parseable.CharGLL.Combinators.MemoisationGLL.Combinators.Visit.GrammarGLL.Combinators.OptionsGLL.Combinators.Visit.SemGLL.Combinators ParseableeosepsmatchesTokenIDLit StringLitBoolLitIntLitEpsilonEOSKeywordCharSymbolsSymbolTermNtSlotGrammarProdsProdSPPFNodeDummyPNodeINodeSNodeEdgeMapImdMapSymbMapPackMapSPPFshowSPPF ParseResult sppf_result res_successnr_descriptorsnr_nterm_nodes nr_term_nodesnr_intermediate_nodesnr_packed_nodes nr_sppf_edges nr_gss_nodes nr_gss_edges error_message ParseOptions ParseOptionfullSPPFallNodespackedNodesOnlystrictBinarisation maximumErrorsparseparseWithOptionsMemoRef MemoTablememClear newMemoTableCombinatorOptionCombinatorOptions maximumPivotmaximumPivotAtNt throwErrors leftBiaseduseMemoisation IsAltExprtoAltHasAltsaltsOf IsSymbExprtoSymbmkRuleAltExprsAltExprBNFSymbExprparseWithOptionsAndError parseResultparseResultWithOptions<:=><::=><$$><**><||> term_parsercharkeycharkeywordint_litbool_lit string_litid_littokensatisfymemomkNt<$$**><**<::=manysomeoptionalmain$fParseableCharTokens$fParseableToken $fShowToken FollowMapFirstMap SelectMap PrefixMapProdMapPEdgeSEdgeNtLPrLSlotL emptySPPF pNodeLookup pMapInsert sNodeLookup sNodeInsert sNodeRemove iNodeLookup iNodeInsert iNodeRemove eMapInsertinUtoUshowDshowGshowPshowSnTepsilon fixedMapsisNtisTermisChar $fShowSymbol $fShowSlotFlagsGLLMutablePcalGSSRcal LhsParamsInput defaultFlags runOptions symbol_nodesintermediate_nodesedgesflexible_binarisation max_errors mut_successmut_sppf mut_worklistmut_descriptorsmut_gss mut_popsetmut_mismatches MisMatchesGSlotU0GSSNodeGSSEdgeUcal RhsParamsrunGLL addSPPFEdgeaddDescrgetDescraddPop getChildren addGSSEdgegetPops addSuccessgetFlags addMisMatchgll joinSPPFsresultFromMutable renderErrors$fShowParseResult $fMonadGLL $fFunctorGLL$fApplicativeGLL$fShowSPPFNode $fShowGSlotbaseGHC.Base$ memLookup memInsert Grammar_Expr grammar_nterm grammar_apply grammar_seq PCOptionsdefaultOptions minimumPivot maximumsWithleft_biased_choice pivot_selectpivot_select_nt throw_errorsdo_memo maintainWith AncestorsSem_AltSem_Symb sem_nterm sem_applysem_seq inAncestors toAncestorsgrammarGHC.IOunsafePerformIOString.$. Data.MaybeNothingparse' defaultPOptsmkNtRule $fIsAltExprOO$fIsAltExprSymbExpr$fIsAltExprAltExpr $fHasAltsOO$fHasAltsSymbExpr$fHasAltsAltExpr$fIsSymbExprOO$fIsSymbExprSymbExpr$fIsSymbExprAltExpr