documentation for tutorial appendix

4 files changed, 1611 insertions, 0 deletions

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 <p>
+    -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
--- /dev/null
+++ b/doc/tutorial-next/Foodmarket.png
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
+