!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~SafeDecode hexadecimal escapes(Decode application/x-www-form-urlencoded"Decode "+" and hexadecimal escapes   Safe// Safe  1 Safe NoneBTAn abstract data type representing multilingual grammar in Portable Grammar Format.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ None NAn data type that represents identifiers for functions and categories in PGF. .Constructs an expression by lambda abstraction 7Decomposes an expression into an abstraction and a body HConstructs an expression by applying a function to a list of expressions:Decomposes an expression into an application of a function.Constructs an expression from a string literal.Decomposes an expression into a string literal0Constructs an expression from an integer literal0Decomposes an expression into an integer literal+Constructs an expression from a real number3Decomposes an expression into a real number literal+Constructs a meta variable as an expression-Decomposes an expression into a meta variableNthis functions is only for backward compatibility with the old Haskell runtime parses a  as an expressionrenders an expression as a z. The list of identifiers is the list of all free variables in the expression in order reverse to the order of binding."Name of function Name of syntactic category       NoneO represents a hypothesis in a type i.e. in the type A -> B, A is the hypothesis parses a  as a typerenders a type as a t. The list of identifiers is the list of all free variables in the type in order reverse to the order of binding.screates a type from a list of hypothesises, a category and a 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_m eDecomposes a type into a list of hypothesises, a category and a list of arguments for the category.!renders a type as a t. The list of identifiers is the list of all free variables in the type in order reverse to the order of binding. !  !  !Krasimir AngelovstableportableNone0AT"%cBracketedString 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.&$this is the leaf i.e. a single token'-the surrounding tokens must be bound together(this 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. The second  B is the name of the abstract function that generated this phrase.The oracle is a triple of functions. The first two take a category name and a linearization field name and they should return True/False when the corresponding prediction or completion is appropriate. The third function is the oracle for literals.+RThis data type encodes the different outcomes which you could get from the parser.,The integer is the position in number of unicode characters where the parser failed. The string is the token where the parser have failed.-zIf the parsing and the type checking are successful we get a list of abstract syntax trees. The list should be non-empty..The sentence is not complete.>4Reads file in Portable Grammar Format and produces . structure. The file is usually produced with: $ gf -make <grammar file name>@/List of all languages available in the grammar.AHThe abstract language name is the name of the top-level abstract moduleCGenerates an exhaustive possibly infinite list of all abstract syntax expressions of the given type. The expressions are ordered by their probability.DHThe abstract language name is the name of the top-level abstract moduleEThe 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.FThe type of a functionGThe type of a functionH.Checks an expression against a specified type.ITries to infer the type of an expression. Note that even if the expression is type correct it is not always possible to infer its type in the GF type system. In this case the function returns an error.JLCheck whether a type is consistent with the abstract syntax of the grammar.R5Renders an abstract syntax tree in a Graphviz format.ZSReturns True if there is a linearization defined for that function in that language[4Linearizes an expression as a string in the language\6Generates all possible linearizations of an expression]5Generates a table of linearizations for an expression^5Generates a table of linearizations for an expression_KRenders the bracketed string as a string where the brackets are shown as (S ...) where S is the category.`9Extracts the sequence of tokens from the bracketed stringe4List of all functions defined in the abstract syntaxf,List of all functions defined for a categorygzList of all categories defined in the grammar. The categories are defined in the abstract syntax with the 'cat' keyword.iCallbacks for the App grammar;Named entity recognition for the App grammar (based on ..javaorggrammaticalframeworkpgf/NercLiteralCallback.java)5Callback to parse arbitrary words as chunks (from ..javaorggrammaticalframework pgf/UnknownLiteralCallback.java)["#$%&'()*+,-./0123456789:;<Name of concrete syntax=Name of abstract syntax>?@ABCDEFGHIJKLMNOPQRSTUVWX the language with which we parsethe start categorythe input sentencemthe heuristic factor. A negative value tells the parser to lookup up the default from the grammar flags a list of callbacks for literal categories. The arguments of the callback are: the index of the constituent for the literal category; the input sentence; the current offset in the sentence. If a literal has been recognized then the output should be Just (expr,probability,end_offset)Y the language with which we parsethe start categorythe input sentence the language with which we parsethe start categorythe input sentenceZ[\]^_`abcdefghijh  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghih>? =D ghefFGZ MNOPLE! HIJK<@AB[\]^ab*)%&'(_`dc+,-.WXYC/UV0123456789:;QRST#$"iI"#$%&'()*+,-./0 123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijSafeLike , but O(n log n) instead of O(n^2), since it uses a set to lookup previous things. The result list is stable (the elements are returned in the order they occur), and lazy. Requires that the list elements can be compared by Ord. Code ruthlessly taken from http://hpaste.org/544118Replace all occurences of an element by another element.SafeSafe9;<=? l-Haskell representation of the GF record type {s:t}n#Overloaded function to project the s field from any record typeqTokensy4Token sequences, output form linearization functionsz/For enumerating parameter values used in tables|Tables}Render a token sequence as a ~Coerce from any record type  {...,s:t,...} to the supertype {s:t}Concatenation with variants#Selection from tables with variantslmnop2To be matched with the prefix of a following tokenqrstuvwxyz{|}~lmnopqrtsuvwxyz{|}~z{|yqrstuvwxp}nolm~lmnopqrstuvwxyz{|}~5SafeWAn abstract data type that represents identifiers for functions and categories in PGF.Creates a new identifier from +Creates an identifier from a UTF-8-encoded  ByteStringReads an identifier from . The function returns ' if the string is not valid identifier.Renders the identifier as  SafeO represents a hypothesis in a type i.e. in the type A -> B, A is the hypothesisTo read a type from a , use .Reads a  from a .renders type as z. The list of identifiers is the list of all free variables in the expression in order reverse to the order of binding.mcreates 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_m0creates hypothesis for non-dependent type i.e. A2creates hypothesis for dependent type i.e. (x : A)Kcreates hypothesis for dependent type with implicit argument i.e. ({x} : A)          Safe string constantinteger constantfloating point constant) !"#$%&'()*+,-./ 012345& !"#$%&'()*+,-./ 012  !"#$%&'()*+,-./ 012345Safe An 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.6nThe 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.7NThe pattern is used to define equations in the abstract syntax of the grammar.8Dapplication. The identifier should be constructor i.e. defined with 'data'9literal:variable;variable@pattern<wildcard=implicit argument in pattern>lambda abstraction? application@literalA meta variableBfunction or data constructorCvariable with de Bruijn indexDlocal type signatureEimplicit argument in expressioneTree is the abstract syntax representation of a given sentence in some concrete syntax. Technically  is a type synonym of .parses  as an expressionrenders expression as z. The list of identifiers is the list of all free variables in the expression in order reverse to the order of binding.HConstructs an expression by applying a function to a list of expressions5Decomposes an expression into application of functionbDecomposes an expression into an application of a constructor such as a constant or a metavariable,Constructs an expression from string literal,Decomposes an expression into string literal-Constructs an expression from integer literal-Decomposes an expression into integer literal1Constructs an expression from real number literal1Decomposes an expression into real number literal/Constructs an expression which is meta variable/Checks whether an expression is a meta variableF$Compute an expression to normal formIGHIJKLMNOPQRSTUV6W789:;<=X>?@ABCDEYZ[\]^_`FabcdefI@B>?ACDEGHIJK/ 0LMNSOQRTPUV6W789:;<=XY\]^_Fabcd/>?@ABCDEGHIJKLMNOPQRSTUV6W789:;<=XYZ[\]^_`FabcdefSafeThis 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 = ...gvalue of a flagh5type, arrity and definition of function + probabilityi context of a categoryXfunctions of a category. The functions are stored in decreasing probability order. probabilityTAn abstract data type representing multilingual grammar in Portable Grammar Format.Cjklmnopqrstuvwxyz{|}~ghi@B>?ACDEGHIJK  / 0SOQRTPUV6W789:;<=XY\]^_Fjklmnopqrstuvwxyz{|}~higjklmnopqrst uvwxyz{|}~ ghiSafecBracketedString 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.$this is the leaf i.e. a single tokenthis 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.AList of functions that lack linearizations in the given language.*Show the printname of function or categoryIRenders the bracketed string as string where the brackets are shown as (S ...) where S is the category.7The length of the bracketed string in number of tokens.00'Safe   NoneSafehAn abstract data structure which represents the probabilities for the different functions in a grammar.+Renders the probability structure as stringReads 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.Builds 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.%Returns the default even distibution.'compute the probability of a given tree'rank from highest to lowest probability SafeSafe:5Linearizes given expression as string in the language The same as # but does not return the language.QLinearizes given expression as string in all languages available in the grammar.ALinearizes given expression as a bracketed string in the languageALinearizes given expression as a bracketed string in the language\Creates a table from feature name to linearization. The outher list encodes the variationsSafeThe 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.6lambda abstraction. The list of variables is non-emptyvariablefunction applicationliteral meta variableaConverts a tree to expression. The conversion is always total, every tree is a valid expression.Converts an expression to tree. The conversion is only partial. Variables and meta variables of function type and beta redexes are not allowed.  AR(stable) (portable)SafeConverts a pattern to tree.   Krasimir Angelov(stable) (portable)Safe9;<=OTmIf an error occurs in the typechecking phase the type checker returns not a plain text error message but a % structure which describes the error. Unknown category name was found. Unknown function name was found.A 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]P argument is the list of free variables in the type. It should be used for the  function.yThe expression is not of the expected type. The first type is the expected type, while the second is the inferred. The [CId]j argument is the list of free variables in both the expression and the type. It should be used for the  and  functions.BSomething that is not of function type was applied to an argument.6It is not possible to infer the type of an expression.QSome metavariables have to be instantiated in order to complete the typechecking.<Implicit argument was passed where the type doesn't allow it%There is a goal that cannot be solved<returns the type and the De Bruijn index of a local variable1returns the type and the name of a local variable3Renders the type checking error to a document. See !".RCheck whether a given type is consistent with the abstract syntax of the grammar..Checks an expression against a specified type.Tries to infer the type of a given expression. Note that even if the expression is type correct it is not always possible to infer its type in the GF type system. In this case the function returns the  error.M      !"#$%&'()*+,-./012345671    "$%&'-;       !"#$%&'()*+,-./01234567#SafeOGenerates an exhaustive possibly infinite list of abstract syntax expressions. A variant of X which also takes as argument the upper limit of the depth of the generated expression.EGenerates a list of abstract syntax expressions in a way similar to [ but instead of generating all instances of a given type, this function uses a template.  A variant of \ which also takes as argument the upper limit of the depth of the generated subexpressions.Generates an infinite list of random abstract syntax expressions. This is usefull for tree bank generation which after that can be used for grammar testing. A variant of X which also takes as argument the upper limit of the depth of the generated expression.#Random generation based on templateCRandom generation based on template with a limitation in the depth.89:;<=>?@A :;=89:;<=>?@A$Krasimir Angelov stable  portable Safe9BThis 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. CDEFGHIJKBLM CDFEGHIBCDEFGHIJKBLM%None:OTN`An abstract data type whose values represent the state in an incremental parser after an error.YAn abstract data type whose values represent the current state in an incremental parser.RThis data type encodes the different outcomes which you could get from the parser.HThe integer is the position in number of tokens where the parser failed.SThe 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.zIf the parsing and the type checking are successful we get a list of abstract syntax trees. The list should be non-empty.=The sentence is not complete. Only partial output is produced@The 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.LCreates an initial parsing state for a given language and startup category.{This 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 StringL literal always match but the length of the literal could be only one token.+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.UIf 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.This 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.SReturn the Continuation of a Parsestate with exportable types Used by PGFService4NOPQRSTUVWXYZ[\]^_`abcdefghijklmnoNcd!NOPQRSTUVWXYZ[\]^_`abcdefghijklmno&KA(stable) (portable)Safe>Renders abstract syntax tree in Graphviz format. The pair of p  (funs,cats)_ lets you control whether function names and category names are included in the rendered tree.Visualize word dependency tree.JPrepare lines obtained from a configuration file for labels for use with . Format per line fun label*.qRender LaTeX pictures as SVG]rstuvwxyz{|}~     Output format: "latex", "conll",  "malt_tab",  "malt_input" or "dot"!Include extra information (debug))abstract label information obtained with @concrete label information obtained with ' ' (was: unused (was:  Maybe String))The language of analysis'Rendered output in the specified formatq     Brstuvwxyz{|}~      q'Safe:(Safe"Safe !"#$%&'()*+,-./0123456789:;<& !"#$%&'()*+,-./012345 <;:9876!"#$%&'()*+,-./012345 !"#$%&'()*+,-./0123456789:;<#5$5%6&6SafeQText lexing with standard word capitalization of the first word of every sentenceFText lexing with custom treatment of the first word of every sentence..Bind tokens separated by Prelude.BIND, i.e. &+#Haskell lexer, usable for much codenormalize = change grave accent on sentence internal words to acute, and shift inherited acutes to the following enclitic (where they are visible only as shown in the list of enclitics above)de-normalize = change acute accent of end syllables in sentence internal (non-enclitic) words to grave accent, and move accents of enclitics to the previous word to produce ordinary ancient greek-Change accent on the final syllable of a word1Accent moves for enclitics and proclitics (atona)Accent manipulation Accent checking on end syllablesILaTeX lexer in the math mode: should not be separated from the next wordCLaTeX style lexer, with "math" environment using Code between $...$Capitalize first letterUncapitalize first letter,Unquote each string wrapped in double quotes5=>      !"#$%&'()*+,=>=>5=>      !"#$%&'()*+,)None-./01-./01-./01*Safe232323+Bjorn Bringert (stability) (portability)Safe4Run 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.5Like 4A, but always returns (), whether the computation fails or not.6"Run an action with SIGINT blocked.789456789456789456,Bjorn Bringert (stability) (portability)Safe46-Safe :;<=>?@ABC;DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrst:;<=>?@ABC :;<=>?@ABC.SafeDJSet the console encoding (for Windows, has no effect on Unix-like systems) ?@ABCDEuvF?@CABDEF?@ABCDEuvF/SafewoAccording to comments in cabal-install cbits/getnumprocessors.c this function is part of the RTS of GHC>=6.12.xMSet parallelism to a given number, or use the number of processors. Returns yZ if compiled with GHC<7.6 and the desired number of threads hasn't already been set with +RTS -Nn -RTS.z/Returns the number of processors in the system.wxzxzwxz0SafeGHGHGH1Safe{=Feed some input to a shell process and read the output lazily{ shell commandinput to shell commandoutput from shell command{{2Safe*|}~*|}~ |}~3Safe4SafeIAttaching location informationIJKLMNOPQRST IJKLMNOPQRST IJKLMNOPQRST5(c) Sven Panne 2002-2005/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportableSafe sDescribes whether an option takes an argument or not, and if so how the argument is injected into a value of type a.no argument expectedoption requires argumentoptional argumentEach  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-What to do with options following non-options+no option processing after first non-option*freely intersperse options and non-optionswrap non-options into optionsReturn a string describing the usage of a command, derived from the header (first argument) and the options described by the second argument.pProcess 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 67).j returns a triple consisting of the option arguments, a list of non-options, and a list of error messages.This 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. 8None 9Safe:PL(stable) (portable)SafeLike 5, but returns the empty list when the input is empty.ESorts and then groups elements given an ordering of the elements."Take the union of a list of lists.Like J, but fails if the argument is not found, instead of returning Nothing.Like  , but fails if nothing is found.Set a value in a lookup table.%Group tuples by their first elements.2Use an ordering function as an equality predicate.:Return the given value if the boolean is true, els return .2Returns true if the argument is Nothing or Just []4Apply all the functions in the list to the argument.Fixpoint iteration.DJoin a number of lists by using the given glue between the lists.Like , but O(n log n) instead of O(n^2), since it uses a set to lookup previous things. The result list is stable (the elements are returned in the order they occur), and lazy. Requires that the list elements can be compared by Ord. Code ruthlessly taken from http://hpaste.org/544118Replace all occurences of an element by another element.*     glue lists to join !"*      !"*      !";Safe#$%&'()*+,-./012 #$%*)&'(+,-.2 #$%&'()*+,-./012<AR(stable) (portable)Safe3ta variant can itself be a token list, but for simplicity only a list of strings i.e. not itself containing variants4Lnotice that having both pre and post would leave to inconsistent situations: /pre {"x" ; "y" / "a"} ++ post {"b" ; "a" / "x"}=always violates a condition expressed by the one or the other5"variants depending on next string 6Cabstract token list type. AR 2001, revised and simplified 20/4/20033475689:;<=>?@AB46;<=?@A 3475689:;<=>?@AB=BB(stable) (portable)SafeC'Keeps both incoming and outgoing edges.D0Creates a relation from a list of related pairs.EUCreates a relation from a list pairs of elements and the elements related to them.FAdd a pair to the relation.G$Add a list of pairs to the relation.H+Checks if an element is related to another.I<Get the set of elements to which a given element is related.J!Get all elements in the relation.K=Keep only pairs for which both elements are in the given set.LUses JM8Get the set of elements which are related to themselves.N7Keep the related pairs for which the predicate is true.O$Remove keys that map to no elements.P:Get the equivalence classes from an equivalence relation. QReturns R if there are cycles, and S if there are cycles.TRemoves an element from a relation. Returns the new relation, and the set of incoming and outgoing edges of the removed element.#CUDEVFGHIJWKXY+The set over which the relation is defined.LZ[\MNOP]^_`aQbcdefTgUDEHIXYLZ[\MP]^_`aQc#CUDEVFGHIJWKXYLZ[\MNOP]^_`aQbcdefTg>BB(stable) (portable)SafehKGraph type, graph ID, graph attirbutes, graph nodes, graph edges, subgraphs ijklmnophqrstuvwxyz{|}~ijklmnophqrstuvwxyz{ijklmnophqrstuvwxyz{|}~?BB(stable) (portable)Safe Create a new empty graph.Get all the nodes in the graph.Get all the edges in the graph.$Map a function over the node labels.$Map a function over the edge labels.Add a node to the graph.2Remove a node and all edges to and from that node.<Remove a set of nodes and all edges to and from those nodes.0Get a map of node names to info about each node.Add the nodes from the second graph to the first graph. The nodes in the second graph will be renamed using the name supply in the first graph. This function is more efficient when the second graph is smaller than the first.Rename the nodes in the graph. A strict ! Node labelNode graph and name of new nodeGets the node to group byrThe new graph and a function translating the old names of nodes in the second graph to names in the new graph.renaming functionOinfinite supply of fresh node names, to use when adding nodes in the future. @BB(stable) (portable)Safe Type parameters: node id type, state label type, edge label type Data constructor arguments: nodes and edges, start state, final states@Create a new finite automaton with an initial and a final state.\Gets all incoming transitions to a given state, excluding transtions from the state itself.Give new names to all nodes.Insert an NFA into anotherMake 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.Transform 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.tRemove empty nodes which are not start or final, and have exactly one outgoing edge or exactly one incoming edge.sMove edges to empty nodes to point to the next node(s). This is not done if the pointed-to node is a final node.IRemove all internal nodes with no incoming edges or no outgoing edges.EGet all the nodes reachable from a list of nodes by only empty edges.Get a map of labels to sets of all nodes reachable from a the set of nodes by one edge with the given label and then any number of empty edges..Start node labelInfinite supply of new namesNFA to insert intoStates to insert betweenNFA to insert.Label to give the new nodeLabel to give the new edgesThe old networkThe new networkA node and its incoming edges-Replacement nodes with their incoming edges.%-ASafeREUnion [] is nullREConcat [] is epsilonBAR(stable) (portable)SafeULike  type with error msgsX Analogue of Y Analogue of  fromMaybe added by KJadded 2/10/2003 by PEB UVWXYUVWXYUVWXYCAR(stable) (portable)Safe ` Add msg s to  failuresh@this is what happens when matching two values in the same moduleThomas Hallgren's wrap lines is the same as !!! peb 30/5-04*Topological sorting with test of cyclicityFTopological sorting with test of cyclicity, new version /TH 2012-06-26KFix point iterator (for computing e.g. transitive closures or reachability)#chop into separator-separated parts  return ()(if the first check fails try another one9Z[\]^_`abcdefghijklmnopqrstuvwxyz{|}~<UVWXYZ\[]^_`abcdefghijklmnopqrstuvwxyz{|}~6Z[\]^_`abcdefghijklmnopqrstuvwxyz{|}~t5u5v5x5DPL(stable) (portable)Safe9;<=OT                              ESafeFSafe             ! " # $ % & ' ( )              ! " # $ % & ' ( )GAR(stable) (portable)SafeHSafe * + , - * + , - * + , -ILennart KolmodinBSD3-style (see LICENSE),Lennart Kolmodin <kolmodin@dtek.chalmers.se> experimentalportable to Hugs and GHC.NoneB .HThe Get monad is just a State monad carrying around the input ByteString /The parse state 0Run the Get monad applies a  1%-based parser on the input ByteString 2Run the Get monad applies a  1-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. 3 Skip ahead n bytes. Fails if fewer than n bytes are available. 4 Skip ahead n- bytes. No error if there isn't enough bytes. 5Run ga4, but return without consuming its input. Fails if ga fails. 6Like  5, but consume the input if gma returns 'Just _'. Fails if gma fails. 7Like  5, but consume the input if gea returns 'Right _'. Fails if gea fails. 8Get the next up to n5 bytes as a lazy ByteString, without consuming them. 91Get the total number of bytes read to this point. :Get the number of remaining unparsed bytes. Useful for checking whether all input has been consumed. Note that this forces the rest of the input. ;VTest whether all input has been consumed, i.e. there are no remaining unparsed bytes. < An efficient  15 method for strict ByteStrings. Fails if fewer than n bytes are left in the input. = An efficient  1; method for lazy ByteStrings. Does not fail if fewer than n bytes are left in the input. >vGet a lazy ByteString that is terminated with a NUL byte. Fails if it reaches the end of input without hitting a NUL. ?,Get the remaining bytes as a lazy ByteString @ importantPull n. bytes from the input, as a strict ByteString. AlSplit a ByteString. If the first result is consumed before the -- second, this runs in constant heap space.8You must force the returned tuple for that to work, e.g. >case splitAtST n xs of (ys,zs) -> consume ys ... consume zs B important C!Read a Word8 from the monad state D"Read a Word16 in big endian format E%Read a Word16 in little endian format F"Read a Word32 in big endian format G%Read a Word32 in little endian format H"Read a Word64 in big endian format I%Read a Word64 in little endian format JO(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. KO(1).? Read a 2 byte Word16 in native host order and host endianness. LO(1).8 Read a Word32 in native host order and host endianness. MO(1).7 Read a Word64 in native host order and host endianess.0 . N O / P 1 Q R S 0 2 T 3 4 5 6 7 8 9 : ; < = > ? @ U A B V C D E F G H I J K L M W X Y Z [ \ ] . 0 2 3 4 5 6 7 8 9 : ; < = > ? @ C D E F G H I J K L M- . N O / P 1 Q R S 0 2 T 3 4 5 6 7 8 9 : ; < = > ? @ U A B V C D E F G H I J K L M W X Y Z [ \ ]JLennart Kolmodin, Ross PatersonBSD3-style (see LICENSE),Lennart Kolmodin <kolmodin@dtek.chalmers.se> experimentalportable to Hugs and GHCNoneB ^A  ^# is an efficient way to build lazy  _1s. There are several functions for constructing  ^Xs, but only one to inspect them: to extract any data, you have to turn them into lazy  _s using  `.Internally, a  ^ constructs a lazy KL 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  ^. aO(1). The empty Builder, satisfying  `  a =  b cO(1).+ A Builder taking a single byte, satisfying  ` ( c b) =  d b eO(1).L The concatenation of two Builders, an associative operation with identity  a , satisfying  ` ( e x y) =  f ( ` x) ( ` y) gO(1). A Builder taking a  h , satisfying  ` ( g bs) =  i [bs] jO(1). A Builder taking a lazy  _ , satisfying  ` ( j bs) = bs `O(n). Extract a lazy  _ from a  ^P. The construction work takes place if and when the relevant part of the lazy  _ is demanded. kO(1). Pop the  hN we have constructed so far, if any, yielding a new chunk in the result lazy  _. l&Sequence an IO operation on the buffer mGet the size of the buffer n&Map the resulting list of bytestrings. oEnsure that there are at least n many bytes available. p Ensure that n( many bytes are available, and then use f& to write some bytes into the memory. q Ensure that n( many bytes are available, and then use f0 to write some storable values into the memory. r#Write a Word16 in big endian format s&Write a Word16 in little endian format t#Write a Word32 in big endian format u&Write a Word32 in little endian format v#Write a Word64 in big endian format w&Write a Word64 in little endian format xO(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. y]Write a Word16 in native host order and host endianness. 2 bytes will be written, unaligned. z]Write a Word32 in native host order and host endianness. 4 bytes will be written, unaligned. {Write 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.$ | } ^ ~  a c e g j ` k l m n o p q r s t u v w x y z {  ^ a c e g j ` k r s t u v w x y z {! | } ^ ~  a c e g j ` k l m n o p q r s t u v w x y z { MLennart KolmodinBSD3-style (see LICENSE),Lennart Kolmodin <kolmodin@dtek.chalmers.se>stable(Portable to Hugs and GHC. Requires MPTCsNone <Put merely lifts Builder into a Writer monad, applied to (). @The PutM type. A Writer monad over the efficient Builder monoid. Run the   monad Run the   monad with a serialiser Run the  + monad with a serialiser and get its result fPop the ByteString we have constructed so far, if any, yielding a new chunk in the result ByteString. /Efficiently write a byte into the output buffer An efficient primitive to write a strict ByteString into the output buffer. It flushes the current buffer, and writes the argument into a new chunk. fWrite a lazy ByteString efficiently, simply appending the lazy ByteString chunks to the output buffer #Write a Word16 in big endian format &Write a Word16 in little endian format #Write a Word32 in big endian format &Write a Word32 in little endian format #Write a Word64 in big endian format &Write a Word64 in little endian format O(1).0 Write 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. O(1).V Write a Word16 in native host order and host endianness. For portability issues see  putWordhost. O(1).V Write a Word32 in native host order and host endianness. For portability issues see  putWordhost. O(1). Write a Word64 in native host order On a 32 bit machine we write two host order Word32s, in big endian form. For portability issues see  putWordhost.     NNoneI3 &       OLennart KolmodinBSD3-style (see LICENSE),Lennart Kolmodin <kolmodin@dtek.chalmers.se>unstableFportable to Hugs and GHC. Requires the FFI and some flexible instancesNone9:;The 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  j methods should be the inverse of each other. A range of instances are provided for basic Haskell types.  Encode a value in the Put monad. Decode a value in the Get monad?Encode a value using binary serialisation to a lazy ByteString.MDecode a value from a lazy ByteString, reconstructing the original structure."Lazily serialise a value to a file<This is just a convenience function, it's defined simply as: %encodeFile f = B.writeFile f . encode@So for example if you wanted to compress as well, you could use: !B.writeFile f . compress . encode8Lazily reconstruct a value previously written to a file.<This is just a convenience function, it's defined simply as: /decodeFile f = return . decode =<< B.readFile fBSo for example if you wanted to decompress as well, you could use: -return . decode . decompress =<< B.readFile f4             . C    2         PNone&                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4   &                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4QNone 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N 9 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M NKrasimir AngelovstableportableNone+A type for tries of plain applicative trees"A type for plain applicative trees4Reads file in Portable Grammar Format and produces . structure. The file is usually produced with: $ gf -make <grammar file name> Like readPGF' but you have the manage file-handling.eTries to parse the given string in the specified language and to produce abstract syntax expression. The same as # but does not return the language.Tries 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. The same as & but returns more detailed information9This is an experimental function. Use it on your own riskHThe abstract language name is the name of the top-level abstract module5List of all languages available in the given grammar.Gets 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.List of all categories defined in the given grammar. The categories are defined in the abstract syntax with the 'cat' keyword.The 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.4List of all functions defined in the abstract syntax2List of all functions defined for a given categoryThe type of a given function%Converts an expression to normal form Convert a  to an #Combine a list of trees into a trie          RNone% O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s O ` a b j p q r O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r sSNone t u v t u v t u vTNone w x y z { | } x y | w x y z { | }UNone ~    ~  VNone *an abstract syntax function with arguments 1A lambda abstraction. The Int is the variable id.  Application -The result of the n:th (0-based) non-terminal A lambda-bound variable A metavariable Removes 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. VBetter bottom-up filter that also removes categories which contain no finite strings. FRemoves categories which are not reachable from any external category. OMerges categories with identical right-hand-sides. FIXME: handle probabilities 6Keeps only the start category as an external category. ?Get the sets of mutually recursive non-terminals for a grammar. Gets all rules in a CFG. 9Gets all rules in a CFG, grouped by their LHS categories. %Gets all categories which have rules. 7Gets all categories which have rules or occur in a RHS. &Gets all rules for the given category. /Gets all rules for categories in the given set. +Clean up CFG after rules have been removed. Combine two CFGs. bCheck if any of the categories used on the right-hand side are in the given list of categories. oCheck if all the rules are right-linear, or all the rules are left-linear, with respect to given categories. .Checks if a context-free rule is right-linear. -Checks if a context-free rule is left-linear. DChecks if a symbol is a non-terminal of one of the given categories.F eIf true, all categories will be in some set. If false, only recursive categories will be included. The categories to consider%The rule to check for right-linearity The categories to consider$The rule to check for left-linearity F 6     W Gleb Lobanov (experimental) (portable)None    XAR(stable) (portable)None                    YAR(stable) (portable)None Ncompare answer to the list of right answers, increase score and give feedback           ZunstableNone<   @B>?ACDEGHIJK   !"#$%&'()*+,-./ 012SOQRTPUV6W789:;<=XY\]^_Fjklmnopqrstuvwxyz{|}~hig . 0 2 3 4 5 6 7 8 9 : ; < = > ? @ C D E F G H I J K L M    9[None                             \Peter LjunglfNone& ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E &#  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E]Peter LjunglfNone: F G H I J K L M N O P Q R S T F F G H I J K L M N O P Q R S T^None U V W X Y Z [ \ ] ^ _ ` a b c d Y Z U V W X Y Z [ \ ] ^ _ ` a b c d_AR(stable) (portable)None bIdentifiers are stored as UTF-8-encoded bytestrings. (It is also possible to use regular Haskell @s, with somewhat reduced performance and increased memory use.)the constructors labelled INTERNAL: are internal representation never returned by the parser e0raw identifier after parsing, resolved in Rename fwildcardLbelow this constructor: internal representation never returned by the parser gINTERNAL variable hINTERNAL argument of cat at position iINTERNAL* argument of cat with bindings at position Module namesXThis function should be used with care, since the returned ByteString is UTF-8-encoded.to mark argument variablesused in lin defaultsrefreshing variables) j k e f g h i l m n o p q r! j k e f g h i l m n o p q r`NoneB s t u v w x y z { | } ~    Y 2 s t u v w x y z { | } ~       N   a kr.angelov(stable) (portable)None9                        ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; <9                        ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; <9                        ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; <bNone2 =BPretty print atomically (i.e. wrap it in parentheses if necessary) >Patterns ? Expressions @Type expressions A,A type constructor applied to some arguments BTop-level declarations6 = C > D E F G H I ? J K L M N O P Q @ R S T U V W X A Y B Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r- = C > E G H D F I ? J O K Q N L M P @ U T R S V W X A Y B ] [ \ Z ^ _ ` a b c d e f g h i = C > D E F G H I ? J K L M N O P Q @ R S T U V W X A Y B Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q rcNone#SISR Working draft 1 April 2003 >http://www.w3.org/TR/2003/WD-semantic-interpretation-20030401/J:Pretty-print the options that are preserved in .gfo files.K:Pretty-print the options that are preserved in .pgf files. sOption descriptionsTThis 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. t u v      !"#$%&'()*+,-./0123456789:;<=>?@ABCDE wF xGlist of string argumentsHlist of string argumentsIJKLMNOPQR y s zS { | }T ~  U VWXYZ[\ ]       !"#$%&'()*+,-./012356478<9:;=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]= t& u v      !"#$%&'()*+,-./0123456789:;<=>?@ABCDE wF xGHIJKLMNOPQR y s zS { | }T ~  U VWXYZ[\ ] d Aarne Ranta(stable) (portable)None the main function -Gets the element category of a list category.  Module name.   eNone the main function  Module name.   fAR(stable) (portable)None[i record labell0to guide computation and type checking of tablesm%received from parser; can be anythingn$type annontated, but can be anythingoexpandedp.just one wild card pattern, no need to expand <Measured pattern (paired with the min & max matching length)qPatternsrconstructor pattern:  C p1 ... pn C spackage constructor pattern:  P.C p1 ... pn P.C tvariable pattern: xuwild card pattern: _vrecord pattern:  {r = p ; ...} -- only concretewstring literal pattern: "foo" -- only abstractxinteger literal pattern: 12 -- only abstractyfloat literal pattern: 1.2 -- only abstractztype-annotated pattern{as-pattern: x@p|.placeholder for pattern for implicit argument {p}}inaccessible pattern~negated pattern: -pdisjunctive pattern: p1 | p2sequence of token parts: p + qsequence of token parts: p + qrepetition of token part: p*string of length one: ?character list: ["aeiou"]variableconstant constructor basic typeinteger literalfloating point literalstring literal or token: "foo"the empty string [] application: f a abstraction: x -> bmetavariable: ?i (only parsable: ? = ?0)"placeholder for implicit argument {t}function type:  (x : A) -> B, A -> B, ({x} : A) -> Btype-annotated term9below this, the constructors are only for concrete syntax!example-based term: @in M.C "foo" record type: { p : A ; ...} record: { p = a ; ...} projection: r.p extension:  R ** {x : A} (both types and terms) table type: P => A table: table {p => c ; ...}!table given as course of values: table T [c1 ; ... ; cn] selection: t ! plocal definition: let {t : T = a} in b!qualified constant from a package$qualified constructor from a packageconcatenation: s ++ tagglutination: s + t"pattern (in macro definition): # ppattern type: pattern T!boxed linearization type of Ident!boxed linearization of type Ident&ad hoc overloading generated in Rename alternatives in free variation: variants { s ; ... }alternatives by prefix: pre {t ; s/c ; ...}conditioning prefix strings: strs {s ; ...}%error values returned by Predef.error#the constructors are judgements in abstract syntax (ABS) resource (RES)concrete syntax (CNC)and indirection to module (INDIR)(ABS) context of a category(ABS+) type, arrity and definition of a function(RES5) the second parameter is list of all possible values(RES+) to mark parameter constructors for lookup(RES)(RES) idents: modules inherited(CNC) lindef ini'zed, (CNC) type info added at TC(INDIR) the p says if canonicalencoding the type of the moduleModules;A grammar is a self-contained collection of grammar modulesinitial dependency listall dependenciesGselect just those modules that a given one depends on, including itselfIall modules that a module extends, directly or indirectly, with restricts the same as , plus that an instance extends its interface,we store the module type with the identifier=don't generate code for interfaces and for incomplete modules-interface and "incomplete M" are not complete8all abstract modules sorted from least to most dependent4the last abstract in dependency order (head of list)all resource modules)the greatest resource in dependency order"all concretes for a given abstract%all concrete modules for any abstract^_`abcdefghijklmnop qrstuvwxyz{|}~  IJKLMNQRST^_`abcdefghijklmnopqs{|}rtuvwxyz~B^_`abcdefghijklmnop qrstuvwxyz{|}~%    gNone       hNone Predefined functions %Show | Read | ToStr | MapStr | EqVal 3Self-contained (not quite) representation of values=       <                iNone9;                              jAR(stable) (portable)None      ! " # $ % & ' ( ) *       ! # " $ % & ' ( ) *      ! " # $ % & ' ( ) *kNone + , - . / 0 1 2 3 4 5 6 7 8 5 + , - . / 0 1 2 3 4 5 6 7 8lKrasimir Angelov  (stable)  (portable) None:% 9 : ;   < = > ? @ A B C D E F G H I J K L M N O     ! 9 : ;   < = > ? @ A B C D E F G H I J K L M N OmAR(stable) (portable)None Pdefault linearization typeQrefreshing variablesR!trying to preserve a given symbolU*quick hack for refining with var in editorV%create a terminal for concrete syntaxY!create a terminal from identifiera&to define compositional term functionsb&to define compositional term functionsi;to gather ultimate cases in a table; preserves pattern listjCto get a string from a term that represents a sequence of terminalskVto print an Str-denoting term as a string; if the term is of wrong type, the error msgn to find the word items in a termrHdependency check, detecting circularities and returning topo-sorted liste !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrste !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrste !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstnNone! P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p! P Q R U S T V W X Y _ ` Z [ \ ] ^ a b c d e f g h i j k l m n o p P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o poNone q r s t u v w x q r s t u v w x q r s t u v w xpAR(stable) (portable)NoneVIJKLMNQRST ^_`abcdefghijklmnopqs{|}rtuvwxyz~      ! # " $ % & ' ( ) *      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstqNone y z y z y zrAR(stable) (portable)None% { | } ~   |   { | } ~  sAR(stable) (portable)None   tAR(stable) (portable)None   uAR(stable) (portable)None returns the original " and the module where it was found this is needed at compile time this is needed at compile time   vNone   wAR(stable) (portable)None:   xNone   yAR(stable) (portable)None CEstimate the minimal length of the string that a pattern will match CEstimate the maximal length of the string that a pattern will match   zNone 9Convert operators once, not every time they are looked up ?Insert a call to the trace function under the top-level lambdas 'Computing the value of a top-level term Computing the value of a term Dto get a string from a value that represents a sequence of terminals Convert a value back to a termC         !"#$%&'()*+,-./ 0123456789:&         + <         !"#$%&'()*+,-./ 0123456789:5161{None;tGenerate Haskell code for the all concrete syntaxes associated with the named abstract syntax in given the grammar.<cGenerate Haskell code for the given concrete module. The only options that make a difference are -haskell=noprefix and -haskell=variants.;<=>?@ABCDEFGHIJKLMNOPQRS;<;<=>?@ABCDEFGHIJKLMNOPQRS|AR(stable) (portable)NoneTJpartial evaluation of concrete syntax. AR 6/2001 -- 16/5/2003 -- 5/2/2005.U.the main function for compiling linearizationsV&auxiliaries for compiling the resource TWUXVYZ[\T TWUXVYZ[\}None]^_`abcd]^_`abcd]^_`abcd~ (Maintainer)(stable) (portable)NoneeReport a fatal errorf&warnings should be reversed in the endg%Report a nonfatal (accumulated) errorh6Turn a fatal error into a nonfatal (accumulated) errori*Turn accumulated errors into a fatal errorj.Run an error check, report errors and warningsk;Run an error check, report errors and (optionally) warningsllAugment error messages with a relative path to the source module and an contextual hint (which can be left )mnopqrstuvwxeyfzghijk{|}~lmpweyfzghijk{|}~lmnopqrstuvwxeyfzghijk{|}~lAR(stable) (portable)NoneDthis gives top-level access to renaming term input in the cc commandAvars not needed in env, since patterns always overshadow old varsAR(stable) (portable)None,invariant way of creating TCEnv from context  None ]Invariant: if the third argument is (Just rho), then rho is in weak-prenex form5Invariant: the second argument is in weak-prenex form*Invariant: tv1 is a flexible type variable=Instantiate the topmost implicit arguments with metavariablesBBuild fresh lambda abstractions for the topmost implicit arguments9Quantify over the specified type variables (all flexible)iThis function takes account of zonking, and returns a set (no duplicates) of unbound meta-type variablesaThis function takes account of zonking, and returns a set (no duplicates) of free type variables%Eliminate any substitutions in a termG?None(light-weight substitution for dep. types.compositional check/infer of binary operations  AR(stable) (portable)None8checking is performed in the dependency order of moduleslGeneral Principle: only Just-values are checked. A May-value has always been checked in its origin module.=for grammars obtained otherwise than by parsing ---- update!! linearization types and defaultsAR(stable) (portable)None@combine a list of definitions into a balanced binary search treeOrebuilding instance + interface, and "with" modules, prior to renaming. AR 24102003When extending a complete module: new information is inserted, and the process is interrupted if unification fails. If the extended module is incomplete, its judgements are just copied.@this is what happens when matching two values in the same module  None9;Bc      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~             !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     9 9 None  AR(stable) (portable)NonezWas: ,newtype IOE a = IOE { appIOE :: IO (Err a) }"extends the search path with the  and 5 environment variables. Returns only existing paths.$Catch exceptions caused by calls to [ or  in the  monad. To catch all  exceptions, use H instead.GPrint the error message and return a default value if the IO operation sRBecause GHC adds the confusing text "user error" for failures caused by calls to .:Make raise and handle mimic behaviour of the old IOE monad%uvwxyz{|#the directory portion of a pathname}~%uyxvwz{|}~!uvwxyz{|}~None8macro definition applications: replace ?i by (exps !! i) return the trees to be sent in pipe, and the output possibly printed interpret :: CommandEnv -> [Expr] -> Command -> SIO CommandOutput!Lanalyse command parse tree to a uniform datastructure, normalizing comm name"#$%&'() !*+, "#$%&'( "#$%&'() !*+,None:-./0--./0Krasimir Angelov(stable) (portable)None9;<=OT1The ProtoFCat represents a linearization type as term schema. The annotations are as follows: the strings are annotated with their index in the PMCFG tuple, the parameters are annotated with their value both as term and as index.2Path into a term or term schema3 Term schema4backtracking for all variants5@backtracking for all parameter values that a variable could take6[the argument should be a parameter type and then the function returns all possible values.G789:;<=1>2?@A3BCDEFGHIJKLMNOPQRS456TUVWXYZ[\]^_`abcdefghijklmnopqrstuvw MOR9789:;<=1>2?@A3BCDEFGHIJKLMNOPQRS456TUVWXYZ[\]^_`abcdefghijklmnopqrstuvwNone:xyz{|}~xxyz{|}~NoneKrasimir Angelov  (stable)  (portable) None*Read just the module header, the returned  will have an empty bodylike : but adds file name to error message if there was an errorgAdds file name to error message if there was an error, | but laziness can cause errors to slip through AR(stable) (portable)NoneReturns 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]5options can be passed to the compiler by comments in --#Z, in the main file getOptionsFromFile :: (MonadIO m,ErrorMonad m) => FilePath -> m OptionsAR(stable) (portable)NoneWRead a source file and parse it (after applying preprocessors specified in the options) NoneACompile a given source file (or just load a .gfo file), given a - containing everything it depends on. Calls  or .`Read a compiled GF module. Also undo common subexp optimization, to enable normal computations.NCompile 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)  NoneThe environment/Compiles a number of source files and builds a / structure for them. This is a composition of  and .Link a grammar into a  that can be used to  and  with the PGF run-time system.RReturns the name of the abstract syntax corresponding to the named concrete syntax_Compile the given grammar files and everything they depend on. Compiled modules are stored in .gfo files (unless the -tagsL 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).compile with one module as starting point command-line options override options (marked by --#) in the file As for path: if it is read from file, the file path is prepended to each name. If from command line, it is used as it is. 4Options from program command line and shell command. NoneNoneECompile the given grammar files and everything they depend on, like  batchCompileL. 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.None9:;If the Monad m superclass is included, then the generic instance for monad transformers below would require UndecidableInstances Run normally Redirect  to the given handleCapture "             None9; !" ` _  !"None #$%&'()*+ #$%&'()*+ #$%&'()*+None,-./,-.,-./None9:;T 0 Run the GF Shell in quiet mode (gf-run).1Run the interactive GF Shell22Read end execute commands until it is time to quit3(Read and execute one command, returning 4 to continue execution, | y when it is time to quit5Read a command6>Optionally show how much CPU time was used to run an IO action7(Execute a given command line, returning 4 to continue execution, | y when it is time to quit8>Execute a given command line, without adding it to the history9Commands that work on :';<=>?:@ABCDE0F1G235H678IJ9KLMNOPQRSTUVW01;<=>?:@ABCDE0F1G235H678IJ9KLMNOPQRSTUVWNone?@CABDEFGHIJKLMNOPQRSTUVWXYZ\[]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./012356478<9:;=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]uyxvwz{|}~ OPKLMNIJQRST=>?@ABCDE3456789:;< !"#$%&'()*+,-./012     SGHIJKMONPFLXYU[ZTQR\]VWUVWX`aYbcZ[\]gihdef^jklmnoqprstuvwxyz{|}~_~}|{zuvwxyGHDE?@ABCFNoneXThe make_fa algorithm from "Regular approximation of CFLs: a grammatical view", Mark-Jan Nederhof, Advances in Probabilistic and other Parsing Technologies, 2000.Y,Build a DFA by building and expanding an MFAZ Sort sub-networks topologically.[Convert a strongly regular grammar to a number of finite automata, one for each non-terminal. The edges in the automata accept tokens, or name another automaton to use.\=The make_fa algorithm from "Regular approximation of CFLs: a grammatical view", Mark-Jan Nederhof, Advances in Probabilistic and other Parsing Technologies, 2000, adapted to build a finite automaton for a single (mutually recursive) set only. Categories not in the set will result in category-labelled edges.]Add a state for the given NFA for each of the categories in the given set. Returns a map of categories to their corresponding states.^_`abcdefghijklXmYnopqrsZ[*A map of non-terminals and their automata.\VThe set of (mutually recursive) categories for which we are building the automaton.State to come fromSymbols to acceptState to end up in FA to add to.t]u ^_kmY^_`abcdefghijklXmYnopqrsZ[\t]uNonevwxyConcrete syntax namewyvwxyNonez{|}z{z{|}None:~+An SLF word is a word, or the empty string.&Make a network with subnetworks in SLF@Check if a word should not correspond to a word in the SLF file.'~~NoneAAn SRG non-terminal. Category name and its number in the profile.<maybe a probability, a rule name and an EBNF right-hand side grammar namestart category name>The language for which the grammar is intended, e.g. en-UK2Create a compact filtered non-left-recursive SRG. zRenames all external cats C to C_cat, and all internal cats C_X (where X is any string), to C_N where N is an integer.VMerges a list of right-hand sides which all have the same sequence of non-terminals.Concrete syntax name. None  None NoneBB(stable) (portable)NoneNone rootlanguage None the main function      !"#$       !"#$NoneExport a PGF to the given '. For many output formats, additional # can be used to control the output.%nGet the name of the concrete syntax to generate output from. FIXME: there should be an option to change this.,List of recommended file names and contents.%%%None9;&/the maximal number of precompiled quiz problems'()*+,-./012&3456789:; ` _'(),+-.'()*+,-./012&3456789:;None>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) Create a .pgfA file (and possibly files in other formats, if specified in the ) from the output of . If a .pgfj 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 .Export the PGF to the s specified in the  . Calls .3Write 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. <=>?@ABCD <=>?@ABCDNoneEFGHIJKLMNOPQRSTUVWXYZ[\]^EHFGIJKLMNOPQRSTUVWXYZ[\]^EFGHIJKLMNOPQRSTUVWXYZ[\]^Safe_GCreate a new cache that uses the given function to read and parse files`Forget all cached objectsaJForget cached objects that have been unused for longer than the given timebList currently cached filesc_Lookup a cached object (or read the file if it is not in the cache or if it has been modified)dLike c8, but also return the last modification time of the file efghi_`abjcdf_`abcd efghi_`abjcdNone'klmnopqrstuvwxyz{|}~None0 NoneNone Convert a Tree to an ATreeStandard lexers8Unlexing for the C runtime system, &+ is already applied,Render trees as JSON with numbered functions%tabulate all variants and their forms^      W      22NoneNone Handler monad Combined FastCGI and HTTP server HTTP request handler!6Check that a path is not outside the current directory"'Only delete files with these extensions#;Remove a directory and the files in it, but not recursively4$%&'()*+,- ./0123456789:;<=>?@ABCDEFGHI!"J#KLMNOPQ4$%&'()*+,- ./0123456789:;<=>?@ABCDEFGHI!"J#KLMNOPQP1None9;T  Run the GF Shell in quiet mode (gf-run).Run the interactive GF ShellRun the GF Server ( gf-server). The R2 argument is the port number for the HTTP service.S2Read end execute commands until it is time to quitT(Read and execute one command, returning 4 to continue execution, | y when it is time to quitURead a commandV>Optionally show how much CPU time was used to run an IO actionW(Execute a given command line, returning 4 to continue execution, | y when it is time to quitX>Execute a given command line, without adding it to the history(Execute a given command line, returning 4 to continue execution, | y when it is time to quitYCommands that work on Z+[\]^_Z`abcdefghiSTUjVWXklYmnopqrstuvwxyz![\]^_Z`abcdefghiSTUjVWXklYmnopqrstuvwxyzNoneLRun the GF main program, taking arguments from the command line. (It calls D and , then .) Run  gf --help for usage info.DGet and parse GF command line arguments. Fix relative paths. Calls { and G._Run 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.NonedIJKLMNQRST^_`abcdefghijklmnopqs{|}rtuvwxyz~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstgqrstuvwxyz{|}~lmnopijkhgfedcba`_^KLMNIJQRST !"#$%&'()*+,-./0123456789;:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrst     |                !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^ _`a b c d e f g h i j k l ##m#n#o#p#q#r#s%t%%%u%%%v%v%w%x%y%z%{%|%}%~%%&&&&&&&&&&&&&&&&&&&&&&&&&........004K4K4444444444BBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCC-CCCCCCCCCCCCCCCCCCCCCCCCCCCCOOOOO     ________________ _!_"_#_$_%_&_'_(_)_*_+c,c-c-c.c/c0c1c2c3c4c5c6c7c8c9c:c;c<c=c>c?c@cAcBcCcDcEcFcGcHcIcJcKcLcMcNcOcPcQcRcScTcUcVcWcXcYcZc[c\c]c^c_c`c`cacbcccdcecfcgchcicjckclcmcncocpcqcrcsctcucvcwcxcyczc{c|c}c~ccccccccccccccccccccccccccccccccccccccccccccccccccccccccffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff f f f f fffffffffffffffffffff f!f"f#f$f%f&f'f(f)f*f+f,f-f.f/f0f1f2f3f4f5f6f7f8f9f:f;f<f=f>f?f@fAfBfCfDfEfFfGfHfIfJfKfLfMfNfOfPfQfRfSlTlUlVlWlXlYlZl[l\l]l^l_l`lambmcmdmemfmgmhmimjmkmlmmmnmompmqmrmmmsmtmumvmwmxmymzm{m|m}m~mmmmmmmmmmmmmmmmmmmmmmmm?mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm                                  ! " # # $ % & 1 1 ' 4 ( )  I  * + , - . / 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 Z [ \ ] ^ _ ` 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 z  { | } ~                                                                                                                                         9        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~\&%    ()hgdPB                        ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B     C D E F G H I#J#J#K#L#M#N#O#P#Q#R$S$T$T$U$y$V$W$X$Y$Z$[$\%]%^%_%`%`%a%b%c%V%d%e%f%g%h%i%j%k%l%m%n%n%% %o%p%q%r%s%t%u%v%w%x%yz{|&}&~&&&&&&&&&&!&&&&&&&&&&&&&&&W&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'''''''''''''''''''''(((((((((((((((((((((((((((((((((('      !"#$%&'()*+,-./0123)4)5)6)7)8*9*:+;+<+=+>+?+@-A-B-C-D-E-F-G-H-I-JKLMKLNKLOKLPKLQKLRKLSKLTKLUKLVKLWKLXKLYKLZKL[KL\KL]KL^KL_KL`KLaKLbKLcKLdKLeKLfKLgKLhKLiKLjKLkKLlKLmKLnKLoKLpKLqKLrKLsKLtKLuKLvKLwKLxKLyKLzKL{KL|K}~..//z{/12222222222222w22222222v2222222222222222222223333333333333333333333333334445555555555555555555555555555888888888888889::::)::::::::: :# :$: : : :::::::::::::::::::: ::!:":#;$;%;&;';(;);;;*;+;,;-;.;/;0;1<2< <3<'<!<'<4<5<6<7<8<9<:<;<<<==>=?=@=A=B=C=D=E=F=G=H=I=J=K=LMNMO=P==Q=R=S=T=U=V=W=X=Y=Z=[=\=]=^=_=`=a=b>c>$>d>d>e>e>f>g>h>c>i>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}>~????????????6??d?e?c?c????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBCCDDDDDDDDDDDDDDDD        F F F F F FF F F F F F F F F F F F F FF F H H H H I II I I !I "I #I $I %I &I 'I (I )II *I +I ,I -I .I /I 0I 1I 2I 3I 4I 5I 6I 7I 8I 9I :I ;I I <II IyI =I >I ?I @I AI BI CI DI EI FI GJ H I J KJ LJ' I M'J( I M(J N I M NJ O I P K I M QJ RJ SJ TJ UJ VJ WJ XJ YJ ZJ [J \J ]J ^J _J `J aJ bJ cJ dJ dJ HJ eJ fJ gJ hJ iJ jJ kJ lJ mMM nM oM pM qM SM rM sM tM ZM [M \M ]M ^M _M `M aM bM cMM uM vM vM wM xM yM zM {M |N }N }N ~N ~N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N N O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O z{     P8P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P Q8Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q R RR R R R R R R !R !R "R R #R $R %R &R 'RR (R )R *R +R ,R -R .R /R 0R 1R 2R R 3R 4R 5R 6R 7R 8R 9S :S ;S <T =T >T ?T @T AT BT CU DU EU FU GU HU IU JU KU LU MV NV OV PV QV RV SV TVVV UV VV WV XV YV ZV [V \V ]V ^V _V `V aV bV cV dV eV fV gVV hV iV jV kV1V1V lV mV nV oV oV pV qV rVV sV tVV uV vV wV xV yV zV {V |V }V ~V V V V V V V V V V V V V W W W W W W W W W W W qW rW W W W W W W W W W W W W W W W W X X X X X X X X X X X X XX X X X X X X X X X X X X X X X X X X Y Y Y Y Y Y Y [ [ [ [ [ [ [ [ [ [ [ [ [ [ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ _ _ _ !_ "_ #_+_ $_ %_ &_ '_ (_ )_ *_ +` ,` -` ,` .` /` 0` /` 1` 2` 3` 4` 5` 6` 7` 8``` 9` :` ;` <` =` >` ?` @` A`K` B` C` D` E` F` G` H` I` J` K` L` M` N` O` P` Q` R` S` T` U` V` W` X` Y` Z` [` \` ]` ^` _` `` 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` z` {` |` }` ~` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` &` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a b b b b b b b b b bb b b bb bb b b b b b b bb bb b b bbb&b b b b b b b b b b b b b b b b b b b b b b c c,c c c c c !c "c #c $c %c &c 'c (cc )c *c +c ,c -cc .c /c 0c 1c 2d 3d 4d 5d 6dd 7d 8d 9d :d ;d <d =d >d ?d @d Ad Bd Cd Dd Ed Fd Gd Hd Id Jd Kd Le Me Ne Oe Pf Qf Rf Sg Tg Ug Vg Wg Xgg Yg Zg [gg \g ]g ^g ^g _g `gg ag bg cg dg eg fg gg hg ig jg kh lhhh mh nh oh ph qh rh sh th uh vhh wh xh yh zh {h |h }h ~h h h hh#h$h%h&hh h h h hh hhh h h Zh h h hh h h h h h h h h h h h h h h i i i i i i i i i i i i i i i i i i i j j j jj jjj j j j j j j j j k k k k k k k k k k k k k k l l l l l8l l l l l ll l ll l l l l l l l l n n n n n nn n n n n n n n n n n n n n n n n n n n n n n n n n n o o o o o o o o q q r r r r r r r r r r r r r r r r r r r r r r rr rrr rr r r r r r r !r "r #s $s %s &s 's (s )s *s +s ,s -s .t /t 0t 1t 2t 3u 4u'u 5u 6u 7u 8u 9u :u ;u <u =u >u ?u @u Au Bu Cu Du Eu Fv Gv Hv Iv Jv Kv Lv Mvv Nv Ov Pv Qv Rv Sv Tw Uw Vw Ww Xw Yw Zw [w \w ]w ^x _x `x ax bx cx dx ex fx gx hx ix jx ky ly my ny oy py qy ry sy ty uy vy wy xy yz zz {z |z }z ~z z z z z z z z z z z z z z z zzz zz z z z )z z z z z z z z z z z z z z zzz z z z z z z z z z z z z z z z z z z z zz z z { { { 7{ { { { { { { { { { { { { { { { { { { { { { | | | | | | | | |$} } } } } } } } ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~              !"#$%&'()*+,-./0123456789:;<=> (?@AB%*,-C"#DEFGHIJCIHKLM)N(OPQRCSTUVWXYZ[\]^_`abcdeefghiijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{z{|}~   S   $_XX      !"#$$%&&'()*+,-./0123456789:;<=>?@@ABCDEFGHIJKLMGN;OPQRSTUVWXY{Z[\]^_`abcde )fghijklmnopqrsz{tuvwxyz{|}~z)/.      //q !"#$%&'()*+,-./ 0123x4567 89WXY{:[];<=>^_`a?@AeBCDEFGHIJKLM NOPQRSTUV WXYZ[\]^_`abcdefghijklmnomnpmnqmnrmnsmntmnumnvmnwmxymxzmxGmxGm{|m{}m{~m{mmmmmmmmmmmmm   .   ,,    !"#$%&'()*+,-./0123456789:;<=>?.@z{ ~rsuvwxyz{|}~zABCD67Egf-3.10-IN8bkFJYSd292eXHuGDTC4 GF.SupportPGF2 PGF.HaskellPGFGFGF.Text.PrettyGF.Text.Lexing URLEncodingSimpleEditor.SyntaxSimpleEditor.JSONPaths_gfPGF2.FFI PGF2.Expr PGF2.Type PGF.Utilities Data.Listnub PGF.TrieMapPGF.CIdPGF.Type PGF.ByteCodePGF.ExprPGF.Data PGF.MacrosPGF.Morphology PGF.OptimizePGF.Probabilistic PGF.SortTop PGF.LinearizePGF.TreePGF.Paraphrase PGF.TypeCheckText PrettyPrint PGF.Generate PGF.Forest PGF.ParsePGF.VisualizeTree PGF.PrinterGF.Text.TransliterationsGF.Text.CodingGF.Text.CliticsGF.System.UseSignalGF.System.SignalGF.System.DirectoryGF.System.ConsoleGF.System.ConcurrencyGF.System.CatchGF.System.ProcessGF.JavaScript.AbsJSGF.JavaScript.PrintJSGF.Infra.LocationGF.Infra.GetOptSystem.EnvironmentgetArgsGF.Infra.ConcurrencyGF.Infra.BuildInfoGF.Data.Utilities GF.Data.XML GF.Data.StrGF.Data.RelationGF.Data.Graphviz GF.Data.GraphGF.Speech.FiniteStateGF.Speech.RegExp GF.Data.ErrMGF.Data.OperationsGF.Data.BacktrackMGF.Compile.TypeCheck.ConcreteGF.Compile.Multi GF.Compile.Compute.AppPredefinedGF.Command.MessagesData.Binary.GetData.Binary.BuilderL BytestringData.Binary.PutData.Binary.IEEE754 Data.Binary PGF.OldBinary PGF.Binary ExampleDemoFoldGF.Command.TreeOperationsGF.Compile.ExampleBasedGF.Grammar.CFGGF.Grammar.BNFCGF.Grammar.EBNFGF.Quiz PGF.InternalGF.Compile.PGFtoJSGF.Compile.PGFtoPrologGF.Compile.PGFtoPythonGF.Compile.ToAPIGF.Infra.IdentGF.Grammar.LexerGF.Grammar.Predef GF.HaskellGF.Infra.OptionGF.Compile.PGFtoHaskellGF.Compile.PGFtoJavaGF.Grammar.GrammarGF.Command.AbstractGF.Compile.Compute.ValueGF.Compile.Compute.PredefGF.Grammar.ValuesGF.Infra.DependenciesGF.Grammar.PrinterGF.Grammar.MacrosGF.Command.CommandInfoGF.Command.Help GF.GrammarGF.Compile.TypeCheck.PrimitivesGF.Compile.TypeCheck.TCGF.Grammar.UnifyGF.Grammar.LockfieldGF.Grammar.LookupGF.Compile.GenerateBCGF.Compile.SubExOptGF.Grammar.AnalyseGF.Grammar.PatternMatchGF.Compile.Compute.ConcreteNewGF.Compile.ConcreteToHaskellGF.Compile.OptimizeGF.Grammar.ShowTermGF.Infra.CheckMGF.Compile.RenameGF.Compile.TypeCheck.Abstract GF.Compile.TypeCheck.ConcreteNewGF.Compile.TypeCheck.RConcreteGF.Compile.CheckGrammarGF.Compile.UpdateGF.Grammar.ParserGF.Command.ParseGF.Infra.UseIOGF.Command.InterpreterGF.Compile.CFGtoPGFGF.Compile.GeneratePMCFGGF.Compile.GrammarToPGFGF.Compile.TagsGF.Grammar.BinaryGF.Compile.ReadFilesGF.Compile.GetGrammar GF.CompileOne GF.Compile linearizeparseGF.Command.ImportingGF.CompileInParallel GF.Infra.SIOGF.Command.Commands2GF.Command.CommonCommandsGF.Command.SourceCommandsGF.Interactive2GF.Speech.CFGToFAGF.Speech.PGFToCFGGF.Speech.PrRegExp GF.Speech.SLF GF.Speech.SRG GF.Speech.GSLGF.Speech.SISRGF.Speech.JSGFGF.Speech.SRGS_ABNFGF.Speech.SRGS_XMLGF.Speech.VoiceXMLGF.Compile.ExportGF.Command.Commands GF.CompilerSimpleEditor.ConvertCacheCGICGIUtilsExampleService PGFServiceRunHTTP GF.ServerGF.InteractiveGF.MainbaseControl.Monad.IO.ClassliftIOMonadIOConcrExprBindTypeExplicitImplicitFunCatCIdmkAbsunAbsmkAppunAppmkStrunStrmkIntunIntmkFloatunFloatmkMetaunMetamkCIdreadExprpExprshowExprHypoTypereadTypeshowTypemkTypeunType showContextLiteralCallbackPGFErrorBracketedStringLeafBINDBracketLIndexFId ParseOutput ParseFailedParseOkParseIncompleteMorphoAnalysisGraphvizOptionsnoLeavesnoFunnoCatnoDepnodeFontleafFont nodeColor leafColor nodeEdgeStyle leafEdgeStyleConcNameAbsNamereadPGFshowPGF languages concreteName languageCode generateAll abstractNamestartCat functionTypefunctionIsConstructor checkExpr inferExpr checkTypecomputetreeProbabilityexprHashexprSize exprFunctionsexprSubstitutegraphvizDefaultsgraphvizAbstractTreegraphvizParseTreegraphvizWordAlignment lookupMorphofullFormLexiconparseWithHeuristicslookupSentencehasLinearization linearizeAlltabularLinearizetabularLinearizeAllshowBracketedStringflattenBracketedStringbracketedLinearizebracketedLinearizeAll alignWords printName functionsfunctionsByCat categoriescategoryContextliteralCallbacks$fExceptionPGFError$fShowPGFErrorR_sHas_sproj_sPrefixTokTKTP SOFT_BIND SOFT_SPACECAPIT ALL_CAPITStrEnumAllenumAlltablefromStrto_R_s+++!!$!* $fHas_sR_st $fEnumAllR_s$fEqTok$fOrdTok $fShowTok$fEqR_s$fOrdR_s $fShowR_swildCIdutf8CIdreadCIdshowCIdpIdentppCIdmkHypo mkDepHypo mkImplHypoTreeunapplymkDoubleunDoubleppMetaLanguageSeqIdFunIdSequenceToken readLanguage showLanguage missingLins showPrintNameMorphoAnalysisLemma buildMorpho isInMorpho morphoMissing morphoKnown ProbabilitiesshowProbabilitiesreadProbabilitiesFromFilemkProbabilitiesdefaultProbabilitiessetProbabilitiesprobTreerankTreesByProbslinearizeAllLangtabularLinearizes paraphraseTcError UnknownCat UnknownFun WrongCatArgs TypeMismatch NotFunTypeCannotInferTypeUnresolvedMetaVarsUnexpectedImplArgUnsolvableGoal ppTcErrorgenerateAllDepth generateFromgenerateFromDepthgenerateRandomgenerateRandomDepthgenerateRandomFromgenerateRandomFromDepth ParseState TypeError ParseInputpiToken piLiteral initStatesimpleParseInput mkParseInput nextStategetCompletionsrecoveryStatesgetParseOutputgetContinuationInfo CncLabelsLabelsgraphvizDependencyTree getDepLabelsgraphvizParseTreeDepgraphvizBracketedString gizaAlignmentgraphvizAlignmentconlls2latexDocgetCncDepLabelsPrettyppppListrender renderStyle$$$+$<+><>bracesbracketscat doubleQuotesfcatfsephanghcathsepnestparens punctuatequotessepvcat $fPretty[] $fPrettyChar$fPrettyDouble $fPrettyFloat$fPrettyInteger $fPrettyInt $fPrettyDocstringOpopInEnv TermColorsredFgblueFgrestoresetConsoleEncodingchangeConsoleEncoding getTermColorscatchtryLocationNoLocLocalExternal HasSourcePath sourcePathunLocnoLoc ppLocationppLErrOkBaderrfromErr ErrorMonadraisehandlehandle_BinTreeifNullmaybeErrtestErrerrIn lookupErr mapPairListM mapPairsMpairM checkUnique unifyMaybe unifyMaybeBy emptyBinTree isInBinTree lookupTreelookupTreeManyAll updateTree buildTreemapTree filterBinTree tree2listindent++-+++++++-+++++prUpper prReplicateprTListprQuotedString prParenthprCurly prBracket prArgList prSemicList prCurlyListrestoreEscapesnumberedParagraphs prConjList prIfEmpty wrapLines combinationstopoTest topoTest2iterFixchunks readIntArgdoneliftErrchecksBinaryencodedecode encodeFile decodeFileTrieOthApATreeOtherAppparsePGFparseAll parseAllLangparse_parseWithRecoverycomplete groupResultsbrowsetoATreetoTrie $fShowATree $fShowTrieRawIdentIdent 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 CFGTransformCFGNoLR CFGRegularCFGTopDownFilterCFGBottomUpFilterCFGStartCatOnlyCFGMergeIdenticalCFGRemoveCycles OptimizationOptStemOptCSE OptExpandOptParametrize SISRFormatSISR_WD20030401SISR_1_0 OutputFormat FmtPGFPretty FmtJavaScript FmtPython FmtHaskellFmtJava FmtPrologFmtBNFFmtEBNF FmtRegularFmtNoLR FmtSRGS_XMLFmtSRGS_XML_NonRec FmtSRGS_ABNFFmtSRGS_ABNF_NonRecFmtJSGFFmtGSL FmtVoiceXMLFmtSLF FmtRegExpFmtFAPhasePreprocConvertCompileLink VerbosityQuietNormalVerboseDebugMode ModeVersionModeHelpModeInteractiveModeRunModeInteractive2ModeRun2 ModeCompiler ModeServer helpMessage parseOptionsparseModuleOptionsfixRelativeLibPaths optionsGFO optionsPGFflag addOptions noOptions concatOptions modifyFlags getEncodingdefaultEncodingoutputFormatsExplrenameEncodingreadOutputFormat verbAtLeastdump cfgTransform haskellOption isLiteralCat isLexicalCatsetOptimizationsetCFGTransform SubstitutionAlternParamLocalDefCaseAssign LabellingEquationContextMetaIdLabelLIdentLVarTInfoTRawTTypedTCompTWildPattPCPPPVPWPRPStringPIntPFloatPTPAsPImplArgPTildePNegPAltPSeqPMSeqPRepPCharPCharsPMacroPMTermVrCnConSortEIntEFloatKEmptyAbsMetaImplArgProdTypedExampleRecTypeRPExtRTableTVSLetQQCCGlueEPatt EPattTypeELincatELin AdHocOverloadFVAltsStrsErrorQIdentInfoAbsCatAbsFunResParamResValueResOper ResOverloadCncCatCncFunAnyIndPMCFG Production ModuleStatus MSComplete MSIncompleteOpenSpecOSimpleOQualifMIncludeMIAllMIOnlyMIExcept ModuleType MTAbstract MTResource MTConcrete MTInterface MTInstance SourceModInfo SourceModule SourceGrammar ModuleInfoModInfomtypemstatusmflagsmextendmwithmopensmexdepsmsrcmseqsjmentsModuleGrammar 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 strsFromTermstringFromTerm getTableTypechangeTableType wordsInTermnoExistdefaultLinTypesortRecallDependenciestopoSortJmentstopoSortJments2OutputePutStr ePutStrLnputStrE putStrLnEIOEFullPathInitPathFileName putIfVerb gfLibraryPathgfGrammarPathVargetLibraryDirectorygetGrammarPath extendPathEnv getSubdirsjustModuleNameisGFisGFOgfFilegfoFilegf2gfogf2gfo'splitInModuleSearchPathtryIOEuseIOEmaybeIOdie putPointE ioErrorTexttimeIt writeUTF8FilereadBinaryFilewriteBinaryFile VersionTaggedTagged WrongVersionunV decodeModuledecodeModuleHeader encodeModulegetSourceModule getBNFCRules getEBNFRulesCompiledModule OneOutput compileOnereuseGFO useTheSource compileToPGFlink srcAbsName batchCompileparallelBatchCompile exportPGFmainGFC linkGrammars writeOutputswritePGF mainRunGFImainGFI mainServerGFImain getOptionsmainOptsurlDecodeUnicode decodeQueryQueryabothfromhex4fromhex2unfoldrchopListbreakAtLhsLinfunargslinOperonameorhsLincatlintypepnameprhsConcretelangcodeopensparamslincatsoperslinsfnameftypeAbstractstartcatcatsfunsbasenameabstract concretesModIdId signature definition.= $fJSONLin $fJSONLincat$fJSONConcrete $fJSONOper $fJSONParam $fJSONFun$fJSONAbstract $fJSONGrammarcatchIOversionbindirlibdir dynlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameMapItorCallbackLookupMorphoCallbackOracleLiteralCallbackOracleCallbackLiteralPredictCallbackLiteralMatchCallback MetaCallback BindCallbackNonExistCallbackPhraseCallbackSymbolTokenCallbackPgfProductionApply PgfCncFunPgfCCat PgfAbsCat PgfAbsFun PgfBindTypePgfGraphvizOptions PgfLinFuncs PgfCncTreePgfOracleCallbackPgfCallbacksMapPgfTypePgfPrintContextPgfMorphoCallbackPgfFullFormEntry PgfExprParser PgfExprProbPgfExprPgfConcrPgfApplicationPgfPGFCUInt8CSizeTGuUCSGuHash GuVariantGuPoolGuBufGuSeqGuHasher GuMapItorGuMap GuStringBufGuStringGuTypeGuKindGuOutGuInGuExnGuEnumconcr touchConcrpgftouchPGFTouchpgf_production_is_lexical pgf_lzr_indexpgf_parser_indexpgf_graphviz_word_alignmentpgf_graphviz_parse_treepgf_graphviz_abstract_tree pgf_read_typepgf_read_expr_matrixpgf_read_expr_tuple pgf_read_expr pgf_printpgf_generate_allpgf_print_contextpgf_print_typepgf_print_expr_tuplepgf_print_expr pgf_computepgf_check_typepgf_infer_exprpgf_check_exprpgf_compute_tree_probabilitypgf_expr_substitutepgf_expr_functions pgf_expr_size pgf_expr_hash pgf_expr_eqpgf_expr_aritypgf_expr_unlitpgf_expr_float pgf_expr_intpgf_expr_stringpgf_expr_unmeta pgf_expr_metapgf_expr_unabs pgf_expr_abspgf_expr_unapplypgf_expr_applypgf_fullform_get_analysespgf_fullform_get_stringpgf_fullform_lexiconwrapMapItorCallbackwrapLookupMorphoCallbackpgf_lookup_morphopgf_parse_with_oraclehspgf_new_oracle_callbackwrapOracleLiteralCallbackwrapOracleCallbackhspgf_callbacks_map_add_literalpgf_new_callbacks_mapwrapLiteralPredictCallbackwrapLiteralMatchCallbackpgf_lookup_sentencepgf_parse_with_heuristicspgf_align_wordswrapSymbolMetaCallbackwrapSymbolBindCallbackwrapSymbolNonExistCallbackwrapPhraseCallbackwrapSymbolTokenCallbackpgf_lzr_get_tablepgf_lzr_linearizepgf_lzr_linearize_simplepgf_lzr_wrap_linrefpgf_lzr_concretize pgf_linearizepgf_has_linearizationpgf_print_namepgf_function_is_constructorpgf_function_typepgf_iter_functions_by_catpgf_iter_functionspgf_category_probpgf_category_context pgf_start_catpgf_iter_categoriespgf_language_codepgf_concrete_unloadpgf_concrete_loadpgf_concrete_namepgf_get_languagepgf_iter_languagespgf_abstract_name pgf_writepgf_readgu_alloc_variantgu_variant_datagu_variant_taggu_null_structgu_string_hashergu_addr_hasher gu_int_hasher gu_map_itergu_map_find_default gu_map_insert gu_make_map gu_make_buf gu_make_seqgu_utf8_encodegu_utf8_decodegu_string_buf_freeze gu_enum_next gu_file_ingu_string_buf_outgu_new_string_buf gu_string_in gu_exn_raise gu_exn_caughtgu_exn_is_raised gu_new_exngu_pool_finalizer gu_pool_freegu_malloc_aligned gu_malloc gu_new_poolfopengu_exn_type_GuErrnogu_exn_type_GuEOFgu_exn_type_PgfLinNonExistgu_exn_type_PgfExngu_exn_type_PgfParseErrorgu_exn_type_PgfTypeError withGuPoolnewOutpeekUtf8CStringpeekUtf8CStringLenpokeUtf8CStringnewUtf8CString utf8Length peekSequence newSequenceGHC.BaseString ParserGetcexpr touchExprwrapParserGetcpgf_expr_parser_exprpgf_new_parser newPrintCtxt$fEqExpr $fShowExprtyp touchTypepokeHypo pokeExprs touchHypo $fShowTypeOraclenercchunk loadConcr unloadConcrnewGraphvizOptions getAnalysismkCallbacksMapparseWithOracleppBracketedStringwithBracketLinFuncsthrowExn categoryProbfromPgfExprEnum trimRight capitalized uncapitalized capitalized'nub'replaceTrieMapTrempty singletonlookupnullcompose decompose insertWithunion unionWithunions unionsWithelemstoList fromListWithfromListmap mapWithKeyNothingpCId insideChar isIdentFirst isIdentRest $fReadCId $fShowCIdDTyppType pHypoBindspAtomppTypeppHypoLStrLIntLFltTailInfoRecCallTailCall UpdateCallIValHEAPARG_VARFREE_VARGLOBALInstr CHECK_ARGSCASECASE_LITSAVEALLOC PUT_CONSTR PUT_CLOSUREPUT_LITSETSET_PAD PUSH_FRAMEPUSHTUCKEVALDROPJUMPFAIL PUSH_ACCUM POP_ACCUMADD CodeLabelLiteralppLitppCodeppInstrppIVal ppTailInfoppLabelPAppPLitPVarPWildEAbsEAppELitEMetaEFunEVarETypedEImplArg normalFormppParens freshNameppExprpBindspArgEnvSigValueVAppVLitVMetaVSuspVGenVConstVClosureVImplArgEqupFactorpTypedpMetapLit pattScopeppBind value2exprevalapply applyValuematch $fReadExpraflagsPArgPApplyPCoercePConstSymbolSymCatSymLitSymVarSymKSSymKPSymBINDSymNE SymSOFT_BIND SymSOFT_SPACESymCAPIT SymALL_CAPITDotPoscflags printnamescncfunslindefslinrefs sequences productions pproductions lproductionscnccatslexicon totalCatsAbstrgflagsabsnameunionPGF msgUnionPGFemptyPGFhaveSameFunsPGF fidStringfidIntfidFloatfidVarfidStart isPredefFIdlengthBracketedStringCncTypeLinTable BracketedToknBracket_LeafKSLeafNELeafBIND LeafSOFT_BIND LeafCAPITLeafKP mapConcreteslookTypeisData lookValCat lookStartCatlookGlobalFlag lookAbsFlag lookConcrlookConcrComplete lookConcrFlagfunctionsToCathasLin restrictPGFdepthcftype typeOfHypo contextLengthlookMap cidStringcidIntcidFloatcidVaruntokn mkLinTable computeSeq collectWordsmorphoClassifymissingWordMsg optimizePGFupdateProductionIndices topDownFilterbottomUpFilterfilterProductionssplitLexicalRulesupdateConcreteCStateProbsfunProbscatProbsgetProbabilities mkProbDefscomputeConstrsp_fp_ik_fk_i arguments showInOrderisArg typesInterm returnCat forExamplefirstLinlinTreeVarLit tree2expr expr2treeprTree patt2treeSubst paraphraseN paraphraseN'fromDefsubstisClosedisLinear lookupVargetVarSelector splitSelectorselectTcMunTcM MetaValueMUnboundMBoundMGuarded MetaStoreScopeTTypeTTyp emptyScope addScopedVarscopeEnv scopeVars scopeSizerunTcM lookupCatHyps lookupFunTypetypeGeneratorsemptyMetaStorenewMetanewGuardedMetagetMetasetMeta lookupMeta addConstrainttcTypetcHypostcHypo tcCatArgstcExprinfExprtcArg appImplArgeqTypeeqExpreqValuecheckResolvedMetaStoregenerateForMetasgenerateForForestevalType refineExpr refineExpr_ refineType refineType_ $fFunctorTcM$fMonadErrorTcErrorTcM$fMonadStatesTcM$fMonadPlusTcM$fAlternativeTcM $fMonadTcM$fApplicativeTcMOntologygenerateOntologygenerateOntologyDepthgenerateproverestart$fSelectorOntology$fSelectorIdentity $fSelector() getAbsTreesForestabstrforestrootlinearizeWithBrackets bracketedTokn isLindefCId foldForest $fSelectorInt ErrorStateEState ContinuationChartactiveactivespassivenextIdoffsetPState PassiveChart PassiveKeyPK ActiveChart ActiveSet ActiveKeyAKActive getPartialSeqprocessupdateAtemptyAClookupAClookupACByFCatlabelsACinsertACemptyPClookupPCinsertPCghc-prim GHC.TypesBooltoSVGAttrsTagNameSVGCharDataElemLengthPositionSize UnitLengthMMObjectTinyTextOvalTop ArrowDownDrawingCommandPutLaTeXCommentPictureCoNLLDep wordLengthtokensdepsPreAlignLangSeq IndexedSeqRelNumTreegetArgumentPlace expr2numtreegenPreAlignment showIndSeqshowRelsgetOffsetIndex computeOffsetstruct tbracketstag conll2latex conll2latex'defaultWordLength defaultUnit spaceLength charWidthwsizewposwdist labelheight labelstartarcbase arcfactorxyratioputArc dep2latex parseCoNLL conll2dep'ppLaTeXapplatexDocppSVGfixCoNLL printCoNLLppPGFppAbsppFlagppCatppFunppCncppCncArg ppProductionppCncFun ppLinDefs ppLinRefsppSeqppCncCat ppPrintNameppSymbolppAltppStrsppFIdppFunIdppSeqIdppAllTransliterationTranstrans_to_unicodetrans_from_unicodeinvisible_chars printname transliteratetransliterateWithFiletransliterationallTransliterationstransliterationPrintNamescharacterTableappTransToUnicodeappTransFromUnicodemkTransliterationgetTransliterationFileunchar transThaitransDevanagariallTransUrduHindi transUrdu transSindhi transArabictransArabicUnvoc transPersian transNepali transHebrew transTelugu transGreektransAncientGreek transAmharicallTransallCodes transSanskritpretty-1.1.3.3#Text.PrettyPrint.Annotated.HughesPJPageMode ZigZagModeLeftMode OneLineModeStylemode lineLengthribbonsPerLinestyleText.PrettyPrint.HughesPJDocisEmptylexTextlexText'bindToklexCode normalize denormalizetoGrave enclitics dropAccent hasEndAcute lexLatexCodelexMixed capitInit uncapitInitunquoteappLexer appUnlexerwrapHTML unlexText lexTextAGreeklexTextAGreek2unlexTextAGreek isAGreekPunct lexAGreek lexAGreek2 unlexAGreek fromAGreektoAGreektoAcute isAGreekVowel proclitics isEnclitic isProclitic wasEnclitic wasProclitic getEnclitic getProcliticdropLastAccentaddAcute hasEndCircumhasPrefinalAcutehasSingleAccent hasAccentenclitics_expls unlexCode unlexMixedisPunct isMajorPunct isMinorPunctisParen isClosing encodeUnicode decodeUnicodedecodeUnicodeIOioe_invalidCharacter1ioe_invalidCharacter2 getCliticsgetCliticsTextrunInterruptiblyrunInterruptibly_blockInterruptmyInstallHandlermyCatchmyIgnorecanonicalizePathcreateDirectoryIfMissingdoesDirectoryExist doesFileExistgetModificationTimegetDirectoryContentsgetCurrentDirectorygetPermissions removeFile renameFiledirectory-1.3.0.0System.DirectorygetTemporaryDirectorygetUserDocumentsDirectorygetAppUserDataDirectorygetXdgDirectorygetHomeDirectorysetModificationTime setAccessTime getAccessTimeisSymbolicLinkpathIsSymbolicLink doesPathExist getFileSizewithCurrentDirectorysetCurrentDirectory listDirectory findFilesWith findFileWith findFilesfindFilefindExecutablesInDirectoriesfindExecutablesfindExecutablemakeRelativeToCurrentDirectory makeAbsolutecopyFileWithMetadatacopyFile renamePathrenameDirectoryremovePathForciblyremoveDirectoryRecursiveremoveDirectorycreateDirectorycopyPermissionssetPermissionssetOwnerSearchablesetOwnerExecutablesetOwnerWritablesetOwnerReadableemptyPermissions Permissionsreadablewritable executable searchable XdgDirectoryXdgData XdgConfigXdgCache System.Directory.Internal.Config exeExtension setEncoding noTermColorsc_getNumberOfProcessorssetNumCapabilitiesFalsegetNumberOfProcessorsreadShellProcess PropertyName IdentPropNameStringPropName IntPropNamePropertyPropEAssignENewEMemberEIndexECallEDblEStrETrueEFalseENullEThisEArrayEObjESeqDeclVarDVarDInit DeclOrExprDeclDExprStmt SCompound SReturnVoidSReturn SDeclOrExprElementFunDefElStmtProgramPrintprtprtList printTreedoc spaceAfter spaceBeforeparenthconcatSconcatDmkEscprPrec$fPrintPropertyName$fPrintProperty $fPrintExpr$fPrintDeclVar$fPrintDeclOrExpr $fPrintStmt$fPrintElement$fPrintProgram $fPrintIdent $fPrintDouble $fPrintInt $fPrintChar $fPrint[] $fPrettyL$fPrettyLocation $fFunctorLArgDescrNoArgReqArgOptArgOptDescrOptionArgOrder RequireOrderPermute ReturnInOrder usageInfogetOptgetOpt'OptKindOptUnreqOptNonOpt EndOfOptsOptErrfmtOptfmtShortfmtLonggetNextlongOpterrAmbigerrReqerrUnrecerrNoArgFuturenowspawnparMapMnewLognewMVarreadMVarputMVar newEmptyMVarnewChangetChanContents writeChanlazyIOControl.Concurrent.ChanChanControl.Concurrent.MVar modifyMVar modifyMVar_ GHC.Conc.SyncforkIOGHC.MVarMVar buildInfosafeInitGHC.Listinit sortGroupByunionAlllookup'find' Data.FoldablefindtableSet buildMultiMap compareEqwhenMPmzero nothingOrNullfoldFunsfixjoin Data.OldList sameLength notLongerThan longerThan lookupListsplitsplitBy foldMerge updateNth updateNthM compareBybothapFstapSndapBothmapFstmapSndmapBothwhenMrepeatMnlspwrapunwordsSunlinesSjoinSAttrXMLDataCDataTagETagcomments showXMLDoc showsXMLDocshowsXML showsAttrs showsAttrescape bottomUpXMLSsTN matchPrefixunmarkup str2stringssstrstritSstrTokplusStrglueStrgluesRel'mkRelmkRel'relaterelates isRelatedTo allRelateddomainintersectSetRelreflexiveClosurereflexiveElements filterRel purgeEmptyequivalenceClassestopologicalSort Data.EitherLeftRightremove relToList reverseReltransitiveClosurereflexiveClosure_symmetricClosuresymmetricSubrelationreflexiveSubrelation isTransitive isReflexive isSymmetric isEquivalenceisSubRelationOftsort findCyclesisEmpty' relToRel' rel'ToRelincomingGraphEdgeNode GraphTypeDirected UndirectedgTypegIdgAttrsgNodesgEdges gSubgraphs addSubGraphssetNamesetAttr prGraphviz prSubGraphprGraph graphtypeprNodeprEdgeedgeop prAttrListprAttrescneedEsc isIDFirstisIDCharnewGraphnodesedgesnmapemapnewNode removeNode removeNodesnodeInfo mergeGraphs renameNodesmap'NodeInfonewNodesnewEdgenewEdgesinsertEdgeWith groupEdgesBy lookupNode getIncoming getOutgoinginDegree outDegree getNodeLabel nodeLabeledgeFromedgeTo edgeLabel reverseGraphFAnewFA_nonLoopTransitionsTo renameStates insertNFA oneFinalStatemoveLabelsToNodesremoveTrivialEmptyNodesskipSimpleEmptyNodes pruneUnusableclosure reachableDFANFAState startState finalStatesstates transitionsnewFA addFinalStatenewState newStates newTransitionnewTransitionsinsertTransitionWithinsertTransitionsWith mapStatesmapTransitionsmodifyTransitions removeStateminimize unusedNamesnonLoopTransitionsFromloopsonGraph isInternalisFinal fixIncoming determinize reachable1 reverseNFAdfa2nfa prFAGraphviz faToGraphvizREUnionREConcatRERERepeatRESymboldfa2re elimStates epsilonREnullREisNull isEpsilonunionREconcatREseqRErepeatREfinalRE reverseRE minimizeRE mergeForwardfirstREmapREmapRE'joinRE symbolsREprREprRE'pMaybe Data.Maybemaybe$fMonadPlusErr $fFunctorErr$fAlternativeErr$fApplicativeErr $fMonadErrData.Traversablesequence checkAgain$fErrorMonadErr BacktrackMBMrunBMfoldBM foldSolutions solutionsfoldFinalStatesmembercut$fMonadStatesBacktrackM$fMonadPlusBacktrackM$fAlternativeBacktrackM$fFunctorBacktrackM$fMonadBacktrackM$fApplicativeBacktrackM mtl-2.2.1-BLKBelFsPB3BoFeSWSOYj6Control.Monad.State.Classgetsmodify'modify MonadStategetputstateMulti rawModulesabsNamecncNamesabsRulescncRules readMulti emptyMultiabsCodecncCodegetMultiaddMultigetRuleschopunspacequoteidCharisModulemodlineswelcome licenseMsg codingMsg changesMsgGetrunGet runGetStateskip uncheckedSkip lookAhead lookAheadM lookAheadEuncheckedLookAhead bytesRead remaining getByteStringgetLazyByteStringgetLazyByteStringNulgetRemainingLazyByteStringgetBytes splitAtSTreadNgetWord8 getWord16be getWord16le getWord32be getWord32le getWord64be getWord64le getWordhost getWord16host getWord32host getWord64hostunGetmkStatefailDescjoinBSgetPtr shiftl_w16 shiftl_w32 shiftl_w64 $fMonadFixGet $fMonadGet$fApplicativeGet $fFunctorGetBuilderbytestring-0.10.8.1Data.ByteString.Lazy.Internal ByteStringtoLazyByteStringData.ByteString.LazyappendfromByteStringData.ByteString.Internal fromChunksfromLazyByteStringflush unsafeLiftIOwithSize mapBuilder ensureFreewriteN writeNbytes putWord16be putWord16le putWord32be putWord32le putWord64be putWord64le putWordhost putWord16host putWord32host putWord64hostBuffer runBuilder defaultSize writeNBuffer newBufferwriteNBufferBytes shiftr_w16 shiftr_w32 shiftr_w64$fMonoidBuilderPutMexecPutrunPutrunPutMputWord8 putByteStringputLazyByteStringunPutPairSsndStell putBuilder $fMonadPutM$fApplicativePutM $fFunctorPutM ByteCountBitCount SignificandExponentSignPositiveNegativeRawFloatrawWidthrawSign rawExponentrawSignificandrawExponentWidthrawSignificandWidth getFloat16be getFloat16le getFloat32be getFloat32le getFloat64be getFloat64le splitBytesmerge normalised denormalisedgetFloat putFloat32be putFloat32le putFloat64be putFloat64le splitFloat rawToBytesclampmashBitsintegerToBytesputFloat exponentWidthbiasunbiasbitCount bitsInWord8 bitShiftL bitShiftRbitSlicesliceIntpow isNegativeNaNSmallInt encodeFile_ decodeFile_unrollroll$fBinaryUArray $fBinaryArray $fBinaryTree $fBinaryFloat$fBinaryDouble $fBinarySeq$fBinaryIntMap$fBinaryIntSet $fBinaryMap $fBinarySet$fBinaryByteString$fBinaryByteString0$fBinaryEither $fBinaryMaybe $fBinary[]$fBinary(,,,,,,,,,)$fBinary(,,,,,,,,)$fBinary(,,,,,,,)$fBinary(,,,,,,)$fBinary(,,,,,)$fBinary(,,,,) $fBinary(,,,) $fBinary(,,) $fBinary(,) $fBinaryChar $fBinaryRatio$fBinaryInteger $fBinaryInt $fBinaryWord $fBinaryInt64 $fBinaryInt32 $fBinaryInt16 $fBinaryInt8$fBinaryWord64$fBinaryWord32$fBinaryWord16 $fBinaryWord8$fBinaryOrdering $fBinaryBool $fBinary()WordGHC.WordWord8Word16Word32Word64 byteSwap64 byteSwap32 byteSwap16pgfMajorVersionpgfMinorVersiongetPGFgetPGF'getCId getAbstractgetFungetCatgetFlagsgetConcrgetExprgetPatt getEquationgetTypegetHypo getBindType getCncFun getCncCat getSequence getSymbols getSymbolgetAlternativesgetTokenSymbolgetPArg getProduction getLiteralgetArraytoArray listToArraygetListgetList'getMaybegetMap getIntMapgetSetgetPair decodingError putSplitAbsputArray putArray2 getArray2$fBinaryLiteral$fBinaryProduction $fBinaryPArg$fBinarySymbol$fBinaryCncCat$fBinaryCncFun$fBinaryBindType $fBinaryType $fBinaryInstr$fBinaryEquation $fBinaryPatt $fBinaryExpr $fBinaryConcr $fBinaryAbstr $fBinaryCId $fBinaryPGFEnviron getTypeMap getConcMapgetSigsgetAllConcMapTypeMap FuncWithArggetName getTypeArgs InterInstrMyFuncConcTypeMyTypeprovideExampletestThisllinreplaceConcArg replaceOne findExprWhich mapToResource embedInStartmkSigssearchGoodTree getNameExprisGeneralizationOfdebugReplaceArgsdebugReplaceConcisMeta mkFuncWithArginitial startCategfoldablefoldappFoldTreeOptreeOp allTreeOpslargestsmallest treeChunkssubtreesExConfigurationExConf resource_pgfresource_morphoverboselanguageprintExpparseExamplesInGrammar convertFileconfigureExBasedCFObjCFAbsCFAppCFResCFVarCFMeta removeCyclesmergeIdenticalpurgeExternalCats mutRecCatsallRulesallRulesGroupedallCatsallCats'catRules catSetRulescleanCFGunionCFG anyUsedBy allXLinear isRightLinear isLeftLinearcatElemParamCFG ParamCFRule ParamCFSymbolCFGCFRuleCFSymbolCFTerm cfgStartCatcfgExternalCatscfgRulesRuleruleLhsruleRhsruleName NonTerminalTerminalremoveLeftRecursionmakeSimpleRegular makeRegularmkCFG groupProds uniqueFuns mapCFGCatsonRules filterCFG filterCFGCats countCats countRulesprCFG prProductionsprCFTermruleFunmkCFTermruleIsNonRecursivesymbol mapSymbol filterCats filterToks noCatsInSetSepMap SepTermSymb IsSeparator IsNonemptyBNFCRule BNFCCoercionsBNFCTerminator BNFCSeparatorlhsCatcoerCatcoerNum termNonEmptytermCattermSep sepNonEmptysepCatsepSep BNFCSymbolIsListbnfc2cf isSepTermtransformRulesfRules transformSymbcreateListRulescreateListRules'EItemEITerm EINonTermEIStarEIPlusEIOpt NormERule CFJustRuleCFRHSERHSETermENonTermEAltEStarEPlusEOptEEmptyETokECatERuleEBNFebnf2cfnormEBNF pickERules eitem2cfitem normERulemkEItemmkECatprECatmkCFCatE mkNewECatmkAnswerQuestionsAndAnswersmkQuiztranslationListmorphologyListnorml teachDialoguepgf2js abstract2js absdef2jslit2js concrete2jschildrenfrule2jsfarg2jsffun2jsseq2jssym2jsalt2jsnew mapToJSObj AlphaConvert alphaConvert ConvertEnvPLPrintplpplpsgrammar2prolog plAbstract plConcreteplCatplFunplSeqplHeaderplFactsplTermplListplOperplVarplAtomisAlphaNumUnderscorecreateLogicalVariableisLogicalVariablelogicalVariablePrefixemptyEnvalphaConvertHypo$fAlphaConvertEquation$fAlphaConvertExpr$fAlphaConvertType$fAlphaConvert[] $fPLPrint[] $fPLPrintChar$fPLPrintSymbol$fPLPrintLiteral $fPLPrintCId$fPLPrintEquation $fPLPrintPatt $fPLPrintExpr $fPLPrintType pgf2pythonpyAbsdef pyLiteral pyConcrete pyProductionpySymbolpyDictpyListpyTuplepyCatpyFunpySeqpyStrpyCIdpyIndentAPIfunc BasicFuncAppFuncNoAPI exprToAPI stringToAPI exprToFuncmkAPI computeAPIoptimize optimizeNP hiddenCats optimizable rephraseable printAPIfunc syntaxFuncsICIWIVIAIAV rawId2utf8packunpackwild $fPrettyIdent$fBinaryRawIdent$fPrettyModuleName$fShowModuleNameAlexAcc AlexAccNone AlexAccSkip AlexLastAccAlexNone AlexLastSkip AlexReturnAlexEOF AlexErrorAlexSkip AlexTokenAlexAddrAlexA#unP ParseResultPOkPFailed AlexInput2 AlexInputAIPosnPn 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_IdentT_EOF alex_tab_size alex_base alex_table alex_check alex_deflt alex_accept alex_actionsidenttokreseitherResIdentisReservedWordresWordsunescapeInitTailalexMove alexGetByterunP runPartialrunP'dupfailLoclexertokengetPosn alex_action_3 alex_action_4 alex_action_5 alex_action_6 alex_action_7 alex_action_8alexIndexInt16OffAddralexIndexInt32OffAddr quickIndexalexScan alexScanUser alex_scan_tkn$fMonadP$fApplicativeP $fFunctorPcTypecPTypecTokcStrcStrs cPredefAbs cPredefCnccPredefcIntcFloatcStringcVarcIntscPBool cErrorType cOverloadcUndefinedType cNonExistcBIND cSOFT_BIND cSOFT_SPACEcCAPIT cALL_CAPIT isPredefCatcPTruecPFalsecLengthcDropcTakecTkcDpcToUppercToLowercIsUppercEqStrcEqValcOccurcOccurscEqIntcLessIntcPluscShowcReadcToStrcMapStrcErrorcTracecMetacAscCharcCharscSeqcAltcRepcNegcCNC cConflictPPAPatExpTyConApDecppAWildPVarPConPAsPConstOpListPairLets LambdaCaseTIdTApListTFunDepsDerivingClassInstanceTypeSigEqnconap0tsyn0lhs0tvartcon0tconlet1singleplusplus$fPPAPat $fPrettyPat$fPPAExp $fPrettyExp$fPPATy $fPrettyTy $fPrettyConAp $fPrettyDec $fPPAIdentoptDescrWarningWarnMissingLincat usageHeadererrors defaultFlags outputFormatsoptimizationPackagescfgTransformNameshaskellOptionNames lookupShowlookupReadsPreconOffsetOptimization'setCFGTransform'toggle readMaybe toEnumBounded$fFunctorArgDescr$fFunctorOptDescr$fReadOutputFormat$fShowOutputFormat $fShowOptionsgrammar2haskellelemCat HSkeletonOIdent haskPreamble predefInst datatypes gfinstances hDatatypenonLexicalRuleslexicalConstructorpredefTypeSkel datatypesGADT hCatTypeGADT hDatatypeGADThEqGADTprCompos gfInstance hInstancemkVarsmkSVars fInstance hSkeleton isListCatbaseSize composClass grammar2java javaPreamble javaMethod javaEndingMPattMGrammar$fHasSourcePathModuleInfoArgumentAExprATermANoArgAMacroVIdVIntVStrOOptOFlagCommandPipe CommandLine valCIdOpts valIntOpts valStrOpts listFlags valueStringisOptisFlag optsAndFlagsprOptmkOpt getCommandOp PredefinedDropTakeTkDpEqStrOccurOccursToUpperToLowerIsUpperPlusEqIntLessIntTracePBoolPFalsePTrueIntFloatIntsNonExistBindBindingWildVCAppVAbsVProdVFloatVStringVSortVTblTypeVRecTypeVRecVVVTVCVSVPVPatt VPattTypeVFVVAltsVStrsVError$fEqBindPredeftoValue fromValueverrorpredefpredefs predefName predefNames predefListdeltaboolVnormstringswap$fPredefPredefined $fPredefValue $fPredef[] $fPredefBool $fPredefInt MetaSubst ConstraintsBindsValVCnVTypeVClos valAbsInt valAbsFloat valAbsStringvTypeeTypeModDepsmodtypeofs extendedsopenedsextradsfunctors interfaces instancesdepGraph prDepGraph noModDepsgrammar2moddeps ppOptions ppEquationppCaseppEnvppDeclppDDecl ppOpenSpec ppInstSpecppLocDefppAlternppParam ppSequences commaPunctprec getCTablegetLet $fPrettyLabel $fPrettyPatt $fPrettyTerm$fPrettyGrammar CommandOutputPipedCommandArgumentsExprsStrings TypeCheckArg typeCheckArg CommandInfoexecsynopsissyntax explanationlongnameoptionsflagsexamplesneedsTypeCheckmapCommandExecemptyCommandInfo fromStrings fromExprs fromStringpipeWithMessage pipeMessage pipeExprsvoid stringAsExpr toStringstoExprstoTermmkExcommandHelpAll' commandHelp' commandHelpcommandHelpTagssection optionallycompact helpCommand typPredefined primitivesTCEnvTheoryAAssign ALabellingAExpAVrACnATypeAIntAFloatAStrAMetaALetAAppAAbsAProdARecTypeARAPAGlueAData lookupConstwhnfeqValcheckExp checkInferExpinferExpcheckLabelling checkAssign checkBranch checkPattnoConstrmkAnnotConstrsUnifierunifyValunifyAllunifyextend subst_all substMetas substTermoccCheckval2term lockRecType unlockRecord lockLabel isLockLabel lockPrefixlookupOrigInfolookupCatContextlockunlock lookupIdentlookupIdentInfolookupQIdentInfo lookupResDeflookupResDefLoc lookupResTypelookupOverloadTypeslookupOverload allOrigInfoslookupParamValuesallParamValues lookupAbsDef lookupLincatallOpers allOpersTogenerateByteCodecompileEquationsmkFail compileBody compileFun compileArg compileLambda shiftIValpushArgstuckArgssetArgsfreeVarsi2ipush_isTermMTermList subexpModuleunsubexpModuleaddSubexpConstsgetSubtermsModcollectSubterms operIdent isOperIdent operPrefixstripSourceGrammar stripInfoconstantsInTerm constantDeps getIdTermconstantDepsTermtermsOfConstant sizeConstantsizeTermsizeInfo sizesModule sizesGrammarprintSizesGrammar minLength maxLength matchPatterntestOvershadow findMatchtryMatch matchPMSeq matchPSeq matchPSeq' matchLength lengthBoundsmPatt measurePattisInConstantFormresourceValues traceResourcevalue0value strsFromValue value2term OpenValueStack LocalScope GLocation CompleteEnvCEsrcgrrvsoptsgloclocal GlobalEnvGEResourceValuesnfxgeLoc geGrammarextglobalvarpickresourcevconcatprojok1ok2ok2p unlockVRecplusVRecextRgluevfv valueMatch valueTable paramValues paramValues' paramValues''push'pushapply'vapplyvbetavaryvaryListvtrace value2term' linPattVarspattVars allPattVarsix#<#buglocbugppbugconcretes2haskellconcrete2haskell toHaskellcon tableTypes paramTypesrecordscoerceconvertconvert'patVarsconvTypeproj'rconrcon' rcon_nameto_rconto_rcon' recordType labelClass paramTypeenumConqualoptimizeModulepartEval mkLinDefaultevalInfo partEvalNewmkLinReference evalPrintnamefactorTermPrintStyleTermPrintTable TermPrintAll TermPrintList TermPrintOneTermPrintDefaultshowTerm ppTermTabular checkError checkWarncheckAccumErroraccumulateError commitCheckrunCheck runCheck' checkInModuleCheckunCheck CheckResultFailSuccess AccumulateNonFatalMessagehandle' checkCond checkWarnings parallelCheckcheckMapcheckMapRecovercheckIn$fErrorMonadCheck$fApplicativeCheck $fMonadCheck$fFunctorCheckrenameSourceTerm renamePattern StatusInfo StatusTreeStatus renameModulerenameIdentTermrenameIdentTerm' info2status tree2status buildStatusmodInfo2status self2status renameInfo renameTerm renameContext initTCEnvtype2valcont2expcont2val justTypeCheck notJustMetagrammar2theory checkContextcheckTypcheckDef checkConstrs instSigma subsCheckRhounifyVar instantiate skolemisequantify getMetaVars getFreeVarszonkTermTcATcSingleTcManyTcResultTcOkTcFailUnboundBoundTauRhoSigma checkLType inferLType inferSigmavtypeInt vtypeFloat vtypeIntsvtypeStr vtypeStrs vtypeType vtypePTypetcRhotcCasestcApptcOverloadFailedtcPattinferRecFieldscheckRecFields tcRecFieldtcRecTypeFields subsCheckFun subsCheckTblunifyFununifyTbl allBinderstcErrortcWarn unimplementednewVar scopeTypes tc_value2termmkTcA singleTcAbindTcArunTcA$fErrorMonadTcMsubstituteLTypecheck2 computeLType getOverload pattContext checkEqLTypecheckIfEqLTypetermWith checkLookup checkModule checkInfocheckReservedId linTypeOfTypecheckRestrictedInheritancecheckCompleteGrammar buildAnyTree rebuildModule extendMod unifyMaybeL extendModule globalizeLoc unifyAnyInfo unifAbsArrity unifAbsDefs HappyAddrHappyA#HappyStk Happy_IntList HappyConsHappyAny HappyAbsSyn happyIn10 happyOut10 happyIn11 happyOut11 happyIn12 happyOut12 happyIn13 happyOut13 happyIn14 happyOut14 happyIn15 happyOut15 happyIn16 happyOut16 happyIn17 happyOut17 happyIn18 happyOut18 happyIn19 happyOut19 happyIn20 happyOut20 happyIn21 happyOut21 happyIn22 happyOut22 happyIn23 happyOut23 happyIn24 happyOut24 happyIn25 happyOut25 happyIn26 happyOut26 happyIn27 happyOut27 happyIn28 happyOut28 happyIn29 happyOut29 happyIn30 happyOut30 happyIn31 happyOut31 happyIn32 happyOut32 happyIn33 happyOut33 happyIn34 happyOut34 happyIn35 happyOut35 happyIn36 happyOut36 happyIn37 happyOut37 happyIn38 happyOut38 happyIn39 happyOut39 happyIn40 happyOut40 happyIn41 happyOut41 happyIn42 happyOut42 happyIn43 happyOut43 happyIn44 happyOut44 happyIn45 happyOut45 happyIn46 happyOut46 happyIn47 happyOut47 happyIn48 happyOut48 happyIn49 happyOut49 happyIn50 happyOut50 happyIn51 happyOut51 happyIn52 happyOut52 happyIn53 happyOut53 happyIn54 happyOut54 happyIn55 happyOut55 happyIn56 happyOut56 happyIn57 happyOut57 happyIn58 happyOut58 happyIn59 happyOut59 happyIn60 happyOut60 happyIn61 happyOut61 happyIn62 happyOut62 happyIn63 happyOut63 happyIn64 happyOut64 happyIn65 happyOut65 happyIn66 happyOut66 happyIn67 happyOut67 happyIn68 happyOut68 happyIn69 happyOut69 happyIn70 happyOut70 happyIn71 happyOut71 happyIn72 happyOut72 happyIn73 happyOut73 happyIn74 happyOut74 happyIn75 happyOut75 happyIn76 happyOut76 happyIn77 happyOut77 happyIn78 happyOut78 happyIn79 happyOut79 happyIn80 happyOut80 happyIn81 happyOut81 happyIn82 happyOut82 happyIn83 happyOut83 happyIn84 happyOut84 happyIn85 happyOut85 happyIn86 happyOut86 happyIn87 happyOut87 happyIn88 happyOut88 happyIn89 happyOut89 happyIn90 happyOut90 happyIn91 happyOut91 happyIn92 happyOut92 happyIn93 happyOut93 happyIn94 happyOut94 happyIn95 happyOut95 happyIn96 happyOut96 happyIn97 happyOut97 happyIn98 happyOut98 happyIn99 happyOut99 happyInTok happyOutTok happyExpListhappyExpListPerStatehappyActOffsetshappyGotoOffsetshappyAdjustOffsethappyDefActions happyCheck happyTablehappyReduceArr happy_n_termshappy_n_nonterms happyReduce_7happyReduction_7 happyReduce_8happyReduction_8 happyReduce_9happyReduction_9happyReduce_10happyReduction_10happyReduce_11happyReduction_11happyReduce_12happyReduction_12happyReduce_13happyReduction_13happyReduce_14happyReduction_14happyReduce_15happyReduction_15happyReduce_16happyReduction_16happyReduce_17happyReduction_17happyReduce_18happyReduction_18happyReduce_19happyReduction_19happyReduce_20happyReduction_20happyReduce_21happyReduction_21happyReduce_22happyReduction_22happyReduce_23happyReduction_23happyReduce_24happyReduction_24happyReduce_25happyReduction_25happyReduce_26happyReduction_26happyReduce_27happyReduction_27happyReduce_28happyReduction_28happyReduce_29happyReduction_29happyReduce_30happyReduction_30happyReduce_31happyReduction_31happyReduce_32happyReduction_32happyReduce_33happyReduction_33happyReduce_34happyReduction_34happyReduce_35happyReduction_35happyReduce_36happyReduction_36happyReduce_37happyReduction_37happyReduce_38happyReduction_38happyReduce_39happyReduction_39happyReduce_40happyReduction_40happyReduce_41happyReduction_41happyReduce_42happyReduction_42happyReduce_43happyReduction_43happyReduce_44happyReduction_44happyReduce_45happyReduction_45happyReduce_46happyReduction_46happyReduce_47happyReduction_47happyReduce_48happyReduction_48happyReduce_49happyReduction_49happyReduce_50happyReduction_50happyReduce_51happyReduction_51happyReduce_52happyReduction_52happyReduce_53happyReduction_53happyReduce_54happyReduction_54happyReduce_55happyReduction_55happyReduce_56happyReduction_56happyReduce_57happyReduction_57happyReduce_58happyReduction_58happyReduce_59happyReduction_59happyReduce_60happyReduction_60happyReduce_61happyReduction_61happyReduce_62happyReduction_62happyReduce_63happyReduction_63happyReduce_64happyReduction_64happyReduce_65happyReduction_65happyReduce_66happyReduction_66happyReduce_67happyReduction_67happyReduce_68happyReduction_68happyReduce_69happyReduction_69happyReduce_70happyReduction_70happyReduce_71happyReduction_71happyReduce_72happyReduction_72happyReduce_73happyReduction_73happyReduce_74happyReduction_74happyReduce_75happyReduction_75happyReduce_76happyReduction_76happyReduce_77happyReduction_77happyReduce_78happyReduction_78happyReduce_79happyReduction_79happyReduce_80happyReduction_80happyReduce_81happyReduction_81happyReduce_82happyReduction_82happyReduce_83happyReduction_83happyReduce_84happyReduction_84happyReduce_85happyReduction_85happyReduce_86happyReduction_86happyReduce_87happyReduction_87happyReduce_88happyReduction_88happyReduce_89happyReduction_89happyReduce_90happyReduction_90happyReduce_91happyReduction_91happyReduce_92happyReduction_92happyReduce_93happyReduction_93happyReduce_94happyReduction_94happyReduce_95happyReduction_95happyReduce_96happyReduction_96happyReduce_97happyReduction_97happyReduce_98happyReduction_98happyReduce_99happyReduction_99happyReduce_100happyReduction_100happyReduce_101happyReduction_101happyReduce_102happyReduction_102happyReduce_103happyReduction_103happyReduce_104happyReduction_104happyReduce_105happyReduction_105happyReduce_106happyReduction_106happyReduce_107happyReduction_107happyReduce_108happyReduction_108happyReduce_109happyReduction_109happyReduce_110happyReduction_110happyReduce_111happyReduction_111happyReduce_112happyReduction_112happyReduce_113happyReduction_113happyReduce_114happyReduction_114happyReduce_115happyReduction_115happyReduce_116happyReduction_116happyReduce_117happyReduction_117happyReduce_118happyReduction_118happyReduce_119happyReduction_119happyReduce_120happyReduction_120happyReduce_121happyReduction_121happyReduce_122happyReduction_122happyReduce_123happyReduction_123happyReduce_124happyReduction_124happyReduce_125happyReduction_125happyReduce_126happyReduction_126happyReduce_127happyReduction_127happyReduce_128happyReduction_128happyReduce_129happyReduction_129happyReduce_130happyReduction_130happyReduce_131happyReduction_131happyReduce_132happyReduction_132happyReduce_133happyReduction_133happyReduce_134happyReduction_134happyReduce_135happyReduction_135happyReduce_136happyReduction_136happyReduce_137happyReduction_137happyReduce_138happyReduction_138happyReduce_139happyReduction_139happyReduce_140happyReduction_140happyReduce_141happyReduction_141happyReduce_142happyReduction_142happyReduce_143happyReduction_143happyReduce_144happyReduction_144happyReduce_145happyReduction_145happyReduce_146happyReduction_146happyReduce_147happyReduction_147happyReduce_148happyReduction_148happyReduce_149happyReduction_149happyReduce_150happyReduction_150happyReduce_151happyReduction_151happyReduce_152happyReduction_152happyReduce_153happyReduction_153happyReduce_154happyReduction_154happyReduce_155happyReduction_155happyReduce_156happyReduction_156happyReduce_157happyReduction_157happyReduce_158happyReduction_158happyReduce_159happyReduction_159happyReduce_160happyReduction_160happyReduce_161happyReduction_161happyReduce_162happyReduction_162happyReduce_163happyReduction_163happyReduce_164happyReduction_164happyReduce_165happyReduction_165happyReduce_166happyReduction_166happyReduce_167happyReduction_167happyReduce_168happyReduction_168happyReduce_169happyReduction_169happyReduce_170happyReduction_170happyReduce_171happyReduction_171happyReduce_172happyReduction_172happyReduce_173happyReduction_173happyReduce_174happyReduction_174happyReduce_175happyReduction_175happyReduce_176happyReduction_176happyReduce_177happyReduction_177happyReduce_178happyReduction_178happyReduce_179happyReduction_179happyReduce_180happyReduction_180happyReduce_181happyReduction_181happyReduce_182happyReduction_182happyReduce_183happyReduction_183happyReduce_184happyReduction_184happyReduce_185happyReduction_185happyReduce_186happyReduction_186happyReduce_187happyReduction_187happyReduce_188happyReduction_188happyReduce_189happyReduction_189happyReduce_190happyReduction_190happyReduce_191happyReduction_191happyReduce_192happyReduction_192happyReduce_193happyReduction_193happyReduce_194happyReduction_194happyReduce_195happyReduction_195happyReduce_196happyReduction_196happyReduce_197happyReduction_197happyReduce_198happyReduction_198happyReduce_199happyReduction_199happyReduce_200happyReduction_200happyReduce_201happyReduction_201happyReduce_202happyReduction_202happyReduce_203happyReduction_203happyReduce_204happyReduction_204happyReduce_205happyReduction_205happyReduce_206happyReduction_206happyReduce_207happyReduction_207happyReduce_208happyReduction_208happyReduce_209happyReduction_209happyReduce_210happyReduction_210happyReduce_211happyReduction_211happyReduce_212happyReduction_212happyReduce_213happyReduction_213happyReduce_214happyReduction_214happyReduce_215happyReduction_215happyReduce_216happyReduction_216happyReduce_217happyReduction_217happyReduce_218happyReduction_218happyReduce_219happyReduction_219happyReduce_220happyReduction_220happyReduce_221happyReduction_221happyReduce_222happyReduction_222happyReduce_223happyReduction_223happyReduce_224happyReduction_224happyReduce_225happyReduction_225happyReduce_226happyReduction_226happyReduce_227happyReduction_227happyReduce_228happyReduction_228happyReduce_229happyReduction_229happyReduce_230happyReduction_230happyReduce_231happyReduction_231happyReduce_232happyReduction_232happyReduce_233happyReduction_233happyReduce_234happyReduction_234happyReduce_235happyReduction_235happyReduce_236happyReduction_236happyReduce_237happyReduction_237happyReduce_238happyReduction_238happyReduce_239happyReduction_239happyReduce_240happyReduction_240happyReduce_241happyReduction_241happyReduce_242happyReduction_242happyReduce_243happyReduction_243happyReduce_244happyReduction_244happyReduce_245happyReduction_245happyReduce_246happyReduction_246happyReduce_247happyReduction_247happyReduce_248happyReduction_248happyReduce_249happyReduction_249happyReduce_250happyReduction_250happyReduce_251happyReduction_251happyReduce_252happyReduction_252happyReduce_253happyReduction_253happyReduce_254happyReduction_254happyReduce_255happyReduction_255happyReduce_256happyReduction_256happyReduce_257happyReduction_257happyReduce_258happyReduction_258happyReduce_259happyReduction_259happyReduce_260happyReduction_260happyReduce_261happyReduction_261happyReduce_262happyReduction_262happyReduce_263happyReduction_263happyReduce_264happyReduction_264happyReduce_265happyReduction_265happyReduce_266happyReduction_266happyReduce_267happyReduction_267happyReduce_268happyReduction_268happyReduce_269happyReduction_269happyReduce_270happyReduction_270happyReduce_271happyReduction_271happyReduce_272happyReduction_272 happyNewToken happyError_ happyThen happyReturn happyThen1 happyReturn1 happyError'pModDefpTopDef pModHeaderpTermpExp pBNFCRules pEBNFRuleshappySeq happyErrormkListIdmkConsIdmkBaseId listCatDeftryLocmkR mkOverload isOverloading checkInfoTypemkAltsmkL happyParse happyAccept happyDoActionindexShortOffAddrhappyLt readArrayBit happyShifthappySpecReduce_0happySpecReduce_1happySpecReduce_2happySpecReduce_3 happyReducehappyMonadReducehappyMonad2Reduce happyDrop happyDropStk happyGoto happyFail notHappyAtAll happyTcHack happyDoSeq happyDontSeqreadCommandLine pCommandLinepPipepCommandpOptionpValue pFilename pArgumentpArgTermpSystemCommandpTheRestfailIO$fErrorMonadIO$fOutputStateT $fOutputIO appCommand interpret getCommand CommandEnvcommands commandmacros expmacros mkCommandEnvinterpretCommandLine interpretPipegetCommandInfo checkOptsgetCommandTreescf2pgfcf2abstrcf2concr mkRuleName ProtoFCatPathSchemavariantschoicesgetAllParamValuesFunSetProdSetPMCFGEnvSeqSetPFCatCProjCSelCNilCRecCTblCStrCParCnvMonadCMunCMBranchVariantReturn generatePMCFGmapAccumWithKeyMaddPMCFGfloc pgfCncCat runCnvMonad protoFCatgetFIds catFactorcomputeCatRangeppPath reversePath convertTerm convertArg convertRec convertTblgoBgoV addSequencesB addSequencesV mapAccumL' addSequenceevalTerm getVarIndex emptyPMCFGEnv addFunctiongetPMCFG restrictArg restrictHeadrestrictProtoFCatmkArray mkSetArrayppU $fShowSchema$fFunctorCnvMonad$fMonadState(,)CnvMonad$fMonadCnvMonad$fApplicativeCnvMonad mkCanon2pgfmi2imkExpmkPatt mkContextmkDefmkArity genCncCats genCncFuns genPrintNames mkMapArray writeTags getLocalTags getImports gftagsFile gf2gftags decodeFile'addFPath gfoVersion gfoBinVersion$fFunctorVersionTagged$fBinaryVersionTagged $fBinaryLabel $fBinaryTInfo $fBinaryTerm $fBinaryL$fBinaryLocation $fBinaryInfo $fBinaryPMCFG$fBinaryOptions$fBinaryModuleStatus$fBinaryOpenSpec$fBinaryMInclude$fBinaryModuleType$fBinaryModuleInfo$fBinaryGrammar$fBinaryModuleName $fBinaryIdent getAllFilesgetOptionsFromFile CompStatusCSCompCSReadCSEnvModEnvModName gfImports gfoImports selectFormatimportsOfModuleparseModHeader parseSourcetoUTF8 recodeToUTF8 getPragmas getFilePath TemporaryTemprunPreprocessorbuiltin_preprocessors mkPresent mkMinimal omit_lines writeTempreadTempkeepTemp removeTemp CompileSourcecompileSourceModulewriteGFO intermOutidumpwarnOut CompileEnv compileModule compileOne'emptyCompileEnvextendCompileEnv importGrammar ioUnionPGF importSourceimportCF CollectOutputCOunCOHiderevealIOCacheopcachesetJobs batchCompile1 splitEither canonicalgetPathFromFile relativeTo newIOCache readIOCache$fErrorMonadCollectOutput$fOutputCollectOutput$fMonadIOCollectOutput$fMonadCollectOutput$fApplicativeCollectOutput$fFunctorCollectOutput $fOrdHide$fEqHideMonadSIOrunSIOhRunSIOGHC.IO.Handle.FDstdout captureSIOliftSIOSIOunSPutStr restrictedrestrictedSystem restrictedIOlift0lift1putStr putStrFlushputStrLn putStrLnFlushprint getCPUTime newStdGenlazySIOreadPGF2 $fMonadSIOt $fMonadSIOSIO $fOutputSIO $fMonadSIO$fApplicativeSIO $fFunctorSIO HasPGFEnv getPGFEnvPGFEnvconcspgfEnv emptyPGFEnv pgfCommands prLexcLexiconprFullFormLexicon prAllWordsprMorphoAnalysishsExprcExprneedPGF$fTypeCheckArgmcommonCommands stringOpsenvFlagstringOpOptionstrietoStringtoLines toParagraphs HasGrammar getGrammarsourceCommandscheckComputeTermloopreadAndExecute1True readCommandoptionallyShowCPUTimeexecute1 execute1' moreCommandsGFEnvCompletionTypeCmplCmdCmplStrCmplOpt CmplIdent startOptspgfenv commandenvhistoryShellMbeQuietshellpwordsimport_printException fetchCommand importInEnv tryGetLineprompt emptyGFEnvemptyCommandEnv multigrammar allCommandswordCompletionwc_type$fHasPGFEnvStateTmake_facfgToFA' sortSubLatscompileAutomatamake_fa1addStatesForCatsMFA MutRecSets MutRecSetmrCats mrNonRecRules mrRecRulesmrRec RecursivityRightRLeftRNotRcfgToFAcompileAutomatoncfgToMFAbuildMFA mfaStartDFAmfaToDFAremoveUnusedSubLats subLatUseMap usedSubLats mutRecSets revMultiMapProfile bnfPrintertoBNFpgfToCFG regexpPrintermultiRegexpPrinterprREsmfa2resSLFWord slfSubPrinter isNonWordSLF_FASLFEdgeeIdeStarteEndSLFNode SLFSubLatnIdnWordnTagnLatSLFslfNodesslfEdgesSLFsmkFAs slfStyleFAslfGraphvizPrinterslfSubGraphvizPrintergvSLFFA slfPrinterautomatonToSLFmfaNodeToSLFNode mkSLFNode mkSLFSubLat mkSLFEdgeprSLFsprSLFprOneSLFshowWordprFieldsSRGNTSRGAltsrgName srgStartCat srgLanguagemakeNonLeftRecursiveSRG renameCats mergeItems SRGSymbolSRGItemSRGRuleSRGsrgExternalCatssrgRules ebnfPrintermakeSRGsetDefaultCFGTransformmaybeTransformmakeNonRecursiveSRGmkSRGcfRulesToSRGRule srgLHSCat isExternalCatsrgItem groupTokens ungroupTokensprSRG lookupFM_width gslPrinterprGSLprItemprSymbolprCat firstToUpper showTokencomment emptyLine$++$SISRTagprSISR topCatSISRprofileInitSISRusedArgscatSISRprofileFinalSISRfmtOutfmtReffieldasstreeobj jsgfPrinterprJSGFaltsrule prepunctuatesrgsAbnfPrintersrgsAbnfNonRecursivePrintershowDocprABNFmetasrgsXmlPrintersrgsXmlNonRecursivePrinter prSrgsXmlmkItemsymItemoneOfgrammar optimizeSRGS grammar2vxml CatQuestionsSkeleton pgfSkeleton catQuestions catQuestiongetCatQuestion skel2vxml grammarURIcatFormscat2formfun2sub catFormIdvxmlform subdialogfilled vxmlGrammar promptStringreturn_block blockCondparam outputConcrinfinitymos treeOpOptions treeOpFlagstranslationQuizmorphologyQuiz viewGraphviz viewLatexstanzascompileSourceFilescompileCFFiles unionPGFFiles writeOutput grammarName grammarName' outputJustPGF outputPathwritingCncJmentPaLCLiIgnored parseModule convModule convAbstract convExtends convExtend convAbsJments convAbsJmentconvSimpleTypeconvId convModId convConcrete convOpensconvOpen convCncJments convCncJmentconvBind jmentList jmentLocationlocnewCache flushCache expireCache listCache readCache readCache'FileInfo cacheLoad cacheObjectsfst3%cgi-3001.3.0.3-3b0EWsaW2Rg7XlmyfCRkXC Network.CGI setHeader readInputgetInputrequestAcceptLanguagegetVarWithDefault outputError handleErrors outputFPSoutputNetwork.CGI.Accept negotiateAcceptNetwork.CGI.MonadcatchCGIthrowCGIrunCGITNetwork.CGI.Protocol CGIRequestcgiVars cgiInputscgiRequestBodyInput inputValue inputFilenameinputContentType CGIResult CGIOutput CGINothing&multipart-0.1.3-158bh73MXnfBVNPhlQ2kmqNetwork.Multipart.Header ContentType ctParameters ctSubtypectType HeaderNameHeadersCGIError cgiErrorCodecgiErrorMessage cgiErrorTextlogError stderrToFile throwCGIErrorhandleCGIErrors outputJSONPoutputEncodedJSONP outputPNG outputBinary outputBinary' outputHTML outputPlain outputText outputStrictsetXO$fExceptionCGIError newPGFCachecgiMaincgiMain'doPossibilitiesdoProvideExampledoAbstractExampleabstractExampledoTestFunction readParsePGF parseEnvirongetInpm2r readResultenviron instExpMetainstMeta $fJSONExpr $fJSONCIdcToATreeunlexerjsonExprlinearizeTabularToATreeshowTreeTreeOptsToFromUnlexerCachespgfCache labelsCachecncLabelsCache cpgfCachecatchIOEwithQSemlogFile flushPGFCache listPGFCache labelsCaches newCache'getPathoptionalCpgfMaingetFilecpgfMainpgfMainout getInput1nonEmpty textInput getLangs'getLang'limitstarttreeoptsgetBooltoBoolmissingerrorMissingIdnotFound badRequestthrowformat doExternaldoLookupMorpho doTranslatejsonTypeErrorsdoTranslateGroupdoParseaddTrieaddTree doCompletecompletionInfo doLinearize doLinearizesdoLinearizeTabulardoRandom doGenerate doGrammaroutputGraphviz abstrTree parseTree doDepTree getLabels getCncLabelstryIO alignmentpipeIt2graphviz browse1jsondoBrowseparse' complete'transferlinearizeAndUnlexselectLanguagelangCodeLanguage%$fJSONBracketedString $fJSONTrie $fToATreeExpr$fToATreeExpr0 $fJSONExpr0 documentRootportrunHTTP cgiHandlerhttpRespcgiReqHMserver ok_access ok_to_delete removeDirdebug gf_versionrunget_qs get_stateput_qs put_state hmbracket_ jsonresultserveStaticFileserveStaticFile' logPutStrLnjsonpok200ok200'json200json200' jsonp200'html200resp204resp301resp400resp404resp500resp501plain plainUTF8jsonUTF8 jsonpUTF8htmlUTF8ctcsutf8xolocationcontentTypeFromExt updateFile newDirectorysetDir utf8inputsdecodedrawinputs$fErrorResponseretainCmdEnv emptyCmdEnv$fHasGrammarStateT