!       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~NoneD pgf2TAn abstract data type representing multilingual grammar in Portable Grammar Format.       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijNone"pgf2NAn data type that represents identifiers for functions and categories in PGF.pgf2.Constructs an expression by lambda abstractionpgf27Decomposes an expression into an abstraction and a bodypgf2HConstructs an expression by applying a function to a list of expressionspgf2:Decomposes an expression into an application of a functionpgf2.Constructs an expression from a string literalpgf2.Decomposes an expression into a string literalpgf20Constructs an expression from an integer literalpgf20Decomposes an expression into an integer literalpgf2+Constructs an expression from a real numberpgf23Decomposes an expression into a real number literalpgf2+Constructs a meta variable as an expressionpgf2-Decomposes an expression into a meta variablepgf2Nthis functions is only for backward compatibility with the old Haskell runtimepgf2 parses a k as an expression!pgf2renders an expression as a kz. The list of identifiers is the list of all free variables in the expression in order reverse to the order of binding.pgf2Name of functionpgf2Name of syntactic category"l mno  pqrstu !vNone+%"pgf2"O represents a hypothesis in a type i.e. in the type A -> B, A is the hypothesis$pgf2 parses a k as a type%pgf2renders a type as a kt. The list of identifiers is the list of all free variables in the type in order reverse to the order of binding.&pgf2screates a type from a list of hypothesises, a category and a list of arguments for the category. The operation $mkType [h_1,...,h_n] C [e_1,...,e_m] will create "h_1 -> ... -> h_n -> C e_1 ... e_m'pgf2eDecomposes a type into a list of hypothesises, a category and a list of arguments for the category.(pgf2renders a type as a kt. The list of identifiers is the list of all free variables in the type in order reverse to the order of binding. "#wxy$%&z{|'(Krasimir AngelovstableportableNone1CV$,pgf2cBracketedString 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.-pgf2$this is the leaf i.e. a single token.pgf2-the surrounding tokens must be bound together/pgf2this 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 analysis string. If the grammar is reduplicating then the constituent indices will be the same for all brackets that represents the same constituent. The second B is the name of the abstract function that generated this phrase.}pgf2The oracle is a triple of functions. The first two take a category name and a linearization field name and they should return True/False when the corresponding prediction or completion is appropriate. The third function is the oracle for literals.0pgf2RThis data type encodes the different outcomes which you could get from the parser.1pgf2The integer is the position in number of unicode characters where the parser failed. The string is the token where the parser have failed.2pgf2sIf the parsing and the type checking are successful we get the abstract syntax trees as either a list or a chart.3pgf2The sentence is not complete.4pgf23This triple is returned by all functions that deal with the grammar's lexicon. Its first element is the name of an abstract lexical function which can produce a given word or a multiword expression (i.e. this is the lemma). After that follows a string which describes the particular inflection form.The last element is a logarithm from the the probability of the function. The probability is not conditionalized on the category of the function. This makes it possible to compare the likelihood of two functions even if they have different types. Cpgf24Reads file in Portable Grammar Format and produces . structure. The file is usually produced with: $ gf -make <grammar file name>Epgf2/List of all languages available in the grammar.Hpgf2Generates an exhaustive possibly infinite list of all abstract syntax expressions of the given type. The expressions are ordered by their probability.Ipgf2HThe abstract language name is the name of the top-level abstract moduleJpgf2The 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.Kpgf2The type of a functionLpgf2The type of a functionMpgf2.Checks an expression against a specified type.Npgf2Tries to infer the type of an expression. Note that even if the expression is type correct it is not always possible to infer its type in the GF type system. In this case the function returns an error.Opgf2LCheck whether a type is consistent with the abstract syntax of the grammar.Wpgf25Renders an abstract syntax tree in a Graphviz format.Zpgf2Z takes a string which must be a single word or a multiword expression. It then computes the list of all possible morphological analyses.[pgf2[ takes an arbitrary string an produces a list of all places where lexical items from the grammar have been identified (i.e. cohorts). The list consists of triples of the format (start,ans,end) , where  start-end% identifies the span in the text and ans< is the list of possible morphological analyses similar to Z. The list is sorted first by the start! position and after than by the endY position. This can be used for instance if you want to filter only the longest matches.cpgf2SReturns True if there is a linearization defined for that function in that languagedpgf24Linearizes an expression as a string in the languageepgf26Generates all possible linearizations of an expressionfpgf25Generates a table of linearizations for an expressiongpgf25Generates a table of linearizations for an expressionipgf2KRenders the bracketed string as a string where the brackets are shown as (S ...) where S is the category.jpgf29Extracts the sequence of tokens from the bracketed stringopgf24List of all functions defined in the abstract syntaxppgf2,List of all functions defined for a categoryqpgf2zList of all categories defined in the grammar. The categories are defined in the abstract syntax with the 'cat' keyword.spgf2Callbacks for the App grammar~pgf2;Named entity recognition for the App grammar (based on ..javaorggrammaticalframeworkpgf/NercLiteralCallback.java)pgf25Callback to parse arbitrary words as chunks (from ..javaorggrammaticalframework pgf/UnknownLiteralCallback.java)Apgf2Name of concrete syntaxBpgf2Name of abstract syntax`pgf2 the language with which we parsepgf2the start categorypgf2the input sentencepgf2mthe heuristic factor. A negative value tells the parser to lookup up the default from the grammar flagspgf2 a list of callbacks for literal categories. The arguments of the callback are: the index of the constituent for the literal category; the input sentence; the current offset in the sentence. If a literal has been recognized then the output should be Just (expr,probability,end_offset)apgf2 the language with which we parsepgf2the start categorypgf2the input sentencepgf2mthe heuristic factor. A negative value tells the parser to lookup up the default from the grammar flagspgf2 a list of callbacks for literal categories. The arguments of the callback are: the index of the constituent for the literal category; the input sentence; the current offset in the sentence. If a literal has been recognized then the output should be Just (expr,probability,end_offset)pgf2the maximal number of rootsbpgf2 the language with which we parsepgf2the start categorypgf2the input sentencepgf2 the language with which we parsepgf2the start categorypgf2the input sentencen  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrsnCDBIqropKLc ! RSTUQ#" J$%(&'MNOPAEFGdefgkl,-./ijnhm0123_`abH4Z[^\]56789:;<=>?@VWXY*+)sNoneQVypgf2a string constantzpgf2an integer constant{pgf2a floating point constant pgf2Concrete syntax flagspgf2 Printnamespgf2Lindefspgf2Linrefspgf2 Productionspgf2,Concrete functions (must be sorted by Fun)pgf2%Sequences (must be sorted)pgf2Concrete categories pgf2!The total count of the categories; vwxyz{|}~;|}~xyz{wv        !"#$%&'()*+,--./01234567789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwx&yz{|}~!pgf2-1.2.0-GnIPkqh64Oq4bK0FjHO6S2PGF2 PGF2.InternalPGF2.FFI PGF2.Expr PGF2.TypePArgFIdConcrconcr touchConcrPGFpgftouchPGFExprBindTypeExplicitImplicitFunCatCIdmkAbsunAbsmkAppunAppmkStrunStrmkIntunIntmkFloatunFloatmkMetaunMetamkCIdreadExprpExprshowExprHypoTypereadTypeshowTypemkTypeunType showContextLiteralCallbackPGFErrorBracketedStringLeafBINDBracket ParseOutput ParseFailedParseOkParseIncompleteMorphoAnalysisGraphvizOptionsnoLeavesnoFunnoCatnoDepnodeFontleafFont nodeColor leafColor nodeEdgeStyle leafEdgeStyleConcNameAbsNamereadPGFshowPGF languages concreteName languageCode generateAll abstractNamestartCat functionTypefunctionIsConstructor checkExpr inferExpr checkTypecomputetreeProbabilityexprHashexprSize exprFunctionsexprSubstitutegraphvizDefaultsgraphvizAbstractTreegraphvizParseTreegraphvizWordAlignment lookupMorpho lookupCohorts filterBest filterLongestfullFormLexiconparseparseWithHeuristics parseToChartlookupSentencehasLinearization linearize linearizeAlltabularLinearizetabularLinearizeAllcategoryFieldsshowBracketedStringflattenBracketedStringbracketedLinearizebracketedLinearizeAll alignWords printName functionsfunctionsByCat categoriescategoryContextliteralCallbacks$fExceptionPGFError$fShowPGFError ConcrInfo AbstrInfoLiteralLStrLIntLFltFunId ProductionPApplyPCoerceSymbolSymCatSymLitSymVarSymKSSymKPSymBINDSymNE SymSOFT_BIND SymSOFT_SPACESymCAPIT SymALL_CAPITToken globalFlags abstrFlags concrFlagsconcrTotalCatsconcrCategoriesconcrProductionsconcrTotalFuns concrFunctionconcrTotalSeqs concrSequence isPredefFIdbuildeAbseAppeMetaeFuneVareTypedeImplArghypodTypnewAbstrnewConcrnewPGFwritePGF $fEqSymbol $fOrdSymbol $fShowSymbol$fEqProduction$fOrdProduction$fShowProduction $fEqLiteral $fOrdLiteral $fShowLiteralMapItorCallbackLookupMorphoCallbackOracleLiteralCallbackOracleCallbackLiteralPredictCallbackLiteralMatchCallback MetaCallback BindCallbackNonExistCallbackPhraseCallbackSymbolTokenCallback PgfParsingPgfProductionApply PgfCncFunPgfCCat PgfAbsCat PgfAbsFun PgfBindTypePgfGraphvizOptions PgfLinFuncs PgfCncTreePgfOracleCallbackPgfCallbacksMapPgfTypePgfPrintContextPgfMorphoCallbackPgfFullFormEntry PgfExprParser PgfExprProbPgfExprPgfConcrPgfApplicationPgfPGFCUInt8CSizeTGuUCSGuHash GuVariantGuPoolGuBufGuSeqGuHasher GuMapItorGuMap GuStringBufGuStringGuTypeGuKindGuOutGuInGuExnGuEnumTouchpgf_production_is_lexical pgf_lzr_indexpgf_parser_indexpgf_graphviz_word_alignmentpgf_graphviz_parse_treepgf_graphviz_abstract_tree pgf_read_type pgf_read_expr pgf_printpgf_generate_allpgf_print_contextpgf_print_typepgf_print_expr_tuplepgf_print_expr pgf_computepgf_check_typepgf_infer_exprpgf_check_exprpgf_compute_tree_probabilitypgf_expr_substitutepgf_expr_functions pgf_expr_size pgf_expr_hash pgf_expr_eqpgf_expr_aritypgf_expr_unlitpgf_expr_float pgf_expr_intpgf_expr_stringpgf_expr_unmeta pgf_expr_metapgf_expr_unabs pgf_expr_abspgf_expr_unapplypgf_expr_applypgf_fullform_get_analysespgf_fullform_get_stringpgf_fullform_lexiconwrapMapItorCallbackwrapLookupMorphoCallbackpgf_lookup_cohortspgf_lookup_morphopgf_parse_with_oraclehspgf_new_oracle_callbackwrapOracleLiteralCallbackwrapOracleCallbackhspgf_callbacks_map_add_literalpgf_new_callbacks_mapwrapLiteralPredictCallbackwrapLiteralMatchCallbackpgf_lookup_sentencepgf_parse_with_heuristicspgf_ccat_to_rangepgf_get_parse_rootspgf_parse_to_chartpgf_align_wordswrapSymbolMetaCallbackwrapSymbolBindCallbackwrapSymbolNonExistCallbackwrapPhraseCallbackwrapSymbolTokenCallbackpgf_lzr_get_tablepgf_lzr_linearizepgf_lzr_linearize_simplepgf_lzr_wrap_linrefpgf_lzr_concretize pgf_linearizepgf_has_linearizationpgf_print_namepgf_function_is_constructorpgf_function_typepgf_iter_functions_by_catpgf_iter_functionspgf_category_fieldspgf_category_probpgf_category_context pgf_start_catpgf_iter_categoriespgf_language_codepgf_concrete_unloadpgf_concrete_loadpgf_concrete_namepgf_get_languagepgf_iter_languagespgf_abstract_name pgf_writepgf_readgu_alloc_variantgu_variant_datagu_variant_taggu_null_structgu_string_hashergu_addr_hasher gu_int_hasher gu_map_itergu_map_find_default gu_map_insert gu_make_map gu_make_buf gu_make_seqgu_utf8_encodegu_utf8_decodegu_string_buf_freeze gu_enum_next gu_file_ingu_string_buf_outgu_new_string_buf gu_string_in gu_exn_raise gu_exn_caughtgu_exn_is_raised gu_new_exngu_pool_finalizer gu_pool_freegu_malloc_aligned gu_malloc gu_new_poolfopengu_exn_type_GuErrnogu_exn_type_GuEOFgu_exn_type_PgfLinNonExistgu_exn_type_PgfExngu_exn_type_PgfParseErrorgu_exn_type_PgfTypeError withGuPoolnewOutpeekUtf8CStringpeekUtf8CStringLenpokeUtf8CStringnewUtf8CString utf8Length peekSequence newSequencepeekFIddeRefbaseGHC.BaseString ParserGetc touchExprexprwrapParserGetcpgf_expr_parser_exprpgf_new_parserwildCIdreadExprConstr exprDataType newPrintCtxt touchTypetyppokeHypo pokeExprs touchHypoOraclenercchunkparseWithOracle