diff --git a/doc/summerschool-folder.pdf b/doc/summerschool-flyer.pdf similarity index 98% rename from doc/summerschool-folder.pdf rename to doc/summerschool-flyer.pdf index 548fecb64..60a44c149 100644 Binary files a/doc/summerschool-folder.pdf and b/doc/summerschool-flyer.pdf differ diff --git a/doc/summerschool-folder.tex b/doc/summerschool-flyer.tex similarity index 54% rename from doc/summerschool-folder.tex rename to doc/summerschool-flyer.tex index c6ed12841..86d72dc41 100644 --- a/doc/summerschool-folder.tex +++ b/doc/summerschool-flyer.tex @@ -3,8 +3,11 @@ \pagestyle{empty} \usepackage[urlcolor=blue,colorlinks=true]{hyperref} +\setlength{\parindent}{0mm} +\setlength{\parskip}{2mm} + \setlength{\oddsidemargin}{0mm} -\setlength{\evensidemargin}{-2mm} +\setlength{\evensidemargin}{0mm} \setlength{\topmargin}{-12mm} \setlength{\textheight}{240mm} \setlength{\textwidth}{158mm} @@ -32,7 +35,7 @@ Gothenburg, 17-28 August 2009 \newpage \begin{itemize} -\item Do you like programming? +\item Do you like programming challenges? \item Are you interested in how your language really works? \item Would you like to try and build a computational grammar for your language, and make it available as a part of an international open-source @@ -42,44 +45,51 @@ Gothenburg, 17-28 August 2009 Then you should consider attending the GF Resource Grammar Summer School in Gothenburg on 17-28 August 2009. -The GF Resource Grammar Library is an open-source computational grammar resource -that currently covers 12 languages. The Summer School is a part of a -collaborative effort to extend the library to all of the 23 official -EU languages. Also other languages chosen by the participants are welcome. +The GF Resource Grammar Library is an open-source computational grammar +resource that currently covers 12 languages. It has been created in +a collaborative effort using the GF (Grammatical Framework) grammar formalism. +The Summer School aims to boost the extension of the library to new languages. -The missing EU languages are: -Czech, Dutch, Estonian, Greek, Hungarian, Irish, Latvian, Lithuanian, -Maltese, Portuguese, Slovak, and Slovenian. There is also more work to +Particularly in focus are the missing 12 of the 23 official languages of the +European Union: \textit{Czech, Dutch, +Estonian, Greek, Hungarian, Irish, Latvian, Lithuanian, +Maltese, Portuguese, Slovak, and Slovenian}. There is also more work to be done on Polish and Romanian. +Any other languages chosen by the participants are also welcome. +Good knowledge of the language is essential, but you don't need to be a +native speaker. The linguistic coverage of the library includes the inflectional morphology -and basic syntax of each language. It can be used in GF applications -and also ported to other formats. It can also be used for building other -linguistic resources, such as morphological lexica and parsers. +and basic syntax of each language. It can be used for parsing, +generation, translation, multilingual web pages, +speech recognition, dialogue systems, language teaching, morphological +analysis, software localization, and lots of other things. +Grammars written in GF can be converted to many different formats. The library is licensed under LGPL. In the summer school, each language will be implemented by one or two students working together. A morphology implementation will be credited -as a Chalmers course worth 7.5 ETCS points; adding a syntax implementation +as a Chalmers University +course worth 7.5 ETCS points; adding a syntax implementation will be worth more. The estimated total work load is 1-2 months for the morphology, and 3-6 months for the whole grammar. Participation in the summer school is free. -Registration is done via the courses's Google group, +Registration is via the courses's Google group, \begin{verbatim} http://groups.google.com/group/gf-resource-school-2009/ \end{verbatim} -The registration deadline is 15 June 2009. +The registration deadline is 15 June 2009. An on-line course on GF (recommended, +but not compulsory) starts on 20 April. Some travel grants will be available. They are distributed on the basis of a -GF programming contest in April and May. +GF programming contest in May. -For more information, see the Google Group above, as well as the -Summer School web page, +For more information, see the Google Group and the Summer School web page, \begin{verbatim} - http://digitalgrammars.com/gf/doc/gf-summerschool.html + http://digitalgrammars.com/gf/summerschool.html \end{verbatim} % LaTeX2e code generated by txt2tags 2.4 (http://txt2tags.sf.net) diff --git a/next-lib/doc/German.dot b/next-lib/doc/German.dot new file mode 100644 index 000000000..e17ca1484 --- /dev/null +++ b/next-lib/doc/German.dot @@ -0,0 +1,107 @@ +digraph { + +size = "12,12" ; + +LangGer [style = "dashed", shape = "box", URL = "LangGer.gf"]; +LangGer -> NounGer [style = "solid"]; +LangGer -> VerbGer [style = "solid"]; +LangGer -> ConjunctionGer [style = "solid"]; +LangGer -> StructuralGer [style = "solid"]; +LangGer -> LexiconGer [style = "solid"]; +LangGer -> Lang [arrowhead = "empty", style = "dashed"]; + +Lang [style = "solid", shape = "ellipse", URL = "Lang.gf"]; +Lang -> Noun [style = "solid"]; +Lang -> Verb [style = "solid"]; +Lang -> Conjunction [style = "solid"]; +Lang -> Structural [style = "solid"]; +Lang -> Lexicon [style = "solid"]; + +NounGer [style = "dashed", shape = "box", URL = "NounGer.gf"]; +NounGer -> CatGer [style = "solid"]; +NounGer -> ResGer [style = "dotted"]; +NounGer -> Prelude [style = "dotted"]; +NounGer -> Noun [arrowhead = "empty", style = "dashed"]; + +Noun [style = "solid", shape = "ellipse", URL = "Noun.gf"]; +Noun -> Cat [style = "solid"]; + +VerbGer [style = "dashed", shape = "box", URL = "VerbGer.gf"]; +VerbGer -> CatGer [style = "solid"]; +VerbGer -> Prelude [style = "dotted"]; +VerbGer -> ResGer [style = "dotted"]; +VerbGer -> Verb [arrowhead = "empty", style = "dashed"]; + +Verb [style = "solid", shape = "ellipse", URL = "Verb.gf"]; +Verb -> Cat [style = "solid"]; + +ConjunctionGer [style = "dashed", shape = "box", URL = "ConjunctionGer.gf"]; +ConjunctionGer -> CatGer [style = "solid"]; +ConjunctionGer -> ResGer [style = "dotted"]; +ConjunctionGer -> Coordination [style = "dotted"]; +ConjunctionGer -> Prelude [style = "dotted"]; +ConjunctionGer -> Conjunction [arrowhead = "empty", style = "dashed"]; + +Conjunction [style = "solid", shape = "ellipse", URL = "Conjunction.gf"]; +Conjunction -> Cat [style = "solid"]; + +Coordination [style = "dashed", shape = "ellipse", URL = "Coordination.gf"]; +Coordination -> Prelude [style = "dotted"]; + +StructuralGer [style = "dashed", shape = "box", URL = "StructuralGer.gf"]; +StructuralGer -> CatGer [style = "solid"]; +StructuralGer -> MorphoGer [style = "dotted"]; +StructuralGer -> Prelude [style = "dotted"]; +StructuralGer -> Structural [arrowhead = "empty", style = "dashed"]; + +Structural [style = "solid", shape = "ellipse", URL = "Structural.gf"]; +Structural -> Cat [style = "solid"]; + +LexiconGer [style = "dashed", shape = "box", URL = "LexiconGer.gf"]; +LexiconGer -> CatGer [style = "solid"]; +LexiconGer -> Prelude [style = "dotted"]; +LexiconGer -> ParadigmsGer [style = "dotted"]; +LexiconGer -> Lexicon [arrowhead = "empty", style = "dashed"]; + +Lexicon [style = "solid", shape = "ellipse", URL = "Lexicon.gf"]; +Lexicon -> Cat [style = "solid"]; + +ParadigmsGer [style = "dashed", shape = "ellipse", URL = "ParadigmsGer.gf"]; +ParadigmsGer -> Predef [style = "dotted"]; +ParadigmsGer -> Prelude [style = "dotted"]; +ParadigmsGer -> MorphoGer [style = "dotted"]; +ParadigmsGer -> CatGer [style = "dotted"]; + +CatGer [style = "dashed", shape = "box", URL = "CatGer.gf"]; +CatGer -> CommonX [style = "solid"]; +CatGer -> ResGer [style = "dotted"]; +CatGer -> Prelude [style = "dotted"]; +CatGer -> Cat [arrowhead = "empty", style = "dashed"]; + +Cat [style = "solid", shape = "ellipse", URL = "Cat.gf"]; +Cat -> Common [style = "solid"]; + +CommonX [style = "dashed", shape = "box", URL = "CommonX.gf"]; +CommonX -> ParamX [style = "dotted"]; +CommonX -> Common [arrowhead = "empty", style = "dashed"]; + +Common [style = "solid", shape = "ellipse", URL = "Common.gf"]; + +MorphoGer [style = "dashed", shape = "ellipse", URL = "MorphoGer.gf"]; +MorphoGer -> ResGer [style = "solid"]; +MorphoGer -> Prelude [style = "dotted"]; +MorphoGer -> Predef [style = "dotted"]; + +ResGer [style = "dashed", shape = "ellipse", URL = "ResGer.gf"]; +ResGer -> ParamX [style = "solid"]; +ResGer -> Prelude [style = "dotted"]; + +ParamX [style = "dashed", shape = "ellipse", URL = "ParamX.gf"]; +ParamX -> Prelude [style = "dotted"]; + +Prelude [style = "dashed", shape = "ellipse", URL = "Prelude.gf"]; +Prelude -> Predef [style = "dotted"]; + +Predef [style = "dashed", shape = "ellipse", URL = "Predef.gf"]; + +} diff --git a/next-lib/doc/German.png b/next-lib/doc/German.png new file mode 100644 index 000000000..7c6303897 Binary files /dev/null and b/next-lib/doc/German.png differ diff --git a/next-lib/doc/Grammar.dot b/next-lib/doc/Grammar.dot new file mode 100644 index 000000000..cb2998eb3 --- /dev/null +++ b/next-lib/doc/Grammar.dot @@ -0,0 +1,75 @@ +digraph { + +size = "12,8" ; + +Lang [style = "solid", shape = "ellipse", URL = "Lang.gf"]; + +Lang -> Grammar [style = "solid"]; +Lang -> Lexicon [style = "solid"]; + +Grammar [style = "solid", shape = "ellipse", URL = "Lang.gf"]; + + +Grammar -> Noun [style = "solid"]; +Grammar -> Verb [style = "solid"]; +Grammar -> Adjective [style = "solid"]; +Grammar -> Adverb [style = "solid"]; +Grammar -> Numeral [style = "solid"]; +Grammar -> Sentence [style = "solid"]; +Grammar -> Question [style = "solid"]; +Grammar -> Relative [style = "solid"]; +Grammar -> Conjunction [style = "solid"]; +Grammar -> Phrase [style = "solid"]; +Grammar -> Text [style = "solid"]; +Grammar -> Idiom [style = "solid"]; +Grammar -> Structural [style = "solid"]; + + +Noun [style = "solid", shape = "ellipse", URL = "Noun.gf"]; +Noun -> Cat [style = "solid"]; + +Verb [style = "solid", shape = "ellipse", URL = "Verb.gf"]; +Verb -> Cat [style = "solid"]; + +Adjective [style = "solid", shape = "ellipse", URL = "Adjective.gf"]; +Adjective -> Cat [style = "solid"]; + +Adverb [style = "solid", shape = "ellipse", URL = "Adverb.gf"]; +Adverb -> Cat [style = "solid"]; + +Numeral [style = "solid", shape = "ellipse", URL = "Numeral.gf"]; +Numeral -> Cat [style = "solid"]; + +Sentence [style = "solid", shape = "ellipse", URL = "Sentence.gf"]; +Sentence -> Cat [style = "solid"]; + +Question [style = "solid", shape = "ellipse", URL = "Question.gf"]; +Question -> Cat [style = "solid"]; + +Relative [style = "solid", shape = "ellipse", URL = "Relative.gf"]; +Relative -> Cat [style = "solid"]; + +Conjunction [style = "solid", shape = "ellipse", URL = "Conjunction.gf"]; +Conjunction -> Cat [style = "solid"]; + +Phrase [style = "solid", shape = "ellipse", URL = "Phrase.gf"]; +Phrase -> Cat [style = "solid"]; + +Text [style = "solid", shape = "ellipse", URL = "Phrase.gf"]; +Text -> Cat [style = "solid"]; + +Idiom [style = "solid", shape = "ellipse", URL = "Phrase.gf"]; +Idiom -> Cat [style = "solid"]; + +Structural [style = "solid", shape = "ellipse", URL = "Structural.gf"]; +Structural -> Cat [style = "solid"]; + +Lexicon [style = "solid", shape = "ellipse", URL = "Lexicon.gf"]; +Lexicon -> Cat [style = "solid"]; + +Cat [style = "solid", shape = "ellipse", URL = "Cat.gf"]; +Cat -> Common [style = "solid"]; + +Common [style = "solid", shape = "ellipse", URL = "Tense.gf"]; + +} diff --git a/next-lib/doc/Grammar.png b/next-lib/doc/Grammar.png new file mode 100644 index 000000000..1c05474b2 Binary files /dev/null and b/next-lib/doc/Grammar.png differ diff --git a/next-lib/doc/Lang.dot b/next-lib/doc/Lang.dot new file mode 100644 index 000000000..7de26e74c --- /dev/null +++ b/next-lib/doc/Lang.dot @@ -0,0 +1,68 @@ +digraph { + +size = "12,8" ; + +Lang [style = "solid", shape = "ellipse", URL = "Lang.gf"]; +Lang -> Noun [style = "solid"]; +Lang -> Verb [style = "solid"]; +Lang -> Adjective [style = "solid"]; +Lang -> Adverb [style = "solid"]; +Lang -> Numeral [style = "solid"]; +Lang -> Sentence [style = "solid"]; +Lang -> Question [style = "solid"]; +Lang -> Relative [style = "solid"]; +Lang -> Conjunction [style = "solid"]; +Lang -> Phrase [style = "solid"]; +Lang -> Text [style = "solid"]; +Lang -> Idiom [style = "solid"]; +Lang -> Structural [style = "solid"]; +Lang -> Lexicon [style = "solid"]; + +Noun [style = "solid", shape = "ellipse", URL = "Noun.gf"]; +Noun -> Cat [style = "solid"]; + +Verb [style = "solid", shape = "ellipse", URL = "Verb.gf"]; +Verb -> Cat [style = "solid"]; + +Adjective [style = "solid", shape = "ellipse", URL = "Adjective.gf"]; +Adjective -> Cat [style = "solid"]; + +Adverb [style = "solid", shape = "ellipse", URL = "Adverb.gf"]; +Adverb -> Cat [style = "solid"]; + +Numeral [style = "solid", shape = "ellipse", URL = "Numeral.gf"]; +Numeral -> Cat [style = "solid"]; + +Sentence [style = "solid", shape = "ellipse", URL = "Sentence.gf"]; +Sentence -> Cat [style = "solid"]; + +Question [style = "solid", shape = "ellipse", URL = "Question.gf"]; +Question -> Cat [style = "solid"]; + +Relative [style = "solid", shape = "ellipse", URL = "Relative.gf"]; +Relative -> Cat [style = "solid"]; + +Conjunction [style = "solid", shape = "ellipse", URL = "Conjunction.gf"]; +Conjunction -> Cat [style = "solid"]; + +Phrase [style = "solid", shape = "ellipse", URL = "Phrase.gf"]; +Phrase -> Cat [style = "solid"]; + +Text [style = "solid", shape = "ellipse", URL = "Phrase.gf"]; +Text -> Cat [style = "solid"]; + +Idiom [style = "solid", shape = "ellipse", URL = "Phrase.gf"]; +Idiom -> Cat [style = "solid"]; + +Structural [style = "solid", shape = "ellipse", URL = "Structural.gf"]; +Structural -> Cat [style = "solid"]; + +Lexicon [style = "solid", shape = "ellipse", URL = "Lexicon.gf"]; +Lexicon -> Cat [style = "solid"]; + +Cat [style = "solid", shape = "ellipse", URL = "Cat.gf"]; +Cat -> Common [style = "solid"]; + +Common [style = "solid", shape = "ellipse", URL = "Tense.gf"]; + +} diff --git a/next-lib/doc/Lang.png b/next-lib/doc/Lang.png new file mode 100644 index 000000000..3fc770382 Binary files /dev/null and b/next-lib/doc/Lang.png differ diff --git a/next-lib/doc/Makefile b/next-lib/doc/Makefile new file mode 100644 index 000000000..e91ff322c --- /dev/null +++ b/next-lib/doc/Makefile @@ -0,0 +1,16 @@ +.PHONY: abstract synopsis + +all: synopsis abstract + +index: + txt2tags -thtml index.txt +synopsis: + runghc MkSynopsis.hs + +categories-imagemap.html: categories.dot + dot -Tcmapx $^ > $@ + +abstract: + gfdoc -txthtml ../src/abstract/*.gf + mv ../src/abstract/*.html abstract + diff --git a/next-lib/doc/MkSynopsis.hs b/next-lib/doc/MkSynopsis.hs new file mode 100644 index 000000000..88fe82c0d --- /dev/null +++ b/next-lib/doc/MkSynopsis.hs @@ -0,0 +1,244 @@ +import System +import Char +import List + +type Cats = [(String,String,String)] +type Rules = [(String,String,String)] + +main = do + xx <- getArgs + let isLatex = case xx of + "-tex":_ -> True + _ -> False + cs1 <- getCats commonAPI + cs2 <- getCats catAPI + let cs = sortCats (cs1 ++ cs2) + writeFile synopsis "GF Resource Grammar Library: Synopsis" + append "B. Bringert and A. Ranta" + space + append "%!postproc(html): '(SRC=\"categories.png\")' '\\1 USEMAP=\"#categories\"'" + append "%!postproc(html): '#LParadigms' ''" + append "%!postproc(tex): '#LParadigms' ''" + delimit $ addToolTips cs + include "synopsis-intro.txt" + title "Categories" + space + link "Source 1:" commonAPI + space + link "Source 2:" catAPI + space + append "==A hierarchic view==\n" + include "categories-intro.txt" + append "==Explanations==\n" + delimit $ mkCatTable isLatex cs + space + title "Syntax Rules and Structural Words" + space + link "Source 1:" syntaxAPI + space + link "Source 2:" structuralAPI + space + rs <- getRules syntaxAPI + rs2 <- getRules structuralAPI + delimit $ mkSplitTables True isLatex cs $ rs ++ rs2 + space +-- title "Structural Words" +-- space +-- link "Source:" structuralAPI +-- space +-- rs <- rulesTable False isLatex cs structuralAPI +-- delimit rs + space + title "Lexical Paradigms" + mapM_ (putParadigms isLatex cs) paradigmFiles + space + include "synopsis-browse.txt" + space + title "An Example of Usage" + space + include "synopsis-example.txt" + space + let format = if isLatex then "tex" else "html" + system $ "txt2tags -t" ++ format ++ " --toc " ++ synopsis + if isLatex then (system $ "pdflatex synopsis.tex") >> return () else return () + +addToolTips :: Cats -> [String] +addToolTips = map f + where f (n,e,_) = "%!postproc(html): '(?i)(HREF=\"#" ++ n ++ "\")( TITLE=\"[^\"]*\")?' '\\1 TITLE=\"" ++ e' ++ "\"'" + where e' = n ++ if null e then "" else " - " ++ e + +getCats :: FilePath -> IO Cats +getCats file = do + ss <- readFile file >>= return . lines + return $ getrs [] ss + where + getrs rs ss = case ss of + ('-':'-':'.':_):_ -> reverse rs + [] -> reverse rs + ('-':'-':_):ss2 -> getrs rs ss2 + s:ss2 -> case words s of + cat:";":"--":exp -> getrs ((cat,unwords expl, unwords (tail ex)):rs) ss2 where + (expl,ex) = span (/="e.g.") exp + _ -> getrs rs ss2 + +rulesTable :: Bool -> Bool -> Cats -> FilePath -> IO [String] +rulesTable hasEx isLatex cs file = do + rs <- getRules file + return $ mkTable hasEx isLatex cs rs + + +getRules :: FilePath -> IO Rules +getRules file = do + ss <- readFile file >>= return . lines + return $ getrs [] ss + where + getrs rs ss = case ss of + ('-':'-':'.':_):_ -> reverse rs + [] -> reverse rs + ('-':'-':_):ss2 -> getrs rs ss2 + s:ss2 -> case words s of + _:_:"overload":_ -> getrs rs ss2 + _:":":_ -> getrs (rule s:rs) ss2 + _ -> getrs rs ss2 + rule s = (name, typ, ex) + where + ws = takeWhile (/="--#") $ words s + name = head ws + (t,e) = span (/="--") (tail ws) + typ = unwords $ filtype (drop 1 t) + filtype = filter (/=";") + ex = if null e then "" else unwords $ unnumber $ drop 1 e + unnumber e = case e of + n:ws | last n == '.' && not (null (init n)) && all isDigit (init n) -> ws + _ -> e + +putParadigms :: Bool -> Cats -> (String, FilePath) -> IO () +putParadigms isLatex cs (lang,file) = do + stitle ("Paradigms for " ++ lang) + append "#LParadigms" + space + link "source" file + space + rs <- rulesTable False isLatex cs file + space + delimit rs + space + +inChunks :: Int -> ([a] -> [String]) -> [a] -> [String] +inChunks i f = concat . intersperse ["\n\n"] . map f . chunks i where + chunks _ [] = [] + chunks i xs = x : chunks i y where (x,y) = splitAt i xs + +-- Makes one table per result category. +-- Adds a subsection header for each table. +mkSplitTables :: Bool -> Bool -> Cats -> Rules -> [String] +mkSplitTables hasEx isLatex cs = concatMap t . addLexicalCats cs . sortRules + where t (c, xs) = [subtitle c expl] ++ tableOrLink + where + expl = case [e | (n,e,_) <- cs, n == c] of + [] -> "" + e:_ -> e + tableOrLink = if null xs then parad else mkTable hasEx isLatex cs xs + parad = [ + "Lexical category, constructors given in", + "[lexical paradigms #RParadigms]." + ] + +mkTable :: Bool -> Bool -> Cats -> Rules -> [String] +mkTable hasEx isLatex cs = inChunks chsize (\rs -> header : map (unwords . row) rs) + where + chsize = if isLatex then 40 else 1000 + header = if hasEx then "|| Function | Type | Example ||" + else "|| Function | Type ||" + row (name,typ,ex) + = if hasEx then ["|", name', "|", typ', "|", ex', "|"] + else ["|", name', "|", typ', "|"] + where + name' = ttf name + typ' = showTyp cs typ + ex' = if null ex then itf (takeWhile (/='_') name) else itf ex + +mkCatTable :: Bool -> Cats -> [String] +mkCatTable isLatex cs = inChunks chsize (\rs -> header ++ map mk1 rs) cs + where + header = ["|| Category | Explanation | Example ||"] + chsize = if isLatex then 40 else 1000 + mk1 (name,expl,ex) = unwords ["|", showCat cs name, "|", expl, "|", typo ex, "|"] + typo ex = if take 1 ex == "\"" then itf (init (tail ex)) else ex + +srcPath = ("../src" ++) + +synopsis = "synopsis.txt" +commonAPI = srcPath "/abstract/Common.gf" +catAPI = srcPath "/abstract/Cat.gf" +syntaxAPI = srcPath "/api/Constructors.gf" +structuralAPI = srcPath "/abstract/Structural.gf" +paradigmFiles = [ + ("Bulgarian", srcPath "/bulgarian/ParadigmsBul.gf"), + ("Catalan", srcPath "/catalan/ParadigmsCat.gf"), + ("Danish", srcPath "/danish/ParadigmsDan.gf"), + ("English", srcPath "/english/ParadigmsEng.gf"), + ("Finnish", srcPath "/finnish/ParadigmsFin.gf"), + ("French", srcPath "/french/ParadigmsFre.gf"), + ("German", srcPath "/german/ParadigmsGer.gf"), +-- ("Interlingua", srcPath "/interlingua/ParadigmsIna.gf"), + ("Italian", srcPath "/italian/ParadigmsIta.gf"), + ("Norwegian", srcPath "/norwegian/ParadigmsNor.gf"), + ("Romanian", srcPath "/romanian/ParadigmsRon.gf"), + ("Russian", srcPath "/russian/ParadigmsRus.gf"), + ("Spanish", srcPath "/spanish/ParadigmsSpa.gf"), + ("Swedish", srcPath "/swedish/ParadigmsSwe.gf") + ] + +append s = appendFile synopsis ('\n':s) +title s = append $ "=" ++ s ++ "=" +stitle s = append $ "==" ++ s ++ "==" +include s = append $ "%!include: " ++ s +space = append "\n" +delimit ss = mapM_ append ss +link s f = append $ s ++ " [``" ++ fa ++ "`` " ++ f ++ "]" where + fa = "http://www.cs.chalmers.se/~aarne/GF/lib/resource" ++ dropWhile (=='.') f + +ttf s = "``" ++ s ++ "``" +itf s = "//" ++ s ++ "//" + +----------------- + +-- sort category synopsis by category, retain one table +sortCats :: Cats -> Cats +sortCats = sortBy compareCat + where compareCat (n1,_,_) (n2,_,_) = compare n1 n2 + +-- sort function synopsis by category, into separate tables +sortRules :: Rules -> [Rules] +sortRules = groupBy sameCat . sortBy compareRules + where sameCat r1 r2 = resultCat r1 == resultCat r2 + compareRules r1@(n1,_,_) r2@(n2,_,_) + = compare (resultCat r1,n1) (resultCat r2,n2) + +addLexicalCats :: Cats -> [Rules] -> [(String,Rules)] +addLexicalCats cs rss = + map head $ groupBy fstEq $ sortBy (\x y -> compare (fst x) (fst y)) $ + [ (resultCat r, rs) | rs@(r:_) <- rss] ++ [(n,[]) | (n,_,_) <- cs] + where fstEq p1 p2 = fst p1 == fst p2 + +resultCat :: (String,String,String) -> String +resultCat (_,t,_) = last (words t) + + +subtitle cat expl = "==" ++ cat ++ e ++ "==" ++ "[" ++ cat ++ "]" + where e = if null expl then "" else " - " ++ expl + +showCat :: Cats -> String -> String +showCat cs cat = "[" ++ cat ++ " #" ++ cat ++ "]" + +showTyp :: Cats -> String -> String +showTyp cs = unwords . map f . words + where f s | head s == '(' && last s == ')' && isCat c + = "(" ++ showCat cs c ++ ")" + | isCat s = showCat cs s + | otherwise = ttf s + where c = init (tail s) + isCat cat = cat `notElem` ["Str","Int"] + && all (\c -> isAlphaNum c || c == '\'') cat + && isUpper (head cat) diff --git a/next-lib/doc/Resource-HOWTO.txt b/next-lib/doc/Resource-HOWTO.txt new file mode 100644 index 000000000..fff5f439f --- /dev/null +++ b/next-lib/doc/Resource-HOWTO.txt @@ -0,0 +1,787 @@ +Resource grammar writing HOWTO +Author: Aarne Ranta +Last update: %%date(%c) + +% NOTE: this is a txt2tags file. +% Create an html file from this file using: +% txt2tags --toc -thtml Resource-HOWTO.txt + +%!target:html + +**History** + +October 2007: updated for API 1.2. + +January 2006: first version. + + +The purpose of this document is to tell how to implement the GF +resource grammar API for a new language. We will //not// cover how +to use the resource grammar, nor how to change the API. But we +will give some hints how to extend the API. + +A manual for using the resource grammar is found in + +[``http://www.cs.chalmers.se/~aarne/GF/lib/resource-1.0/doc/synopsis.html`` http://www.cs.chalmers.se/~aarne/GF/lib/resource-1.0/doc/synopsis.html]. + +A tutorial on GF, also introducing the idea of resource grammars, is found in + +[``http://www.cs.chalmers.se/~aarne/GF/doc/tutorial/gf-tutorial2.html`` ../../../doc/tutorial/gf-tutorial2.html]. + +This document concerns the API v. 1.0. You can find the current code in + +[``http://www.cs.chalmers.se/~aarne/GF/lib/resource-1.0/`` ..] + + + + +==The resource grammar structure== + +The library is divided into a bunch of modules, whose dependencies +are given in the following figure. + +[Syntax.png] + +- solid contours: module used by end users +- dashed contours: internal module +- ellipse: abstract/concrete pair of modules +- rectangle: resource or instance +- diamond: interface + + +The solid ellipses show the API as visible to the user of the library. The +dashed ellipses form the main of the implementation, on which the resource +grammar programmer has to work with. With the exception of the ``Paradigms`` +module, the visible API modules can be produced mechanically. + +[Grammar.png] + +Thus the API consists of a grammar and a lexicon, which is +provided for test purposes. + +The module structure is rather flat: most modules are direct +parents of ``Grammar``. The idea +is that you can concentrate on one linguistic aspect at a time, or +also distribute the work among several authors. The module ``Cat`` +defines the "glue" that ties the aspects together - a type system +to which all the other modules conform, so that e.g. ``NP`` means +the same thing in those modules that use ``NP``s and those that +constructs them. + + + +===Phrase category modules=== + +The direct parents of the top will be called **phrase category modules**, +since each of them concentrates on a particular phrase category (nouns, verbs, +adjectives, sentences,...). A phrase category module tells +//how to construct phrases in that category//. You will find out that +all functions in any of these modules have the same value type (or maybe +one of a small number of different types). Thus we have + + +- ``Noun``: construction of nouns and noun phrases +- ``Adjective``: construction of adjectival phrases +- ``Verb``: construction of verb phrases +- ``Adverb``: construction of adverbial phrases +- ``Numeral``: construction of cardinal and ordinal numerals +- ``Sentence``: construction of sentences and imperatives +- ``Question``: construction of questions +- ``Relative``: construction of relative clauses +- ``Conjunction``: coordination of phrases +- ``Phrase``: construction of the major units of text and speech +- ``Text``: construction of texts as sequences of phrases +- ``Idiom``: idiomatic phrases such as existentials + + + + +===Infrastructure modules=== + +Expressions of each phrase category are constructed in the corresponding +phrase category module. But their //use// takes mostly place in other modules. +For instance, noun phrases, which are constructed in ``Noun``, are +used as arguments of functions of almost all other phrase category modules. +How can we build all these modules independently of each other? + +As usual in typeful programming, the //only// thing you need to know +about an object you use is its type. When writing a linearization rule +for a GF abstract syntax function, the only thing you need to know is +the linearization types of its value and argument categories. To achieve +the division of the resource grammar to several parallel phrase category modules, +what we need is an underlying definition of the linearization types. This +definition is given as the implementation of + +- ``Cat``: syntactic categories of the resource grammar + + +Any resource grammar implementation has first to agree on how to implement +``Cat``. Luckily enough, even this can be done incrementally: you +can skip the ``lincat`` definition of a category and use the default +``{s : Str}`` until you need to change it to something else. In +English, for instance, many categories do have this linearization type. + + + +===Lexical modules=== + +What is lexical and what is syntactic is not as clearcut in GF as in +some other grammar formalisms. Logically, lexical means atom, i.e. a +``fun`` with no arguments. Linguistically, one may add to this +that the ``lin`` consists of only one token (or of a table whose values +are single tokens). Even in the restricted lexicon included in the resource +API, the latter rule is sometimes violated in some languages. For instance, +``Structural.both7and_DConj`` is an atom, but its linearization is +two words e.g. //both - and//. + +Another characterization of lexical is that lexical units can be added +almost //ad libitum//, and they cannot be defined in terms of already +given rules. The lexical modules of the resource API are thus more like +samples than complete lists. There are two such modules: + +- ``Structural``: structural words (determiners, conjunctions,...) +- ``Lexicon``: basic everyday content words (nouns, verbs,...) + + +The module ``Structural`` aims for completeness, and is likely to +be extended in future releases of the resource. The module ``Lexicon`` +gives a "random" list of words, which enable interesting testing of syntax, +and also a check list for morphology, since those words are likely to include +most morphological patterns of the language. + +In the case of ``Lexicon`` it may come out clearer than anywhere else +in the API that it is impossible to give exact translation equivalents in +different languages on the level of a resource grammar. In other words, +application grammars are likely to use the resource in different ways for +different languages. + + +==Language-dependent syntax modules== + +In addition to the common API, there is room for language-dependent extensions +of the resource. The top level of each languages looks as follows (with English as example): +``` + abstract English = Grammar, ExtraEngAbs, DictEngAbs +``` +where ``ExtraEngAbs`` is a collection of syntactic structures specific to English, +and ``DictEngAbs`` is an English dictionary +(at the moment, it consists of ``IrregEngAbs``, +the irregular verbs of English). Each of these language-specific grammars has +the potential to grow into a full-scale grammar of the language. These grammar +can also be used as libraries, but the possibility of using functors is lost. + +To give a better overview of language-specific structures, +modules like ``ExtraEngAbs`` +are built from a language-independent module ``ExtraAbs`` +by restricted inheritance: +``` + abstract ExtraEngAbs = Extra [f,g,...] +``` +Thus any category and function in ``Extra`` may be shared by a subset of all +languages. One can see this set-up as a matrix, which tells +what ``Extra`` structures +are implemented in what languages. For the common API in ``Grammar``, the matrix +is filled with 1's (everything is implemented in every language). + +In a minimal resource grammar implementation, the language-dependent +extensions are just empty modules, but it is good to provide them for +the sake of uniformity. + + +==The core of the syntax== + +Among all categories and functions, a handful are +most important and distinct ones, of which the others are can be +seen as variations. The categories are +``` + Cl ; VP ; V2 ; NP ; CN ; Det ; AP ; +``` +The functions are +``` + PredVP : NP -> VP -> Cl ; -- predication + ComplV2 : V2 -> NP -> VP ; -- complementization + DetCN : Det -> CN -> NP ; -- determination + ModCN : AP -> CN -> CN ; -- modification +``` +This [toy Latin grammar latin.gf] shows in a nutshell how these +rules relate the categories to each other. It is intended to be a +first approximation when designing the parameter system of a new +language. + + +===Another reduced API=== + +If you want to experiment with a small subset of the resource API first, +try out the module +[Syntax http://www.cs.chalmers.se/~aarne/GF/doc/tutorial/resource/Syntax.gf] +explained in the +[GF Tutorial http://www.cs.chalmers.se/~aarne/GF/doc/tutorial/gf-tutorial2.html]. + + +===The present-tense fragment=== + +Some lines in the resource library are suffixed with the comment +```--# notpresent +which is used by a preprocessor to exclude those lines from +a reduced version of the full resource. This present-tense-only +version is useful for applications in most technical text, since +they reduce the grammar size and compilation time. It can also +be useful to exclude those lines in a first version of resource +implementation. To compile a grammar with present-tense-only, use +``` + i -preproc=GF/lib/resource-1.0/mkPresent LangGer.gf +``` + + + +==Phases of the work== + +===Putting up a directory=== + +Unless you are writing an instance of a parametrized implementation +(Romance or Scandinavian), which will be covered later, the +simplest way is to follow roughly the following procedure. Assume you +are building a grammar for the German language. Here are the first steps, +which we actually followed ourselves when building the German implementation +of resource v. 1.0. + ++ Create a sister directory for ``GF/lib/resource/english``, named + ``german``. +``` + cd GF/lib/resource/ + mkdir german + cd german +``` + ++ Check out the [ISO 639 3-letter language code + http://www.w3.org/WAI/ER/IG/ert/iso639.htm] + for German: both ``Ger`` and ``Deu`` are given, and we pick ``Ger``. + ++ Copy the ``*Eng.gf`` files from ``english`` ``german``, + and rename them: +``` + cp ../english/*Eng.gf . + rename 's/Eng/Ger/' *Eng.gf +``` + ++ Change the ``Eng`` module references to ``Ger`` references + in all files: +``` + sed -i 's/English/German/g' *Ger.gf + sed -i 's/Eng/Ger/g' *Ger.gf +``` + The first line prevents changing the word ``English``, which appears + here and there in comments, to ``Gerlish``. + ++ This may of course change unwanted occurrences of the + string ``Eng`` - verify this by +``` + grep Ger *.gf +``` + But you will have to make lots of manual changes in all files anyway! + ++ Comment out the contents of these files: +``` + sed -i 's/^/--/' *Ger.gf +``` + This will give you a set of templates out of which the grammar + will grow as you uncomment and modify the files rule by rule. + ++ In all ``.gf`` files, uncomment the module headers and brackets, + leaving the module bodies commented. Unfortunately, there is no + simple way to do this automatically (or to avoid commenting these + lines in the previous step) - but uncommenting the first + and the last lines will actually do the job for many of the files. + ++ Uncomment the contents of the main grammar file: +``` + sed -i 's/^--//' LangGer.gf +``` + ++ Now you can open the grammar ``LangGer`` in GF: +``` + gf LangGer.gf +``` + You will get lots of warnings on missing rules, but the grammar will compile. + ++ At all following steps you will now have a valid, but incomplete + GF grammar. The GF command +``` + pg -printer=missing +``` + tells you what exactly is missing. + + +Here is the module structure of ``LangGer``. It has been simplified by leaving out +the majority of the phrase category modules. Each of them has the same dependencies +as e.g. ``VerbGer``. + +[German.png] + + +===Direction of work=== + +The real work starts now. There are many ways to proceed, the main ones being +- Top-down: start from the module ``Phrase`` and go down to ``Sentence``, then + ``Verb``, ``Noun``, and in the end ``Lexicon``. In this way, you are all the time + building complete phrases, and add them with more content as you proceed. + **This approach is not recommended**. It is impossible to test the rules if + you have no words to apply the constructions to. + +- Bottom-up: set as your first goal to implement ``Lexicon``. To this end, you + need to write ``ParadigmsGer``, which in turn needs parts of + ``MorphoGer`` and ``ResGer``. + **This approach is not recommended**. You can get stuck to details of + morphology such as irregular words, and you don't have enough grasp about + the type system to decide what forms to cover in morphology. + + +The practical working direction is thus a saw-like motion between the morphological +and top-level modules. Here is a possible course of the work that gives enough +test data and enough general view at any point: ++ Define ``Cat.N`` and the required parameter types in ``ResGer``. As we define +``` + lincat N = {s : Number => Case => Str ; g : Gender} ; +``` +we need the parameter types ``Number``, ``Case``, and ``Gender``. The definition +of ``Number`` in [``common/ParamX`` ../common/ParamX.gf] works for German, so we +use it and just define ``Case`` and ``Gender`` in ``ResGer``. + ++ Define ``regN`` in ``ParadigmsGer``. In this way you can +already implement a huge amount of nouns correctly in ``LexiconGer``. Actually +just adding ``mkN`` should suffice for every noun - but, +since it is tedious to use, you +might proceed to the next step before returning to morphology and defining the +real work horse ``reg2N``. + ++ While doing this, you may want to test the resource independently. Do this by +``` + i -retain ParadigmsGer + cc regN "Kirche" +``` + ++ Proceed to determiners and pronouns in +``NounGer`` (``DetCN UsePron DetSg SgQuant NoNum NoOrd DefArt IndefArt UseN``)and +``StructuralGer`` (``i_Pron every_Det``). You also need some categories and +parameter types. At this point, it is maybe not possible to find out the final +linearization types of ``CN``, ``NP``, and ``Det``, but at least you should +be able to correctly inflect noun phrases such as //every airplane//: +``` + i LangGer.gf + l -table DetCN every_Det (UseN airplane_N) + + Nom: jeder Flugzeug + Acc: jeden Flugzeug + Dat: jedem Flugzeug + Gen: jedes Flugzeugs +``` + ++ Proceed to verbs: define ``CatGer.V``, ``ResGer.VForm``, and +``ParadigmsGer.regV``. You may choose to exclude ``notpresent`` +cases at this point. But anyway, you will be able to inflect a good +number of verbs in ``Lexicon``, such as +``live_V`` (``regV "leven"``). + ++ Now you can soon form your first sentences: define ``VP`` and +``Cl`` in ``CatGer``, ``VerbGer.UseV``, and ``SentenceGer.PredVP``. +Even if you have excluded the tenses, you will be able to produce +``` + i -preproc=mkPresent LangGer.gf + > l -table PredVP (UsePron i_Pron) (UseV live_V) + + Pres Simul Pos Main: ich lebe + Pres Simul Pos Inv: lebe ich + Pres Simul Pos Sub: ich lebe + Pres Simul Neg Main: ich lebe nicht + Pres Simul Neg Inv: lebe ich nicht + Pres Simul Neg Sub: ich nicht lebe +``` + ++ Transitive verbs (``CatGer.V2 ParadigmsGer.dirV2 VerbGer.ComplV2``) +are a natural next step, so that you can +produce ``ich liebe dich``. + ++ Adjectives (``CatGer.A ParadigmsGer.regA NounGer.AdjCN AdjectiveGer.PositA``) +will force you to think about strong and weak declensions, so that you can +correctly inflect //my new car, this new car//. + ++ Once you have implemented the set +(``Noun.DetCN Noun.AdjCN Verb.UseV Verb.ComplV2 Sentence.PredVP), +you have overcome most of difficulties. You know roughly what parameters +and dependences there are in your language, and you can now produce very +much in the order you please. + + + +===The develop-test cycle=== + +The following develop-test cycle will +be applied most of the time, both in the first steps described above +and in later steps where you are more on your own. + ++ Select a phrase category module, e.g. ``NounGer``, and uncomment some + linearization rules (for instance, ``DefSg``, which is + not too complicated). + ++ Write down some German examples of this rule, for instance translations + of "the dog", "the house", "the big house", etc. Write these in all their + different forms (two numbers and four cases). + ++ Think about the categories involved (``CN, NP, N``) and the + variations they have. Encode this in the lincats of ``CatGer``. + You may have to define some new parameter types in ``ResGer``. + ++ To be able to test the construction, + define some words you need to instantiate it + in ``LexiconGer``. You will also need some regular inflection patterns + in``ParadigmsGer``. + ++ Test by parsing, linearization, + and random generation. In particular, linearization to a table should + be used so that you see all forms produced: +``` + gr -cat=NP -number=20 -tr | l -table +``` + ++ Spare some tree-linearization pairs for later regression testing. Use the + ``tree_bank`` command, +``` + gr -cat=NP -number=20 | tb -xml | wf NP.tb +``` + You can later compared your modified grammar to this treebank by +``` + rf NP.tb | tb -c +``` + + + +You are likely to run this cycle a few times for each linearization rule +you implement, and some hundreds of times altogether. There are 66 ``cat``s and +458 ``funs`` in ``Lang`` at the moment; 149 of the ``funs`` are outside the two +lexicon modules). + +Here is a [live log ../german/log.txt] of the actual process of +building the German implementation of resource API v. 1.0. +It is the basis of the more detailed explanations, which will +follow soon. (You will found out that these explanations involve +a rational reconstruction of the live process! Among other things, the +API was changed during the actual process to make it more intuitive.) + + +===Resource modules used=== + +These modules will be written by you. + +- ``ResGer``: parameter types and auxiliary operations +(a resource for the resource grammar!) +- ``ParadigmsGer``: complete inflection engine and most important regular paradigms +- ``MorphoGer``: auxiliaries for ``ParadigmsGer`` and ``StructuralGer``. This need +not be separate from ``ResGer``. + + +These modules are language-independent and provided by the existing resource +package. + +- ``ParamX``: parameter types used in many languages +- ``CommonX``: implementation of language-uniform categories + such as $Text$ and $Phr$, as well as of + the logical tense, anteriority, and polarity parameters +- ``Coordination``: operations to deal with lists and coordination +- ``Prelude``: general-purpose operations on strings, records, + truth values, etc. +- ``Predefined``: general-purpose operations with hard-coded definitions + + +An important decision is what rules to implement in terms of operations in +``ResGer``. A golden rule of functional programming says that, whenever +you find yourself programming by copy and paste, you should write a function +instead. This indicates that an operation should be created if it is to be +used at least twice. At the same time, a sound principle of vicinity says that +it should not require too much browsing to understand what a rule does. +From these two principles, we have derived the following practice: +- If an operation is needed //in two different modules//, +it should be created in ``ResGer``. An example is ``mkClause``, +used in ``Sentence``, ``Question``, and ``Relative``- +- If an operation is needed //twice in the same module//, but never +outside, it should be created in the same module. Many examples are +found in ``Numerals``. +- If an operation is only needed once, it should not be created (but rather +inlined). Most functions in phrase category modules are implemented in this +way. + + +This discipline is very different from the one followed in earlier +versions of the library (up to 0.9). We then valued the principle of +abstraction more than vicinity, creating layers of abstraction for +almost everything. This led in practice to the duplication of almost +all code on the ``lin`` and ``oper`` levels, and made the code +hard to understand and maintain. + + + +===Morphology and lexicon=== + +The paradigms needed to implement +``LexiconGer`` are defined in +``ParadigmsGer``. +This module provides high-level ways to define the linearization of +lexical items, of categories ``N, A, V`` and their complement-taking +variants. + + + +For ease of use, the ``Paradigms`` modules follow a certain +naming convention. Thus they for each lexical category, such as ``N``, +the functions + +- ``mkN``, for worst-case construction of ``N``. Its type signature + has the form +``` + mkN : Str -> ... -> Str -> P -> ... -> Q -> N +``` + with as many string and parameter arguments as can ever be needed to + construct an ``N``. +- ``regN``, for the most common cases, with just one string argument: +``` + regN : Str -> N +``` +- A language-dependent (small) set of functions to handle mild irregularities + and common exceptions. + +For the complement-taking variants, such as ``V2``, we provide + +- ``mkV2``, which takes a ``V`` and all necessary arguments, such + as case and preposition: +``` + mkV2 : V -> Case -> Str -> V2 ; +``` +- A language-dependent (small) set of functions to handle common special cases, + such as direct transitive verbs: +``` + dirV2 : V -> V2 ; + -- dirV2 v = mkV2 v accusative [] +``` + + +The golden rule for the design of paradigms is that + +- The user will only need function applications with constants and strings, + never any records or tables. + + +The discipline of data abstraction moreover requires that the user of the resource +is not given access to parameter constructors, but only to constants that denote +them. This gives the resource grammarian the freedom to change the underlying +data representation if needed. It means that the ``ParadigmsGer`` module has +to define constants for those parameter types and constructors that +the application grammarian may need to use, e.g. +``` + oper + Case : Type ; + nominative, accusative, genitive, dative : Case ; +``` +These constants are defined in terms of parameter types and constructors +in ``ResGer`` and ``MorphoGer``, which modules are not +visible to the application grammarian. + + +===Lock fields=== + +An important difference between ``MorphoGer`` and +``ParadigmsGer`` is that the former uses "raw" record types +for word classes, whereas the latter used category symbols defined in +``CatGer``. When these category symbols are used to denote +record types in a resource modules, such as ``ParadigmsGer``, +a **lock field** is added to the record, so that categories +with the same implementation are not confused with each other. +(This is inspired by the ``newtype`` discipline in Haskell.) +For instance, the lincats of adverbs and conjunctions are the same +in ``CommonX`` (and therefore in ``CatGer``, which inherits it): +``` + lincat Adv = {s : Str} ; + lincat Conj = {s : Str} ; +``` +But when these category symbols are used to denote their linearization +types in resource module, these definitions are translated to +``` + oper Adv : Type = {s : Str ; lock_Adv : {}} ; + oper Conj : Type = {s : Str} ; lock_Conj : {}} ; +``` +In this way, the user of a resource grammar cannot confuse adverbs with +conjunctions. In other words, the lock fields force the type checker +to function as grammaticality checker. + +When the resource grammar is ``open``ed in an application grammar, the +lock fields are never seen (except possibly in type error messages), +and the application grammarian should never write them herself. If she +has to do this, it is a sign that the resource grammar is incomplete, and +the proper way to proceed is to fix the resource grammar. + +The resource grammarian has to provide the dummy lock field values +in her hidden definitions of constants in ``Paradigms``. For instance, +``` + mkAdv : Str -> Adv ; + -- mkAdv s = {s = s ; lock_Adv = <>} ; +``` + + +===Lexicon construction=== + +The lexicon belonging to ``LangGer`` consists of two modules: + +- ``StructuralGer``, structural words, built by directly using + ``MorphoGer``. +- ``BasicGer``, content words, built by using ``ParadigmsGer``. + + +The reason why ``MorphoGer`` has to be used in ``StructuralGer`` +is that ``ParadigmsGer`` does not contain constructors for closed +word classes such as pronouns and determiners. The reason why we +recommend ``ParadigmsGer`` for building ``LexiconGer`` is that +the coverage of the paradigms gets thereby tested and that the +use of the paradigms in ``LexiconGer`` gives a good set of examples for +those who want to build new lexica. + + + + + + + +==Inside grammar modules== + +Detailed implementation tricks +are found in the comments of each module. + + +===The category system=== + +- [Common gfdoc/Common.html], [CommonX ../common/CommonX.gf] +- [Cat gfdoc/Cat.html], [CatGer gfdoc/CatGer.gf] + + +===Phrase category modules=== + +- [Noun gfdoc/Noun.html], [NounGer ../german/NounGer.gf] +- [Adjective gfdoc/Adjective.html], [AdjectiveGer ../german/AdjectiveGer.gf] +- [Verb gfdoc/Verb.html], [VerbGer ../german/VerbGer.gf] +- [Adverb gfdoc/Adverb.html], [AdverbGer ../german/AdverbGer.gf] +- [Numeral gfdoc/Numeral.html], [NumeralGer ../german/NumeralGer.gf] +- [Sentence gfdoc/Sentence.html], [SentenceGer ../german/SentenceGer.gf] +- [Question gfdoc/Question.html], [QuestionGer ../german/QuestionGer.gf] +- [Relative gfdoc/Relative.html], [RelativeGer ../german/RelativeGer.gf] +- [Conjunction gfdoc/Conjunction.html], [ConjunctionGer ../german/ConjunctionGer.gf] +- [Phrase gfdoc/Phrase.html], [PhraseGer ../german/PhraseGer.gf] +- [Text gfdoc/Text.html], [TextX ../common/TextX.gf] +- [Idiom gfdoc/Idiom.html], [IdiomGer ../german/IdiomGer.gf] +- [Lang gfdoc/Lang.html], [LangGer ../german/LangGer.gf] + + +===Resource modules=== + +- [ResGer ../german/ResGer.gf] +- [MorphoGer ../german/MorphoGer.gf] +- [ParadigmsGer gfdoc/ParadigmsGer.html], [ParadigmsGer.gf ../german/ParadigmsGer.gf] + + +===Lexicon=== + +- [Structural gfdoc/Structural.html], [StructuralGer ../german/StructuralGer.gf] +- [Lexicon gfdoc/Lexicon.html], [LexiconGer ../german/LexiconGer.gf] + + +==Lexicon extension== + +===The irregularity lexicon=== + +It may be handy to provide a separate module of irregular +verbs and other words which are difficult for a lexicographer +to handle. There are usually a limited number of such words - a +few hundred perhaps. Building such a lexicon separately also +makes it less important to cover //everything// by the +worst-case paradigms (``mkV`` etc). + + + +===Lexicon extraction from a word list=== + +You can often find resources such as lists of +irregular verbs on the internet. For instance, the +[Irregular German Verbs http://www.iee.et.tu-dresden.de/~wernerr/grammar/verben_dt.html] +page gives a list of verbs in the +traditional tabular format, which begins as follows: +``` + backen (du bäckst, er bäckt) backte [buk] gebacken + befehlen (du befiehlst, er befiehlt; befiehl!) befahl (beföhle; befähle) befohlen + beginnen begann (begönne; begänne) begonnen + beißen biß gebissen +``` +All you have to do is to write a suitable verb paradigm +``` + irregV : (x1,_,_,_,_,x6 : Str) -> V ; +``` +and a Perl or Python or Haskell script that transforms +the table to +``` + backen_V = irregV "backen" "bäckt" "back" "backte" "backte" "gebacken" ; + befehlen_V = irregV "befehlen" "befiehlt" "befiehl" "befahl" "beföhle" "befohlen" ; +``` + +When using ready-made word lists, you should think about +coyright issues. Ideally, all resource grammar material should +be provided under GNU General Public License. + + + +===Lexicon extraction from raw text data=== + +This is a cheap technique to build a lexicon of thousands +of words, if text data is available in digital format. +See the [Functional Morphology http://www.cs.chalmers.se/~markus/FM/] +homepage for details. + + + +===Extending the resource grammar API=== + +Sooner or later it will happen that the resource grammar API +does not suffice for all applications. A common reason is +that it does not include idiomatic expressions in a given language. +The solution then is in the first place to build language-specific +extension modules. This chapter will deal with this issue (to be completed). + + +==Writing an instance of parametrized resource grammar implementation== + +Above we have looked at how a resource implementation is built by +the copy and paste method (from English to German), that is, formally +speaking, from scratch. A more elegant solution available for +families of languages such as Romance and Scandinavian is to +use parametrized modules. The advantages are + +- theoretical: linguistic generalizations and insights +- practical: maintainability improves with fewer components + + +In this chapter, we will look at an example: adding Italian to +the Romance family (to be completed). Here is a set of +[slides http://www.cs.chalmers.se/~aarne/geocal2006.pdf] +on the topic. + + +==Parametrizing a resource grammar implementation== + +This is the most demanding form of resource grammar writing. +We do //not// recommend the method of parametrizing from the +beginning: it is easier to have one language first implemented +in the conventional way and then add another language of the +same family by aprametrization. This means that the copy and +paste method is still used, but at this time the differences +are put into an ``interface`` module. + + + +This chapter will work out an example of how an Estonian grammar +is constructed from the Finnish grammar through parametrization. + + diff --git a/next-lib/doc/Syntax.dot b/next-lib/doc/Syntax.dot new file mode 100644 index 000000000..a7081660e --- /dev/null +++ b/next-lib/doc/Syntax.dot @@ -0,0 +1,111 @@ +digraph { + +size = "12,8" ; + +German [style = "solid", shape = "ellipse"]; +ExtraGer [style = "solid", shape = "ellipse"]; +IrregGer [style = "solid", shape = "ellipse"]; + +German -> IrregGer [style = "solid"]; +German -> ExtraGer [style = "solid"]; +German -> LangGer [style = "solid"]; +IrregGer -> ParadigmsGer [style = "solid"]; +ExtraGer -> Grammar [style = "solid"]; + +TryGer [style = "solid", shape = "rectangle"]; + +LangGer [style = "solid", shape = "ellipse"]; + +TryGer -> SyntaxGer [style = "solid"]; + +TryGer -> ParadigmsGer [style = "solid"]; + +TryGer -> Lexicon [style = "solid"]; + +LangGer -> Grammar [style = "solid"]; +LangGer -> Lexicon [style = "solid"]; + +Lexicon [style = "dashed", shape = "ellipse", URL = "Lang.gf"]; + +SyntaxGer [style = "solid", shape = "rectangle"]; + +SyntaxGer -> Syntax [style = "solid"]; + +ParadigmsGer [style = "solid", shape = "rectangle"]; + +Syntax [style = "solid", shape = "diamond"]; + +Syntax -> Grammar [style = "solid"]; +Syntax -> Constructors [style = "solid"]; +ParadigmsGer -> Grammar [style = "solid"]; + +Constructors [style = "dashed", shape = "ellipse", URL = "Lang.gf"]; + +Constructors -> Grammar [style = "solid"]; + +Grammar [style = "dashed", shape = "ellipse", URL = "Lang.gf"]; + + +Grammar -> Noun [style = "solid"]; +Grammar -> Verb [style = "solid"]; +Grammar -> Adjective [style = "solid"]; +Grammar -> Adverb [style = "solid"]; +Grammar -> Numeral [style = "solid"]; +Grammar -> Sentence [style = "solid"]; +Grammar -> Question [style = "solid"]; +Grammar -> Relative [style = "solid"]; +Grammar -> Conjunction [style = "solid"]; +Grammar -> Phrase [style = "solid"]; +Grammar -> Text [style = "solid"]; +Grammar -> Idiom [style = "solid"]; +Grammar -> Structural [style = "solid"]; + + +Noun [style = "dashed", shape = "ellipse", URL = "Noun.gf"]; +Noun -> Cat [style = "solid"]; + +Verb [style = "dashed", shape = "ellipse", URL = "Verb.gf"]; +Verb -> Cat [style = "solid"]; + +Adjective [style = "dashed", shape = "ellipse", URL = "Adjective.gf"]; +Adjective -> Cat [style = "solid"]; + +Adverb [style = "dashed", shape = "ellipse", URL = "Adverb.gf"]; +Adverb -> Cat [style = "solid"]; + +Numeral [style = "dashed", shape = "ellipse", URL = "Numeral.gf"]; +Numeral -> Cat [style = "solid"]; + +Sentence [style = "dashed", shape = "ellipse", URL = "Sentence.gf"]; +Sentence -> Cat [style = "solid"]; + +Question [style = "dashed", shape = "ellipse", URL = "Question.gf"]; +Question -> Cat [style = "solid"]; + +Relative [style = "dashed", shape = "ellipse", URL = "Relative.gf"]; +Relative -> Cat [style = "solid"]; + +Conjunction [style = "dashed", shape = "ellipse", URL = "Conjunction.gf"]; +Conjunction -> Cat [style = "solid"]; + +Phrase [style = "dashed", shape = "ellipse", URL = "Phrase.gf"]; +Phrase -> Cat [style = "solid"]; + +Text [style = "dashed", shape = "ellipse", URL = "Phrase.gf"]; +Text -> Cat [style = "solid"]; + +Idiom [style = "dashed", shape = "ellipse", URL = "Phrase.gf"]; +Idiom -> Cat [style = "solid"]; + +Structural [style = "dashed", shape = "ellipse", URL = "Structural.gf"]; +Structural -> Cat [style = "solid"]; + +#Lexicon [style = "dashed", shape = "ellipse", URL = "Lexicon.gf"]; +#Lexicon -> Cat [style = "solid"]; + +Cat [style = "dashed", shape = "ellipse", URL = "Cat.gf"]; +Cat -> Common [style = "solid"]; + +Common [style = "dashed", shape = "ellipse", URL = "Tense.gf"]; + +} diff --git a/next-lib/doc/Syntax.png b/next-lib/doc/Syntax.png new file mode 100644 index 000000000..1cc8161b1 Binary files /dev/null and b/next-lib/doc/Syntax.png differ diff --git a/next-lib/doc/categories-imagemap.html b/next-lib/doc/categories-imagemap.html new file mode 100644 index 000000000..31f01eef5 --- /dev/null +++ b/next-lib/doc/categories-imagemap.html @@ -0,0 +1,53 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/next-lib/doc/categories-intro.txt b/next-lib/doc/categories-intro.txt new file mode 100644 index 000000000..f5498fcfe --- /dev/null +++ b/next-lib/doc/categories-intro.txt @@ -0,0 +1,19 @@ + + +The chart below shows the categories in a hierarchical top-down order. +The edges do not define the complete dependency structure; if they did, +the graph would have many many more edges, and also many cycles. The precise +meaning of a directed edge from //C// to //D// is: there is a constructor +of //C// that takes //D// as an argument. What the constructors exactly are, +and what other arguments they take, is described by separate tables for +each category. + + | [categories.png] | + +%!include(html): ''categories-imagemap.html'' + + +The rectangular boxes mark open lexical categories, which have constructors +also in the ``Paradigms`` modules. + + diff --git a/next-lib/doc/categories.dot b/next-lib/doc/categories.dot new file mode 100644 index 000000000..69cf67e74 --- /dev/null +++ b/next-lib/doc/categories.dot @@ -0,0 +1,149 @@ + +digraph categories { + +size = "11,11" ; +node [href="#\N"]; + +Text [style = "solid", shape = "ellipse"]; +Text -> Punct [style = "solid"]; +Text -> Phr [style = "solid"]; + +Punct [style = "solid", shape = "ellipse"]; + +Phr [style = "solid", shape = "ellipse"]; +Phr -> PConj [style = "solid"]; +Phr -> Utt [style = "solid"]; +Phr -> Voc [style = "solid"]; + +PConj [style = "solid", shape = "ellipse"]; +Voc [style = "solid", shape = "ellipse"]; + +Utt [style = "solid", shape = "ellipse"]; +Utt -> Imp [style = "solid"]; +Utt -> S [style = "solid"]; +Utt -> QS [style = "solid"]; + +Imp [style = "solid", shape = "ellipse"]; + +S [style = "solid", shape = "ellipse"]; +S -> Tense [style = "solid"]; +S -> Ant [style = "solid"]; +S -> Pol [style = "solid"]; +S -> Cl [style = "solid"]; +S -> ListS [style = "solid"]; +S -> Conjs [style = "solid"]; + +Conjs [label = "Conj", href="#Conj", style = "solid", shape = "ellipse"]; + +Tense [style = "solid", shape = "ellipse"]; +Ant [style = "solid", shape = "ellipse"]; +Pol [style = "solid", shape = "ellipse"]; + +Cl [style = "solid", shape = "ellipse"]; +Cl -> NP [style = "solid"]; +Cl -> VP [style = "solid"]; +Cl -> Adv [style = "solid"]; + +Adv [style = "solid", shape = "rectangle"]; +Adv -> Subj [style = "solid"]; +Adv -> ListAdj [style = "solid"]; + + +NP [style = "solid", shape = "ellipse"]; +NP -> Predet [style = "solid"]; +NP -> Pron [style = "solid"]; +NP -> PN [style = "solid"]; +NP -> Det [style = "solid"]; +NP -> CN [style = "solid"]; +NP -> ListNP [style = "solid"]; + +Predet [style = "solid", shape = "ellipse"]; + +Pron [style = "solid", shape = "ellipse"]; +PN [style = "solid", shape = "rectangle"]; + +Det [style = "solid", shape = "ellipse"]; +Det -> Art [style = "solid"]; +Det -> Quant [style = "solid"]; +Det -> Num [style = "solid"]; +Det -> Ord [style = "solid"]; + + +Art [label = "Art", style = "solid", shape = "ellipse"]; +Quant [label = "Quant", style = "solid", shape = "ellipse"]; + + +Num [style = "solid", shape = "ellipse"]; +Num -> Card [style = "solid"]; + +Card [style = "solid", shape = "ellipse"]; +Card -> Numerals [style = "solid"]; +Card -> AdN [style = "solid"]; + +AdN [style = "solid", shape = "ellipse"]; +AdN -> CAdv [style = "solid"]; + +Numerals [label = "Numeral,Digits", href="#Numeral", style = "solid", shape = "ellipse"]; + + +Ord [style = "solid", shape = "ellipse"]; + +CN [style = "solid", shape = "ellipse"]; +CN -> Ns [style = "solid"]; +CN -> RS [style = "solid"]; + +Ns [label = "N,N2,N3", href="#N", style = "solid", shape = "rectangle"]; + + +VP [style = "solid", shape = "ellipse"]; +VP -> AdV [style = "solid"]; +VP -> Vs [style = "solid"]; +VP -> AP [style = "solid"]; + +AdV [style = "solid", shape = "ellipse"]; + +Vs [label = "V,V2,V3,V*,V2*", href="#V", style = "solid", shape = "rectangle"]; + +AP [style = "solid", shape = "ellipse"]; +AP -> AdA [style = "solid"]; +AP -> As [style = "solid"]; +AP -> ListAP [style = "solid"]; + +As [label = "A, A2", href="#A", style = "solid", shape = "rectangle"]; + + + + +QS [style = "solid", shape = "ellipse"]; +QS -> QCl [style = "solid"]; + +QCl [style = "solid", shape = "ellipse"]; +QCl -> IP [style = "solid"]; +QCl -> IAdv [style = "solid"]; +QCl -> ClSlash [style = "solid"]; + +IP [style = "solid", shape = "ellipse"]; +IP -> IDet [style = "solid"]; + +IDet [style = "solid", shape = "ellipse"]; +IDet -> IQuant [style = "solid"]; + +IQuant [style = "solid", shape = "ellipse"]; + +IAdv [style = "solid", shape = "ellipse"]; + +ClSlash [style = "solid", shape = "ellipse"]; +ClSlash -> VPSlash [style = "solid"]; + +VPSlash [style = "solid", shape = "ellipse"]; + +RS [style = "solid", shape = "ellipse"]; +RS -> RCl [style = "solid"]; + +RCl [style = "solid", shape = "ellipse"]; +RCl -> RP [style = "solid"]; + +RP [style = "solid", shape = "ellipse"]; + + +} diff --git a/next-lib/doc/categories.png b/next-lib/doc/categories.png new file mode 100644 index 000000000..590540fc5 Binary files /dev/null and b/next-lib/doc/categories.png differ diff --git a/next-lib/doc/editor.png b/next-lib/doc/editor.png new file mode 100644 index 000000000..63a3161bf Binary files /dev/null and b/next-lib/doc/editor.png differ diff --git a/next-lib/doc/index.txt b/next-lib/doc/index.txt new file mode 100644 index 000000000..86d1f3d0c --- /dev/null +++ b/next-lib/doc/index.txt @@ -0,0 +1,267 @@ +GF Resource Grammar Library v. 1.2 +Author: Aarne Ranta +Last update: %%date(%c) + +% NOTE: this is a txt2tags file. +% Create an html file from this file using: +% txt2tags --toc -thtml index.txt + +%!target:html + +%!postproc(html): #BCEN
+%!postproc(html): #ECEN
+ + +#BCEN + +[10lang-large.png] + +#ECEN + + +The GF Resource Grammar Library defines the basic grammar of +ten languages: +Danish, English, Finnish, French, German, +Italian, Norwegian, Russian, Spanish, Swedish. +Still incomplete implementations for Arabic and Catalan are also +included. + +**New** in December 2007: Browsing the library by syntax editor +[directly on the web ../../../demos/resource-api/editor.html]. + + + + +==Authors== + +Inger Andersson and Therese Soderberg (Spanish morphology), +Nicolas Barth and Sylvain Pogodalla (French verb list), +Ali El Dada (Arabic modules), +Magda Gerritsen and Ulrich Real (Russian paradigms and lexicon), +Janna Khegai (Russian modules), +Bjorn Bringert (many Swadesh lexica), +Carlos Gonzalía (Spanish cardinals), +Harald Hammarström (German morphology), +Patrik Jansson (Swedish cardinals), +Andreas Priesnitz (German lexicon), +Aarne Ranta, +Jordi Saludes (Catalan modules), +Henning Thielemann (German lexicon). + + +We are grateful for contributions and +comments to several other people who have used this and +the previous versions of the resource library, including +Ludmilla Bogavac, +Ana Bove, +David Burke, +Lauri Carlson, +Gloria Casanellas, +Karin Cavallin, +Robin Cooper, +Hans-Joachim Daniels, +Elisabet Engdahl, +Markus Forsberg, +Kristofer Johannisson, +Anni Laine, +Hans Leiß, +Peter Ljunglöf, +Saara Myllyntausta, +Wanjiku Ng'ang'a, +Nadine Perera, +Jordi Saludes. + + +==License== + +The GF Resource Grammar Library is open-source software licensed under +GNU Lesser General Public License (LGPL). See the file [LICENSE ../LICENSE] for more +details. + + +==Scope== + +Coverage, for each language: +- complete morphology +- lexicon of the ca. 100 most important structural words +- test lexicon of ca. 300 content words (rough equivalents in each language) +- list of irregular verbs (separately for each language) +- representative fragment of syntax (cf. CLE (Core Language Engine)) +- rather flat semantics (cf. Quasi-Logical Form of CLE) + + +Organization: +- top-level (API) modules +- Ground API + special-purpose APIs +- "school grammar" concepts rather than advanced linguistic theory + + +Presentation: +- tool ``gfdoc`` for generating HTML from grammars +- example collections + + +==Location== + +Assuming you have installed the libraries, you will find the precompiled +``gfc`` and ``gfr`` files directly under ``$GF_LIB_PATH``, whose default +value is ``/usr/local/share/GF/``. The precompiled subdirectories are +``` + alltenses + mathematical + multimodal + present +``` +Do for instance +``` + cd $GF_LIB_PATH + gf alltenses/langs.gfcm + + > p -cat=S -lang=LangEng "this grammar is too big" | tb +``` +For more details, see the [Synopsis synopsis.html]. + + +==Compilation== + +If you want to compile the library from scratch, use ``make`` in the root of +the source directory: +``` + cd GF/lib/resource-1.0 + make +``` +The ``make`` procedure does not by default make Arabic and Catalan, but you +can uncomment the relevant lines in ``Makefile`` to compile them. + + +==Encoding== + +Finnish, German, Romance, and Scandinavian languages are in isolatin-1. + +Arabic and Russian are in UTF-8. + +English is in pure ASCII. + +The different encodings imply, unfortunately, that it is hard to get +a nice view of all languages simultaneously. The easiest way to achieve this is +to use ``gfeditor``, which automatically converts grammars to UTF-8. + + +==Using the resource as library== + +This API is accessible by both ``present`` and ``alltenses``. The modules you most often need are +- ``Syntax``, the interface to syntactic structures +- ``Syntax``//L//, the implementations of ``Syntax`` for each language //L// +- ``Paradigms``//L//, the morphological paradigms for each language //L// + + +The [Synopsis synopsis.html] gives examples on the typical usage of these +modules. + + +==Using the resource as top level grammar== + +The following modules can be used for parsing and linearization. They are accessible from both +``present`` and ``alltenses``. +- ``Lang``//L// for each language //L//, implementing a common abstract syntax ``Lang`` +- ``Danish``, ``English``, etc, implementing ``Lang`` with language-specific extensions + + +In addition, there is in both ``present`` and ``alltenses`` the file +- ``langs.gfcm``, a package with precompiled ``Lang``//L// grammars + + +A way to test and view the resource grammar is to load ``langs.gfcm`` either into ``gfeditor`` +or into the ``gf`` shell and perform actions such as syntax editing and treebank generation. +For instance, the command +``` + > p -lang=LangEng -cat=S "this grammar is too big" | tb +``` +creates a treebank entry with translations of this sentence. + +For parsing, currently only English and the Scandinavian languages are within the limits ofr +reasonable resources. For other languages //L//, parsing with ``Lang``//L// will probably eat +up the computer resources before finishing the parser generation. + + + +==Accessing the lower level ground API== + +The ``Syntax`` API is implemented in terms a bunch of ``abstract`` modules, which +as of version 1.2 are mainly interesting for implementors of the resource. +See the [documentation for version 1.1 index-1.1.html] for more details. + + +==Known bugs and missing components== + +Danish +- the lexicon and chosen inflections are only partially verified + + +English + + +Finnish +- wrong cases in some passive constructions + + +French +- multiple clitics (with V3) not always right +- third person pronominal questions with inverted word order + have wrong forms if "t" is required e.g. + (e.g. "comment fera-t-il" becomes "comment fera il") + + +German + + +Italian +- multiple clitics (with V3) not always right + + +Norwegian +- the lexicon and chosen inflections are only partially verified + + +Russian +- some functions missing +- some regular paradigms are missing + + +Spanish +- multiple clitics (with V3) not always right +- missing contractions with imperatives and clitics + + +Swedish + + + + +==More reading== + +[Synopsis synopsis.html]. The concise guide to API v. 1.2. + +[Grammars as Software Libraries gslt-sem-2006.html]. Slides +with background and motivation for the resource grammar library. + +[GF Resource Grammar Library Version 1.0 clt2006.html]. Slides +giving an overview of the library and practical hints on its use. + +[How to write resource grammars Resource-HOWTO.html]. Helps you +start if you want to add another language to the library. + +[Parametrized modules for Romance languages http://www.cs.chalmers.se/~aarne/geocal2006.pdf]. +Slides explaining some ideas in the implementation of +French, Italian, and Spanish. + +[Grammar writing by examples http://www.cs.chalmers.se/~aarne/slides/webalt-2005.pdf]. +Slides showing how linearization rules are written as strings parsable by the resource grammar. + +[Multimodal Resource Grammars http://www.cs.chalmers.se/~aarne/slides/talk-edin2005.pdf]. +Slides showing how to use the multimodal resource library. N.B. the library +examples are from ``multimodal/old``, which is a reduced-size API. + +[GF Resource Grammar Library ../../../doc/resource.pdf] (pdf). +Printable user manual with API documentation, for version 1.0. + diff --git a/next-lib/doc/official.txt b/next-lib/doc/official.txt new file mode 100644 index 000000000..1216226e2 --- /dev/null +++ b/next-lib/doc/official.txt @@ -0,0 +1,581 @@ +The Official EU languages + +The 20 official languages of the EU and their abbreviations are as follows: + +Español ES Spanish +Dansk DA Danish +Deutsch DE German +Elinika EL Greek +English EN +Français FR French +Italiano IT Italian +Nederlands NL Dutch +Português PT Portuguese +Suomi FI Finnish +Svenska SV Swedish +?e?tina CS Czech +Eesti ET Estonian +Latviesu valoda LV Latvian +Lietuviu kalba LT Lithuanian +Magyar HU Hungarian +Malti MT Maltese +Polski PL Polish +Sloven?ina SK Slovak +Sloven??ina SL Slovene + +http://europa.eu.int/comm/education/policies/lang/languages/index_en.html + +----- +http://www.w3.org/WAI/ER/IG/ert/iso639.htm + +ar arabic +no norwegian +ru russian + +-- + +ISO 639: 3-letter codes + +abk ab Abkhazian +ace Achinese +ach Acoli +ada Adangme +aar aa Afar +afh Afrihili +afr af Afrikaans +afa Afro-Asiatic (Other) +aka Akan +akk Akkadian +alb/sqi sq Albanian +ale Aleut +alg Algonquian languages +tut Altaic (Other) +amh am Amharic +apa Apache languages +ara ar Arabic +arc Aramaic +arp Arapaho +arn Araucanian +arw Arawak +arm/hye hy Armenian +art Artificial (Other) +asm as Assamese +ath Athapascan languages +map Austronesian (Other) +ava Avaric +ave Avestan +awa Awadhi +aym ay Aymara +aze az Azerbaijani +nah Aztec +ban Balinese +bat Baltic (Other) +bal Baluchi +bam Bambara +bai Bamileke languages +bad Banda +bnt Bantu (Other) +bas Basa +bak ba Bashkir +baq/eus eu Basque +bej Beja +bem Bemba +ben bn Bengali +ber Berber (Other) +bho Bhojpuri +bih bh Bihari +bik Bikol +bin Bini +bis bi Bislama +bra Braj +bre be Breton +bug Buginese +bul bg Bulgarian +bua Buriat +bur/mya my Burmese +bel be Byelorussian +cad Caddo +car Carib +cat ca Catalan +cau Caucasian (Other) +ceb Cebuano +cel Celtic (Other) +cai Central American Indian (Other) +chg Chagatai +cha Chamorro +che Chechen +chr Cherokee +chy Cheyenne +chb Chibcha +chi/zho zh Chinese +chn Chinook jargon +cho Choctaw +chu Church Slavic +chv Chuvash +cop Coptic +cor Cornish +cos co Corsican +cre Cree +mus Creek +crp Creoles and Pidgins (Other) +cpe Creoles and Pidgins, English-based (Other) +cpf Creoles and Pidgins, French-based (Other) +cpp Creoles and Pidgins, Portuguese-based (Other) +cus Cushitic (Other) + hr Croatian +ces/cze cs Czech +dak Dakota +dan da Danish +del Delaware +din Dinka +div Divehi +doi Dogri +dra Dravidian (Other) +dua Duala +dut/nla nl Dutch +dum Dutch, Middle (ca. 1050-1350) +dyu Dyula +dzo dz Dzongkha +efi Efik +egy Egyptian (Ancient) +eka Ekajuk +elx Elamite +eng en English +enm English, Middle (ca. 1100-1500) +ang English, Old (ca. 450-1100) +esk Eskimo (Other) +epo eo Esperanto +est et Estonian +ewe Ewe +ewo Ewondo +fan Fang +fat Fanti +fao fo Faroese +fij fj Fijian +fin fi Finnish +fiu Finno-Ugrian (Other) +fon Fon +fra/fre fr French +frm French, Middle (ca. 1400-1600) +fro French, Old (842- ca. 1400) +fry fy Frisian +ful Fulah +gaa Ga +gae/gdh Gaelic (Scots) +glg gl Gallegan +lug Ganda +gay Gayo +gez Geez +geo/kat ka Georgian +deu/ger de German +gmh German, Middle High (ca. 1050-1500) +goh German, Old High (ca. 750-1050) +gem Germanic (Other) +gil Gilbertese +gon Gondi +got Gothic +grb Grebo +grc Greek, Ancient (to 1453) +ell/gre el Greek, Modern (1453-) +kal kl Greenlandic +grn gn Guarani +guj gu Gujarati +hai Haida +hau ha Hausa +haw Hawaiian +heb he Hebrew +her Herero +hil Hiligaynon +him Himachali +hin hi Hindi +hmo Hiri Motu +hun hu Hungarian +hup Hupa +iba Iban +ice/isl is Icelandic +ibo Igbo +ijo Ijo +ilo Iloko +inc Indic (Other) +ine Indo-European (Other) +ind id Indonesian +ina ia Interlingua (International Auxiliary language Association) +ine - Interlingue +iku iu Inuktitut +ipk ik Inupiak +ira Iranian (Other) +gai/iri ga Irish +sga Irish, Old (to 900) +mga Irish, Middle (900 - 1200) +iro Iroquoian languages +ita it Italian +jpn ja Japanese +jav/jaw jv/jw Javanese +jrb Judeo-Arabic +jpr Judeo-Persian +kab Kabyle +kac Kachin +kam Kamba +kan kn Kannada +kau Kanuri +kaa Kara-Kalpak +kar Karen +kas ks Kashmiri +kaw Kawi +kaz kk Kazakh +kha Khasi +khm km Khmer +khi Khoisan (Other) +kho Khotanese +kik Kikuyu +kin rw Kinyarwanda +kir ky Kirghiz +kom Komi +kon Kongo +kok Konkani +kor ko Korean +kpe Kpelle +kro Kru +kua Kuanyama +kum Kumyk +kur ku Kurdish +kru Kurukh +kus Kusaie +kut Kutenai +lad Ladino +lah Lahnda +lam Lamba +oci oc Langue d'Oc (post 1500) +lao lo Lao +lat la Latin +lav lv Latvian +ltz Letzeburgesch +lez Lezghian +lin ln Lingala +lit lt Lithuanian +loz Lozi +lub Luba-Katanga +lui Luiseno +lun Lunda +luo Luo (Kenya and Tanzania) +mac/mak mk Macedonian +mad Madurese +mag Magahi +mai Maithili +mak Makasar +mlg mg Malagasy +may/msa ms Malay +mal Malayalam +mlt ml Maltese +man Mandingo +mni Manipuri +mno Manobo languages +max Manx +mao/mri mi Maori +mar mr Marathi +chm Mari +mah Marshall +mwr Marwari +mas Masai +myn Mayan languages +men Mende +mic Micmac +min Minangkabau +mis Miscellaneous (Other) +moh Mohawk +mol mo Moldavian +mkh Mon-Kmer (Other) +lol Mongo +mon mn Mongolian +mos Mossi +mul Multiple languages +mun Munda languages +nau na Nauru +nav Navajo +nde Ndebele, North +nbl Ndebele, South +ndo Ndongo +nep ne Nepali +new Newari +nic Niger-Kordofanian (Other) +ssa Nilo-Saharan (Other) +niu Niuean +non Norse, Old +nai North American Indian (Other) +nor no Norwegian +nno Norwegian (Nynorsk) +nub Nubian languages +nym Nyamwezi +nya Nyanja +nyn Nyankole +nyo Nyoro +nzi Nzima +oji Ojibwa +ori or Oriya +orm om Oromo +osa Osage +oss Ossetic +oto Otomian languages +pal Pahlavi +pau Palauan +pli Pali +pam Pampanga +pag Pangasinan +pan pa Panjabi +pap Papiamento +paa Papuan-Australian (Other) +fas/per fa Persian +peo Persian, Old (ca 600 - 400 B.C.) +phn Phoenician +pol pl Polish +pon Ponape +por pt Portuguese +pra Prakrit languages +pro Provencal, Old (to 1500) +pus ps Pushto +que qu Quechua +roh rm Rhaeto-Romance +raj Rajasthani +rar Rarotongan +roa Romance (Other) +ron/rum ro Romanian +rom Romany +run rn Rundi +rus ru Russian +sal Salishan languages +sam Samaritan Aramaic +smi Sami languages +smo sm Samoan +sad Sandawe +sag sg Sango +san sa Sanskrit +srd Sardinian +sco Scots +sel Selkup +sem Semitic (Other) + sr Serbian +scr sh Serbo-Croatian +srr Serer +shn Shan +sna sn Shona +sid Sidamo +bla Siksika +snd sd Sindhi +sin si Singhalese +sit - Sino-Tibetan (Other) +sio Siouan languages +sla Slavic (Other) +ssw ss Siswant +slk/slo sk Slovak +slv sl Slovenian +sog Sogdian +som so Somali +son Songhai +wen Sorbian languages +nso Sotho, Northern +sot st Sotho, Southern +sai South American Indian (Other) +esl/spa es Spanish +suk Sukuma +sux Sumerian +sun su Sudanese +sus Susu +swa sw Swahili +ssw Swazi +sve/swe sv Swedish +syr Syriac +tgl tl Tagalog +tah Tahitian +tgk tg Tajik +tmh Tamashek +tam ta Tamil +tat tt Tatar +tel te Telugu +ter Tereno +tha th Thai +bod/tib bo Tibetan +tig Tigre +tir ti Tigrinya +tem Timne +tiv Tivi +tli Tlingit +tog to Tonga (Nyasa) +ton Tonga (Tonga Islands) +tru Truk +tsi Tsimshian +tso ts Tsonga +tsn tn Tswana +tum Tumbuka +tur tr Turkish +ota Turkish, Ottoman (1500 - 1928) +tuk tk Turkmen +tyv Tuvinian +twi tw Twi +uga Ugaritic +uig ug Uighur +ukr uk Ukrainian +umb Umbundu +und Undetermined +urd ur Urdu +uzb uz Uzbek +vai Vai +ven Venda +vie vi Vietnamese +vol vo Volapük +vot Votic +wak Wakashan languages +wal Walamo +war Waray +was Washo +cym/wel cy Welsh +wol wo Wolof +xho xh Xhosa +sah Yakut +yao Yao +yap Yap +yid yi Yiddish +yor yo Yoruba +zap Zapotec +zen Zenaga +zha za Zhuang +zul zu Zulu +zun Zuni + +ISO 639: 2-letter codes + +AA "Afar" +AB "Abkhazian" +AF "Afrikaans" +AM "Amharic" +AR "Arabic" +AS "Assamese" +AY "Aymara" +AZ "Azerbaijani" +BA "Bashkir" +BE "Byelorussian" +BG "Bulgarian" +BH "Bihari" +BI "Bislama" +BN "Bengali" "Bangla" +BO "Tibetan" +BR "Breton" +CA "Catalan" +CO "Corsican" +CS "Czech" +CY "Welsh" +DA "Danish" +DE "German" +DZ "Bhutani" +EL "Greek" +EN "English" "American" +EO "Esperanto" +ES "Spanish" +ET "Estonian" +EU "Basque" +FA "Persian" +FI "Finnish" +FJ "Fiji" +FO "Faeroese" +FR "French" +FY "Frisian" +GA "Irish" +GD "Gaelic" "Scots Gaelic" +GL "Galician" +GN "Guarani" +GU "Gujarati" +HA "Hausa" +HI "Hindi" +HR "Croatian" +HU "Hungarian" +HY "Armenian" +IA "Interlingua" +IE "Interlingue" +IK "Inupiak" +IN "Indonesian" +IS "Icelandic" +IT "Italian" +IW "Hebrew" +JA "Japanese" +JI "Yiddish" +JW "Javanese" +KA "Georgian" +KK "Kazakh" +KL "Greenlandic" +KM "Cambodian" +KN "Kannada" +KO "Korean" +KS "Kashmiri" +KU "Kurdish" +KY "Kirghiz" +LA "Latin" +LN "Lingala" +LO "Laothian" +LT "Lithuanian" +LV "Latvian" "Lettish" +MG "Malagasy" +MI "Maori" +MK "Macedonian" +ML "Malayalam" +MN "Mongolian" +MO "Moldavian" +MR "Marathi" +MS "Malay" +MT "Maltese" +MY "Burmese" +NA "Nauru" +NE "Nepali" +NL "Dutch" +NO "Norwegian" +OC "Occitan" +OM "Oromo" "Afan" +OR "Oriya" +PA "Punjabi" +PL "Polish" +PS "Pashto" "Pushto" +PT "Portuguese" +QU "Quechua" +RM "Rhaeto-Romance" +RN "Kirundi" +RO "Romanian" +RU "Russian" +RW "Kinyarwanda" +SA "Sanskrit" +SD "Sindhi" +SG "Sangro" +SH "Serbo-Croatian" +SI "Singhalese" +SK "Slovak" +SL "Slovenian" +SM "Samoan" +SN "Shona" +SO "Somali" +SQ "Albanian" +SR "Serbian" +SS "Siswati" +ST "Sesotho" +SU "Sudanese" +SV "Swedish" +SW "Swahili" +TA "Tamil" +TE "Tegulu" +TG "Tajik" +TH "Thai" +TI "Tigrinya" +TK "Turkmen" +TL "Tagalog" +TN "Setswana" +TO "Tonga" +TR "Turkish" +TS "Tsonga" +TT "Tatar" +TW "Twi" +UK "Ukrainian" +UR "Urdu" +UZ "Uzbek" +VI "Vietnamese" +VO "Volapuk" +WO "Wolof" +XH "Xhosa" +YO "Yoruba" +ZH "Chinese" +ZU "Zulu" diff --git a/next-lib/doc/paradigms.txt b/next-lib/doc/paradigms.txt new file mode 100644 index 000000000..0c4cf260c --- /dev/null +++ b/next-lib/doc/paradigms.txt @@ -0,0 +1,48 @@ +Morphological Paradigms in the GF Resource Grammar Library +Aarne Ranta + + +This is a synopsis of the main morphological paradigms for +nouns (``N``), adjectives (``A``), and verbs (``V``). + + +=English= + +``` + mkN : (flash : Str) -> N ; -- car, bus, ax, hero, fly, boy + mkN : (man,men : Str) -> N ; -- index, indices + mkN : (man,men,man's,men's : Str) -> N ; + mkN : Str -> N -> N ; -- baby boom + + mkA : (happy : Str) -> A ; -- small, happy, free + mkA : (fat,fatter : Str) -> A ; + mkA : (good,better,best,well : Str) -> A + compoundA : A -> A ; -- -/more/most ridiculous + + mkV : (cry : Str) -> V ; -- call, kiss, echo, cry, pray + 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 +``` + +=French= + +``` + mkN : (cheval : Str) -> N ; -- pas, prix, nez, bijou, cheval + mkN : (foie : Str) -> Gender -> N ; + mkN : (oeil,yeux : Str) -> Gender -> N ; + mkN : N -> Str -> N + + mkA : (cher : Str) -> A ; -- banal, heureux, italien, jeune, amer, carré, joli + mkA : (sec,seche : Str) -> A ; + mkA : (banal,banale,banaux,banalement : Str) -> A ; + mkA : (bon : A) -> (meilleur : A) -> A + prefixA : A -> A ; + + mkV : (finir : Str) -> V ; -- aimer, céder, placer, manger, payer, finir + mkV : (jeter,jette,jettera : Str) -> V ; + mkV : V2 -> V + etreV : V -> V ; + reflV : V -> V ; +``` diff --git a/next-lib/doc/synopsis-browse.txt b/next-lib/doc/synopsis-browse.txt new file mode 100644 index 000000000..4d26fc600 --- /dev/null +++ b/next-lib/doc/synopsis-browse.txt @@ -0,0 +1,34 @@ + + + + +=Browsing the libraries with GF commands= + +**New**: Browsing by syntax editor +[directly on the web ../../../demos/resource-api/editor.html]. + +All of the following assume +``` + cd $GF_LIB_PATH +``` +To try out inflection paradigms: +``` + > i -path=alltenses -retain alltenses/ParadigmsGer.gfo + > cc mkN "Farbe" +``` +To try out overloaded syntax, test lexicon, and inflection paradigms: +``` + > i -path=alltenses -retain alltenses/TryGer.gfo + > cc mkCl (mkNP this_Quant (mkN "Farbe")) (mkA "dunkel") +``` +% To look for a syntax tree in the overload API by parsing: +% ``` +% > i -path=alltenses alltenses/OverLangEng.gf +% > p -cat=S -overload "this grammar is too big" +% ``` +% To view linearizations in all languages by parsing from English: +% ``` +% > i alltenses/langs.gfcm +% > p -cat=S -lang=LangEng "this grammar is too big" | tb +% ``` + diff --git a/next-lib/doc/synopsis-example.txt b/next-lib/doc/synopsis-example.txt new file mode 100644 index 000000000..8c992339e --- /dev/null +++ b/next-lib/doc/synopsis-example.txt @@ -0,0 +1,51 @@ + +The standard way of building an application has the following modules. + +An abstract syntax: +``` + abstract Music = { + cat + Kind, + Property ; + fun + PropKind : Kind -> Property -> Kind ; + Song : Kind ; + American : Property ; + } +``` +A domain lexicon interface: +``` + interface LexMusic = open Cat in { + oper + song_N : N ; + american_A : A ; + } +``` +A functor on ``Syntax`` and the domain lexicon interface: +``` + incomplete concrete MusicI of Music = open Syntax, MusicLex in { + lincat + Kind = CN ; + Property = AP ; + lin + PropKind k p = mkCN p k ; + Song = mkCN song_N ; + American = mkAP american_A ; + } +``` +For each language, an instance of the domain lexicon: +``` + instance LexMusicGer of LexMusic = CatGer ** open ParadigmsGer in { + oper + song_N = mkN "Lied" "Lieder" neuter ; + american_A = mkA "amerikanisch" ; + } +``` +For each language, an instantiation of the functor: +``` + --# -path=.:present:prelude + + concrete MusicGer of Music = MusicI with + (Syntax = SyntaxGer), + (LexMusic = LexMusicGer) ; +``` diff --git a/next-lib/doc/synopsis-intro.txt b/next-lib/doc/synopsis-intro.txt new file mode 100644 index 000000000..5a473d241 --- /dev/null +++ b/next-lib/doc/synopsis-intro.txt @@ -0,0 +1,26 @@ + + + +=Introduction= + +This document contains the most important parts of the GF Resource Grammar API. +It has been machine-generated from the source files; each chapter gives a link +to the relevant source files, which give more information. Some of the files have +not yet been prepared so that the machine generated documentation has the right +format. + +Since the character encoding is UTF-8 for Russian and Latin-1 for other +languages, you +may have to change the encoding preference of your browser when reading different +parts of the document. + +The second-last chapter gives instructions on how to "browse" the library by +loading the grammars into the ``gf`` command editor. + +**New**: Browsing by syntax editor +[directly on the web ../../../demos/resource-api/editor.html]. + +The last chapter contains a brief example of how application grammars can +import resource modules. At the same time, it illustrates a "design pattern" for +using the resource API to build functor-based applications + diff --git a/next-lib/doc/synopsis.html b/next-lib/doc/synopsis.html new file mode 100644 index 000000000..6bb70acd5 --- /dev/null +++ b/next-lib/doc/synopsis.html @@ -0,0 +1,6693 @@ + + + + +GF Resource Grammar Library: Synopsis + +

GF Resource Grammar Library: Synopsis

+ +B. Bringert and A. Ranta
+
+ +

+
+

+ + +

+
+

+ +

Introduction

+

+This document contains the most important parts of the GF Resource Grammar API. +It has been machine-generated from the source files; each chapter gives a link +to the relevant source files, which give more information. Some of the files have +not yet been prepared so that the machine generated documentation has the right +format. +

+

+Since the character encoding is UTF-8 for Russian and Latin-1 for other +languages, you +may have to change the encoding preference of your browser when reading different +parts of the document. +

+

+The second-last chapter gives instructions on how to "browse" the library by +loading the grammars into the gf command editor. +

+

+New: Browsing by syntax editor +directly on the web. +

+

+The last chapter contains a brief example of how application grammars can +import resource modules. At the same time, it illustrates a "design pattern" for +using the resource API to build functor-based applications +

+ +

Categories

+

+Source 1: http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/abstract/Common.gf +

+

+Source 2: http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/abstract/Cat.gf +

+ +

A hierarchic view

+

+The chart below shows the categories in a hierarchical top-down order. +The edges do not define the complete dependency structure; if they did, +the graph would have many many more edges, and also many cycles. The precise +meaning of a directed edge from C to D is: there is a constructor +of C that takes D as an argument. What the constructors exactly are, +and what other arguments they take, is described by separate tables for +each category. +

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+The rectangular boxes mark open lexical categories, which have constructors +also in the Paradigms modules. +

+ +

Explanations

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
CategoryExplanationExample
Aone-place adjectivewarm
A2two-place adjectivedivisible
APadjectival phrasevery warm
AdAadjective-modifying adverbvery
AdNnumeral-modifying adverbmore than
AdVadverb directly attached to verbalways
Advverb-phrase-modifying adverbin the house
Antanterioritysimultaneous, anterior
CAdvcomparative adverbmore
CNcommon noun (without determiner)red house
Cardcardinal numberseven
Cldeclarative clause, with all tensesshe looks at this
Compcomplement of copula, such as APvery warm
Conjconjunctionand
Detdeterminer phrasethose seven
Digitscardinal or ordinal in digits1,000/1,000th
IAdvinterrogative adverbwhy
ICompinterrogative complement of copulawhere
IDetinterrogative determinerhow many
IPinterrogative pronounwho
Impimperativelook at this
Ncommon nounhouse
N2relational nounson
N3three-place relational nounconnection
NPnoun phrase (subject or object)the red house
Numnumber determining elementseven
Numeralcardinal or ordinal in wordsfive/fifth
Ordordinal number (used in Det)seventh
PConjphrase-beginning conjunctiontherefore
PNproper nameParis
Phrphrase in a textbut be quiet please
Polpolaritypositive, negative
Predetpredeterminer (prefixed Quant)all
Preppreposition, or just casein
Pronpersonal pronounshe
QClquestion clause, with all tenseswhy does she walk
QSquestionwhere did she live
Quantquantifier ('nucleus' of Det)this/these
RClrelative clause, with all tensesin which she lives
RPrelative pronounin which
RSrelativein which she lived
Sdeclarative sentenceshe lived here
SCembedded sentence or questionthat it rains
Subjsubjunctionif
Temptemporal and aspectual featurespast anterior
Tensetensepresent, past, future
Texttext consisting of several phrasesHe is here. Why?
Uttsentence, question, word...be quiet
Vone-place verbsleep
V2two-place verblove
V2Averb with NP and AP complementpaint
V2Qverb with NP and Q complementask
V2Sverb with NP and S complementtell
V2Vverb with NP and V complementcause
V3three-place verbshow
VAadjective-complement verblook
VPverb phraseis very warm
VPSlashverb phrase missing complementgive to John
VQquestion-complement verbwonder
VSsentence-complement verbclaim
VVverb-phrase-complement verbwant
Vocvocative or "please"my darling
+ + +

Syntax Rules and Structural Words

+

+Source 1: http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/api/Constructors.gf +

+

+Source 2: http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/abstract/Structural.gf +

+ +

A - one-place adjective

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

A2 - two-place adjective

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

AP - adjectival phrase

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
comparAPA -> APwarmer
mkAPA -> APold
mkAPA -> NP -> APolder than John
mkAPA2 -> NP -> APmarried to her
mkAPA2 -> APmarried
mkAPAP -> S -> APprobable that John walks
mkAPAP -> QS -> APuncertain if John walks
mkAPAP -> VP -> APready to go
mkAPAdA -> A -> APvery old
mkAPAdA -> AP -> APvery very old
mkAPConj -> AP -> AP -> APold and big
mkAPConj -> ListAP -> APold, big, and warm
mkAPOrd -> APoldest
mkAPCAdv -> AP -> NP -> APas old as John
reflAPA2 -> APmarried to himself
+ + +

AdA - adjective-modifying adverb

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
almost_AdAAdAalmost
quite_AdvAdAquite
so_AdAAdAso
too_AdAAdAtoo
very_AdAAdAvery
+ + +

AdN - numeral-modifying adverb

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
almost_AdNAdNalmost
at_least_AdNAdNat
at_most_AdNAdNat
mkAdNCAdv -> AdNmore than
+ + +

AdV - adverb directly attached to verb

+ + + + + + + + + + + +
FunctionTypeExample
always_AdVAdValways
+ + +

Adv - verb-phrase-modifying adverb

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
everywhere_AdvAdveverywhere
here7from_AdvAdvfrom here
here7to_AdvAdvto here
here_AdvAdvhere
mkAdvA -> Advwarmly
mkAdvPrep -> NP -> Advwith John
mkAdvSubj -> S -> Advwhen John walks
mkAdvCAdv -> A -> NP -> Advmore warmly than John
mkAdvCAdv -> A -> S -> Advmore warmly than John walks
mkAdvAdA -> Adv -> Advvery warmly
mkAdvConj -> Adv -> Adv -> Advhere and now
mkAdvConj -> ListAdv -> Advwith John, here and now
somewhere_AdvAdvsomewhere
there7from_AdvAdvfrom there
there7to_AdvAdvto there
there_AdvAdvthere
+ + +

Ant - anteriority

+ + + + + + + + + + + + + + + + +
FunctionTypeExample
anteriorAntAnt(John has walked)
simultaneousAntAnt(John walks) [default]
+ + +

CAdv - comparative adverb

+ + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
as_CAdvCAdvas
less_CAdvCAdvless
more_CAdvCAdvmore
+ + +

CN - common noun (without determiner)

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
mkCNN -> CNhouse
mkCNN2 -> NP -> CNmother of John
mkCNN3 -> NP -> NP -> CNdistance from this city to Paris
mkCNN2 -> CNson
mkCNN3 -> CNflight
mkCNA -> N -> CNbig house
mkCNA -> CN -> CNbig blue house
mkCNAP -> N -> CNvery big house
mkCNAP -> CN -> CNvery big blue house
mkCNN -> RS -> CNhouse that John loves
mkCNCN -> RS -> CNbig house that John loves
mkCNN -> Adv -> CNhouse in the city
mkCNCN -> Adv -> CNbig house in the city
mkCNCN -> S -> CNrule that John walks
mkCNCN -> QS -> CNquestion if John walks
mkCNCN -> VP -> CNreason to walk
mkCNN -> NP -> CNking John
mkCNCN -> NP -> CNold king John
+ + +

Card - cardinal number

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

Cl - declarative clause, with all tenses

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
genericClVP -> Clone walks
mkClNP -> V -> ClJohn walks
mkClNP -> V2 -> NP -> ClJohn loves her
mkClNP -> V3 -> NP -> NP -> ClJohn sends it to her
mkClNP -> VV -> VP -> ClJohn wants to walk
mkClNP -> VS -> S -> ClJohn says that it is good
mkClNP -> VQ -> QS -> ClJohn wonders if it is good
mkClNP -> VA -> AP -> ClJohn becomes old
mkClNP -> V2A -> NP -> AP -> ClJohn paints it red
mkClNP -> V2S -> NP -> S -> ClJohn tells her that we are here
mkClNP -> V2Q -> NP -> QS -> ClJohn asks her who is here
mkClNP -> V2V -> NP -> VP -> ClJohn forces us to sleep
mkClNP -> A -> ClJohn is old
mkClNP -> A -> NP -> ClJohn is older than her
mkClNP -> A2 -> NP -> ClJohn is married to her
mkClNP -> AP -> ClJohn is very old
mkClNP -> N -> ClJohn is a man
mkClNP -> CN -> ClJohn is an old man
mkClNP -> NP -> ClJohn is the man
mkClNP -> Adv -> ClJohn is here
mkClNP -> VP -> ClJohn walks here
mkClV -> Clit rains
mkClVP -> Clit is raining
mkClN -> Clthere is a house
mkClCN -> Clthere is an old houses
mkClNP -> Clthere are five houses
mkClNP -> RS -> Clit is John that walks
mkClAdv -> S -> Clit is here John walks
+ + +

ClSlash

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
mkClSlashNP -> V2 -> ClSlash(whom) John loves
mkClSlashNP -> VV -> V2 -> ClSlash(whom) John wants to see
mkClSlashCl -> Prep -> ClSlash(with whom) John walks
mkClSlashClSlash -> Adv -> ClSlash(whom) John loves today
+ + +

Comp - complement of copula, such as AP

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

Conj - conjunction

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
and_ConjConjand
both7and_DConjConjboth...and
either7or_DConjConjeither...or
if_then_ConjConjif
or_ConjConjor
+ + +

Det - determiner phrase

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
every_DetDetevery
few_DetDetfew
many_DetDetmany
mkDetQuant -> Detthis
mkDetQuant -> (Ord) -> Detthis first
mkDetQuant -> Num -> Detthese
mkDetQuant -> Num -> (Ord) -> Detthese five best
mkDetQuant -> Detthis
mkDetQuant -> Num -> Detthese five
mkDetCard -> Detalmost twenty
mkDetNumeral -> Detfive
mkDetDigits -> Det51
mkDetPron -> Detmy (house)
mkDetPron -> Num -> Detmy (houses)
much_DetDetmuch
somePl_DetDetsomePl
someSg_DetDetsomeSg
+ + +

Dig

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
n0_DigDig0
n1_DigDig1
n2_DigDig2
n3_DigDig3
n4_DigDig4
n5_DigDig5
n6_DigDig6
n7_DigDig7
n8_DigDig8
n9_DigDig9
+ + +

Digits - cardinal or ordinal in digits

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
mkDigitsDig -> Digits8
mkDigitsDig -> Digits -> Digits876
n1000_DigitsDigits1,000
n100_DigitsDigits100
n10_DigitsDigits10
n1_DigitsDigits1
n20_DigitsDigits20
n2_DigitsDigits2
n3_DigitsDigits3
n4_DigitsDigits4
n5_DigitsDigits5
n6_DigitsDigits6
n7_DigitsDigits7
n8_DigitsDigits8
n9_DigitsDigits9
+ + +

IAdv - interrogative adverb

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
how_IAdvIAdvhow
mkIAdvPrep -> IP -> IAdvin which city
when_IAdvIAdvwhen
where_IAdvIAdvwhere
why_IAdvIAdvwhy
+ + +

IComp - interrogative complement of copula

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

IDet - interrogative determiner

+ + + + + + + + + + + +
FunctionTypeExample
how8many_IDetIDethow8many
+ + +

IP - interrogative pronoun

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
mkIPIQuant -> N -> IPwhich city
mkIPIQuant -> (Num) -> CN -> IPwhich five big cities
mkIPIP -> Adv -> IPwho in Paris
whatPl_IPIPwhat (plural)
whatSg_IPIPwhat (singular)
whoPl_IPIPwho (plural)
whoSg_IPIPwho (singular)
+ + +

IQuant

+ + + + + + + + + + + +
FunctionTypeExample
which_IQuantIQuantwhich
+ + +

Imp - imperative

+ + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
mkImpV -> Impgo
mkImpV2 -> NP -> Imptake it
mkImpVP -> Impgo there now
+ + +

ImpForm

+ + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
pluralImpFormImpForm(help yourselves)
politeImpFormImpForm(help yourself) (polite singular)
singularImpFormImpForm(help yourself) [default]
+ + +

ListAP

+ + + + + + + + + + + + + + + + +
FunctionTypeExample
mkListAPAP -> AP -> ListAPold, big
mkListAPAP -> ListAP -> ListAPold, big, warm
+ + +

ListAdv

+ + + + + + + + + + + + + + + + +
FunctionTypeExample
mkListAdvAdv -> Adv -> ListAdvhere, now
mkListAdvAdv -> ListAdv -> ListAdvto me, here, now
+ + +

ListNP

+ + + + + + + + + + + + + + + + +
FunctionTypeExample
mkListNPNP -> NP -> ListNPJohn, I
mkListNPNP -> ListNP -> ListNPJohn, I, that
+ + +

ListRS

+ + + + + + + + + + + + + + + + +
FunctionTypeExample
mkListRSRS -> RS -> ListRSwho walks, who runs
mkListRSRS -> ListRS -> ListRSwho walks, who runs, who sleeps
+ + +

ListS

+ + + + + + + + + + + + + + + + +
FunctionTypeExample
mkListSS -> S -> ListShe walks, I run
mkListSS -> ListS -> ListSJohn walks, I run, you sleep
+ + +

N - common noun

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

N2 - relational noun

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

N3 - three-place relational noun

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

NP - noun phrase (subject or object)

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
everybody_NPNPeverybody
everything_NPNPeverything
mkNPQuant -> N -> NPthis men
mkNPQuant -> (Num) -> CN -> NPthese five old men
mkNPDet -> N -> NPthe first man
mkNPDet -> CN -> NPthe first old man
mkNPNumeral -> N -> NPtwenty men
mkNPNumeral -> CN -> NPtwenty old men
mkNPDigits -> N -> NP45 men
mkNPDigits -> CN -> NP45 old men
mkNPCard -> N -> NPalmost twenty men
mkNPCard -> CN -> NPalmost twenty old men
mkNPPron -> N -> NPmy man
mkNPPron -> CN -> NPmy old man
mkNPPN -> NPJohn
mkNPPron -> NPhe
mkNPQuant -> NPthis
mkNPDet -> NPthese five
mkNPN -> NPbeer
mkNPCN -> NPbeer
mkNPPredet -> NP -> NPonly John
mkNPNP -> V2 -> NPJohn killed
mkNPNP -> Adv -> NPJohn in Paris
mkNPNP -> RS -> NPJohn, who lives in Paris
mkNPConj -> NP -> NP -> NPJohn and I
mkNPConj -> ListNP -> NPJohn, I, and that
nobody_NPNPnobody
nothing_NPNPnothing
somebody_NPNPsomebody
something_NPNPsomething
+ + +

Num - number determining element

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
mkNumNumeral -> Numtwenty
mkNumDigits -> Num51
mkNumCard -> Numalmost ten
mkNumAdN -> Card -> Numalmost ten
plNumNumplural
sgNumNumsingular
+ + +

Numeral - cardinal or ordinal in words

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
n1000_NumeralNumeralthousand
n100_NumeralNumeralhundred
n10_NumeralNumeralten
n1_NumeralNumeralone
n20_NumeralNumeraltwenty
n2_NumeralNumeraltwo
n3_NumeralNumeralthree
n4_NumeralNumeralfour
n5_NumeralNumeralfive
n6_NumeralNumeralsix
n7_NumeralNumeralseven
n8_NumeralNumeraleight
n9_NumeralNumeralnine
+ + +

Ord - ordinal number (used in Det)

+ + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
mkOrdNumeral -> Ordtwentieth
mkOrdDigits -> Ord51st
mkOrdA -> Ordbest
+ + +

PConj - phrase-beginning conjunction

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
but_PConjPConjbut
mkPConjConj -> PConjand
otherwise_PConjPConjotherwise
therefore_PConjPConjtherefore
+ + +

PN - proper name

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

Phr - phrase in a text

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
mkPhrUtt -> Phrwhy
mkPhr(PConj) -> Utt -> (Voc) -> Phrbut why John
mkPhrS -> PhrJohn walked
mkPhrCl -> PhrJohn walks
mkPhrQS -> Phrdid John walk
mkPhrImp -> Phrwalk
+ + +

Pol - polarity

+ + + + + + + + + + + + + + + + +
FunctionTypeExample
negativePolPol(John doesn't walk)
positivePolPol(John walks) [default]
+ + +

Predet - predeterminer (prefixed Quant)

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
all_PredetPredetall
most_PredetPredetmost
not_PredetPredetnot
only_PredetPredetonly
+ + +

Prep - preposition, or just case

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
above_PrepPrepabove
after_PrepPrepafter
before_PrepPrepbefore
behind_PrepPrepbehind
between_PrepPrepbetween
by8agent_PrepPrepby (agent)
by8means_PrepPrepby (means of)
during_PrepPrepduring
except_PrepPrepexcept
for_PrepPrepfor
from_PrepPrepfrom
in8front_PrepPrepin front of
in_PrepPrepin
on_PrepPrepon
part_PrepPreppart
possess_PrepPrepof (possessive)
through_PrepPrepthrough
to_PrepPrepto
under_PrepPrepunder
with_PrepPrepwith
without_PrepPrepwithout
+ + +

Pron - personal pronoun

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
he_PronPronhe
i_PronProni
it_PronPronit
she_PronPronshe
they_PronPronthey
we_PronPronwe
youPl_PronPronyou (plural)
youPol_PronPronyou (polite)
youSg_PronPronyou (singular)
+ + +

Punct

+ + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
exclMarkPunctPunct!
fullStopPunctPunct.
questMarkPunctPunct?
+ + +

QCl - question clause, with all tenses

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
mkQClCl -> QCldoes John walk
mkQClIP -> VP -> QClwho walks
mkQClIP -> NP -> V2 -> QClwhom does John love
mkQClIP -> ClSlash -> QClwhom does John love today
mkQClIAdv -> Cl -> QClwhy does John walk
mkQClPrep -> IP -> Cl -> QClwith who does John walk
mkQClIAdv -> NP -> QClwhere is John
mkQClIP -> QClwhat is there
+ + +

QS - question

+ + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
mkQSQCl -> QSwho walks
mkQS(Tense) -> (Ant) -> (Pol) -> QCl -> QSwho wouldn't have walked
mkQSCl -> QSdoes John walk
+ + +

Quant - quantifier ('nucleus' of Det)

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
a_QuantQuanta
no_QuantQuantno
that_QuantQuantthat
the_QuantQuantthe
this_QuantQuantthis
+ + +

RCl - relative clause, with all tenses

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
mkRClRP -> VP -> RClthat walk
mkRClRP -> NP -> V2 -> RClwhich John loves
mkRClRP -> ClSlash -> RClwhich John loves today
mkRClCl -> RClsuch that John loves her
+ + +

RP - relative pronoun

+ + + + + + + + + + + + + + + + +
FunctionTypeExample
mkRPPrep -> NP -> RP -> RPall the houses in which
which_RPRPwhich
+ + +

RS - relative

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
mkRSRCl -> RSthat walk
mkRS(Tense) -> (Ant) -> (Pol) -> RCl -> RSthat wouldn't have walked
mkRSConj -> RS -> RS -> RSwho walks and whom I know
mkRSConj -> ListRS -> RSwho walks, whose son runs, and whom I know
+ + +

S - declarative sentence

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
mkSCl -> SJohn walks
mkS(Tense) -> (Ant) -> (Pol) -> Cl -> SJohn wouldn't have walked
mkSConj -> S -> S -> SJohn walks and I run
mkSConj -> ListS -> SJohn walks, I run and you sleep
mkSAdv -> S -> Stoday, John walks
+ + +

SC - embedded sentence or question

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

Subj - subjunction

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
although_SubjSubjalthough
because_SubjSubjbecause
if_SubjSubjif
when_SubjSubjwhen
+ + +

Temp - temporal and aspectual features

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

Tense - tense

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
conditionalTenseTense(John would walk)
futureTenseTense(John will walk)
pastTenseTense(John walked)
presentTenseTense(John walks) [default]
+ + +

Text - text consisting of several phrases

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
emptyTextText(empty text)
mkTextPhr -> TextBut John walks.
mkTextPhr -> (Punct) -> (Text) -> TextJohn walks? Yes.
mkTextUtt -> TextJohn.
mkTextS -> TextJohn walked.
mkTextCl -> TextJohn walks.
mkTextQS -> TextDid John walk?
mkTextImp -> TextWalk!
mkTextText -> Text -> TextWhere? When? Here. Now!
+ + +

Utt - sentence, question, word...

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
lets_UttVP -> Uttlet's walk
mkUttS -> UttJohn walked
mkUttCl -> UttJohn walks
mkUttQS -> Uttdid John walk
mkUttQCl -> Uttdoes John walk
mkUttImp -> Uttlove yourself
mkUtt(ImpForm) -> (Pol) -> Imp -> Uttdon't love yourselves
mkUttIP -> Uttwho
mkUttIAdv -> Uttwhy
mkUttNP -> UttJohn
mkUttAdv -> Utthere
mkUttVP -> Uttto walk
no_UttUttno
yes_UttUttyes
+ + +

V - one-place verb

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

V2 - two-place verb

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

V2A - verb with NP and AP complement

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

V2Q - verb with NP and Q complement

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

V2S - verb with NP and S complement

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

V2V - verb with NP and V complement

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

V3 - three-place verb

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

VA - adjective-complement verb

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

VP - verb phrase

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
mkVPV -> VPwalk
mkVPV2 -> NP -> VPlove her
mkVPV3 -> NP -> NP -> VPsend it to her
mkVPVV -> VP -> VPwant to walk
mkVPVS -> S -> VPknow that she walks
mkVPVQ -> QS -> VPask if she walks
mkVPVA -> AP -> VPbecome old
mkVPV2A -> NP -> AP -> VPpaint it red
mkVPA -> VPbe warm
mkVPAP -> VPbe very warm
mkVPA -> NP -> VPbe older than her
mkVPA2 -> NP -> VPbe married to her
mkVPN -> VPbe a man
mkVPCN -> VPbe an old man
mkVPNP -> VPbe the man
mkVPAdv -> VPbe here
mkVPVP -> Adv -> VPsleep here
mkVPAdV -> VP -> VPalways sleep
mkVPVPSlash -> NP -> VPpaint it black
mkVPVPSlash -> VPpaint itself black
passiveVPV2 -> VPbe loved
passiveVPV2 -> NP -> VPbe loved by her
progressiveVPVP -> VPbe sleeping
reflexiveVPV2 -> VPlove itself
+ + +

VPSlash - verb phrase missing complement

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
mkVPSlashV2 -> VPSlash(whom) (John) loves
mkVPSlashV3 -> NP -> VPSlash(whom) (John) gives an apple
mkVPSlashV2A -> AP -> VPSlash(whom) (John) paints red
mkVPSlashV2Q -> QS -> VPSlash(whom) (John) asks who sleeps
mkVPSlashV2S -> S -> VPSlash(whom) (John) tells that we sleep
mkVPSlashV2V -> VP -> VPSlash(whom) (John) forces to sleep
+ + +

VQ - question-complement verb

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

VS - sentence-complement verb

+

+Lexical category, constructors given in +lexical paradigms. +

+ +

VV - verb-phrase-complement verb

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionTypeExample
can8know_VVVVcan (capacity)
can_VVVVcan (possibility)
must_VVVVmust
want_VVVVwant
+ + +

Voc - vocative or "please"

+ + + + + + + + + + + + + + + + +
FunctionTypeExample
mkVocNP -> VocJohn
please_VocVocplease
+ + +

Lexical Paradigms

+ +

Paradigms for Bulgarian

+

+ +

+

+source http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/bulgarian/ParadigmsBul.gf +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionType
mkN001Str -> N
mkN002Str -> N
mkN002aStr -> N
mkN003Str -> N
mkN004Str -> N
mkN005Str -> N
mkN006Str -> N
mkN007Str -> N
mkN007bStr -> N
mkN007aStr -> N
mkN008Str -> N
mkN008bStr -> N
mkN008cStr -> N
mkN008aStr -> N
mkN009Str -> N
mkN009aStr -> N
mkN010Str -> N
mkN011Str -> N
mkN012Str -> N
mkN013Str -> N
mkN014Str -> N
mkN014aStr -> N
mkN015Str -> N
mkN015aStr -> N
mkN016Str -> N
mkN016aStr -> N
mkN017Str -> N
mkN018Str -> N
mkN018aStr -> N
mkN019Str -> N
mkN019aStr -> N
mkN020Str -> N
mkN021Str -> N
mkN022Str -> N
mkN023Str -> N
mkN024aStr -> N
mkN024Str -> N
mkN025Str -> N
mkN026Str -> N
mkN027Str -> N
mkN028Str -> N
mkN028aStr -> N
mkN029Str -> N
mkN030Str -> N
mkN031Str -> N
mkN031aStr -> N
mkN032Str -> N
mkN032aStr -> N
mkN033Str -> N
mkN034Str -> N
mkN035Str -> N
mkN035aStr -> N
mkN036Str -> N
mkN037Str -> N
mkN038Str -> N
mkN039Str -> N
mkN040Str -> N
mkN040aStr -> N
mkN041Str -> N
mkN041aStr -> N
mkN041bStr -> N
mkN042Str -> N
mkN043Str -> N
mkN043aStr -> N
mkN044Str -> N
mkN045Str -> N
mkN046Str -> N
mkN047Str -> N
mkN048Str -> N
mkN049Str -> N
mkN050Str -> N
mkN051Str -> N
mkN052Str -> N
mkN052aStr -> N
mkN053Str -> N
mkN054Str -> N
mkN055Str -> N
mkN056Str -> N
mkN057Str -> N
mkN057aStr -> N
mkN058Str -> N
mkN059Str -> N
mkN060Str -> N
mkN061Str -> N
mkN062Str -> N
mkN063Str -> N
mkN064Str -> N
mkN065Str -> N
mkN066Str -> N
mkN067Str -> N
mkN068Str -> N
mkN069Str -> N
mkN070Str -> N
mkN071Str -> N
mkN072Str -> N
mkN073Str -> N
mkN074Str -> N
mkN075Str -> N
mkA076Str -> A
mkA077Str -> A
mkA078Str -> A
mkA079Str -> A
mkA080Str -> A
mkA081Str -> A
mkA082Str -> A
mkA082aStr -> A
mkA083Str -> A
mkA084Str -> A
mkA084aStr -> A
mkA085Str -> A
mkA086Str -> A
mkA087Str -> A
mkA088Str -> A
mkA089aStr -> A
mkV142Str -> VTable
mkV143Str -> VTable
mkV144Str -> VTable
mkV145Str -> VTable
mkV145aStr -> VTable
mkV145bStr -> VTable
mkV146Str -> VTable
mkV146aStr -> VTable
mkV147Str -> VTable
mkV148Str -> VTable
mkV149Str -> VTable
mkV150Str -> VTable
mkV150aStr -> VTable
mkV151Str -> VTable
mkV152Str -> VTable
mkV152aStr -> VTable
mkV153Str -> VTable
mkV154Str -> VTable
mkV155Str -> VTable
mkV156Str -> VTable
mkV157Str -> VTable
mkV158Str -> VTable
mkV159Str -> VTable
mkV160Str -> VTable
mkV160aStr -> VTable
mkV161Str -> VTable
mkV161aStr -> VTable
mkV162Str -> VTable
mkV163Str -> VTable
mkV164Str -> VTable
mkV165Str -> VTable
mkV166Str -> VTable
mkV167Str -> VTable
mkV168Str -> VTable
mkV169Str -> VTable
mkV170Str -> VTable
mkV171Str -> VTable
mkV172Str -> VTable
mkV173Str -> VTable
mkV174Str -> VTable
mkV175Str -> VTable
mkV176Str -> VTable
mkV177Str -> VTable
mkV178Str -> VTable
mkV179Str -> VTable
mkV180Str -> VTable
mkV181Str -> VTable
mkV182Str -> VTable
mkV183Str -> VTable
mkV184Str -> VTable
mkV185Str -> VTable
mkV186Str -> VTable
mkV187Str -> VTable
adjAdvA -> Str -> A =
+ + +

Paradigms for Catalan

+

+ +

+

+source http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/catalan/ParadigmsCat.gf +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionType
GenderType
masculineGender
feminineGender
NumberType
singularNumber
pluralNumber
accusativePrep
genitivePrep
dativePrep
mkPrepStr -> Prep
mkN(llum : Str) -> N
mkNStr -> Gender -> N
mkN(disc,discos : Str) -> Gender -> N
compNN -> Str -> N
mkN2N -> Prep -> N2
deN2N -> N2
aN2N -> N2
mkN3N -> Prep -> Prep -> N3
mkPN(Anna : Str) -> PN
mkPN(Pilar : Str) -> Gender -> PN
mkA(sol : Str) -> A
mkA(fort,forta,forts,fortes,fortament : Str) -> A
mkA(bo : A) -> (millor : A) -> A
prefixAA -> A
mkA2A -> Prep -> A2
mkAdvStr -> Adv
mkAdVStr -> AdV
mkAdAStr -> AdA
mkV(cantar : Str) -> V
mkVVerbum -> V
reflVV -> V
special_ppVV -> Str -> V
mkV2Str -> V2
mkV2V -> V2
mkV2V -> Prep -> V2
v2VV2 -> V
mkV3V -> Prep -> Prep -> V3
dirV3V -> Prep -> V3
dirdirV3V -> V3
mkV0V -> V0
mkVSV -> VS
mkV2SV -> Prep -> V2S
mkVVV -> VV
deVVV -> VV
aVVV -> VV
mkV2VV -> Prep -> Prep -> V2V
mkVAV -> VA
mkV2AV -> Prep -> Prep -> V2A
mkVQV -> VQ
mkV2QV -> Prep -> V2Q
mkASA -> AS
mkA2SA -> Prep -> A2S
mkAVA -> Prep -> AV
mkA2VA -> Prep -> Prep -> A2V
V0Type
+ + +

Paradigms for Danish

+

+ +

+

+source http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/danish/ParadigmsDan.gf +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionType
GenderType
utrumGender
neutrumGender
NumberType
singularNumber
pluralNumber
CaseType
nominativeCase
genitiveCase
mkPrepStr -> Prep
noPrepPrep
mkN(bil : Str) -> N
mkN(hus : Str) -> Gender -> N
mkN(bil,bilen : Str) -> N
mkN(bil,bilen,biler : Str) -> N
mkN(dreng,drengen,drenge,drengene : Str) -> N
mkN2N -> Prep -> N2
regN2Str -> Gender -> N2
mkN3N -> Prep -> Prep -> N3
mkPNStr -> PN
mkPNStr -> Gender -> PN
mkPNN -> PN
mkA(fin : Str) -> A
mkA(fin,fint : Str) -> A
mkA(galen,galet,galne : Str) -> A
mkA(stor,stort,store,storre,storst : Str) -> A
mkAA -> A
mkA2A -> Prep -> A2
mkAdvStr -> Adv
mkAdVStr -> AdV
mkAdAStr -> AdA
mkV(snakke : Str) -> V
mkV(leve,levde : Str) -> V
mkV(drikke, drakk, drukket : Str) -> V
mkV(spise,spiser,spises,spiste,spist,spis : Str) -> V
mkVV -> Str -> V
vaereVV -> V
depVV -> V
reflVV -> V
mkV2Str -> V2
mkV2V -> V2
mkV2V -> Prep -> V2
mkV3V -> Prep -> Prep -> V3
dirV3V -> Prep -> V3
dirdirV3V -> V3
mkV0V -> V0
mkVSV -> VS
mkV2SV -> Prep -> V2S
mkVVV -> VV
mkV2VV -> Prep -> Prep -> V2V
mkVAV -> VA
mkV2AV -> Prep -> V2A
mkVQV -> VQ
mkV2QV -> Prep -> V2Q
mkASA -> AS
mkA2SA -> Prep -> A2S
mkAVA -> AV
mkA2VA -> Prep -> A2V
V0Type
+ + +

Paradigms for English

+

+ +

+

+source http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/english/ParadigmsEng.gf +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionType
GenderType
humanGender
nonhumanGender
masculineGender
feminineGender
NumberType
singularNumber
pluralNumber
CaseType
nominativeCase
genitiveCase
mkN(flash : Str) -> N
mkN(man,men : Str) -> N
mkN(man,men,man's,men's : Str) -> N
mkNGender -> N -> N
mkNStr -> N -> N
mkN2N -> Prep -> N2
mkN2N -> Str -> N2
mkN2Str -> Str -> N2
mkN2N -> N2
mkN2Str -> N2
mkN3N -> Prep -> Prep -> N3
mkPNStr -> PN
mkPNN -> PN
mkQuant(this, these : Str) -> Quant
mkQuant(no_sg, no_pl, none_sg, non_pl : Str) -> Quant
mkOrdStr -> Ord
mkA(happy : Str) -> A
mkA(fat,fatter : Str) -> A
mkA(good,better,best,well : Str) -> A
compoundAA -> A
simpleAA -> A
mkA2A -> Prep -> A2
mkA2A -> Str -> A2
mkA2Str -> Prep -> A2
mkA2Str -> Str -> A2
mkAdvStr -> Adv
mkAdVStr -> AdV
mkAdAStr -> AdA
mkAdNStr -> AdN
mkPrepStr -> Prep
noPrepPrep
mkConjStr -> Conj
mkConjStr -> Number -> Conj
mkConjStr -> Str -> Conj
mkConjStr -> Str -> Number -> Conj
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
mkVStr -> V -> V
partVV -> Str -> V
reflVV -> V
mkV2Str -> V2
mkV2V -> V2
mkV2V -> Prep -> V2
mkV2V -> Str -> V2
mkV2Str -> Prep -> V2
mkV2Str -> Str -> V2
mkV3V -> Prep -> Prep -> V3
mkV3V -> Prep -> V3
mkV3V -> Str -> V3
mkV3Str -> Str -> V3
mkV3V -> V3
mkV3Str -> V3
mkV0V -> V0
mkVSV -> VS
mkV2SV -> Prep -> V2S
mkVVV -> VV
mkV2VV -> Prep -> Prep -> V2V
mkVAV -> VA
mkV2AV -> Prep -> V2A
mkVQV -> VQ
mkV2QV -> Prep -> V2Q
mkASA -> AS
mkA2SA -> Prep -> A2S
mkAVA -> AV
mkA2VA -> Prep -> A2V
V0Type
mkSubjStr -> Subj = \s -> {s = s lock_Subj = <>}
+ + +

Paradigms for Finnish

+

+ +

+

+source http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/finnish/ParadigmsFin.gf +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionType
NumberType
singularNumber
pluralNumber
CaseType
nominativeCase
genitiveCase
partitiveCase
translativeCase
inessiveCase
elativeCase
illativeCase
adessiveCase
ablativeCase
allativeCase
prePrepCase -> Str -> Prep
postPrepCase -> Str -> Prep
postGenPrepStr -> Prep
casePrepCase -> Prep
mkN(talo : Str) -> N
mkN(savi,savia : Str) -> N
mkN(vesi,veden,vesiä : Str) -> N
mkN(vesi,veden,vesiä,vettä : Str) -> N
mkN(olo,olon,olona,oloa,oloon,olojen,oloja,oloina,oloissa,oloihin : Str) -> N
mkN(pika : Str) -> (juna : N) -> N
mkN(oma : N) -> (tunto : N) -> N
mkN2N -> N2
mkN2N -> Prep -> N2
mkN3N -> Prep -> Prep -> N3
mkPNStr -> PN
mkPNN -> PN
mkAStr -> A
mkAN -> A
mkAN -> (kivempaa,kivinta : Str) -> A
mkA(hyva,parempi,paras : N) -> (hyvin,paremmin,parhaiten : Str) -> A
mkA2A -> Prep -> A2 = \a,p -> a ** {c2 = p lock_A2 = <>};
mkV(huutaa : Str) -> V
mkV(huutaa,huusi : Str) -> V
mkV(huutaa,huudan,huusi : Str) -> V
mkV(
huusin,huusi,huusisi,huutanut,huudettu,huutaneeStr) -> V
caseVCase -> V -> V
vOllaV
mkV2Str -> V2
mkV2V -> V2
mkV2V -> Case -> V2
mkV2V -> Prep -> V2
mkV3V -> Prep -> Prep -> V3
dirV3V -> Case -> V3
dirdirV3V -> V3
mkV0V -> V0
mkVSV -> VS
mkV2SV -> Prep -> V2S
mkVVV -> VV
mkVVfV -> InfForm -> VV
mkV2VV -> Prep -> V2V
mkV2VfV -> Prep -> InfForm -> V2V
mkVAV -> Prep -> VA
mkV2AV -> Prep -> Prep -> V2A
mkVQV -> VQ
mkV2QV -> Prep -> V2Q
mkASA -> AS
mkA2SA -> Prep -> A2S
mkAVA -> AV
mkA2VA -> Prep -> A2V
V0Type
+ + +

Paradigms for French

+

+ +

+

+source http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/french/ParadigmsFre.gf +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionType
GenderType
masculineGender
feminineGender
NumberType
singularNumber
pluralNumber
accusativePrep
genitivePrep
dativePrep
mkPrepStr -> Prep
mkN(cheval : Str) -> N
mkN(foie : Str) -> Gender -> N
mkN(oeil,yeux : Str) -> Gender -> N
mkNN -> Str -> N
mkN2N -> Prep -> N2
deN2N -> N2
aN2N -> N2
mkN3N -> Prep -> Prep -> N3
mkPNStr -> PN
mkPNStr -> Gender -> PN
mkA(cher : Str) -> A
mkA(sec,seche : Str) -> A
mkA(banal,banale,banaux,banalement : Str) -> A
mkAA -> A -> A
prefixAA -> A
mkA2A -> Prep -> A2
mkAdvStr -> Adv
mkAdVStr -> AdV
mkAdAStr -> AdA
mkV(finir : Str) -> V
mkV(jeter,jette,jettera : Str) -> V
mkVV2 -> V
etreVV -> V
reflVV -> V
mkV2Str -> V2 = \s -> dirV2 (regV s)
mkV2V -> V2 = dirV2
mkV2V -> Prep -> V2 = mmkV2
mkV3V -> V3
mkV3V -> Prep -> V3
mkV3V -> Prep -> Prep -> V3
mkV0V -> V0
mkVSV -> VS
mkV2SV -> Prep -> V2S
mkVVV -> VV
deVVV -> VV
aVVV -> VV
mkV2VV -> Prep -> Prep -> V2V
mkVAV -> VA
mkV2AV -> Prep -> Prep -> V2A
mkVQV -> VQ
mkV2QV -> Prep -> V2Q
mkASA -> AS
mkA2SA -> Prep -> A2S
mkAVA -> Prep -> AV
mkA2VA -> Prep -> Prep -> A2V
V0Type
+ + +

Paradigms for German

+

+ +

+

+source http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/german/ParadigmsGer.gf +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionType
GenderType
masculineGender
feminineGender
neuterGender
CaseType
nominativeCase
accusativeCase
dativeCase
genitiveCase
NumberType
singularNumber
pluralNumber
mkN(Stufe : Str) -> N
mkN(Bild,Bilder : Str) -> Gender -> N
mkN(x1,_,_,_,_,x6 : Str) -> Gender -> N
mkN2Str -> N2
mkN2N -> N2
mkN2N -> Prep -> N2
mkN3N -> Prep -> Prep -> N3
mkPNStr -> PN
mkPN(nom,gen : Str) -> PN
mkPN(nom,acc,dat,gen : Str) -> PN
mkAStr -> A
mkA(gut,besser,beste : Str) -> A
mkA(gut,gute,besser,beste : Str) -> A
invarAStr -> A
mkA2A -> Prep -> A2
mkAdvStr -> Adv
mkPrepStr -> Case -> Prep
accPrepPrep
datPrepPrep
genPrepPrep
von_PrepPrep
zu_PrepPrep
mkV(führen : Str) -> V
mkV(sehen,sieht,sah,sähe,gesehen : Str) -> V
mkV(geben, gibt, gib, gab, gäbe, gegeben : Str) -> V
mkVStr -> V -> V
no_geVV -> V
seinVV -> V
habenVV -> V
reflVV -> Case -> V
mkV2Str -> V2
mkV2V -> V2
mkV2V -> Prep -> V2
mkV2V -> Case -> V2
mkV3V -> Prep -> Prep -> V3
dirV3V -> Prep -> V3
accdatV3V -> V3
mkV0V -> V0
mkVSV -> VS
mkV2SV -> Prep -> V2S
mkVVV -> VV
mkV2VV -> Prep -> V2V
mkVAV -> VA
mkV2AV -> Prep -> V2A
mkVQV -> VQ
mkV2QV -> Prep -> V2Q
mkASA -> AS
mkA2SA -> Prep -> A2S
mkAVA -> AV
mkA2VA -> Prep -> A2V
V0Type
+ + +

Paradigms for Italian

+

+ +

+

+source http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/italian/ParadigmsIta.gf +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionType
GenderType
masculineGender
feminineGender
NumberType
singularNumber
pluralNumber
--PrepType
accusativePrep
genitivePrep
dativePrep
mkPrepStr -> Prep
mkN(cane : Str) -> N
mkN(carne : Str) -> Gender -> N
mkN(uomo,uomini : Str) -> Gender -> N
mkNN -> Str -> N
mkN2Str -> N2
mkN2N -> Prep -> N2
mkN3N -> Prep -> Prep -> N3
mkPNStr -> PN
mkPNStr -> Gender -> PN
mkA(bianco : Str) -> A
mkA(solo,sola,soli,sole,solamente : Str) -> A
mkAA -> A -> A
prefixAA -> A = prefA
mkA2A -> Prep -> A2
mkAdvStr -> Adv
mkAdVStr -> AdV
mkAdAStr -> AdA
mkVStr -> V
mkVVerbo -> V
mkV(udire,odo,ode,udiamo,udiro,udii,udisti,udi,udirono,odi,udito : Str) -> V
essereVV -> V
reflVV -> V
mkV2Str -> V2
mkV2V -> V2
mkV2V -> Prep -> V2
v2VV2 -> V
mkV3V -> Prep -> Prep -> V3
dirV3V -> Prep -> V3
dirdirV3V -> V3
mkV0V -> V0
mkVSV -> VS
mkV2SV -> Prep -> V2S
mkVVV -> VV
deVVV -> VV
aVVV -> VV
mkV2VV -> Prep -> Prep -> V2V
mkVAV -> VA
mkV2AV -> Prep -> Prep -> V2A
mkVQV -> VQ
mkV2QV -> Prep -> V2Q
mkASA -> AS
mkA2SA -> Prep -> A2S
mkAVA -> Prep -> AV
mkA2VA -> Prep -> Prep -> A2V
V0Type
+ + +

Paradigms for Norwegian

+

+ +

+

+source http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/norwegian/ParadigmsNor.gf +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionType
GenderType
masculineGender
feminineGender
neutrumGender
NumberType
singularNumber
pluralNumber
CaseType
nominativeCase
genitiveCase
mkPrepStr -> Prep
noPrepPrep
mkNStr -> N
mkNStr -> Gender -> N
mkN(bil,bilen : Str) -> N
mkN(dreng,drengen,drenger,drengene : Str) -> N
mkN2N -> Prep -> N2
regN2Str -> Gender -> N2
mkN3N -> Prep -> Prep -> N3
mkPNStr -> PN
mkPNStr -> Gender -> PN
mkPNN -> PN
mkA(fin : Str) -> A
mkA(fin,fint : Str) -> A
mkA(galen,galet,galne : Str) -> A
mkA(stor,stort,store,storre,storst : Str) -> A
mkAA -> A
mkA2A -> Prep -> A2
mkAdvStr -> Adv
mkAdVStr -> AdV
mkAdAStr -> AdA
mkV(snakke : Str) -> V
mkV(leve,levde : Str) -> V
mkV(drikke, drakk, drukket : Str) -> V
mkV(spise,spiser,spises,spiste,spist,spis : Str) -> V
mkVV -> Str -> V
vaereVV -> V
depVV -> V
reflVV -> V
mkV2Str -> V2
mkV2V -> V2
mkV2V -> Prep -> V2
mkV3V -> Prep -> Prep -> V3
dirV3V -> Prep -> V3
dirdirV3V -> V3
mkV0V -> V0
mkVSV -> VS
mkV2SV -> Prep -> V2S
mkVVV -> VV
mkV2VV -> Prep -> Prep -> V2V
mkVAV -> VA
mkV2AV -> Prep -> V2A
mkVQV -> VQ
mkV2QV -> Prep -> V2Q
mkASA -> AS
mkA2SA -> Prep -> A2S
mkAVA -> AV
mkA2VA -> Prep -> A2V
V0Type
+ + +

Paradigms for Romanian

+

+ +

+

+source http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/romanian/ParadigmsRon.gf +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionType
NGenderType
masculineNGender
feminineNGender
neuterNGender
GenderType
MasculineGender
FeminineGender
AnimType
animateAnim
inanimateAnim;
NumberType
singularNumber
pluralNumber
PrepositionType
NCaseType
AccNCase
DatNCase
GenNCase
mkPrepStr -> NCase -> Prep
noPrepNCase -> Prep
mkN2N -> Prep -> N2
mkN3N -> Prep -> Prep -> N3
mkPNStr -> PN = mkPropN
mkPNStr -> Gender -> PN = mkPropNoun
mkPNStr -> Gender -> Number -> PN = mkProperNoun;
mkPropNStr -> PN = \Ion ->
mkPropNounStr -> Gender -> PN = \Ion, gen ->
mkProperNounStr -> Gender -> Number -> PN = \Ion, gen, num ->
mkA2A -> Prep -> A2
+ + +

Paradigms for Russian

+

+ +

+

+source http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/russian/ParadigmsRus.gf +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionType
GenderType
masculineGender
feminineGender
neuterGender
CaseType
nominativeCase
genitiveCase
dativeCase
accusativeCase
instructiveCase
prepositionalCase
NumberType
singularNumber
pluralNumber
mkN(karta : Str) -> N
mkN(tigr : Str) -> Animacy -> N
mkN(nomSg, genSg, datSg, accSg, instSg, preposSg, prepos2Sg, nomPl, genPl, datPl, accPl, instPl, preposPl : Str) -> Gender -> Animacy -> N
mkN2N -> N2
mkN2N -> Prep -> N2
mkN3N -> Prep -> Prep -> N3
mkPNStr -> Gender -> Animacy -> PN
nounPNN -> PN
mkA(positive : Str) -> A
mkA(positive, comparative : Str) -> A
mkA2A -> Str -> Case -> A2
mkAdvStr -> Adv
mkVAspect -> (presentSgP1,presentSgP2,presentSgP3,
pastSgP1,imperative,infinitiveStr) -> V
mkV2V -> Str -> Case -> V2
mkV3V -> Str -> Str -> Case -> Case -> V3
dirV2V -> V2
tvDirDirV -> V3
+ + +

Paradigms for Spanish

+

+ +

+

+source http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/spanish/ParadigmsSpa.gf +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionType
GenderType
masculineGender
feminineGender
NumberType
singularNumber
pluralNumber
accusativePrep
genitivePrep
dativePrep
mkPrepStr -> Prep
mkN(luz : Str) -> N
mkNStr -> Gender -> N
mkN(baston,bastones : Str) -> Gender -> N
compNN -> Str -> N
mkN2N -> Prep -> N2
deN2N -> N2
aN2N -> N2
mkN3N -> Prep -> Prep -> N3
mkPN(Anna : Str) -> PN
mkPN(Pilar : Str) -> Gender -> PN
mkA(util : Str) -> A
mkA(solo,sola,solos,solas,solamente : Str) -> A
mkA(bueno : A) -> (mejor : A) -> A
prefixAA -> A
mkA2A -> Prep -> A2
mkAdvStr -> Adv
mkAdVStr -> AdV
mkAdAStr -> AdA
mkV(pagar : Str) -> V
mkV(mostrar,muestro : Str) -> V
mkVVerbum -> V
reflVV -> V
special_ppVV -> Str -> V
mkV2Str -> V2
mkV2V -> V2
mkV2V -> Prep -> V2
v2VV2 -> V
mkV3V -> Prep -> Prep -> V3
dirV3V -> Prep -> V3
dirdirV3V -> V3
mkV0V -> V0
mkVSV -> VS
mkV2SV -> Prep -> V2S
mkVVV -> VV
deVVV -> VV
aVVV -> VV
mkV2VV -> Prep -> Prep -> V2V
mkVAV -> VA
mkV2AV -> Prep -> Prep -> V2A
mkVQV -> VQ
mkV2QV -> Prep -> V2Q
mkASA -> AS
mkA2SA -> Prep -> A2S
mkAVA -> Prep -> AV
mkA2VA -> Prep -> Prep -> A2V
V0Type
+ + +

Paradigms for Swedish

+

+ +

+

+source http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/swedish/ParadigmsSwe.gf +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunctionType
GenderType
utrumGender
neutrumGender
NumberType
singularNumber
pluralNumber
CaseType
nominativeCase
genitiveCase
mkPrepStr -> Prep
noPrepPrep
mkN(apa : Str) -> N
mkN(lik : Str) -> Gender -> N
mkN(nyckel,nycklar : Str) -> N
mkN(museum,museet,museer,museerna : Str) -> N
mkN2Str -> N2
mkN2N -> Prep -> N2
mkN3N -> Prep -> Prep -> N3
mkPNStr -> PN
mkPNStr -> 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
compoundAA -> A
mkA2A -> Prep -> A2
mkAdvStr -> Adv
mkAdVStr -> AdV
mkAdAStr -> AdA
mkV(stämmer : Str) -> V
mkV(dricka,drack,druckit : Str) -> V
mkV(gå,går,gå,gick,gått,gången : Str) -> V
mkVV -> Str -> V
depVV -> V
reflVV -> V
mkV2Str -> V2
mkV2V -> V2
mkV2V -> Prep -> V2
mkV3Str -> V3
mkV3V -> V3
mkV3V -> Prep -> V3
mkV3V -> Prep -> Prep -> V3
mkV0V -> V0
mkVSV -> VS
mkV2SV -> Prep -> V2S
mkVVV -> VV
mkV2VV -> Prep -> Prep -> V2V
mkVAV -> VA
mkV2AV -> Prep -> V2A
mkVQV -> VQ
mkV2QV -> Prep -> V2Q
mkASA -> AS
mkA2SA -> Prep -> A2S
mkAVA -> AV
mkA2VA -> Prep -> A2V
V0Type
+ + +

Browsing the libraries with GF commands

+

+New: Browsing by syntax editor +directly on the web. +

+

+All of the following assume +

+
+    cd $GF_LIB_PATH
+
+

+To try out inflection paradigms: +

+
+    > i -path=alltenses -retain alltenses/ParadigmsGer.gfo
+    > cc mkN "Farbe"
+
+

+To try out overloaded syntax, test lexicon, and inflection paradigms: +

+
+    > i -path=alltenses -retain alltenses/TryGer.gfo
+    > cc mkCl (mkNP this_Quant (mkN "Farbe")) (mkA "dunkel")
+
+

+ +

An Example of Usage

+

+The standard way of building an application has the following modules. +

+

+An abstract syntax: +

+
+    abstract Music = {    
+    cat 
+      Kind, 
+      Property ;
+    fun 
+      PropKind : Kind -> Property -> Kind ; 
+      Song : Kind ;
+      American : Property ;
+    }
+
+

+A domain lexicon interface: +

+
+    interface LexMusic = open Cat in {
+    oper
+      song_N : N ;
+      american_A : A ;
+    }
+
+

+A functor on Syntax and the domain lexicon interface: +

+
+    incomplete concrete MusicI of Music = open Syntax, MusicLex in {
+    lincat 
+      Kind = CN ;
+      Property = AP ;
+    lin
+      PropKind k p = mkCN p k ;
+      Song = mkCN song_N ;
+      American = mkAP american_A ;
+    }
+
+

+For each language, an instance of the domain lexicon: +

+
+    instance LexMusicGer of LexMusic = CatGer ** open ParadigmsGer in {    
+    oper
+      song_N = mkN "Lied" "Lieder" neuter ;
+      american_A = mkA "amerikanisch" ;
+    }
+
+

+For each language, an instantiation of the functor: +

+
+    --# -path=.:present:prelude
+  
+    concrete MusicGer of Music = MusicI with
+      (Syntax = SyntaxGer),
+      (LexMusic = LexMusicGer) ;
+
+

+ + + + diff --git a/next-lib/doc/synopsis.txt b/next-lib/doc/synopsis.txt new file mode 100644 index 000000000..247220d2e --- /dev/null +++ b/next-lib/doc/synopsis.txt @@ -0,0 +1,1703 @@ +GF Resource Grammar Library: Synopsis +B. Bringert and A. Ranta + + +%!postproc(html): '(SRC="categories.png")' '\1 USEMAP="#categories"' +%!postproc(html): '#LParadigms' '' +%!postproc(tex): '#LParadigms' '' +%!postproc(html): '(?i)(HREF="#A")( TITLE="[^"]*")?' '\1 TITLE="A - one-place adjective"' +%!postproc(html): '(?i)(HREF="#A2")( TITLE="[^"]*")?' '\1 TITLE="A2 - two-place adjective"' +%!postproc(html): '(?i)(HREF="#AP")( TITLE="[^"]*")?' '\1 TITLE="AP - adjectival phrase"' +%!postproc(html): '(?i)(HREF="#AdA")( TITLE="[^"]*")?' '\1 TITLE="AdA - adjective-modifying adverb"' +%!postproc(html): '(?i)(HREF="#AdN")( TITLE="[^"]*")?' '\1 TITLE="AdN - numeral-modifying adverb"' +%!postproc(html): '(?i)(HREF="#AdV")( TITLE="[^"]*")?' '\1 TITLE="AdV - adverb directly attached to verb"' +%!postproc(html): '(?i)(HREF="#Adv")( TITLE="[^"]*")?' '\1 TITLE="Adv - verb-phrase-modifying adverb"' +%!postproc(html): '(?i)(HREF="#Ant")( TITLE="[^"]*")?' '\1 TITLE="Ant - anteriority"' +%!postproc(html): '(?i)(HREF="#CAdv")( TITLE="[^"]*")?' '\1 TITLE="CAdv - comparative adverb"' +%!postproc(html): '(?i)(HREF="#CN")( TITLE="[^"]*")?' '\1 TITLE="CN - common noun (without determiner)"' +%!postproc(html): '(?i)(HREF="#Card")( TITLE="[^"]*")?' '\1 TITLE="Card - cardinal number"' +%!postproc(html): '(?i)(HREF="#Cl")( TITLE="[^"]*")?' '\1 TITLE="Cl - declarative clause, with all tenses"' +%!postproc(html): '(?i)(HREF="#Comp")( TITLE="[^"]*")?' '\1 TITLE="Comp - complement of copula, such as AP"' +%!postproc(html): '(?i)(HREF="#Conj")( TITLE="[^"]*")?' '\1 TITLE="Conj - conjunction"' +%!postproc(html): '(?i)(HREF="#Det")( TITLE="[^"]*")?' '\1 TITLE="Det - determiner phrase"' +%!postproc(html): '(?i)(HREF="#Digits")( TITLE="[^"]*")?' '\1 TITLE="Digits - cardinal or ordinal in digits"' +%!postproc(html): '(?i)(HREF="#IAdv")( TITLE="[^"]*")?' '\1 TITLE="IAdv - interrogative adverb"' +%!postproc(html): '(?i)(HREF="#IComp")( TITLE="[^"]*")?' '\1 TITLE="IComp - interrogative complement of copula"' +%!postproc(html): '(?i)(HREF="#IDet")( TITLE="[^"]*")?' '\1 TITLE="IDet - interrogative determiner"' +%!postproc(html): '(?i)(HREF="#IP")( TITLE="[^"]*")?' '\1 TITLE="IP - interrogative pronoun"' +%!postproc(html): '(?i)(HREF="#Imp")( TITLE="[^"]*")?' '\1 TITLE="Imp - imperative"' +%!postproc(html): '(?i)(HREF="#N")( TITLE="[^"]*")?' '\1 TITLE="N - common noun"' +%!postproc(html): '(?i)(HREF="#N2")( TITLE="[^"]*")?' '\1 TITLE="N2 - relational noun"' +%!postproc(html): '(?i)(HREF="#N3")( TITLE="[^"]*")?' '\1 TITLE="N3 - three-place relational noun"' +%!postproc(html): '(?i)(HREF="#NP")( TITLE="[^"]*")?' '\1 TITLE="NP - noun phrase (subject or object)"' +%!postproc(html): '(?i)(HREF="#Num")( TITLE="[^"]*")?' '\1 TITLE="Num - number determining element"' +%!postproc(html): '(?i)(HREF="#Numeral")( TITLE="[^"]*")?' '\1 TITLE="Numeral - cardinal or ordinal in words"' +%!postproc(html): '(?i)(HREF="#Ord")( TITLE="[^"]*")?' '\1 TITLE="Ord - ordinal number (used in Det)"' +%!postproc(html): '(?i)(HREF="#PConj")( TITLE="[^"]*")?' '\1 TITLE="PConj - phrase-beginning conjunction"' +%!postproc(html): '(?i)(HREF="#PN")( TITLE="[^"]*")?' '\1 TITLE="PN - proper name"' +%!postproc(html): '(?i)(HREF="#Phr")( TITLE="[^"]*")?' '\1 TITLE="Phr - phrase in a text"' +%!postproc(html): '(?i)(HREF="#Pol")( TITLE="[^"]*")?' '\1 TITLE="Pol - polarity"' +%!postproc(html): '(?i)(HREF="#Predet")( TITLE="[^"]*")?' '\1 TITLE="Predet - predeterminer (prefixed Quant)"' +%!postproc(html): '(?i)(HREF="#Prep")( TITLE="[^"]*")?' '\1 TITLE="Prep - preposition, or just case"' +%!postproc(html): '(?i)(HREF="#Pron")( TITLE="[^"]*")?' '\1 TITLE="Pron - personal pronoun"' +%!postproc(html): '(?i)(HREF="#QCl")( TITLE="[^"]*")?' '\1 TITLE="QCl - question clause, with all tenses"' +%!postproc(html): '(?i)(HREF="#QS")( TITLE="[^"]*")?' '\1 TITLE="QS - question"' +%!postproc(html): '(?i)(HREF="#Quant")( TITLE="[^"]*")?' '\1 TITLE="Quant - quantifier ('nucleus' of Det)"' +%!postproc(html): '(?i)(HREF="#RCl")( TITLE="[^"]*")?' '\1 TITLE="RCl - relative clause, with all tenses"' +%!postproc(html): '(?i)(HREF="#RP")( TITLE="[^"]*")?' '\1 TITLE="RP - relative pronoun"' +%!postproc(html): '(?i)(HREF="#RS")( TITLE="[^"]*")?' '\1 TITLE="RS - relative"' +%!postproc(html): '(?i)(HREF="#S")( TITLE="[^"]*")?' '\1 TITLE="S - declarative sentence"' +%!postproc(html): '(?i)(HREF="#SC")( TITLE="[^"]*")?' '\1 TITLE="SC - embedded sentence or question"' +%!postproc(html): '(?i)(HREF="#Subj")( TITLE="[^"]*")?' '\1 TITLE="Subj - subjunction"' +%!postproc(html): '(?i)(HREF="#Temp")( TITLE="[^"]*")?' '\1 TITLE="Temp - temporal and aspectual features"' +%!postproc(html): '(?i)(HREF="#Tense")( TITLE="[^"]*")?' '\1 TITLE="Tense - tense"' +%!postproc(html): '(?i)(HREF="#Text")( TITLE="[^"]*")?' '\1 TITLE="Text - text consisting of several phrases"' +%!postproc(html): '(?i)(HREF="#Utt")( TITLE="[^"]*")?' '\1 TITLE="Utt - sentence, question, word..."' +%!postproc(html): '(?i)(HREF="#V")( TITLE="[^"]*")?' '\1 TITLE="V - one-place verb"' +%!postproc(html): '(?i)(HREF="#V2")( TITLE="[^"]*")?' '\1 TITLE="V2 - two-place verb"' +%!postproc(html): '(?i)(HREF="#V2A")( TITLE="[^"]*")?' '\1 TITLE="V2A - verb with NP and AP complement"' +%!postproc(html): '(?i)(HREF="#V2Q")( TITLE="[^"]*")?' '\1 TITLE="V2Q - verb with NP and Q complement"' +%!postproc(html): '(?i)(HREF="#V2S")( TITLE="[^"]*")?' '\1 TITLE="V2S - verb with NP and S complement"' +%!postproc(html): '(?i)(HREF="#V2V")( TITLE="[^"]*")?' '\1 TITLE="V2V - verb with NP and V complement"' +%!postproc(html): '(?i)(HREF="#V3")( TITLE="[^"]*")?' '\1 TITLE="V3 - three-place verb"' +%!postproc(html): '(?i)(HREF="#VA")( TITLE="[^"]*")?' '\1 TITLE="VA - adjective-complement verb"' +%!postproc(html): '(?i)(HREF="#VP")( TITLE="[^"]*")?' '\1 TITLE="VP - verb phrase"' +%!postproc(html): '(?i)(HREF="#VPSlash")( TITLE="[^"]*")?' '\1 TITLE="VPSlash - verb phrase missing complement"' +%!postproc(html): '(?i)(HREF="#VQ")( TITLE="[^"]*")?' '\1 TITLE="VQ - question-complement verb"' +%!postproc(html): '(?i)(HREF="#VS")( TITLE="[^"]*")?' '\1 TITLE="VS - sentence-complement verb"' +%!postproc(html): '(?i)(HREF="#VV")( TITLE="[^"]*")?' '\1 TITLE="VV - verb-phrase-complement verb"' +%!postproc(html): '(?i)(HREF="#Voc")( TITLE="[^"]*")?' '\1 TITLE="Voc - vocative or "please""' +%!include: synopsis-intro.txt +=Categories= + + +Source 1: [``http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/abstract/Common.gf`` ../src/abstract/Common.gf] + + +Source 2: [``http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/abstract/Cat.gf`` ../src/abstract/Cat.gf] + + +==A hierarchic view== + +%!include: categories-intro.txt +==Explanations== + +|| Category | Explanation | Example || +| [A #A] | one-place adjective | //warm// | +| [A2 #A2] | two-place adjective | //divisible// | +| [AP #AP] | adjectival phrase | //very warm// | +| [AdA #AdA] | adjective-modifying adverb | //very// | +| [AdN #AdN] | numeral-modifying adverb | //more than// | +| [AdV #AdV] | adverb directly attached to verb | //always// | +| [Adv #Adv] | verb-phrase-modifying adverb | //in the house// | +| [Ant #Ant] | anteriority | simultaneous, anterior | +| [CAdv #CAdv] | comparative adverb | //more// | +| [CN #CN] | common noun (without determiner) | //red house// | +| [Card #Card] | cardinal number | //seven// | +| [Cl #Cl] | declarative clause, with all tenses | //she looks at this// | +| [Comp #Comp] | complement of copula, such as AP | //very warm// | +| [Conj #Conj] | conjunction | //and// | +| [Det #Det] | determiner phrase | //those seven// | +| [Digits #Digits] | cardinal or ordinal in digits | //1,000/1,000th// | +| [IAdv #IAdv] | interrogative adverb | //why// | +| [IComp #IComp] | interrogative complement of copula | //where// | +| [IDet #IDet] | interrogative determiner | //how many// | +| [IP #IP] | interrogative pronoun | //who// | +| [Imp #Imp] | imperative | //look at this// | +| [N #N] | common noun | //house// | +| [N2 #N2] | relational noun | //son// | +| [N3 #N3] | three-place relational noun | //connection// | +| [NP #NP] | noun phrase (subject or object) | //the red house// | +| [Num #Num] | number determining element | //seven// | +| [Numeral #Numeral] | cardinal or ordinal in words | //five/fifth// | +| [Ord #Ord] | ordinal number (used in Det) | //seventh// | +| [PConj #PConj] | phrase-beginning conjunction | //therefore// | +| [PN #PN] | proper name | //Paris// | +| [Phr #Phr] | phrase in a text | //but be quiet please// | +| [Pol #Pol] | polarity | positive, negative | +| [Predet #Predet] | predeterminer (prefixed Quant) | //all// | +| [Prep #Prep] | preposition, or just case | //in// | +| [Pron #Pron] | personal pronoun | //she// | +| [QCl #QCl] | question clause, with all tenses | //why does she walk// | +| [QS #QS] | question | //where did she live// | +| [Quant #Quant] | quantifier ('nucleus' of Det) | //this/these// | +| [RCl #RCl] | relative clause, with all tenses | //in which she lives// | +| [RP #RP] | relative pronoun | //in which// | +| [RS #RS] | relative | //in which she lived// | +| [S #S] | declarative sentence | //she lived here// | +| [SC #SC] | embedded sentence or question | //that it rains// | +| [Subj #Subj] | subjunction | //if// | +| [Temp #Temp] | temporal and aspectual features | past anterior | +| [Tense #Tense] | tense | present, past, future | +| [Text #Text] | text consisting of several phrases | //He is here. Why?// | +| [Utt #Utt] | sentence, question, word... | //be quiet// | +| [V #V] | one-place verb | //sleep// | +| [V2 #V2] | two-place verb | //love// | +| [V2A #V2A] | verb with NP and AP complement | //paint// | +| [V2Q #V2Q] | verb with NP and Q complement | //ask// | +| [V2S #V2S] | verb with NP and S complement | //tell// | +| [V2V #V2V] | verb with NP and V complement | //cause// | +| [V3 #V3] | three-place verb | //show// | +| [VA #VA] | adjective-complement verb | //look// | +| [VP #VP] | verb phrase | //is very warm// | +| [VPSlash #VPSlash] | verb phrase missing complement | //give to John// | +| [VQ #VQ] | question-complement verb | //wonder// | +| [VS #VS] | sentence-complement verb | //claim// | +| [VV #VV] | verb-phrase-complement verb | //want// | +| [Voc #Voc] | vocative or "please" | //my darling// | + + +=Syntax Rules and Structural Words= + + +Source 1: [``http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/api/Constructors.gf`` ../src/api/Constructors.gf] + + +Source 2: [``http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/abstract/Structural.gf`` ../src/abstract/Structural.gf] + + +==A - one-place adjective==[A] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==A2 - two-place adjective==[A2] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==AP - adjectival phrase==[AP] +|| Function | Type | Example || +| ``comparAP`` | [A #A] ``->`` [AP #AP] | //warmer// | +| ``mkAP`` | [A #A] ``->`` [AP #AP] | //old// | +| ``mkAP`` | [A #A] ``->`` [NP #NP] ``->`` [AP #AP] | //older than John// | +| ``mkAP`` | [A2 #A2] ``->`` [NP #NP] ``->`` [AP #AP] | //married to her// | +| ``mkAP`` | [A2 #A2] ``->`` [AP #AP] | //married// | +| ``mkAP`` | [AP #AP] ``->`` [S #S] ``->`` [AP #AP] | //probable that John walks// | +| ``mkAP`` | [AP #AP] ``->`` [QS #QS] ``->`` [AP #AP] | //uncertain if John walks// | +| ``mkAP`` | [AP #AP] ``->`` [VP #VP] ``->`` [AP #AP] | //ready to go// | +| ``mkAP`` | [AdA #AdA] ``->`` [A #A] ``->`` [AP #AP] | //very old// | +| ``mkAP`` | [AdA #AdA] ``->`` [AP #AP] ``->`` [AP #AP] | //very very old// | +| ``mkAP`` | [Conj #Conj] ``->`` [AP #AP] ``->`` [AP #AP] ``->`` [AP #AP] | //old and big// | +| ``mkAP`` | [Conj #Conj] ``->`` [ListAP #ListAP] ``->`` [AP #AP] | //old, big, and warm// | +| ``mkAP`` | [Ord #Ord] ``->`` [AP #AP] | //oldest// | +| ``mkAP`` | [CAdv #CAdv] ``->`` [AP #AP] ``->`` [NP #NP] ``->`` [AP #AP] | //as old as John// | +| ``reflAP`` | [A2 #A2] ``->`` [AP #AP] | //married to himself// | +==AdA - adjective-modifying adverb==[AdA] +|| Function | Type | Example || +| ``almost_AdA`` | [AdA #AdA] | //almost// | +| ``quite_Adv`` | [AdA #AdA] | //quite// | +| ``so_AdA`` | [AdA #AdA] | //so// | +| ``too_AdA`` | [AdA #AdA] | //too// | +| ``very_AdA`` | [AdA #AdA] | //very// | +==AdN - numeral-modifying adverb==[AdN] +|| Function | Type | Example || +| ``almost_AdN`` | [AdN #AdN] | //almost// | +| ``at_least_AdN`` | [AdN #AdN] | //at// | +| ``at_most_AdN`` | [AdN #AdN] | //at// | +| ``mkAdN`` | [CAdv #CAdv] ``->`` [AdN #AdN] | //more than// | +==AdV - adverb directly attached to verb==[AdV] +|| Function | Type | Example || +| ``always_AdV`` | [AdV #AdV] | //always// | +==Adv - verb-phrase-modifying adverb==[Adv] +|| Function | Type | Example || +| ``everywhere_Adv`` | [Adv #Adv] | //everywhere// | +| ``here7from_Adv`` | [Adv #Adv] | //from here// | +| ``here7to_Adv`` | [Adv #Adv] | //to here// | +| ``here_Adv`` | [Adv #Adv] | //here// | +| ``mkAdv`` | [A #A] ``->`` [Adv #Adv] | //warmly// | +| ``mkAdv`` | [Prep #Prep] ``->`` [NP #NP] ``->`` [Adv #Adv] | //with John// | +| ``mkAdv`` | [Subj #Subj] ``->`` [S #S] ``->`` [Adv #Adv] | //when John walks// | +| ``mkAdv`` | [CAdv #CAdv] ``->`` [A #A] ``->`` [NP #NP] ``->`` [Adv #Adv] | //more warmly than John// | +| ``mkAdv`` | [CAdv #CAdv] ``->`` [A #A] ``->`` [S #S] ``->`` [Adv #Adv] | //more warmly than John walks// | +| ``mkAdv`` | [AdA #AdA] ``->`` [Adv #Adv] ``->`` [Adv #Adv] | //very warmly// | +| ``mkAdv`` | [Conj #Conj] ``->`` [Adv #Adv] ``->`` [Adv #Adv] ``->`` [Adv #Adv] | //here and now// | +| ``mkAdv`` | [Conj #Conj] ``->`` [ListAdv #ListAdv] ``->`` [Adv #Adv] | //with John, here and now// | +| ``somewhere_Adv`` | [Adv #Adv] | //somewhere// | +| ``there7from_Adv`` | [Adv #Adv] | //from there// | +| ``there7to_Adv`` | [Adv #Adv] | //to there// | +| ``there_Adv`` | [Adv #Adv] | //there// | +==Ant - anteriority==[Ant] +|| Function | Type | Example || +| ``anteriorAnt`` | [Ant #Ant] | //(John has walked)// | +| ``simultaneousAnt`` | [Ant #Ant] | //(John walks) [default]// | +==CAdv - comparative adverb==[CAdv] +|| Function | Type | Example || +| ``as_CAdv`` | [CAdv #CAdv] | //as// | +| ``less_CAdv`` | [CAdv #CAdv] | //less// | +| ``more_CAdv`` | [CAdv #CAdv] | //more// | +==CN - common noun (without determiner)==[CN] +|| Function | Type | Example || +| ``mkCN`` | [N #N] ``->`` [CN #CN] | //house// | +| ``mkCN`` | [N2 #N2] ``->`` [NP #NP] ``->`` [CN #CN] | //mother of John// | +| ``mkCN`` | [N3 #N3] ``->`` [NP #NP] ``->`` [NP #NP] ``->`` [CN #CN] | //distance from this city to Paris// | +| ``mkCN`` | [N2 #N2] ``->`` [CN #CN] | //son// | +| ``mkCN`` | [N3 #N3] ``->`` [CN #CN] | //flight// | +| ``mkCN`` | [A #A] ``->`` [N #N] ``->`` [CN #CN] | //big house// | +| ``mkCN`` | [A #A] ``->`` [CN #CN] ``->`` [CN #CN] | //big blue house// | +| ``mkCN`` | [AP #AP] ``->`` [N #N] ``->`` [CN #CN] | //very big house// | +| ``mkCN`` | [AP #AP] ``->`` [CN #CN] ``->`` [CN #CN] | //very big blue house// | +| ``mkCN`` | [N #N] ``->`` [RS #RS] ``->`` [CN #CN] | //house that John loves// | +| ``mkCN`` | [CN #CN] ``->`` [RS #RS] ``->`` [CN #CN] | //big house that John loves// | +| ``mkCN`` | [N #N] ``->`` [Adv #Adv] ``->`` [CN #CN] | //house in the city// | +| ``mkCN`` | [CN #CN] ``->`` [Adv #Adv] ``->`` [CN #CN] | //big house in the city// | +| ``mkCN`` | [CN #CN] ``->`` [S #S] ``->`` [CN #CN] | //rule that John walks// | +| ``mkCN`` | [CN #CN] ``->`` [QS #QS] ``->`` [CN #CN] | //question if John walks// | +| ``mkCN`` | [CN #CN] ``->`` [VP #VP] ``->`` [CN #CN] | //reason to walk// | +| ``mkCN`` | [N #N] ``->`` [NP #NP] ``->`` [CN #CN] | //king John// | +| ``mkCN`` | [CN #CN] ``->`` [NP #NP] ``->`` [CN #CN] | //old king John// | +==Card - cardinal number==[Card] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==Cl - declarative clause, with all tenses==[Cl] +|| Function | Type | Example || +| ``genericCl`` | [VP #VP] ``->`` [Cl #Cl] | //one walks// | +| ``mkCl`` | [NP #NP] ``->`` [V #V] ``->`` [Cl #Cl] | //John walks// | +| ``mkCl`` | [NP #NP] ``->`` [V2 #V2] ``->`` [NP #NP] ``->`` [Cl #Cl] | //John loves her// | +| ``mkCl`` | [NP #NP] ``->`` [V3 #V3] ``->`` [NP #NP] ``->`` [NP #NP] ``->`` [Cl #Cl] | //John sends it to her// | +| ``mkCl`` | [NP #NP] ``->`` [VV #VV] ``->`` [VP #VP] ``->`` [Cl #Cl] | //John wants to walk// | +| ``mkCl`` | [NP #NP] ``->`` [VS #VS] ``->`` [S #S] ``->`` [Cl #Cl] | //John says that it is good// | +| ``mkCl`` | [NP #NP] ``->`` [VQ #VQ] ``->`` [QS #QS] ``->`` [Cl #Cl] | //John wonders if it is good// | +| ``mkCl`` | [NP #NP] ``->`` [VA #VA] ``->`` [AP #AP] ``->`` [Cl #Cl] | //John becomes old// | +| ``mkCl`` | [NP #NP] ``->`` [V2A #V2A] ``->`` [NP #NP] ``->`` [AP #AP] ``->`` [Cl #Cl] | //John paints it red// | +| ``mkCl`` | [NP #NP] ``->`` [V2S #V2S] ``->`` [NP #NP] ``->`` [S #S] ``->`` [Cl #Cl] | //John tells her that we are here// | +| ``mkCl`` | [NP #NP] ``->`` [V2Q #V2Q] ``->`` [NP #NP] ``->`` [QS #QS] ``->`` [Cl #Cl] | //John asks her who is here// | +| ``mkCl`` | [NP #NP] ``->`` [V2V #V2V] ``->`` [NP #NP] ``->`` [VP #VP] ``->`` [Cl #Cl] | //John forces us to sleep// | +| ``mkCl`` | [NP #NP] ``->`` [A #A] ``->`` [Cl #Cl] | //John is old// | +| ``mkCl`` | [NP #NP] ``->`` [A #A] ``->`` [NP #NP] ``->`` [Cl #Cl] | //John is older than her// | +| ``mkCl`` | [NP #NP] ``->`` [A2 #A2] ``->`` [NP #NP] ``->`` [Cl #Cl] | //John is married to her// | +| ``mkCl`` | [NP #NP] ``->`` [AP #AP] ``->`` [Cl #Cl] | //John is very old// | +| ``mkCl`` | [NP #NP] ``->`` [N #N] ``->`` [Cl #Cl] | //John is a man// | +| ``mkCl`` | [NP #NP] ``->`` [CN #CN] ``->`` [Cl #Cl] | //John is an old man// | +| ``mkCl`` | [NP #NP] ``->`` [NP #NP] ``->`` [Cl #Cl] | //John is the man// | +| ``mkCl`` | [NP #NP] ``->`` [Adv #Adv] ``->`` [Cl #Cl] | //John is here// | +| ``mkCl`` | [NP #NP] ``->`` [VP #VP] ``->`` [Cl #Cl] | //John walks here// | +| ``mkCl`` | [V #V] ``->`` [Cl #Cl] | //it rains// | +| ``mkCl`` | [VP #VP] ``->`` [Cl #Cl] | //it is raining// | +| ``mkCl`` | [N #N] ``->`` [Cl #Cl] | //there is a house// | +| ``mkCl`` | [CN #CN] ``->`` [Cl #Cl] | //there is an old houses// | +| ``mkCl`` | [NP #NP] ``->`` [Cl #Cl] | //there are five houses// | +| ``mkCl`` | [NP #NP] ``->`` [RS #RS] ``->`` [Cl #Cl] | //it is John that walks// | +| ``mkCl`` | [Adv #Adv] ``->`` [S #S] ``->`` [Cl #Cl] | //it is here John walks// | +==ClSlash==[ClSlash] +|| Function | Type | Example || +| ``mkClSlash`` | [NP #NP] ``->`` [V2 #V2] ``->`` [ClSlash #ClSlash] | //(whom) John loves// | +| ``mkClSlash`` | [NP #NP] ``->`` [VV #VV] ``->`` [V2 #V2] ``->`` [ClSlash #ClSlash] | //(whom) John wants to see// | +| ``mkClSlash`` | [Cl #Cl] ``->`` [Prep #Prep] ``->`` [ClSlash #ClSlash] | //(with whom) John walks// | +| ``mkClSlash`` | [ClSlash #ClSlash] ``->`` [Adv #Adv] ``->`` [ClSlash #ClSlash] | //(whom) John loves today// | +==Comp - complement of copula, such as AP==[Comp] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==Conj - conjunction==[Conj] +|| Function | Type | Example || +| ``and_Conj`` | [Conj #Conj] | //and// | +| ``both7and_DConj`` | [Conj #Conj] | //both...and// | +| ``either7or_DConj`` | [Conj #Conj] | //either...or// | +| ``if_then_Conj`` | [Conj #Conj] | //if// | +| ``or_Conj`` | [Conj #Conj] | //or// | +==Det - determiner phrase==[Det] +|| Function | Type | Example || +| ``every_Det`` | [Det #Det] | //every// | +| ``few_Det`` | [Det #Det] | //few// | +| ``many_Det`` | [Det #Det] | //many// | +| ``mkDet`` | [Quant #Quant] ``->`` [Det #Det] | //this// | +| ``mkDet`` | [Quant #Quant] ``->`` ([Ord #Ord]) ``->`` [Det #Det] | //this first// | +| ``mkDet`` | [Quant #Quant] ``->`` [Num #Num] ``->`` [Det #Det] | //these// | +| ``mkDet`` | [Quant #Quant] ``->`` [Num #Num] ``->`` ([Ord #Ord]) ``->`` [Det #Det] | //these five best// | +| ``mkDet`` | [Quant #Quant] ``->`` [Det #Det] | //this// | +| ``mkDet`` | [Quant #Quant] ``->`` [Num #Num] ``->`` [Det #Det] | //these five// | +| ``mkDet`` | [Card #Card] ``->`` [Det #Det] | //almost twenty// | +| ``mkDet`` | [Numeral #Numeral] ``->`` [Det #Det] | //five// | +| ``mkDet`` | [Digits #Digits] ``->`` [Det #Det] | //51// | +| ``mkDet`` | [Pron #Pron] ``->`` [Det #Det] | //my (house)// | +| ``mkDet`` | [Pron #Pron] ``->`` [Num #Num] ``->`` [Det #Det] | //my (houses)// | +| ``much_Det`` | [Det #Det] | //much// | +| ``somePl_Det`` | [Det #Det] | //somePl// | +| ``someSg_Det`` | [Det #Det] | //someSg// | +==Dig==[Dig] +|| Function | Type | Example || +| ``n0_Dig`` | [Dig #Dig] | //0// | +| ``n1_Dig`` | [Dig #Dig] | //1// | +| ``n2_Dig`` | [Dig #Dig] | //2// | +| ``n3_Dig`` | [Dig #Dig] | //3// | +| ``n4_Dig`` | [Dig #Dig] | //4// | +| ``n5_Dig`` | [Dig #Dig] | //5// | +| ``n6_Dig`` | [Dig #Dig] | //6// | +| ``n7_Dig`` | [Dig #Dig] | //7// | +| ``n8_Dig`` | [Dig #Dig] | //8// | +| ``n9_Dig`` | [Dig #Dig] | //9// | +==Digits - cardinal or ordinal in digits==[Digits] +|| Function | Type | Example || +| ``mkDigits`` | [Dig #Dig] ``->`` [Digits #Digits] | //8// | +| ``mkDigits`` | [Dig #Dig] ``->`` [Digits #Digits] ``->`` [Digits #Digits] | //876// | +| ``n1000_Digits`` | [Digits #Digits] | //1,000// | +| ``n100_Digits`` | [Digits #Digits] | //100// | +| ``n10_Digits`` | [Digits #Digits] | //10// | +| ``n1_Digits`` | [Digits #Digits] | //1// | +| ``n20_Digits`` | [Digits #Digits] | //20// | +| ``n2_Digits`` | [Digits #Digits] | //2// | +| ``n3_Digits`` | [Digits #Digits] | //3// | +| ``n4_Digits`` | [Digits #Digits] | //4// | +| ``n5_Digits`` | [Digits #Digits] | //5// | +| ``n6_Digits`` | [Digits #Digits] | //6// | +| ``n7_Digits`` | [Digits #Digits] | //7// | +| ``n8_Digits`` | [Digits #Digits] | //8// | +| ``n9_Digits`` | [Digits #Digits] | //9// | +==IAdv - interrogative adverb==[IAdv] +|| Function | Type | Example || +| ``how_IAdv`` | [IAdv #IAdv] | //how// | +| ``mkIAdv`` | [Prep #Prep] ``->`` [IP #IP] ``->`` [IAdv #IAdv] | //in which city// | +| ``when_IAdv`` | [IAdv #IAdv] | //when// | +| ``where_IAdv`` | [IAdv #IAdv] | //where// | +| ``why_IAdv`` | [IAdv #IAdv] | //why// | +==IComp - interrogative complement of copula==[IComp] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==IDet - interrogative determiner==[IDet] +|| Function | Type | Example || +| ``how8many_IDet`` | [IDet #IDet] | //how8many// | +==IP - interrogative pronoun==[IP] +|| Function | Type | Example || +| ``mkIP`` | [IQuant #IQuant] ``->`` [N #N] ``->`` [IP #IP] | //which city// | +| ``mkIP`` | [IQuant #IQuant] ``->`` ([Num #Num]) ``->`` [CN #CN] ``->`` [IP #IP] | //which five big cities// | +| ``mkIP`` | [IP #IP] ``->`` [Adv #Adv] ``->`` [IP #IP] | //who in Paris// | +| ``whatPl_IP`` | [IP #IP] | //what (plural)// | +| ``whatSg_IP`` | [IP #IP] | //what (singular)// | +| ``whoPl_IP`` | [IP #IP] | //who (plural)// | +| ``whoSg_IP`` | [IP #IP] | //who (singular)// | +==IQuant==[IQuant] +|| Function | Type | Example || +| ``which_IQuant`` | [IQuant #IQuant] | //which// | +==Imp - imperative==[Imp] +|| Function | Type | Example || +| ``mkImp`` | [V #V] ``->`` [Imp #Imp] | //go// | +| ``mkImp`` | [V2 #V2] ``->`` [NP #NP] ``->`` [Imp #Imp] | //take it// | +| ``mkImp`` | [VP #VP] ``->`` [Imp #Imp] | //go there now// | +==ImpForm==[ImpForm] +|| Function | Type | Example || +| ``pluralImpForm`` | [ImpForm #ImpForm] | //(help yourselves)// | +| ``politeImpForm`` | [ImpForm #ImpForm] | //(help yourself) (polite singular)// | +| ``singularImpForm`` | [ImpForm #ImpForm] | //(help yourself) [default]// | +==ListAP==[ListAP] +|| Function | Type | Example || +| ``mkListAP`` | [AP #AP] ``->`` [AP #AP] ``->`` [ListAP #ListAP] | //old, big// | +| ``mkListAP`` | [AP #AP] ``->`` [ListAP #ListAP] ``->`` [ListAP #ListAP] | //old, big, warm// | +==ListAdv==[ListAdv] +|| Function | Type | Example || +| ``mkListAdv`` | [Adv #Adv] ``->`` [Adv #Adv] ``->`` [ListAdv #ListAdv] | //here, now// | +| ``mkListAdv`` | [Adv #Adv] ``->`` [ListAdv #ListAdv] ``->`` [ListAdv #ListAdv] | //to me, here, now// | +==ListNP==[ListNP] +|| Function | Type | Example || +| ``mkListNP`` | [NP #NP] ``->`` [NP #NP] ``->`` [ListNP #ListNP] | //John, I// | +| ``mkListNP`` | [NP #NP] ``->`` [ListNP #ListNP] ``->`` [ListNP #ListNP] | //John, I, that// | +==ListRS==[ListRS] +|| Function | Type | Example || +| ``mkListRS`` | [RS #RS] ``->`` [RS #RS] ``->`` [ListRS #ListRS] | //who walks, who runs// | +| ``mkListRS`` | [RS #RS] ``->`` [ListRS #ListRS] ``->`` [ListRS #ListRS] | //who walks, who runs, who sleeps// | +==ListS==[ListS] +|| Function | Type | Example || +| ``mkListS`` | [S #S] ``->`` [S #S] ``->`` [ListS #ListS] | //he walks, I run// | +| ``mkListS`` | [S #S] ``->`` [ListS #ListS] ``->`` [ListS #ListS] | //John walks, I run, you sleep// | +==N - common noun==[N] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==N2 - relational noun==[N2] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==N3 - three-place relational noun==[N3] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==NP - noun phrase (subject or object)==[NP] +|| Function | Type | Example || +| ``everybody_NP`` | [NP #NP] | //everybody// | +| ``everything_NP`` | [NP #NP] | //everything// | +| ``mkNP`` | [Quant #Quant] ``->`` [N #N] ``->`` [NP #NP] | //this men// | +| ``mkNP`` | [Quant #Quant] ``->`` ([Num #Num]) ``->`` [CN #CN] ``->`` [NP #NP] | //these five old men// | +| ``mkNP`` | [Det #Det] ``->`` [N #N] ``->`` [NP #NP] | //the first man// | +| ``mkNP`` | [Det #Det] ``->`` [CN #CN] ``->`` [NP #NP] | //the first old man// | +| ``mkNP`` | [Numeral #Numeral] ``->`` [N #N] ``->`` [NP #NP] | //twenty men// | +| ``mkNP`` | [Numeral #Numeral] ``->`` [CN #CN] ``->`` [NP #NP] | //twenty old men// | +| ``mkNP`` | [Digits #Digits] ``->`` [N #N] ``->`` [NP #NP] | //45 men// | +| ``mkNP`` | [Digits #Digits] ``->`` [CN #CN] ``->`` [NP #NP] | //45 old men// | +| ``mkNP`` | [Card #Card] ``->`` [N #N] ``->`` [NP #NP] | //almost twenty men// | +| ``mkNP`` | [Card #Card] ``->`` [CN #CN] ``->`` [NP #NP] | //almost twenty old men// | +| ``mkNP`` | [Pron #Pron] ``->`` [N #N] ``->`` [NP #NP] | //my man// | +| ``mkNP`` | [Pron #Pron] ``->`` [CN #CN] ``->`` [NP #NP] | //my old man// | +| ``mkNP`` | [PN #PN] ``->`` [NP #NP] | //John// | +| ``mkNP`` | [Pron #Pron] ``->`` [NP #NP] | //he// | +| ``mkNP`` | [Quant #Quant] ``->`` [NP #NP] | //this// | +| ``mkNP`` | [Det #Det] ``->`` [NP #NP] | //these five// | +| ``mkNP`` | [N #N] ``->`` [NP #NP] | //beer// | +| ``mkNP`` | [CN #CN] ``->`` [NP #NP] | //beer// | +| ``mkNP`` | [Predet #Predet] ``->`` [NP #NP] ``->`` [NP #NP] | //only John// | +| ``mkNP`` | [NP #NP] ``->`` [V2 #V2] ``->`` [NP #NP] | //John killed// | +| ``mkNP`` | [NP #NP] ``->`` [Adv #Adv] ``->`` [NP #NP] | //John in Paris// | +| ``mkNP`` | [NP #NP] ``->`` [RS #RS] ``->`` [NP #NP] | //John, who lives in Paris// | +| ``mkNP`` | [Conj #Conj] ``->`` [NP #NP] ``->`` [NP #NP] ``->`` [NP #NP] | //John and I// | +| ``mkNP`` | [Conj #Conj] ``->`` [ListNP #ListNP] ``->`` [NP #NP] | //John, I, and that// | +| ``nobody_NP`` | [NP #NP] | //nobody// | +| ``nothing_NP`` | [NP #NP] | //nothing// | +| ``somebody_NP`` | [NP #NP] | //somebody// | +| ``something_NP`` | [NP #NP] | //something// | +==Num - number determining element==[Num] +|| Function | Type | Example || +| ``mkNum`` | [Numeral #Numeral] ``->`` [Num #Num] | //twenty// | +| ``mkNum`` | [Digits #Digits] ``->`` [Num #Num] | //51// | +| ``mkNum`` | [Card #Card] ``->`` [Num #Num] | //almost ten// | +| ``mkNum`` | [AdN #AdN] ``->`` [Card #Card] ``->`` [Num #Num] | //almost ten// | +| ``plNum`` | [Num #Num] | //plural// | +| ``sgNum`` | [Num #Num] | //singular// | +==Numeral - cardinal or ordinal in words==[Numeral] +|| Function | Type | Example || +| ``n1000_Numeral`` | [Numeral #Numeral] | //thousand// | +| ``n100_Numeral`` | [Numeral #Numeral] | //hundred// | +| ``n10_Numeral`` | [Numeral #Numeral] | //ten// | +| ``n1_Numeral`` | [Numeral #Numeral] | //one// | +| ``n20_Numeral`` | [Numeral #Numeral] | //twenty// | +| ``n2_Numeral`` | [Numeral #Numeral] | //two// | +| ``n3_Numeral`` | [Numeral #Numeral] | //three// | +| ``n4_Numeral`` | [Numeral #Numeral] | //four// | +| ``n5_Numeral`` | [Numeral #Numeral] | //five// | +| ``n6_Numeral`` | [Numeral #Numeral] | //six// | +| ``n7_Numeral`` | [Numeral #Numeral] | //seven// | +| ``n8_Numeral`` | [Numeral #Numeral] | //eight// | +| ``n9_Numeral`` | [Numeral #Numeral] | //nine// | +==Ord - ordinal number (used in Det)==[Ord] +|| Function | Type | Example || +| ``mkOrd`` | [Numeral #Numeral] ``->`` [Ord #Ord] | //twentieth// | +| ``mkOrd`` | [Digits #Digits] ``->`` [Ord #Ord] | //51st// | +| ``mkOrd`` | [A #A] ``->`` [Ord #Ord] | //best// | +==PConj - phrase-beginning conjunction==[PConj] +|| Function | Type | Example || +| ``but_PConj`` | [PConj #PConj] | //but// | +| ``mkPConj`` | [Conj #Conj] ``->`` [PConj #PConj] | //and// | +| ``otherwise_PConj`` | [PConj #PConj] | //otherwise// | +| ``therefore_PConj`` | [PConj #PConj] | //therefore// | +==PN - proper name==[PN] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==Phr - phrase in a text==[Phr] +|| Function | Type | Example || +| ``mkPhr`` | [Utt #Utt] ``->`` [Phr #Phr] | //why// | +| ``mkPhr`` | ([PConj #PConj]) ``->`` [Utt #Utt] ``->`` ([Voc #Voc]) ``->`` [Phr #Phr] | //but why John// | +| ``mkPhr`` | [S #S] ``->`` [Phr #Phr] | //John walked// | +| ``mkPhr`` | [Cl #Cl] ``->`` [Phr #Phr] | //John walks// | +| ``mkPhr`` | [QS #QS] ``->`` [Phr #Phr] | //did John walk// | +| ``mkPhr`` | [Imp #Imp] ``->`` [Phr #Phr] | //walk// | +==Pol - polarity==[Pol] +|| Function | Type | Example || +| ``negativePol`` | [Pol #Pol] | //(John doesn't walk)// | +| ``positivePol`` | [Pol #Pol] | //(John walks) [default]// | +==Predet - predeterminer (prefixed Quant)==[Predet] +|| Function | Type | Example || +| ``all_Predet`` | [Predet #Predet] | //all// | +| ``most_Predet`` | [Predet #Predet] | //most// | +| ``not_Predet`` | [Predet #Predet] | //not// | +| ``only_Predet`` | [Predet #Predet] | //only// | +==Prep - preposition, or just case==[Prep] +|| Function | Type | Example || +| ``above_Prep`` | [Prep #Prep] | //above// | +| ``after_Prep`` | [Prep #Prep] | //after// | +| ``before_Prep`` | [Prep #Prep] | //before// | +| ``behind_Prep`` | [Prep #Prep] | //behind// | +| ``between_Prep`` | [Prep #Prep] | //between// | +| ``by8agent_Prep`` | [Prep #Prep] | //by (agent)// | +| ``by8means_Prep`` | [Prep #Prep] | //by (means of)// | +| ``during_Prep`` | [Prep #Prep] | //during// | +| ``except_Prep`` | [Prep #Prep] | //except// | +| ``for_Prep`` | [Prep #Prep] | //for// | +| ``from_Prep`` | [Prep #Prep] | //from// | +| ``in8front_Prep`` | [Prep #Prep] | //in front of// | +| ``in_Prep`` | [Prep #Prep] | //in// | +| ``on_Prep`` | [Prep #Prep] | //on// | +| ``part_Prep`` | [Prep #Prep] | //part// | +| ``possess_Prep`` | [Prep #Prep] | //of (possessive)// | +| ``through_Prep`` | [Prep #Prep] | //through// | +| ``to_Prep`` | [Prep #Prep] | //to// | +| ``under_Prep`` | [Prep #Prep] | //under// | +| ``with_Prep`` | [Prep #Prep] | //with// | +| ``without_Prep`` | [Prep #Prep] | //without// | +==Pron - personal pronoun==[Pron] +|| Function | Type | Example || +| ``he_Pron`` | [Pron #Pron] | //he// | +| ``i_Pron`` | [Pron #Pron] | //i// | +| ``it_Pron`` | [Pron #Pron] | //it// | +| ``she_Pron`` | [Pron #Pron] | //she// | +| ``they_Pron`` | [Pron #Pron] | //they// | +| ``we_Pron`` | [Pron #Pron] | //we// | +| ``youPl_Pron`` | [Pron #Pron] | //you (plural)// | +| ``youPol_Pron`` | [Pron #Pron] | //you (polite)// | +| ``youSg_Pron`` | [Pron #Pron] | //you (singular)// | +==Punct==[Punct] +|| Function | Type | Example || +| ``exclMarkPunct`` | [Punct #Punct] | //!// | +| ``fullStopPunct`` | [Punct #Punct] | //.// | +| ``questMarkPunct`` | [Punct #Punct] | //?// | +==QCl - question clause, with all tenses==[QCl] +|| Function | Type | Example || +| ``mkQCl`` | [Cl #Cl] ``->`` [QCl #QCl] | //does John walk// | +| ``mkQCl`` | [IP #IP] ``->`` [VP #VP] ``->`` [QCl #QCl] | //who walks// | +| ``mkQCl`` | [IP #IP] ``->`` [NP #NP] ``->`` [V2 #V2] ``->`` [QCl #QCl] | //whom does John love// | +| ``mkQCl`` | [IP #IP] ``->`` [ClSlash #ClSlash] ``->`` [QCl #QCl] | //whom does John love today// | +| ``mkQCl`` | [IAdv #IAdv] ``->`` [Cl #Cl] ``->`` [QCl #QCl] | //why does John walk// | +| ``mkQCl`` | [Prep #Prep] ``->`` [IP #IP] ``->`` [Cl #Cl] ``->`` [QCl #QCl] | //with who does John walk// | +| ``mkQCl`` | [IAdv #IAdv] ``->`` [NP #NP] ``->`` [QCl #QCl] | //where is John// | +| ``mkQCl`` | [IP #IP] ``->`` [QCl #QCl] | //what is there// | +==QS - question==[QS] +|| Function | Type | Example || +| ``mkQS`` | [QCl #QCl] ``->`` [QS #QS] | //who walks// | +| ``mkQS`` | ([Tense #Tense]) ``->`` ([Ant #Ant]) ``->`` ([Pol #Pol]) ``->`` [QCl #QCl] ``->`` [QS #QS] | //who wouldn't have walked// | +| ``mkQS`` | [Cl #Cl] ``->`` [QS #QS] | //does John walk// | +==Quant - quantifier ('nucleus' of Det)==[Quant] +|| Function | Type | Example || +| ``a_Quant`` | [Quant #Quant] | //a// | +| ``no_Quant`` | [Quant #Quant] | //no// | +| ``that_Quant`` | [Quant #Quant] | //that// | +| ``the_Quant`` | [Quant #Quant] | //the// | +| ``this_Quant`` | [Quant #Quant] | //this// | +==RCl - relative clause, with all tenses==[RCl] +|| Function | Type | Example || +| ``mkRCl`` | [RP #RP] ``->`` [VP #VP] ``->`` [RCl #RCl] | //that walk// | +| ``mkRCl`` | [RP #RP] ``->`` [NP #NP] ``->`` [V2 #V2] ``->`` [RCl #RCl] | //which John loves// | +| ``mkRCl`` | [RP #RP] ``->`` [ClSlash #ClSlash] ``->`` [RCl #RCl] | //which John loves today// | +| ``mkRCl`` | [Cl #Cl] ``->`` [RCl #RCl] | //such that John loves her// | +==RP - relative pronoun==[RP] +|| Function | Type | Example || +| ``mkRP`` | [Prep #Prep] ``->`` [NP #NP] ``->`` [RP #RP] ``->`` [RP #RP] | //all the houses in which// | +| ``which_RP`` | [RP #RP] | //which// | +==RS - relative==[RS] +|| Function | Type | Example || +| ``mkRS`` | [RCl #RCl] ``->`` [RS #RS] | //that walk// | +| ``mkRS`` | ([Tense #Tense]) ``->`` ([Ant #Ant]) ``->`` ([Pol #Pol]) ``->`` [RCl #RCl] ``->`` [RS #RS] | //that wouldn't have walked// | +| ``mkRS`` | [Conj #Conj] ``->`` [RS #RS] ``->`` [RS #RS] ``->`` [RS #RS] | //who walks and whom I know// | +| ``mkRS`` | [Conj #Conj] ``->`` [ListRS #ListRS] ``->`` [RS #RS] | //who walks, whose son runs, and whom I know// | +==S - declarative sentence==[S] +|| Function | Type | Example || +| ``mkS`` | [Cl #Cl] ``->`` [S #S] | //John walks// | +| ``mkS`` | ([Tense #Tense]) ``->`` ([Ant #Ant]) ``->`` ([Pol #Pol]) ``->`` [Cl #Cl] ``->`` [S #S] | //John wouldn't have walked// | +| ``mkS`` | [Conj #Conj] ``->`` [S #S] ``->`` [S #S] ``->`` [S #S] | //John walks and I run// | +| ``mkS`` | [Conj #Conj] ``->`` [ListS #ListS] ``->`` [S #S] | //John walks, I run and you sleep// | +| ``mkS`` | [Adv #Adv] ``->`` [S #S] ``->`` [S #S] | //today, John walks// | +==SC - embedded sentence or question==[SC] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==Subj - subjunction==[Subj] +|| Function | Type | Example || +| ``although_Subj`` | [Subj #Subj] | //although// | +| ``because_Subj`` | [Subj #Subj] | //because// | +| ``if_Subj`` | [Subj #Subj] | //if// | +| ``when_Subj`` | [Subj #Subj] | //when// | +==Temp - temporal and aspectual features==[Temp] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==Tense - tense==[Tense] +|| Function | Type | Example || +| ``conditionalTense`` | [Tense #Tense] | //(John would walk)// | +| ``futureTense`` | [Tense #Tense] | //(John will walk)// | +| ``pastTense`` | [Tense #Tense] | //(John walked)// | +| ``presentTense`` | [Tense #Tense] | //(John walks) [default]// | +==Text - text consisting of several phrases==[Text] +|| Function | Type | Example || +| ``emptyText`` | [Text #Text] | //(empty text)// | +| ``mkText`` | [Phr #Phr] ``->`` [Text #Text] | //But John walks.// | +| ``mkText`` | [Phr #Phr] ``->`` ([Punct #Punct]) ``->`` ([Text #Text]) ``->`` [Text #Text] | //John walks? Yes.// | +| ``mkText`` | [Utt #Utt] ``->`` [Text #Text] | //John.// | +| ``mkText`` | [S #S] ``->`` [Text #Text] | //John walked.// | +| ``mkText`` | [Cl #Cl] ``->`` [Text #Text] | //John walks.// | +| ``mkText`` | [QS #QS] ``->`` [Text #Text] | //Did John walk?// | +| ``mkText`` | [Imp #Imp] ``->`` [Text #Text] | //Walk!// | +| ``mkText`` | [Text #Text] ``->`` [Text #Text] ``->`` [Text #Text] | //Where? When? Here. Now!// | +==Utt - sentence, question, word...==[Utt] +|| Function | Type | Example || +| ``lets_Utt`` | [VP #VP] ``->`` [Utt #Utt] | //let's walk// | +| ``mkUtt`` | [S #S] ``->`` [Utt #Utt] | //John walked// | +| ``mkUtt`` | [Cl #Cl] ``->`` [Utt #Utt] | //John walks// | +| ``mkUtt`` | [QS #QS] ``->`` [Utt #Utt] | //did John walk// | +| ``mkUtt`` | [QCl #QCl] ``->`` [Utt #Utt] | //does John walk// | +| ``mkUtt`` | [Imp #Imp] ``->`` [Utt #Utt] | //love yourself// | +| ``mkUtt`` | ([ImpForm #ImpForm]) ``->`` ([Pol #Pol]) ``->`` [Imp #Imp] ``->`` [Utt #Utt] | //don't love yourselves// | +| ``mkUtt`` | [IP #IP] ``->`` [Utt #Utt] | //who// | +| ``mkUtt`` | [IAdv #IAdv] ``->`` [Utt #Utt] | //why// | +| ``mkUtt`` | [NP #NP] ``->`` [Utt #Utt] | //John// | +| ``mkUtt`` | [Adv #Adv] ``->`` [Utt #Utt] | //here// | +| ``mkUtt`` | [VP #VP] ``->`` [Utt #Utt] | //to walk// | +| ``no_Utt`` | [Utt #Utt] | //no// | +| ``yes_Utt`` | [Utt #Utt] | //yes// | +==V - one-place verb==[V] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==V2 - two-place verb==[V2] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==V2A - verb with NP and AP complement==[V2A] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==V2Q - verb with NP and Q complement==[V2Q] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==V2S - verb with NP and S complement==[V2S] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==V2V - verb with NP and V complement==[V2V] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==V3 - three-place verb==[V3] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==VA - adjective-complement verb==[VA] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==VP - verb phrase==[VP] +|| Function | Type | Example || +| ``mkVP`` | [V #V] ``->`` [VP #VP] | //walk// | +| ``mkVP`` | [V2 #V2] ``->`` [NP #NP] ``->`` [VP #VP] | //love her// | +| ``mkVP`` | [V3 #V3] ``->`` [NP #NP] ``->`` [NP #NP] ``->`` [VP #VP] | //send it to her// | +| ``mkVP`` | [VV #VV] ``->`` [VP #VP] ``->`` [VP #VP] | //want to walk// | +| ``mkVP`` | [VS #VS] ``->`` [S #S] ``->`` [VP #VP] | //know that she walks// | +| ``mkVP`` | [VQ #VQ] ``->`` [QS #QS] ``->`` [VP #VP] | //ask if she walks// | +| ``mkVP`` | [VA #VA] ``->`` [AP #AP] ``->`` [VP #VP] | //become old// | +| ``mkVP`` | [V2A #V2A] ``->`` [NP #NP] ``->`` [AP #AP] ``->`` [VP #VP] | //paint it red// | +| ``mkVP`` | [A #A] ``->`` [VP #VP] | //be warm// | +| ``mkVP`` | [AP #AP] ``->`` [VP #VP] | //be very warm// | +| ``mkVP`` | [A #A] ``->`` [NP #NP] ``->`` [VP #VP] | //be older than her// | +| ``mkVP`` | [A2 #A2] ``->`` [NP #NP] ``->`` [VP #VP] | //be married to her// | +| ``mkVP`` | [N #N] ``->`` [VP #VP] | //be a man// | +| ``mkVP`` | [CN #CN] ``->`` [VP #VP] | //be an old man// | +| ``mkVP`` | [NP #NP] ``->`` [VP #VP] | //be the man// | +| ``mkVP`` | [Adv #Adv] ``->`` [VP #VP] | //be here// | +| ``mkVP`` | [VP #VP] ``->`` [Adv #Adv] ``->`` [VP #VP] | //sleep here// | +| ``mkVP`` | [AdV #AdV] ``->`` [VP #VP] ``->`` [VP #VP] | //always sleep// | +| ``mkVP`` | [VPSlash #VPSlash] ``->`` [NP #NP] ``->`` [VP #VP] | //paint it black// | +| ``mkVP`` | [VPSlash #VPSlash] ``->`` [VP #VP] | //paint itself black// | +| ``passiveVP`` | [V2 #V2] ``->`` [VP #VP] | //be loved// | +| ``passiveVP`` | [V2 #V2] ``->`` [NP #NP] ``->`` [VP #VP] | //be loved by her// | +| ``progressiveVP`` | [VP #VP] ``->`` [VP #VP] | //be sleeping// | +| ``reflexiveVP`` | [V2 #V2] ``->`` [VP #VP] | //love itself// | +==VPSlash - verb phrase missing complement==[VPSlash] +|| Function | Type | Example || +| ``mkVPSlash`` | [V2 #V2] ``->`` [VPSlash #VPSlash] | //(whom) (John) loves// | +| ``mkVPSlash`` | [V3 #V3] ``->`` [NP #NP] ``->`` [VPSlash #VPSlash] | //(whom) (John) gives an apple// | +| ``mkVPSlash`` | [V2A #V2A] ``->`` [AP #AP] ``->`` [VPSlash #VPSlash] | //(whom) (John) paints red// | +| ``mkVPSlash`` | [V2Q #V2Q] ``->`` [QS #QS] ``->`` [VPSlash #VPSlash] | //(whom) (John) asks who sleeps// | +| ``mkVPSlash`` | [V2S #V2S] ``->`` [S #S] ``->`` [VPSlash #VPSlash] | //(whom) (John) tells that we sleep// | +| ``mkVPSlash`` | [V2V #V2V] ``->`` [VP #VP] ``->`` [VPSlash #VPSlash] | //(whom) (John) forces to sleep// | +==VQ - question-complement verb==[VQ] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==VS - sentence-complement verb==[VS] +Lexical category, constructors given in +[lexical paradigms #RParadigms]. +==VV - verb-phrase-complement verb==[VV] +|| Function | Type | Example || +| ``can8know_VV`` | [VV #VV] | //can (capacity)// | +| ``can_VV`` | [VV #VV] | //can (possibility)// | +| ``must_VV`` | [VV #VV] | //must// | +| ``want_VV`` | [VV #VV] | //want// | +==Voc - vocative or "please"==[Voc] +|| Function | Type | Example || +| ``mkVoc`` | [NP #NP] ``->`` [Voc #Voc] | //John// | +| ``please_Voc`` | [Voc #Voc] | //please// | + + + + +=Lexical Paradigms= +==Paradigms for Bulgarian== +#LParadigms + + +source [``http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/bulgarian/ParadigmsBul.gf`` ../src/bulgarian/ParadigmsBul.gf] + + + + +|| Function | Type || +| ``mkN001`` | ``Str`` ``->`` [N #N] | +| ``mkN002`` | ``Str`` ``->`` [N #N] | +| ``mkN002a`` | ``Str`` ``->`` [N #N] | +| ``mkN003`` | ``Str`` ``->`` [N #N] | +| ``mkN004`` | ``Str`` ``->`` [N #N] | +| ``mkN005`` | ``Str`` ``->`` [N #N] | +| ``mkN006`` | ``Str`` ``->`` [N #N] | +| ``mkN007`` | ``Str`` ``->`` [N #N] | +| ``mkN007b`` | ``Str`` ``->`` [N #N] | +| ``mkN007a`` | ``Str`` ``->`` [N #N] | +| ``mkN008`` | ``Str`` ``->`` [N #N] | +| ``mkN008b`` | ``Str`` ``->`` [N #N] | +| ``mkN008c`` | ``Str`` ``->`` [N #N] | +| ``mkN008a`` | ``Str`` ``->`` [N #N] | +| ``mkN009`` | ``Str`` ``->`` [N #N] | +| ``mkN009a`` | ``Str`` ``->`` [N #N] | +| ``mkN010`` | ``Str`` ``->`` [N #N] | +| ``mkN011`` | ``Str`` ``->`` [N #N] | +| ``mkN012`` | ``Str`` ``->`` [N #N] | +| ``mkN013`` | ``Str`` ``->`` [N #N] | +| ``mkN014`` | ``Str`` ``->`` [N #N] | +| ``mkN014a`` | ``Str`` ``->`` [N #N] | +| ``mkN015`` | ``Str`` ``->`` [N #N] | +| ``mkN015a`` | ``Str`` ``->`` [N #N] | +| ``mkN016`` | ``Str`` ``->`` [N #N] | +| ``mkN016a`` | ``Str`` ``->`` [N #N] | +| ``mkN017`` | ``Str`` ``->`` [N #N] | +| ``mkN018`` | ``Str`` ``->`` [N #N] | +| ``mkN018a`` | ``Str`` ``->`` [N #N] | +| ``mkN019`` | ``Str`` ``->`` [N #N] | +| ``mkN019a`` | ``Str`` ``->`` [N #N] | +| ``mkN020`` | ``Str`` ``->`` [N #N] | +| ``mkN021`` | ``Str`` ``->`` [N #N] | +| ``mkN022`` | ``Str`` ``->`` [N #N] | +| ``mkN023`` | ``Str`` ``->`` [N #N] | +| ``mkN024a`` | ``Str`` ``->`` [N #N] | +| ``mkN024`` | ``Str`` ``->`` [N #N] | +| ``mkN025`` | ``Str`` ``->`` [N #N] | +| ``mkN026`` | ``Str`` ``->`` [N #N] | +| ``mkN027`` | ``Str`` ``->`` [N #N] | +| ``mkN028`` | ``Str`` ``->`` [N #N] | +| ``mkN028a`` | ``Str`` ``->`` [N #N] | +| ``mkN029`` | ``Str`` ``->`` [N #N] | +| ``mkN030`` | ``Str`` ``->`` [N #N] | +| ``mkN031`` | ``Str`` ``->`` [N #N] | +| ``mkN031a`` | ``Str`` ``->`` [N #N] | +| ``mkN032`` | ``Str`` ``->`` [N #N] | +| ``mkN032a`` | ``Str`` ``->`` [N #N] | +| ``mkN033`` | ``Str`` ``->`` [N #N] | +| ``mkN034`` | ``Str`` ``->`` [N #N] | +| ``mkN035`` | ``Str`` ``->`` [N #N] | +| ``mkN035a`` | ``Str`` ``->`` [N #N] | +| ``mkN036`` | ``Str`` ``->`` [N #N] | +| ``mkN037`` | ``Str`` ``->`` [N #N] | +| ``mkN038`` | ``Str`` ``->`` [N #N] | +| ``mkN039`` | ``Str`` ``->`` [N #N] | +| ``mkN040`` | ``Str`` ``->`` [N #N] | +| ``mkN040a`` | ``Str`` ``->`` [N #N] | +| ``mkN041`` | ``Str`` ``->`` [N #N] | +| ``mkN041a`` | ``Str`` ``->`` [N #N] | +| ``mkN041b`` | ``Str`` ``->`` [N #N] | +| ``mkN042`` | ``Str`` ``->`` [N #N] | +| ``mkN043`` | ``Str`` ``->`` [N #N] | +| ``mkN043a`` | ``Str`` ``->`` [N #N] | +| ``mkN044`` | ``Str`` ``->`` [N #N] | +| ``mkN045`` | ``Str`` ``->`` [N #N] | +| ``mkN046`` | ``Str`` ``->`` [N #N] | +| ``mkN047`` | ``Str`` ``->`` [N #N] | +| ``mkN048`` | ``Str`` ``->`` [N #N] | +| ``mkN049`` | ``Str`` ``->`` [N #N] | +| ``mkN050`` | ``Str`` ``->`` [N #N] | +| ``mkN051`` | ``Str`` ``->`` [N #N] | +| ``mkN052`` | ``Str`` ``->`` [N #N] | +| ``mkN052a`` | ``Str`` ``->`` [N #N] | +| ``mkN053`` | ``Str`` ``->`` [N #N] | +| ``mkN054`` | ``Str`` ``->`` [N #N] | +| ``mkN055`` | ``Str`` ``->`` [N #N] | +| ``mkN056`` | ``Str`` ``->`` [N #N] | +| ``mkN057`` | ``Str`` ``->`` [N #N] | +| ``mkN057a`` | ``Str`` ``->`` [N #N] | +| ``mkN058`` | ``Str`` ``->`` [N #N] | +| ``mkN059`` | ``Str`` ``->`` [N #N] | +| ``mkN060`` | ``Str`` ``->`` [N #N] | +| ``mkN061`` | ``Str`` ``->`` [N #N] | +| ``mkN062`` | ``Str`` ``->`` [N #N] | +| ``mkN063`` | ``Str`` ``->`` [N #N] | +| ``mkN064`` | ``Str`` ``->`` [N #N] | +| ``mkN065`` | ``Str`` ``->`` [N #N] | +| ``mkN066`` | ``Str`` ``->`` [N #N] | +| ``mkN067`` | ``Str`` ``->`` [N #N] | +| ``mkN068`` | ``Str`` ``->`` [N #N] | +| ``mkN069`` | ``Str`` ``->`` [N #N] | +| ``mkN070`` | ``Str`` ``->`` [N #N] | +| ``mkN071`` | ``Str`` ``->`` [N #N] | +| ``mkN072`` | ``Str`` ``->`` [N #N] | +| ``mkN073`` | ``Str`` ``->`` [N #N] | +| ``mkN074`` | ``Str`` ``->`` [N #N] | +| ``mkN075`` | ``Str`` ``->`` [N #N] | +| ``mkA076`` | ``Str`` ``->`` [A #A] | +| ``mkA077`` | ``Str`` ``->`` [A #A] | +| ``mkA078`` | ``Str`` ``->`` [A #A] | +| ``mkA079`` | ``Str`` ``->`` [A #A] | +| ``mkA080`` | ``Str`` ``->`` [A #A] | +| ``mkA081`` | ``Str`` ``->`` [A #A] | +| ``mkA082`` | ``Str`` ``->`` [A #A] | +| ``mkA082a`` | ``Str`` ``->`` [A #A] | +| ``mkA083`` | ``Str`` ``->`` [A #A] | +| ``mkA084`` | ``Str`` ``->`` [A #A] | +| ``mkA084a`` | ``Str`` ``->`` [A #A] | +| ``mkA085`` | ``Str`` ``->`` [A #A] | +| ``mkA086`` | ``Str`` ``->`` [A #A] | +| ``mkA087`` | ``Str`` ``->`` [A #A] | +| ``mkA088`` | ``Str`` ``->`` [A #A] | +| ``mkA089a`` | ``Str`` ``->`` [A #A] | +| ``mkV142`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV143`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV144`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV145`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV145a`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV145b`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV146`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV146a`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV147`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV148`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV149`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV150`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV150a`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV151`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV152`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV152a`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV153`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV154`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV155`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV156`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV157`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV158`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV159`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV160`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV160a`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV161`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV161a`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV162`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV163`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV164`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV165`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV166`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV167`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV168`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV169`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV170`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV171`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV172`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV173`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV174`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV175`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV176`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV177`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV178`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV179`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV180`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV181`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV182`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV183`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV184`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV185`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV186`` | ``Str`` ``->`` [VTable #VTable] | +| ``mkV187`` | ``Str`` ``->`` [VTable #VTable] | +| ``adjAdv`` | [A #A] ``->`` ``Str`` ``->`` [A #A] ``=`` | + + +==Paradigms for Catalan== +#LParadigms + + +source [``http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/catalan/ParadigmsCat.gf`` ../src/catalan/ParadigmsCat.gf] + + + + +|| Function | Type || +| ``Gender`` | [Type #Type] | +| ``masculine`` | [Gender #Gender] | +| ``feminine`` | [Gender #Gender] | +| ``Number`` | [Type #Type] | +| ``singular`` | [Number #Number] | +| ``plural`` | [Number #Number] | +| ``accusative`` | [Prep #Prep] | +| ``genitive`` | [Prep #Prep] | +| ``dative`` | [Prep #Prep] | +| ``mkPrep`` | ``Str`` ``->`` [Prep #Prep] | +| ``mkN`` | ``(llum`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | ``Str`` ``->`` [Gender #Gender] ``->`` [N #N] | +| ``mkN`` | ``(disc,discos`` ``:`` ``Str)`` ``->`` [Gender #Gender] ``->`` [N #N] | +| ``compN`` | [N #N] ``->`` ``Str`` ``->`` [N #N] | +| ``mkN2`` | [N #N] ``->`` [Prep #Prep] ``->`` [N2 #N2] | +| ``deN2`` | [N #N] ``->`` [N2 #N2] | +| ``aN2`` | [N #N] ``->`` [N2 #N2] | +| ``mkN3`` | [N #N] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [N3 #N3] | +| ``mkPN`` | ``(Anna`` ``:`` ``Str)`` ``->`` [PN #PN] | +| ``mkPN`` | ``(Pilar`` ``:`` ``Str)`` ``->`` [Gender #Gender] ``->`` [PN #PN] | +| ``mkA`` | ``(sol`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(fort,forta,forts,fortes,fortament`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(bo`` ``:`` ``A)`` ``->`` ``(millor`` ``:`` ``A)`` ``->`` [A #A] | +| ``prefixA`` | [A #A] ``->`` [A #A] | +| ``mkA2`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2 #A2] | +| ``mkAdv`` | ``Str`` ``->`` [Adv #Adv] | +| ``mkAdV`` | ``Str`` ``->`` [AdV #AdV] | +| ``mkAdA`` | ``Str`` ``->`` [AdA #AdA] | +| ``mkV`` | ``(cantar`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | [Verbum #Verbum] ``->`` [V #V] | +| ``reflV`` | [V #V] ``->`` [V #V] | +| ``special_ppV`` | [V #V] ``->`` ``Str`` ``->`` [V #V] | +| ``mkV2`` | ``Str`` ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2 #V2] | +| ``v2V`` | [V2 #V2] ``->`` [V #V] | +| ``mkV3`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V3 #V3] | +| ``dirV3`` | [V #V] ``->`` [Prep #Prep] ``->`` [V3 #V3] | +| ``dirdirV3`` | [V #V] ``->`` [V3 #V3] | +| ``mkV0`` | [V #V] ``->`` [V0 #V0] | +| ``mkVS`` | [V #V] ``->`` [VS #VS] | +| ``mkV2S`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2S #V2S] | +| ``mkVV`` | [V #V] ``->`` [VV #VV] | +| ``deVV`` | [V #V] ``->`` [VV #VV] | +| ``aVV`` | [V #V] ``->`` [VV #VV] | +| ``mkV2V`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V2V #V2V] | +| ``mkVA`` | [V #V] ``->`` [VA #VA] | +| ``mkV2A`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V2A #V2A] | +| ``mkVQ`` | [V #V] ``->`` [VQ #VQ] | +| ``mkV2Q`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2Q #V2Q] | +| ``mkAS`` | [A #A] ``->`` [AS #AS] | +| ``mkA2S`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2S #A2S] | +| ``mkAV`` | [A #A] ``->`` [Prep #Prep] ``->`` [AV #AV] | +| ``mkA2V`` | [A #A] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [A2V #A2V] | +| ``V0`` | [Type #Type] | + + +==Paradigms for Danish== +#LParadigms + + +source [``http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/danish/ParadigmsDan.gf`` ../src/danish/ParadigmsDan.gf] + + + + +|| Function | Type || +| ``Gender`` | [Type #Type] | +| ``utrum`` | [Gender #Gender] | +| ``neutrum`` | [Gender #Gender] | +| ``Number`` | [Type #Type] | +| ``singular`` | [Number #Number] | +| ``plural`` | [Number #Number] | +| ``Case`` | [Type #Type] | +| ``nominative`` | [Case #Case] | +| ``genitive`` | [Case #Case] | +| ``mkPrep`` | ``Str`` ``->`` [Prep #Prep] | +| ``noPrep`` | [Prep #Prep] | +| ``mkN`` | ``(bil`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | ``(hus`` ``:`` ``Str)`` ``->`` [Gender #Gender] ``->`` [N #N] | +| ``mkN`` | ``(bil,bilen`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | ``(bil,bilen,biler`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | ``(dreng,drengen,drenge,drengene`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN2`` | [N #N] ``->`` [Prep #Prep] ``->`` [N2 #N2] | +| ``regN2`` | ``Str`` ``->`` [Gender #Gender] ``->`` [N2 #N2] | +| ``mkN3`` | [N #N] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [N3 #N3] | +| ``mkPN`` | ``Str`` ``->`` [PN #PN] | +| ``mkPN`` | ``Str`` ``->`` [Gender #Gender] ``->`` [PN #PN] | +| ``mkPN`` | [N #N] ``->`` [PN #PN] | +| ``mkA`` | ``(fin`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(fin,fint`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(galen,galet,galne`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(stor,stort,store,storre,storst`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | [A #A] ``->`` [A #A] | +| ``mkA2`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2 #A2] | +| ``mkAdv`` | ``Str`` ``->`` [Adv #Adv] | +| ``mkAdV`` | ``Str`` ``->`` [AdV #AdV] | +| ``mkAdA`` | ``Str`` ``->`` [AdA #AdA] | +| ``mkV`` | ``(snakke`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``(leve,levde`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``(drikke,`` ``drakk,`` ``drukket`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``(spise,spiser,spises,spiste,spist,spis`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | [V #V] ``->`` ``Str`` ``->`` [V #V] | +| ``vaereV`` | [V #V] ``->`` [V #V] | +| ``depV`` | [V #V] ``->`` [V #V] | +| ``reflV`` | [V #V] ``->`` [V #V] | +| ``mkV2`` | ``Str`` ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2 #V2] | +| ``mkV3`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V3 #V3] | +| ``dirV3`` | [V #V] ``->`` [Prep #Prep] ``->`` [V3 #V3] | +| ``dirdirV3`` | [V #V] ``->`` [V3 #V3] | +| ``mkV0`` | [V #V] ``->`` [V0 #V0] | +| ``mkVS`` | [V #V] ``->`` [VS #VS] | +| ``mkV2S`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2S #V2S] | +| ``mkVV`` | [V #V] ``->`` [VV #VV] | +| ``mkV2V`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V2V #V2V] | +| ``mkVA`` | [V #V] ``->`` [VA #VA] | +| ``mkV2A`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2A #V2A] | +| ``mkVQ`` | [V #V] ``->`` [VQ #VQ] | +| ``mkV2Q`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2Q #V2Q] | +| ``mkAS`` | [A #A] ``->`` [AS #AS] | +| ``mkA2S`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2S #A2S] | +| ``mkAV`` | [A #A] ``->`` [AV #AV] | +| ``mkA2V`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2V #A2V] | +| ``V0`` | [Type #Type] | + + +==Paradigms for English== +#LParadigms + + +source [``http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/english/ParadigmsEng.gf`` ../src/english/ParadigmsEng.gf] + + + + +|| Function | Type || +| ``Gender`` | [Type #Type] | +| ``human`` | [Gender #Gender] | +| ``nonhuman`` | [Gender #Gender] | +| ``masculine`` | [Gender #Gender] | +| ``feminine`` | [Gender #Gender] | +| ``Number`` | [Type #Type] | +| ``singular`` | [Number #Number] | +| ``plural`` | [Number #Number] | +| ``Case`` | [Type #Type] | +| ``nominative`` | [Case #Case] | +| ``genitive`` | [Case #Case] | +| ``mkN`` | ``(flash`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | ``(man,men`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | ``(man,men,man's,men's`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | [Gender #Gender] ``->`` [N #N] ``->`` [N #N] | +| ``mkN`` | ``Str`` ``->`` [N #N] ``->`` [N #N] | +| ``mkN2`` | [N #N] ``->`` [Prep #Prep] ``->`` [N2 #N2] | +| ``mkN2`` | [N #N] ``->`` ``Str`` ``->`` [N2 #N2] | +| ``mkN2`` | ``Str`` ``->`` ``Str`` ``->`` [N2 #N2] | +| ``mkN2`` | [N #N] ``->`` [N2 #N2] | +| ``mkN2`` | ``Str`` ``->`` [N2 #N2] | +| ``mkN3`` | [N #N] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [N3 #N3] | +| ``mkPN`` | ``Str`` ``->`` [PN #PN] | +| ``mkPN`` | [N #N] ``->`` [PN #PN] | +| ``mkQuant`` | ``(this,`` ``these`` ``:`` ``Str)`` ``->`` [Quant #Quant] | +| ``mkQuant`` | ``(no_sg,`` ``no_pl,`` ``none_sg,`` ``non_pl`` ``:`` ``Str)`` ``->`` [Quant #Quant] | +| ``mkOrd`` | ``Str`` ``->`` [Ord #Ord] | +| ``mkA`` | ``(happy`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(fat,fatter`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(good,better,best,well`` ``:`` ``Str)`` ``->`` [A #A] | +| ``compoundA`` | [A #A] ``->`` [A #A] | +| ``simpleA`` | [A #A] ``->`` [A #A] | +| ``mkA2`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2 #A2] | +| ``mkA2`` | [A #A] ``->`` ``Str`` ``->`` [A2 #A2] | +| ``mkA2`` | ``Str`` ``->`` [Prep #Prep] ``->`` [A2 #A2] | +| ``mkA2`` | ``Str`` ``->`` ``Str`` ``->`` [A2 #A2] | +| ``mkAdv`` | ``Str`` ``->`` [Adv #Adv] | +| ``mkAdV`` | ``Str`` ``->`` [AdV #AdV] | +| ``mkAdA`` | ``Str`` ``->`` [AdA #AdA] | +| ``mkAdN`` | ``Str`` ``->`` [AdN #AdN] | +| ``mkPrep`` | ``Str`` ``->`` [Prep #Prep] | +| ``noPrep`` | [Prep #Prep] | +| ``mkConj`` | ``Str`` ``->`` [Conj #Conj] | +| ``mkConj`` | ``Str`` ``->`` [Number #Number] ``->`` [Conj #Conj] | +| ``mkConj`` | ``Str`` ``->`` ``Str`` ``->`` [Conj #Conj] | +| ``mkConj`` | ``Str`` ``->`` ``Str`` ``->`` [Number #Number] ``->`` [Conj #Conj] | +| ``mkV`` | ``(cry`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``(stop,`` ``stopped`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``(drink,`` ``drank,`` ``drunk`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``(run,`` ``ran,`` ``run,`` ``running`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``(go,`` ``goes,`` ``went,`` ``gone,`` ``going`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``Str`` ``->`` [V #V] ``->`` [V #V] | +| ``partV`` | [V #V] ``->`` ``Str`` ``->`` [V #V] | +| ``reflV`` | [V #V] ``->`` [V #V] | +| ``mkV2`` | ``Str`` ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` ``Str`` ``->`` [V2 #V2] | +| ``mkV2`` | ``Str`` ``->`` [Prep #Prep] ``->`` [V2 #V2] | +| ``mkV2`` | ``Str`` ``->`` ``Str`` ``->`` [V2 #V2] | +| ``mkV3`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V3 #V3] | +| ``mkV3`` | [V #V] ``->`` [Prep #Prep] ``->`` [V3 #V3] | +| ``mkV3`` | [V #V] ``->`` ``Str`` ``->`` [V3 #V3] | +| ``mkV3`` | ``Str`` ``->`` ``Str`` ``->`` [V3 #V3] | +| ``mkV3`` | [V #V] ``->`` [V3 #V3] | +| ``mkV3`` | ``Str`` ``->`` [V3 #V3] | +| ``mkV0`` | [V #V] ``->`` [V0 #V0] | +| ``mkVS`` | [V #V] ``->`` [VS #VS] | +| ``mkV2S`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2S #V2S] | +| ``mkVV`` | [V #V] ``->`` [VV #VV] | +| ``mkV2V`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V2V #V2V] | +| ``mkVA`` | [V #V] ``->`` [VA #VA] | +| ``mkV2A`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2A #V2A] | +| ``mkVQ`` | [V #V] ``->`` [VQ #VQ] | +| ``mkV2Q`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2Q #V2Q] | +| ``mkAS`` | [A #A] ``->`` [AS #AS] | +| ``mkA2S`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2S #A2S] | +| ``mkAV`` | [A #A] ``->`` [AV #AV] | +| ``mkA2V`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2V #A2V] | +| ``V0`` | [Type #Type] | +| ``mkSubj`` | ``Str`` ``->`` [Subj #Subj] ``=`` ``\s`` ``->`` ``{s`` ``=`` ``s`` ``lock_Subj`` ``=`` ``<>}`` | + + +==Paradigms for Finnish== +#LParadigms + + +source [``http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/finnish/ParadigmsFin.gf`` ../src/finnish/ParadigmsFin.gf] + + + + +|| Function | Type || +| ``Number`` | [Type #Type] | +| ``singular`` | [Number #Number] | +| ``plural`` | [Number #Number] | +| ``Case`` | [Type #Type] | +| ``nominative`` | [Case #Case] | +| ``genitive`` | [Case #Case] | +| ``partitive`` | [Case #Case] | +| ``translative`` | [Case #Case] | +| ``inessive`` | [Case #Case] | +| ``elative`` | [Case #Case] | +| ``illative`` | [Case #Case] | +| ``adessive`` | [Case #Case] | +| ``ablative`` | [Case #Case] | +| ``allative`` | [Case #Case] | +| ``prePrep`` | [Case #Case] ``->`` ``Str`` ``->`` [Prep #Prep] | +| ``postPrep`` | [Case #Case] ``->`` ``Str`` ``->`` [Prep #Prep] | +| ``postGenPrep`` | ``Str`` ``->`` [Prep #Prep] | +| ``casePrep`` | [Case #Case] ``->`` [Prep #Prep] | +| ``mkN`` | ``(talo`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | ``(savi,savia`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | ``(vesi,veden,vesiä`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | ``(vesi,veden,vesiä,vettä`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | ``(olo,olon,olona,oloa,oloon,olojen,oloja,oloina,oloissa,oloihin`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | ``(pika`` ``:`` ``Str)`` ``->`` ``(juna`` ``:`` ``N)`` ``->`` [N #N] | +| ``mkN`` | ``(oma`` ``:`` ``N)`` ``->`` ``(tunto`` ``:`` ``N)`` ``->`` [N #N] | +| ``mkN2`` | [N #N] ``->`` [N2 #N2] | +| ``mkN2`` | [N #N] ``->`` [Prep #Prep] ``->`` [N2 #N2] | +| ``mkN3`` | [N #N] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [N3 #N3] | +| ``mkPN`` | ``Str`` ``->`` [PN #PN] | +| ``mkPN`` | [N #N] ``->`` [PN #PN] | +| ``mkA`` | ``Str`` ``->`` [A #A] | +| ``mkA`` | [N #N] ``->`` [A #A] | +| ``mkA`` | [N #N] ``->`` ``(kivempaa,kivinta`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(hyva,parempi,paras`` ``:`` ``N)`` ``->`` ``(hyvin,paremmin,parhaiten`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA2`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2 #A2] ``=`` ``\a,p`` ``->`` ``a`` ``**`` ``{c2`` ``=`` ``p`` ``lock_A2`` ``=`` ``<>};`` | +| ``mkV`` | ``(huutaa`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``(huutaa,huusi`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``(huutaa,huudan,huusi`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``(`` | +| ``huusin,huusi,huusisi,huutanut,huudettu,huutanee`` | ``Str)`` ``->`` [V #V] | +| ``caseV`` | [Case #Case] ``->`` [V #V] ``->`` [V #V] | +| ``vOlla`` | [V #V] | +| ``mkV2`` | ``Str`` ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [Case #Case] ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2 #V2] | +| ``mkV3`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V3 #V3] | +| ``dirV3`` | [V #V] ``->`` [Case #Case] ``->`` [V3 #V3] | +| ``dirdirV3`` | [V #V] ``->`` [V3 #V3] | +| ``mkV0`` | [V #V] ``->`` [V0 #V0] | +| ``mkVS`` | [V #V] ``->`` [VS #VS] | +| ``mkV2S`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2S #V2S] | +| ``mkVV`` | [V #V] ``->`` [VV #VV] | +| ``mkVVf`` | [V #V] ``->`` [InfForm #InfForm] ``->`` [VV #VV] | +| ``mkV2V`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2V #V2V] | +| ``mkV2Vf`` | [V #V] ``->`` [Prep #Prep] ``->`` [InfForm #InfForm] ``->`` [V2V #V2V] | +| ``mkVA`` | [V #V] ``->`` [Prep #Prep] ``->`` [VA #VA] | +| ``mkV2A`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V2A #V2A] | +| ``mkVQ`` | [V #V] ``->`` [VQ #VQ] | +| ``mkV2Q`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2Q #V2Q] | +| ``mkAS`` | [A #A] ``->`` [AS #AS] | +| ``mkA2S`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2S #A2S] | +| ``mkAV`` | [A #A] ``->`` [AV #AV] | +| ``mkA2V`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2V #A2V] | +| ``V0`` | [Type #Type] | + + +==Paradigms for French== +#LParadigms + + +source [``http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/french/ParadigmsFre.gf`` ../src/french/ParadigmsFre.gf] + + + + +|| Function | Type || +| ``Gender`` | [Type #Type] | +| ``masculine`` | [Gender #Gender] | +| ``feminine`` | [Gender #Gender] | +| ``Number`` | [Type #Type] | +| ``singular`` | [Number #Number] | +| ``plural`` | [Number #Number] | +| ``accusative`` | [Prep #Prep] | +| ``genitive`` | [Prep #Prep] | +| ``dative`` | [Prep #Prep] | +| ``mkPrep`` | ``Str`` ``->`` [Prep #Prep] | +| ``mkN`` | ``(cheval`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | ``(foie`` ``:`` ``Str)`` ``->`` [Gender #Gender] ``->`` [N #N] | +| ``mkN`` | ``(oeil,yeux`` ``:`` ``Str)`` ``->`` [Gender #Gender] ``->`` [N #N] | +| ``mkN`` | [N #N] ``->`` ``Str`` ``->`` [N #N] | +| ``mkN2`` | [N #N] ``->`` [Prep #Prep] ``->`` [N2 #N2] | +| ``deN2`` | [N #N] ``->`` [N2 #N2] | +| ``aN2`` | [N #N] ``->`` [N2 #N2] | +| ``mkN3`` | [N #N] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [N3 #N3] | +| ``mkPN`` | ``Str`` ``->`` [PN #PN] | +| ``mkPN`` | ``Str`` ``->`` [Gender #Gender] ``->`` [PN #PN] | +| ``mkA`` | ``(cher`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(sec,seche`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(banal,banale,banaux,banalement`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | [A #A] ``->`` [A #A] ``->`` [A #A] | +| ``prefixA`` | [A #A] ``->`` [A #A] | +| ``mkA2`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2 #A2] | +| ``mkAdv`` | ``Str`` ``->`` [Adv #Adv] | +| ``mkAdV`` | ``Str`` ``->`` [AdV #AdV] | +| ``mkAdA`` | ``Str`` ``->`` [AdA #AdA] | +| ``mkV`` | ``(finir`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``(jeter,jette,jettera`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | [V2 #V2] ``->`` [V #V] | +| ``etreV`` | [V #V] ``->`` [V #V] | +| ``reflV`` | [V #V] ``->`` [V #V] | +| ``mkV2`` | ``Str`` ``->`` [V2 #V2] ``=`` ``\s`` ``->`` ``dirV2`` ``(regV`` ``s)`` | +| ``mkV2`` | [V #V] ``->`` [V2 #V2] ``=`` ``dirV2`` | +| ``mkV2`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2 #V2] ``=`` ``mmkV2`` | +| ``mkV3`` | [V #V] ``->`` [V3 #V3] | +| ``mkV3`` | [V #V] ``->`` [Prep #Prep] ``->`` [V3 #V3] | +| ``mkV3`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V3 #V3] | +| ``mkV0`` | [V #V] ``->`` [V0 #V0] | +| ``mkVS`` | [V #V] ``->`` [VS #VS] | +| ``mkV2S`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2S #V2S] | +| ``mkVV`` | [V #V] ``->`` [VV #VV] | +| ``deVV`` | [V #V] ``->`` [VV #VV] | +| ``aVV`` | [V #V] ``->`` [VV #VV] | +| ``mkV2V`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V2V #V2V] | +| ``mkVA`` | [V #V] ``->`` [VA #VA] | +| ``mkV2A`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V2A #V2A] | +| ``mkVQ`` | [V #V] ``->`` [VQ #VQ] | +| ``mkV2Q`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2Q #V2Q] | +| ``mkAS`` | [A #A] ``->`` [AS #AS] | +| ``mkA2S`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2S #A2S] | +| ``mkAV`` | [A #A] ``->`` [Prep #Prep] ``->`` [AV #AV] | +| ``mkA2V`` | [A #A] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [A2V #A2V] | +| ``V0`` | [Type #Type] | + + +==Paradigms for German== +#LParadigms + + +source [``http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/german/ParadigmsGer.gf`` ../src/german/ParadigmsGer.gf] + + + + +|| Function | Type || +| ``Gender`` | [Type #Type] | +| ``masculine`` | [Gender #Gender] | +| ``feminine`` | [Gender #Gender] | +| ``neuter`` | [Gender #Gender] | +| ``Case`` | [Type #Type] | +| ``nominative`` | [Case #Case] | +| ``accusative`` | [Case #Case] | +| ``dative`` | [Case #Case] | +| ``genitive`` | [Case #Case] | +| ``Number`` | [Type #Type] | +| ``singular`` | [Number #Number] | +| ``plural`` | [Number #Number] | +| ``mkN`` | ``(Stufe`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | ``(Bild,Bilder`` ``:`` ``Str)`` ``->`` [Gender #Gender] ``->`` [N #N] | +| ``mkN`` | ``(x1,_,_,_,_,x6`` ``:`` ``Str)`` ``->`` [Gender #Gender] ``->`` [N #N] | +| ``mkN2`` | ``Str`` ``->`` [N2 #N2] | +| ``mkN2`` | [N #N] ``->`` [N2 #N2] | +| ``mkN2`` | [N #N] ``->`` [Prep #Prep] ``->`` [N2 #N2] | +| ``mkN3`` | [N #N] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [N3 #N3] | +| ``mkPN`` | ``Str`` ``->`` [PN #PN] | +| ``mkPN`` | ``(nom,gen`` ``:`` ``Str)`` ``->`` [PN #PN] | +| ``mkPN`` | ``(nom,acc,dat,gen`` ``:`` ``Str)`` ``->`` [PN #PN] | +| ``mkA`` | ``Str`` ``->`` [A #A] | +| ``mkA`` | ``(gut,besser,beste`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(gut,gute,besser,beste`` ``:`` ``Str)`` ``->`` [A #A] | +| ``invarA`` | ``Str`` ``->`` [A #A] | +| ``mkA2`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2 #A2] | +| ``mkAdv`` | ``Str`` ``->`` [Adv #Adv] | +| ``mkPrep`` | ``Str`` ``->`` [Case #Case] ``->`` [Prep #Prep] | +| ``accPrep`` | [Prep #Prep] | +| ``datPrep`` | [Prep #Prep] | +| ``genPrep`` | [Prep #Prep] | +| ``von_Prep`` | [Prep #Prep] | +| ``zu_Prep`` | [Prep #Prep] | +| ``mkV`` | ``(führen`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``(sehen,sieht,sah,sähe,gesehen`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``(geben,`` ``gibt,`` ``gib,`` ``gab,`` ``gäbe,`` ``gegeben`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``Str`` ``->`` [V #V] ``->`` [V #V] | +| ``no_geV`` | [V #V] ``->`` [V #V] | +| ``seinV`` | [V #V] ``->`` [V #V] | +| ``habenV`` | [V #V] ``->`` [V #V] | +| ``reflV`` | [V #V] ``->`` [Case #Case] ``->`` [V #V] | +| ``mkV2`` | ``Str`` ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [Case #Case] ``->`` [V2 #V2] | +| ``mkV3`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V3 #V3] | +| ``dirV3`` | [V #V] ``->`` [Prep #Prep] ``->`` [V3 #V3] | +| ``accdatV3`` | [V #V] ``->`` [V3 #V3] | +| ``mkV0`` | [V #V] ``->`` [V0 #V0] | +| ``mkVS`` | [V #V] ``->`` [VS #VS] | +| ``mkV2S`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2S #V2S] | +| ``mkVV`` | [V #V] ``->`` [VV #VV] | +| ``mkV2V`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2V #V2V] | +| ``mkVA`` | [V #V] ``->`` [VA #VA] | +| ``mkV2A`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2A #V2A] | +| ``mkVQ`` | [V #V] ``->`` [VQ #VQ] | +| ``mkV2Q`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2Q #V2Q] | +| ``mkAS`` | [A #A] ``->`` [AS #AS] | +| ``mkA2S`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2S #A2S] | +| ``mkAV`` | [A #A] ``->`` [AV #AV] | +| ``mkA2V`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2V #A2V] | +| ``V0`` | [Type #Type] | + + +==Paradigms for Italian== +#LParadigms + + +source [``http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/italian/ParadigmsIta.gf`` ../src/italian/ParadigmsIta.gf] + + + + +|| Function | Type || +| ``Gender`` | [Type #Type] | +| ``masculine`` | [Gender #Gender] | +| ``feminine`` | [Gender #Gender] | +| ``Number`` | [Type #Type] | +| ``singular`` | [Number #Number] | +| ``plural`` | [Number #Number] | +| ``--Prep`` | [Type #Type] | +| ``accusative`` | [Prep #Prep] | +| ``genitive`` | [Prep #Prep] | +| ``dative`` | [Prep #Prep] | +| ``mkPrep`` | ``Str`` ``->`` [Prep #Prep] | +| ``mkN`` | ``(cane`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | ``(carne`` ``:`` ``Str)`` ``->`` [Gender #Gender] ``->`` [N #N] | +| ``mkN`` | ``(uomo,uomini`` ``:`` ``Str)`` ``->`` [Gender #Gender] ``->`` [N #N] | +| ``mkN`` | [N #N] ``->`` ``Str`` ``->`` [N #N] | +| ``mkN2`` | ``Str`` ``->`` [N2 #N2] | +| ``mkN2`` | [N #N] ``->`` [Prep #Prep] ``->`` [N2 #N2] | +| ``mkN3`` | [N #N] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [N3 #N3] | +| ``mkPN`` | ``Str`` ``->`` [PN #PN] | +| ``mkPN`` | ``Str`` ``->`` [Gender #Gender] ``->`` [PN #PN] | +| ``mkA`` | ``(bianco`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(solo,sola,soli,sole,solamente`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | [A #A] ``->`` [A #A] ``->`` [A #A] | +| ``prefixA`` | [A #A] ``->`` [A #A] ``=`` ``prefA`` | +| ``mkA2`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2 #A2] | +| ``mkAdv`` | ``Str`` ``->`` [Adv #Adv] | +| ``mkAdV`` | ``Str`` ``->`` [AdV #AdV] | +| ``mkAdA`` | ``Str`` ``->`` [AdA #AdA] | +| ``mkV`` | ``Str`` ``->`` [V #V] | +| ``mkV`` | [Verbo #Verbo] ``->`` [V #V] | +| ``mkV`` | ``(udire,odo,ode,udiamo,udiro,udii,udisti,udi,udirono,odi,udito`` ``:`` ``Str)`` ``->`` [V #V] | +| ``essereV`` | [V #V] ``->`` [V #V] | +| ``reflV`` | [V #V] ``->`` [V #V] | +| ``mkV2`` | ``Str`` ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2 #V2] | +| ``v2V`` | [V2 #V2] ``->`` [V #V] | +| ``mkV3`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V3 #V3] | +| ``dirV3`` | [V #V] ``->`` [Prep #Prep] ``->`` [V3 #V3] | +| ``dirdirV3`` | [V #V] ``->`` [V3 #V3] | +| ``mkV0`` | [V #V] ``->`` [V0 #V0] | +| ``mkVS`` | [V #V] ``->`` [VS #VS] | +| ``mkV2S`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2S #V2S] | +| ``mkVV`` | [V #V] ``->`` [VV #VV] | +| ``deVV`` | [V #V] ``->`` [VV #VV] | +| ``aVV`` | [V #V] ``->`` [VV #VV] | +| ``mkV2V`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V2V #V2V] | +| ``mkVA`` | [V #V] ``->`` [VA #VA] | +| ``mkV2A`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V2A #V2A] | +| ``mkVQ`` | [V #V] ``->`` [VQ #VQ] | +| ``mkV2Q`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2Q #V2Q] | +| ``mkAS`` | [A #A] ``->`` [AS #AS] | +| ``mkA2S`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2S #A2S] | +| ``mkAV`` | [A #A] ``->`` [Prep #Prep] ``->`` [AV #AV] | +| ``mkA2V`` | [A #A] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [A2V #A2V] | +| ``V0`` | [Type #Type] | + + +==Paradigms for Norwegian== +#LParadigms + + +source [``http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/norwegian/ParadigmsNor.gf`` ../src/norwegian/ParadigmsNor.gf] + + + + +|| Function | Type || +| ``Gender`` | [Type #Type] | +| ``masculine`` | [Gender #Gender] | +| ``feminine`` | [Gender #Gender] | +| ``neutrum`` | [Gender #Gender] | +| ``Number`` | [Type #Type] | +| ``singular`` | [Number #Number] | +| ``plural`` | [Number #Number] | +| ``Case`` | [Type #Type] | +| ``nominative`` | [Case #Case] | +| ``genitive`` | [Case #Case] | +| ``mkPrep`` | ``Str`` ``->`` [Prep #Prep] | +| ``noPrep`` | [Prep #Prep] | +| ``mkN`` | ``Str`` ``->`` [N #N] | +| ``mkN`` | ``Str`` ``->`` [Gender #Gender] ``->`` [N #N] | +| ``mkN`` | ``(bil,bilen`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | ``(dreng,drengen,drenger,drengene`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN2`` | [N #N] ``->`` [Prep #Prep] ``->`` [N2 #N2] | +| ``regN2`` | ``Str`` ``->`` [Gender #Gender] ``->`` [N2 #N2] | +| ``mkN3`` | [N #N] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [N3 #N3] | +| ``mkPN`` | ``Str`` ``->`` [PN #PN] | +| ``mkPN`` | ``Str`` ``->`` [Gender #Gender] ``->`` [PN #PN] | +| ``mkPN`` | [N #N] ``->`` [PN #PN] | +| ``mkA`` | ``(fin`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(fin,fint`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(galen,galet,galne`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(stor,stort,store,storre,storst`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | [A #A] ``->`` [A #A] | +| ``mkA2`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2 #A2] | +| ``mkAdv`` | ``Str`` ``->`` [Adv #Adv] | +| ``mkAdV`` | ``Str`` ``->`` [AdV #AdV] | +| ``mkAdA`` | ``Str`` ``->`` [AdA #AdA] | +| ``mkV`` | ``(snakke`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``(leve,levde`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``(drikke,`` ``drakk,`` ``drukket`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``(spise,spiser,spises,spiste,spist,spis`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | [V #V] ``->`` ``Str`` ``->`` [V #V] | +| ``vaereV`` | [V #V] ``->`` [V #V] | +| ``depV`` | [V #V] ``->`` [V #V] | +| ``reflV`` | [V #V] ``->`` [V #V] | +| ``mkV2`` | ``Str`` ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2 #V2] | +| ``mkV3`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V3 #V3] | +| ``dirV3`` | [V #V] ``->`` [Prep #Prep] ``->`` [V3 #V3] | +| ``dirdirV3`` | [V #V] ``->`` [V3 #V3] | +| ``mkV0`` | [V #V] ``->`` [V0 #V0] | +| ``mkVS`` | [V #V] ``->`` [VS #VS] | +| ``mkV2S`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2S #V2S] | +| ``mkVV`` | [V #V] ``->`` [VV #VV] | +| ``mkV2V`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V2V #V2V] | +| ``mkVA`` | [V #V] ``->`` [VA #VA] | +| ``mkV2A`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2A #V2A] | +| ``mkVQ`` | [V #V] ``->`` [VQ #VQ] | +| ``mkV2Q`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2Q #V2Q] | +| ``mkAS`` | [A #A] ``->`` [AS #AS] | +| ``mkA2S`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2S #A2S] | +| ``mkAV`` | [A #A] ``->`` [AV #AV] | +| ``mkA2V`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2V #A2V] | +| ``V0`` | [Type #Type] | + + +==Paradigms for Romanian== +#LParadigms + + +source [``http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/romanian/ParadigmsRon.gf`` ../src/romanian/ParadigmsRon.gf] + + + + +|| Function | Type || +| ``NGender`` | [Type #Type] | +| ``masculine`` | [NGender #NGender] | +| ``feminine`` | [NGender #NGender] | +| ``neuter`` | [NGender #NGender] | +| ``Gender`` | [Type #Type] | +| ``Masculine`` | [Gender #Gender] | +| ``Feminine`` | [Gender #Gender] | +| ``Anim`` | [Type #Type] | +| ``animate`` | [Anim #Anim] | +| ``inanimate`` | ``Anim;`` | +| ``Number`` | [Type #Type] | +| ``singular`` | [Number #Number] | +| ``plural`` | [Number #Number] | +| ``Preposition`` | [Type #Type] | +| ``NCase`` | [Type #Type] | +| ``Acc`` | [NCase #NCase] | +| ``Dat`` | [NCase #NCase] | +| ``Gen`` | [NCase #NCase] | +| ``mkPrep`` | ``Str`` ``->`` [NCase #NCase] ``->`` [Prep #Prep] | +| ``noPrep`` | [NCase #NCase] ``->`` [Prep #Prep] | +| ``mkN2`` | [N #N] ``->`` [Prep #Prep] ``->`` [N2 #N2] | +| ``mkN3`` | [N #N] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [N3 #N3] | +| ``mkPN`` | ``Str`` ``->`` [PN #PN] ``=`` ``mkPropN`` | +| ``mkPN`` | ``Str`` ``->`` [Gender #Gender] ``->`` [PN #PN] ``=`` ``mkPropNoun`` | +| ``mkPN`` | ``Str`` ``->`` [Gender #Gender] ``->`` [Number #Number] ``->`` [PN #PN] ``=`` ``mkProperNoun;`` | +| ``mkPropN`` | ``Str`` ``->`` [PN #PN] ``=`` ``\Ion`` ``->`` | +| ``mkPropNoun`` | ``Str`` ``->`` [Gender #Gender] ``->`` [PN #PN] ``=`` ``\Ion,`` ``gen`` ``->`` | +| ``mkProperNoun`` | ``Str`` ``->`` [Gender #Gender] ``->`` [Number #Number] ``->`` [PN #PN] ``=`` ``\Ion,`` ``gen,`` ``num`` ``->`` | +| ``mkA2`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2 #A2] | + + +==Paradigms for Russian== +#LParadigms + + +source [``http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/russian/ParadigmsRus.gf`` ../src/russian/ParadigmsRus.gf] + + + + +|| Function | Type || +| ``Gender`` | [Type #Type] | +| ``masculine`` | [Gender #Gender] | +| ``feminine`` | [Gender #Gender] | +| ``neuter`` | [Gender #Gender] | +| ``Case`` | [Type #Type] | +| ``nominative`` | [Case #Case] | +| ``genitive`` | [Case #Case] | +| ``dative`` | [Case #Case] | +| ``accusative`` | [Case #Case] | +| ``instructive`` | [Case #Case] | +| ``prepositional`` | [Case #Case] | +| ``Number`` | [Type #Type] | +| ``singular`` | [Number #Number] | +| ``plural`` | [Number #Number] | +| ``mkN`` | ``(karta`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | ``(tigr`` ``:`` ``Str)`` ``->`` [Animacy #Animacy] ``->`` [N #N] | +| ``mkN`` | ``(nomSg,`` ``genSg,`` ``datSg,`` ``accSg,`` ``instSg,`` ``preposSg,`` ``prepos2Sg,`` ``nomPl,`` ``genPl,`` ``datPl,`` ``accPl,`` ``instPl,`` ``preposPl`` ``:`` ``Str)`` ``->`` [Gender #Gender] ``->`` [Animacy #Animacy] ``->`` [N #N] | +| ``mkN2`` | [N #N] ``->`` [N2 #N2] | +| ``mkN2`` | [N #N] ``->`` [Prep #Prep] ``->`` [N2 #N2] | +| ``mkN3`` | [N #N] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [N3 #N3] | +| ``mkPN`` | ``Str`` ``->`` [Gender #Gender] ``->`` [Animacy #Animacy] ``->`` [PN #PN] | +| ``nounPN`` | [N #N] ``->`` [PN #PN] | +| ``mkA`` | ``(positive`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(positive,`` ``comparative`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA2`` | [A #A] ``->`` ``Str`` ``->`` [Case #Case] ``->`` [A2 #A2] | +| ``mkAdv`` | ``Str`` ``->`` [Adv #Adv] | +| ``mkV`` | [Aspect #Aspect] ``->`` ``(presentSgP1,presentSgP2,presentSgP3,`` | +| ``pastSgP1,imperative,infinitive`` | ``Str)`` ``->`` [V #V] | +| ``mkV2`` | [V #V] ``->`` ``Str`` ``->`` [Case #Case] ``->`` [V2 #V2] | +| ``mkV3`` | [V #V] ``->`` ``Str`` ``->`` ``Str`` ``->`` [Case #Case] ``->`` [Case #Case] ``->`` [V3 #V3] | +| ``dirV2`` | [V #V] ``->`` [V2 #V2] | +| ``tvDirDir`` | [V #V] ``->`` [V3 #V3] | + + +==Paradigms for Spanish== +#LParadigms + + +source [``http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/spanish/ParadigmsSpa.gf`` ../src/spanish/ParadigmsSpa.gf] + + + + +|| Function | Type || +| ``Gender`` | [Type #Type] | +| ``masculine`` | [Gender #Gender] | +| ``feminine`` | [Gender #Gender] | +| ``Number`` | [Type #Type] | +| ``singular`` | [Number #Number] | +| ``plural`` | [Number #Number] | +| ``accusative`` | [Prep #Prep] | +| ``genitive`` | [Prep #Prep] | +| ``dative`` | [Prep #Prep] | +| ``mkPrep`` | ``Str`` ``->`` [Prep #Prep] | +| ``mkN`` | ``(luz`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | ``Str`` ``->`` [Gender #Gender] ``->`` [N #N] | +| ``mkN`` | ``(baston,bastones`` ``:`` ``Str)`` ``->`` [Gender #Gender] ``->`` [N #N] | +| ``compN`` | [N #N] ``->`` ``Str`` ``->`` [N #N] | +| ``mkN2`` | [N #N] ``->`` [Prep #Prep] ``->`` [N2 #N2] | +| ``deN2`` | [N #N] ``->`` [N2 #N2] | +| ``aN2`` | [N #N] ``->`` [N2 #N2] | +| ``mkN3`` | [N #N] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [N3 #N3] | +| ``mkPN`` | ``(Anna`` ``:`` ``Str)`` ``->`` [PN #PN] | +| ``mkPN`` | ``(Pilar`` ``:`` ``Str)`` ``->`` [Gender #Gender] ``->`` [PN #PN] | +| ``mkA`` | ``(util`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(solo,sola,solos,solas,solamente`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(bueno`` ``:`` ``A)`` ``->`` ``(mejor`` ``:`` ``A)`` ``->`` [A #A] | +| ``prefixA`` | [A #A] ``->`` [A #A] | +| ``mkA2`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2 #A2] | +| ``mkAdv`` | ``Str`` ``->`` [Adv #Adv] | +| ``mkAdV`` | ``Str`` ``->`` [AdV #AdV] | +| ``mkAdA`` | ``Str`` ``->`` [AdA #AdA] | +| ``mkV`` | ``(pagar`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``(mostrar,muestro`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | [Verbum #Verbum] ``->`` [V #V] | +| ``reflV`` | [V #V] ``->`` [V #V] | +| ``special_ppV`` | [V #V] ``->`` ``Str`` ``->`` [V #V] | +| ``mkV2`` | ``Str`` ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2 #V2] | +| ``v2V`` | [V2 #V2] ``->`` [V #V] | +| ``mkV3`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V3 #V3] | +| ``dirV3`` | [V #V] ``->`` [Prep #Prep] ``->`` [V3 #V3] | +| ``dirdirV3`` | [V #V] ``->`` [V3 #V3] | +| ``mkV0`` | [V #V] ``->`` [V0 #V0] | +| ``mkVS`` | [V #V] ``->`` [VS #VS] | +| ``mkV2S`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2S #V2S] | +| ``mkVV`` | [V #V] ``->`` [VV #VV] | +| ``deVV`` | [V #V] ``->`` [VV #VV] | +| ``aVV`` | [V #V] ``->`` [VV #VV] | +| ``mkV2V`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V2V #V2V] | +| ``mkVA`` | [V #V] ``->`` [VA #VA] | +| ``mkV2A`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V2A #V2A] | +| ``mkVQ`` | [V #V] ``->`` [VQ #VQ] | +| ``mkV2Q`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2Q #V2Q] | +| ``mkAS`` | [A #A] ``->`` [AS #AS] | +| ``mkA2S`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2S #A2S] | +| ``mkAV`` | [A #A] ``->`` [Prep #Prep] ``->`` [AV #AV] | +| ``mkA2V`` | [A #A] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [A2V #A2V] | +| ``V0`` | [Type #Type] | + + +==Paradigms for Swedish== +#LParadigms + + +source [``http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/swedish/ParadigmsSwe.gf`` ../src/swedish/ParadigmsSwe.gf] + + + + +|| Function | Type || +| ``Gender`` | [Type #Type] | +| ``utrum`` | [Gender #Gender] | +| ``neutrum`` | [Gender #Gender] | +| ``Number`` | [Type #Type] | +| ``singular`` | [Number #Number] | +| ``plural`` | [Number #Number] | +| ``Case`` | [Type #Type] | +| ``nominative`` | [Case #Case] | +| ``genitive`` | [Case #Case] | +| ``mkPrep`` | ``Str`` ``->`` [Prep #Prep] | +| ``noPrep`` | [Prep #Prep] | +| ``mkN`` | ``(apa`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | ``(lik`` ``:`` ``Str)`` ``->`` [Gender #Gender] ``->`` [N #N] | +| ``mkN`` | ``(nyckel,nycklar`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN`` | ``(museum,museet,museer,museerna`` ``:`` ``Str)`` ``->`` [N #N] | +| ``mkN2`` | ``Str`` ``->`` [N2 #N2] | +| ``mkN2`` | [N #N] ``->`` [Prep #Prep] ``->`` [N2 #N2] | +| ``mkN3`` | [N #N] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [N3 #N3] | +| ``mkPN`` | ``Str`` ``->`` [PN #PN] | +| ``mkPN`` | ``Str`` ``->`` [Gender #Gender] ``->`` [PN #PN] | +| ``mkPN`` | ``(jesus,jesu`` ``:`` ``Str)`` ``->`` [Gender #Gender] ``->`` [PN #PN] | +| ``mkA`` | ``(billig`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(bred,brett`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(tung,tyngre,tyngst`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(god,gott,goda,battre,bast`` ``:`` ``Str)`` ``->`` [A #A] | +| ``mkA`` | ``(liten,litet,lilla,sma,mindre,minst,minsta`` ``:`` ``Str)`` ``->`` [A #A] | +| ``compoundA`` | [A #A] ``->`` [A #A] | +| ``mkA2`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2 #A2] | +| ``mkAdv`` | ``Str`` ``->`` [Adv #Adv] | +| ``mkAdV`` | ``Str`` ``->`` [AdV #AdV] | +| ``mkAdA`` | ``Str`` ``->`` [AdA #AdA] | +| ``mkV`` | ``(stämmer`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``(dricka,drack,druckit`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | ``(gå,går,gå,gick,gått,gången`` ``:`` ``Str)`` ``->`` [V #V] | +| ``mkV`` | [V #V] ``->`` ``Str`` ``->`` [V #V] | +| ``depV`` | [V #V] ``->`` [V #V] | +| ``reflV`` | [V #V] ``->`` [V #V] | +| ``mkV2`` | ``Str`` ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [V2 #V2] | +| ``mkV2`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2 #V2] | +| ``mkV3`` | ``Str`` ``->`` [V3 #V3] | +| ``mkV3`` | [V #V] ``->`` [V3 #V3] | +| ``mkV3`` | [V #V] ``->`` [Prep #Prep] ``->`` [V3 #V3] | +| ``mkV3`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V3 #V3] | +| ``mkV0`` | [V #V] ``->`` [V0 #V0] | +| ``mkVS`` | [V #V] ``->`` [VS #VS] | +| ``mkV2S`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2S #V2S] | +| ``mkVV`` | [V #V] ``->`` [VV #VV] | +| ``mkV2V`` | [V #V] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [V2V #V2V] | +| ``mkVA`` | [V #V] ``->`` [VA #VA] | +| ``mkV2A`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2A #V2A] | +| ``mkVQ`` | [V #V] ``->`` [VQ #VQ] | +| ``mkV2Q`` | [V #V] ``->`` [Prep #Prep] ``->`` [V2Q #V2Q] | +| ``mkAS`` | [A #A] ``->`` [AS #AS] | +| ``mkA2S`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2S #A2S] | +| ``mkAV`` | [A #A] ``->`` [AV #AV] | +| ``mkA2V`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2V #A2V] | +| ``V0`` | [Type #Type] | + + + + +%!include: synopsis-browse.txt + + +=An Example of Usage= + + +%!include: synopsis-example.txt + diff --git a/next-lib/src/api/TryBul.gf b/next-lib/src/api/TryBul.gf index 9becc455d..5b58da938 100644 --- a/next-lib/src/api/TryBul.gf +++ b/next-lib/src/api/TryBul.gf @@ -1,7 +1,7 @@ --# -path=.:alltenses:prelude resource TryBul = SyntaxBul, LexiconBul, ParadigmsBul - [mkAdv] ** - open (P = ParadigmsBul), in { + open (P = ParadigmsBul) in { oper diff --git a/next-lib/src/api/TryCat.gf b/next-lib/src/api/TryCat.gf index c1a9acfba..872a85395 100644 --- a/next-lib/src/api/TryCat.gf +++ b/next-lib/src/api/TryCat.gf @@ -1,7 +1,7 @@ --# -path=.:alltenses:prelude resource TryCat = SyntaxCat, LexiconCat, ParadigmsCat - [mkAdv] ** - open (P = ParadigmsCat), in { + open (P = ParadigmsCat) in { oper diff --git a/next-lib/src/api/TryEng.gf b/next-lib/src/api/TryEng.gf index 3204af793..823dc212f 100644 --- a/next-lib/src/api/TryEng.gf +++ b/next-lib/src/api/TryEng.gf @@ -1,7 +1,7 @@ --# -path=.:alltenses:prelude resource TryEng = SyntaxEng-[mkAdN], LexiconEng, ParadigmsEng - [mkAdv,mkAdN,mkOrd] ** - open (P = ParadigmsEng), in { + open (P = ParadigmsEng) in { oper diff --git a/next-lib/src/api/TrySwe.gf b/next-lib/src/api/TrySwe.gf index 1d5612fd3..ea721ac3c 100644 --- a/next-lib/src/api/TrySwe.gf +++ b/next-lib/src/api/TrySwe.gf @@ -1,7 +1,7 @@ --# -path=.:alltenses:prelude resource TrySwe = SyntaxSwe, LexiconSwe, ParadigmsSwe - [mkAdv] ** - open (P = ParadigmsSwe), in { + open (P = ParadigmsSwe) in { oper @@ -9,4 +9,4 @@ oper mkAdv : Str -> Adv = P.mkAdv ; } ; -} \ No newline at end of file +} diff --git a/next-lib/src/french/StructuralFre.gf b/next-lib/src/french/StructuralFre.gf index 8096a0c8e..2bdaeb577 100644 --- a/next-lib/src/french/StructuralFre.gf +++ b/next-lib/src/french/StructuralFre.gf @@ -96,7 +96,7 @@ lin Sg => \\g,c => prepCase c ++ genForms "celui-là" "celle-là" ! g ; Pl => \\g,c => prepCase c ++ genForms "celui-là" "celle-là" ! g } ; - s2 = "-là" + s2 = [] ---- "-là" } ; ---b that_NP = makeNP ["cela"] Masc Sg ; @@ -119,7 +119,7 @@ lin Sg => \\g,c => prepCase c ++ genForms "celui-ci" "celle-ci" ! g ; Pl => \\g,c => prepCase c ++ genForms "celui-ci" "celle-ci" ! g } ; - s2 = "-ci" + s2 = [] ---- "-ci" } ; ---b this_NP = pn2np (mkPN ["ceci"] Masc) ;