diff --git a/doc/gf-help.txt b/doc/gf-help.txt new file mode 100644 index 000000000..d77e9aff7 --- /dev/null +++ b/doc/gf-help.txt @@ -0,0 +1,699 @@ +=GF Command Help= + +Each command has a long and a short name, options, and zero or more +arguments. Commands are sorted by functionality. The short name is +given first. + +Commands and options marked with * are currently not implemented. + +==Commands that change the state== + +``` +i, import: i File + Reads a grammar from File and compiles it into a GF runtime grammar. + Files "include"d in File are read recursively, nubbing repetitions. + If a grammar with the same language name is already in the state, + it is overwritten - but only if compilation succeeds. + The grammar parser depends on the file name suffix: + .gf normal GF source + .gfc canonical GF + .gfr precompiled GF resource + .gfcm multilingual canonical GF + .gfe example-based grammar files (only with the -ex option) + .gfwl multilingual word list (preprocessed to abs + cncs) + .ebnf Extended BNF format + .cf Context-free (BNF) format + .trc TransferCore format + options: + -old old: parse in GF<2.0 format (not necessary) + -v verbose: give lots of messages + -s silent: don't give error messages + -src from source: ignore precompiled gfc and gfr files + -gfc from gfc: use compiled modules whenever they exist + -retain retain operations: read resource modules (needed in comm cc) + -nocf don't build old-style context-free grammar (default without HOAS) + -docf do build old-style context-free grammar (default with HOAS) + -nocheckcirc don't eliminate circular rules from CF + -cflexer build an optimized parser with separate lexer trie + -noemit do not emit code (default with old grammar format) + -o do emit code (default with new grammar format) + -ex preprocess .gfe files if needed + -prob read probabilities from top grammar file (format --# prob Fun Double) + -treebank read a treebank file to memory (xml format) + flags: + -abs set the name used for abstract syntax (with -old option) + -cnc set the name used for concrete syntax (with -old option) + -res set the name used for resource (with -old option) + -path use the (colon-separated) search path to find modules + -optimize select an optimization to override file-defined flags + -conversion select parsing method (values strict|nondet) + -probs read probabilities from file (format (--# prob) Fun Double) + -preproc use a preprocessor on each source file + -noparse read nonparsable functions from file (format --# noparse Funs) + examples: + i English.gf -- ordinary import of Concrete + i -retain german/ParadigmsGer.gf -- import of Resource to test + +r, reload: r + Executes the previous import (i) command. + +rl, remove_language: rl Language + Takes away the language from the state. + +e, empty: e + Takes away all languages and resets all global flags. + +sf, set_flags: sf Flag* + The values of the Flags are set for Language. If no language + is specified, the flags are set globally. + examples: + sf -nocpu -- stop showing CPU time + sf -lang=Swe -- make Swe the default concrete + +s, strip: s + Prune the state by removing source and resource modules. + +dc, define_command Name Anything + Add a new defined command. The Name must star with '%'. Later, + if 'Name X' is used, it is replaced by Anything where #1 is replaced + by X. + Restrictions: Currently at most one argument is possible, and a defined + command cannot appear in a pipe. + To see what definitions are in scope, use help -defs. + examples: + dc %tnp p -cat=NP -lang=Eng #1 | l -lang=Swe -- translate NPs + %tnp "this man" -- translate and parse + +dt, define_term Name Tree + Add a constant for a tree. The constant can later be called by + prefixing it with '$'. + Restriction: These terms are not yet usable as a subterm. + To see what definitions are in scope, use help -defs. + examples: + p -cat=NP "this man" | dt tm -- define tm as parse result + l -all $tm -- linearize tm in all forms +``` + +==Commands that give information about the state== + +``` +pg, print_grammar: pg + Prints the actual grammar (overridden by the -lang=X flag). + The -printer=X flag sets the format in which the grammar is + written. + N.B. since grammars are compiled when imported, this command + generally does not show the grammar in the same format as the + source. In particular, the -printer=latex is not supported. + Use the command tg -printer=latex File to print the source + grammar in LaTeX. + options: + -utf8 apply UTF8-encoding to the grammar + flags: + -printer + -lang + -startcat -- The start category of the generated grammar. + Only supported by some grammar printers. + examples: + pg -printer=cf -- show the context-free skeleton + +pm, print_multigrammar: pm + Prints the current multilingual grammar in .gfcm form. + (Automatically executes the strip command (s) before doing this.) + options: + -utf8 apply UTF8 encoding to the tokens in the grammar + -utf8id apply UTF8 encoding to the identifiers in the grammar + examples: + pm | wf Letter.gfcm -- print the grammar into the file Letter.gfcm + pm -printer=graph | wf D.dot -- then do 'dot -Tps D.dot > D.ps' + +vg, visualize_graph: vg + Show the dependency graph of multilingual grammar via dot and gv. + +po, print_options: po + Print what modules there are in the state. Also + prints those flag values in the current state that differ from defaults. + +pl, print_languages: pl + Prints the names of currently available languages. + +pi, print_info: pi Ident + Prints information on the identifier. +``` + +==Commands that execute and show the session history== + +``` +eh, execute_history: eh File + Executes commands in the file. + +ph, print_history; ph + Prints the commands issued during the GF session. + The result is readable by the eh command. + examples: + ph | wf foo.hist" -- save the history into a file +``` + + +==Linearization, parsing, translation, and computation== + +``` +l, linearize: l PattList? Tree + Shows all linearization forms of Tree by the actual grammar + (which is overridden by the -lang flag). + The pattern list has the form [P, ... ,Q] where P,...,Q follow GF + syntax for patterns. All those forms are generated that match with the + pattern list. Too short lists are filled with variables in the end. + Only the -table flag is available if a pattern list is specified. + HINT: see GF language specification for the syntax of Pattern and Term. + You can also copy and past parsing results. + options: + -struct bracketed form + -table show parameters (not compatible with -record, -all) + -record record, i.e. explicit GF concrete syntax term (not compatible with -table, -all) + -all show all forms and variants (not compatible with -record, -table) + -multi linearize to all languages (can be combined with the other options) + flags: + -lang linearize in this grammar + -number give this number of forms at most + -unlexer filter output through unlexer + examples: + l -lang=Swe -table -- show full inflection table in Swe + +p, parse: p String + Shows all Trees returned for String by the actual + grammar (overridden by the -lang flag), in the category S (overridden + by the -cat flag). + options for batch input: + -lines parse each line of input separately, ignoring empty lines + -all as -lines, but also parse empty lines + -prob rank results by probability + -cut stop after first lexing result leading to parser success + -fail show strings whose parse fails prefixed by #FAIL + -ambiguous show strings that have more than one parse prefixed by #AMBIGUOUS + options for selecting parsing method: + -fcfg parse using a fast variant of MCFG (default is no HOAS in grammar) + -old parse using an overgenerating CFG (default if HOAS in grammar) + -cfg parse using a much less overgenerating CFG + -mcfg parse using an even less overgenerating MCFG + Note: the first time parsing with -cfg, -mcfg, and -fcfg may take a long time + options that only work for the -old default parsing method: + -n non-strict: tolerates morphological errors + -ign ignore unknown words when parsing + -raw return context-free terms in raw form + -v verbose: give more information if parsing fails + flags: + -cat parse in this category + -lang parse in this grammar + -lexer filter input through this lexer + -parser use this parsing strategy + -number return this many results at most + examples: + p -cat=S -mcfg "jag är gammal" -- parse an S with the MCFG + rf examples.txt | p -lines -- parse each non-empty line of the file + +at, apply_transfer: at (Module.Fun | Fun) + Transfer a term using Fun from Module, or the topmost transfer + module. Transfer modules are given in the .trc format. They are + shown by the 'po' command. + flags: + -lang typecheck the result in this lang instead of default lang + examples: + p -lang=Cncdecimal "123" | at num2bin | l -- convert dec to bin + +tb, tree_bank: tb + Generate a multilingual treebank from a list of trees (default) or compare + to an existing treebank. + options: + -c compare to existing xml-formatted treebank + -trees return the trees of the treebank + -all show all linearization alternatives (branches and variants) + -table show tables of linearizations with parameters + -record show linearization records + -xml wrap the treebank (or comparison results) with XML tags + -mem write the treebank in memory instead of a file TODO + examples: + gr -cat=S -number=100 | tb -xml | wf tb.xml -- random treebank into file + rf tb.xml | tb -c -- compare-test treebank from file + rf old.xml | tb -trees | tb -xml -- create new treebank from old + +ut, use_treebank: ut String + Lookup a string in a treebank and return the resulting trees. + Use 'tb' to create a treebank and 'i -treebank' to read one from + a file. + options: + -assocs show all string-trees associations in the treebank + -strings show all strings in the treebank + -trees show all trees in the treebank + -raw return the lookup result as string, without typechecking it + flags: + -treebank use this treebank (instead of the latest introduced one) + examples: + ut "He adds this to that" | l -multi -- use treebank lookup as parser in translation + ut -assocs | grep "ComplV2" -- show all associations with ComplV2 + +tt, test_tokenizer: tt String + Show the token list sent to the parser when String is parsed. + HINT: can be useful when debugging the parser. + flags: + -lexer use this lexer + examples: + tt -lexer=codelit "2*(x + 3)" -- a favourite lexer for program code + +g, grep: g String1 String2 + Grep the String1 in the String2. String2 is read line by line, + and only those lines that contain String1 are returned. + flags: + -v return those lines that do not contain String1. + examples: + pg -printer=cf | grep "mother" -- show cf rules with word mother + +cc, compute_concrete: cc Term + Compute a term by concrete syntax definitions. Uses the topmost + resource module (the last in listing by command po) to resolve + constant names. + N.B. You need the flag -retain when importing the grammar, if you want + the oper definitions to be retained after compilation; otherwise this + command does not expand oper constants. + N.B.' The resulting Term is not a term in the sense of abstract syntax, + and hence not a valid input to a Tree-demanding command. + flags: + -table show output in a similar readable format as 'l -table' + -res use another module than the topmost one + examples: + cc -res=ParadigmsFin (nLukko "hyppy") -- inflect "hyppy" with nLukko + +so, show_operations: so Type + Show oper operations with the given value type. Uses the topmost + resource module to resolve constant names. + N.B. You need the flag -retain when importing the grammar, if you want + the oper definitions to be retained after compilation; otherwise this + command does not find any oper constants. + N.B.' The value type may not be defined in a supermodule of the + topmost resource. In that case, use appropriate qualified name. + flags: + -res use another module than the topmost one + examples: + so -res=ParadigmsFin ResourceFin.N -- show N-paradigms in ParadigmsFin + +t, translate: t Lang Lang String + Parses String in Lang1 and linearizes the resulting Trees in Lang2. + flags: + -cat + -lexer + -parser + examples: + t Eng Swe -cat=S "every number is even or odd" + +gr, generate_random: gr Tree? + Generates a random Tree of a given category. If a Tree + argument is given, the command completes the Tree with values to + the metavariables in the tree. + options: + -prob use probabilities (works for nondep types only) + -cf use a very fast method (works for nondep types only) + flags: + -cat generate in this category + -lang use the abstract syntax of this grammar + -number generate this number of trees (not impl. with Tree argument) + -depth use this number of search steps at most + examples: + gr -cat=Query -- generate in category Query + gr (PredVP ? (NegVG ?)) -- generate a random tree of this form + gr -cat=S -tr | l -- gererate and linearize + +gt, generate_trees: gt Tree? + Generates all trees up to a given depth. If the depth is large, + a small -alts is recommended. If a Tree argument is given, the + command completes the Tree with values to the metavariables in + the tree. + options: + -metas also return trees that include metavariables + -all generate all (can be infinitely many, lazily) + -lin linearize result of -all (otherwise, use pipe to linearize) + flags: + -depth generate to this depth (default 3) + -atoms take this number of atomic rules of each category (default unlimited) + -alts take this number of alternatives at each branch (default unlimited) + -cat generate in this category + -nonub don't remove duplicates (faster, not effective with -mem) + -mem use a memorizing algorithm (often faster, usually more memory-consuming) + -lang use the abstract syntax of this grammar + -number generate (at most) this number of trees (also works with -all) + -noexpand don't expand these categories (comma-separated, e.g. -noexpand=V,CN) + -doexpand only expand these categories (comma-separated, e.g. -doexpand=V,CN) + examples: + gt -depth=10 -cat=NP -- generate all NP's to depth 10 + gt (PredVP ? (NegVG ?)) -- generate all trees of this form + gt -cat=S -tr | l -- generate and linearize + gt -noexpand=NP | l -mark=metacat -- the only NP is meta, linearized "?0 +NP" + gt | l | p -lines -ambiguous | grep "#AMBIGUOUS" -- show ambiguous strings + +ma, morphologically_analyse: ma String + Runs morphological analysis on each word in String and displays + the results line by line. + options: + -short show analyses in bracketed words, instead of separate lines + -status show just the work at success, prefixed with "*" at failure + flags: + -lang + examples: + wf Bible.txt | ma -short | wf Bible.tagged -- analyse the Bible +``` + + +==Elementary generation of Strings and Trees== + +``` +ps, put_string: ps String + Returns its argument String, like Unix echo. + HINT. The strength of ps comes from the possibility to receive the + argument from a pipeline, and altering it by the -filter flag. + flags: + -filter filter the result through this string processor + -length cut the string after this number of characters + examples: + gr -cat=Letter | l | ps -filter=text -- random letter as text + +pt, put_tree: pt Tree + Returns its argument Tree, like a specialized Unix echo. + HINT. The strength of pt comes from the possibility to receive + the argument from a pipeline, and altering it by the -transform flag. + flags: + -transform transform the result by this term processor + -number generate this number of terms at most + examples: + p "zero is even" | pt -transform=solve -- solve ?'s in parse result + +* st, show_tree: st Tree + Prints the tree as a string. Unlike pt, this command cannot be + used in a pipe to produce a tree, since its output is a string. + flags: + -printer show the tree in a special format (-printer=xml supported) + +wt, wrap_tree: wt Fun + Wraps the tree as the sole argument of Fun. + flags: + -c compute the resulting new tree to normal form + +vt, visualize_tree: vt Tree + Shows the abstract syntax tree via dot and gv (via temporary files + grphtmp.dot, grphtmp.ps). + flags: + -c show categories only (no functions) + -f show functions only (no categories) + -g show as graph (sharing uses of the same function) + -o just generate the .dot file + examples: + p "hello world" | vt -o | wf my.dot ;; ! open -a GraphViz my.dot + -- This writes the parse tree into my.dot and opens the .dot file + -- with another application without generating .ps. +``` + +==Subshells== + +``` +es, editing_session: es + Opens an interactive editing session. + N.B. Exit from a Fudget session is to the Unix shell, not to GF. + options: + -f Fudget GUI (necessary for Unicode; only available in X Window System) + +ts, translation_session: ts + Translates input lines from any of the actual languages to all other ones. + To exit, type a full stop (.) alone on a line. + N.B. Exit from a Fudget session is to the Unix shell, not to GF. + HINT: Set -parser and -lexer locally in each grammar. + options: + -f Fudget GUI (necessary for Unicode; only available in X Windows) + -lang prepend translation results with language names + flags: + -cat the parser category + examples: + ts -cat=Numeral -lang -- translate numerals, show language names + +tq, translation_quiz: tq Lang Lang + Random-generates translation exercises from Lang1 to Lang2, + keeping score of success. + To interrupt, type a full stop (.) alone on a line. + HINT: Set -parser and -lexer locally in each grammar. + flags: + -cat + examples: + tq -cat=NP TestResourceEng TestResourceSwe -- quiz for NPs + +tl, translation_list: tl Lang Lang + Random-generates a list of ten translation exercises from Lang1 + to Lang2. The number can be changed by a flag. + HINT: use wf to save the exercises in a file. + flags: + -cat + -number + examples: + tl -cat=NP TestResourceEng TestResourceSwe -- quiz list for NPs + +mq, morphology_quiz: mq + Random-generates morphological exercises, + keeping score of success. + To interrupt, type a full stop (.) alone on a line. + HINT: use printname judgements in your grammar to + produce nice expressions for desired forms. + flags: + -cat + -lang + examples: + mq -cat=N -lang=TestResourceSwe -- quiz for Swedish nouns + +ml, morphology_list: ml + Random-generates a list of ten morphological exercises, + keeping score of success. The number can be changed with a flag. + HINT: use wf to save the exercises in a file. + flags: + -cat + -lang + -number + examples: + ml -cat=N -lang=TestResourceSwe -- quiz list for Swedish nouns +``` + + +==IO-related commands== + +``` +rf, read_file: rf File + Returns the contents of File as a String; error if File does not exist. + +wf, write_file: wf File String + Writes String into File; File is created if it does not exist. + N.B. the command overwrites File without a warning. + +af, append_file: af File + Writes String into the end of File; File is created if it does not exist. + +* tg, transform_grammar: tg File + Reads File, parses as a grammar, + but instead of compiling further, prints it. + The environment is not changed. When parsing the grammar, the same file + name suffixes are supported as in the i command. + HINT: use this command to print the grammar in + another format (the -printer flag); pipe it to wf to save this format. + flags: + -printer (only -printer=latex supported currently) + +* cl, convert_latex: cl File + Reads File, which is expected to be in LaTeX form. + +sa, speak_aloud: sa String + Uses the Flite speech generator to produce speech for String. + Works for American English spelling. + examples: + h | sa -- listen to the list of commands + gr -cat=S | l | sa -- generate a random sentence and speak it aloud + +si, speech_input: si + Uses an ATK speech recognizer to get speech input. + flags: + -lang: The grammar to use with the speech recognizer. + -cat: The grammar category to get input in. + -language: Use acoustic model and dictionary for this language. + -number: The number of utterances to recognize. + +h, help: h Command? + Displays the paragraph concerning the command from this help file. + Without the argument, shows the first lines of all paragraphs. + options + -all show the whole help file + -defs show user-defined commands and terms + -FLAG show the values of FLAG (works for grammar-independent flags) + examples: + h print_grammar -- show all information on the pg command + +q, quit: q + Exits GF. + HINT: you can use 'ph | wf history' to save your session. + +!, system_command: ! String + Issues a system command. No value is returned to GF. + example: + ! ls + +?, system_command: ? String + Issues a system command that receives its arguments from GF pipe + and returns a value to GF. + example: + h | ? 'wc -l' | p -cat=Num +``` + + +==Flags== + +The availability of flags is defined separately for each command. +``` +-cat, category in which parsing is performed. + The default is S. + +-depth, the search depth in e.g. random generation. + The default depends on application. + +-filter, operation performed on a string. The default is identity. + -filter=identity no change + -filter=erase erase the text + -filter=take100 show the first 100 characters + -filter=length show the length of the string + -filter=text format as text (punctuation, capitalization) + -filter=code format as code (spacing, indentation) + +-lang, grammar used when executing a grammar-dependent command. + The default is the last-imported grammar. + +-language, voice used by Festival as its --language flag in the sa command. + The default is system-dependent. + +-length, the maximum number of characters shown of a string. + The default is unlimited. + +-lexer, tokenization transforming a string into lexical units for a parser. + The default is words. + -lexer=words tokens are separated by spaces or newlines + -lexer=literals like words, but GF integer and string literals recognized + -lexer=vars like words, but "x","x_...","$...$" as vars, "?..." as meta + -lexer=chars each character is a token + -lexer=code use Haskell's lex + -lexer=codevars like code, but treat unknown words as variables, ?? as meta + -lexer=textvars like text, but treat unknown words as variables, ?? as meta + -lexer=text with conventions on punctuation and capital letters + -lexer=codelit like code, but treat unknown words as string literals + -lexer=textlit like text, but treat unknown words as string literals + -lexer=codeC use a C-like lexer + -lexer=ignore like literals, but ignore unknown words + -lexer=subseqs like ignore, but then try all subsequences from longest + +-number, the maximum number of generated items in a list. + The default is unlimited. + +-optimize, optimization on generated code. + The default is share for concrete, none for resource modules. + Each of the flags can have the suffix _subs, which performs + common subexpression elimination after the main optimization. + Thus, -optimize=all_subs is the most aggressive one. The _subs + strategy only works in GFC, and applies therefore in concrete but + not in resource modules. + -optimize=share share common branches in tables + -optimize=parametrize first try parametrize then do share with the rest + -optimize=values represent tables as courses-of-values + -optimize=all first try parametrize then do values with the rest + -optimize=none no optimization + +-parser, parsing strategy. The default is chart. If -cfg or -mcfg are + selected, only bottomup and topdown are recognized. + -parser=chart bottom-up chart parsing + -parser=bottomup a more up to date bottom-up strategy + -parser=topdown top-down strategy + -parser=old an old bottom-up chart parser + +-printer, format in which the grammar is printed. The default is + gfc. Those marked with M are (only) available for pm, the rest + for pg. + -printer=gfc GFC grammar + -printer=gf GF grammar + -printer=old old GF grammar + -printer=cf context-free grammar, with profiles + -printer=bnf context-free grammar, without profiles + -printer=lbnf labelled context-free grammar for BNF Converter + -printer=plbnf grammar for BNF Converter, with precedence levels + *-printer=happy source file for Happy parser generator (use lbnf!) + -printer=haskell abstract syntax in Haskell, with transl to/from GF + -printer=haskell_gadt abstract syntax GADT in Haskell, with transl to/from GF + -printer=morpho full-form lexicon, long format + *-printer=latex LaTeX file (for the tg command) + -printer=fullform full-form lexicon, short format + *-printer=xml XML: DTD for the pg command, object for st + -printer=old old GF: file readable by GF 1.2 + -printer=stat show some statistics of generated GFC + -printer=probs show probabilities of all functions + -printer=gsl Nuance GSL speech recognition grammar + -printer=jsgf Java Speech Grammar Format + -printer=jsgf_sisr_old Java Speech Grammar Format with semantic tags in + SISR WD 20030401 format + -printer=srgs_abnf SRGS ABNF format + -printer=srgs_abnf_non_rec SRGS ABNF format, without any recursion. + -printer=srgs_abnf_sisr_old SRGS ABNF format, with semantic tags in + SISR WD 20030401 format + -printer=srgs_xml SRGS XML format + -printer=srgs_xml_non_rec SRGS XML format, without any recursion. + -printer=srgs_xml_prob SRGS XML format, with weights + -printer=srgs_xml_sisr_old SRGS XML format, with semantic tags in + SISR WD 20030401 format + -printer=vxml Generate a dialogue system in VoiceXML. + -printer=slf a finite automaton in the HTK SLF format + -printer=slf_graphviz the same automaton as slf, but in Graphviz format + -printer=slf_sub a finite automaton with sub-automata in the + HTK SLF format + -printer=slf_sub_graphviz the same automaton as slf_sub, but in + Graphviz format + -printer=fa_graphviz a finite automaton with labelled edges + -printer=regular a regular grammar in a simple BNF + -printer=unpar a gfc grammar with parameters eliminated + -printer=functiongraph abstract syntax functions in 'dot' format + -printer=typegraph abstract syntax categories in 'dot' format + -printer=transfer Transfer language datatype (.tr file format) + -printer=cfg-prolog M cfg in prolog format (also pg) + -printer=gfc-prolog M gfc in prolog format (also pg) + -printer=gfcm M gfcm file (default for pm) + -printer=graph M module dependency graph in 'dot' (graphviz) format + -printer=header M gfcm file with header (for GF embedded in Java) + -printer=js M JavaScript type annotator and linearizer + -printer=mcfg-prolog M mcfg in prolog format (also pg) + -printer=missing M the missing linearizations of each concrete + +-startcat, like -cat, but used in grammars (to avoid clash with keyword cat) + +-transform, transformation performed on a syntax tree. The default is identity. + -transform=identity no change + -transform=compute compute by using definitions in the grammar + -transform=nodup return the term only if it has no constants duplicated + -transform=nodupatom return the term only if it has no atomic constants duplicated + -transform=typecheck return the term only if it is type-correct + -transform=solve solve metavariables as derived refinements + -transform=context solve metavariables by unique refinements as variables + -transform=delete replace the term by metavariable + +-unlexer, untokenization transforming linearization output into a string. + The default is unwords. + -unlexer=unwords space-separated token list (like unwords) + -unlexer=text format as text: punctuation, capitals, paragraph

+ -unlexer=code format as code (spacing, indentation) + -unlexer=textlit like text, but remove string literal quotes + -unlexer=codelit like code, but remove string literal quotes + -unlexer=concat remove all spaces + -unlexer=bind like identity, but bind at "&+" + +-mark, marking of parts of tree in linearization. The default is none. + -mark=metacat append "+CAT" to every metavariable, showing its category + -mark=struct show tree structure with brackets + -mark=java show tree structure with XML tags (used in gfeditor) + +-coding, Some grammars are in UTF-8, some in isolatin-1. + If the letters ä (a-umlaut) and ö (o-umlaut) look strange, either + change your terminal to isolatin-1, or rewrite the grammar with + 'pg -utf8'. +``` diff --git a/doc/resource-synopsis.txt b/doc/resource-synopsis.txt new file mode 100644 index 000000000..383c8804b --- /dev/null +++ b/doc/resource-synopsis.txt @@ -0,0 +1,893 @@ +==GF Resource Grammar Library: Synopsis== + + +==Syntax== + +[source ../api/Constructors.gf] + + +|| Function | Type | Example || +| ``mkText`` | ``Phr -> Text`` | //But John walks.// | +| ``mkText`` | ``Phr -> (Punct) -> (Text) -> Text`` | //John walks? Yes.// | +| ``mkText`` | ``Utt -> Text`` | //John.// | +| ``mkText`` | ``S -> Text`` | //John walked.// | +| ``mkText`` | ``Cl -> Text`` | //John walks.// | +| ``mkText`` | ``QS -> Text`` | //Did John walk?// | +| ``mkText`` | ``Imp -> Text`` | //Walk!// | +| ``emptyText`` | ``Text`` | //(empty text)// | +| ``fullStopPunct`` | ``Punct`` | //.// | +| ``questMarkPunct`` | ``Punct`` | //?// | +| ``exclMarkPunct`` | ``Punct`` | //!// | +| ``mkPhr`` | ``Utt -> Phr`` | //why// | +| ``mkPhr`` | ``(PConj) -> Utt -> (Voc) -> Phr`` | //but why John// | +| ``mkPhr`` | ``S -> Phr`` | //John walked// | +| ``mkPhr`` | ``Cl -> Phr`` | //John walks// | +| ``mkPhr`` | ``QS -> Phr`` | //did John walk// | +| ``mkPhr`` | ``Imp -> Phr`` | //walk// | +| ``mkPConj`` | ``Conj -> PConj`` | //and// | +| ``mkVoc`` | ``NP -> Voc`` | //John// | +| ``mkUtt`` | ``S -> Utt`` | //John walked// | +| ``mkUtt`` | ``Cl -> Utt`` | //John walks// | +| ``mkUtt`` | ``QS -> Utt`` | //did John walk// | +| ``mkUtt`` | ``Imp -> Utt`` | //love yourself// | +| ``mkUtt`` | ``(ImpForm) -> (Pol) -> Imp -> Utt`` | //don't love yourselves// | +| ``mkUtt`` | ``IP -> Utt`` | //who// | +| ``mkUtt`` | ``IAdv -> Utt`` | //why// | +| ``mkUtt`` | ``NP -> Utt`` | //John// | +| ``mkUtt`` | ``Adv -> Utt`` | //here// | +| ``mkUtt`` | ``VP -> Utt`` | //to walk// | +| ``lets_Utt`` | ``VP -> Utt`` | //let's walk// | +| ``positivePol`` | ``Pol`` | //(John walks) [default]// | +| ``negativePol`` | ``Pol`` | //(John doesn't walk)// | +| ``simultaneousAnt`` | ``Ant`` | //(John walks) [default]// | +| ``anteriorAnt`` | ``Ant`` | //(John has walked) --# notpresent// | +| ``presentTense`` | ``Tense`` | //(John walks) [default]// | +| ``pastTense`` | ``Tense`` | //(John walked) --# notpresent// | +| ``futureTense`` | ``Tense`` | //(John will walk) --# notpresent// | +| ``conditionalTense`` | ``Tense`` | //(John would walk) --# notpresent// | +| ``singularImpForm`` | ``ImpForm`` | //(help yourself) [default]// | +| ``pluralImpForm`` | ``ImpForm`` | //(help yourselves)// | +| ``politeImpForm`` | ``ImpForm`` | //(help yourself) (polite singular)// | +| ``mkS`` | ``Cl -> S`` | //John walks// | +| ``mkS`` | ``(Tense) -> (Ant) -> (Pol) -> Cl -> S`` | //John wouldn't have walked// | +| ``mkS`` | ``Conj -> S -> S -> S`` | //John walks and I run// | +| ``mkS`` | ``Conj -> ListS -> S`` | //John walks, I run and you sleep// | +| ``mkS`` | ``DConj -> S -> S -> S`` | //either John walk or I run// | +| ``mkS`` | ``DConj -> ListS -> S`` | //either John walks, I run or you sleep// | +| ``mkS`` | ``Adv -> S -> S`` | //today, John walks// | +| ``mkCl`` | ``NP -> V -> Cl`` | //John walks// | +| ``mkCl`` | ``NP -> V2 -> NP -> Cl`` | //John loves her// | +| ``mkCl`` | ``NP -> V3 -> NP -> NP -> Cl`` | //John sends it to her// | +| ``mkCl`` | ``NP -> VV -> VP -> Cl`` | //John wants to walk// | +| ``mkCl`` | ``NP -> VS -> S -> Cl`` | //John says that it is good// | +| ``mkCl`` | ``NP -> VQ -> QS -> Cl`` | //John wonders if it is good// | +| ``mkCl`` | ``NP -> VA -> AP -> Cl`` | //John becomes old// | +| ``mkCl`` | ``NP -> V2A ->NP -> AP -> Cl`` | //John paints it red// | +| ``mkCl`` | ``NP -> A -> Cl`` | //John is old// | +| ``mkCl`` | ``NP -> A -> NP -> Cl`` | //John is older than her// | +| ``mkCl`` | ``NP -> A2 -> NP -> Cl`` | //John is married to her// | +| ``mkCl`` | ``NP -> AP -> Cl`` | //John is very old// | +| ``mkCl`` | ``NP -> N -> Cl`` | //John is a man// | +| ``mkCl`` | ``NP -> CN -> Cl`` | //John is an old man// | +| ``mkCl`` | ``NP -> NP -> Cl`` | //John is the man// | +| ``mkCl`` | ``NP -> Adv -> Cl`` | //John is here// | +| ``mkCl`` | ``NP -> VP -> Cl`` | //John walks here// | +| ``mkCl`` | ``V -> Cl`` | //it rains// | +| ``mkCl`` | ``VP -> Cl`` | //it is raining// | +| ``mkCl`` | ``N -> Cl`` | //there is a house// | +| ``mkCl`` | ``CN -> Cl`` | //there is an old houses// | +| ``mkCl`` | ``NP -> Cl`` | //there are five houses// | +| ``mkCl`` | ``NP -> RS -> Cl`` | //it is John that walks// | +| ``mkCl`` | ``Adv -> S -> Cl`` | //it is here John walks// | +| ``genericCl`` | ``VP -> Cl`` | //one walks// | +| ``mkVP`` | ``V -> VP`` | //walk// | +| ``mkVP`` | ``V2 -> NP -> VP`` | //love her// | +| ``mkVP`` | ``V3 -> NP -> NP -> VP`` | //send it to her// | +| ``mkVP`` | ``VV -> VP -> VP`` | //want to walk// | +| ``mkVP`` | ``VS -> S -> VP`` | //know that she walks// | +| ``mkVP`` | ``VQ -> QS -> VP`` | //ask if she walks// | +| ``mkVP`` | ``VA -> AP -> VP`` | //become old// | +| ``mkVP`` | ``V2A -> NP -> AP -> VP`` | //paint it red// | +| ``mkVP`` | ``A -> VP`` | //be warm// | +| ``mkVP`` | ``AP -> VP`` | //be very warm// | +| ``mkVP`` | ``A -> NP -> VP`` | //be older than her// | +| ``mkVP`` | ``A2 -> NP -> VP`` | //be married to her// | +| ``mkVP`` | ``N -> VP`` | //be a man// | +| ``mkVP`` | ``CN -> VP`` | //be an old man// | +| ``mkVP`` | ``NP -> VP`` | //be the man// | +| ``mkVP`` | ``Adv -> VP`` | //be here// | +| ``mkVP`` | ``VP -> Adv -> VP`` | //sleep here// | +| ``mkVP`` | ``AdV -> VP -> VP`` | //always sleep// | +| ``reflexiveVP`` | ``V2 -> VP`` | //love itself// | +| ``passiveVP`` | ``V2 -> VP`` | //be loved// | +| ``passiveVP`` | ``V2 -> NP -> VP`` | //be loved by her// | +| ``progressiveVP`` | ``VP -> VP`` | //be sleeping// | +| ``mkImp`` | ``V -> Imp`` | //go// | +| ``mkImp`` | ``V2 -> NP -> Imp`` | //take it// | +| ``mkImp`` | ``VP -> Imp`` | //go there now// | +| ``mkNP`` | ``Det -> N -> NP`` | //the first man// | +| ``mkNP`` | ``Det -> CN -> NP`` | //the first old man// | +| ``mkNP`` | ``QuantSg -> N -> NP`` | //this man// | +| ``mkNP`` | ``QuantSg -> CN -> NP`` | //this old man// | +| ``mkNP`` | ``QuantPl -> N -> NP`` | //these men// | +| ``mkNP`` | ``QuantPl -> CN -> NP`` | //these old men// | +| ``mkNP`` | ``Numeral -> N -> NP`` | //twenty men// | +| ``mkNP`` | ``Numeral -> CN -> NP`` | //twenty old men// | +| ``mkNP`` | ``Int -> N -> NP`` | //45 men// | +| ``mkNP`` | ``Int -> CN -> NP`` | //45 old men// | +| ``mkNP`` | ``Num -> N -> NP`` | //almost twenty men// | +| ``mkNP`` | ``Num -> CN -> NP`` | //almost twenty old men// | +| ``mkNP`` | ``Pron -> N -> NP`` | //my man// | +| ``mkNP`` | ``Pron -> CN -> NP;`` | //my old man// | +| ``mkNP`` | ``PN -> NP`` | //John// | +| ``mkNP`` | ``Pron -> NP`` | //he// | +| ``mkNP`` | ``Predet -> NP -> NP`` | //only John// | +| ``mkNP`` | ``NP -> V2 -> NP`` | //John killed// | +| ``mkNP`` | ``NP -> Adv -> NP`` | //John in Paris// | +| ``mkNP`` | ``Conj -> NP -> NP -> NP`` | //John and I// | +| ``mkNP`` | ``Conj -> ListNP -> NP`` | //John, I, and that// | +| ``mkNP`` | ``DConj -> NP -> NP -> NP`` | //either John or I// | +| ``mkNP`` | ``DConj -> ListNP -> NP`` | //either John, I, or that// | +| ``mkDet`` | ``QuantSg -> Det`` | //this// | +| ``mkDet`` | ``QuantSg -> (Ord) -> Det`` | //this first// | +| ``mkDet`` | ``QuantPl -> Det`` | //these// | +| ``mkDet`` | ``QuantPl -> (Num) -> (Ord) -> Det`` | //these five best// | +| ``mkDet`` | ``Quant -> Det`` | //this// | +| ``mkDet`` | ``Quant -> Num -> Det`` | //these five// | +| ``mkDet`` | ``Num -> Det`` | //almost twenty// | +| ``mkDet`` | ``Numeral -> Det`` | //five// | +| ``mkDet`` | ``Int -> Det`` | //51// | +| ``mkDet`` | ``Pron -> Det`` | //my// | +| ``defSgDet`` | ``Det`` | //the (house)// | +| ``defPlDet`` | ``Det`` | //the (houses)// | +| ``indefSgDet`` | ``Det`` | //a (house)// | +| ``indefPlDet`` | ``Det`` | //(houses)// | +| ``defQuant`` | ``Quant`` | //the// | +| ``indefQuant`` | ``Quant`` | //a// | +| ``mkQuantSg`` | ``Quant -> QuantSg`` | //this// | +| ``massQuant`` | ``QuantSg`` | //(mass terms)// | +| ``mkQuantPl`` | ``Quant -> QuantPl`` | //these// | +| ``mkNum`` | ``Numeral -> Num`` | //twenty// | +| ``mkNum`` | ``Int -> Num`` | //51// | +| ``mkNum`` | ``AdN -> Num -> Num`` | //almost ten// | +| ``mkOrd`` | ``Numeral -> Ord`` | //twentieth// | +| ``mkOrd`` | ``Int -> Ord`` | //51st// | +| ``mkOrd`` | ``A -> Ord`` | //best// | +| ``mkAdN`` | ``CAdv -> AdN`` | //more than// | +| ``n1_Numeral`` | ``Numeral`` | //one// | +| ``n2_Numeral`` | ``Numeral`` | //two// | +| ``n3_Numeral`` | ``Numeral`` | //three// | +| ``n4_Numeral`` | ``Numeral`` | //four// | +| ``n5_Numeral`` | ``Numeral`` | //five// | +| ``n6_Numeral`` | ``Numeral`` | //six// | +| ``n7_Numeral`` | ``Numeral`` | //seven// | +| ``n8_Numeral`` | ``Numeral`` | //eight// | +| ``n9_Numeral`` | ``Numeral`` | //nine// | +| ``n10_Numeral`` | ``Numeral`` | //ten// | +| ``n20_Numeral`` | ``Numeral`` | //twenty// | +| ``n100_Numeral`` | ``Numeral`` | //hundred// | +| ``n1000_Numeral`` | ``Numeral`` | //thousand// | +| ``mkCN`` | ``N -> CN`` | //house// | +| ``mkCN`` | ``N2 -> NP -> CN`` | //mother of John// | +| ``mkCN`` | ``N3 -> NP -> NP -> CN`` | //distance from this city to Paris// | +| ``mkCN`` | ``N2 -> CN`` | //son// | +| ``mkCN`` | ``N3 -> CN`` | //flight// | +| ``mkCN`` | ``A -> N -> CN`` | //big house// | +| ``mkCN`` | ``A -> CN -> CN`` | //big blue house// | +| ``mkCN`` | ``AP -> N -> CN`` | //very big house// | +| ``mkCN`` | ``AP -> CN -> CN`` | //very big blue house// | +| ``mkCN`` | ``N -> RS -> CN`` | //house that John loves// | +| ``mkCN`` | ``CN -> RS -> CN`` | //big house that John loves// | +| ``mkCN`` | ``N -> Adv -> CN`` | //house in the city// | +| ``mkCN`` | ``CN -> Adv -> CN`` | //big house in the city// | +| ``mkCN`` | ``CN -> S -> CN`` | //rule that John walks// | +| ``mkCN`` | ``CN -> QS -> CN`` | //question if John walks// | +| ``mkCN`` | ``CN -> VP -> CN`` | //reason to walk// | +| ``mkCN`` | ``N -> NP -> CN`` | //king John// | +| ``mkCN`` | ``CN -> NP -> CN`` | //old king John// | +| ``mkAP`` | ``A -> AP`` | //old// | +| ``mkAP`` | ``A -> NP -> AP`` | //older than John// | +| ``mkAP`` | ``A2 -> NP -> AP`` | //married to her// | +| ``mkAP`` | ``A2 -> AP`` | //married to myself// | +| ``mkAP`` | ``AP -> S -> AP`` | //probable that John walks// | +| ``mkAP`` | ``AP -> QS -> AP`` | //uncertain if John walks// | +| ``mkAP`` | ``AP -> VP -> AP`` | //ready to go// | +| ``mkAP`` | ``AdA -> A -> AP`` | //very old// | +| ``mkAP`` | ``AdA -> AP -> AP`` | //very very old// | +| ``mkAP`` | ``Conj -> AP -> AP -> AP`` | //old and big// | +| ``mkAP`` | ``Conj -> ListAP -> AP`` | //old, big, and warm// | +| ``mkAP`` | ``DConj -> AP -> AP -> AP`` | //either old or big// | +| ``mkAP`` | ``DConj -> ListAP -> AP`` | //either old, big, or warm// | +| ``mkAdv`` | ``A -> Adv`` | //warmly// | +| ``mkAdv`` | ``Prep -> NP -> Adv`` | //with John// | +| ``mkAdv`` | ``Subj -> S -> Adv`` | //when John walks// | +| ``mkAdv`` | ``CAdv -> A -> NP -> Adv`` | //more warmly than John// | +| ``mkAdv`` | ``CAdv -> A -> S -> Adv`` | //more warmly than John walks// | +| ``mkAdv`` | ``AdA -> Adv -> Adv`` | //very warmly// | +| ``mkAdv`` | ``Conj -> Adv -> Adv -> Adv`` | //here and now// | +| ``mkAdv`` | ``Conj -> ListAdv -> Adv`` | //with John, here and now// | +| ``mkAdv`` | ``DConj -> Adv -> Adv -> Adv`` | //either here or now// | +| ``mkAdv`` | ``DConj -> ListAdv -> Adv`` | //either here, now, or with John// | +| ``mkQS`` | ``QCl -> QS`` | //who walks// | +| ``mkQS`` | ``(Tense) -> (Ant) -> (Pol) -> QCl -> QS`` | //who wouldn't have walked// | +| ``mkQS`` | ``Cl -> QS`` | //does John walk// | +| ``mkQCl`` | ``Cl -> QCl`` | //does John walk// | +| ``mkQCl`` | ``IP -> VP -> QCl`` | //who walks// | +| ``mkQCl`` | ``IP -> NP -> V2 -> QCl`` | //whom does John love// | +| ``mkQCl`` | ``IP -> Slash -> QCl`` | //whom does John love today// | +| ``mkQCl`` | ``IAdv -> Cl -> QCl`` | //why does John walk// | +| ``mkQCl`` | ``Prep -> IP -> Cl -> QCl`` | //with who does John walk// | +| ``mkQCl`` | ``IAdv -> NP -> QCl`` | //where is John// | +| ``mkQCl`` | ``IP -> QCl`` | //what is there// | +| ``mkIP`` | ``IDet -> N -> IP`` | //which city// | +| ``mkIP`` | ``IDet -> (Num) -> (Ord) -> CN -> IP`` | //which five best cities// | +| ``mkIP`` | ``IP -> Adv -> IP`` | //who in Paris// | +| ``mkIAdv`` | ``Prep -> IP -> IAdv`` | //in which city// | +| ``mkRS`` | ``RCl -> RS`` | //that walk// | +| ``mkRS`` | ``(Tense) -> (Ant) -> (Pol) -> RCl -> RS`` | //that wouldn't have walked// | +| ``mkRCl`` | ``RP -> VP -> RCl`` | //that walk// | +| ``mkRCl`` | ``RP -> NP -> V2 -> RCl`` | //which John loves// | +| ``mkRCl`` | ``RP -> Slash -> RCl`` | //which John loves today// | +| ``mkRCl`` | ``Cl -> RCl`` | //such that John loves her// | +| ``which_RP`` | ``RP`` | //which// | +| ``mkRP`` | ``Prep -> NP -> RP -> RP`` | //all the houses in which// | +| ``mkSlash`` | ``NP -> V2 -> Slash`` | //(whom) John loves// | +| ``mkSlash`` | ``NP -> VV -> V2 -> Slash`` | //(whom) John wants to see// | +| ``mkSlash`` | ``Cl -> Prep -> Slash`` | //(with whom) John walks// | +| ``mkSlash`` | ``Slash -> Adv -> Slash`` | //(whom) John loves today// | +| ``mkListS`` | ``S -> S -> ListS`` | //he walks, I run// | +| ``mkListS`` | ``S -> ListS -> ListS`` | //John walks, I run, you sleep// | +| ``mkListAdv`` | ``Adv -> Adv -> ListAdv`` | //here, now// | +| ``mkListAdv`` | ``Adv -> ListAdv -> ListAdv`` | //to me, here, now// | +| ``mkListAP`` | ``AP -> AP -> ListAP`` | //old, big// | +| ``mkListAP`` | ``AP -> ListAP -> ListAP`` | //old, big, warm// | +| ``mkListNP`` | ``NP -> NP -> ListNP`` | //John, I// | +| ``mkListNP`` | ``NP -> ListNP -> ListNP`` | //John, I, that// | + + +==Paradigms for Danish== + + +[source ../danish/ParadigmsDan.gf] + + + + +|| Function | Type | Example || +| ``Gender`` | ``Type`` | - | +| ``utrum`` | ``Gender`` | - | +| ``neutrum`` | ``Gender`` | - | +| ``Number`` | ``Type`` | - | +| ``singular`` | ``Number`` | - | +| ``plural`` | ``Number`` | - | +| ``Case`` | ``Type`` | - | +| ``nominative`` | ``Case`` | - | +| ``genitive`` | ``Case`` | - | +| ``mkPrep`` | ``Str -> Prep`` | - | +| ``noPrep`` | ``Prep`` | //empty string// | +| ``mkN`` | ``(dreng,drengen,drenge,drengene : Str) -> N`` | - | +| ``regN`` | ``Str -> N`` | - | +| ``regGenN`` | ``Str -> Gender -> N`` | - | +| ``mk2N`` | ``(bil,bilen : Str) -> N`` | - | +| ``mk3N`` | ``(bil,bilen,biler : Str) -> N`` | - | +| ``mkN2`` | ``N -> Prep -> N2`` | - | +| ``regN2`` | ``Str -> Gender -> N2`` | - | +| ``mkN3`` | ``N -> Prep -> Prep -> N3`` | - | +| ``mkPN`` | ``Str -> Gender -> PN`` | //Paris neutrum// | +| ``regPN`` | ``Str -> PN`` | //utrum gender// | +| ``nounPN`` | ``N -> PN`` | - | +| ``mkNP`` | ``Str -> Str -> Number -> Gender -> NP`` | - | +| ``mkA`` | ``(galen,galet,galne : Str) -> A`` | - | +| ``regA`` | ``Str -> A`` | - | +| ``mk2A`` | ``(stor,stort : Str) -> A`` | - | +| ``mkA2`` | ``A -> Prep -> A2`` | - | +| ``mkADeg`` | ``(stor,stort,store,storre,storst : Str) -> A`` | - | +| ``regADeg`` | ``Str -> A`` | - | +| ``irregADeg`` | ``(tung,tyngre,tyngst : Str) -> A`` | - | +| ``mk3ADeg`` | ``(galen,galet,galna : Str) -> A`` | - | +| ``mk2ADeg`` | ``(bred,bredt : Str) -> A`` | - | +| ``compoundA`` | ``A -> A`` | //-/mer/mest norsk// | +| ``mkAdv`` | ``Str -> Adv`` | - | +| ``mkAdV`` | ``Str -> AdV`` | - | +| ``mkAdA`` | ``Str -> AdA`` | - | +| ``mkV`` | ``(spise,spiser,spises,spiste,spist,spis : Str) -> V`` | - | +| ``regV`` | ``(snakke : Str) -> V`` | - | +| ``mk2V`` | ``(leve,levde : Str) -> V`` | - | +| ``irregV`` | ``(drikke, drak, drukket : Str) -> V`` | - | +| ``vaereV`` | ``V -> V`` | - | +| ``partV`` | ``V -> Str -> V`` | - | +| ``depV`` | ``V -> V`` | - | +| ``reflV`` | ``V -> V`` | - | +| ``mkV2`` | ``V -> Prep -> V2`` | - | +| ``dirV2`` | ``V -> V2`` | - | +| ``mkV3`` | ``V -> Prep -> Prep -> V3`` | //snakke, med, om// | +| ``dirV3`` | ``V -> Prep -> V3`` | //give,_,til// | +| ``dirdirV3`` | ``V -> V3`` | //give,_,_// | +| ``mkV0`` | ``V -> V0`` | - | +| ``mkVS`` | ``V -> VS`` | - | +| ``mkV2S`` | ``V -> Prep -> V2S`` | - | +| ``mkVV`` | ``V -> VV`` | - | +| ``mkV2V`` | ``V -> Prep -> Prep -> V2V`` | - | +| ``mkVA`` | ``V -> VA`` | - | +| ``mkV2A`` | ``V -> Prep -> V2A`` | - | +| ``mkVQ`` | ``V -> VQ`` | - | +| ``mkV2Q`` | ``V -> Prep -> V2Q`` | - | +| ``mkAS`` | ``A -> AS`` | - | +| ``mkA2S`` | ``A -> Prep -> A2S`` | - | +| ``mkAV`` | ``A -> AV`` | - | +| ``mkA2V`` | ``A -> Prep -> A2V`` | - | + + +==Paradigms for English== + + +[source ../english/ParadigmsEng.gf] + + + + +|| Function | Type | Example || +| ``Gender`` | ``Type`` | - | +| ``human`` | ``Gender`` | - | +| ``nonhuman`` | ``Gender`` | - | +| ``masculine`` | ``Gender`` | - | +| ``Number`` | ``Type`` | - | +| ``singular`` | ``Number`` | - | +| ``plural`` | ``Number`` | - | +| ``Case`` | ``Type`` | - | +| ``nominative`` | ``Case`` | - | +| ``genitive`` | ``Case`` | - | +| ``mkN`` | ``(flash : Str) -> N`` | - | +| ``mkN`` | ``(man,men : Str) -> N`` | - | +| ``mkN`` | ``(man,men,man's,men's : Str) -> N`` | - | +| ``mkN`` | ``Str -> N -> N`` | - | +| ``mkN2`` | ``N -> Prep -> N2`` | - | +| ``regN2`` | ``Str -> N2`` | - | +| ``mkN3`` | ``N -> Prep -> Prep -> N3`` | - | +| ``mkPN`` | ``Str -> PN`` | - | +| ``mkPN`` | ``N -> PN`` | - | +| ``mkA`` | ``(happy : Str) -> A`` | - | +| ``mkA`` | ``(fat,fatter : Str) -> A`` | - | +| ``mkA`` | ``(good,better,best,well : Str) -> A`` | - | +| ``compoundA`` | ``A -> A`` | //-/more/most ridiculous// | +| ``mkA2`` | ``A -> Prep -> A2`` | - | +| ``mkAdv`` | ``Str -> Adv`` | - | +| ``mkAdV`` | ``Str -> AdV`` | - | +| ``mkAdA`` | ``Str -> AdA`` | - | +| ``mkPrep`` | ``Str -> Prep`` | - | +| ``noPrep`` | ``Prep`` | - | +| ``mkV`` | ``(cry : Str) -> V`` | - | +| ``mkV`` | ``(stop, stopped : Str) -> V`` | - | +| ``mkV`` | ``(drink, drank, drunk : Str) -> V`` | - | +| ``mkV`` | ``(run, ran, run, running : Str) -> V`` | - | +| ``mkV`` | ``(go, goes, went, gone, going : Str) -> V`` | - | +| ``partV`` | ``V -> Str -> V`` | - | +| ``reflV`` | ``V -> V`` | - | +| ``mkV2`` | ``V -> Prep -> V2`` | //believe in// | +| ``mkV2`` | ``V -> V2`` | //kill// | +| ``mkV3`` | ``V -> Prep -> Prep -> V3`` | //speak, with, about// | +| ``dirV3`` | ``V -> Prep -> V3`` | //give,_,to// | +| ``dirdirV3`` | ``V -> V3`` | //give,_,_// | +| ``mkV0`` | ``V -> V0`` | - | +| ``mkVS`` | ``V -> VS`` | - | +| ``mkV2S`` | ``V -> Prep -> V2S`` | - | +| ``mkVV`` | ``V -> VV`` | - | +| ``mkV2V`` | ``V -> Prep -> Prep -> V2V`` | - | +| ``mkVA`` | ``V -> VA`` | - | +| ``mkV2A`` | ``V -> Prep -> V2A`` | - | +| ``mkVQ`` | ``V -> VQ`` | - | +| ``mkV2Q`` | ``V -> Prep -> V2Q`` | - | +| ``mkAS`` | ``A -> AS`` | - | +| ``mkA2S`` | ``A -> Prep -> A2S`` | - | +| ``mkAV`` | ``A -> AV`` | - | +| ``mkA2V`` | ``A -> Prep -> A2V`` | - | + + +==Paradigms for Finnish== + + +[source ../finnish/ParadigmsFin.gf] + + + + +|| Function | Type | Example || +| ``Number`` | ``Type`` | - | +| ``singular`` | ``Number`` | - | +| ``plural`` | ``Number`` | - | +| ``Case`` | ``Type`` | - | +| ``nominative`` | ``Case`` | - | +| ``genitive`` | ``Case`` | - | +| ``partitive`` | ``Case`` | - | +| ``translative`` | ``Case`` | - | +| ``inessive`` | ``Case`` | - | +| ``elative`` | ``Case`` | - | +| ``illative`` | ``Case`` | - | +| ``adessive`` | ``Case`` | - | +| ``ablative`` | ``Case`` | - | +| ``allative`` | ``Case`` | - | +| ``prePrep`` | ``Case -> Str -> Prep`` | //ilman, partitive// | +| ``postPrep`` | ``Case -> Str -> Prep`` | //takana, genitive// | +| ``postGenPrep`` | ``Str -> Prep`` | //takana// | +| ``casePrep`` | ``Case -> Prep`` | //adessive// | +| ``mkN`` | ``(talo : Str) -> N`` | - | +| ``mkN`` | ``(savi,savia : Str) -> N`` | - | +| ``mkN`` | ``(vesi,veden,vesiä : Str) -> N`` | - | +| ``mkN`` | ``(olo,oln,olona,oloa,oloon,oloina,oloissa,olojen,oloja,oloihin : Str) -> N`` | - | +| ``sgpartN`` | ``(meri : N) -> (merta : Str) -> N`` | - | +| ``nMeri`` | ``(meri : Str) -> N`` | - | +| ``nKukko`` | ``(kukko,kukon,kukkoja : Str) -> N`` | - | +| ``nTalo`` | ``(talo : Str) -> N`` | - | +| ``nLukko`` | ``(lukko : Str) -> N`` | - | +| ``nArpi`` | ``(arpi : Str) -> N`` | - | +| ``nSylki`` | ``(sylki : Str) -> N`` | - | +| ``nLinux`` | ``(linuxia : Str) -> N`` | - | +| ``nPeruna`` | ``(peruna : Str) -> N`` | - | +| ``nRae`` | ``(rae, rakeena : Str) -> N`` | - | +| ``nSusi`` | ``(susi,suden,sutta : Str) -> N`` | - | +| ``nPuu`` | ``(puu : Str) -> N`` | - | +| ``nSuo`` | ``(suo : Str) -> N`` | - | +| ``nNainen`` | ``(naista : Str) -> N`` | - | +| ``nTilaus`` | ``(tilaus,tilauksena : Str) -> N`` | - | +| ``nKulaus`` | ``(kulaus : Str) -> N`` | - | +| ``nNauris`` | ``(naurista : Str) -> N`` | - | +| ``compN`` | ``Str -> N -> N`` | - | +| ``mkN2`` | ``N -> N2`` | - | +| ``mkN2`` | ``N -> Prep -> N2`` | - | +| ``mkN3`` | ``N -> Prep -> Prep -> N3`` | - | +| ``mkPN`` | ``Str -> PN`` | - | +| ``mkPN`` | ``N -> PN`` | - | +| ``mkA`` | ``Str -> A`` | - | +| ``mkA`` | ``N -> A`` | - | +| ``mkA`` | ``N -> (kivempaa,kivinta : Str) -> A`` | - | +| ``mkA2`` | ``A -> Prep -> A2`` | - | +| ``mkV`` | ``(soutaa : Str) -> V`` | - | +| ``mkV`` | ``(soutaa,souti : Str) -> V`` | - | +| ``mkV`` | ``(soutaa,soudan,souti : Str) -> V`` | - | +| ``mkV`` | ``(tulla,tulee,tulen,tulevat,tulkaa,tullaan,tuli,tulin,tulisi,tullut,tultu,tullun : Str) -> V`` | - | +| ``mkV`` | ``V -> Case -> V`` | - | +| ``vValua`` | ``(valua : Str) -> V`` | - | +| ``vKattaa`` | ``(kattaa, katan : Str) -> V`` | - | +| ``vOstaa`` | ``(ostaa : Str) -> V`` | - | +| ``vNousta`` | ``(nousta, nousen : Str) -> V`` | - | +| ``vTuoda`` | ``(tuoda : Str) -> V`` | - | +| ``caseV`` | ``Case -> V -> V`` | - | +| ``vOlla`` | ``V`` | - | +| ``mkV2`` | ``V -> Prep -> V2`` | - | +| ``caseV2`` | ``V -> Case -> V2`` | - | +| ``dirV2`` | ``V -> V2`` | - | +| ``mkV3`` | ``V -> Prep -> Prep -> V3`` | //puhua, allative, elative// | +| ``dirV3`` | ``V -> Case -> V3`` | //siirtää, (accusative), illative// | +| ``dirdirV3`` | ``V -> V3`` | //antaa, (accusative), (allative)// | +| ``mkV0`` | ``V -> V0`` | - | +| ``mkVS`` | ``V -> VS`` | - | +| ``mkV2S`` | ``V -> Prep -> V2S`` | - | +| ``mkVV`` | ``V -> VV`` | - | +| ``mkV2V`` | ``V -> Prep -> V2V`` | - | +| ``mkVA`` | ``V -> Prep -> VA`` | - | +| ``mkV2A`` | ``V -> Prep -> Prep -> V2A`` | - | +| ``mkVQ`` | ``V -> VQ`` | - | +| ``mkV2Q`` | ``V -> Prep -> V2Q`` | - | +| ``mkAS`` | ``A -> AS`` | - | +| ``mkA2S`` | ``A -> Prep -> A2S`` | - | +| ``mkAV`` | ``A -> AV`` | - | +| ``mkA2V`` | ``A -> Prep -> A2V`` | - | + + +==Paradigms for French== + + +[source ../french/ParadigmsFre.gf] + + + + +|| Function | Type | Example || +| ``Gender`` | ``Type`` | - | +| ``masculine`` | ``Gender`` | - | +| ``feminine`` | ``Gender`` | - | +| ``Number`` | ``Type`` | - | +| ``singular`` | ``Number`` | - | +| ``plural`` | ``Number`` | - | +| ``accusative`` | ``Prep`` | - | +| ``genitive`` | ``Prep`` | - | +| ``dative`` | ``Prep`` | - | +| ``mkPrep`` | ``Str -> Prep`` | - | +| ``mkN`` | ``(cheval : Str) -> N`` | - | +| ``mkN`` | ``(foie : Str) -> Gender -> N`` | - | +| ``mkN`` | ``(oeil,yeux : Str) -> Gender -> N`` | - | +| ``mkN`` | ``N -> Str -> N`` | - | +| ``mkN2`` | ``N -> Prep -> N2`` | - | +| ``deN2`` | ``N -> N2`` | - | +| ``aN2`` | ``N -> N2`` | - | +| ``mkN3`` | ``N -> Prep -> Prep -> N3`` | - | +| ``mkPN`` | ``Str -> PN`` | - | +| ``mkPN`` | ``Str -> Gender -> PN`` | - | +| ``mkA`` | ``(cher : Str) -> A`` | - | +| ``mkA`` | ``(sec,seche : Str) -> A`` | - | +| ``mkA`` | ``(banal,banale,banaux,banalement : Str) -> A`` | - | +| ``mkA`` | ``A -> A -> A`` | - | +| ``prefixA`` | ``A -> A`` | - | +| ``mkA2`` | ``A -> Prep -> A2`` | - | +| ``mkAdv`` | ``Str -> Adv`` | - | +| ``mkAdV`` | ``Str -> AdV`` | - | +| ``mkAdA`` | ``Str -> AdA`` | - | +| ``mkV`` | ``(finir : Str) -> V`` | - | +| ``mkV`` | ``(jeter,jette,jettera : Str) -> V`` | - | +| ``mkV`` | ``V2 -> V`` | - | +| ``etreV`` | ``V -> V`` | - | +| ``reflV`` | ``V -> V`` | - | +| ``mkV2`` | ``V -> V2 = dirV2`` | - | +| ``mkV2`` | ``V -> Prep -> V2 = mmkV2`` | - | +| ``mkV3`` | ``V -> V3`` | //donner,_,_// | +| ``mkV3`` | ``V -> Prep -> V3`` | //placer,_,dans// | +| ``mkV3`` | ``V -> Prep -> Prep -> V3`` | //parler, ā, de// | +| ``mkV0`` | ``V -> V0`` | - | +| ``mkVS`` | ``V -> VS`` | - | +| ``mkV2S`` | ``V -> Prep -> V2S`` | - | +| ``mkVV`` | ``V -> VV`` | //plain infinitive: "je veux parler"// | +| ``deVV`` | ``V -> VV`` | //"j'essaie de parler"// | +| ``aVV`` | ``V -> VV`` | //"j'arrive ā parler"// | +| ``mkV2V`` | ``V -> Prep -> Prep -> V2V`` | - | +| ``mkVA`` | ``V -> VA`` | - | +| ``mkV2A`` | ``V -> Prep -> Prep -> V2A`` | - | +| ``mkVQ`` | ``V -> VQ`` | - | +| ``mkV2Q`` | ``V -> Prep -> V2Q`` | - | +| ``mkAS`` | ``A -> AS`` | - | +| ``mkA2S`` | ``A -> Prep -> A2S`` | - | +| ``mkAV`` | ``A -> Prep -> AV`` | - | +| ``mkA2V`` | ``A -> Prep -> Prep -> A2V`` | - | + + +==Paradigms for German== + + +[source ../german/ParadigmsGer.gf] + + + + +|| Function | Type | Example || +| ``Gender`` | ``Type`` | - | +| ``masculine`` | ``Gender`` | - | +| ``feminine`` | ``Gender`` | - | +| ``neuter`` | ``Gender`` | - | +| ``Case`` | ``Type`` | - | +| ``nominative`` | ``Case`` | - | +| ``accusative`` | ``Case`` | - | +| ``dative`` | ``Case`` | - | +| ``genitive`` | ``Case`` | - | +| ``Number`` | ``Type`` | - | +| ``singular`` | ``Number`` | - | +| ``plural`` | ``Number`` | - | +| ``mkN`` | ``(Stufe : Str) -> N`` | - | +| ``mkN`` | ``(Bild,Bilder : Str) -> Gender -> N`` | - | +| ``mkN`` | ``(x1,_,_,_,_,x6 : Str) -> Gender -> N`` | - | +| ``mkN2`` | ``Str -> N2`` | - | +| ``mkN2`` | ``N -> N2`` | - | +| ``mkN2`` | ``N -> Prep -> N2`` | - | +| ``mkN3`` | ``N -> Prep -> Prep -> N3`` | - | +| ``mkPN`` | ``Str -> PN`` | - | +| ``mkPN`` | ``(nom,gen : Str) -> PN`` | - | +| ``mkPN`` | ``(nom,acc,dat,gen : Str) -> PN`` | - | +| ``mkA`` | ``Str -> A`` | - | +| ``mkA`` | ``(gut,besser,beste : Str) -> A`` | //gut,besser,beste// | +| ``invarA`` | ``Str -> A`` | //prima// | +| ``mkA2`` | ``A -> Prep -> A2`` | - | +| ``mkAdv`` | ``Str -> Adv`` | - | +| ``mkPrep`` | ``Str -> Case -> Prep`` | - | +| ``accPrep`` | ``Prep`` | - | +| ``datPrep`` | ``Prep`` | - | +| ``genPrep`` | ``Prep`` | - | +| ``von_Prep`` | ``Prep`` | - | +| ``zu_Prep`` | ``Prep`` | - | +| ``mkV`` | ``(führen : Str) -> V`` | - | +| ``mkV`` | ``(sehen,sieht,sah,sähe,gesehen : Str) -> V`` | - | +| ``mkV`` | ``(geben, gibt, gib, gab, gäbe, gegeben : Str) -> V`` | - | +| ``mkV`` | ``Str -> V -> V`` | - | +| ``no_geV`` | ``V -> V`` | - | +| ``seinV`` | ``V -> V`` | - | +| ``habenV`` | ``V -> V`` | - | +| ``reflV`` | ``V -> Case -> V`` | - | +| ``mkV2`` | ``V -> Prep -> V2`` | - | +| ``mkV2`` | ``V -> V2`` | - | +| ``mkV2`` | ``V -> Case -> V2`` | - | +| ``mkV3`` | ``V -> Prep -> Prep -> V3`` | //sprechen, mit, über// | +| ``dirV3`` | ``V -> Prep -> V3`` | //senden,(accusative),nach// | +| ``accdatV3`` | ``V -> V3`` | //give,accusative,dative// | +| ``mkV0`` | ``V -> V0`` | - | +| ``mkVS`` | ``V -> VS`` | - | +| ``mkV2S`` | ``V -> Prep -> V2S`` | - | +| ``mkVV`` | ``V -> VV`` | - | +| ``mkV2V`` | ``V -> Prep -> V2V`` | - | +| ``mkVA`` | ``V -> VA`` | - | +| ``mkV2A`` | ``V -> Prep -> V2A`` | - | +| ``mkVQ`` | ``V -> VQ`` | - | +| ``mkV2Q`` | ``V -> Prep -> V2Q`` | - | +| ``mkAS`` | ``A -> AS`` | - | +| ``mkA2S`` | ``A -> Prep -> A2S`` | - | +| ``mkAV`` | ``A -> AV`` | - | +| ``mkA2V`` | ``A -> Prep -> A2V`` | - | + + +==Paradigms for Italian== + + +[source ../italian/ParadigmsIta.gf] + + + + +|| Function | Type | Example || +| ``Gender`` | ``Type`` | - | +| ``masculine`` | ``Gender`` | - | +| ``feminine`` | ``Gender`` | - | +| ``Number`` | ``Type`` | - | +| ``singular`` | ``Number`` | - | +| ``plural`` | ``Number`` | - | +| ``Prep`` | ``Type`` | - | +| ``accusative`` | ``Prep`` | - | +| ``genitive`` | ``Prep`` | - | +| ``dative`` | ``Prep`` | - | +| ``mkPrep`` | ``Str -> Prep`` | - | +| ``mkN`` | ``(cane : Str) -> N`` | - | +| ``mkN`` | ``(carne : Str) -> Gender -> N`` | - | +| ``mkN`` | ``(uomo,uomini : Str) -> Gender -> N`` | - | +| ``mkN`` | ``N -> Str -> N`` | - | +| ``mkN2`` | ``Str -> N2`` | - | +| ``mkN2`` | ``N -> Prep -> N2`` | - | +| ``mkN3`` | ``N -> Prep -> Prep -> N3`` | - | +| ``mkPN`` | ``Str -> PN`` | - | +| ``mkPN`` | ``Str -> Gender -> PN`` | - | +| ``mkA`` | ``(bianco : Str) -> A`` | - | +| ``mkA`` | ``(solo,sola,soli,sole,solamente : Str) -> A`` | - | +| ``mkA`` | ``A -> A -> A`` | - | +| ``prefixA`` | ``A -> A = prefA`` | - | +| ``mkA2`` | ``A -> Prep -> A2`` | - | +| ``mkAdv`` | ``Str -> Adv`` | - | +| ``mkAdV`` | ``Str -> AdV`` | - | +| ``mkAdA`` | ``Str -> AdA`` | - | +| ``mkV`` | ``Str -> V`` | - | +| ``mkV`` | ``Verbo -> V`` | - | +| ``mkV`` | ``(udire,odo,ode,udiamo,udiro,udii,udisti,udi,udirono,odi,udito : Str) -> V`` | - | +| ``essereV`` | ``V -> V`` | - | +| ``reflV`` | ``V -> V`` | - | +| ``mkV2`` | ``Str -> V2`` | - | +| ``mkV2`` | ``V -> V2`` | - | +| ``mkV2`` | ``V -> Prep -> V2`` | - | +| ``v2V`` | ``V2 -> V`` | - | +| ``mkV3`` | ``V -> Prep -> Prep -> V3`` | //parlare, a, di// | +| ``dirV3`` | ``V -> Prep -> V3`` | //dare,_,a// | +| ``dirdirV3`` | ``V -> V3`` | //dare,_,_// | +| ``mkV0`` | ``V -> V0`` | - | +| ``mkVS`` | ``V -> VS`` | - | +| ``mkV2S`` | ``V -> Prep -> V2S`` | - | +| ``mkVV`` | ``V -> VV`` | //plain infinitive: "voglio parlare"// | +| ``deVV`` | ``V -> VV`` | //"cerco di parlare"// | +| ``aVV`` | ``V -> VV`` | //"arrivo a parlare"// | +| ``mkV2V`` | ``V -> Prep -> Prep -> V2V`` | - | +| ``mkVA`` | ``V -> VA`` | - | +| ``mkV2A`` | ``V -> Prep -> Prep -> V2A`` | - | +| ``mkVQ`` | ``V -> VQ`` | - | +| ``mkV2Q`` | ``V -> Prep -> V2Q`` | - | +| ``mkAS`` | ``A -> AS`` | - | +| ``mkA2S`` | ``A -> Prep -> A2S`` | - | +| ``mkAV`` | ``A -> Prep -> AV`` | - | +| ``mkA2V`` | ``A -> Prep -> Prep -> A2V`` | - | + + +==Paradigms for Norwegian== + + +[source ../norwegian/ParadigmsNor.gf] + + + + +|| Function | Type | Example || +| ``Gender`` | ``Type`` | - | +| ``masculine`` | ``Gender`` | - | +| ``feminine`` | ``Gender`` | - | +| ``neutrum`` | ``Gender`` | - | +| ``Number`` | ``Type`` | - | +| ``singular`` | ``Number`` | - | +| ``plural`` | ``Number`` | - | +| ``Case`` | ``Type`` | - | +| ``nominative`` | ``Case`` | - | +| ``genitive`` | ``Case`` | - | +| ``mkPrep`` | ``Str -> Prep`` | - | +| ``noPrep`` | ``Prep`` | //empty string// | +| ``mkN`` | ``(dreng,drengen,drenger,drengene : Str) -> N`` | - | +| ``regN`` | ``Str -> N`` | - | +| ``regGenN`` | ``Str -> Gender -> N`` | - | +| ``mk2N`` | ``(bil,bilen : Str) -> N`` | - | +| ``mkN2`` | ``N -> Prep -> N2`` | - | +| ``regN2`` | ``Str -> Gender -> N2`` | - | +| ``mkN3`` | ``N -> Prep -> Prep -> N3`` | - | +| ``regPN`` | ``Str -> PN`` | //utrum// | +| ``regGenPN`` | ``Str -> Gender -> PN`` | - | +| ``nounPN`` | ``N -> PN`` | - | +| ``mkNP`` | ``Str -> Str -> Number -> Gender -> NP`` | - | +| ``mkA`` | ``(galen,galet,galne : Str) -> A`` | - | +| ``regA`` | ``Str -> A`` | - | +| ``mk2A`` | ``(stor,stort : Str) -> A`` | - | +| ``mkA2`` | ``A -> Prep -> A2`` | - | +| ``mkADeg`` | ``(stor,stort,store,storre,storst : Str) -> A`` | - | +| ``regADeg`` | ``Str -> A`` | - | +| ``irregADeg`` | ``(tung,tyngre,tyngst : Str) -> A`` | - | +| ``mk3ADeg`` | ``(galen,galet,galne : Str) -> A`` | - | +| ``mk2ADeg`` | ``(bred,bredt : Str) -> A`` | - | +| ``compoundA`` | ``A -> A`` | //-/mer/mest norsk// | +| ``mkAdv`` | ``Str -> Adv`` | //e.g. her// | +| ``mkAdV`` | ``Str -> AdV`` | //e.g. altid// | +| ``mkAdA`` | ``Str -> AdA`` | - | +| ``mkV`` | ``(spise,spiser,spises,spiste,spist,spis : Str) -> V`` | - | +| ``regV`` | ``(snakke : Str) -> V`` | - | +| ``mk2V`` | ``(leve,levde : Str) -> V`` | - | +| ``irregV`` | ``(drikke, drakk, drukket : Str) -> V`` | - | +| ``vaereV`` | ``V -> V`` | - | +| ``partV`` | ``V -> Str -> V`` | - | +| ``depV`` | ``V -> V`` | - | +| ``reflV`` | ``V -> V`` | - | +| ``mkV2`` | ``V -> Prep -> V2`` | - | +| ``dirV2`` | ``V -> V2`` | - | +| ``mkV3`` | ``V -> Prep -> Prep -> V3`` | //snakke, med, om// | +| ``dirV3`` | ``V -> Prep -> V3`` | //gi,_,til// | +| ``dirdirV3`` | ``V -> V3`` | //gi,_,_// | +| ``mkV0`` | ``V -> V0`` | - | +| ``mkVS`` | ``V -> VS`` | - | +| ``mkV2S`` | ``V -> Prep -> V2S`` | - | +| ``mkVV`` | ``V -> VV`` | - | +| ``mkV2V`` | ``V -> Prep -> Prep -> V2V`` | - | +| ``mkVA`` | ``V -> VA`` | - | +| ``mkV2A`` | ``V -> Prep -> V2A`` | - | +| ``mkVQ`` | ``V -> VQ`` | - | +| ``mkV2Q`` | ``V -> Prep -> V2Q`` | - | +| ``mkAS`` | ``A -> AS`` | - | +| ``mkA2S`` | ``A -> Prep -> A2S`` | - | +| ``mkAV`` | ``A -> AV`` | - | +| ``mkA2V`` | ``A -> Prep -> A2V`` | - | + + +==Paradigms for Russian== + + +[source ../russian/ParadigmsRus.gf] + +(To appear) + + +==Paradigms for Spanish== + + +[source ../spanish/ParadigmsSpa.gf] + + + + +|| Function | Type | Example || +| ``Gender`` | ``Type`` | - | +| ``masculine`` | ``Gender`` | - | +| ``feminine`` | ``Gender`` | - | +| ``Number`` | ``Type`` | - | +| ``singular`` | ``Number`` | - | +| ``plural`` | ``Number`` | - | +| ``Prep`` | ``Type`` | - | +| ``accusative`` | ``Prep`` | - | +| ``genitive`` | ``Prep`` | - | +| ``dative`` | ``Prep`` | - | +| ``mkPrep`` | ``Str -> Prep`` | - | +| ``mkN`` | ``(luz : Str) -> N`` | - | +| ``mkN`` | ``Str -> Gender -> N`` | - | +| ``mkN`` | ``(baston,bastones : Str) -> Gender -> N`` | - | +| ``compN`` | ``N -> Str -> N`` | - | +| ``mkN2`` | ``N -> Prep -> N2`` | - | +| ``deN2`` | ``N -> N2`` | - | +| ``aN2`` | ``N -> N2`` | - | +| ``mkN3`` | ``N -> Prep -> Prep -> N3`` | - | +| ``mkPN`` | ``(Anna : Str) -> PN`` | - | +| ``mkPN`` | ``(Pilar : Str) -> Gender -> PN`` | - | +| ``mkA`` | ``(util : Str) -> A`` | - | +| ``mkA`` | ``(solo,sola,solos,solas,solamiento : Str) -> A`` | - | +| ``mkA`` | ``(bueno : A) -> (mejor : A) -> A`` | - | +| ``prefixA`` | ``A -> A`` | - | +| ``mkA2`` | ``A -> Prep -> A2`` | - | +| ``mkAdv`` | ``Str -> Adv`` | - | +| ``mkAdV`` | ``Str -> AdV`` | - | +| ``mkAdA`` | ``Str -> AdA`` | - | +| ``mkV`` | ``(pagar : Str) -> V`` | - | +| ``mkV`` | ``(mostrar,muestro : Str) -> V`` | - | +| ``mkV`` | ``Verbum -> V`` | - | +| ``reflV`` | ``V -> V`` | - | +| ``special_ppV`` | ``V -> Str -> V`` | - | +| ``mkV2`` | ``Str -> V2`` | - | +| ``mkV2`` | ``V -> V2`` | - | +| ``mkV2`` | ``V -> Prep -> V2`` | - | +| ``v2V`` | ``V2 -> V`` | - | +| ``mkV3`` | ``V -> Prep -> Prep -> V3`` | //hablar, a, di// | +| ``dirV3`` | ``V -> Prep -> V3`` | //dar,(accusative),a// | +| ``dirdirV3`` | ``V -> V3`` | //dar,(dative),(accusative)// | +| ``mkV0`` | ``V -> V0`` | - | +| ``mkVS`` | ``V -> VS`` | - | +| ``mkV2S`` | ``V -> Prep -> V2S`` | - | +| ``mkVV`` | ``V -> VV`` | //plain infinitive: "quiero hablar"// | +| ``deVV`` | ``V -> VV`` | //"terminar de hablar"// | +| ``aVV`` | ``V -> VV`` | //"aprender a hablar"// | +| ``mkV2V`` | ``V -> Prep -> Prep -> V2V`` | - | +| ``mkVA`` | ``V -> VA`` | - | +| ``mkV2A`` | ``V -> Prep -> Prep -> V2A`` | - | +| ``mkVQ`` | ``V -> VQ`` | - | +| ``mkV2Q`` | ``V -> Prep -> V2Q`` | - | +| ``mkAS`` | ``A -> AS`` | - | +| ``mkA2S`` | ``A -> Prep -> A2S`` | - | +| ``mkAV`` | ``A -> Prep -> AV`` | - | +| ``mkA2V`` | ``A -> Prep -> Prep -> A2V`` | - | + + +==Paradigms for Swedish== + + +[source ../swedish/ParadigmsSwe.gf] + + + + +|| Function | Type | Example || +| ``Gender`` | ``Type`` | - | +| ``utrum`` | ``Gender`` | - | +| ``neutrum`` | ``Gender`` | - | +| ``Number`` | ``Type`` | - | +| ``singular`` | ``Number`` | - | +| ``plural`` | ``Number`` | - | +| ``Case`` | ``Type`` | - | +| ``nominative`` | ``Case`` | - | +| ``genitive`` | ``Case`` | - | +| ``mkPrep`` | ``Str -> Prep`` | - | +| ``noPrep`` | ``Prep`` | //empty string// | +| ``mkN`` | ``(apa : Str) -> N`` | - | +| ``mkN`` | ``(lik : Str) -> Gender -> N`` | - | +| ``mkN`` | ``(nyckel,nycklar : Str) -> N`` | - | +| ``mkN`` | ``(museum,museet,museer,museerna : Str) -> N`` | - | +| ``mkN2`` | ``Str -> N2`` | - | +| ``mkN2`` | ``N -> Prep -> N2`` | - | +| ``mkN3`` | ``N -> Prep -> Prep -> N3`` | - | +| ``mkPN`` | ``Str -> PN`` | - | +| ``mkPN`` | ``Str -> Gender -> PN`` | - | +| ``mkPN`` | ``(jesus,jesu : Str) -> Gender -> PN`` | - | +| ``mkA`` | ``(billig : Str) -> A`` | - | +| ``mkA`` | ``(bred,brett : Str) -> A`` | - | +| ``mkA`` | ``(tung,tyngre,tyngst : Str) -> A`` | - | +| ``mkA`` | ``(god,gott,goda,battre,bast : Str) -> A`` | - | +| ``mkA`` | ``(liten,litet,lilla,sma,mindre,minst,minsta : Str) -> A`` | - | +| ``compoundA`` | ``A -> A`` | - | +| ``mkA2`` | ``A -> Prep -> A2`` | - | +| ``mkAdv`` | ``Str -> Adv`` | //här// | +| ``mkAdV`` | ``Str -> AdV`` | //alltid// | +| ``mkAdA`` | ``Str -> AdA`` | - | +| ``mkV`` | ``(stämmer : Str) -> V`` | - | +| ``mkV`` | ``(dricka,drack,druckit : Str) -> V`` | - | +| ``mkV`` | ``(gå,går,gå,gick,gått,gången : Str) -> V`` | - | +| ``mkV`` | ``V -> Str -> V`` | - | +| ``depV`` | ``V -> V`` | - | +| ``reflV`` | ``V -> V`` | - | +| ``mkV2`` | ``Str -> V2`` | - | +| ``mkV2`` | ``V -> V2`` | - | +| ``mkV2`` | ``V -> Prep -> V2`` | - | +| ``mkV3`` | ``Str -> V3`` | - | +| ``mkV3`` | ``V -> V3`` | - | +| ``mkV3`` | ``V -> Prep -> V3`` | - | +| ``mkV3`` | ``V -> Prep -> Prep -> V3`` | - | +| ``mkV0`` | ``V -> V0`` | - | +| ``mkVS`` | ``V -> VS`` | - | +| ``mkV2S`` | ``V -> Prep -> V2S`` | - | +| ``mkVV`` | ``V -> VV`` | - | +| ``mkV2V`` | ``V -> Prep -> Prep -> V2V`` | - | +| ``mkVA`` | ``V -> VA`` | - | +| ``mkV2A`` | ``V -> Prep -> V2A`` | - | +| ``mkVQ`` | ``V -> VQ`` | - | +| ``mkV2Q`` | ``V -> Prep -> V2Q`` | - | +| ``mkAS`` | ``A -> AS`` | - | +| ``mkA2S`` | ``A -> Prep -> A2S`` | - | +| ``mkAV`` | ``A -> AV`` | - | +| ``mkA2V`` | ``A -> Prep -> A2V`` | - | + diff --git a/doc/tutorial-next/Foodmarket.png b/doc/tutorial-next/Foodmarket.png new file mode 100644 index 000000000..753cc850d Binary files /dev/null and b/doc/tutorial-next/Foodmarket.png differ diff --git a/doc/tutorial-next/gf-tutorial2.txt b/doc/tutorial-next/gf-tutorial2.txt index ac872e32f..9323bad67 100644 --- a/doc/tutorial-next/gf-tutorial2.txt +++ b/doc/tutorial-next/gf-tutorial2.txt @@ -2938,3 +2938,22 @@ A simpler example will be explained here. See TALK project deliverables, [TALK homepage http://www.talk-project.org] + + + +% Appendices + +=Appendix A: The GF Command Help= + +%!include: ../gf-help.txt + + +=Appendix B: GF Quick Reference= + +%!include: ../gf-reference.txt + + +=Appendix C: Resource Grammar Synopsis= + +%!include: ../resource-synopsis.txt +