(      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~        Safe9;QRT  A list of  ParserOptions%An option updates the current set of ./Flags to influence the behaviour of the parser. 5The default flags: * Do not add symbol nodes to the SPPF*. * Do not add intermediate nodes to the SPPF. * Do not add edges to the SPPF. * Flexible binarisation. * The three furthest discoveries of a token mismatch are reported. * Select tests are performed. Execute the given Options in left-to-right order on  .  Create the SPPF> with all nodes and edges, not necessarily strictly binarised. -Create all nodes, but no edges between nodes.Create packed-nodes only./Fully binarise the SPPF, resulting in a larger SPPF 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.HSet the maximum number of errors shown in case of an unsuccessful parse.)Turn of select tests. Disables lookahead.      Safe/9;QRT'Class whose members are super-types of .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 notdThis function pretty-prints the Parseable type by displaying its lexeme. Default implementation is 7, which should be replaced for prettier error messages. A list of sA datatype for representing tokens with some builtins and an aribitrary Token constructor. This datatype stores (optional) lexemes.%Palternative identifiers, for example functions vs. constructors (as in Haskell).' A list of (s(A (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).1Identifier for nonterminals.2Pretty-prints a list of &s as a concatenation of their lexemes.) !"#$%&'()*+,-./0123456789:$& !"#$%'()*+,-./012345)1/0.-+,()*' !"#$%&:98234576  !"#$%&'()*+,-./0123456789:Safe9;QRTDAssumes  and #" never appear in the inpur string.DDSafe/9;QRTNAn SPPFNodeI is either a symbol node, an intermediate node, a packed node or a dummy.S!Stores edges, potentially costly.T'Stores intermediate nodes using nested  Data.IntMaps, nesting is as follows: left extent right extent set of slots U!Stores symbol nodes using nested  Data.IntMaps, nesting is as follows: left extent right extentset of symbolsV!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 pivotsWAn W contains symbol nodes, intermediate nodes, packed nodes and edges between them. See Scott and Johnstone (2013) for an explanation of the W.(EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkl(EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkl(ZYXWVUTSNOPQRMLKJ[\]^_`abcdefghijkIHGFEl$EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklSafe9;QRToThe  ParseResult datatype contains the SPPF/ and some other information about the parse:W 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 edges $Monad for implicitly passing around context Connecting it all Pop-set GSS representation The worklist and descriptor set Types for "Representation of the input string Create an 1 (nonterminal) from a String.|)A smart constructor for creating a start 1 (nonterminal).}#A smart constructor for creating a / (production).~/A smart constructor for creating a nonterminal (.,A smart constructor for creating a terminal (.Run the GLL parser given a - t and a list of t s, where t6 is an arbitrary token-type. All token-types must be .)Run the GLL parser given some options, a - t and a list of ts."If no options are given a minimal W will be created:only packed nodes are createdthe resulting W is not strictly binarised=opqrstuvwxyz{     |}~ !"#$%&'()*+,-5 '()*+,-./0NOPQRSTUVWkopqrstuvwxyz{|}~5-./0'()*+,|}~ opqrstuvwxyz{WNOPQRUTVSk(o pqrstuvwxyz{     |}~ !"#$%&'()*+,- Safe9;QRT./01./01./01Safe9;QRT 9Settings for changing the behaviour of the builtin lexer . Lexers are built using Text.Regex.Applicative.+Which keychars to recognise? Default: none.+Which keywords to recognise? Default: none.4What is considered a whitespace character? Default: 2.*How does a line comment start? Default: '"//"'.2How does a block comment open? Default: '"'{-'"'. 2How does a block comment close? Default: '"'-}'"'.PHow to recognise identifiers? Default alphanumerical with lowercase alpha start.\How to recognise alternative identifiers? Default alphanumerical with uppercase alpha start.Arbitrary tokens (a,b). a is the token name, b is a regular expression. The default .A lexer using the default .A lexer parameterised by .3 3None9;QRTAn 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 .Safe9;QRTA 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.2Discards a pivot select option (internal use only)Enables 'longest-match' at non-terminal level. HSet the maximum number of errors shown in case of an unsuccessful parse.If 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.Turns all occurrences of <||> into a 'left biased' variant: only return results of the second alternate if the first alternate does not have any results.OWhether 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.FEnables select tests at all levels: nonterminal, alternative and slot.GDisables select tests at all levels: nonterminal, alternative and slot.1Enables select tests at the level of alternatives2Disables select tests at the level of alternatives1Enables select tests at the level of nonterminals2Disables select tests at the level of nonterminals2Enables select tests at the level of grammar slots3Disables select tests at the level of grammar slots""" Safe9;QRT456789:;456789:;456789:; None9;QRTClass for lifting to . Class for lifting to . Class for lifting to . Synonym of  for creating derived combinators. @A list of alternatives represents the right-hand side of a rule.[A combinator expression representing an alternative: the right-hand side of a production.^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. 2A combinator expression representing a symbol. A j either represents a terminal or a nonterminal. In the latter case it is constructed with (a variant of) <:=>Z and adds a rule to the grammar of which the represented symbol is the left-hand side.<=>?@ABCDEFGHI<=>?@<=>?@ABCDEFGHI None9;QRTBJThe grammar of a given parser. Runs a parser given a string of [s and returns a list of semantic results, corresponding to all finitely many derivations.Run the parser with some .Run the parser with some  and .Run 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.Run the parser with some  and i. Returns either an error or the results. Any returned results will be a list of length greater than 0.Get the o, containing an W?, produced by parsing the given input with the given parser.Get the o given some  and . vForm a rule by giving the name of the left-hand side of the new rule. Use this combinator on recursive non-terminals. Variant of l 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. Variant of  ::=/ that can be supplied with a list of alternatesForm an J by mapping some semantic action overy the result of the second argument.Add a * to the right-hand side represented by an  creating a new ]. The semantic result of the first argument is applied to the second as a cross-product.  Variant of 0 that applies longest match on the left operand. Variant of 1 that applies shortest match on the left operand.Add an  to a list of D The resuling '[] :. AltExpr' forms the right-hand side of a rule.Apply this combinator to an alternative to indicate that the alternative is for a left-associative operator. Used for top-down disambiguation.Apply this combinator to an alternative to indicate that the alternative is for a right-associative operator. Used for top-down disambiguation.Apply this combinator to an alternative to indicate that the alternative is for an associative operator. Used for top-down disambiguation.+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 a  type."Parse a single character, using a  type. Parse a single integer, using a 5 type. Returns the lexeme interpreted as an integer. Parse a single Boolean, using a 4 type. Returns the lexeme interpreter as a Boolean.*Parse a single Character literal, using a > type. Returns the lexeme interpreted as a Character literal.'Parse a single String literal, using a ; type. Returns the lexeme interpreted as a String literal.#Parse a single identifier, using a ' type. Returns the lexeme as a String./Parse a single alternative identifier, using a ' type. Returns the lexeme as a String.(Parse a single arbitrary token, using a  type. Returns the lexeme.QThe empty right-hand side that yields its first argument as a semantic result.'This function memoises a parser, given:A  pointing to a fresh , created using .The  to memoise.Use  on those parsers that are expected to derive the same substring multiple times. If the same combinator expression is used to parse multiple times the  needs to be cleared using . relies on K2 and is therefore potentially unsafe. The option 5 enables memoisation. It is off by default, even if $ is used in a combinator expression.3Helper function for defining new combinators. Use H to form a new unique non-terminal name based on the symbol of a given  and a L1 that is unique to the newly defined combinator.MSpecialised fmap for altparsers Variant of : that ignores the semantic result of its second argument.  Variant of 8 that ignores the semantic result of the first argument. Variant of 9 that ignores the semantic result of the second argument. Variant of 0 that applies longest match on its left operand.Variant 0 that applies shortest match on its left operand Variant of D that prioritises productions from left-to-right (or top-to-bottom). Variant of D that prioritises productions from left-to-right (or top-to-bottom).oTry to apply a parser multiple times (0 or more) with shortest match applied to each occurrence of the parser.oTry to apply a parser multiple times (1 or more) with shortest match applied to each occurrence of the parser.nTry to apply a parser multiple times (0 or more) with longest match applied to each occurrence of the parser.nTry to apply a parser multiple times (1 or more) with longest match applied to each occurrence of the parser.Try to apply a parser multiple times (0 or more). The results are returned in a list. In the case of ambiguity the largest list is returned.Try to apply a parser multiple times (1 or more). The results are returned in a list. In the case of ambiguity the largest list is returned.NInternalOInternalSame as " but with an additional separator.Same as " but with an additional separator.Same as " but with an additional separator.Same as " but with an additional separator.Same as " but with an additional separator.Same as " but with an additional separator.Like  but matching at least two occurrences of the first argument. The returned list is therefore always of at least length 2. At least one separator will be consumed.Like a but matching the minimum number of occurrences of the first argument as possible (at least 2).Like ` but matching the maximum number of occurrences of the first argument as possible (at least 2).FMake a piece of BNF optional, but proceed if unsuccessful (yielding P as a result in that case).Place a piece of BNF within3 two other BNF fragments, ignoring their semantics.8Place a piece of BNF between the characters '(' and ')'.8Place a piece of BNF between the characters '{' and '}'.8Place a piece of BNF between the characters '[' and ']'.,Place a piece of BNF between the characters Q and R.S/Place a piece of BNF between two single quotes.T/Place a piece of BNF between two double quotes.IUJVWMNOXYST & !"#$%23opqrstuvwxyz{ !"#$%&23 opqrstuvwxyz{IUJVWMNOXYST2244443444444422 None9;QRT*Defines and executes multiple1 unit-tests None9;QRT & !"#$%23opqrstuvwxyz{Z !"#$%&'()*+,-./0123)4567889:;;6<=>?@ABCDEFGHIJKLMNOPQRSTUVWXWYVZ[\]^_`abcdefghijklmnopqrstuvwwxyz{|}~                     !"#$%&'()*+,- . / 0 1234 5 6 7 8 9 : ; <   = > ? @ A B C D E F G H IJK L M N O PQRSQRT U V W X Y Z [\"gll-0.4.0.2-3hvvmlpAlXLDelaXbr5Cij GLL.FlagsGLL.Types.GrammarGLL.Parseable.CharGLL.Types.Derivations GLL.ParserGLL.Combinators.LexerGLL.Combinators.MemoisationGLL.Combinators.OptionsGLL.Combinators.InterfaceGLL.Combinators.Test.InterfaceGLL.Combinators.Visit.GrammarGLL.Combinators.Visit.SemGLL.Combinators.Visit.JoinGLL.Combinators ParseOptions ParseOptionFlags symbol_nodesintermediate_nodesedgesflexible_binarisation max_errorsdo_select_test defaultFlags runOptionsfullSPPFallNodespackedNodesOnlystrictBinarisation maximumErrors noSelectTest SubsumesTokenupcastdowncast ParseableeosepsmatchesunlexTokensTokenCharKeywordEOSEpsilonIntLitBoolLit StringLitCharLitIDLitAltIDLitSymbolsSymbolNtTermSlotGrammarProdsProd unlexTokens unlexTokenisNtisTerm $fShowSymbol $fShowSlot$fParseableToken $fShowToken$fSubsumesTokenToken $fOrdSymbol $fEqSymbol$fEqProd $fOrdProd $fShowProd$fEqSlot $fOrdSlot $fEqToken $fOrdToken$fParseableChar FollowMapFirstMap SelectMap PrefixMapProdMapPEdgeSEdgePNodeSNodeSPPFNodeINodeDummyEdgeMapImdMapSymbMapPackMapSPPFNtLPrLSlotL emptySPPF pNodeLookup pMapInsert sNodeLookup sNodeInsert sNodeRemove iNodeLookup iNodeInsert iNodeRemove eMapInsertinUtoUshowDshowGshowPshowSshowSPPF fixedMaps $fOrdSPPFNode $fEqSPPFNode 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_messagestartprodntermtermparseparseWithOptions$fShowParseResult $fMonadGLL $fFunctorGLL$fApplicativeGLL$fShowSPPFNode LexerSettingskeycharskeywords whitespace lineCommentblockCommentOpenblockCommentClose identifiersaltIdentifierstokens emptyLanguage default_lexerlexerMemoRef MemoTable memLookup memInsertmemClear newMemoTableCombinatorOptionCombinatorOptions PCOptionsleft_biased_choice pivot_selectpivot_select_nt throw_errorsdo_memont_select_testalt_select_testseq_select_test runOptionsOndefaultOptions maximumPivot minimumPivotanyPivotmaximumPivotAtNt throwErrors leftBiaseduseMemoisation maximumsWith maintainWith doSelectTestdoAltSelectTestnoAltSelectTestdoNtSelectTestnoNtSelectTestdoSlotSelectTestnoSlotSelectTest IsAltExprtoAltHasAltsaltsOf IsSymbExprtoSymbmkRuleAltExprsAltExprBNFSymbExprparseWithParseOptionsparseWithOptionsAndErrorparseWithParseOptionsAndError parseResultparseResultWithOptions<:=><::=>chooses<$$><**><**>>><<<**><||>lassocrassocassoc term_parsercharkeycharkeywordint_litbool_litchar_lit string_litid_lit alt_id_littokensatisfymemomkNt<$$**>**>>><<**><**<**>><<<**<::=<:=manymany1somesome1multiple multiple1 manySepBy manySepBy1 someSepBy someSepBy1 multipleSepBymultipleSepBy1multipleSepBy2 someSepBy2 manySepBy2optionalwithinparensbracesbracketsanglesmainbaseGHC.ShowshowGHC.Base$GLLMutablePcalGSSRcal LhsParamsInput string2nt mut_successmut_sppf mut_worklistmut_descriptorsmut_gss mut_popsetmut_mismatches MisMatchesGSSNodeGSSEdgeUcal RhsParamsrunGLL addSPPFEdgeaddDescrgetDescraddPop getChildren addGSSEdgegetPops addSuccessgetFlags addMisMatchgll joinSPPFsresultFromMutable renderErrors Grammar_Expr grammar_nterm grammar_apply grammar_seq GHC.UnicodeisSpacelTokens AncestorsSem_AltSem_Symb sem_nterm sem_applysem_seq inAncestors toAncestorsmkNtRule join_applyjoin_seq $fIsAltExprOO$fIsAltExprSymbExpr$fIsAltExprAltExpr $fHasAltsOO$fHasAltsSymbExpr$fHasAltsAltExpr$fIsSymbExprOO$fIsSymbExprSymbExpr$fIsSymbExprAltExprgrammar GHC.IO.UnsafeunsafePerformIOString.$. multiple_ multiple1_Nothingghc-prim GHC.Classes<>quotesdquotesparse' defaultPOptsepsilonsepBysepBy1