!GnZ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'() * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y None=?UVX~gllAn 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=?UVX/gllA 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)gllEnables 'longest-match' at non-terminal level. gllHSet 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.gllOWhether to use unsafe memoisation to speed up the enumeration of parse results.gllrFilter a list such that the only remaining elements are equal to the maximum element, given an ordering operator. gllFEnables select tests at all levels: nonterminal, alternative and slot.!gllGDisables 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=?UVXA (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.8gllHSet 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)(456789Safe1=?UVX[: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 notAglldThis function pretty-prints the Parseable type by displaying its lexeme. Default implementation is Z7, 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.NgllPalternative identifiers, for example functions vs. constructors (as in Haskell).Pgll A list of QsQgllA QX is either a nonterminal or a terminal, where a terminal contains some arbitrary token.TglldA 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.Xgll{A 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@?>:<;[\]^Safe1=?UVXhVvgllAn SPPFNodeI 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{|}~(~}|{vzyxwutsrqponmSafe=?UVXgllThe  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 edges[gll$Monad for implicitly passing around context\gllConnecting it all]gllPop-set^gllGSS representation_gllThe worklist and descriptor set`gll Types for gll"Representation of the input stringagll 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=?UVX:gllAssumes b and #" never appear in the input string. Safe=?UVX cdefghijkSafe=?UVX+lmnoNone=?UVXWgllClass for lifting to . gllClass for lifting to . gllClass for lifting to .gll Synonym of  for creating derived combinators. gll@A list of alternatives represents the right-hand side of a rule.gll[A combinator expression representing an alternative: the right-hand side of a production.gll^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. gll2A 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.pqrst Safe=?UVXgll9Settings 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: u.gll*How does a line comment start? Default: '"//"'.gll2How does a block comment open? Default: '"'{-'"'. gll2How does a block comment close? Default: '"'-}'"'.gllPHow to recognise identifiers? Default alphanumerical with lowercase alpha start.gll\How to recognise alternative identifiers? Default alphanumerical with uppercase alpha start.gllArbitrary tokens (a,b). a is the token name, b is a regular expression.gllFWhether integer literals may be signed positive or negative. Default: vgll 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)None=?UVXIgll'A table mapping operator keywords to a  and C 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 j 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 i. 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 . gllvForm 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 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.gll Variant of / that can be supplied with a list of alternatesgll Variant of  / that can be supplied with a list of alternatesgllForm an J 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 D The resuling '[] :. AltExpr' forms the right-hand side of a rule.gllOApply 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 w.gll/Parse a single floating point literal, using a :, type. Returns the lexeme interpreted as a x.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.gllQThe 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 y2 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 H to form a new unique non-terminal name based on the symbol of a given  and a z1 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 operand gll Variant of D that prioritises productions from left-to-right (or top-to-bottom). gll Variant of D that prioritises productions from left-to-right (or top-to-bottom). glloTry to apply a parser multiple times (0 or more) with shortest match applied to each occurrence of the parser.glloTry to apply a parser multiple times (1 or more) with shortest match applied to each occurrence of the parser.gllnTry to apply a parser multiple times (0 or more) with longest match applied to each occurrence of the parser.gllnTry 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.|gllInternal}gllInternalgllSame 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 a 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 Y that prefers to derive from the given symbol, affects only nullable nonterminal symbolsgll Version of k that prefers to derive the empty string from the given symbol, affects only nullable nonterminal symbols gllPlace 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:;<[\45679 !"#$%&('     224444344444 4 4 2 2None=?UVX45679:;<=>?@ACDOEFGHIJKLMN[\      !"#$%&'( None=?UVXB)gll*Defines and executes multiple1 unit-tests ))None=?UVX45679:;<=>?@ACDOEFGHIJKLMN[\      !"#$%&'( None=?UVXe/*gllvForm 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 *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.,gll Variant of +/ that can be supplied with a list of alternates-gll Variant of ?/ that can be supplied with a list of alternates.gllForm an J 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. 0gll Variant of /0 that applies longest match on the left operand.1gll Variant of /1 that applies shortest match on the left operand.2gllAdd an  to a list of D The resuling '[] :. AltExpr' forms the right-hand side of a rule.3gllOApply this combinator to an alternative to turn all underlying occurrences of /% (or variants) apply 'longest match'.5gllQThe empty right-hand side that yields its first argument as a semantic result.6gll'This function memoises a parser, given:A  pointing to a fresh , created using .The  to memoise.Use 6 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 .6 relies on y2 and is therefore potentially unsafe. The option 5 enables memoisation. It is off by default, even if 6$ is used in a combinator expression.7gll3Helper function for defining new combinators. Use 7H to form a new unique non-terminal name based on the symbol of a given  and a z1 that is unique to the newly defined combinator.8gll Variant of .: that ignores the semantic result of its second argument. 9gll 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 operand?gll Variant of +D that prioritises productions from left-to-right (or top-to-bottom).@gll Variant of *D that prioritises productions from left-to-right (or top-to-bottom).AglloTry to apply a parser multiple times (0 or more) with shortest match applied to each occurrence of the parser.BglloTry to apply a parser multiple times (1 or more) with shortest match applied to each occurrence of the parser.CgllnTry to apply a parser multiple times (0 or more) with longest match applied to each occurrence of the parser.DgllnTry to apply a parser multiple times (1 or more) with longest match applied to each occurrence of the parser.EgllTry 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.FgllTry 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.gllInternalgllInternalGgllSame as A" but with an additional separator.HgllSame as B" but with an additional separator.IgllSame as D" but with an additional separator.JgllSame as D" but with an additional separator.KgllSame as E" but with an additional separator.LgllSame as F" but with an additional separator.MgllLike L 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.NgllLike Ma but matching the minimum number of occurrences of the first argument as possible (at least 2).OgllLike M` but matching the maximum number of occurrences of the first argument as possible (at least 2).Pgll8Derive either from the given symbol or the empty string.Qgll Version of PY that prefers to derive from the given symbol, affects only nullable nonterminal symbolsRgll Version of Pk that prefers to derive the empty string from the given symbol, affects only nullable nonterminal symbolsTgllPlace a piece of BNF within3 two other BNF fragments, ignoring their semantics.Ugll8Place a piece of BNF between the characters '(' and ')'.Vgll8Place a piece of BNF between the characters '{' and '}'.Wgll8Place a piece of BNF between the characters '[' and ']'.Xgll,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[\%&'(*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX 5/2.*+,-CDOEFGHIJKLMN=>?@A:;<[\45679789<PQRSEFKLMTUVWX@?10;>:=34ABCDGHOIJN645679:;<=>?@ACDOEFGHIJKLMN[\%&'(*2+2.4/40414238494:4;4<4=4>4?2@2 None=?UVXnYgll*Defines and executes multiple1 unit-tests YY !"#$%&'()*+,-./0123456789:;;<=>? @A$BCDE+2FGHIJKLMNOPQRSTUVWXYZO[\]^__`abb]cdefghijklmnopqrstuvwxyz{|}~}|         !"#$%&'()* +                               ! " # $ % & +,-./012345,67 8 9 : ; < = > ? @ABCDEFG,HIJKLJKMJKN,OP,6QRSTJUVJUWXY S T X YZ#gll-0.4.0.13-FfB8fY12ZhK2J9mF9vcMlFGLL.Combinators.MemoisationGLL.Combinators.Options GLL.FlagsGLL.Types.GrammarGLL.Types.Derivations GLL.ParserGLL.Parseable.CharGLL.Combinators.InterfaceGLL.Combinators.LexerGLL.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 IsAltExprtoAltHasAltsaltsOf IsSymbExprtoSymbmkRuleAltExprsAltExprBNFSymbExpr LexerSettingskeycharskeywords whitespace lineCommentblockCommentOpenblockCommentClose identifiersaltIdentifierstokenssigned_int_lits emptyLanguage default_lexerlexer lexerEither baseToDeconeOfmanyOfsomeOfAssocLAssocRAssocNAFixityPrefixInfixOpTableprintParseDataprintParseDataWithOptionsevaluatorWithParseData 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_seqmkNtRule join_applyjoin_seq GHC.UnicodeisSpaceghc-prim GHC.TypesFalseIntDouble GHC.IO.UnsafeunsafePerformIOString.$. multiple_ multiple1_ GHC.Classes<>quotesdquotes