SYD      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABC Safe-Inferred/DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqr/DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqr  Safe-Inferred stuvwxyz{|}stu stuvwxyz{|}u  Safe-Inferred~GCreate a new cache that uses the given function to read and parse filesForget all cached objectsJForget cached objects that have been unused for longer than the given timeList currently cached files_Lookup a cached object (or read the file if it is not in the cache or if it has been modified)Like 8, but also return the last modification time of the file ~~ ~  Safe-InferredDecode hexadecimal escapes(Decode application/x-www-form-urlencoded"Decode "+" and hexadecimal escapes   Bjorn Bringert (stability) (portability) Safe-InferredRun 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.Like A, but always returns (), whether the computation fails or not."Run an action with SIGINT blocked. BB(stable) (portable) Safe-Inferred 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.  Safe-InferredNone Safe-Inferred**  Safe-InferredPL(stable) (portable) Safe-Inferred246HM               AR(stable) (portable) Safe-Inferred Safe-Inferred !"#$%&'()*+,-./0123& !"#$%&'()*+,-./0123 Safe-Inferred!456789:;<=>?@ABCDEFGHIJKLMNOPQRST:;<>?456789:;<=>?@ABCDEFGHIJKLMNOPQRST Safe-InferredUVWXYUVUVWXY Safe-InferredZ[\Z[\Z[\ Safe-Inferred]]](c) Sven Panne 2002-2005/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportable Safe-Inferred ^sDescribes whether an option takes an argument or not, and if so how the argument is injected into a value of type a._optional argument`option requires argumentano argument expectedbEach b describes a single option.The arguments to c are:list of short option characters*list of long option strings (without "--")argument descriptorexplanation of option for userd-What to do with options following non-optionsewrap non-options into optionsf*freely intersperse options and non-optionsg+no option processing after first non-optionhReturn a string describing the usage of a command, derived from the header (first argument) and the options described by the second argument.ipProcess the command-line, and return the list of values that matched (and those that didn't). The arguments are:The order requirements (see d)The option descriptions (see b):The actual command line arguments (presumably got from ).ij returns a triple consisting of the option arguments, a list of non-options, and a list of error messages.jThis is almost the same as i, 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.klmnop^_`abcdefghqrsijtuvwxy ^_`abcdefghijkponml^a`_bcdgfehqrsijtuvwxyNonez{|}~z{|}~ z{|}~Bjorn Bringert (stability) (portability) Safe-Inferred Safe-Inferred %  Safe-Inferred AR(stable) (portable) Safe-InferredLike  type with error msgs Analogue of  Analogue of  fromMaybe added by KJadded 2/10/2003 by PEB ! Safe-Inferred  " Safe-Inferred Safe-Inferred  !"#$%&  %$#"!    !"#$%  # Safe-Inferred+JSet the console encoding (for Windows, has no effect on Unix-like systems) &'()*+,-&'()*+,-&'()*+,-$ Safe-Inferred./././% Safe-Inferred=Feed some input to a shell process and read the output lazily shell commandinput to shell commandoutput from shell command& Safe-Inferred0Attaching location information 0123456789:; 0123456789:;0125436789:; Safe-Inferred2468 <-Haskell representation of the GF record type {s:t}>#Overloaded function to project the s field from any record typeATokensI4Token sequences, output form linearization functionsJ/For enumerating parameter values used in tablesLTablesMRender a token sequence as a NCoerce from any record type  {...,s:t,...} field to the supertype {s:t}OConcatenation with variantsP#Selection from tables with variants<=>?@2To be matched with the prefix of a following tokenABCDEFGHIJKLMNOPQRST<=>?@ABCDEFGHIJKLMNOPQRJKLIAHGFEDCB@M>?<=TSNOPQR<=>?@AHGFEDCBIJKLMNOPQRSTO Safe-Inferred UQText lexing with standard word capitalization of the first word of every sentenceVFText lexing with custom treatment of the first word of every sentence.X.Bind tokens separated by Prelude.BIND, i.e. &+Y#Haskell lexer, usable for much code[ILaTeX lexer in the math mode: should not be separated from the next word\CLaTeX style lexer, with "math" environment using Code between $...$^Capitalize first letter_Uncapitalize first letter`,Unquote each string wrapped in double quotesUVWXYZ[\]^_`abcdeUVWXYZ[\]^_`abcdeUVWXYZ[\]^_`abcdeUVWXYZ[\]^_`abcde' Safe-Inferred Safe-InferredfLike (), 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/54411g8Replace all occurences of an element by another element.fgfgfgfg*PL(stable) (portable) Safe-Inferred Like 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.&     glue lists to join(fg     &     +BB(stable) (portable) Safe-Inferred'Keeps both incoming and outgoing edges.0Creates a relation from a list of related pairs.UCreates a relation from a list pairs of elements and the elements related to them.Add a pair to the relation. $Add a list of pairs to the relation.!+Checks if an element is related to another."<Get the set of elements to which a given element is related.#!Get all elements in the relation.$=Keep only pairs for which both elements are in the given set.%Uses #&8Get the set of elements which are related to themselves.'7Keep the related pairs for which the predicate is true.($Remove keys that map to no elements.):Get the equivalence classes from an equivalence relation. *Returns + if there are cycles, and , if there are cycles.-Removes an element from a relation. Returns the new relation, and the set of incoming and outgoing edges of the removed element.$./ !"#0$12+The set over which the relation is defined.%345&'()6789:*;<=>?-@A.!"12%345&)6789:*<$./ !"#0$12%345&'()6789:*;<=>?-@A,AR(stable) (portable) Safe-Inferred n Add msg s to  failuresv@this is what happens when matching two values in the same moduleThomas Hallgren's wrap lines is the same as B!!! 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 ()C(if the first check fails try another one9hijklmnopqrstuvwxyz{|}~CD<hijklmnopqrstuvwxyz{|}~6hijklmnopqrstuvwxyz{|}~CD-AR(stable) (portable) Safe-InferredEta variant can itself be a token list, but for simplicity only a list of strings i.e. not itself containing variantsFLnotice 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 otherG"variants depending on next string HCabstract token list type. AR 2001, revised and simplified 20/4/2003Ito handle a list of variantsJ'to create the list of all lexical itemsEFGKHLMNOPQRISTUVWXYZJFGKHLPQRISUVWXYJEFKGHLMNOPQRISTUVWXYZJ.BB(stable) (portable) Safe-Inferred[KGraph type, graph ID, graph attirbutes, graph nodes, graph edges, subgraphs \]^_`abc[defghijklmnopqrstuvwxyz\]^_`abc[defghijklmn\]^_`acb[defghijklmnopqrstuvwxyz/BB(stable) (portable) Safe-Inferred {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.1{Start node label|}~Infinite 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.%{|}~0{|}~0 Safe-Inferred  1 Safe-InferredREConcat [] is epsilonREUnion [] is null2 Safe-InferredWAn 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  3 Safe-Inferredfloating point constantinteger constantstring constant)& 4 Safe-InferredP represents a hypothesis in a type i.e. in the type A -> B, A is the hypothesis To read a type from a , use . Reads a  from a . renders type as ~. The list of identifiers is the list of all free variables in the expression in order reverse to the order of binding. ocreates 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_m 1creates hypothesis for non-dependent type i.e. A 3creates hypothesis for dependent type i.e. (x : A) Lcreates hypothesis for dependent type with implicit argument i.e. ({x} : A)              5 Safe-Inferred 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. oThe 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. OThe pattern is used to define equations in the abstract syntax of the grammar. implicit argument in pattern  wildcard variable@pattern  variable literal Dapplication. The identifier should be constructor i.e. defined with 'data'  implicit argument in expression local type signature variable with de Bruijn index function or data constructor meta variable literal  application lambda abstraction fTree is the abstract syntax representation of a given sentence in some concrete syntax. Technically  is a type synonym of . parses  as an expression renders expression as ~. The list of identifiers is the list of all free variables in the expression in order reverse to the order of binding. IConstructs an expression by applying a function to a list of expressions 6Decomposes an expression into application of function cDecomposes 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 literal 2Constructs an expression from real number literal 2Decomposes an expression into real number literal 0Constructs an expression which is meta variable 0Checks whether an expression is a meta variable %Compute an expression to normal form G !"#$%&'()*+,-./0123456789:;<=>?G !"#$%&'()*+,-./0125678:;<=- !"#$%&'/.-,+*)(0123456789:;<=>?6 Safe-InferredThis 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 = ...@value of a flagA5type, arrity and definition of function + probabilityB 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.BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi@ABjklmnopqrstuvw !"#$   ()*+,-./0125678CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi@ABjklmnopqrstuvwCDEFGHILKJM XWVUTSRQPONYZ [\]^_`abcdefghi@ABjklmnopqrstuvw7 Safe-InferredbBracketedString 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 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.$this is the leaf i.e. a single tokenAList 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.x7The length of the bracketed string in number of tokens.0yz{|}~x0yz{|}~x'yz{~}|x8 Safe-Inferred35Linearizes 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 language\Creates a table from feature name to linearization. The outher list encodes the variations9Krasimir Angelov(stable) (portable) Safe-Inferred246HMmIf an error occurs in the typechecking phase the type checker returns not a plain text error message but a % structure which describes the error.%There is a goal that cannot be solved<Implicit argument was passed where the type doesn't allow itQSome metavariables have to be instantiated in order to complete the typechecking.6It is not possible to infer the type of an expression.BSomething that is not of function type was applied to an argument.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.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. Unknown function name was found. Unknown category name was found.<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.M1; < Safe-InferredOGenerates 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.   =KA(stable) (portable) Safe-Inferred/Renders abstract syntax tree in Graphviz format! > Safe-InferredhAn 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          ? Safe-Inferred         @Krasimir Angelov stable  portable  Safe-Inferred2This 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.       x         ANone3HMbAn abstract data type whose values represent the state in an incremental parser after an error. [An abstract data type whose values represent the current state in an incremental parser. SThis data type encodes the different outcomes which you could get from the parser. >The sentence is not complete. Only partial output is produced |If the parsing and the type checking are successful we get a list of abstract syntax trees. The list should be non-empty. TThe 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. IThe integer is the position in number of tokens where the parser failed. AThe 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. NCreates 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 StringM 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. #VIf 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. &UReturn the Continuation of a Parsestate with exportable types Used by PGFService 5 !"#$%&' !"#$%()*+,-./0123&&' !"#$%&" !"#$%&' !"#$%()*+,-./0123&BNone456789:45456789:C Safe-Inferred3;<=>?@ABCDEFGHIJKLMN;>?EKLM;<=>?@ABCDEFGHIJKLMND Safe-InferredOThe 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.P meta variableQliteralRfunction applicationSvariableT6lambda abstraction. The list of variables is non-emptyUaConverts a tree to expression. The conversion is always total, every tree is a valid expression.VConverts an expression to tree. The conversion is only partial. Variables and meta variables of function type and beta redexes are not allowed. OPQRSTUVW OPQRSTUVWOTSRQPUVWEAR(stable) (portable) Safe-InferredXConverts a pattern to tree. Y'Z[\]^_`X'Z Y'Z[\]^_`XF Safe-InferredabcdefghhabcdefghGNone'ijklmnopqrstuvwxyz{|}~HNone+ INoneJLennart KolmodinBSD3-style (see LICENSE),Lennart Kolmodin <kolmodin@dtek.chalmers.se> experimentalportable to Hugs and GHC.None;HThe Get monad is just a State monad carrying around the input ByteStringThe parse stateRun the Get monad applies a %-based parser on the input ByteStringRun the Get monad applies a -based parser on the input ByteString. Additional to the result of get it returns the number of consumed bytes and the rest of the input. Skip ahead n bytes. Fails if fewer than n bytes are available. Skip ahead n- bytes. No error if there isn't enough bytes.Run ga4, but return without consuming its input. Fails if ga fails.Like , but consume the input if gma returns 'Just _'. Fails if gma fails.Like , but consume the input if gea returns 'Right _'. Fails if gea fails.Get the next up to n5 bytes as a lazy ByteString, without consuming them. 1Get 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 5 method for strict ByteStrings. Fails if fewer than n bytes are left in the input. An efficient ; 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.lSplit 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 important!Read a Word8 from the monad state"Read a Word16 in big endian format%Read a Word16 in little endian format"Read a Word32 in big endian format%Read a Word32 in little endian format"Read a Word64 in big endian format%Read a Word64 in little endian formatO(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.O(1).? Read a 2 byte Word16 in native host order and host endianness.O(1).8 Read a Word32 in native host order and host endianness.O(1).7 Read a Word64 in native host order and host endianess.0-KLennart Kolmodin, Ross PatersonBSD3-style (see LICENSE),Lennart Kolmodin <kolmodin@dtek.chalmers.se> experimentalportable to Hugs and GHCNone;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 LM 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 .O(1). The empty Builder, satisfying   = O(1).+ A Builder taking a single byte, satisfying  ( b) =  bO(1).L The concatenation of two Builders, an associative operation with identity  , satisfying  ( x y) =  ( x) ( y)O(1). A Builder taking a  , satisfying  ( bs) =  [bs]O(1). A Builder taking a lazy  , satisfying  ( bs) = bsO(n). Extract a lazy  from a P. The construction work takes place if and when the relevant part of the lazy  is demanded.O(1). Pop the N we have constructed so far, if any, yielding a new chunk in the result lazy .&Sequence an IO operation on the bufferGet the size of the buffer&Map the resulting list of bytestrings.Ensure that there are at least n many bytes available. Ensure that n( many bytes are available, and then use f& to write some bytes into the memory. Ensure that n( many bytes are available, and then use f0 to write some storable values into the memory.#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 formatO(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.]Write a Word16 in native host order and host endianness. 2 bytes will be written, unaligned.]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.$!NLennart 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  monadRun the  monad with a serialiserRun 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 formatO(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.                 ONoneB3!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS 456789?@AB&!"#$%&'()+*,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSPLennart KolmodinBSD3-style (see LICENSE),Lennart Kolmodin <kolmodin@dtek.chalmers.se>unstableFportable to Hugs and GHC. Requires the FFI and some flexible instancesNone234(The Binary class provides T and U, 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 U and Tj methods should be the inverse of each other. A range of instances are provided for basic Haskell types. T Encode a value in the Put monad.UDecode 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 . encode,8Lazily 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 f4V(TU)*+W,XYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ (TU)*+W,X2V(TU)*+W,XYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~QNone''RNoneKrasimir AngelovstableportableNone-+A type for tries of plain applicative trees0"A type for plain applicative trees34Reads file in Portable Grammar Format and produces . structure. The file is usually produced with: $ gf -make <grammar file name>4eTries to parse the given string in the specified language and to produce abstract syntax expression.5 The same as 6# but does not return the language.6Tries 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.7 The same as 4& but returns more detailed information89This is an experimental function. Use it on your own risk:HThe abstract language name is the name of the top-level abstract module;5List 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 syntaxA2List of all functions defined for a given categoryBThe type of a given functionC%Converts an expression to normal formE Convert a  to an 0F#Combine a list of trees into a trie-./0123456789:;<=>?@ABCDEF      !"#$%&'-./0123456789:;<=>?@ABCDEF3;:<=>?@AB946578C'"#$ !%&     D021-/.EF-/.0213456789:;<=>?@ABCDEFSNoneA metavariableA lambda-bound variable-The result of the n:th (0-based) non-terminal Application1A lambda abstraction. The Int is the variable id.*an abstract syntax function with argumentsRemoves 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 probabilities6Keeps 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.AeIf 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-linearityThe categories to consider$The rule to check for left-linearity   A          1          TNone                   ! " # $ %                   ! " # $ %                    ! " # $ %UNone & ' ( ) * + , - . / & ) & ' ( ) * + , - . /VAR(stable) (portable)None$ 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 9 : ; < = > ? @ A D E F 0 5 4 3 2 1 6 7 8 9 A @ ? > = < ; : B C D E F G H I J K L M N O P Q R SWNone T U V W X Y Z [ \ ] [ ] T U V W X Y Z [ \ ]XAR(stable) (portable)None ^Ncompare answer to the list of right answers, increase score and give feedback  _ ` a b ^ c d ` a b _ ` a b ^ c dYNone e f g e f g e f gZNone hKLexers with a text lexer that tries to be a more clever with the first word iStandard lexers j,Render trees as JSON with numbered functions k%tabulate all variants and their formsT l m n o p q r s t u v w x y z { | } ~ h i  j k  v w x y { | }R l m n o p q r s t u v w x y z { | } ~ h i  j k   [None2  )   \unstableNone9fg !"#$   ()*+,-./0125678CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi@ABjklmnopqrstuvwyz{|}~x45;>?EKLM     456789?@AB(TU)*+W,X]AR(stable) (portable)None GbIdentifiers are stored as UTF-8-encoded bytestrings. (It is also possible to use regular Haskell @s, with somewhat reduced performance and increased memory use.)Hthe constructors labelled INTERNAL: are internal representation never returned by the parser INTERNAL* argument of cat with bindings at position INTERNAL argument of cat at position INTERNAL variable wildcardLbelow this constructor: internal representation never returned by the parser 0raw identifier after parsing, resolved in RenameI Module namesQXThis function should be used with care, since the returned ByteString is UTF-8-encoded.[to mark argument variables^used in lin defaults_refreshing variables)G H IJK LMNOPQRSTUVWXYZ[\]^_` a GHIJKLMNOPQRSTUVWXYZ[\]^_`a!G H IJK LMNOPQRSTUVWXYZ[\]^_` a ^None;                           ! " # $ % & ' ( ) * + , - . / 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 { | } ~  S              ! " # $ % & ' ( ) * + , - . / 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 [ \ ] ^ _ j p q r s.                    J _ ^ ] \ [ Z Y X W V U T S R Q P O N M L K J I H G F E D C B A @ ? > = < ; : 9 8 7 6 5 4 3 2 1 0 / . - , + * ) ( ' & % $ # " !           ` 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 { | } ~  _ kr.angelov(stable) (portable)None8 8 8 `None- BPretty print atomically (i.e. wrap it in parentheses if necessary) Patterns  Expressions Type expressions ,A type constructor applied to some arguments Top-level declarations6 -        aNone#SISR Working draft 1 April 2003 >http://www.w3.org/TR/2003/WD-semantic-interpretation-20030401/:Pretty-print the options that are preserved in .gfo files.:Pretty-print the options that are preserved in .pgf files. Option descriptionsThis 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.b cdefghijklmnopqrstuvwxyz{|}~   list of string argumentslist of string arguments            bcdefghijklmnopqrstuvwxyz{|}~=b c%defghijklmnopqrstuvwxyz{|}~                bAR(stable) (portable)None\ record label0to guide computation and type checking of tables.just one wild card pattern, no need to expand expanded$type annontated, but can be anything%received from parser; can be anything <Measured pattern (paired with the min & max matching length)Patternscharacter list: ["aeiou"]string of length one: ?repetition of token part: p*sequence of token parts: p + qsequence of token parts: p + qdisjunctive pattern: p1 | p2 negated pattern: -p inaccessible pattern .placeholder for pattern for implicit argument {p} as-pattern: x@p type-annotated patternfloat literal pattern: 1.2 -- only abstractinteger literal pattern: 12 -- only abstractstring literal pattern: "foo" -- only abstractrecord pattern:  {r = p ; ...} -- only concretewild card pattern: _variable pattern: xpackage constructor pattern:  P.C p1 ... pn P.C constructor pattern:  C p1 ... pn C %error values returned by Predef.errorconditioning prefix strings: strs {s ; ...}alternatives by prefix: pre {t ; s/c ; ...} alternatives in free variation: variants { s ; ... }&ad hoc overloading generated in Rename!boxed linearization of type Ident!boxed linearization type of Identpattern type: pattern T"pattern (in macro definition): # p agglutination: s + t!concatenation: s ++ t"$qualified constructor from a package#!qualified constant from a package$local definition: let {t : T = a} in b% selection: t ! p&!table given as course of values: table T [c1 ; ... ; cn]' table: table {p => c ; ...}( table type: P => A) extension:  R ** {x : A} (both types and terms)* projection: r.p+ record: { p = a ; ...}, record type: { p : A ; ...}-!example-based term: @in M.C "foo".type-annotated term9below this, the constructors are only for concrete syntax/function type:  (x : A) -> B, A -> B, ({x} : A) -> B0"placeholder for implicit argument {t}1metavariable: ?i (only parsable: ? = ?0)2 abstraction: x -> b3 application: f a4the empty string []5string literal or token: "foo"6floating point literal7integer literal8 basic type9 constructor:constant;variable@#the constructors are judgements in abstract syntax (ABS) resource (RES)concrete syntax (CNC)and indirection to module (INDIR)A(INDIR) the   says if canonicalB(CNC) type info added at TCC(CNC) lindef ini'zed, D(RES) idents: modules inheritedE(RES)F(RES+) to mark parameter constructors for lookupG(RES5) the second parameter is list of all possible valuesH(ABS+) type, arrity and definition of a functionI(ABS) context of a categoryXencoding the type of the modulemModulesn;A grammar is a self-contained collection of grammar modulesuinitial dependency listvall dependencieswGselect just those modules that a given one depends on, including itselfxIall modules that a module extends, directly or indirectly, with restrictsy the same as x, plus that an instance extends its interface 2initial search path: the nonqualified dependencies},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        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn opqrstuvwxy z{|}~ 01234589:;I      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~D       %;:9876543210/.-,+*)('&%$#"! <=>?@ IHGFEDCBAJKLMNPOQSRTWVUX]\[ZY^_`a bcdefghijklmn opqrstuvwxy z{|}~ cNone                             dAR(stable) (portable)None ! " # $ % & ' ( ) * + , - . / 0 ! " # $ % & ' ( ) * + , - . / 0 ! " # $ % + * ) ( ' & , - . / 0eKrasimir Angelov  (stable)  (portable) None3$ 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G! 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F GfAR(stable) (portable)None default linearization typerefreshing variables!trying to preserve a given symbol*quick hack for refining with var in editor%create a terminal for concrete syntax!create a terminal from identifier&to define compositional term functions&to define compositional term functions;to gather ultimate cases in a table; preserves pattern listCto get a string from a term that represents a sequence of terminalsVto print an Str-denoting term as a string; if the term is of wrong type, the error msg to find the word items in a termHdependency check, detecting circularities and returning topo-sorted listeeegAR(stable) (portable)NoneU01234589:;GHIJKLMNOPQRSTUVWXYZ[\]^_`a       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ ! " # $ % & ' ( ) * + , - . / 0hAR(stable) (portable)None H I J K L M N O P Q R J H I J K L M N O P Q RiAR(stable) (portable)None& 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 T W X Y Z [ \ ] ^ _ ` a b c d e f g k n p r u S T U V W g f e d c b a ` _ ^ ] \ [ Z Y X h i j k l m n o p q r s t u v w xjNone y z y z y zkAR(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 }3to search matching parameter combinations in tables ~  { | } ~   ~  { | }lAR(stable) (portable)None   mAR(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   nNone   oNone    pAR(stable) (portable)None3   qNone    rAR(stable) (portable)NoneWas: ,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 i or   in the   monad. To catch all   exceptions, use / instead.GPrint the error message and return a default value if the IO operation  s RBecause GHC adds the confusing text "user error" for failures caused by calls to  . :Make raise and handle mimic behaviour of the old IOE monad$  #the directory portion of a pathname    !"#$ %      !"#$       !"#$ sKrasimir Angelov  (stable)  (portable) None**Read just the module header, the returned m will have an empty body like ,; but adds file name to error message if there was an error iAdds file name to error message if there was an error, | but laziness can cause errors to slip through %&'( )*+ %&'()*+%'&( )*+ None&'()*+,-./0123456789:;hijklmnopqrstuvwxyz{|}~()*+,bcdefghijklmnopqrstuvwxyz{|}~      !"#$6725430189:;bcdefghijklmnopqrstuvwxyz{|}~nopqhijkuwvrstlxyz{|}~m      !"#$./+,&'()*-()*+,t (Maintainer)(stable) (portable)None Report a fatal error &warnings should be reversed in the end %Report a nonfatal (accumulated) error 6Turn a fatal error into a nonfatal (accumulated) error *Turn accumulated errors into a fatal error .Run an error check, report errors and warnings ;Run an error check, report errors and (optionally) warnings lAugment error messages with a relative path to the source module and an contextual hint (which can be left )                                       uAR(stable) (portable)None Dthis gives top-level access to renaming term input in the cc command Avars not needed in env, since patterns always overshadow old vars          ! " # $  %            ! " # $  %vNone &(light-weight substitution for dep. types '.compositional check/infer of binary operations ( ) * + , - . & / ' 0 1 2 ( ) + 0 ( ) * + , - . & / ' 0 1 2wAR(stable) (portable)None 3,invariant way of creating TCEnv from context 3 4 5 6 7 8 9 : ; < = : ; < = 3 4 5 6 7 8 9 : ; < =xNone >]Invariant: if the third argument is (Just rho), then rho is in weak-prenex form ?1(subsCheck scope args off exp) checks that off, is at least as polymorphic as 'args -> exp' @5Invariant: the second argument is in weak-prenex form A*Invariant: tv1 is a flexible type variable BIInstantiate the topmost for-alls of the argument type with metavariables C9Quantify over the specified type variables (all flexible) DiThis function takes account of zonking, and returns a set (no duplicates) of unbound meta-type variables EaThis function takes account of zonking, and returns a set (no duplicates) of free type variables F%Eliminate any substitutions in a term4 G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ > ? @ _ ` a A B b C c d e f g h i j k l m n D E F o p q U V. G H I J L K M N P O Q R S T U V W X Y Z [ \ ] ^ > ? @ _ ` a A B b C c d e f g h i j k l m n D E F o p qyAR(stable) (portable)None r@combine a list of definitions into a balanced binary search tree sOrebuilding instance + interface, and "with" modules, prior to renaming. AR 24102003 tWhen 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. u@this is what happens when matching two values in the same module r v s t w x u y z r v s r v s t w x u y zzNone *+-./02345689:;=?BCDGHJKM { | } ~                            ! " # $ % & ' ( ) * + , - . / 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 { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstu pOPQRST { | } ~                             ! " # $ % & ' ( ) * + , - . / 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 { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstu }  ~ {AR(stable) (portable)NonevReturns 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]w5options can be passed to the compiler by comments in --#Z, in the main file getOptionsFromFile :: (MonadIO m,ErrorMonad m) => FilePath -> m Optionsxyz{|}~vw%&'(}~vwxy|{z}~vw|AR(stable) (portable)None,WRead a source file and parse it (after applying preprocessors specified in the options),-.,-. ,-.}None~None3None NoneNone  NonePredefined functions%Show | Read | ToStr | MapStr | EqVal 3Self-contained (not quite) representation of values;:None24           None9Convert operators once, not every time they are looked up'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 termA#$%&'()*+,-./0123456789: ;<=>?@ABC!DEFGHIJKLMNOPQR"STUVWXYZ[\]^-0:#$%&'()*+,-./0123456789: ;<=>?@ABC!DEFGHIJKLMNOPQR"STUVWXYZ[\]^WXYNone_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._`abcdefghijklmnopqrstuvw_`_`abcdefghijklmnopqrstuvwAR(stable) (portable)Nonex8checking is performed in the dependency order of modulesylGeneral Principle: only Just-values are checked. A May-value has always been checked in its origin module.z=for grammars obtained otherwise than by parsing ---- update!!{ linearization types and defaultsx|}yz{xx|}yz{AR(stable) (portable)None~Jpartial evaluation of concrete syntax. AR 6/2001 -- 16/5/2003 -- 5/2/2005..the main function for compiling linearizations&auxiliaries for compiling the resource ~~ ~Krasimir Angelov(stable) (portable)None246HMThe 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.Path into a term or term schema Term schemabacktracking for all variants@backtracking for all parameter values that a variable could take[the argument should be a parameter type and then the function returns all possible values.G9None1ACompile a given source file (or just load a .gfo file), given a n- containing everything it depends on. Calls 2 or 3.2`Read a compiled GF module. Also undo common subexp optimization, to enable normal computations.3NCompile 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) /0123/0123 /0123None4ECompile 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 is supposed to be the number of jobs to run in parallel, but this has not been implemented yet. Instead you have to use the GHC run-time flag  +RTS -N -RTS to enable parallelism.444 Aarne Ranta(stable) (portable)Nonethe main function-Gets the element category of a list category. Module name.      Peter LjunglfNone&   !"#$%&'()*+,-./01#   !"#$%&'()*+,-./01None23456789:;<=>?@ABCDE2323456789:;<=>?@ABCDENoneFGHIJKLMNOPQRSTUVFFGHIJKLMNOPQRSTUVPeter LjunglfNone3WXYZ[\]^_`abcdeWWXYZ[\]^_`abcdeNonefghiConcrete syntax namegifghiNonejthe main function'kljmnopqrstuvwxyz{|}~j'kljmnopqrstuvwxyz{|}~NoneNone3NoneThe environment5/Compiles a number of source files and builds a / structure for them. This is a composition of 6 and 8.6Link a grammar into a  that can be used to  and  with the PGF run-time system.7RReturns the name of the abstract syntax corresponding to the named concrete syntax8_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. 56784Options from program command line and shell command.5678 5678NoneNone Run normally Redirect  to the given handleCapture NoneThe make_fa algorithm from "Regular approximation of CFLs: a grammatical view", Mark-Jan Nederhof, Advances in Probabilistic and other Parsing Technologies, 2000.,Build a DFA by building and expanding an MFA 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.*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.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 !"#$%&'()*+,-  !"$% !"#$%&'()*+,-BB(stable) (portable)None./0123456789:;<=>/0./0123456789:;<=>None ?@ABCDEFGHrootlanguageIJ?@ ?@ABCDEFGHIJNoneKLMNOPQRSTUVWXLKLMNOPQRSTUVWXNone3Y+An SLF word is a word, or the empty string.Z%Give sequential names to subnetworks.[&Make a network with subnetworks in SLF\@Check if a word should not correspond to a word in the SLF file.(]^_`abYcdefghijklmnopqZrstu[vwxyz{|}\~rsu[]^_`abYcfdghigejklmnopqZrstu[vwxyz{|}\~NoneNone9Export a PGF to the given '. For many output formats, additional b# 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.9,List of recommended file names and contents.99None:>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 b) from the output of 4. 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 b . Calls 9.=3Write the result of compiling a grammar (e.g. with  compileToPGF or 6) to a .pgf* file. A split PGF file is output if the  -split-pgf option is used.:;<=:;<=:;<=None/the maximal number of precompiled quiz problems. " None % NoneNone Handler monad Combined FastCGI and HTTP serverHTTP request handler6Check 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     4     NoneM> Run the GF Shell in quiet mode (gf-run).?Run the interactive GF Shell@Run the GF Server ( gf-server). The 2 argument is the port number for the HTTP service.2Read end execute commands until it is time to quitRead and execute one command, returning Just an updated environment for | the next command, or Nothing when it is time to quit Read a command!>Optionally show how much CPU time was used to run an IO action"zExecute a given command, returning Just an updated environment for | the next command, or Nothing when it is time to quit#$%&'()*+,->.?/@ !"0123456789>?@#'&%$()*+,->.?/@ !"0123456789NoneALRun the GF main program, taking arguments from the command line. (It calls + and B, then C.) Run  gf --help for usage info.BDGet and parse GF command line arguments. Fix relative paths. Calls : and .C_Run the GF main program with the given options and files. Depending on the options it invokes :, ?, >, @(, or it just prints version/usage info.ABCABCABCNonec01234589:;GHIJKLMNOPQRSTUVWXYZ[\]^_`a      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~%&'()*+,-./0123456789:;<=>?@ABCfABC?>@:;=<5687490/123,-.nopImabcdefghijkl`^_X]\[ZY{|pzoTWVUQSRqrstvwuxy~}NPO@IHGFEDCBA;:9876543210/.-,+*)('&%$#"! ?>=<     25430189:;JKLMIJKHQSUTVZWXY[\]^_`aGLMROPN%'&(*)+;    ########$$&L&L&&&&&&&&&&     ,,,,,,,,,,,,,,,,, ,!,",#,$,%,&,',(,),,*,+,,,-,.,/,0,1,2,3,4,5,6,7,8,9,:,;,<,=,>,?,@,A,B,C,D,E2F2G2H2I2J2K2L2M5N5O5P5Q4R4S4T4U4V4W4X4Y4Z5[5\5]5^5_5`5a5b5c5d5e5f5g5h5i5j5k6l6m6n6o6p6q6r66s6t7u7v7w7x7y7z7{88|8}8~899999999999999<<<<<<<<===================>>>>>>>>?????????AAAAAAAAAAAAAAAAAAEPPPPP]]]]]]]]]]]]]]]]]]]]]]]]]]]aaaaaaa a a a a aaaaaaaaaaaaaaaaaaa a!a"a#a$a%a&a'a(a)a*a+a,a-a.a/a0a1a2a3a4a5a6a7a7a8a9a:a;a<a=a>a?a@aAaBaCaDaEaFaGaHaIaJaKaLaMaNaOaPaQaRaSaTaUaVaWaXaYaZa[a\a]a^a_a`aaabacadaeafagahaiajakalamanaoapaqarasatauavawaxayaza{a|a}a~aaaaaaaaaaaaaabbbbbbbbbbRbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbSbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb b b b b bbbbbbbbbbbbbbbbbbb b!b"b#b$b%b&b'b(b)b*b+e,e-e.e/e0e1e2e3e4e5e6e7e8f9f:f;f<f=f>f?f@fAfBfCfDfEfFfGfHfIf`f^fJfKfLfMfNfOfPfQfRfSfTfUfVfWfXfYfZf[f\f]f^f_f`fafbfcfdfefffgfhfifjfkflfWfmfnfofpfqfrfsftfufvfwfxfyfzf{f|f}f~ffffffffffffffffffffffffffffrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrsssssss|||   Sn                                           ! " # $ % & ' ( )*+, - . / 0 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ABCDEFGHIJKQLMNOPQRSTUVWXYZ[\]^_`abcdefghijjklmnopqrstuvwxyz{|}~*** *  *   !"#$%&'()*+,-./012345*67*68 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"[","\]^n]^_]^`]^a]^b]^c]^c]^d]^e]^f]^n]^M]^g]^h#i#j%k&l*+m'n'o'p'q'r*s*tu*v*w*x*tO*y*(z*{*|*}*~***************************t***+++++++++++++++**+++++++++++++++++++++*,,----------------------.0.....././....0......................///////////////////////// / / / / /////////////////// /!00"00#0$0%0&0'0(0)0*0+0,0-0.0/101112131415161718191:1;1<1=1>1?1@1A1B1C1D1E1F1G1H1I1J*6K2F2L2M2N2O2P2Q3R3S3T3U3V3W3X3Y3Z3[3\3]3^3_3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z4{4|4}4~4455555555555V5O555555555555555555555555555555355555555666666666666666666666666666666666666666666666666666666667777777777777777777777777777?7>7;777<777777778889999999999999999 9 9 9 9 9999999999999999999 9!9"9#9$9%9&9'9(9)9*9+9,9-99999.9/9091929394<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@U@V@W@X@Y@Z@[@\@]@^A_A`AaAbAbAcAdAeAXAfAgAhAiAjAkAlAmAnAoApApAAAqArAsAtAuAvAwAxAyAzA{A|B}B~BBBBBCCCCCCCCCCCCCCCCCCCCD[DDDDDDDDEEEEEEEEEFFFFFFFFllGHHHHHHHHHHHHHHHHHHHIIIIIIIIJJJJJJJJJJJJJJgJJJJJJJJJJJJJJJJJJJJJJJJ J J J J JJJJJJKKKMMKNNKKKKK K!K"K#K$K%K&K'K(K)K*K+K,K-K.K/K0K0KK1K2K3K4K5K6K7K8K9N:N;N<N=N>NN?N@NAN&N'N(N)N*N+N,N-N.N/N:NBNCNCNDNENFNGNHNIOJOJOKOKOLOLOMOMONOOOPOQOQOROSOTOUOVOWOXOYOZO[O\O]O^O_O`OaObOcOdOeOfOgOhOiOjOkOlOmOnOoOpOqOrOsOtOuOvOwPPPxPyPzP{P|P}P~PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP*******Q?QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQR?RRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSS S S S S S S S S S S S SS S SS S S S S S S S S S S S S S S S S S S S S S !S "S #T $T %T &T 'TT (T )T *TT +T ,T -T -T .T /TT 0T 1T 2T 3T 4T 5T 6T 7T 8U 9U :U ;U <U =U >U ?U @U AU BV CV DV EV FV GV HV IV JV KV LV MV NV OV PV QVLV RV SV TV UV VV WV XV YV ZV [V \V ]V ^V _V `V aV bV cV dV eW fW gW hW iW jW kW lW mW nW oX pX qX rX sX tX uX vY wY xY yZ zZ {Z |Z }Z ~Z ZZ Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z ZZ Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z ZZ Z Z Z Z Z Z ZZ Z Z Z Z Z Z [ [[ [ [ [ [ [ [ [ [ [[ [ [ [ [ [[ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [[ [ [ [ [ [ [ [ [ [ [ [ [ ] ] ] ] ] ]] ] ] ] ] ] ] ] ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^^^ ^ ^ ^ ^ ^ ^ ^ ^r^ ^ ^ ^ ^ ^ ^ ^ ^ !^ "^ #^ $^ %^ &^ '^ (^ )^ *^ +^ ,^ -^ .^ /^ 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^ {^ |^ }^ ~^ ^ ^ ^ ^ ^ ^ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ ` ` ` ` ` ` ` ` ` `` ` ` ` ` ` ` ` `` `` `` ` `` ` ` ` ` ` ` `'`S`#` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` a aa a a a a a a a a a a a aa a a a a aa a a a a b  b b b b c c c c c c c c c c c c c c d d d dd d d d d ddd d d d d e !e "e #e $ee %e &e 'e (e )ee *e +ee ,e -e .e /e 0e 1e 2e 3e 4h 5h 6h 7h 8h 9h :h ;h <h =h >h ?i @i Ai Bi Ci Di Ei Fi Gi Hi Ii Ji Ki Li Mi Ni Oi Pi Qi Ri Si Ti Uii Vi Wi Xii Yii Zi [i \i ]i ^i _i `i ai bj cj dk ek fk gk hk ik jk kk lk mk nk ok pk qk rk sl tl ul vl wl xm ymm zm {m |m }m ~m m m m m m m m m m m m n n n n n n n n n n n n n n n o o o o o o o o p p p p p p p p p p qqq q q q q q q q q qq q q q )qqqqqqqq *+  r r s s s s ss s s s ss s s s s ss s s s s s s s s t t t t t t t t t t t t t t t t t tt t t t t t t t t t t t u u u u u u u u u u u u u u u u v v v v v v v v v v vv v w w w w w w w w w w w x x x x x x x x x xxxx x x xxx x !x "x #x $xx x x %x &x 'x (x )x *x +x ,x -x .x 9x /x 0x 1x 2x 3xxxxx 4x xx 5x.x4x3y 6y 7y 8y 9y :y ;y <y =y >z ?z @z Az Az Bz Cz Dz Ez Ez Fz Gz Hz Iz Jz Kz Lz Mz Nz Oz Pz Qz Rz Sz Tz Uz Vz Wz Xz Yz Zz [z \z ]z ^z _z `z az bz cz dz ez fz gz hz iz jz kz lz mz nz oz pz qz rz sz tz uz vz wz xz yz zz {z |z }z ~z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z !z "z #z $z %z &z 'z (z )z *z +z ,z -z .z /z 0z 1z 2z 3z 4z 5z 6z 7z 8z 9z :z ;z <z =z >z ?z @z Az Bz Cz Dz Ez Fz Gz Hz Iz Jz Kz Lz Mz Nz Oz Pz Qz Rz Sz Tz Uz Vz Wz Xz Yz Zz [z \z ]z ^z _z `z az bz cz dz ez fz gz hz iz jz kz lz mz nz oz pz qz rz sz tz uz vz wz xz yz zz {z |z }z ~z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z zzzzzzzzzz z z z z zzzzzzzzzzzzzzzzzzz z!z"z#z$z%z&z'z(z)z*z+z,z-z.z/z0z1z2z3z4z5z6z7z8z9z:z;z<z=z>z?z@zAzBzCzDzEzFzGzHzIzJzKzLzMzNzOzPzQzRzSzTzUzVzWzXzYzZz[z\z]z^z_z`zazbzczdzezfzgzhzizjzkzlzmznzozpzqzrzsztzuzvzwzxzyzzz{z|z}z~zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz z z z z zzzzzzzzzzzzzzzzzzz z!z"z#z$z%z&z'z(z)z*z+z,z-z.z/z0z1z2z3z4z5z6z7{8{9{{:{;{<{={>{?{!{@{A{B{C{D{E{F{G{H{I|J|-|K|6|L|M|N|O|P|Q|R|S|T}U}V}W}X}Y~Z~[~\~]^_`abcdefghijklm nopqrstuvwxyz{ |}~             )  :        !"#$%&'()*+,-./012345Wk6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^__`aabcdefgWhijklmnopqrstuvwxyz{|}~bO      VN O!"#$%&'()*+*,-.//0123456789:;<&(=>?@ABCDEFFGHHIJKLMNOPQRSTUVWXYZ[\]^_`abcde]ffgghijklmnopqrstuvwxyz{|}T~ z}~E HEz}~E          !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abccdefghijklmnopq*rgf-3.7 GF.SupportGF.Text.Pretty PGF.Haskell PGF.Lexing PGF.UtilitiesPGFGFSimpleEditor.SyntaxSimpleEditor.JSONCache URLEncodingGF.System.UseSignal GF.Data.GraphGF.Compile.TypeCheck.ConcreteGF.Text.CodingGF.JavaScript.AbsJSGF.JavaScript.PrintJSGF.Data.BacktrackM GF.Compile.Compute.AppPredefinedGF.Compile.MultiGF.Text.TransliterationsGF.Text.CliticsGF.Command.MessagesDarcsVersion_gfGF.Infra.GetOptSystem.EnvironmentgetArgsGF.Infra.ConcurrencyGF.System.SignalGF.System.DirectoryGF.Infra.BuildInfo GF.Data.ErrMPaths_gf PGF.TrieMapGF.System.ConsoleGF.System.CatchGF.System.ProcessGF.Infra.LocationGF.Text.Lexing Data.ListnubGF.Data.UtilitiesGF.Data.RelationGF.Data.Operations GF.Data.StrGF.Data.GraphvizGF.Speech.FiniteState GF.Data.XMLGF.Speech.RegExpPGF.CId PGF.ByteCodePGF.TypePGF.ExprPGF.Data PGF.Macros PGF.Linearize PGF.TypeCheckText PrettyPrint PGF.GeneratePGF.VisualizeTreePGF.ProbabilisticPGF.Morphology PGF.Forest PGF.Parse PGF.Optimize PGF.PrinterPGF.TreePGF.Paraphrase PGF.SortTopCGICGIUtilsRunHTTPData.Binary.GetData.Binary.BuilderL BytestringData.Binary.PutData.Binary.IEEE754 Data.Binary PGF.OldBinary PGF.BinaryGF.Grammar.CFGGF.Command.AbstractGF.Command.ParseGF.Grammar.EBNFGF.Compile.ExampleBasedGF.QuizFold PGFService ExampleDemo PGF.InternalGF.Infra.IdentGF.Grammar.LexerGF.Grammar.Predef GF.HaskellGF.Infra.OptionGF.Grammar.GrammarGF.Infra.DependenciesGF.Grammar.ValuesGF.Grammar.PrinterGF.Grammar.Macros GF.GrammarGF.Grammar.UnifyGF.Compile.TypeCheck.TCGF.Compile.TypeCheck.PrimitivesGF.Grammar.PatternMatchGF.Grammar.LockfieldGF.Grammar.LookupGF.Grammar.AnalyseGF.Grammar.ShowTermGF.Compile.SubExOptGF.Compile.Compute.ConcreteNew1GF.Infra.UseIOGF.Grammar.BinaryGF.Infra.CheckMGF.Compile.RenameGF.Compile.TypeCheck.RConcreteGF.Compile.TypeCheck.Abstract GF.Compile.TypeCheck.ConcreteNewGF.Compile.UpdateGF.Grammar.ParserGF.Compile.ReadFilesGF.Compile.GetGrammarGF.Compile.TagsGF.Compile.CFGtoPGFGF.Compile.ToAPIExampleServiceGF.Command.TreeOperationsGF.Compile.Compute.ValueGF.Compile.Compute.PredefGF.Compile.Compute.ConcreteNewGF.Compile.ConcreteToHaskellGF.Compile.CheckGrammarGF.Compile.OptimizeGF.Compile.GeneratePMCFG GF.CompileOneGF.CompileInParallelGF.Compile.PGFtoHaskellGF.Compile.PGFtoPrologGF.Compile.PGFtoLPrologGF.Compile.PGFtoJSGF.Compile.PGFtoPythonGF.Speech.PGFToCFGGF.Speech.VoiceXMLGF.Compile.GenerateBCGF.Compile.GrammarToPGF GF.Compile linearizeparseGF.Command.Importing GF.Infra.SIOGF.Speech.CFGToFA GF.Speech.SRG GF.Speech.GSLGF.Speech.SISRGF.Speech.SRGS_ABNFGF.Speech.SRGS_XMLGF.Speech.JSGF GF.Speech.SLFGF.Speech.PrRegExpGF.Compile.Export GF.CompilerGF.Command.CommandsGF.Command.InterpreterSimpleEditor.Convert GF.ServerGF.InteractiveGF.Maintransformers-0.4.3.0Control.Monad.IO.ClassliftIOMonadIOErrBadOkerrfromErrPrettyppppListrender renderStyle$$$+$<+><>bracesbracketscat doubleQuotesfcatfsephanghcathsepnestparens punctuatequotessepvcat $fPretty[] $fPrettyChar$fPrettyDouble $fPrettyFloat$fPrettyInteger $fPrettyInt $fPrettyDoc TermColorsredFgblueFgrestoresetConsoleEncodingchangeConsoleEncoding getTermColorscatchtryLocationExternalLocalNoLoc HasSourcePath sourcePathunLocnoLoc ppLocationppLR_sHas_sproj_sPrefixTok ALL_CAPITCAPIT SOFT_SPACE SOFT_BINDBINDTPTKStrEnumAllenumAlltablefromStrto_R_s+++!!$!* $fHas_sR_st $fEnumAllR_slexTextlexText' unlexTextbindToklexCode unlexCode lexLatexCodelexMixed unlexMixed capitInit uncapitInitunquoteisPunct isMajorPunct isMinorPunctisParen isClosingnub'replace 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 readIntArgdoneliftErrchecksdoUntilCIdwildCIdmkCIdutf8CIdreadCIdshowCIdpIdentppCIdBindTypeImplicitExplicitExprHypoTypereadTypeshowTypemkTypemkHypo mkDepHypo mkImplHypounTypeTreereadExprshowExprmkAbsunAbsmkAppunAppmkStrunStrmkIntunIntmkDoubleunDoublemkMetaunMetapExprppMetaLanguageSeqIdFunIdSequenceLIndexFIdToken readLanguage showLanguageBracketedStringBracketLeaf missingLins showPrintNameshowBracketedStringflattenBracketedString linearizeAlllinearizeAllLangbracketedLinearizetabularLinearizesTcErrorUnsolvableGoalUnexpectedImplArgUnresolvedMetaVarsCannotInferType NotFunType TypeMismatch WrongCatArgs UnknownFun UnknownCat ppTcError checkType checkExpr inferExpr generateAllgenerateAllDepth generateFromgenerateFromDepthgenerateRandomgenerateRandomDepthgenerateRandomFromgenerateRandomFromDepthGraphvizOptionsnoLeavesnoFunnoCatnodeFontleafFont nodeColor leafColor nodeEdgeStyle leafEdgeStylegraphvizDefaultsgraphvizAbstractTreegraphvizDependencyTree getDepLabelsgraphvizParseTreegraphvizBracketedString gizaAlignmentgraphvizAlignment ProbabilitiesshowProbabilitiesreadProbabilitiesFromFilemkProbabilitiesdefaultProbabilitiessetProbabilitiesprobTreerankTreesByProbsMorphoAnalysisLemma buildMorpho lookupMorpho isInMorphofullFormLexicon morphoMissing morphoKnown ParseState ParseOutputParseIncompleteParseOk TypeError ParseFailed ParseInputpiToken piLiteral initStatesimpleParseInput mkParseInput nextStategetCompletionsrecoveryStatesgetParseOutputgetContinuationInfo paraphraseBinaryencodedecode encodeFile decodeFileTrieApOthATreeAppOtherreadPGFparseAll parseAllLangparse_parseWithRecovery groupResults abstractName languages languageCode categoriescategoryContextstartCat functionsfunctionsByCat functionTypecomputebrowsetoATreetoTrieRawIdentIdent 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 optPlusAsBindoptJobsRecomp NeverRecomp RecompIfNewer AlwaysRecompPassCanonOptimizeRefresh TypeCheckRenameExtendRebuildSourceDump HaskellOptionHaskellVariantsHaskellConcreteHaskellLexical HaskellGADTHaskellNoPrefix CFGTransformCFGRemoveCyclesCFGMergeIdenticalCFGStartCatOnlyCFGBottomUpFilterCFGTopDownFilter CFGRegularCFGNoLR OptimizationOptParametrize OptExpandOptCSEOptStem SISRFormatSISR_1_0SISR_WD20030401 OutputFormatFmtFA FmtRegExpFmtSLF FmtVoiceXMLFmtGSLFmtJSGFFmtSRGS_ABNF_NonRec FmtSRGS_ABNFFmtSRGS_XML_NonRec FmtSRGS_XMLFmtNoLR FmtRegularFmtEBNFFmtBNF FmtByteCodeFmtLambdaProlog FmtProlog FmtHaskell FmtPython FmtJavaScript FmtPGFPrettyPhaseLinkCompileConvertPreproc VerbosityDebugVerboseNormalQuietMode ModeServer ModeCompilerModeRunModeInteractiveModeHelp ModeVersion helpMessage parseOptionsparseModuleOptionsfixRelativeLibPaths optionsGFO optionsPGFflag addOptions noOptions concatOptions modifyFlags getEncodingdefaultEncodingoutputFormatsExplrenameEncodingreadOutputFormat verbAtLeastdump cfgTransform haskellOption isLiteralCat isLexicalCatsetOptimizationsetCFGTransform SubstitutionAlternParamLocalDefCaseAssign LabellingEquationContextMetaIdLabelLVarLIdentTInfoTWildTCompTTypedTRawPattPMPMacroPCharsPCharPRepPMSeqPSeqPAltPNegPTildePImplArgPAsPTPFloatPIntPStringPRPWPVPPPCTermErrorStrsAltsFV AdHocOverloadELinELincat EPattTypeEPattGlueCQCQLetSVTTableExtRPRRecTypeExampleTypedProdImplArgMetaAbsEmptyKEFloatEIntSortConCnVrQIdentFunCatInfoAnyIndCncFunCncCat ResOverloadResOperResValueResParamAbsFunAbsCatPMCFG Production ModuleStatus MSIncomplete MSCompleteOpenSpecOQualifOSimpleMIncludeMIExceptMIOnlyMIAll ModuleType MTInstance MTInterface MTConcrete MTResource MTAbstract SourceModInfo SourceModule SourceGrammar ModuleInfoModInfomtypemstatusmflagsmextendmwithmopensmexdepsmsrcmseqsjmentsModuleGrammar moduleMapmodulesextends isInherited inheritAll openedModule depPathModule allDepsModule partOfGrammar allExtendsallExtendsPlus prependModule emptyGrammarmGrammarabstractOfConcrete lookupModuleisModAbsisModResisModCnc sameMTypeisCompilableModuleisCompleteModule allAbstractsgreatestAbstract allResourcesgreatestResource allConcretesallConcreteModulesvarLabel tupleLabellinLabel theLinLabel ident2label label2ident TermPrintQualInternal Qualified UnqualifiedppModule 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 putStrLnEputStrE ePutStrLnIOEFullPathInitPathFileName putIfVerb gfLibraryPathgfGrammarPathVargetLibraryDirectorygetGrammarPath extendPathEnv getSubdirsjustModuleNameisGFisGFOgfFilegfoFilegf2gfogf2gfo'splitInModuleSearchPathtryIOEuseIOEmaybeIOdie putPointE ioErrorTexttimeIt writeUTF8FilereadBinaryFilewriteBinaryFile VersionTagged WrongVersionTaggedunV decodeModuledecodeModuleHeader encodeModulegetSourceModule getCFRules getEBNFRulesCompiledModule OneOutput compileOnereuseGFO useTheSourceparallelBatchCompile compileToPGFlink srcAbsName batchCompile exportPGFmainGFC linkGrammars writeOutputswritePGF mainRunGFImainGFI mainServerGFImain getOptionsmainOptsLhsLinfunargslinOperonameorhsLincatlintypepnameprhsConcretelangcodeopensparamslincatsoperslinsfnameftypeAbstractstartcatcatsfunsbasenameabstract concretesModIdId signature definition.= $fJSONLin $fJSONLincat$fJSONConcrete $fJSONOper $fJSONParam $fJSONFun$fJSONAbstract $fJSONGrammarnewCache flushCache expireCache listCache readCache readCache'FileInfo cacheLoad cacheObjectsfst3urlDecodeUnicode decodeQueryQueryabothfromhex4fromhex2unfoldrchopListbreakAtrunInterruptiblyrunInterruptibly_blockInterruptmyInstallHandlermyCatchmyIgnorenewGraphnodesedgesnmapemapnewNode removeNode removeNodesnodeInfo mergeGraphs renameNodesmap'baseGHC.BasemapNodeInfoEdgeNodeGraphnewNodesnewEdgenewEdgesinsertEdgeWith groupEdgesBy lookupNode getIncoming getOutgoinginDegree outDegree getNodeLabel nodeLabeledgeFromedgeTo edgeLabel reverseGraph encodeUnicode decodeUnicodedecodeUnicodeIOioe_invalidCharacter1ioe_invalidCharacter2 PropertyName IntPropNameStringPropName IdentPropNamePropertyPropESeqEObjEArrayEFunEThisENullEFalseETrueEStrEDblEVarECallEIndexEMemberENewEAssignDeclVarDInitDVar DeclOrExprDExprDeclStmt SDeclOrExprSReturn SReturnVoid SCompoundElementElStmtFunDefProgramPrintprtprtListDoc printTreedoc spaceAfter spaceBeforeparenthconcatSconcatD replicateSmkEscprPrec$fPrintPropertyName$fPrintProperty $fPrintExpr$fPrintDeclVar$fPrintDeclOrExpr $fPrintStmt$fPrintElement$fPrintProgram $fPrintIdent $fPrintDouble $fPrintInt $fPrintChar $fPrint[] BacktrackMBMrunBMfoldBM foldSolutions solutionsfoldFinalStates finalStatesmembercut$fMonadStatesBacktrackM$fMonadPlusBacktrackM$fAlternativeBacktrackM$fFunctorBacktrackM$fMonadBacktrackM$fApplicativeBacktrackM mtl-2.2.1Control.Monad.State.Classgetsmodify'modifystateputget MonadStateMulti rawModulesabsNamecncNamesabsRulescncRules readMulti emptyMultiabsCodecncCodegetMultiaddMultigetRuleschopunspacequoteidCharisModulemodlinesTransliterationTranstrans_to_unicodetrans_from_unicodeinvisible_chars printname transliteratetransliterateWithFiletransliterationallTransliterationstransliterationPrintNamescharacterTableappTransToUnicodeappTransFromUnicodemkTransliterationgetTransliterationFileunchar transThaitransDevanagariallTransUrduHindi transUrdu transSindhi transArabic transPersian transNepali transHebrew transTelugu transGreektransAncientGreek transAmharicallTransallCodes transSanskrit getCliticsgetCliticsText getClitics1exlex1exclits1 licenseMsg codingMsg changesMsg darcs_infoArgDescrOptArgReqArgNoArgOptDescrOptionArgOrder ReturnInOrderPermute RequireOrder usageInfogetOptgetOpt'OptKindOptErr EndOfOptsNonOptUnreqOptOptfmtOptfmtShortfmtLonggetNextlongOpterrAmbigerrReqerrUnrecerrNoArgFuturenowspawnparMapMnewLognewMVarreadMVarputMVar newEmptyMVarnewChangetChanContents writeChanlazyIOControl.Concurrent.ChanChanControl.Concurrent.MVar modifyMVar modifyMVar_ GHC.Conc.SyncforkIOGHC.MVarMVarcanonicalizePathcreateDirectoryIfMissingdoesDirectoryExist doesFileExistgetModificationTimegetDirectoryContentsgetCurrentDirectorygetPermissions removeFile renameFiledirectory-1.2.1.0System.DirectorygetTemporaryDirectorygetUserDocumentsDirectorygetAppUserDataDirectorygetHomeDirectorysetCurrentDirectory findFilesWith findFilesfindFilefindExecutablemakeRelativeToCurrentDirectorycopyFilerenameDirectoryremoveDirectoryRecursiveremoveDirectorycreateDirectorycopyPermissionssetPermissionssetOwnerSearchablesetOwnerExecutablesetOwnerWritablesetOwnerReadableemptyPermissions searchable executablewritablereadable Permissions buildInfo Data.MaybeMaybemaybe$fMonadPlusErr $fFunctorErr$fAlternativeErr$fApplicativeErr $fMonadErrcatchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameTrieMapTrempty singletonlookupnullcompose decompose insertWithunion unionWithunions unionsWithelemstoList fromListWithfromList mapWithKeypretty-1.1.1.1Text.PrettyPrint.HughesPJ OneLineModeLeftMode ZigZagModePageModeStylemode lineLengthribbonsPerLineisEmptystyle setEncoding noTermColorsreadShellProcess $fFunctorLStringstringOpopInEnvappLexer appUnlexerwrapHTMLsafeInitGHC.Listinit sortGroupByunionAlllookup'find'findtableSet buildMultiMap compareEqwhenMP Control.Monadmzero nothingOrNullfoldFunsfixjoin sameLength notLongerThan longerThan lookupListsplitsplitBy foldMergeselect updateNth updateNthM compareBybothapFstapSndapBothmapFstmapSndmapBothnlspwrapunwordsSunlinesSjoinSRel'mkRelmkRel'relaterelates isRelatedTo allRelateddomainintersectSetRelreflexiveClosurereflexiveElements filterRel purgeEmptyequivalenceClassestopologicalSort Data.EitherLeftRightremoveRel relToList reverseReltransitiveClosurereflexiveClosure_symmetricClosuresymmetricSubrelationreflexiveSubrelation isTransitive isReflexive isSymmetric isEquivalenceisSubRelationOftsort findCyclesisEmpty' relToRel' rel'ToRelincomingoutgoingsequence checkAgain$fErrorMonadErrSsTNsstrVallItems matchPrefix matchSuffixunmarkup str2stringsstr2allStringssstrstritS isZeroTokstrTokprStrplusStrglueStrgluesAttr GraphType UndirectedDirectedgTypegIdgAttrsgNodesgEdges gSubgraphs addSubGraphssetNamesetAttr prGraphviz prSubGraphprGraph graphtypeprNodeprEdgeedgeop prAttrListprAttrescneedEsc isIDFirstisIDCharFAnewFA_nonLoopTransitionsTo renameStates insertNFA oneFinalStatemoveLabelsToNodesremoveTrivialEmptyNodesskipSimpleEmptyNodes pruneUnusableclosure reachableDFANFAState startStatestates transitionsnewFA addFinalStatenewState newStates newTransitionnewTransitionsinsertTransitionWithinsertTransitionsWith mapStatesmapTransitionsmodifyTransitions removeStateminimize unusedNamesnonLoopTransitionsFromloopsonGraph isInternalisFinal fixIncomingalphabet determinize reachable1 reverseNFAdfa2nfa prFAGraphviz prFAGraphviz_ faToGraphvizlookupsXMLCommentETagTagCDataDatacomments showXMLDoc showsXMLDocshowsXML showsAttrs showsAttrescape bottomUpXMLREConcatREUnionRERESymbolRERepeatdfa2re elimStates epsilonREnullREisNull isEpsilonunionREconcatREseqRErepeatREfinalRE reverseRE minimizeRE mergeForwardfirstREmapREmapRE'joinRE symbolsREprREprRE'pNothingpCId insideChar isIdentFirst isIdentRest $fReadCId $fShowCIdLFltLIntLStrTailInfo UpdateCallTailCallRecCallIValGLOBALFREE_VARARG_VARHEAPInstrADD POP_ACCUM PUSH_ACCUMFAILJUMPDROPEVALTUCKPUSH PUSH_FRAMESET_PADSETPUT_LIT PUT_CLOSURE PUT_CONSTRALLOCSAVECASE_LITCASE CHECK_ARGS CodeLabelLiteralppLitppCodeppInstrppIVal ppTailInfoppLabelDTyppType pHypoBindspAtomppTypeppHypoPWildPVarPLitPAppEImplArgETypedEMetaELitEAppEAbs unAppForm normalFormppParens freshNameppExprpBindspArgEnvSigValueVImplArgVClosureVConstVGenVSuspVMetaVLitVAppEqupFactorpTypedpMetapLit pattScopeppBind value2exprevalapply applyValuematch $fReadExpraflagsPArgPConstPCoercePApplySymbol SymALL_CAPITSymCAPIT SymSOFT_SPACE SymSOFT_BINDSymNESymBINDSymKPSymKSSymVarSymLitSymCatDotPosConcrcflags printnamescncfunslindefslinrefs sequences productions pproductions lproductionscnccatslexicon totalCatsAbstrgflagsabsnameunionPGF msgUnionPGFemptyPGFhaveSameFunsPGF fidStringfidIntfidFloatfidVar isPredefFIdlengthBracketedStringCncTypeLinTable BracketedToknLeafKP LeafCAPIT LeafSOFT_BINDLeafBINDLeafNELeafKSBracket_ mapConcreteslookTypeisData lookValCat lookStartCatlookGlobalFlag lookAbsFlag lookConcrlookConcrComplete lookConcrFlagfunctionsToCathasLin restrictPGFdepthcftype typeOfHypo contextLengthlookMap cidStringcidIntcidFloatcidVarppBracketedStringuntokn mkLinTable computeSeqfirstLinlinTree amapWithIndex lookupVargetVarSelector splitSelectorTcMunTcM MetaValueMGuardedMBoundMUnbound MetaStoreScopeTTypeTTyp emptyScope addScopedVarscopeEnv scopeVars scopeSizerunTcM lookupCatHyps lookupFunTypetypeGeneratorsemptyMetaStorenewMetanewGuardedMetagetMetasetMeta lookupMeta addConstrainttcTypetcHypostcHypo tcCatArgstcExprinfExprtcArg appImplArgeqTypeeqExpreqValuecheckResolvedMetaStoregenerateForMetasgenerateForForestevalType refineExpr refineExpr_ refineType refineType_ $fFunctorTcM$fMonadErrorTcErrorTcM$fMonadStatesTcM$fMonadPlusTcM$fAlternativeTcM $fMonadTcM$fApplicativeTcMgenerateproverestart$fSelectorIdentity $fSelector()PreAlignLangSeq IndexedSeqLabelsgenPreAlignment showIndSeqshowRelsgetOffsetIndex computeOffsetstruct tbracketstagCStateProbsfunProbscatProbsgetProbabilities mkProbDefscomputeConstrsp_fp_ik_fk_i collectWordsmorphoClassifymissingWordMsg getAbsTreesForestabstrconcrforestrootlinearizeWithBrackets bracketedTokn isLindefCId foldForest $fSelectorInt ErrorStateEState ContinuationChartactiveactivespassivenextIdoffsetPState PassiveChart PassiveKeyPK ActiveChart ActiveSet ActiveKeyAKActive getPartialSeqprocesspredictupdateAtemptyAClookupAClookupACByFCatlabelsACinsertACemptyPClookupPCinsertPC optimizePGFupdateProductionIndices topDownFilterbottomUpFilterfilterProductionssplitLexicalRulesupdateConcreteppPGFppAbsppFlagppCatppFunppCncppCncArg ppProductionppCncFun ppFunListppSeqppCncCat ppPrintNameppSymbolppAltppStrsppFIdppFunIdppSeqIdppAllLitVar tree2expr expr2treeprTree patt2treeSubst paraphraseN paraphraseN'fromDefsubstisClosedisLinear arguments showInOrderisArg typesIntermtakeArgs doesReturnCat returnCat forExamplecgi-3001.2.2.2 Network.CGI setHeader readInputgetInputrequestAcceptLanguagegetVarWithDefault outputError handleErrors outputFPSoutputNetwork.CGI.Accept negotiateAcceptNetwork.CGI.MonadcatchCGIthrowCGIrunCGITNetwork.CGI.ProtocolcgiRequestBody cgiInputscgiVars CGIRequestinputContentType inputFilename inputValueInput CGIOutput CGINothing CGIResultmultipart-0.1.2Network.Multipart.Header ContentTypectType ctSubtype ctParameters HeaderNameHeadersCGIError cgiErrorCodecgiErrorMessage cgiErrorTextlogError stderrToFile throwCGIErrorhandleCGIErrors outputJSONPoutputEncodedJSONP outputPNG outputBinary outputBinary' outputHTML outputPlain outputStrictsetXO$fExceptionCGIError documentRootportrunHTTP cgiHandlerhttpRespcgiReqGetrunGet 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.4.0Data.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$fMonoidBuilderPutPutMexecPutrunPutrunPutMputWord8 putByteStringputLazyByteStringunPutPairSsndStell putBuilder $fMonadPutM$fApplicativePutM $fFunctorPutM ByteCountBitCount SignificandExponentSignNegativePositiveRawFloatrawWidthrawSign 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()ghc-prim GHC.TypesWordGHC.WordWord8Word16Word32Word64 byteSwap64 byteSwap32 byteSwap16pgfMajorVersionpgfMinorVersiongetPGFgetPGF'getCId getAbstractgetFungetCatgetFlagsgetConcrgetExprgetPatt getEquationgetTypegetHypo getBindType getCncFun getCncCat getSequence getSymbols getSymbolgetAlternativesgetTokenSymbolgetPArg getProduction getLiteralgetArraytoArray listToArray getArray2getListgetList'getMaybegetMap getIntMapgetSetgetPair decodingError putSplitAbsputArray putArray2$fBinaryLiteral$fBinaryProduction $fBinaryPArg$fBinarySymbol$fBinaryCncCat$fBinaryCncFun$fBinaryBindType $fBinaryType $fBinaryInstr$fBinaryEquation $fBinaryPatt $fBinaryExpr $fBinaryConcr $fBinaryAbstr $fBinaryCId $fBinaryPGFCFMetaCFVarCFResCFAppCFAbsCFObj removeCyclesmergeIdenticalpurgeExternalCats mutRecCatsallRulesallRulesGroupedallCatsallCats'catRules catSetRulescleanCFGunionCFG anyUsedBy allXLinear isRightLinear isLeftLinearcatElemCFG cfgStartCatcfgExternalCatscfgRulesCFTermCFRulelhsCatruleRhsruleNameCFSymbolTerminal NonTerminalremoveLeftRecursionmakeSimpleRegular makeRegularmkCFG groupProds uniqueFuns mapCFGCatsonCFGonRules filterCFG filterCFGCats countCats countRulesprCFG prProductionsprCFTermruleFunmkCFTermruleIsNonRecursivesymbol mapSymbol filterCats filterToks noCatsInSetArgumentAMacroANoArgAExprVStrVIntVIdOFlagOOptCommandPipe CommandLine valCIdOpts valIntOpts valStrOptsisOptisFlag optsAndFlagsprOptmkOpt getCommandOpreadCommandLine pCommandLinepPipepCommandpOptionpValue pFilename pArgumentpSystemCommandpTheRestEItemEIOptEIPlusEIStar EINonTermEITerm NormERule CFJustRuleCFRHSERHSEEmptyEOptEPlusEStarEAltENonTermETermETokECatERuleEBNFebnf2cfnormEBNF refreshECats pickERules nubERules substERules eitem2cfitem normERulemkEItemmkECatprECatmkCFCatEupdECat mkNewECatExConfigurationExConf resource_pgfresource_morphoverboselanguageprintExpparseExamplesInGrammar convertFileconfigureExBasedmkAnswerQuestionsAndAnswersmkQuiztranslationListmorphologyListnorml teachDialoguefoldablefoldappFoldilexerlexerjsonExprlinearizeTabularToATreeshowTreeTreeOptsToFromUnlexerCachescatchIOEwithQSemlogFile newPGFCache flushPGFCache listPGFCache newCache'getPathcgiMaincgiMain'getFilelexer'unlexerpgfMainout getInput1nonEmpty textInput getLangs'getLang'limitstarttreeoptsgetBooltoBoolmissingerrorMissingIdnotFound badRequest serverErrorthrowformat doExternaldoLookupMorpho doTranslatejsonTypeErrorsdoTranslateGroupdoParseaddTrieaddTree doCompletecompletionInfo doLinearize doLinearizesdoLinearizeTabulardoRandom doGenerate doGrammaroutputGraphviz abstrTree parseTree alignmentpipeIt2graphviz browse1jsondoBrowseparse' complete'transferlinearizeAndBinddoBindselectLanguagelangCodeLanguage#%$fJSONBracketedString $fJSONExpr $fJSONCId $fJSONTrie $fToATreeExprEnviron getTypeMap getConcMapgetSigsgetAllConcMapTypeMap FuncWithArggetName getTypeArgs InterInstrMyFuncConcTypeMyTypeprovideExampletestThisllinreplaceConcArg replaceOne findExprWhich mapToResource embedInStart updateConcMapupdateInterInstr putSignatures updateEnvmkSigslang parseLang parsePGFfilesearchGoodTree getNameExprisGeneralizationOfdebugReplaceArgsdebugReplaceConc replaceArgs replaceConc writeResults simpleReplaceisMeta mkFuncWithArginitialtestInitlTypes startCategIAVIAIVIWIC rawId2utf8packunpackwild $fPrettyIdent$fBinaryRawIdent$fPrettyModuleName$fShowModuleNameAlexAcc AlexAccSkip AlexAccNone AlexLastAcc AlexLastSkipAlexNone AlexReturn AlexTokenAlexSkip AlexErrorAlexEOFAlexAddrAlexA#unP ParseResultPFailedPOk AlexInputAIPosnPnT_EOFT_IdentT_Double T_IntegerT_StringT_withT_where T_variants T_transferT_tableT_strs T_resource T_printnameT_pre T_patternT_paramT_operT_openT_ofT_linrefT_lindefT_lincatT_linT_let T_interface T_instance T_incompleteT_inT_funT_fnT_flagsT_defT_data T_concreteT_catT_case T_abstractT_TypeT_TokT_StrsT_StrT_PType T_cfarrowT_at T_underscoreT_ccurlyT_barT_ocurlyT_cbrackT_lamlamT_lamT_obrack T_questmarkT_great T_big_rarrowT_equalT_less T_semicolonT_colonT_altT_dotT_rarrowT_minusT_comma T_plusplusT_plus T_starstarT_starT_tildeT_cparenT_oparen T_int_labelT_patt T_exclmark alex_base alex_table alex_check alex_deflt alex_acceptidenttokreseitherResIdentisReservedWordresWordsunescapeInitTailalexMove alexGetBytealexInputPrevCharrunPfailLocgetPosn alex_action_3 alex_action_4 alex_action_5 alex_action_6 alex_action_7 alex_action_8alexIndexInt16OffAddralexIndexInt32OffAddr quickIndexalexScan alexScanUser alex_scan_tkniUnbox$fFunctorAlexLastAcc$fMonadP$fApplicativeP $fFunctorPcTypecPTypecTokcStrcStrs cPredefAbs cPredefCnccPredefcIntcFloatcStringcVarcIntscPBool cErrorType cOverloadcUndefinedType cNonExistcBIND cSOFT_BIND cSOFT_SPACEcCAPIT cALL_CAPIT isPredefCatcPTruecPFalsecLengthcDropcTakecTkcDpcToUppercToLowercIsUppercEqStrcEqValcOccurcOccurscEqIntcLessIntcPluscShowcReadcToStrcMapStrcErrorcMetacAscCharcCharscSeqcAltcRepcNegcCNC cConflictPPAPatExpTyConApDecppAAsPConPVarPWildPConst LambdaCaseLetsPairListOpListTTApTIdFunDepsDerivingEqnTypeSigInstanceClassconap0tsyn0lhs0tvartcon0tconlet1singleplusplus$fPPAPat $fPrettyPat$fPPAExp $fPrettyExp$fPPATy $fPrettyTy $fPrettyConAp $fPrettyDec $fPPAIdentoptDescrWarningWarnMissingLincat usageHeadererrors defaultFlags outputFormatsoptimizationPackagescfgTransformNameshaskellOptionNames lookupShowlookupReadsPreconOffsetOptimization'setCFGTransform'toggle readMaybe toEnumBounded$fFunctorArgDescr$fFunctorOptDescr$fReadOutputFormat$fShowOutputFormat $fShowOptionsMPattBoolsearchPathModuleCasesMGrammar$fHasSourcePathModuleInfoModDepsmodtypeofs extendedsopenedsextradsfunctors interfaces instancesdepGraph prDepGraph noModDepsgrammar2moddeps MetaSubst ConstraintsBindsValVClosVTypeVRecTypeVCn valAbsInt valAbsFloat valAbsStringvTypeeType ppOptions ppEquationppCaseppEnvppDeclppDDecl ppOpenSpec ppInstSpecppLocDefppAlternppParam ppSequences commaPunctprec getCTablegetLet $fPrettyLabel $fPrettyPatt $fPrettyTerm$fPrettyGrammarConstrsUnifierunifyValunifyAllunifyextend subst_all substMetas substTermoccCheckval2termTCEnvTheoryAAssign ALabellingAExpADataAGlueAPARARecTypeAProdAAbsAAppALetAMetaAStrAFloatAIntATypeACnAVr lookupConst emptyTCEnvwhnfappeqValcheckExp checkInferExpinferExpcheckLabelling checkAssign checkBranch checkPattnoConstrmkAnnot typPredefined primitives minLength maxLengthisMatchingForms matchPatterntestOvershadow findMatchtryMatch matchPMSeq matchPSeq matchPSeq' matchLength lengthBoundsmPatt measurePattisInConstantForm lockRecType unlockRecord lockLabel isLockLabel lockPrefixlookupOrigInfolookupCatContextlockunlock lookupIdentlookupIdentInfolookupQIdentInfo lookupResDeflookupResDefLoc lookupResTypelookupOverload allOrigInfoslookupParamValuesallParamValues lookupAbsDef lookupLincatallOpers allOpersTostripSourceGrammar stripInfoconstantsInTerm constantDeps getIdTermconstantDepsTermtermsOfConstant sizeConstantsizeTermsizeInfo sizeModule sizesModule sizeGrammar sizesGrammarprintSizesGrammarTermPrintStyleTermPrintDefault TermPrintOne TermPrintList TermPrintAllTermPrintTableshowTerm ppTermTabularTermMTermList subexpModuleunsubexpModuleaddSubexpConstsgetSubtermsModcollectSubterms operIdent isOperIdent operPrefixVErrorVAltsVFV VPattTypeVPattVTblVRecVTblTypeVSortVStringVFloat value2termfailIO$fErrorMonadIO $fOutputIO decodeFile'addFPath gfoVersion gfoBinVersion$fFunctorVersionTagged$fBinaryVersionTagged $fBinaryLabel $fBinaryTInfo $fBinaryTerm $fBinaryL$fBinaryLocation $fBinaryInfo $fBinaryPMCFG$fBinaryOptions$fBinaryModuleStatus$fBinaryOpenSpec$fBinaryMInclude$fBinaryModuleType$fBinaryModuleInfo$fBinaryGrammar$fBinaryModuleName $fBinaryIdent checkError checkWarncheckAccumErroraccumulateError commitCheckrunCheck runCheck' checkInModuleCheckunCheck CheckResultSuccessFail AccumulateNonFatalMessagehandle' checkCond checkWarnings parallelCheckcheckMapcheckMapRecovercheckIn$fErrorMonadCheck$fApplicativeCheck $fMonadCheck$fFunctorCheckrenameSourceTerm renamePattern StatusInfo StatusTreeStatus renameModulerenameIdentTermrenameIdentTerm' info2status tree2status buildStatusmodInfo2status self2status renameInfo renameTerm renameContextsubstituteLTypecheck2 computeLType inferLType getOverload checkLType pattContext checkEqLTypecheckIfEqLTypetermWithppqType checkLookup initTCEnvtype2valcont2expcont2val justTypeCheck notJustMetagrammar2theory checkContextcheckTypcheckDef checkConstrs instSigma subsCheck subsCheckRhounifyVar instantiatequantify getMetaVars getFreeVarszonkTermTcResultTcFailTcOkBoundUnboundTauRhoSigma inferSigma checkSigmatcRhotcCasetcPattinferRecFieldscheckRecFields tcRecField subsCheckFununifyFun skolemise allBinderstcErrortcWarn unimplementednewVar scopeTypes buildAnyTree rebuildModule extendMod unifyMaybeL extendModule globalizeLoc unifyAnyInfo unifAbsArrity unifAbsDefs HappyAddrHappyA#HappyStk Happy_IntList HappyConsHappyAny HappyAbsSynhappyIn9 happyOut9 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 happyInTok happyOutTokhappyActOffsetshappyGotoOffsetshappyDefActions happyCheck happyTablehappyReduceArr happy_n_termshappy_n_nonterms happyReduce_6happyReduction_6 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_265 happyNewToken happyError_ happyThen happyReturn happyThen1 happyReturn1 happyError'pModDefpTopDef pModHeaderpExppCFRules pEBNFRuleshappySeq happyErrormkListIdmkConsIdmkBaseId listCatDeftryLocmkR mkOverload isOverloading checkInfoTypemkAltsmkL happyParse happyAccept happyDoActionindexShortOffAddr happyShifthappySpecReduce_0happySpecReduce_1happySpecReduce_2happySpecReduce_3 happyReducehappyMonadReducehappyMonad2Reduce happyDrop happyDropStk happyGoto happyFail notHappyAtAll happyTcHack happyDoSeq happyDontSeq getAllFilesgetOptionsFromFile CompStatusCSEnvCSReadCSCompModEnvModName gfImports gfoImports selectFormatimportsOfModuleparseModHeader parseSourcetoUTF8 recodeToUTF8 getPragmas getFilePath TemporaryTemprunPreprocessorbuiltin_preprocessors mkPresent mkMinimal omit_lines writeTempreadTempkeepTemp removeTemp writeTags getLocalTags getImports gftagsFile gf2gftagscf2pgfcf2abstrcf2concr mkRuleNameAPIfuncNoAPIAppFunc BasicFunc exprToAPI stringToAPI exprToFuncmkAPI computeAPIoptimize optimizeNP hiddenCats optimizable rephraseable printAPIfunc syntaxFuncsdoPossibilitiesdoProvideExampledoAbstractExampleabstractExampledoTestFunctiongetLimit readParsePGF parseEnvirongetInpm2r readResultenviron instExpMetainstMetaTreeOptreeOp allTreeOpslargestsmallest treeChunkssubtreesfunNodes PredefinedNonExistIntsIntPTruePFalsePBoolLessIntEqIntPlusLengthIsUpperToLowerToUpperOccursOccurEqStrDpTkTakeDropBindBindingWildVStrsVPVSVCVTVVVProdVAbsVCApp$fEqBindPredeftoValue fromValueverrorpredefpredefs predefName predefNames predefListdeltaboolVnormstrictstringswapbugppbug$fPredefPredefined $fPredefValue $fPredef[] $fPredefBool $fPredefIntresourceValuesvalue0value strsFromValue OpenValueStack LocalScope CompleteEnvCEsrcgrrvsoptsgloclocal GlobalEnvGEResourceValuesnfxextglobaltoplevelvarpickresourcevconcatprojok1ok2ok2p unlockVRecplusVRecextRgluevfv valueMatch valueTable paramValues paramValues' paramValues''push'pushapply'vapplyvbetavaryvaryList linPattVarspattVars allPattVarsix<#@@ppTbuglocconcretes2haskellconcrete2haskell haskPreamble toHaskellcon tableTypes paramTypesrecordscoerceconvertconvert'patVarsconvTypeproj'rconrcon' rcon_nameto_rconto_rcon' recordType labelClass paramTypeenumConqual checkModule checkInfocheckReservedId linTypeOfTypecheckRestrictedInheritancecheckCompleteGrammaroptimizeModulepartEval mkLinDefaultevalInfo partEvalNewmkLinReference evalPrintnamefactor ProtoFCatPathSchemavariantschoicesgetAllParamValuesFunSetProdSetPMCFGEnvSeqSetPFCatCNilCSelCProjCParCStrCTblCRecCnvMonadCMunCMBranchReturnVariant 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 CompileSourcecompileSourceModulewriteGFO intermOutidumpwarnOut CollectOutputCOunCOHiderevealIOCacheopcache batchCompile1 splitEither canonicalgetPathFromFile relativeTo newIOCache readIOCache$fErrorMonadCollectOutput$fOutputCollectOutput$fMonadIOCollectOutput$fMonadCollectOutput$fApplicativeCollectOutput$fFunctorCollectOutput $fOrdHide$fEqHidegrammar2haskellelemCat HSkeletonOIdent predefInst datatypes gfinstances hDatatypenonLexicalRuleslexicalConstructorpredefTypeSkel datatypesGADT hCatTypeGADT hDatatypeGADThEqGADTprCompos gfInstance hInstancemkVarsmkSVars fInstance hSkeletonupdateSkeleton isListCat isBaseFun isConsFunbaseSize composClass AlphaConvert alphaConvert ConvertEnvPLPrintplpplpsgrammar2prolog plAbstract plConcreteplCatplFunplSeqplHeaderplFactsplTermplListplOperplVarplAtomisAlphaNumUnderscorecreateLogicalVariableisLogicalVariablelogicalVariablePrefixemptyEnvalphaConvertHypo$fAlphaConvertEquation$fAlphaConvertExpr$fAlphaConvertType$fAlphaConvert[] $fPLPrint[] $fPLPrintChar$fPLPrintSymbol$fPLPrintLiteral $fPLPrintCId$fPLPrintEquation $fPLPrintPatt $fPLPrintExpr $fPLPrintTypegrammar2lambdaprolog_modgrammar2lambdaprolog_sigppExport ppFunPredppClausemkVarppPredppKinddotdepTypedepHypodepExprequation2clause patt2expr expr2goalpgf2js abstract2js absdef2jslit2js concrete2jsmkSeqchildrenfrule2jsfarg2jsffun2jsseq2jssym2jsalt2jsnew mapToJSObj pgf2pythonpyAbsdef pyLiteral pyConcrete pyProductionpySymbolpyDictpyListpyTuplepyCatpyFunpySeqpyStrpyCIdpyIndentProfile bnfPrintertoBNFpgfToCFG grammar2vxml CatQuestionsSkeleton pgfSkeleton catQuestions catQuestiongetCatQuestion skel2vxml grammarURIcatFormscat2formfun2sub catFormIdvxmlformfield subdialogfilled vxmlGrammarprompt promptStringrepromptif_if_elsecond goto_itemreturn_block blockCondnomatchhelpparamscript scriptURIgenerateByteCodecompileEquationsmkFail compileBody compileFun compileArg compileLambda shiftIValpushArgstuckArgssetArgsfreeVarsi2ipush_is mkCanon2pgfmi2imkExpmkPatt mkContextmkDefmkArity genCncCats genCncFuns genPrintNames mkMapArray CompileEnv compileModule compileOne'emptyCompileEnvextendCompileEnv importGrammar ioUnionPGF importSourceimportCFrunSIOhRunSIOGHC.IO.Handle.FDstdout captureSIOSIOunSPutStrLn restrictedrestrictedSystem restrictedIOlift0lift1putStrLn putStrLnFlushprint getCPUTime newStdGenlazySIO $fMonadSIO$fApplicativeSIO $fFunctorSIOmake_facfgToFA' sortSubLatscompileAutomatamake_fa1addStatesForCatsMFA MutRecSets MutRecSetmrCats mrNonRecRules mrRecRulesmrRec RecursivityNotRLeftRRightRcfgToFAcompileAutomatoncfgToMFAbuildMFA mfaStartDFAmfaToDFAremoveUnusedSubLats subLatUseMap usedSubLats mutRecSets revMultiMapSRGNTSRGAltsrgName srgStartCat srgLanguagemakeNonLeftRecursiveSRG renameCats mergeItems SRGSymbolSRGItemSRGRuleSRGsrgExternalCatssrgRules ebnfPrintermakeSRGsetDefaultCFGTransformmaybeTransform traceStatsstatsmakeNonRecursiveSRGmkSRGcfRulesToSRGRule srgLHSCat isExternalCatsrgItem groupTokens ungroupTokensprSRG lookupFM_width gslPrinterprGSLprItemprSymbolprCat firstToUpper showTokencomment emptyLine$++$SISRTagprSISR topCatSISRprofileInitSISRusedArgscatSISRprofileFinalSISRfmtOutfmtRefasstreeobjsrgsAbnfPrintersrgsAbnfNonRecursivePrintershowDocprABNFaltsrulemeta prepunctuatesrgsXmlPrintersrgsXmlNonRecursivePrinter prSrgsXmlmkItemsymItemoneOfgrammar optimizeSRGS jsgfPrinterprJSGFSLFWord renameSubs slfSubPrinter isNonWordSLF_FASLFEdgeeIdeStarteEndSLFNode SLFSubLatnLatnIdnWordnTagSLFslfNodesslfEdgesSLFsmkFAs slfStyleFAslfGraphvizPrinterslfSubGraphvizPrintergvSLFFA slfPrinterautomatonToSLFmfaNodeToSLFNode mkSLFNode mkSLFSubLat mkSLFEdgeprSLFsprSLFprOneSLFshowWordprFields regexpPrintermultiRegexpPrinterprREsmfa2res outputConcrcompileSourceFilescompileCFFiles unionPGFFiles writeOutput grammarName grammarName' outputJustPGF outputPathwritinginfinity CommandOutputPipedfromPipe CommandInfoexecsynopsissyntax explanationlongnameoptionsflagsexamplesneedsTypeCheckPGFEnv fromStrings fromExprs fromStringpipeWithMessage pipeMessage pipeExprsvoidtoString toStringsemptyCommandInfo lookCommandcommandHelpAll commandHelp' commandHelpcommandHelpTagssection optionallycompactmkEx allCommandsstringOpOptions treeOpOptions treeOpFlagstranslationQuizmorphologyQuiz prLexcLexiconprFullFormLexicon prAllWordsprMorphoAnalysistrie CommandEnv multigrammarmorphos commandmacros expmacroscommands mkCommandEnvemptyCommandEnvinterpretCommandLine interpretPipe appCommand interpret getCommandgetCommandInfo checkOptsgetCommandTreesCncJmentIgnoredLiLCPa parseModule convModule convAbstract convExtends convExtend convAbsJments convAbsJmentconvSimpleTypeconvId convModId convConcrete convOpensconvOpen convCncJments convCncJmentconvBind jmentList jmentLocationlocHMserver 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$fErrorResponseloopreadAndExecute1 readCommandoptionallyShowCPUTimeexecute1CompletionType CmplIdentCmplOptCmplStrCmplCmdGFEnvretain commandenvhistorybeQuietshellprintExceptioncheckComputeTerm fetchCommand importInEnv tryGetLinewelcome emptyGFEnvwordCompletionwc_type