h&vm      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                      Safe-InferredgllAn impure reference to a .gllA  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.gll Clears the % to which the given reference refers.gllCreate a reference to a fresh . Safe-InferredgllA single option.gll A list of (s for evaluating combinator expressions.gllCombinatorOptions datatype * left_biased_choice: see function leftBiased * pivot_select: provide a filtering function on pivotsgll'The default options: no disambiguation.gll.Enables a 'longest-match' at production level.gll/Enables a 'shortest-match' at production level.gll2Discards a pivot select option (internal use only)gll/Enables 'longest-match' at non-terminal level. gllSet the maximum number of errors shown in case of an unsuccessful parse.gllIf 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.gllTurns all occurrences of <||> into a 'left biased' variant: only return results of the second alternate if the first alternate does not have any results.gllWhether to use unsafe memoisation to speed up the enumeration of parse results.gllFilter a list such that the only remaining elements are equal to the maximum element, given an ordering operator. gllEnables select tests at all levels: nonterminal, alternative and slot.!gllDisables select tests at all levels: nonterminal, alternative and slot."gll1Enables select tests at the level of alternatives#gll2Disables select tests at the level of alternatives$gll1Enables select tests at the level of nonterminals%gll2Disables select tests at the level of nonterminals&gll2Enables select tests at the level of grammar slots'gll3Disables select tests at the level of grammar slots"  !"#$%&'"  !"#$%&' Safe-Inferred (gll A list of  ParserOptions)gll%An option updates the current set of *.*gll/Flags to influence the behaviour of the parser.2gll5The 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.3gllExecute the given Options in left-to-right order on 2.4gll Create the SPPF> with all nodes and edges, not necessarily strictly binarised.5gll-Create all nodes, but no edges between nodes.6gllCreate packed-nodes only.7gll/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.8gllSet the maximum number of errors shown in case of an unsuccessful parse.9gll)Turn of select tests. Disables lookahead.()*1/-,0.+23456789*1/-,0.+23)(456789 Safe-Inferred5:gll'Class whose members are super-types of C.=gll9Class 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.@gllThis 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 notAgllThis function pretty-prints the Parseable type by displaying its lexeme. Default implementation is 7, which should be replaced for prettier error messages.Bgll A list of CsCgllA datatype for representing tokens with some builtins and an aribitrary Token constructor. This datatype stores (optional) lexemes.Ngllalternative identifiers, for example functions vs. constructors (as in Haskell).Pgll A list of QsQgllA Q is either a nonterminal or a terminal, where a terminal contains some arbitrary token.TgllA 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.Vgll7A grammar is a start symbol and a list of productions. Wgll A list of Xs.XgllA production binds a nonterminal identifier (left-hand side) to a list of symbols (the right-hand side of the production).ZgllIdentifier for nonterminals.[gllPretty-prints a list of C&s as a concatenation of their lexemes.%:<;=A@?>BCNMLKJIHGFEODPQSRTUVWXYZ[\]^%ZXYWVTUQSRPCNMLKJIHGFEODB=A@?>:<;[\]^ Safe-Inferred5vgllAn SPPFNode is either a symbol node, an intermediate node, a packed node or a dummy.{gll!Stores edges, potentially costly.|gll'Stores intermediate nodes using nested  Data.IntMaps, nesting is as follows: left extent right extent set of slots }gll!Stores symbol nodes using nested  Data.IntMaps, nesting is as follows: left extent right extentset of symbols~gll!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 pivotsgllAn  contains symbol nodes, intermediate nodes, packed nodes and edges between them. See Scott and Johnstone (2013) for an explanation of the .(mnopqrstuvzyxw{|}~(~}|{vzyxwutsrqponm Safe-Inferred%ugllThe  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 edgesgll$Monad for implicitly passing around contextgllConnecting it allgllPop-setgllGSS representationgllThe worklist and descriptor setgll Types for gll"Representation of the input stringgll Create an Z (nonterminal) from a String.gll)A smart constructor for creating a start Z (nonterminal).gll#A smart constructor for creating a X (production).gll/A smart constructor for creating a nonterminal Q.gll,A smart constructor for creating a terminal Q.gllRun the GLL parser given a V t and a list of t s, where t6 is an arbitrary token-type. All token-types must be =.gllRun the GLL parser given a V t and an Array of t s, where t6 is an arbitrary token-type. All token-types must be =.gll Variant of  where the input is a list of =s rather than an Arraygll)Run the GLL parser given some options, a V 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 binarised;()456789=>?@APQRSTUVWXYvwxyz{|}~;VWXYPQRSTU=>?@A()745689vwxyz}|~{ Safe-Inferred&gllAssumes  and #" never appear in the input string. Safe-Inferred&  Safe-Inferred' Safe-Inferred,gll9Settings for changing the behaviour of the builtin lexer . Lexers are built using Text.Regex.Applicative.gll+Which keychars to recognise? Default: none.gll+Which keywords to recognise? Default: none.gll4What is considered a whitespace character? Default: .gll*How does a line comment start? Default: '"//"'.gll2How does a block comment open? Default: '"'{-'"'. gll2How does a block comment close? Default: '"'-}'"'.gllHow to recognise identifiers? Default alphanumerical with lowercase alpha start.gllHow to recognise alternative identifiers? Default alphanumerical with uppercase alpha start.gllArbitrary tokens (a,b). a is the token name, b is a regular expression.gllWhether integer literals may be signed positive or negative. Default: gll The default .gllA lexer using the default .gll Variant of 5 that throws an error or returns the result otherwisegllA lexer parameterised by .gllConvert numerical representation in a given base (max base = 16, written as string) into decimal representation (returned as Int)  Safe-Inferred-gll>Composition of type constructors: unary with binary. Called  StaticArrow in [1]. Safe-Inferred0gllClass for lifting to . gllClass for lifting to . gllClass for lifting to .gll Synonym of  for creating derived combinators. gllA list of alternatives represents the right-hand side of a rule.gllA combinator expression representing an alternative: the right-hand side of a production.gllA combinator expression representing a BNF-grammar. The terminals of the grammar are of type t. When used to parse, the expression yields semantic results of type a. gll2A combinator expression representing a symbol. A  either represents a terminal or a nonterminal. In the latter case it is constructed with (a variant of) <:=> and adds a rule to the grammar of which the represented symbol is the left-hand side.  Safe-InferredOgll'A table mapping operator keywords to a  and  It provides a convenient way to build an expression grammar (see ). gll?Print some information about the parse. Helpful for debugging.gll Variant of  which can be controlled by )sgllPrint some information gll)The grammar of a given symbol expression.gll:Print some information about the grammar constructed by a  . useful for debugging purposesgll Runs a parser given a string of =s and returns a list of semantic results, corresponding to all finitely many derivations.gllRun the parser with some .gllRun the parser with some ( and .gllRun the parser with some  and return either an error or the results. Any returned results will be a list of length greater than 0.gllRun the parser with some ( and . Returns either an error or the results. Any returned results will be a list of length greater than 0.gllGet the , containing an ?, produced by parsing the given input with the given parser.gllGet the  given some ( and . gllForm a rule by giving the name of the left-hand side of the new rule. Use this combinator on recursive non-terminals.gll Variant of  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.gll Variant of / that can be supplied with a list of alternatesgll Variant of / that can be supplied with a list of alternatesgllForm an  by mapping some semantic action overy the result of the second argument.gllAdd 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. gll Variant of 0 that applies longest match on the left operand.gll Variant of 1 that applies shortest match on the left operand.gllAdd an  to a list of  The resuling '[] :. AltExpr' forms the right-hand side of a rule.gllApply this combinator to an alternative to turn all underlying occurrences of % (or variants) apply 'longest match'.gll+Create a symbol-parse for a terminal given:The =# token represented by the terminal.A function from that = to a semantic result.gllParse 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.gll"Parse a single character, using a : type.gll"Parse a single character, using a : type.gll Parse a single integer, using a :- type. Returns the lexeme interpreted as an .gll/Parse a single floating point literal, using a :, type. Returns the lexeme interpreted as a .gll Parse a single Boolean, using a :4 type. Returns the lexeme interpreter as a Boolean.gll*Parse a single Character literal, using a :> type. Returns the lexeme interpreted as a Character literal.gll'Parse a single String literal, using a :; type. Returns the lexeme interpreted as a String literal.gll#Parse a single identifier, using a :' type. Returns the lexeme as a String.gll/Parse a single alternative identifier, using a :' type. Returns the lexeme as a String.gll(Parse a single arbitrary token, using a : type. Returns the lexeme.gllThe empty right-hand side that yields its first argument as a semantic result.gll'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.gll3Helper function for defining new combinators. Use  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.gllSpecialised fmap for altparsersgll Variant of : that ignores the semantic result of its second argument. gll Variant of 8 that ignores the semantic result of the first argument.gll Variant of 9 that ignores the semantic result of the second argument.gll Variant of 0 that applies longest match on its left operand.gllVariant 0 that applies shortest match on its left operandgll Variant of  that prioritises productions from left-to-right (or top-to-bottom).gll Variant of  that prioritises productions from left-to-right (or top-to-bottom).gllTry to apply a parser multiple times (0 or more) with shortest match applied to each occurrence of the parser.gllTry to apply a parser multiple times (1 or more) with shortest match applied to each occurrence of the parser.gllTry to apply a parser multiple times (0 or more) with longest match applied to each occurrence of the parser.gllTry to apply a parser multiple times (1 or more) with longest match applied to each occurrence of the parser.gllTry 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.gllTry 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.gllInternalgllInternalgllSame as " but with an additional separator.gllSame as " but with an additional separator.gllSame as " but with an additional separator.gllSame as " but with an additional separator.gllSame as " but with an additional separator.gllSame as " but with an additional separator.gllLike  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.gllLike  but matching the minimum number of occurrences of the first argument as possible (at least 2).gllLike  but matching the maximum number of occurrences of the first argument as possible (at least 2).gll8Derive either from the given symbol or the empty string.gll Version of  that prefers to derive from the given symbol, affects only nullable nonterminal symbolsgll Version of  that prefers to derive the empty string from the given symbol, affects only nullable nonterminal symbolsgllPlace a piece of BNF within3 two other BNF fragments, ignoring their semantics.gll8Place a piece of BNF between the characters '(' and ')'.gll8Place a piece of BNF between the characters '{' and '}'.gll8Place a piece of BNF between the characters '[' and ']'.gll,Place a piece of BNF between the characters  and .gll/Place a piece of BNF between two single quotes.gll/Place a piece of BNF between two double quotes.45679:;<=>?@ACDOEFGHIJKLMN[\CDOEFGHIJKLMN=>?@A:;<[\456792244443444444422 Safe-InferredRu45679:;<=A@>?CNMLKJIHGFEDO[\  Safe-InferredTgll*Defines and executes multiple1 unit-tests  Safe-InferredT545679:;<=A@>?CNMLKJIHGFEDO[\  Safe-Inferredj/gllForm a rule by giving the name of the left-hand side of the new rule. Use this combinator on recursive non-terminals.gll Variant of  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.gll Variant of / that can be supplied with a list of alternatesgll Variant of / that can be supplied with a list of alternatesgllForm an  by mapping some semantic action overy the result of the second argument.gllAdd 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. gll Variant of 0 that applies longest match on the left operand.gll Variant of 1 that applies shortest match on the left operand.gllAdd an  to a list of  The resuling '[] :. AltExpr' forms the right-hand side of a rule.gllApply this combinator to an alternative to turn all underlying occurrences of % (or variants) apply 'longest match'.gllThe empty right-hand side that yields its first argument as a semantic result.gll'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.gll3Helper function for defining new combinators. Use  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.gll Variant of : that ignores the semantic result of its second argument. gll Variant of 8 that ignores the semantic result of the first argument.gll Variant of 9 that ignores the semantic result of the second argument.gll Variant of 0 that applies longest match on its left operand.gllVariant 0 that applies shortest match on its left operandgll Variant of  that prioritises productions from left-to-right (or top-to-bottom).gll Variant of  that prioritises productions from left-to-right (or top-to-bottom).gllTry to apply a parser multiple times (0 or more) with shortest match applied to each occurrence of the parser.gllTry to apply a parser multiple times (1 or more) with shortest match applied to each occurrence of the parser.gllTry to apply a parser multiple times (0 or more) with longest match applied to each occurrence of the parser.gllTry to apply a parser multiple times (1 or more) with longest match applied to each occurrence of the parser.gllTry 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.gllTry 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.gllInternalgllInternalgllSame as " but with an additional separator.gllSame as " but with an additional separator.gllSame as " but with an additional separator.gllSame as " but with an additional separator.gllSame as " but with an additional separator.gllSame as " but with an additional separator.gllLike  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.gllLike  but matching the minimum number of occurrences of the first argument as possible (at least 2).gllLike  but matching the maximum number of occurrences of the first argument as possible (at least 2).gll8Derive either from the given symbol or the empty string.gll Version of  that prefers to derive from the given symbol, affects only nullable nonterminal symbolsgll Version of  that prefers to derive the empty string from the given symbol, affects only nullable nonterminal symbolsgllPlace a piece of BNF within3 two other BNF fragments, ignoring their semantics.gll8Place a piece of BNF between the characters '(' and ')'.gll8Place a piece of BNF between the characters '{' and '}'.gll8Place a piece of BNF between the characters '[' and ']'.gll,Place a piece of BNF between the characters  and .gll/Place a piece of BNF between two single quotes.gll/Place a piece of BNF between two double quotes.45679:;<=>?@ACDOEFGHIJKLMN[\CDOEFGHIJKLMN=>?@A:;<[\4567945679:;<=A@>?CNMLKJIHGFEDO[\2244443444444422  Safe-Inferredmgll*Defines and executes multiple1 unit-tests  !"#$%&'()*+,-./0123456789:;<<=>?@!AB%CDEF,3GHIJKLMNOPQRSTUVWXYZ[P\]^_``abcc^defghijklmnopqrstuvwxyz{|}~~}                                                                                                                                                   "gll-0.4.1.0-34HYWkL893QCCWMVZLFDdBGLL.Combinators.MemoisationGLL.Combinators.Options GLL.FlagsGLL.Types.GrammarGLL.Types.Derivations GLL.ParserGLL.Parseable.CharGLL.Combinators.LexerGLL.Types.TypeComposeGLL.Combinators.InterfaceGLL.Combinators.Test.InterfaceGLL.Combinators.BinaryInterface$GLL.Combinators.Test.BinaryInterfaceGLL.Combinators.Visit.SemGLL.Combinators.Visit.GrammarGLL.Combinators.Visit.JoinGLL.GrammarCombinatorsGLL.CombinatorsMemoRef MemoTable memLookup memInsertmemClear newMemoTableCombinatorOptionCombinatorOptions PCOptionsleft_biased_choice pivot_selectpivot_select_nt throw_errorsdo_memo max_errorsnt_select_testalt_select_testseq_select_test runOptions runOptionsOndefaultOptions maximumPivot minimumPivotanyPivotmaximumPivotAtNt maximumErrors throwErrors leftBiaseduseMemoisation maximumsWith maintainWith doSelectTest noSelectTestdoAltSelectTestnoAltSelectTestdoNtSelectTestnoNtSelectTestdoSlotSelectTestnoSlotSelectTest ParseOptions ParseOptionFlags symbol_nodesintermediate_nodesedgesflexible_binarisationdo_select_test defaultFlagsfullSPPFallNodespackedNodesOnlystrictBinarisation SubsumesTokenupcastdowncast ParseableeosepsmatchesunlexTokensTokenCharKeywordEOSEpsilonIntLitFloatLitBoolLit StringLitCharLitIDLitAltIDLitSymbolsSymbolNtTermSlotGrammarProdsProd unlexTokens unlexTokenisNtisTerm $fShowSymbol $fShowSlot $fShowToken$fParseableToken$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 ParseResult sppf_result res_success res_successesnr_descriptorsnr_nterm_nodes nr_term_nodesnr_intermediate_nodesnr_packed_nodesnr_packed_node_attempts nr_sppf_edges nr_gss_nodes nr_gss_edges error_messageInputstartprodntermtermmkInputparse parseArrayparseWithOptionsparseWithOptionsArray$fShowSPPFNode $fMonadGLL $fFunctorGLL$fApplicativeGLL$fShowParseResult$fParseableChar LexerSettingskeycharskeywords whitespace lineCommentblockCommentOpenblockCommentClose identifiersaltIdentifierstokenssigned_int_lits emptyLanguage default_lexerlexer lexerEither baseToDeconeOfmanyOfsomeOfOOunOO $fArrowOO$fCategoryTYPEOO IsAltExprtoAltHasAltsaltsOf IsSymbExprtoSymbmkRuleAltExprsAltExprBNFSymbExprAssocLAssocRAssocNAFixityPrefixInfixOpTableprintParseDataprintParseDataWithOptionsevaluatorWithParseData evaluatorWithParseDataAndOptions grammarOfprintGrammarDataparseWithParseOptionsparseWithOptionsAndErrorparseWithParseOptionsAndError 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 reluctantlyoptionalWithDefwithinparensbracesbracketsanglesfoldr_multiplefoldr_multipleSepByopTableFromList fromOpTablemainbaseGHC.ShowshowGLLMutablePcalGSSRcal LhsParams string2ntGHC.Base$ AncestorsSem_AltSem_Symb sem_nterm sem_applysem_seqemptyAncestors inAncestors toAncestors Grammar_Expr grammar_nterm grammar_apply grammar_seq GHC.UnicodeisSpaceghc-prim GHC.TypesFalsemkNtRule join_applyjoin_seqIntDouble GHC.IO.UnsafeunsafePerformIOString.$. multiple_ multiple1_ GHC.Classes<>quotesdquotes