h$WH      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None% None3   Safe-InferredgfCreate a new cache that uses the given function to read and parse filesgfForget all cached objectsgfForget cached objects that have been unused for longer than the given timegfList currently cached filesgfLookup a cached object (or read the file if it is not in the cache or if it has been modified)gfLike 8, but also return the last modification time of the file Lennart Kolmodin, Ross PatersonBSD3-style (see LICENSE),Lennart Kolmodin  experimentalportable to Hugs and GHCNone gfA # is an efficient way to build lazy 1s. There are several functions for constructing s, but only one to inspect them: to extract any data, you have to turn them into lazy s using .Internally, a  constructs a lazy    by filling byte arrays piece by piece. As each buffer is filled, it is 'popped' off, to become a new chunk of the resulting lazy +. All this is hidden from the user of the .gfO(1). The empty Builder, satisfying   = gfO(1).+ A Builder taking a single byte, satisfying  ( b) =  bgfO(1). The concatenation of two Builders, an associative operation with identity  , satisfying  ( x y) =  ( x) ( y)gfO(1). A Builder taking a  , satisfying  ( bs) =  [bs]gfO(1). A Builder taking a lazy  , satisfying  ( bs) = bsgfO(n). Extract a lazy  from a . The construction work takes place if and when the relevant part of the lazy  is demanded.gfO(1). Pop the  we have constructed so far, if any, yielding a new chunk in the result lazy .gf#Write a Word16 in big endian formatgf&Write a Word16 in little endian formatgf#Write a Word32 in big endian formatgf&Write a Word32 in little endian formatgf#Write a Word64 in big endian formatgf&Write a Word64 in little endian formatgfO(1). A Builder taking a single native machine word. The word is written in host order, host endian form, for the machine you're on. On a 64 bit machine the Word is an 8 byte value, on a 32 bit machine, 4 bytes. Values written this way are not portable to different endian or word sized machines, without conversion.gfWrite a Word16 in native host order and host endianness. 2 bytes will be written, unaligned.gfWrite a Word32 in native host order and host endianness. 4 bytes will be written, unaligned.gfWrite a Word64 in native host order. On a 32 bit machine we write two host order Word32s, in big endian form. 8 bytes will be written, unaligned.Lennart KolmodinBSD3-style (see LICENSE),Lennart Kolmodin  experimentalportable to Hugs and GHC.None+gfThe Get monad is just a State monad carrying around the input ByteStringgfRun the Get monad applies a  %-based parser on the input ByteString gfRun the Get monad applies a  -based parser on the input ByteString. Additional to the result of get it returns the number of consumed bytes and the rest of the input. gf Skip ahead n bytes. Fails if fewer than n bytes are available. gf Skip ahead n- bytes. No error if there isn't enough bytes. gfRun ga4, but return without consuming its input. Fails if ga fails. gfLike  , but consume the input if gma returns 'Just _'. Fails if gma fails. gfLike  , but consume the input if gea returns 'Right _'. Fails if gea fails. gfGet the next up to n5 bytes as a lazy ByteString, without consuming them. gf1Get the total number of bytes read to this point. gfGet the number of remaining unparsed bytes. Useful for checking whether all input has been consumed. Note that this forces the rest of the input. gfTest whether all input has been consumed, i.e. there are no remaining unparsed bytes. gf An efficient  5 method for strict ByteStrings. Fails if fewer than n bytes are left in the input. gf An efficient  ; method for lazy ByteStrings. Does not fail if fewer than n bytes are left in the input. gfGet a lazy ByteString that is terminated with a NUL byte. Fails if it reaches the end of input without hitting a NUL. gf,Get the remaining bytes as a lazy ByteString gf importantPull n. bytes from the input, as a strict ByteString. gf!Read a Word8 from the monad state gf"Read a Word16 in big endian format gf%Read a Word16 in little endian format gf"Read a Word32 in big endian format gf%Read a Word32 in little endian format gf"Read a Word64 in big endian format gf%Read a Word64 in little endian format gfO(1). Read a single native machine word. The word is read in host order, host endian form, for the machine you're on. On a 64 bit machine the Word is an 8 byte value, on a 32 bit machine, 4 bytes. gfO(1).? Read a 2 byte Word16 in native host order and host endianness. gfO(1).8 Read a Word32 in native host order and host endianness. gfO(1).7 Read a Word64 in native host order and host endianess. Lennart KolmodinBSD3-style (see LICENSE),Lennart Kolmodin stable(Portable to Hugs and GHC. Requires MPTCsNone2 gfunstableportable to Hugs and GHC. Requires the FFI and some flexible instancesNone>?:gfThe Binary class provides   and  , methods to encode and decode a Haskell value to a lazy ByteString. It mirrors the Read and Show classes for textual representation of Haskell types, and is suitable for serialising Haskell values to disk, over the network.For parsing and generating simple external binary formats (e.g. C structures), Binary may be used, but in general is not suitable for complex protocols. Instead use the Put and Get primitives directly.:Instances of Binary should satisfy the following property: decode . encode == id That is, the   and   methods should be the inverse of each other. A range of instances are provided for basic Haskell types. gf Encode a value in the Put monad. gfDecode a value in the Get monadgf?Encode a value using binary serialisation to a lazy ByteString.gfDecode a value from a lazy ByteString, reconstructing the original structure.gf"Lazily serialise a value to a file: AR(stable) (portable) Safe-Inferred;gfLike   type with error msgsgf Analogue of  gf Analogue of  fromMaybe gf added by KJ gfadded 2/10/2003 by PEBBB(stable) (portable) Safe-Inferred? gfCreate a new empty graph. gfGet all the nodes in the graph. gfGet all the edges in the graph. gf$Map a function over the node labels. gf$Map a function over the edge labels. gfAdd a node to the graph. gf2Remove a node and all edges to and from that node. gfgfFix point iterator (for computing e.g. transitive closures or reachability)?gf#chop into separator-separated parts. !"#$%&'()*+,-./0123456789:;<=>?@AB(5)5*5,5BB(stable) (portable) Safe-InferredL- gfGraph type, graph ID, graph attirbutes, graph nodes, graph edges, subgraphs  Safe-InferredL|  Safe-InferredL NoneL (c) Sven Panne 2002-2005/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportable Safe-InferredS gfDescribes whether an option takes an argument or not, and if so how the argument is injected into a value of type a. gfno argument expected gfoption requires argument gfoptional argument gfEach   describes a single option.The arguments to   are:list of short option characters*list of long option strings (without "--")argument descriptorexplanation of option for user gf-What to do with options following non-options gf+no option processing after first non-option gf*freely intersperse options and non-options gfwrap non-options into options gfReturn a string describing the usage of a command, derived from the header (first argument) and the options described by the second argument. gfProcess the command-line, and return the list of values that matched (and those that didn't). The arguments are:The order requirements (see  )The option descriptions (see  ):The actual command line arguments (presumably got from  ).  returns a triple consisting of the option arguments, a list of non-options, and a list of error messages. gfThis is almost the same as  , but returns a quadruple consisting of the option arguments, a list of non-options, a list of unrecognized options, and a list of error messages. ! Safe-InferredSM* " Safe-InferredS #BB(stable) (portable) Safe-InferredX{ gfType parameters: node id type, state label type, edge label type Data constructor arguments: nodes and edges, start state, final states gfCreate a new finite automaton with an initial and a final state. gfGets all incoming transitions to a given state, excluding transtions from the state itself. gfGive new names to all nodes. gfInsert an NFA into another gfMake the finite automaton have a single final state by adding a new final state and adding an edge from the old final states to the new state. gfTransform a standard finite automaton with labelled edges to one where the labels are on the nodes instead. This can add up to one extra node per edge. gfRemove empty nodes which are not start or final, and have exactly one outgoing edge or exactly one incoming edge. gfStart node label gfInfinite supply of new names gfNFA to insert intogfStates to insert betweengfNFA to insert. gfLabel to give the new nodegfLabel to give the new edgesgfThe old networkgfThe new network% $ Safe-InferredY( gfREUnion [] is null gfREConcat [] is epsilon % Safe-InferredYwCD& Safe-InferredZ gfSet parallelism to a given number, or use the number of processors. Returns   if compiled with GHC<7.6 and the desired number of threads hasn't already been set with +RTS -Nn -RTS. gf/Returns the number of processors in the system. ' Safe-Inferred[0JgfSet the console encoding (for Windows, has no effect on Unix-like systems)EFIGHJKL( Safe-Inferred[_ ) Safe-Inferred\ gf=Feed some input to a shell process and read the output lazily gf shell commandgfinput to shell commandgfoutput from shell command *Bjorn Bringert (stability) (portability) Safe-Inferred_ gfRun an IO action, and allow it to be interrupted by a SIGINT to the current process. Returns an exception if the process did not complete normally. NOTES: * This will replace any existing SIGINT handler during the action. After the computation has completed the existing handler will be restored. * If the IO action is lazy (e.g. using readFile, unsafeInterleaveIO etc.) the lazy computation will not be interruptible, as it will be performed after the signal handler has been removed. gfLike  , but always returns (), whether the computation fails or not. gf"Run an action with SIGINT blocked. +Bjorn Bringert (stability) (portability) Safe-Inferred` , Safe-Inferred`, -None`N  Safe-Inferred`'   MNOPQRSTUVWXYZ[\]^_`abcde'MNOPQRSTUVWXYZ[\]^_`abcde   S5T5U6V6. Safe-Inferreda2mgfAttaching location information mnorqpstuvwx/ Safe-Inferredae  Safe-Inferreda{gf.Bind tokens separated by Prelude.BIND, i.e. &+yz{yz{0 Safe-Inferredcb|gfAn abstract data type that represents identifiers for functions and categories in PGF.~gfCreates a new identifier from  gf+Creates an identifier from a UTF-8-encoded  ByteStringgfReads an identifier from  . The function returns  ' if the string is not valid identifier.gfRenders the identifier as  | }~ 1 Safe-Inferredc gfstring constant gfinteger constant gffloating point constant&  Safe-Inferred>f gf-Haskell representation of the GF record type {s:t}gf#Overloaded function to project the s field from any record typegfTokensgf4Token sequences, output form linearization functionsgf/For enumerating parameter values used in tablesgfTablesgfRender a token sequence as a  gfCoerce from any record type  {...,s:t,...} to the supertype {s:t}gfConcatenation with variantsgf#Selection from tables with variantsgf2To be matched with the prefix of a following token52 Safe-Inferredg* 3 Safe-Inferredjwgf represents a hypothesis in a type i.e. in the type A -> B, A is the hypothesisgfTo read a type from a  , use .gfReads a  from a  .gfrenders type as  . The list of identifiers is the list of all free variables in the expression in order reverse to the order of binding.gfcreates a type from list of hypothesises, category and list of arguments for the category. The operation $mkType [h_1,...,h_n] C [e_1,...,e_m] will create "h_1 -> ... -> h_n -> C e_1 ... e_mgf0creates hypothesis for non-dependent type i.e. Agf2creates hypothesis for dependent type i.e. (x : A)gfcreates hypothesis for dependent type with implicit argument i.e. ({x} : A)|  4 Safe-Inferredr gfAn expression in the abstract syntax of the grammar. It could be both parameter of a dependent type or an abstract syntax tree for for some sentence. gfThe equation is used to define lambda function as a sequence of equations with pattern matching. The list of ) represents the patterns and the second ) is the function body for this equation. gfThe pattern is used to define equations in the abstract syntax of the grammar. gfapplication. The identifier should be constructor i.e. defined with 'data' gfliteral gfvariable gfvariable@pattern gfwildcard gfimplicit argument in pattern gflambda abstraction gf application gfliteral gf meta variable gffunction or data constructor gfvariable with de Bruijn index gflocal type signature gfimplicit argument in expressiongfTree is the abstract syntax representation of a given sentence in some concrete syntax. Technically  is a type synonym of .gfparses   as an expressiongfrenders expression as  . The list of identifiers is the list of all free variables in the expression in order reverse to the order of binding.gfConstructs an expression by applying a function to a list of expressionsgf5Decomposes an expression into application of functiongfDecomposes an expression into an application of a constructor such as a constant or a metavariablegf,Constructs an expression from string literalgf,Decomposes an expression into string literalgf-Constructs an expression from integer literalgf-Decomposes an expression into integer literalgf1Constructs an expression from real number literalgf1Decomposes an expression into real number literalgf/Constructs an expression which is meta variablegf/Checks whether an expression is a meta variable gf$Compute an expression to normal form     5 Safe-Inferredu gfThe tree is an evaluated expression in the abstract syntax of the grammar. The type is especially restricted to not allow unapplied lambda abstractions. The tree is used directly from the linearizer and is produced directly from the parser. gf6lambda abstraction. The list of variables is non-empty gfvariable gffunction application gfliteral gf meta variable gfConverts a tree to expression. The conversion is always total, every tree is a valid expression. gfConverts an expression to tree. The conversion is only partial. Variables and meta variables of function type and beta redexes are not allowed. 6 Safe-InferredxpgfThis is just a | with the language name. A language name is the identifier that you write in the top concrete or abstract module in GF after the concrete/abstract keyword. Example: 2abstract Lang = ... concrete LangEng of Lang = ... gfvalue of a flag gf5type, arrity and definition of function + probability gf context of a categoryfunctions of a category. The functions are stored in decreasing probability order. probabilitygfAn abstract data type representing multilingual grammar in Portable Grammar Format.|          7 Safe-Inferredy 8 Safe-Inferred?y 9AR(stable) (portable) Safe-Inferredz1: Safe-Inferredz\ ;None?TgfBracketedString represents a sentence that is linearized as usual but we also want to retain the ' brackets': that mark the beginning and the end of each constituent.gf$this is the leaf i.e. a single tokengfthis is a bracket. The |% is the category of the phrase. The  is an unique identifier for every phrase in the sentence. For context-free grammars i.e. without discontinuous constituents this identifier is also unique for every bracket. When there are discontinuous phrases then the identifiers are unique for every phrase but not for every bracket since the bracket represents a constituent. The different constituents could still be distinguished by using the constituent index i.e. . If the grammar is reduplicating then the constituent indices will be the same for all brackets that represents the same constituent.gfList of functions that lack linearizations in the given language.gf*Show the printname of function or categorygfRenders the bracketed string as string where the brackets are shown as (S ...) where S is the category.gf7The length of the bracketed string in number of tokens.2<NoneKgfAn abstract data structure which represents the probabilities for the different functions in a grammar.gf+Renders the probability structure as stringgfReads the probabilities from a file. This should be a text file where on every line there is a function name followed by a real number. The number represents the probability mass allocated for that function. The function name and the probability should be separated by a whitespace.gfBuilds probability tables. The second argument is a map which contains the know probabilities. If some function is not in the map then it gets assigned some probability based on the even distribution of the unallocated probability mass for the result category.gf%Returns the default even distibution.gf'compute the probability of a given treegf'rank from highest to lowest probability =None?>None?None?gf5Linearizes given expression as string in the languagegf The same as # but does not return the language.gfLinearizes given expression as string in all languages available in the grammar.gfLinearizes given expression as a bracketed string in the languagegfLinearizes given expression as a bracketed string in the languagegfCreates a table from feature name to linearization. The outher list encodes the variations@NoneAKrasimir Angelov(stable) (portable)None>ogfIf an error occurs in the typechecking phase the type checker returns not a plain text error message but a % structure which describes the error.gf Unknown category name was found.gf Unknown function name was found.gfA category was applied to wrong number of arguments. The first integer is the number of expected arguments and the second the number of given arguments. The [CId] argument is the list of free variables in the type. It should be used for the  function.gfThe expression is not of the expected type. The first type is the expected type, while the second is the inferred. The [CId] argument is the list of free variables in both the expression and the type. It should be used for the  and  functions.gfSomething that is not of function type was applied to an argument.gf6It is not possible to infer the type of an expression.gfSome metavariables have to be instantiated in order to complete the typechecking.gfhttp://www.w3.org/TR/2003/WD-semantic-interpretation-20030401/gf:Pretty-print the options that are preserved in .gfo files.gf:Pretty-print the options that are preserved in .pgf files.gfThis is for bacward compatibility. Since GHC 6.12 we started using the native Unicode support in GHC but it uses different names for the code pages.gflist of string argumentsgflist of string argumentsM (Maintainer)(stable) (portable)NonegfReport a fatal errorgf&warnings should be reversed in the endgf%Report a nonfatal (accumulated) errorgf6Turn a fatal error into a nonfatal (accumulated) errorgf*Turn accumulated errors into a fatal errorgf.Run an error check, report errors and warningsgf;Run an error check, report errors and (optionally) warningsgfAugment error messages with a relative path to the source module and an contextual hint (which can be left )NNone provisionalNone567gfPretty print atomically (i.e. wrap it in parentheses if necessary)gf!Name of param type or param valuegfLinearization value, RHS of lingfLinearization type, RHS of lincatgfConcrete SyntaxgfAbstract SyntaxgfA Complete grammarONonePAR(stable) (portable)Nonegf record labelgf0to guide computation and type checking of tablesgf%received from parser; can be anythinggf$type annontated, but can be anythinggfexpandedgf.just one wild card pattern, no need to expand gfPatternsgfconstructor pattern:  C p1 ... pn C gfpackage constructor pattern:  P.C p1 ... pn P.C gfvariable pattern: xgfwild card pattern: _gfrecord pattern:  {r = p ; ...} -- only concretegfstring literal pattern: "foo" -- only abstractgfinteger literal pattern: 12 -- only abstractgffloat literal pattern: 1.2 -- only abstractgftype-annotated patterngfas-pattern: x@pgf.placeholder for pattern for implicit argument {p}gfinaccessible patterngfnegated pattern: -pgfdisjunctive pattern: p1 | p2gfsequence of token parts: p + qgfsequence of token parts: p + qgfrepetition of token part: p*gfstring of length one: ?gfcharacter list: ["aeiou"]gfvariablegfconstantgf constructorgf basic typegfinteger literalgffloating point literalgfstring literal or token: "foo"gfthe empty string []gf application: f agf abstraction: x -> bgfmetavariable: ?i (only parsable: ? = ?0)gf"placeholder for implicit argument {t}gffunction type:  (x : A) -> B, A -> B, ({x} : A) -> Bgftype-annotated term9below this, the constructors are only for concrete syntaxgf!example-based term: @in M.C "foo"gf record type: { p : A ; ...}gf record: { p = a ; ...}gf projection: r.pgf extension:  R ** {x : A} (both types and terms)gf table type: P => Agf table: table {p => c ; ...}gf!table given as course of values: table T [c1 ; ... ; cn]gf selection: t ! pgflocal definition: let {t : T = a} in bgf!qualified constant from a packagegf$qualified constructor from a packagegfconcatenation: s ++ tgfagglutination: s + tgf"pattern (in macro definition): # pgfpattern type: pattern Tgf!boxed linearization type of Identgf!boxed linearization of type Identgf&ad hoc overloading generated in Renamegf alternatives in free variation: variants { s ; ... }gfalternatives by prefix: pre {t ; s/c ; ...}gfconditioning prefix strings: strs {s ; ...}gf%error values returned by Predef.errorgf#the constructors are judgements in abstract syntax (ABS) resource (RES)concrete syntax (CNC)and indirection to module (INDIR)gf(ABS) context of a categorygf(ABS+) type, arrity and definition of a functiongf(RES5) the second parameter is list of all possible valuesgf(RES+) to mark parameter constructors for lookupgf(RES)gf(RES) idents: modules inheritedgf(CNC) lindef ini'zed, gf(CNC) type info added at TCgf(INDIR) the  says if canonicalgfencoding the type of the modulegfModulesgf;A grammar is a self-contained collection of grammar modulesgfinitial dependency listgfall dependenciesgfselect just those modules that a given one depends on, including itselfgfall modules that a module extends, directly or indirectly, with restrictsgf the same as , plus that an instance extends its interfacegf,we store the module type with the identifiergf=don't generate code for interfaces and for incomplete modulesgf-interface and "incomplete M" are not completegf8all abstract modules sorted from least to most dependentgf4the last abstract in dependency order (head of list)gfall resource modulesgf)the greatest resource in dependency ordergf"all concretes for a given abstractgf%all concrete modules for any abstractmnopqruvwxQNone'RAR(stable) (portable)None^SKrasimir Angelov(stable) (portable)None?TAR(stable) (portable)None gfdefault linearization typegfrefreshing variablesgf!trying to preserve a given symbolgf*quick hack for refining with var in editorgf%create a terminal for concrete syntaxgf!create a terminal from identifiergf&to define compositional term functionsgf&to define compositional term functionsgf;to gather ultimate cases in a table; preserves pattern listgfto get a string from a term that represents a sequence of terminalsgf to find the word items in a termgf/normalize records and record types; put s firstgfdependency check, detecting circularities and returning topo-sorted listUAR(stable) (portable)NoneVAR(stable) (portable)NoneWAR(stable) (portable)Nonegfreturns the original " and the module where it was foundgfthis is needed at compile timegfthis is needed at compile timeXNone YNone8ZAR(stable) (portable)None{mnorpquvwx[AR(stable) (portable)NoneQ\AR(stable) (portable)None]None^None_AR(stable) (portable)None3`AR(stable) (portable)None!gfcombine a list of definitions into a balanced binary search treegfrebuilding instance + interface, and "with" modules, prior to renaming. AR 24102003aAR(stable) (portable)None?]bAR(stable) (portable)Nonegfthis gives top-level access to renaming term input in the cc commandcNonegfPredefined functionsgf%Show | Read | ToStr | MapStr | EqVal gf3Self-contained (not quite) representation of values<dNone>*eNone¹gf9Convert operators once, not every time they are looked upgfConvert a value back to a term&11fNone2gAR(stable) (portable)Nonegfpartial evaluation of concrete syntax. AR 6/2001 -- 16/5/2003 -- 5/2/2005.hNone[gfGenerate Canonical code for the named abstract syntax and all associated concrete syntaxesgf5Generate Canonical code for the named abstract syntaxgfGenerate Canonical code for the all concrete syntaxes associated with the named abstract syntax in given the grammar.gf!Smart constructor for projectionsgf Smart constructor for selectionsiNoneƦgfGenerate Haskell code for the all concrete syntaxes associated with the named abstract syntax in given the grammar.gfGenerate Haskell code for the given concrete module. The only options that make a difference are -haskell=noprefix and -haskell=variants.jAR(stable) (portable)None!gf8checking is performed in the dependency order of moduleskKrasimir AngelovstableportableNone>BgfThis function extracts the list of all completed parse trees that spans the whole input consumed so far. The trees are also limited by the category specified, which is usually the same as the startup category. lNone?gfAn abstract data type whose values represent the state in an incremental parser after an error.gfAn abstract data type whose values represent the current state in an incremental parser.gfThis data type encodes the different outcomes which you could get from the parser.gfThe integer is the position in number of tokens where the parser failed.gfThe parsing was successful but none of the trees is type correct. The forest id () points to the bracketed string from the parser where the type checking failed. More than one error is returned if there are many analizes for some phrase but they all are not type correct.gfIf the parsing and the type checking are successful we get a list of abstract syntax trees. The list should be non-empty.gf=The sentence is not complete. Only partial output is producedgfThe input to the parser is a pair of predicates. The first one  selects a token from a list of suggestions from the grammar, actually appears at the current position in the input string. The second one - recognizes whether a literal with forest id + could be matched at the current position.gfCreates an initial parsing state for a given language and startup category.gfThis function constructs the simplest possible parser input. It checks the tokens for exact matching and recognizes only String, Int and Float literals. The Int and Float> literals match only if the token passed is some number. The String literal always match but the length of the literal could be only one token.gf+From the current state and the next token  computes a new state, where the token is consumed and the current position is shifted by one. If the new token cannot be accepted then an error state is returned.gfIf the next token is not known but only its prefix (possible empty prefix) then the  function can be used to calculate the possible next words and the consequent states. This is used for word completions in the GF interpreter.gfThis function extracts the list of all completed parse trees that spans the whole input consumed so far. The trees are also limited by the category specified, which is usually the same as the startup category.gfReturn the Continuation of a Parsestate with exportable types Used by PGFServicemKA(stable) (portable)Nonergf>Renders abstract syntax tree in Graphviz format. The pair of   (funs,cats) lets you control whether function names and category names are included in the rendered tree.gfVisualize word dependency tree.gfPrepare lines obtained from a configuration file for labels for use with . Format per line fun label*.gfOutput format: "latex", "conll",  "malt_tab",  "malt_input" or "dot"gf!Include extra information (debug)gf)abstract label information obtained with gfconcrete label information obtained with ' ' (was: unused (was:  Maybe String))gfThe language of analysisgf'Rendered output in the specified formatKrasimir AngelovstableportableNonegf+A type for tries of plain applicative treesgf"A type for plain applicative treesgf4Reads file in Portable Grammar Format and produces . structure. The file is usually produced with: $ gf -make  gfLike readPGF' but you have the manage file-handling.gfTries to parse the given string in the specified language and to produce abstract syntax expression.gf The same as # but does not return the language.gfTries to parse the given string with all available languages. The returned list contains pairs of language and list of abstract syntax expressions (this is a list, since grammars can be ambiguous). Only those languages for which at least one parsing is possible are listed.gf The same as & but returns more detailed informationgf9This is an experimental function. Use it on your own riskgfThe abstract language name is the name of the top-level abstract modulegf5List of all languages available in the given grammar.gfGets the RFC 4646 language tag of the language which the given concrete syntax implements, if this is listed in the source grammar. Example language tags include "en" for English, and "en-UK" for British English.gfList of all categories defined in the given grammar. The categories are defined in the abstract syntax with the 'cat' keyword.gfThe start category is defined in the grammar with the 'startcat' flag. This is usually the sentence category but it is not necessary. Despite that there is a start category defined you can parse with any category. The start category definition is just for convenience.gf4List of all functions defined in the abstract syntaxgf2List of all functions defined for a given categorygfThe type of a given functiongf%Converts an expression to normal formgf Convert a  to an gf#Combine a list of trees into a trie|}~|~}nNonegfthe main functionoAR(stable) (portable)NonepNonegf*an abstract syntax function with argumentsgf1A lambda abstraction. The Int is the variable id.gf Applicationgf-The result of the n:th (0-based) non-terminalgfA lambda-bound variablegfA metavariablegfRemoves all directly and indirectly cyclic productions. FIXME: this may be too aggressive, only one production needs to be removed to break a given cycle. But which one should we pick? FIXME: Does not (yet) remove productions which are cyclic because of empty productions.gfBetter bottom-up filter that also removes categories which contain no finite strings.gfRemoves categories which are not reachable from any external category.gfMerges categories with identical right-hand-sides. FIXME: handle probabilitiesgf6Keeps only the start category as an external category.gf?Get the sets of mutually recursive non-terminals for a grammar.gfGets all rules in a CFG.gf9Gets all rules in a CFG, grouped by their LHS categories.gf%Gets all categories which have rules.gf7Gets all categories which have rules or occur in a RHS.gf&Gets all rules for the given category.gf/Gets all rules for categories in the given set.gf+Clean up CFG after rules have been removed.gfCombine two CFGs.gfCheck if any of the categories used on the right-hand side are in the given list of categories.gfCheck if all the rules are right-linear, or all the rules are left-linear, with respect to given categories.gf.Checks if a context-free rule is right-linear.gf-Checks if a context-free rule is left-linear.gfChecks if a symbol is a non-terminal of one of the given categories.gfIf true, all categories will be in some set. If false, only recursive categories will be included.gfThe categories to considergf%The rule to check for right-linearitygfThe categories to considergf$The rule to check for left-linearityqNonegfConcrete syntax namerNone#gf,Build a DFA by building and expanding an MFAsNonegfAn SRG non-terminal. Category name and its number in the profile.gf 9 9 ~NoneRPeter LjunglfNone?Peter LjunglfNoneNone gfthe main functiongf Module name.None+NoneL Aarne Ranta(stable) (portable)Nonegfthe main functiongf Module name.NoneNone1gfExport a PGF to the given '. For many output formats, additional # can be used to control the output.gfGet the name of the concrete syntax to generate output from. FIXME: there should be an option to change this.gf,List of recommended file names and contents.NoneTNonewNoneNoneNone!None}NoneNone Safe-InferredAR(stable) (portable)NonegfWas: ,newtype IOE a = IOE { appIOE :: IO (Err a) }gf"extends the search path with the  and 5 environment variables. Returns only existing paths.gf$Catch exceptions caused by calls to  or  in the  monad. To catch all  exceptions, use D instead.gfPrint the error message and return a default value if the IO operation sgfBecause GHC adds the confusing text "user error" for failures caused by calls to .gf:Make raise and handle mimic behaviour of the old IOE monadgf#the directory portion of a pathname%ANone$ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFHIGJKLmnorpqstuvwxstorqpmnuvwx !BA$&%"#'()*+,-./0123456789:;<=@>?ACDJKEFIGHLKrasimir Angelov(stable) (portable)None$gf*Read just the module header, the returned  will have an empty bodyNoneQAR(stable) (portable)NonegfReturns a list of all files to be compiled in topological order i.e. the low level (leaf) modules are first. getAllFiles :: (MonadIO m,ErrorMonad m) => Options -> [InitPath] -> ModEnv -> FileName -> m [FullPath]gf5options can be passed to the compiler by comments in --#, in the main file getOptionsFromFile :: (MonadIO m,ErrorMonad m) => FilePath -> m OptionsAR(stable) (portable)NonegfRead a source file and parse it (after applying preprocessors specified in the options)Krasimir Angelov(stable) (portable)None>NonegfCompile a given source file (or just load a .gfo file), given a - containing everything it depends on. Calls  or .gfRead a compiled GF module. Also undo common subexp optimization, to enable normal computations.gfCompile GF module from source. It both returns the result and stores it in a .gfo, file (or a tags file, if running with the -tags option)NonejgfCompile the given grammar files and everything they depend on, like  batchCompile. This function compiles modules in parallel. It keeps modules compiled in present and  alltenses mode apart, storing the .gfo files in separate subdirectories to avoid creating the broken PGF files that can result from mixing different modes in the same concrete syntax.The first argument controls the number of jobs to run in parallel. This works if GF was compiled with GHC>=7.6, otherwise you have to use the GHC run-time flag  +RTS -N -RTS to enable parallelism.None?None?Nonegf/Compiles a number of source files and builds a / structure for them. This is a composition of  and .gfLink a grammar into a  that can be used to  and  with the PGF run-time system.gfReturns the name of the abstract syntax corresponding to the named concrete syntaxgfCompile the given grammar files and everything they depend on. Compiled modules are stored in .gfo files (unless the -tags option is used, in which case tags files are produced instead). Existing .gfo= files are reused if they are up-to-date (unless the option -src aka  -force-recomp is used).Nonegf>Compile the given GF grammar files. The result is a number of .gfo) files and, depending on the options, a .pgf file. ( gf-batch, gf-make)gf Create a .pgf file (and possibly files in other formats, if specified in the ) from the output of . If a .pgf file by the same name already exists and it is newer than the source grammar files (as indicated by the UTCTime( argument), it is not recreated. Calls  and .gfExport the PGF to the s specified in the  . Calls .gf3Write the result of compiling a grammar (e.g. with  compileToPGF or ) to a .pgf* file. A split PGF file is output if the  -split-pgf option is used.NoneNoneNone>? #gfIf the Monad m superclass is included, then the generic instance for monad transformers below would require UndecidableInstancesgf Run normallygf Redirect  to the given handlegfCapture None jNone None>  Safe-Inferred None & Safe-Inferred ^/ Safe-Inferred 1None  Safe-Inferred gfDecode hexadecimal escapesgf(Decode application/x-www-form-urlencodedNone None  22None }gf Combined FastCGI and HTTP server1None> ~gf Run the GF Shell in quiet mode (gf-run).gfRun the interactive GF ShellgfRun the GF Server ( gf-server). The 2 argument is the port number for the HTTP service.NonegfRun the GF main program, taking arguments from the command line. (It calls setConsoleEncoding and , then .) Run  gf --help for usage info.gfGet and parse GF command line arguments. Fix relative paths. Calls  and .gfRun the GF main program with the given options and files. Depending on the options it invokes , mainGFI,  mainRunGFI,  mainServerGFI(, or it just prints version/usage info.Nonemnorpquvwxopqrmnuvwx%%''''''''. . ..........0000000044443333333334444444444444444444466666666669:::::::::;;;;;;;<<<<<<<<??????AAAAAAAAAAAAAADDDDDDDDIIIIIIIIIIIIIIIIIIIIIIIIIIILLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTThhhhhllllllllllllllllllmmmmmmmmmmmmmmmmmmmmmmmmm                                                                                                                                                                                                                           G                                                                                                                        ! ! ! ! ! ! !! ! ! ! ! ! ! ! ! !! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !! ! !!" " " "" # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ &  &         ( ( ( ( ( ( ( ( ( ( ) * * * * * * , , - - - - - / / / / /     00 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 22 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 3 444 4 4 44 44 4 4 4 4 4 4 4 4 444444444444444444444444444555555555666666666666666666666666666666666666666666666666666666666788888889::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<==>>>@AA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDDE E JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ JJ JJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNO QRRRRRRRRRRRRRRRRUUUUVVVVWWWWWWWWWWWWWWWWXXXXXXXXYYYYYYY[\\\\\\\\\\\\\\\\\\\\\\\]]^^^^ ____```aabbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccdddeeeee eeeeeeffgiijkkkkkkkklllnoooppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppqqrrrrrsssssssssssssssssssttttttuuvvwxyyyyzz{{ {{{{{{{{{{||||||||||||||||||}}}}}}}}}~~       gf-3.11-4nYtOuqtcAu6rlNC96VMj9 GF.SupportGF.Text.PrettyGF.Text.LexingPGFGF PGF.HaskellGF.Grammar.CanonicalCGICGIUtilsCacheData.Binary.BuilderL BytestringData.Binary.GetData.Binary.PutData.Binary.IEEE754 Data.BinaryGF.Compile.MultiGF.Data.BacktrackM GF.Data.ErrM GF.Data.Graph GF.Data.StrGF.Data.UtilitiesGF.Data.RelationGF.Data.OperationsGF.Data.Graphviz GF.Data.XMLGF.Infra.BuildInfoGF.Infra.ConcurrencyGF.Infra.GetOptSystem.EnvironmentgetArgsGF.JavaScript.AbsJSGF.JavaScript.PrintJSGF.Speech.FiniteStateGF.Speech.RegExpGF.System.CatchGF.System.ConcurrencyGF.System.ConsoleGF.System.DirectoryGF.System.ProcessGF.System.UseSignalGF.System.SignalGF.Text.CliticsGF.Text.CodingGF.Infra.LocationGF.Text.TransliterationsPGF.CId PGF.ByteCode PGF.TrieMapPGF.TypePGF.ExprPGF.TreePGF.Data PGF.SortTop PGF.PrinterPGF.ParaphrasePGF.Morphology PGF.MacrosPGF.Probabilistic PGF.Optimize PGF.OldBinary PGF.Linearize PGF.Binary PGF.TypeCheckText PrettyPrint PGF.Generate PGF.Utilities Data.Listnub PGF.InternalGF.Infra.Ident GF.HaskellGF.Grammar.PredefGF.Infra.OptionGF.Infra.CheckMGF.Grammar.LexerGF.Grammar.CanonicalJSONGF.Grammar.GrammarGF.Infra.DependenciesGF.Grammar.ValuesGF.Grammar.PrinterGF.Grammar.MacrosGF.Grammar.PatternMatchGF.Grammar.LockfieldGF.Grammar.LookupGF.Grammar.ShowTermGF.Grammar.Analyse GF.GrammarGF.Grammar.UnifyGF.Compile.TypeCheck.TCGF.Compile.TypeCheck.PrimitivesGF.Compile.TypeCheck.ConcreteGF.Compile.TypeCheck.AbstractGF.Compile.UpdateGF.Compile.SubExOptGF.Compile.RenameGF.Compile.Compute.ValueGF.Compile.Compute.PredefGF.Compile.Compute.Concrete GF.Compile.TypeCheck.ConcreteNewGF.Compile.OptimizeGF.Compile.GrammarToCanonicalGF.Compile.ConcreteToHaskellGF.Compile.CheckGrammar PGF.Forest PGF.ParsePGF.VisualizeTreeGF.Speech.VoiceXMLGF.QuizGF.Grammar.CFGGF.Speech.PGFToCFGGF.Speech.CFGToFA GF.Speech.SRGGF.Speech.SISRGF.Speech.SRGS_XMLGF.Speech.SRGS_ABNFGF.Speech.JSGF GF.Speech.GSL GF.Speech.SLFGF.Speech.PrRegExpGF.Grammar.EBNFGF.Grammar.BNFCGF.Grammar.ParserGF.Compile.ToAPIGF.Compile.PGFtoPythonGF.Compile.PGFtoPrologGF.Compile.PGFtoJavaGF.Compile.PGFtoJSONGF.Compile.PGFtoJSGF.Compile.PGFtoHaskellGF.Compile.GenerateBCGF.Compile.ExportGF.Compile.ExampleBasedGF.Command.TreeOperationsGF.Command.AbstractGF.Command.ParseGF.Command.CommandInfoFold ExampleDemoExampleServicePaths_gfGF.Infra.UseIOGF.Grammar.BinaryGF.Compile.TagsGF.Compile.ReadFilesGF.Compile.GetGrammarGF.Compile.GeneratePMCFG GF.CompileOneGF.CompileInParallelGF.Compile.GrammarToPGFGF.Compile.CFGtoPGF GF.Compile linearizeparse GF.CompilerGF.Command.InterpreterGF.Command.Importing GF.Infra.SIOGF.Command.SourceCommandsGF.Command.CommonCommandsGF.Command.CommandsGF.Command.MessagesGF.Command.HelpSimpleEditor.SyntaxSimpleEditor.JSONSimpleEditor.Convert URLEncodingRunHTTP PGFService GF.ServerGF.InteractiveGF.MainbaseControl.Monad.IO.ClassliftIOMonadIOpretty-1.1.3.6#Text.PrettyPrint.Annotated.HughesPJ ZigZagModePageModeLeftMode OneLineModeMode lineLengthmoderibbonsPerLineStylestyleText.PrettyPrint.HughesPJDocemptyisEmptyBinaryencodedecode encodeFile decodeFileErrOkBaderrfromErr ErrorMonadraisehandlehandle_maybeErrtestErrerrIn lookupErr mapPairsMpairM checkUnique unifyMaybe unifyMaybeByindent+++++-+++++++-+++++prUpper prReplicateprTListprQuotedString prParenthprCurly prBracket prArgList prSemicList prCurlyListrestoreEscapesnumberedParagraphs prConjList prIfEmpty wrapLinestopoTest topoTest2iterFixchunks readIntArgliftErrcheckscatchtry TermColorsredFgblueFgrestoresetConsoleEncodingchangeConsoleEncoding getTermColorsPrettyppppListrenderrender80 renderStyle$$$+$<+><>bracesbracketscat doubleQuotesfcatfsephanghcathsepnestparens punctuatequotessepvcat $fPretty[] $fPrettyChar$fPrettyDouble $fPrettyFloat$fPrettyInteger $fPrettyInt $fPrettyDocLocationNoLocLocalExternal HasSourcePath sourcePathunLocnoLoc ppLocationppLstringOpopInEnvbindTokCIdwildCIdmkCIdutf8CIdreadCIdshowCIdpIdentppCIdBindTypeExplicitImplicitExprR_sHas_sproj_sPrefixTokTKTPBIND SOFT_BIND SOFT_SPACECAPIT ALL_CAPITStrEnumAllenumAlltablefromStrto_R_s!!$!* $fHas_sR_st $fEnumAllR_s$fEqR_s$fOrdR_s $fShowR_s$fEqTok$fOrdTok $fShowTokHypoTypereadTypeshowTypemkTypemkHypo mkDepHypo mkImplHypounTypeTreereadExprshowExprmkAbsunAbsmkAppunAppunapplymkStrunStrmkIntunIntmkDoubleunDoublemkFloatunFloatmkMetaunMetapExprppMetaLanguageSeqIdFunIdSequenceLIndexFIdToken readLanguage showLanguage paraphraseMorphoAnalysisLemma buildMorpho lookupMorpho isInMorphofullFormLexicon morphoMissing morphoKnownBracketedStringLeafBracket missingLins showPrintNameshowBracketedStringflattenBracketedString ProbabilitiesshowProbabilitiesreadProbabilitiesFromFilemkProbabilitiesdefaultProbabilitiessetProbabilitiesprobTreerankTreesByProbs linearizeAlllinearizeAllLangbracketedLinearizebracketedLinearizeAlltabularLinearizesTcError UnknownCat UnknownFun WrongCatArgs TypeMismatch NotFunTypeCannotInferTypeUnresolvedMetaVarsUnexpectedImplArgUnsolvableGoal ppTcError checkType checkExpr inferExpr generateAllgenerateAllDepth generateFromgenerateFromDepthgenerateRandomgenerateRandomDepthgenerateRandomFromgenerateRandomFromDepthRawIdentIdent ModuleNameMN moduleNameS rawIdentS rawIdentC showRawIdentprefixRawIdent isPrefixOf ident2utf8 ident2raw showIdentidentS prefixIdentidentCidentVidentAidentAVidentWargIdent isArgIdent getArgIndexvarStrvarX isWildIdentvarIndexOptionsFlagsoptModeoptStopAfterPhase optVerbosityoptShowCPUTimeoptOutputFormatsoptSISRoptHaskellOptionsoptLexicalCatsoptLiteralCats optGFODir optOutputDir optGFLibPathoptDocumentRoot optRecomp optProbsFileoptRetainResourceoptNameoptPreprocessors optEncodingoptPMCFGoptOptimizationsoptOptimizePGF optSplitPGFoptCFGTransformsoptLibraryPath optStartCatoptSpeechLanguageoptLexer optUnlexer optWarningsoptDump optTagsOnlyoptHeuristicFactoroptCaseSensitive optPlusAsBindoptJobsoptTraceRecomp AlwaysRecomp RecompIfNewer NeverRecompPassSourceRebuildExtendRename TypeCheckRefreshOptimizeCanonDump HaskellOptionHaskellNoPrefix HaskellGADTHaskellLexicalHaskellConcreteHaskellVariants HaskellData HaskellPGF2 CFGTransformCFGNoLR CFGRegularCFGTopDownFilterCFGBottomUpFilterCFGStartCatOnlyCFGMergeIdenticalCFGRemoveCycles OptimizationOptStemOptCSE OptExpandOptParametrize SISRFormatSISR_WD20030401SISR_1_0 OutputFormat FmtPGFPrettyFmtCanonicalGFFmtCanonicalJson FmtJavaScriptFmtJSON FmtPython FmtHaskellFmtJava FmtPrologFmtBNFFmtEBNF FmtRegularFmtNoLR FmtSRGS_XMLFmtSRGS_XML_NonRec FmtSRGS_ABNFFmtSRGS_ABNF_NonRecFmtJSGFFmtGSL FmtVoiceXMLFmtSLF FmtRegExpFmtFAPhasePreprocConvertCompileLink VerbosityQuietNormalVerboseDebug ModeVersionModeHelpModeInteractiveModeRunModeInteractive2ModeRun2 ModeCompiler ModeServer helpMessage parseOptionsparseModuleOptionsfixRelativeLibPaths optionsGFO optionsPGFflag addOptions noOptions concatOptions modifyFlags getEncodingdefaultEncodingoutputFormatsExplrenameEncodingreadOutputFormat verbAtLeastdump cfgTransform haskellOption isLiteralCat isLexicalCatsetOptimizationsetCFGTransform RhsSeparatorrhsSepPPAppAQualIdQualUnqualId FlagValueIntFltFlagNameVarId AnonymousCatIdModIdParamId VarValueIdLabelIdPredefIdTableRow RecordRow TableRowValueRecordRowValue RecordRowTypeParam ParamValueDef ParamPattern ParamValue LinPattern RecordPattern TuplePattern WildPattern LinLiteral FloatConstant IntConstant StrConstantLinValue ConcatValue LiteralValue ErrorValue ParamConstant PredefValue RecordValue TableValue TupleValue VariantValueVarValuePreValue Projection SelectionCommentedValue ParamType ParamTypeIdLinType FloatTypeIntType RecordTypeStrType TableType TupleTypeLinDef LincatDefParamDef ParamAliasDefConcrete TypeBindingTypeAppFunDefCatDefAbstractGrammar abstrNameconcNamesemiSepblock$fPrettyFlagValue $fPrettyFlags $fPrettyVarId $fPrettyFunId $fPrettyCatId$fPrettyTypeBinding $fPrettyType$fPrettyFunDef$fPrettyCatDef $fPrettyModId$fPrettyAbstract$fPrettyLabelId$fPrettyTableRow$fPrettyParamType$fPrettyLinType$fPrettyLincatDef$fPrettyParamDef$fPrettyVarValueId$fPrettyLinDef$fPrettyConcrete$fPrettyGrammar $fPPAQualId$fPrettyQualId $fPPAParamId$fPrettyParamId $fPPAPredefId$fPrettyPredefId$fPPALinPattern$fPrettyLinPattern$fPPALinLiteral$fPrettyLinLiteral $fPPALinValue$fPrettyLinValue $fPPAParam $fPrettyParam$fPrettyTypeApp $fPPAType$fPrettyRecordRow$fRhsSeparatorLinPattern$fRhsSeparatorLinValue$fRhsSeparatorLinType $fShowGrammar$fShowConcrete $fShowLinDef $fEqLinValue $fOrdLinValue$fShowLinValue$fEqVarValueId$fOrdVarValueId$fShowVarValueId$fShowParamDef$fShowLincatDef $fEqLinType $fOrdLinType $fShowLinType $fEqParamType$fOrdParamType$fShowParamType $fEqTableRow $fOrdTableRow$fShowTableRow$fFunctorTableRow$fFoldableTableRow$fTraversableTableRow$fEqLinPattern$fOrdLinPattern$fShowLinPattern $fEqParam $fOrdParam $fShowParam$fFunctorParam$fFoldableParam$fTraversableParam $fEqParamId $fOrdParamId $fShowParamId $fEqQualId $fOrdQualId $fShowQualId $fEqPredefId $fOrdPredefId$fShowPredefId $fEqRecordRow$fOrdRecordRow$fShowRecordRow$fFunctorRecordRow$fFoldableRecordRow$fTraversableRecordRow $fEqLabelId $fOrdLabelId $fShowLabelId$fShowAbstract $fEqModId $fOrdModId $fShowModId $fShowCatDef $fShowFunDef $fShowTypeApp $fShowType$fShowTypeBinding $fEqCatId $fOrdCatId $fShowCatId $fEqFunId $fShowFunId $fShowVarId $fShowFlags$fShowFlagValue$fEqLinLiteral$fOrdLinLiteral$fShowLinLiteral SubstitutionAlternLocalDefCaseAssign LabellingEquationContextMetaIdLabelLIdentLVarTInfoTRawTTypedTCompTWildPattPCPPPVPWPRPStringPIntPFloatPTPAsPImplArgPTildePNegPAltPSeqPMSeqPRepPCharPCharsPMacroPMTermVrCnConSortEIntEFloatKEmptyAppAbsMetaImplArgProdTypedExampleRecTypeRPExtRTableTVSLetQQCCGlueEPatt EPattTypeELincatELin AdHocOverloadFVAltsStrsErrorQIdentFunCatInfoAbsCatAbsFunResParamResValueResOper ResOverloadCncCatCncFunAnyIndPMCFG Production ModuleStatus MSComplete MSIncompleteOpenSpecOSimpleOQualifMIncludeMIAllMIOnlyMIExcept ModuleType MTAbstract MTResource MTConcrete MTInterface MTInstance SourceModInfo SourceModule SourceGrammar ModuleInfoModInfomtypemstatusmflagsmextendmwithmopensmexdepsmsrcmseqsjmentsModule moduleMapmodulesextends isInherited inheritAll openedModule depPathModule allDepsModule partOfGrammar allExtendsallExtendsPlus prependModule emptyGrammarmGrammarabstractOfConcrete lookupModuleisModAbsisModResisModCnc sameMTypeisCompilableModuleisCompleteModule allAbstractsgreatestAbstract allResourcesgreatestResource allConcretesallConcreteModulesvarLabel tupleLabellinLabel theLinLabel ident2label label2ident TermPrintQualTerse Unqualified QualifiedInternalppModule ppJudgementppTermppPattppValue ppConstrsppQIdentppParamsgetAbstypeForm typeFormCncvalCatvalType valTypeCnc typeSkeleton catSkeleton funsToAndFromisRecursiveTypeisHigherOrderType contextOfTypetermForm termFormCncappForm mkProdSimplemkProdmkTermappConsmkLet mkLetUntyped isVariableuTypeassignassignTunzipRmkAssign projectRec zipAssign mapAssignM mkRecordNmkRecord mkRecTypeN mkRecType record2substtypeType typePTypetypeStrtypeToktypeStrs typeStringtypeInt typeFloattypeInts typePBool typeError isTypeIntsisPredefConstantcheckPredefErrorcnPredef mkSelectsmkTablemkCTable eqStrIdent tuple2recordtuple2recordTypetuple2recordPattmkCases mkWildCases mkFunType plusRecType plusRecord defLinType mkFreshVar mkFreshVarX maxVarIndex mkFreshVars freshAsTerm string2termint2term float2termident2terminal symbolOfIdentsymid justIdentOf linTypeStrlinAsStr term2patt patt2term composSafeOpcomposOpcomposSafePattOp composPattOp collectOp mconcatMap collectPattOp redirectTerm allCaseValues strsFromTerm getTableTypechangeTableType wordsInTermnoExistdefaultLinTypesortRecallDependenciestopoSortJmentstopoSortJments2grammar2canonicalabstract2canonicalconcretes2canonical projection selection ParseState ParseOutput ParseFailed TypeErrorParseOkParseIncomplete ParseInputpiToken piLiteral initStatesimpleParseInput mkParseInput nextStategetCompletionsrecoveryStatesgetParseOutputgetContinuationInfo CncLabelsLabelsGraphvizOptionsnoLeavesnoFunnoCatnoDepnodeFontleafFont nodeColor leafColor nodeEdgeStyle leafEdgeStylegraphvizDefaultsgraphvizAbstractTreegraphvizDependencyTree getDepLabelsgraphvizParseTreegraphvizParseTreeDepgraphvizBracketedString gizaAlignmentgraphvizAlignmentconlls2latexDocgetCncDepLabelsTrieOthApATreeOtherreadPGFparsePGFparseAll parseAllLangparse_parseWithRecoverycomplete groupResults abstractName languages languageCode categoriescategoryContextstartCat functionsfunctionsByCat functionTypecomputeexprSize exprFunctionsbrowsetoATreetoTrie $fShowTrie $fShowATree exportPGFOutputePutStr ePutStrLnputStrE putStrLnEIOEFullPathInitPathFileName putIfVerb gfLibraryPathgfGrammarPathVargetLibraryDirectorygetGrammarPath extendPathEnv getSubdirsjustModuleNameisGFisGFOgfFilegfoFilegf2gfogf2gfo'splitInModuleSearchPathtryIOEuseIOEmaybeIOdie putPointE ioErrorTexttimeIt writeUTF8FilereadBinaryFilewriteBinaryFile VersionTaggedTagged WrongVersionunV decodeModuledecodeModuleHeader encodeModulegetSourceModule getBNFCRules getEBNFRulesCompiledModule OneOutput compileOnereuseGFO useTheSourceparallelBatchCompile compileToPGFlink srcAbsName batchCompilemainGFC linkGrammars writeOutputswritePGF mainRunGFImainGFI mainServerGFImain getOptionsmainOpts%cgi-3001.5.0.0-8Hb15ctrym8K6fSeuEVDxx Network.CGI setHeader readInputgetInputrequestAcceptLanguagegetVarWithDefault outputError handleErrors outputFPSoutputNetwork.CGI.MonadrunCGITNetwork.CGI.Protocol CGIRequestcgiRequestBodycgiVars cgiInputsInputinputContentType inputValue inputFilename CGIResult CGIOutput CGINothingNetwork.CGI.Accept negotiateAccept&multipart-0.2.1-FRr2yMUX3oIJRxteV2JoHTNetwork.Multipart.Header ContentTypectType ctParameters ctSubtype HeaderNameHeaderslogError stderrToFile throwCGIErrorhandleCGIErrors outputJSONPoutputEncodedJSONP outputPNG outputBinary outputBinary' outputHTML outputPlain outputTextnewCache flushCache expireCache listCache readCache readCache'Builderbytestring-0.10.10.0Data.ByteString.Lazy.Internal ByteStringtoLazyByteStringData.ByteString.Lazy singletonappendfromByteStringData.ByteString.Internal fromChunksfromLazyByteStringflush putWord16be putWord16le putWord32be putWord32le putWord64be putWord64le putWordhost putWord16host putWord32host putWord64hostGetrunGetget runGetStateskip uncheckedSkip lookAhead lookAheadM lookAheadEuncheckedLookAhead bytesRead remaining getByteStringgetLazyByteStringgetLazyByteStringNulgetRemainingLazyByteStringgetBytesgetWord8 getWord16be getWord16le getWord32be getWord32le getWord64be getWord64le getWordhost getWord16host getWord32host getWord64hostPutPutMexecPutrunPutrunPutMputWord8 putByteStringputLazyByteStringunPut putBuilder getFloat16be getFloat16le getFloat32be getFloat32le getFloat64be getFloat64le putFloat32be putFloat32le putFloat64be putFloat64leputghc-prim GHC.TypesWordGHC.WordWord8Word16Word32Word64 bitReverse64 bitReverse32 bitReverse16 bitReverse8 byteSwap64 byteSwap32 byteSwap16 encodeFile_ decodeFile_ readMulti mtl-2.2.2Control.Monad.State.Classgetsmodify'modify MonadStatestate BacktrackMrunBMfoldBM foldSolutions solutionsfoldFinalStates finalStatesmembercut GHC.MaybeMaybe Data.Maybemaybe$fMonadPlusErr $fFunctorErrnewGraphnodesedgesnmapemapnewNode removeNode removeNodesnodeInfo mergeGraphs renameNodesNodeInfoEdgeNodeGraphnewNodesnewEdgenewEdgesinsertEdgeWith getIncoming getOutgoinginDegree outDegree getNodeLabel nodeLabeledgeFromedgeTo edgeLabel reverseGraph str2stringssstrstrstrTokplusStrglueStrsafeInitGHC.Listinit sortGroupByunionAlllookup'lookupfind' Data.FoldablefindtableSet buildMultiMap compareEqwhenMPGHC.Basemzero nothingOrNullfoldFunsfixjoinnub' Data.OldListreplace sameLength notLongerThan longerThan lookupListsplitsplitBy foldMergeselect updateNth updateNthM compareBybothapFstapSndapBothmapFstmapSndmapBothwhenMrepeatMnlspwrapconcatSunwordsSunlinesSjoinSmkRelmkRel' isRelatedTo allRelatedreflexiveClosuredomainreflexiveElementsequivalenceClassestopologicalSort Data.EitherLeftRightreflexiveClosure_ReltransitiveClosuresymmetricClosuresymmetricSubrelationreflexiveSubrelation isTransitive isReflexive isSymmetric isEquivalenceisSubRelationOf findCyclesAttr GraphTypeDirected UndirectedgTypegIdgAttrsgNodesgEdges gSubgraphs addSubGraphssetNamesetAttr prGraphvizXMLDataCDataTagETagCommentcomments showXMLDoc showsXMLDocshowsXML bottomUpXML buildInfoControl.Concurrent.ChanChanControl.Concurrent.MVar modifyMVar modifyMVar_ GHC.Conc.SyncforkIOGHC.MVarMVarFuturenowspawnparMapMnewLognewMVarreadMVarputMVar newEmptyMVarnewChangetChanContents writeChanlazyIOArgDescrNoArgReqArgOptArgOptDescrOptionArgOrder RequireOrderPermute ReturnInOrder usageInfogetOptgetOpt' PropertyName IntPropNameStringPropName IdentPropNamePropertyPropESeqEObjEArrayEThisENullEFalseETrueEStrEDblEVarECallEIndexEMemberENewEAssignEFunDeclVarDInitDVar DeclOrExprDExprDeclStmt SDeclOrExprSReturn SReturnVoid SCompoundElementElStmtProgramPrintprtprtList printTreeFAnewFA_nonLoopTransitionsTo renameStates insertNFA oneFinalStatemoveLabelsToNodesremoveTrivialEmptyNodesnewFADFANFAState startStatestates transitions addFinalStatenewState newStates newTransitionnewTransitionsinsertTransitionWithinsertTransitionsWith mapStatesmapTransitionsmodifyTransitions removeStateminimize unusedNamesnonLoopTransitionsFromloopsonGraph isInternaldfa2nfa prFAGraphviz faToGraphvizREUnionREConcatRERERepeatRESymboldfa2re epsilonREnullREisNull isEpsilonunionREconcatREseqRErepeatRE minimizeREmapREmapRE'joinRE symbolsREprREsetNumCapabilitiesFalsegetNumberOfProcessorsdirectory-1.3.6.0System.DirectorygetTemporaryDirectorygetUserDocumentsDirectorygetAppUserDataDirectorygetXdgDirectoryListgetXdgDirectorygetHomeDirectorysetModificationTime setAccessTime getAccessTimegetSymbolicLinkTargetisSymbolicLinkpathIsSymbolicLinkremoveDirectoryLinkcreateDirectoryLinkcreateFileLink doesPathExist getFileSizewithCurrentDirectorysetCurrentDirectory listDirectory exeExtension findFilesWith findFileWith findFilesfindFilefindExecutablesInDirectoriesfindExecutablesfindExecutablemakeRelativeToCurrentDirectory makeAbsolutecopyFileWithMetadatacopyFile renamePathrenameDirectoryremovePathForciblyremoveDirectoryRecursiveremoveDirectorycreateDirectorycopyPermissionssetPermissionssetOwnerSearchablesetOwnerExecutablesetOwnerWritablesetOwnerReadableemptyPermissions System.Directory.Internal.Common Permissions searchable executablereadablewritable XdgDirectoryXdgCacheXdgData XdgConfigXdgDirectoryList XdgDataDirs XdgConfigDirscanonicalizePathcreateDirectoryIfMissingdoesDirectoryExist doesFileExistgetModificationTimegetDirectoryContentsgetCurrentDirectorygetPermissions removeFile renameFilereadShellProcessrunInterruptiblyrunInterruptibly_blockInterruptmyInstallHandlermyCatchmyIgnore getCliticsgetCliticsText encodeUnicode decodeUnicodedecodeUnicodeIOioe_invalidCharacter1ioe_invalidCharacter2 transliteratetransliterateWithFiletransliterationtransliterationPrintNamescharacterTableStringNothingpCIdLStrLIntLFltTailInfoRecCallTailCall UpdateCallIValHEAPARG_VARFREE_VARGLOBALInstr CHECK_ARGSCASECASE_LITSAVEALLOC PUT_CONSTR PUT_CLOSUREPUT_LITSETSET_PAD PUSH_FRAMEPUSHTUCKEVALDROPJUMPFAIL PUSH_ACCUM POP_ACCUMADD CodeLabelLiteralppLitppCodeppInstrTrieMapnullcompose decompose insertWithunion unionWithunions unionsWithelemstoList fromListWithfromListmap mapWithKeyDTyppTypeppTypeppHypoPAppPLitPVarPWildEAbsEAppELitEMetaETypedEImplArg normalFormppParens freshNameppExprpBindspArgEnvSigValueVGenVAppVMetaVSuspVConstVLitVClosureVImplArgEqupMetapLit pattScope value2exprevalapply applyValueVarLit tree2expr expr2treeprTreeaflagsfunscatsPArgPConstPApplyPCoerceSymbol SymALL_CAPITSymCAPIT SymSOFT_SPACE SymSOFT_BINDSymNESymBINDSymKPSymKSSymVarSymCatSymLitDotPosConcrlexicon lproductions pproductionslinrefslindefs printnames totalCats sequences productionscncfunscflagscnccatsAbstrgflagsabsname concretesabstractunionPGF msgUnionPGFemptyPGFhaveSameFunsPGF fidStringfidIntfidFloatfidVarfidStart isPredefFId forExampleppPGFppCatppFunppSeqppFIdppFunIdppSeqId paraphraseNmorphoClassifymissingWordMsglengthBracketedStringCncTypeLinTable BracketedToknLeafKP LeafCAPIT LeafSOFT_BINDLeafBINDLeafNELeafKSBracket_ mapConcreteslookTypeisData lookValCat lookStartCatlookGlobalFlag lookAbsFlag lookConcrlookConcrComplete lookConcrFlagfunctionsToCathasLin restrictPGFdepthcftype typeOfHypo contextLengthlookMap combinations cidStringcidIntcidFloatcidVarppBracketedStringuntokn mkLinTable computeSeq sortNubBycompareCaseInsensitveProbsfunProbscatProbsgetProbabilities mkProbDefs optimizePGFupdateProductionIndicesversiongetPGFgetPGF' putSplitAbsSelector splitSelectorTcMunTcM MetaValueMUnboundMBoundMGuarded MetaStoreScopeTTypeTTyp emptyScope addScopedVarscopeEnv scopeSizerunTcM lookupFunTypetypeGeneratorsemptyMetaStorenewMetanewGuardedMetagetMetasetMeta lookupMetatcExprinfExpreqTypeeqValuecheckResolvedMetaStoregenerateForMetasgenerateForForestgenerateOntologygenerateOntologyDepthprovePatExpTyConApDecWildPAsPConPVarPConstLetsList LambdaCaseOpPairTApTIdListTLhsFunDepsDerivingEqnInstanceTypeSigClassconap0tsyn0lhs0tvartcon0tconletslet1singlepluspluscTypecPTypecTokcStrcStrs cPredefAbs cPredefCnccPredefcIntcFloatcStringcVarcIntscPBool cErrorType cOverloadcUndefinedType cNonExistcBIND cSOFT_BIND cSOFT_SPACEcCAPIT cALL_CAPIT isPredefCatcPTruecPFalsecLengthcDropcTakecTkcDpcToUppercToLowercIsUppercEqStrcEqValcOccurcOccurscEqIntcLessIntcPluscShowcReadcToStrcMapStrcErrorcTracecMetacAscCharcCharscSeqcAltcRepcNegcCNC cConflict checkError checkWarncheckAccumErroraccumulateError commitCheckrunCheck runCheck' checkInModuleCheck CheckResultMessage checkCond checkWarnings parallelCheckcheckMapcheckMapRecovercheckInPosnPnT_Ident T_exclmarkT_patt T_int_labelT_oparenT_cparenT_tildeT_star T_starstarT_plus T_plusplusT_commaT_minusT_rarrowT_dotT_altT_colon T_semicolonT_lessT_equal T_big_rarrowT_great T_questmarkT_obrackT_lamT_lamlamT_cbrackT_ocurlyT_barT_ccurly T_underscoreT_at T_cfarrowT_PTypeT_StrT_StrsT_TokT_Type T_abstractT_caseT_cat T_concreteT_dataT_defT_flagsT_fnT_funT_in T_incomplete T_instance T_interfaceT_letT_linT_lincatT_lindefT_linrefT_ofT_openT_operT_param T_patternT_pre T_printname T_resourceT_strsT_table T_transfer T_variantsT_whereT_with T_coercions T_terminator T_separator T_nonemptyT_String T_IntegerT_DoubleT_EOFisReservedWordrunP runPartialfailLoclexertokengetPosn encodeJSONBooldepGraph MetaSubst ConstraintsBindsValVRecTypeVCnVTypeVClos valAbsInt valAbsFloat valAbsStringvTypeeType matchPatterntestOvershadow findMatch measurePatt lockRecType unlockRecord lockLabel isLockLabellookupOrigInfolookupCatContext lookupIdent lookupResDeflookupResDefLoc lookupResTypelookupOverloadTypeslookupOverload allOrigInfoslookupParamValuesallParamValues lookupAbsDef lookupLincatallOpers allOpersToTermPrintStyleTermPrintDefault TermPrintOne TermPrintList TermPrintAllTermPrintTableshowTerm ppTermTabularstripSourceGrammarconstantDepsTerm sizeConstantsizeTerm sizesModule sizesGrammarprintSizesGrammarunifyValTheoryAExpAVrACnATypeAIntAFloatAStrAMetaALetAAppAAbsAProdARecTypeARAPAGlueADatawhnfeqValcheckExpinferExp checkBranch typPredefined primitives computeLType inferLType checkLType checkContextcheckTypcheckDef checkConstrs buildAnyTree rebuildModule extendModule subexpModuleunsubexpModulerenameSourceTerm renameModule PredefinedNonExistLessIntEqIntPlusLengthIsUpperToLowerToUpperOccursOccurEqStrDpTkTakeDropIntsPBoolPTruePFalseTraceFloatBindBindingWildVErrorVStrsVAltsVFV VPattTypeVPattVPVSVCVTVVVRecVTblTypeVSortVStringVFloatVIntVProdVAbsVCApppredef predefNamedeltaresourceValues value2term GLocation GlobalEnvgeLoc geGrammarvapply#<#optimizeModuleconcretes2haskellconcrete2haskell checkModule getAbsTreesForestabstrrootconcrforestlinearizeWithBrackets ErrorState grammar2vxmlmkQuiztranslationListmorphologyListCFObjCFAbsCFAppCFResCFVarCFMeta removeCyclesbottomUpFilter topDownFiltermergeIdenticalpurgeExternalCats mutRecCatsallRulesallRulesGroupedallCatsallCats'catRules catSetRulescleanCFGunionCFG anyUsedBy allXLinear isRightLinear isLeftLinearcatElemParamCFG ParamCFRule ParamCFSymbolCFGCFRuleCFSymbolCFTermcfgRulescfgExternalCats cfgStartCatRuleruleNameruleRhsruleLhs NonTerminalTerminalremoveLeftRecursionmakeSimpleRegular makeRegularmkCFG groupProds uniqueFuns mapCFGCatsonRules filterCFG filterCFGCats countCats countRulesprCFG prProductionsprCFTermruleFunmkCFTermruleIsNonRecursivesymbol mapSymbol filterCats filterToks noCatsInSetpgfToCFG bnfPrintercfgToFA'MFAcfgToFAcfgToMFASRGNTSRGAltsrgName srgStartCat srgLanguagemakeNonLeftRecursiveSRGmakeNonRecursiveSRG SRGSymbolSRGItemSRGRuleSRGsrgExternalCatssrgRules ebnfPrinter isExternalCat lookupFM_SISRTagprSISR topCatSISRprofileInitSISRcatSISRprofileFinalSISRsrgsXmlPrintersrgsXmlNonRecursivePrintersrgsAbnfPrintersrgsAbnfNonRecursivePrinter jsgfPrinter gslPrinter slfSubPrinterslfGraphvizPrinterslfSubGraphvizPrinter slfPrinter regexpPrintermultiRegexpPrinterERHSETermENonTermEAltEStarEPlusEOptEEmptyERuleEBNFebnf2cfBNFCRule BNFCCoercionsBNFCTerminator BNFCSeparatorlhsCatcoerCatcoerNum termNonEmptytermCattermSep sepNonEmptysepCatsepSep BNFCSymbolbnfc2cfpModDefpTopDef pModHeaderpTermpExp pBNFCRules pEBNFRulesHappyStk exprToAPI stringToAPI pgf2pythongrammar2prolog grammar2javapgf2jsonpgf2jsgrammar2haskellgenerateByteCode outputConcrparseExamplesInGrammarconfigureExBasedtreeOp allTreeOps treeChunksArgumentAMacroANoArgAExprATermVStrVIdOOptOFlagCommandPipe CommandLine valCIdOpts valIntOpts valStrOpts listFlags valueStringisOptisFlag optsAndFlagsprOptmkOpt getCommandOpreadCommandLinepCommand CommandOutputPipedCommandArgumentsStringsExprs TypeCheckArg typeCheckArg CommandInfoneedsTypeCheckexampleslongname explanationsyntaxsynopsisexecflagsoptionsmapCommandExecemptyCommandInfo fromStrings fromExprs fromStringpipeWithMessage pipeMessage pipeExprsvoid stringAsExpr toStringstoExprstoTermmkExfoldablefoldappFoldEnvirongetNextprovideExampletestThissearchGoodTreeisMeta mkFuncWithArginitial newPGFCachecgiMaincgiMain' getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameControl.Monad.FailfailIO$fErrorMonadIO writeTags gf2gftags getAllFilesgetOptionsFromFileModEnvModName gfImports gfoImportsimportsOfModule parseSource getPragmas generatePMCFGaddPMCFG pgfCncCat mkCanon2pgfcf2pgf CommandEnvcommands commandmacros expmacros mkCommandEnvinterpretCommandLine importGrammar importSourceMonadSIOrunSIOhRunSIOGHC.IO.Handle.FDstdout captureSIOliftSIOSIO restrictedrestrictedSystemputStrputStrLn putStrLnFlushprint getCPUTime newStdGenlazySIO HasGrammar getGrammarsourceCommandsextendcommonCommands stringOpsenvFlagstringOpOptionstrietoStringtoLines toParagraphs HasPGFEnv getPGFEnvPGFEnvpgfmospgfEnv pgfCommandswelcome licenseMsg codingMsg changesMsgcommandHelpAll' commandHelp' commandHelpcommandHelpTagssection optionallycompact helpCommandLinargslinfunOperorhsonameLincatlintypeprhspnamelangcodeopersopenslincatsparamslinsftypefnamestartcatbasename signature definition.=CncJmentIgnoredLiLCPa parseModule convModule convAbstract convExtends convExtend convAbsJments convAbsJmentconvTypeconvSimpleTypeconvId convModId convConcrete convOpensconvOpen convCncJments convCncJmentconvBind jmentList jmentLocationlocurlDecodeUnicode decodeQueryport documentRootrunHTTP cgiHandlerCachespgfCachelogFile flushPGFCache listPGFCachegetPath%server