!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       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  s A 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 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). Identifier for nonterminals.!Pretty-prints a list of  &s as a concatenation of their lexemes.*  !"#$%&'()%   !"#$*  )('!"#$&%  !"#$%&'()Safe/9;QRT<An SPPFNodeI is either a symbol node, an intermediate node, a packed node or a dummy.A!Stores edges, potentially costly.B'Stores intermediate nodes using nested  Data.IntMaps, nesting is as follows: left extent right extent set of slots C!Stores symbol nodes using nested  Data.IntMaps, nesting is as follows: left extent right extentset of symbolsD!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 pivotsEAn E contains symbol nodes, intermediate nodes, packed nodes and edges between them. See Scott and Johnstone (2013) for an explanation of the E.(3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ(3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ(HGFEDCBA<=>?@;:98IJKLMNOPQRSTUVWXY76543Z$3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZSafe9;QRT]Assumes  and #" never appear in the inpur string.]]Safe9;QRT ^ A list of  ParserOptions_%An option updates the current set of `.`/Flags to influence the behaviour of the parser.h5The 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.iExecute the given Options in left-to-right order on h.j Create the SPPF> with all nodes and edges, not necessarily strictly binarised.k-Create all nodes, but no edges between nodes.lCreate packed-nodes only.m/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.nHSet the maximum number of errors shown in case of an unsuccessful parse.o)Turn of select tests. Disables lookahead.^_`abcdefghijklmno^_`adbcefghijklmno`abcdefghi_^jklmno ^_`abcdefghijklmnoSafe9;QRTpThe  ParseResult datatype contains the SPPF/ and some other information about the parse:E 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 contextConnecting it allPop-setGSS representationThe worklist and descriptor set Types for "Representation of the input string Create an   (nonterminal) from a String.})A smart constructor for creating a start   (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 E will be created:only packed nodes are createdthe resulting E is not strictly binarised=pqrstuvwxyz{| !"#$%&'}~()*+,-./01234565<=>?@ABCDEY^_jklmnopqrstuvwxyz{|}~5}~^_mjklnopqrstuvwxyz{|E<=>?@CBDAY(p qrstuvwxyz{| !"#$%&'}~()*+,-./0123456 Safe9;QRT789:789:789: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;QRT;<=>?@AB;<=>?@AB;<=>?@AB 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.CDEFGHIJKLMNOPCDEFGCDEFGHIJKLMNOPNone9;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;QRT9Settings 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: Q.*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 .Convert numerical representation in a given base (max base = 16, written as string) into decimal representation (returned as Int)RSTUVWX RSTUVWXNone9;QRTDYThe 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 p, containing an E?, produced by parsing the given input with the given parser.Get the p 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 alternates 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.OApply this combinator to an alternative to turn all underlying occurrences of % (or variants) apply 'longest match'.+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 floating point literal, using a , type. Returns the lexeme interpreted as a Z. 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 [2 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 \1 that is unique to the newly defined combinator.]Specialised 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.^Internal_InternalSame 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).8Derive either from the given symbol or the empty string. Version of X that prefers to derive from the given symbol affects only nullable nonterminal symbols Version of k that prefers to derive the empty string from the given symbol, effects only nullable nonterminal symbols 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 ` and a.b/Place a piece of BNF between two single quotes.c/Place a piece of BNF between two double quotes.MdYef]^_gh     bc  !"jklmopqrstuvwxyz{|      !"jklmopqrstuvwxyz{|     MdYef]^_gh     bc2244443444444422 None9;QRT*Defines and executes multiple1 unit-tests None9;QRT  !"jklmopqrstuvwxyz{|     i !"#$%&'(()*++&,-./0123456789:;<=>?@ABCDEFGFHEIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghiijklmnopqrstuvwxxyz{|}~nqvw                !"#$%&'()*+,-./0123456 7 8 9 : ; < = > ? @ A B   C D E F G H I J K L M NOP Q R S T U V WXYZ[\]^_`aYbcYbdefghijkl"gll-0.4.0.3-3MLSmVMi6mbHxHUzpdx9tiGLL.Types.GrammarGLL.Types.DerivationsGLL.Parseable.Char GLL.Flags GLL.ParserGLL.Combinators.OptionsGLL.Combinators.InterfaceGLL.Combinators.MemoisationGLL.Combinators.LexerGLL.Combinators.Test.InterfaceGLL.Combinators.Visit.GrammarGLL.Combinators.Visit.SemGLL.Combinators.Visit.JoinGLL.Combinators SubsumesTokenupcastdowncast ParseableeosepsmatchesunlexTokensTokenCharKeywordEOSEpsilonIntLitFloatLitBoolLit StringLitCharLitIDLitAltIDLitSymbolsSymbolNtTermSlotGrammarProdsProd unlexTokens unlexTokenisNtisTerm $fShowSymbol $fShowSlot$fParseableToken $fShowToken$fSubsumesTokenToken $fOrdSymbol $fEqSymbol$fEqProd $fOrdProd $fShowProd$fEqSlot $fOrdSlot $fEqToken $fOrdToken FollowMapFirstMap SelectMap PrefixMapProdMapPEdgeSEdgePNodeSNodeSPPFNodeINodeDummyEdgeMapImdMapSymbMapPackMapSPPFNtLPrLSlotL emptySPPF pNodeLookup pMapInsert sNodeLookup sNodeInsert sNodeRemove iNodeLookup iNodeInsert iNodeRemove eMapInsertinUtoUshowDshowGshowPshowSshowSPPF fixedMaps $fOrdSPPFNode $fEqSPPFNode$fParseableChar ParseOptions ParseOptionFlags symbol_nodesintermediate_nodesedgesflexible_binarisation max_errorsdo_select_test defaultFlags runOptionsfullSPPFallNodespackedNodesOnlystrictBinarisation maximumErrors noSelectTest 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$fShowSPPFNodeCombinatorOptionCombinatorOptions 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 IsSymbExprtoSymbmkRuleAltExprsAltExprBNFSymbExprMemoRef MemoTable memLookup memInsertmemClear newMemoTable LexerSettingskeycharskeywords whitespace lineCommentblockCommentOpenblockCommentClose identifiersaltIdentifierstokens emptyLanguage default_lexerlexer baseToDeconeOfmanyOfsomeOfparseWithParseOptionsparseWithOptionsAndErrorparseWithParseOptionsAndError parseResultparseResultWithOptions<:=><::=>chooses chooses_prec<$$><**><**>>><<<**><||> longest_matchshortest_match term_parsercharkeycharkeywordint_lit float_litbool_litchar_lit string_litid_lit alt_id_littokensatisfymemomkNt<$$**>**>>><<**><**<**>><<<**<::=<:=manymany1somesome1multiple multiple1 manySepBy manySepBy1 someSepBy someSepBy1 multipleSepBymultipleSepBy1multipleSepBy2 someSepBy2 manySepBy2optional preferably reluctantlyoptionalWithDefwithinparensbracesbracketsanglesmainbaseGHC.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 AncestorsSem_AltSem_Symb sem_nterm sem_applysem_seq inAncestors toAncestorsmkNtRule join_applyjoin_seq $fIsAltExprOO$fIsAltExprSymbExpr$fIsAltExprAltExpr $fHasAltsOO$fHasAltsSymbExpr$fHasAltsAltExpr$fIsSymbExprOO$fIsSymbExprSymbExpr$fIsSymbExprAltExpr GHC.UnicodeisSpacelTokenslToken lStringLitlCharLitlFloats lIntegersdecimalgrammarghc-prim GHC.TypesDouble GHC.IO.UnsafeunsafePerformIOString.$. multiple_ multiple1_ GHC.Classes<>quotesdquotesparse' defaultPOptsepsilonsepBysepBy1