From 3b4eaf50171abe37b95c75f16f19d76ef1ae071b Mon Sep 17 00:00:00 2001 From: aarne Date: Fri, 10 Jun 2005 14:59:58 +0000 Subject: [PATCH] editor command pc n ; resource/finnish --- lib/resource-0.6/finnish/ParadigmsFin.gf | 2 +- lib/resource/abstract/Resource.gf | 1 - lib/resource/english/ParadigmsEng.gf | 13 +- lib/resource/finnish/MorphoFin.gf | 1009 +++++++++++++++++++ lib/resource/finnish/SyntaxFin.gf | 1160 ++++++++++++++++++++++ lib/resource/finnish/TypesFin.gf | 134 +++ src/GF/Shell/CommandL.hs | 5 +- src/GF/Shell/Commands.hs | 8 +- src/GF/UseGrammar/Session.hs | 9 +- 9 files changed, 2328 insertions(+), 13 deletions(-) create mode 100644 lib/resource/finnish/MorphoFin.gf create mode 100644 lib/resource/finnish/SyntaxFin.gf create mode 100644 lib/resource/finnish/TypesFin.gf diff --git a/lib/resource-0.6/finnish/ParadigmsFin.gf b/lib/resource-0.6/finnish/ParadigmsFin.gf index d9343d860..ea22ec6ba 100644 --- a/lib/resource-0.6/finnish/ParadigmsFin.gf +++ b/lib/resource-0.6/finnish/ParadigmsFin.gf @@ -294,7 +294,7 @@ oper vOlla = verbOlla ** {lock_V = <>} ; vEi = verbEi ** {lock_V = <>} ; - mkTV = \v,c,p,o -> v ** {s3 = p ; s4 = o ; c = c ; lock_TV = <>} ; +---- mkTV = \v,c,p,o -> v ** {s3 = p ; s4 = o ; c = c ; lock_TV = <>} ; tvCase = \v,c -> mkTV v c [] [] ; tvDir v = mkTransVerbDir v ** {lock_TV = <>} ; } ; diff --git a/lib/resource/abstract/Resource.gf b/lib/resource/abstract/Resource.gf index 117b17478..c675bc1ba 100644 --- a/lib/resource/abstract/Resource.gf +++ b/lib/resource/abstract/Resource.gf @@ -1,4 +1,3 @@ --# -path=.:../../prelude ----- abstract Resource = Rules, Verbphrase ** {} ; abstract Resource = Rules, Clause, Structural ** {} ; diff --git a/lib/resource/english/ParadigmsEng.gf b/lib/resource/english/ParadigmsEng.gf index 685d8fa33..aff5b0a47 100644 --- a/lib/resource/english/ParadigmsEng.gf +++ b/lib/resource/english/ParadigmsEng.gf @@ -54,9 +54,9 @@ oper nominative : Case ; genitive : Case ; --- Prepositions used in many-argument functions are just strings. +-- Prepositions are used in many-argument functions for rection. - Preposition : Type = Str ; + Preposition : Type ; --2 Nouns @@ -187,9 +187,13 @@ oper --2 Prepositions -- --- A preposition is just a string. +-- A preposition as used for rection in the lexicon, as well as to +-- build $PP$s in the resource API, just requires a string. mkPreposition : Str -> Preposition ; + mkPrep : Str -> Prep ; + +-- (These two functions are synonyms.) --2 Verbs -- @@ -282,6 +286,8 @@ oper nominative = Nom ; genitive = Gen ; + Preposition = Str ; + regN = \ray -> let ra = Predef.tk 1 ray ; @@ -360,6 +366,7 @@ oper mkAdA x = ss x ** {lock_AdA = <>} ; mkPreposition p = p ; + mkPrep p = ss p ** {lock_Prep = <>} ; mkV a b c d e = mkVerbP3worst a b c d e ** {s1 = [] ; lock_V = <>} ; diff --git a/lib/resource/finnish/MorphoFin.gf b/lib/resource/finnish/MorphoFin.gf new file mode 100644 index 000000000..85a30ae15 --- /dev/null +++ b/lib/resource/finnish/MorphoFin.gf @@ -0,0 +1,1009 @@ +--# -path=.:../../prelude + +--1 A Simple Finnish Resource Morphology +-- +-- Aarne Ranta 2002 +-- +-- This resource morphology contains definitions needed in the resource +-- syntax. It moreover contains the most usual inflectional patterns. +-- +-- We use the parameter types and word classes defined in $TypesFin.gf$. + +resource MorphoFin = TypesFin ** open Prelude in { + +flags optimize=all ; + +--2 Nouns +-- + +oper + +-- worst-case macro + + mkSubst : Str -> (_,_,_,_,_,_,_,_,_,_ : Str) -> CommonNoun = + \a,vesi,vede,vete,vetta,veteen,vetii,vesii,vesien,vesia,vesiin -> + {s = table { + NCase Sg Nom => vesi ; + NCase Sg Gen => vede + "n" ; + NCase Sg Part => vetta ; + NCase Sg Transl => vede + "ksi" ; + NCase Sg Ess => vete + ("n" + a) ; + NCase Sg Iness => vede + ("ss" + a) ; + NCase Sg Elat => vede + ("st" + a) ; + NCase Sg Illat => veteen ; + NCase Sg Adess => vede + ("ll" + a) ; + NCase Sg Ablat => vede + ("lt" + a) ; + NCase Sg Allat => vede + "lle" ; + NCase Sg Abess => vede + ("tt" + a) ; + + NCase Pl Nom => vede + "t" ; + NCase Pl Gen => vesien ; + NCase Pl Part => vesia ; + NCase Pl Transl => vesii + "ksi" ; + NCase Pl Ess => vetii + ("n" + a) ; + NCase Pl Iness => vesii + ("ss" + a) ; + NCase Pl Elat => vesii + ("st" + a) ; + NCase Pl Illat => vesiin ; + NCase Pl Adess => vesii + ("ll" + a) ; + NCase Pl Ablat => vesii + ("lt" + a) ; + NCase Pl Allat => vesii + "lle" ; + NCase Pl Abess => vesii + ("tt" + a) ; + + NComit => Predef.tk 2 vesia + "ine" ; + NInstruct => Predef.tk 2 vesia + "in" ; + + NPossNom => vete ; + NPossGenPl => Predef.tk 1 vesien ; + NPossTransl Sg => vede + "kse" ; + NPossTransl Pl => vesii + "kse" ; + NPossIllat Sg => Predef.tk 1 veteen ; + NPossIllat Pl => Predef.tk 1 vesiin + } + } ; + +-- A user-friendly variant takes existing forms and infers the vowel harmony. + + mkNoun : (_,_,_,_,_,_,_,_,_,_ : Str) -> CommonNoun = + \talo,talon,talona,taloa,taloon,taloina,taloissa,talojen,taloja,taloihin -> + mkSubst (ifTok Str (Predef.dp 1 talona) "a" "a" "ä") + talo (Predef.tk 1 talon) (Predef.tk 2 talona) taloa taloon + (Predef.tk 2 taloina) (Predef.tk 3 taloissa) talojen taloja taloihin ; + +-- Here some useful special cases; more will be given in $paradigms.Fin.gf$. +-- +-- Nouns with partitive "a"/"ä" ; +-- to account for grade and vowel alternation, three forms are usually enough +-- Examples: "talo", "kukko", "huippu", "koira", "kukka", "syylä",... + + sKukko : (_,_,_ : Str) -> CommonNoun = \kukko,kukon,kukkoja -> + let { + o = Predef.dp 1 kukko ; + a = Predef.dp 1 kukkoja ; + kukkoj = Predef.tk 1 kukkoja ; + i = Predef.dp 1 kukkoj ; + ifi = ifTok Str i "i" ; + kukkoi = ifi kukkoj (Predef.tk 1 kukkoj) ; + e = Predef.dp 1 kukkoi ; + kukoi = Predef.tk 2 kukon + Predef.dp 1 kukkoi + } + in + mkSubst a + kukko + (Predef.tk 1 kukon) + kukko + (kukko + a) + (kukko + o + "n") + (kukkoi + ifi "" "i") + (kukoi + ifi "" "i") + (ifTok Str e "e" (Predef.tk 1 kukkoi + "ien") (kukkoi + ifi "en" "jen")) + kukkoja + (kukkoi + ifi "in" "ihin") ; + + sLukko : Str -> CommonNoun = \lukko -> + let + o = last lukko ; + lukk = init lukko ; + a = getHarmony o ; + lukkoja = case o of { + "a" => lukk + "oja" ; + "ä" => lukk + "iä" ; + _ => lukko + "j" + a + } + in + sKukko lukko (weakGrade lukko + "n") lukkoja ; + +-- The special case with no alternations. + + sTalo : Str -> CommonNoun = sLukko ; + + sBaari : Str -> CommonNoun = \baaria -> + let + baari = Predef.tk 1 baaria ; + baar = Predef.tk 1 baari ; + a = getHarmony (Predef.dp 1 baaria) + in + sKukko baari (baari + "n") (baar + ("ej" + a)) ; + + sKorpi : (_,_,_ : Str) -> CommonNoun = \korpi,korven,korpena -> + let { + a = Predef.dp 1 korpena ; + korpe = Predef.tk 2 korpena ; + korve = Predef.tk 1 korven ; + korvi = Predef.tk 1 korve + "i" + } + in + mkSubst a + korpi + korve + korpe + (korpe + a) + (korpe + "en") + korpi + korvi + (korpi + "en") + (korpi + a) + (korpi + "in") ; + + sArpi : Str -> CommonNoun = \arpi -> + sKorpi arpi (init (weakGrade arpi) + "en") (init arpi + "ena") ; + sSylki : Str -> CommonNoun = \sylki -> + sKorpi sylki (init (weakGrade sylki) + "en") (init sylki + "enä") ; + + sKoira : Str -> CommonNoun = \koira -> + let a = getHarmony (last koira) in + sKukko koira (koira + "n") (init koira + "i" + a) ; + +-- Loan words ending in consonants are actually similar to words like +-- "malli"/"mallin"/"malleja", with the exception that the "i" is not attached +-- to the singular nominative. + + sLinux : Str -> CommonNoun = \linuxia -> + let { + linux = Predef.tk 2 linuxia ; + a = getHarmony (Predef.dp 1 linuxia) ; + linuxi = linux + "i" + } in + mkSubst a + linux + linuxi + linuxi + (linuxi + a) + (linuxi + "in") + (linux + "ei") + (linux + "ei") + (linux + "ien") + (linux + "eja") + (linux + "eihin") ; + +-- Nouns of at least 3 syllables ending with "a" or "ä", like "peruna", "rytinä". + + sPeruna : Str -> CommonNoun = \peruna -> + let { + a = Predef.dp 1 peruna ; + perun = Predef.tk 1 peruna ; + perunoi = perun + (ifTok Str a "a" "o" "ö" + "i") + } + in + mkSubst a + peruna + peruna + peruna + (peruna + a) + (peruna + a + "n") + perunoi + perunoi + (perunoi + "den") + (perunoi + ("t" + a)) + (perunoi + "hin") ; + +-- Surpraisingly, making the test for the partitive, this not only covers +-- "rae", "perhe", "savuke", but also "rengas", "lyhyt" (except $Sg Illat$), etc. + + sRae : (_,_ : Str) -> CommonNoun = \rae,rakeena -> + let { + a = Predef.dp 1 rakeena ; + rakee = Predef.tk 2 rakeena ; + rakei = Predef.tk 1 rakee + "i" ; + raet = rae + (ifTok Str (Predef.dp 1 rae) "e" "t" []) + } + in + mkSubst a + rae + rakee + rakee + (raet + ("t" + a)) + (rakee + "seen") + rakei + rakei + (rakei + "den") + (rakei + ("t" + a)) + (rakei + "siin") ; + + sSusi : (_,_,_ : Str) -> CommonNoun = \susi,suden,sutena -> + let { + a = Predef.dp 1 sutena ; + sude = Predef.tk 1 suden ; + sute = Predef.tk 2 sutena + } + in + mkSubst a + susi + sude + sute + (Predef.tk 1 sute + ("t" + a)) + (sute + "en") + susi + susi + (susi + "en") + (susi + a) + (susi + "in") ; + + sPuu : Str -> CommonNoun = \puu -> + let { + u = Predef.dp 1 puu ; + a = getHarmony u ; + pu = Predef.tk 1 puu ; + pui = pu + "i" + } + in + mkSubst a + puu + puu + puu + (puu + ("t" + a)) + (puu + ("h" + u + "n")) + pui + pui + (pui + "den") + (pui + ("t" + a)) + (pui + "hin") ; + + sSuo : Str -> CommonNoun = \suo -> + let { + o = Predef.dp 1 suo ; + a = getHarmony o ; + soi = Predef.tk 2 suo + (o + "i") + } + in + mkSubst a + suo + suo + suo + (suo + ("t" + a)) + (suo + ("h" + o + "n")) + soi + soi + (soi + "den") + (soi + ("t" + a)) + (soi + "hin") ; + +-- Here in fact it is handy to use the partitive form as the only stem. + + sNainen : Str -> CommonNoun = \naista -> + let { + nainen = Predef.tk 3 naista + "nen" ; + nais = Predef.tk 2 naista ; + naise = nais + "e" ; + naisi = nais + "i" ; + a = Predef.dp 1 naista + } + in + mkSubst a + nainen + naise + naise + (nais + ("t" + a)) + (nais + "een") + naisi + naisi + (nais + "ten") + (nais + ("i" + a)) + (nais + "iin") ; + +-- The following covers: "tilaus", "kaulin", "paimen", "laidun", "sammal", +-- "kyynel" (excep $Sg Iness$ for the last two?). + + sTilaus : (_,_ : Str) -> CommonNoun = \tilaus, tilauksena -> + let { + tilauks = Predef.tk 3 tilauksena ; + tilaukse = tilauks + "e" ; + tilauksi = tilauks + "i" ; + a = Predef.dp 1 tilauksena + } + in + mkSubst a + tilaus + tilaukse + tilaukse + (tilaus + ("t" + a)) + (tilauks + "een") + tilauksi + tilauksi + (tilaus + "ten") + (tilauks + ("i" + a)) + (tilauks + "iin") ; + +-- Some words have the three grades ("rakkaus","rakkauden","rakkautena"), which +-- are however derivable from the stem. + + sRakkaus : Str -> CommonNoun = \rakkaus -> + let { + rakkau = Predef.tk 1 rakkaus ; + rakkaut = rakkau + "t" ; + rakkaute = rakkau + "te" ; + rakkaude = rakkau + "de" ; + rakkauksi = rakkau + "ksi" ; + u = Predef.dp 1 rakkau ; + a = ifTok Str u "u" "a" "ä" + } + in + mkSubst a + rakkaus + rakkaude + rakkaute + (rakkaut + ("t" + a)) + (rakkaut + "een") + rakkauksi + rakkauksi + (rakkauksi + "en") + (rakkauksi + a) + (rakkauksi + "in") ; + +-- The following covers nouns like "nauris" and adjectives like "kallis", "tyyris". + + sNauris : (_ : Str) -> CommonNoun = \naurista -> + let { + a = Predef.dp 1 naurista ; + nauris = Predef.tk 2 naurista ; + nauri = Predef.tk 3 naurista ; + i = Predef.dp 1 nauri ; + naurii = nauri + i ; + naurei = nauri + "i" + } + in + mkSubst a + nauris + naurii + naurii + (nauris + ("t" + a)) + (naurii + "seen") + naurei + naurei + (naurei + "den") + (naurei + ("t" + a)) + (naurei + "siin") ; + +-- The following two are used for adjective comparison. + + sSuurempi : Str -> CommonNoun = \suurempaa -> + let { + a = Predef.dp 1 suurempaa ; + suure = Predef.tk 4 suurempaa ; + suurempi = suure + "mpi" ; + suurempa = suure + ("mp" + a) ; + suuremm = suure + "mm" + } + in + mkSubst a + suurempi + (suuremm + a) + suurempa + (suurempa + a) + (suurempa + (a + "n")) + suurempi + (suuremm + "i") + (suurempi + "en") + (suurempi + a) + (suurempi + "in") ; + + sSuurin : Str -> CommonNoun = \suurinta -> + let { + a = Predef.dp 1 suurinta ; + suuri = Predef.tk 3 suurinta ; + suurin = suuri + "n" ; + suurimma = suuri + ("mm" + a) ; + suurimpa = suuri + ("mp" + a) ; + suurimpi = suuri + "mpi" ; + suurimmi = suuri + "mmi" + } + in + mkSubst a + suurin + suurimma + suurimpa + (suurin + ("t" + a)) + (suurimpa + (a + "n")) + suurimpi + suurimmi + (suurimpi + "en") + (suurimpi + a) + (suurimpi + "in") ; + +-- The almost-regular heuristic analyses three forms. + +reg3Noun : (_,_,_ : Str) -> CommonNoun = \vesi,veden,vesiä -> + let + esi = Predef.dp 3 vesi ; -- analysis: suffixes + si = Predef.dp 2 esi ; + i = last si ; + s = init si ; + den = Predef.dp 3 veden ; + d = Predef.tk 2 den ; + esiä = Predef.dp 4 vesiä ; + a = last vesiä ; + ves = init vesi ; -- synthesis: prefixes + ve = init ves ; + ved = Predef.tk 2 veden ; + sRae_vesi = sRae vesi (veden + a) ; + sKukko_vesi = sKukko vesi veden vesiä + in + case si of { + "aa" | "ee" | "ii" | "oo" | "uu" | "yy" | "ää" | "öö" => sPuu vesi ; + "ie" | "uo" | "yö" => sSuo vesi ; + "is" => sNauris (vesi + ("t" + a)) ; + "ut" | "yt" => sRae vesi (ves + ("en" + a)) ; + "si" => + ifTok CommonNoun d s + sKukko_vesi + (sSusi vesi veden (ve + ("ten" + a))) ; + "us" | "ys" => + ifTok CommonNoun d "s" + (sTilaus vesi (veden + a)) + (sRakkaus vesi) ; + "ki" | "pi" | "ti" => + ifTok CommonNoun d s + sKukko_vesi + (sKorpi vesi veden (ves + ("en" + a))) ; + _ => case esi of { + "nen" => sNainen (Predef.tk 3 vesi + ("st" + a)) ; + _ => case esiä of { + "oita" | "öitä" => sPeruna vesi ; + _ => case den of { + "een" => sRae_vesi ; + _ => case i of { + "a" | "ä" => sKukko vesi veden vesiä ; + "i" => sBaari (vesi + a) ; + "o" | "u" | "y" | "ö" => sKukko vesi veden vesiä ; + _ => sLinux (vesi + "i" + a) +{- + _ => case i of { + "b" | "c" | "d" | "f" | "g" | "h" | "j" | "k" | "l" | "m" | "n" | + "p" | "q" | "r" | "s" | "t" | "v" | "w" | "x" | "z" => sLinux (vesi + "i" + a) +-} + } + } + } + } + } ; + +-- The regular heuristic takes just one form and analyses its suffixes. + +regNoun : Str -> CommonNoun = \vesi -> + let + esi = Predef.dp 3 vesi ; -- analysis: suffixes + si = Predef.dp 2 esi ; + i = last si ; + s = init si ; + occ : Str -> Bool = \a -> pbool2bool (Predef.occur a vesi) ; + a = if_then_Str (orB (occ "a") (orB (occ "o") (occ "u"))) "a" "ä" ; + ves = init vesi ; -- synthesis: prefixes + ve = init ves ; + in + case esi of { + "uus" | "yys" => sRakkaus vesi ; + "nen" => sNainen (Predef.tk 3 vesi + ("st" + a)) ; + + _ => case si of { + "aa" | "ee" | "ii" | "oo" | "uu" | "yy" | "ää" | "öö" => sPuu vesi ; + "ie" | "uo" | "yö" => sSuo vesi ; + "is" => sNauris (vesi + ("t" + a)) ; + "ut" | "yt" => sRae vesi (ves + ("en" + a)) ; + "uus" | "yys" => sRakkaus vesi ; + "us" | "ys" => sTilaus vesi (ves + ("ksen" + a)) ; + _ => case i of { + "i" => sBaari (vesi + a) ; + "e" => sRae vesi (strongGrade ves + ("een" + a)) ; + "a" | "o" | "u" | "y" | "ä" | "ö" => sLukko vesi ; + _ => sLinux (vesi + "i" + a) + } + } + } ; + +-- This auxiliary resolves vowel harmony from a given letter. + +getHarmony : Str -> Str = \u -> case u of { + "a" => "a" ; + "o" => "a" ; + "u" => "a" ; + _ => "ä" + } ; + + +-- The following function defines how grade alternation works if it is active. +-- In general, *whether there is* grade alternation must be given in the lexicon +-- (cf. "auto" - "auton", not "audon"). + + weakGrade : Str -> Str = \kukko -> + let { + kukk = init kukko ; + ku = Predef.tk 3 kukko ; + kul = Predef.tk 2 kukko ; + kk = init (Predef.dp 3 kukko) ; + k = last kk ; + o = last kukko ; + kuk = case kk of { + "kk" => ku + "k" ; + "pp" => ku + "p" ; + "tt" => ku + "t" ; + "nk" => ku + "ng" ; + "nt" => ku + "nn" ; + "mp" => ku + "mm" ; + "rt" => ku + "rr" ; + "lt" => ku + "ll" ; + "lk" => kul + case o of { + "i" => "j" ; + _ => "" + } ; + "rk" => kul + case o of { + "i" => "j" ; + _ => "" + } ; + "hk" => kukk ; -- *tahko-tahon + "sk" => kukk ; -- *lasku-lasvun + "sp" => kukk ; -- *raspi-rasvin + "st" => kukk ; -- *lastu-lasdun + _ => case k of { + "k" => case o of { + "u" => kul + "v" ; + _ => kul + }; + "p" => kul + "v" ; + "t" => kul + "d" ; + _ => kukk + } + } + } + in kuk + o ; + +--- This is only used to analyse nouns "rae", "hake", etc. + + strongGrade : Str -> Str = \hak -> + let + ha = init hak ; + k = last hak ; + ly = Predef.tk 2 hak ; + hd = Predef.dp 2 hak + in + case hd of { + "ng" => ha + "nk" ; + "nn" => ha + "nt" ; + "mm" => ha + "mp" ; + "rr" => ha + "rt" ; + "ll" => ha + "lt" ; + "lj" => ha + "lk" ; + "hk" | "sk" | "sp" | "st" => hak ; + _ => -- vihje/pohje: impossible to infer + case k of { + "k" => hak + "k" ; + "p" => hak + "p" ; + "t" => hak + "t" ; + "d" => ha + "t" ; + "v" => ha + "p" ; + "a" | "ä" => hak + "k" ; + _ => hak + } + } ; + + +--3 Proper names +-- +-- Proper names are similar to common nouns in the singular. + + mkProperName : CommonNoun -> ProperName = \jussi -> + {s = \\c => jussi.s ! NCase Sg c} ; + +--2 Pronouns +-- +-- Here we define personal and relative pronouns. + + mkPronoun : (_,_,_,_,_ : Str) -> Number -> Person -> Pronoun = + \mina, minun, minua, minuna, minuun, n, p -> + let { + minu = Predef.tk 2 minuna ; + a = Predef.dp 1 minuna + } in + {s = table { + PCase Nom => mina ; + PCase Gen => minun ; + PCase Part => minua ; + PCase Transl => minu + "ksi" ; + PCase Ess => minuna ; + PCase Iness => minu + ("ss" + a) ; + PCase Elat => minu + ("st" + a) ; + PCase Illat => minuun ; + PCase Adess => minu + ("ll" + a) ; + PCase Ablat => minu + ("lt" + a) ; + PCase Allat => minu + "lle" ; + PCase Abess => minu + ("tt" + a) ; + PAcc => Predef.tk 1 minun + "t" + } ; + n = n ; p = p} ; + + pronMina = mkPronoun "minä" "minun" "minua" "minuna" "minuun" Sg P1 ; + pronSina = mkPronoun "sinä" "sinun" "sinua" "sinuna" "sinuun" Sg P2 ; + pronHan = mkPronoun "hän" "hänen" "häntä" "hänenä" "häneen" Sg P3 ; + pronMe = mkPronoun "me" "meidän" "meitä" "meinä" "meihin" Pl P1 ; + pronTe = mkPronoun "te" "teidän" "teitä" "teinä" "teihin" Pl P2 ; + pronHe = mkPronoun "he" "heidän" "heitä" "heinä" "heihin" Pl P3 ; + pronNe = mkPronoun "ne" "niiden" "niitä" "niinä" "niihin" Pl P3 ; + + pronTama = mkPronoun "tämä" "tämän" "tätä" "tänä" "tähän" Sg P3 ; + pronNama = mkPronoun "nämä" "näiden" "näitä" "näinä" "näihin" Pl P3 ; + pronTuo = mkPronoun "tuo" "tuon" "tuota" "tuona" "tuohon" Sg P3 ; + pronNuo = mkPronoun "nuo" "noiden" "noita" "noina" "noihin" Pl P3 ; + +-- The non-human pronoun "se" ('it') is even more irregular, +-- Its accusative cases do not +-- have a special form with "t", but have the normal genitive/nominative variation. +-- We use the type $ProperName$ for "se", because of the accusative but also +-- because the person and number are as for proper names. + + pronSe : ProperName = { + s = table { + Nom => "se" ; + Gen => "sen" ; + Part => "sitä" ; + Transl => "siksi" ; + Ess => "sinä" ; + Iness => "siinä" ; + Elat => "siitä" ; + Illat => "siihen" ; + Adess => "sillä" ; + Ablat => "siltä" ; + Allat => "sille" ; + Abess => "sittä" + } ; + } ; + +-- The possessive suffixes will be needed in syntax. It will show up +-- as a separate word ("auto &+ ni"), which needs unlexing. Unlexing also +-- has to fix the vowel harmony in cases like "äiti &+ nsä". + + suff : Str -> Str = \ni -> BIND ++ ni ; + + possSuffix : Number => Person => Str = \\n,p => + suff (case of { + => "ni" ; + => "si" ; + => "nsa" ; + => "mme" ; + => "nne" ; + => "nsa" + } ) ; + +-- The relative pronoun, "joka", is inflected in case and number, +-- like common nouns, but it does not take possessive suffixes. +-- The inflextion shows a surprising similarity with "suo". + + relPron : RelPron = + let {jo = sSuo "jo"} in {s = + table { + Sg => table { + Nom => "joka" ; + Gen => "jonka" ; + c => jo.s ! NCase Sg c + } ; + Pl => table { + Nom => "jotka" ; + c => "j" + (jo.s ! NCase Pl c) + } + } + } ; + + mikaInt : Number => Case => Str = + let { + mi = sSuo "mi" + } in + table { + Sg => table { + Nom => "mikä" ; + Gen => "minkä" ; + c => mi.s ! NCase Sg c + } ; + Pl => table { + Nom => "mitkä" ; + Gen => "mittenkä" ; + c => mi.s ! NCase Sg c + } + } ; + + kukaInt : Number => Case => Str = + let { + ku = sRae "kuka" "kenenä" ; + ket = sRae "kuka" "keinä"} in + table { + Sg => table { + Nom => "kuka" ; + Part => "ketä" ; + Illat => "keneen" ; + c => ku.s ! NCase Sg c + } ; + Pl => table { + Nom => "ketkä" ; + Illat => "keihin" ; + c => ket.s ! NCase Pl c + } + } ; + + mikaanPron : Number => Case => Str = \\n,c => + case of { + => "mikään" ; + <_,Part> => "mitään" ; + => "minkään" ; + => "mitkään" ; + => "mittenkään" ; + <_,Ess> => "minään" ; + <_,Iness> => "missään" ; + <_,Elat> => "mistään" ; + <_,Adess> => "millään" ; + <_,Ablat> => "miltään" ; + _ => mikaInt ! n ! c + "kään" + } ; + + kukaanPron : Number => Case => Str = + table { + Sg => table { + Nom => "kukaan" ; + Part => "ketään" ; + Ess => "kenään" ; + Iness => "kessään" ; + Elat => "kestään" ; + Illat => "kehenkään" ; + Adess => "kellään" ; + Ablat => "keltään" ; + c => kukaInt ! Sg ! c + "kään" + } ; + Pl => table { + Nom => "ketkään" ; + Part => "keitään" ; + Ess => "keinään" ; + Iness => "keissään" ; + Elat => "keistään" ; + Adess => "keillään" ; + Ablat => "keiltään" ; + c => kukaInt ! Pl ! c + "kään" + } + } ; + + jokuPron : Number => Case => Str = + let + ku = sPuu "ku" ; + kui = sPuu "kuu" + in + table { + Sg => table { + Nom => "joku" ; + Gen => "jonkun" ; + c => relPron.s ! Sg ! c + ku.s ! NCase Sg c + } ; + Pl => table { + Nom => "jotkut" ; + c => relPron.s ! Pl ! c + kui.s ! NCase Pl c + } + } ; + + jokinPron : Number => Case => Str = + table { + Sg => table { + Nom => "jokin" ; + Gen => "jonkin" ; + c => relPron.s ! Sg ! c + "kin" + } ; + Pl => table { + Nom => "jotkin" ; + c => relPron.s ! Pl ! c + "kin" + } + } ; + +moniPron : Case => Str = caseTable singular (sSusi "moni" "monen" "monena") ; + +caseTable : Number -> CommonNoun -> Case => Str = \n,cn -> + \\c => cn.s ! NCase n c ; + + +--2 Adjectives +-- +-- To form an adjective, it is usually enough to give a noun declension: the +-- adverbial form is regular. + + noun2adj : CommonNoun -> Adjective = noun2adjComp True ; + + noun2adjComp : Bool -> CommonNoun -> Adjective = \isPos,tuore -> + let + tuoreesti = Predef.tk 1 (tuore.s ! NCase Sg Gen) + "sti" ; + tuoreemmin = Predef.tk 2 (tuore.s ! NCase Sg Gen) + "in" + in {s = table { + AN f => tuore.s ! f ; + AAdv => if_then_Str isPos tuoreesti tuoreemmin + } + } ; + +-- For the comparison of adjectives, three noun declensions +-- are needed in the worst case. + + mkAdjDegr : (_,_,_ : Adjective) -> AdjDegr = \hyva,parempi,paras -> + {s = table { + Pos => hyva.s ; + Comp => parempi.s ; + Sup => paras.s + } + } ; + +-- However, it is usually enough to give the positive declension and +-- the characteristic forms of comparative and superlative. + + regAdjDegr : CommonNoun -> Str -> Str -> AdjDegr = \kiva, kivempaa, kivinta -> + mkAdjDegr + (noun2adj kiva) + (noun2adjComp False (sSuurempi kivempaa)) + (noun2adjComp False (sSuurin kivinta)) ; + + +--3 Verbs +-- + + mkVerb : (_,_,_,_,_,_ : Str) -> Verb = + \tulla,tulen,tulee,tulevat,tulkaa,tullaan -> + let { + tule = Predef.tk 1 tulen ; + a = Predef.dp 1 tulkaa + } in + {s = table { + Inf => tulla ; + Pres Sg P1 => tulen ; + Pres Sg P2 => tule + "t" ; + Pres Sg P3 => tulee ; + Pres Pl P1 => tule + "mme" ; + Pres Pl P2 => tule + "tte" ; + Pres Pl P3 => tulevat ; + Imper Sg => tule ; + Imper Pl => tulkaa ; + ImpNegPl => Predef.tk 2 tulkaa + (ifTok Str a "a" "o" "ö") ; + Pass True => tullaan ; + Pass False => Predef.tk 2 tullaan ; + p => tulla + Predef.show VForm p ---- + } + } ; + +-- For "harppoa", "hukkua", "löytyä", with grade alternation. + + vHukkua : (_,_ : Str) -> Verb = \hukkua,huku -> + let { + a = Predef.dp 1 hukkua ; + hukku = Predef.tk 1 hukkua ; + u = Predef.dp 1 huku + } in + mkVerb + hukkua + (huku + "n") + (hukku + u) + (hukku + (("v" + a) + "t")) + (hukku + (("k" + a) + a)) + (huku + ((("t" + a) + a) + "n")) ; + +-- For cases without alternation: "sanoa", "valua", "kysyä". + + vSanoa : Str -> Verb = \sanoa -> + vHukkua sanoa (Predef.tk 1 sanoa) ; + +-- For "ottaa", "käyttää", "löytää", "huoltaa", "hiihtää", "siirtää". + + vOttaa : (_,_ : Str) -> Verb = \ottaa,otan -> + let { + a = Predef.dp 1 ottaa ; + ota = Predef.tk 1 otan ; + otta = Predef.tk 1 ottaa ; + ote = Predef.tk 1 ota + "e" + } in + mkVerb + ottaa + (ota + "n") + ottaa + (otta + (("v" + a) + "t")) + (otta + (("k" + a) + a)) + (ote + ((("t" + a) + a) + "n")) ; + +-- For "poistaa", "ryystää". + + vPoistaa : Str -> Verb = \poistaa -> + vOttaa poistaa (Predef.tk 1 poistaa + "n") ; + +-- For "osata", "lisätä" + + vOsata : Str -> Verb = \osata -> + let { + a = Predef.dp 1 osata ; + osa = Predef.tk 2 osata + } in + mkVerb + osata + (osa + (a + "n")) + (osa + a) + (osa + ((("a" + "v") + a) + "t")) + (osa + ((("t" + "k") + a) + a)) + (osata + (a + "n")) ; + +-- For "juosta", "piestä", "nousta", "rangaista", "kävellä", "surra", "panna". + + vJuosta : (_,_ : Str) -> Verb = \juosta,juoksen -> + let { + a = Predef.dp 1 juosta ; + juokse = Predef.tk 1 juoksen ; + juos = Predef.tk 2 juosta + } in + mkVerb + juosta + juoksen + (juokse + "e") + (juokse + (("v" + a) + "t")) + (juos + (("k" + a) + a)) + (juosta + (a + "n")) ; + +-- For "juoda", "syödä". + + vJuoda : Str -> Verb = \juoda -> + let { + a = Predef.dp 1 juoda ; + juo = Predef.tk 2 juoda + } in + mkVerb + juoda + (juo + "n") + juo + (juo + (("v" + a) + "t")) + (juo + (("k" + a) + a)) + (juoda + (a + "n")) ; + + + verbOlla : Verb = mkVerb "olla" "olen" "on" "ovat" "olkaa" "ollaan" ; + +-- The negating operator "ei" is actually a verb, which has present +-- active indicative and imperative forms, but no infinitive. + + verbEi : Verb = + let {ei = mkVerb nonExist "en" "ei" "eivät" "älkää" "ei"} in + {s = table { + Pres Pl P3 => "eivät" ; + v => ei.s ! v + } + } ; + + +--2 Some structural words + + kuinConj = "kuin" ; + + conjEtta = "että" ; + advSiten = "siten" ; + + mikakukaInt : Gender => Number => Case => Str = + table { + NonHuman => mikaInt ; + Human => kukaInt + } ; + + kaikkiPron : Number -> Case => Str = \n -> + let {kaiket = caseTable n (sKorpi "kaikki" "kaiken" "kaikkena")} in + table { + Nom => "kaikki" ; + c => kaiket ! c + } ; + + stopPunct = "." ; + commaPunct = "," ; + questPunct = "?" ; + exclPunct = "!" ; + + koPart = suff "ko" ; + +} ; diff --git a/lib/resource/finnish/SyntaxFin.gf b/lib/resource/finnish/SyntaxFin.gf new file mode 100644 index 000000000..7798b5543 --- /dev/null +++ b/lib/resource/finnish/SyntaxFin.gf @@ -0,0 +1,1160 @@ +--1 A Small Finnish Resource Syntax +-- +-- Aarne Ranta 2003 +-- +-- This resource grammar contains definitions needed to construct +-- indicative, interrogative, and imperative sentences in Finnish. +-- +-- The following files are presupposed: + +resource SyntaxFin = MorphoFin ** open Prelude, (CO = Coordination) in { + +--2 Common Nouns +-- +-- Simple common nouns are defined as the type $CommNoun$ in $MorphoFin$. + +--3 Common noun phrases + +-- In Finnish, common noun phrases behave like simple common nouns, except that +-- we need a kind of a *gender* parameter telling if the noun is human or not. +-- This parameter regulates determiners such as "joku"/"jokin" ('some') and +-- "kuka"/"mikä" ('which'). +-- +-- A subtle reason forces us to distinguish the parameters of common noun phrases +-- from those of morphological common nouns: the parameter value $NPossNom$ is +-- syntactically applicable to each of $Sg Nom$, $Pl Nom$, $Sg Gen$. In morphology, +-- these forms are always the same ("autoni"), but with complex common nouns, we +-- have three different forms: "iso autoni", "isot autoni", "ison autoni". + +oper + CommNoun = {s : NForm => Str ; g : Gender} ; + + CommNounPhrase = {s : Bool => Number => Case => Str ; g : Gender} ; + + noun2CommNounPhrase : CommNoun -> CommNounPhrase = \man -> + useCN man ** {g = man.g} ; + + n2n = noun2CommNounPhrase ; + + useCN : CommonNoun -> {s : Bool => Number => Case => Str} = \auto -> + {s = table { + True => \\n,c => case of { + <_, Nom> => auto.s ! NPossNom ; + => auto.s ! NPossNom ; + => auto.s ! NPossGenPl ; + <_,Transl> => auto.s ! NPossTransl n ; + <_,Illat> => auto.s ! NPossIllat n ; + _ => auto.s ! NCase n c + } ; + False => \\n,c => auto.s ! NCase n c + } + } ; + + cnNoHum : CommonNoun -> CommNoun = \cn -> cn ** {g = NonHuman} ; + cnHum : CommonNoun -> CommNoun = \cn -> cn ** {g = Human} ; + +--2 Noun phrases +-- +-- Two forms of *virtual accusative* are needed for nouns in singular, +-- the nominative and the genitive one ("ostan talon"/"osta talo"). +-- For nouns in plural, only a nominative accusative exist. Pronouns +-- have a uniform, special accusative form ("minut", etc). + +param + NPForm = NPCase Case | NPAccNom | NPAccGen ; + +-- The *person* of a noun phrase is also special, to steer the use of +-- possessive suffixes. It expresses a distinction between pronominal and +-- non-pronominal noun phrases. The pronominal ones impose possessive suffixes +-- in genitival constructions ("minun taloni", "hänen talonsa"), the non-pronominal +-- ones don't ("Jussin talo"). As for verbal agreement, non-pronominal noun +-- phrases are third-person. + + NPPerson = NP3 | NPP Person ; + +oper + np2Person : NPPerson -> Person = \n -> case n of { + NP3 => P3 ; + NPP p => p + } ; + +oper + npForm2Case : Number -> NPForm -> Case = \n,f -> case f of { + NPCase c => c ; + NPAccNom => Nom ; + NPAccGen => case n of { + Sg => Gen ; + Pl => Nom + } + } ; + + npForm2PForm : NPForm -> PForm = \f -> case f of { + NPCase c => PCase c ; + _ => PAcc + } ; + + NounPhrase : Type = {s : NPForm => Str ; n : Number ; p : NPPerson} ; + + nameNounPhrase : ProperName -> NounPhrase = \jussi -> + {s = \\f => jussi.s ! npForm2Case Sg f ; n = Sg ; p = NP3} ; + + singularNounPhrase : CommNounPhrase -> NounPhrase = \cn -> + {s = \\f => cn.s ! False ! Sg ! (npForm2Case Sg f) ; n = Sg ; p = NP3} ; + + pluralNounPhrase : CommNounPhrase -> NounPhrase = \cn -> + {s = \\f => cn.s ! False ! Pl ! (npForm2Case Pl f) ; n = Pl ; p = NP3} ; + + pronNounPhrase : Pronoun -> NounPhrase = \pron -> + {s = \\f => pron.s ! npForm2PForm f ; n = pron.n ; p = NPP pron.p} ; + + pronNounPhraseNP : Pronoun -> NounPhrase = \pron -> + {s = table { + NPAccNom => pron.s ! PCase Nom ; + NPAccGen => pron.s ! PCase Gen ; + f => pron.s ! npForm2PForm f + } ; + n = pron.n ; + p = NPP pron.p + } ; + +-- *Partitive noun phrases* use the partitive instead of the nominative +-- and accusative forms. + + npForm2CasePart : NPForm -> Case = \f -> case f of { + NPCase Nom => Part ; + NPCase c => c ; + _ => Part + } ; + + partNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n, cn -> + {s = \\f => cn.s ! False ! n ! (npForm2CasePart f) ; n = n ; p = NP3} ; + + Numeral : Type = {s : NPForm => Str ; isNum : Bool} ; + + pronWithNum : Pronoun -> Numeral -> NounPhrase = \me,kaksi -> + let meihin = pronNounPhraseNP me + in + {s = \\c => meihin.s ! c ++ kaksi.s ! c ; + n = me.n ; + p = NPP me.p --- meidän kahden talo (*talomme) + } ; + + noNum : Numeral = {s = \\_ => [] ; isNum = False} ; + + +--2 Determiners +-- +-- Most determiners are inflected like nouns. They have an inherent number +-- that is given to the noun that is being determined. + + Determiner : Type = {s : Gender => Case => Str ; n : Number ; isNum : Bool} ; + + detNounPhrase : Determiner -> CommNounPhrase -> NounPhrase = \joku, mies -> + {s = \\f => let {c = npForm2Case joku.n f} in + joku.s ! mies.g ! c ++ + mkCaseNum joku.isNum joku.n c (mies.s ! False) ; + n = joku.n ; + p = NP3 + } ; + + mkCaseNum : Bool -> Number -> Case -> (Number => Case => Str) -> Str = + \isNum, n, c, mies -> + case of { + => mies ! Sg ! Part ; -- kolme miestä + => mies ! Sg ! c ; -- kolmelle miehelle + _ => mies ! n ! c + } ; + + mkDeterminerGen : Number -> (_,_ : Case => Str) -> Determiner = \n,mika,kuka -> + {s = table { + NonHuman => mika ; + Human => kuka + } ; + n = n ; + isNum = False + } ; + + mkDeterminerGenNum : Numeral -> (_,_ : Case => Str) -> Determiner = + \n,mika,kuka -> + {s = table { + NonHuman => \\c => mika ! c ++ n.s ! NPCase c ; + Human => \\c => kuka ! c ++ n.s ! NPCase c + } ; + n = Pl ; + isNum = n.isNum + } ; + + mkDeterminer : Number -> (Case => Str) -> Determiner = \n,kaikki -> + mkDeterminerGen n kaikki kaikki ; + + mkDeterminerNum : Numeral -> (Case => Str) -> Determiner = \n,kaikki -> + mkDeterminerGenNum n kaikki kaikki ; + + jokainenDet = mkDeterminer Sg (caseTable Sg (sNainen "jokaista")) ; + kaikkiDet : Numeral -> Determiner = \n -> mkDeterminerNum n (kaikkiPron Pl) ; + useimmatDet = mkDeterminer Pl (caseTable Pl (sSuurin "useinta")) ; + mikaDet = mkDeterminerGen Sg (mikaInt ! Sg) (kukaInt ! Sg) ; + mitkaDet : Numeral -> Determiner = \n -> + mkDeterminerGenNum n (mikaInt ! Pl) (kukaInt ! Pl) ; + + indefNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n,mies -> + case n of { + Sg => singularNounPhrase mies ; -- mies + Pl => partNounPhrase plural mies -- miehiä + } ; + +-- The definite and indefinite numeral phrases differ in case, and a numeral +-- creates partitive for the nominative. + + nounPhraseNum : Bool -> Numeral -> CommNounPhrase -> NounPhrase = + \isDef,n,mies -> + case n.isNum of { + True => { + s = table { + NPCase Nom => n.s ! NPCase Nom ++ mies.s ! False ! Sg ! Part ; + c => n.s ! c ++ mies.s ! False ! Sg ! npForm2Case Sg c + } ; + n = if_then_else Number isDef Pl Sg ; + p = NP3 + } ; + _ => if_then_else NounPhrase isDef + (pluralNounPhrase mies) + (partNounPhrase plural mies) + } ; + + defNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n,mies -> + case n of { + Sg => singularNounPhrase mies ; + Pl => pluralNounPhrase mies + } ; + + +-- Genitives of noun phrases can be used like determiners, to build noun phrases. +-- The number argument makes the difference between "Jussin talo" - "Jussin talot". +-- The NP person of the 'owner' decides if there is a possessive suffix. + + npGenDet : Number -> NounPhrase -> CommNounPhrase -> NounPhrase = \n,jussi,talo -> + {s = \\c => jussi.s ! NPCase Gen ++ + ifPossSuffix talo jussi.p jussi.n (npForm2Case n c) ; + n = n ; + p = NP3 + } ; + + npGenDetNum : Numeral -> NounPhrase -> CommNounPhrase -> NounPhrase = + \viisi,jussi,talo -> + {s = \\c => jussi.s ! NPCase Gen ++ viisi.s ! c ++ + ifPossSuffix talo jussi.p jussi.n ( + case viisi.isNum of { + True => Part ; + _ => npForm2Case Pl c + } + ) ; + n = Pl ; + p = NP3 + } ; + + ifPossSuffix : CommNounPhrase -> NPPerson -> Number -> Case -> Str = + \talo,np,n,c -> case np of { + NP3 => talo.s ! False ! n ! c ; + NPP p => talo.s ! True ! n ! c ++ possSuffix ! n ! p + } ; + +-- *Bare plural noun phrases*, like "koivut" in "koivut ovat valkoisia", +-- are similar to definite plurals. + + plurDet : CommNounPhrase -> NounPhrase = pluralNounPhrase ; + +-- Constructions like "huomio että kaksi on parillinen" are formed at the +-- first place as common nouns, so that one can also have +-- "kaikki ehdotukset että...". + + nounThatSentence : CommNounPhrase -> Sentence -> CommNounPhrase = \idea,x -> + {s = \\p,n,c => idea.s ! p ! n ! c ++ "että" ++ x.s ; + g = idea.g + } ; + +-- The existential structure is simple. + + onNounPhrase : NounPhrase -> Sentence = \kaljaa -> + ss (kaljaa.s ! NPCase Nom ++ "on") ; + +--2 Adjectives +-- +-- Adjectival phrases are used either as attributes or in predicative position. +-- In the attributive position, all cases occur; in the predicative position, only +-- the nominative, partitive, translative, and essive - but we ignore this +-- restriction for simplicity. The important thing with the parameter is to +-- regulate the word order of complex adjectival phrases: cf. predicative +-- "(kuusi on) jaollinen kolmella" vs. attributive "kolmella jaollinen (luku)". +-- In comparatives, the whole construction is affected: "suurempi kuin kolme" +-- vs. "kolmea suurempi". (Actually, in the predicative position, the two +-- are in free variation, the distinguished one being the normal choice: +-- "kuusi on kolmella jaollinen" is possible, but not quite neutral.) + +param + AdjPos = APred | AAttr ; + +oper + AdjPhrase : Type = {s : AdjPos => AForm => Str} ; + + adj2adjPhrase : Adjective -> AdjPhrase = \uusi -> + {s = \\_ => uusi.s} ; + + +--3 Comparison adjectives +-- +-- Each of the comparison forms has a characteristic use: +-- +-- Positive forms are used alone, as adjectival phrases ("iso"). + + positAdjPhrase : AdjDegr -> AdjPhrase = \iso -> + adj2adjPhrase {s = iso.s ! Pos} ; + +-- Comparative forms are used with an object of comparison, as +-- adjectival phrases ("isompi kuin te"/"teitä isompi"). + + comparAdjPhrase : AdjDegr -> NounPhrase -> AdjPhrase = \iso, te -> + {s = let {teitaisompi : AForm => Str = + \\a => te.s ! NPCase Part ++ iso.s ! Comp ! a} in + table { + APred => variants { + \\a => iso.s ! Comp ! a ++ kuinConj ++ te.s ! NPCase Nom ; + teitaisompi + } ; + AAttr => teitaisompi + } + } ; + +-- Superlative forms are used with a modified noun, picking out the +-- maximal representative of a domain ("isoin talo"). + + superlNounPhrase : AdjDegr -> CommNounPhrase -> NounPhrase = \iso,talo -> + {s = \\np => let {c = npForm2Case Sg np} in + iso.s ! Sup ! AN (NCase Sg c) ++ talo.s ! False ! Sg ! c ; + n = Sg ; + p = NP3 + } ; + +--3 Two-place adjectives +-- +-- A two-place adjective is an adjective with a case used after (or before) +-- the complement. The case can be the genitival accusative, which is different +-- in the singular and the plural ("rajan ylittävä"/"rajat ylittävä"). +-- The order of the adjective and its argument depends on the case: the local +-- cases favour Adj + Noun in the predicative position ("hyvä painissa", +-- "tyytyväinen vaalitulokseen", "jaollinen kolmella"), which is not a possible +-- order for the accusative case. + + AdjCompl = Adjective ** {c : NPForm} ; + + complAdj : AdjCompl -> NounPhrase -> AdjPhrase = \hyva,paini -> + let { + hyvat : AForm => Str = \\a => hyva.s ! a ; + painissa : Str = paini.s ! hyva.c + } + in + {s = table { + AAttr => \\a => painissa ++ hyvat ! a ; + APred => \\a => if_then_else Str + (isLocalNPForm hyva.c) + (variants { + hyvat ! a ++ painissa ; + painissa ++ hyvat ! a + } + ) + (painissa ++ hyvat ! a) + } + } ; + + isLocalNPForm : NPForm -> Bool = \c -> case c of { + NPCase Iness => True ; + NPCase Elat => True ; + NPCase Illat => True ; + NPCase Adess => True ; + NPCase Ablat => True ; + NPCase Allat => True ; + _ => False + } ; + + +--3 Modification of common nouns +-- +-- The two main functions of adjective are in predication ("Jussi on iso") +-- and in modification ("iso mies"). Predication will be defined +-- later, in the chapter on verbs. +-- +-- Modification uses the attributive form of an adjectival phrase. +-- The adjective always comes before the noun. The possessive suffix is +-- given to the noun. + + modCommNounPhrase : AdjPhrase -> CommNounPhrase -> CommNounPhrase = \iso,mies -> + {s = \\p,n,c => iso.s ! AAttr ! AN (NCase n c) ++ mies.s ! p ! n ! c ; + g = mies.g + } ; + +--2 Function expressions + +-- A function expression is a common noun together with the +-- case taken by its argument ("x'n vaimo"). +-- The type is analogous to two-place adjectives and transitive verbs; +-- but here the genitive is by far the commonest case. The possessive suffix +-- is then needed with pronominal arguments. + + Function = CommNounPhrase ** {c : NPForm} ; + +-- The application of a function gives, in the first place, a common noun: +-- "Jussi vaimo/vaimot". From this, other rules of the resource grammar +-- give noun phrases, such as "Jussi vaimo", "Jussin vaimot", +-- "Jussin ja Marin äidit", and "Jussin ja Marin äiti" (the +-- latter two corresponding to distributive and collective functions, +-- respectively). Semantics will eventually tell when each +-- of the readings is meaningful. + + appFunComm : Function -> NounPhrase -> CommNounPhrase = \vaimo, jussi -> + {s = \\p,n,c => case vaimo.c of { + NPCase Gen => jussi.s ! NPCase Gen ++ + ifPossSuffix vaimo jussi.p jussi.n c ; + h => vaimo.s ! False ! n ! c ++ jussi.s ! h + } ; + g = vaimo.g + } ; + +-- Notice the switched word order in other cases than the genitive, e.g. +-- "veli Jussille". +-- +-- It is possible to use a function word as a common noun; the semantics is +-- often existential or indexical. + + funAsCommNounPhrase : Function -> CommNounPhrase = \x -> x ; + +-- The following is an aggregate corresponding to function application +-- producing "John's mother" and "the mother of John". It does not appear in the +-- resource grammar API as a primitive. + + appFun : Bool -> Function -> NounPhrase -> NounPhrase = \coll, vaimo,jussi -> + let {n = jussi.n ; nf = if_then_else Number coll Sg n} in + npGenDet nf jussi vaimo ; + +-- The commonest case is functions with the genitive case. + + funGen : CommNounPhrase -> Function = \vaimo -> + vaimo ** {c = NPCase Gen} ; + +-- Two-place functions add one argument place. + + Function2 = Function ** {c2 : NPForm} ; + +-- There application starts by filling the first place. + + appFun2 : Function2 -> NounPhrase -> Function = \juna, turku -> + {s = \\p,n,c => juna.s ! False ! n ! c ++ turku.s ! juna.c ; + g = juna.g ; + c = juna.c2 + } ; + + +--2 Verbs +-- +--3 Verb phrases +-- +-- Verb phrases are discontinuous: the two parts of a verb phrase are +-- (s) an inflected verb, (s2) a complement. +-- For instance: "on" - "kaunis" ; "ei" - "ole kaunis" ; "sisältää" - "rikkiä". +-- Moreover, a subject case is needed, because of passive and 'have' verb +-- phrases ("minä uin" ; "minut valitaan" ; "minua odotetaan" ; "minulla on jano"). + + VerbPhrase = Verb ** {s2 : VForm => Str ; c : ComplCase} ; + VerbGroup = {s,s2 : Bool => VForm => Str ; c : ComplCase} ; + + predVerbGroup : Bool -> VerbGroup -> VerbPhrase = \b,vg -> { + s = vg.s ! b ; + s2 = vg.s2 ! b ; + c = vg.c + } ; + + vp2vg : (Bool -> VerbPhrase) -> VerbGroup = \f -> { + s = \\b => (f b).s ; + s2 = \\b => (f b).s2 ; + c = (f True).c + } ; + +-- The normal subject case is the nominative. + + nomVerbPhrase : (p,n : {s,s2 : VForm => Str}) -> VerbGroup = \pos,neg -> + {s = table {True => pos.s ; False => neg.s} ; + s2 = table {True => pos.s2 ; False => neg.s2} ; + c = CCase Nom + } ; + +-- From the inflection table, we select the finite form as function +-- of person and number: + + indicVerb : Verb -> Person -> Number -> Str = \v,p,n -> + v.s ! Ind n p ; + +-- A simple verb can be made into a verb phrase with an empty complement, e.g. +-- "ui" - []. +-- There are two versions, depending on if we want to negate the verb. +-- In the negated form, the negative verb "ei" becomes the verb, and the +-- complement is a special infinite form of the verb (usually similar to the +-- 2nd person singular imperative): "ei" - "ui". +-- +-- N.B. negation is *not* a function applicable to a verb phrase, since +-- double negations with "ei" are not grammatical. + + predVerb : Verb -> VerbGroup = \walk -> + let { + noCompl : {s2 : VForm => Str} = {s2 = \\_ => []} ; + infCompl : {s2 : VForm => Str} = {s2 = table { + Imper Pl => walk.s ! ImpNegPl ; + _ => walk.s ! vFormNeg + } + } + } + in + nomVerbPhrase (walk ** noCompl) (verbEi ** infCompl) ; + +-- (N.B. local definitions workaround for poor type inference in GF 1.2). + +-- Sometimes we want to extract the verb part of a verb phrase. Not strictly +-- necessary since this is a consequence of record subtyping. + + verbOfPhrase : VerbPhrase -> Verb = \v -> {s = v.s} ; + +-- Verb phrases can also be formed from adjectives ("on vanha"), +-- common nouns ("on mies"), and noun phrases ("on Jussi"). +-- The third rule is overgenerating: "on jokainen mies" has to be ruled out +-- on semantic grounds. +-- +-- For adjectives and common nouns, notice the case difference in the complement +-- depending on number: "on kaunis" - "ovat kauniita". We ignore the forms +-- "on kaunista", used with mass terms, and "ovat kauniit", used in +-- constructions of the "plurale tantum" kind. The adjective rule can be defined +-- in terms of the common noun rule. + + predAdjective : AdjPhrase -> VerbGroup = \iso -> + let + isot : CommNounPhrase = { + s = \\_,n,c => iso.s ! APred ! AN (NCase n c) ; + g = NonHuman + } + in predCommNoun isot ; + + predCommNoun : CommNounPhrase -> VerbGroup = \mies -> + let { + miehia : VForm => Str = \\v => case vform2number v of { + Sg => mies.s ! False ! Sg ! Nom ; + Pl => mies.s ! False ! Pl ! Part + } ; + olemiehia : VForm => Str = + \\v => verbOlla.s ! vFormNeg ++ miehia ! v + } + in nomVerbPhrase (verbOlla ** {s2 = miehia}) (verbEi ** {s2 = olemiehia}) ; + + predNounPhrase : NounPhrase -> VerbGroup = \jussi -> + let {jussia : Bool => Number => Case => Str = \\_,_,_ => jussi.s ! NPCase Nom} + in predCommNoun {s = jussia ; g = Human} ; --- gender does not matter + + predAdverb : Adverb -> VerbGroup = \pois -> + let {poissa : Bool => Number => Case => Str = \\_,_,_ => pois.s} + in predCommNoun {s = poissa ; g = NonHuman} ; --- gender does not matter + +--3 Transitive verbs +-- +-- Transitive verbs are verbs with a case and, possibly, a preposition +-- or a postposition for the complement, +-- in analogy with two-place adjectives and functions. +-- One might prefer to use the term "2-place verb", since +-- "transitive" traditionally means that the inherent preposition is empty. +-- Such a verb is one with a *direct object*. + +param + ComplCase = CCase Case | CAcc ; + +oper + TransVerb : Type = Verb ** {s3, s4 : Str ; c : ComplCase} ; + +-- The rule for using transitive verbs is the complementization rule. +-- +-- N.B. One or both of the pre- and postposition are empty. + + complTransVerb : TransVerb -> NounPhrase -> VerbGroup = \ostaa,talo -> + let { + ostan = predVerb ostaa ; + talon : Bool => VForm => Str = \\b,v => + ostaa.s3 ++ talo.s ! complementCase b ostaa.c v ++ ostaa.s4 + } + in + {s = ostan.s ; + s2 = \\b,v => ostan.s2 ! b ! v ++ talon ! b ! v ; + c = CCase Nom + } ; + +-- N.B. If the case is accusative, it becomes partitive in negated verb phrases. +-- The choice between the nominative and genitive accusatives depends on the verb +-- form. + + complementCase : Bool -> ComplCase -> VForm -> NPForm = \b,c,v -> case c of { + CCase k => NPCase k ; + CAcc => case b of { + True => case v of { + Inf => NPAccNom ; + Ind _ _ => NPAccGen ; + Imper _ => NPAccNom ; + ImpNegPl => NPCase Part ; + Pass True => NPAccNom ; + Pass False => NPCase Part + } ; + _ => NPCase Part + } + } ; + +-- Verbs that take their object with a case other than the accusative, +-- without pre- or postposition: + + mkTransVerbCase : Verb -> Case -> TransVerb = \nauraa,c -> + nauraa ** {s3 = [] ; s4 = [] ; c = CCase c} ; + +-- Verbs that take direct object with the accusative: + + mkTransVerbDir : Verb -> TransVerb = \ostaa -> + ostaa ** {s3 = [] ; s4 = [] ; c = CAcc} ; + +-- Most two-place verbs can be used passively; the object case need not be +-- the accusative, and it becomes the subject case in the passive sentence. + + passTransVerb : TransVerb -> VerbGroup = \tavata -> + {s = \\b,_ => if_then_else Str b (tavata.s ! Pass b) "ei" ; + s2 = \\b,_ => if_then_else Str b [] (tavata.s ! Pass b) ; + c = tavata.c + } ; + +-- The API function does not demand that the verb is two-place. +-- Therefore, we can only give it the accusative case, as default. + + passVerb : Verb -> VerbGroup = \uida -> + passTransVerb (mkTransVerbDir uida) ; + +-- Transitive verbs can be used elliptically as verbs. The semantics +-- is left to applications. The definition is trivial, due to record +-- subtyping. + + transAsVerb : TransVerb -> Verb = \juoda -> + juoda ; + +-- The 'real' Finnish passive is unpersonal, equivalent to the +-- "man" construction in German. It is formed by inflecting the +-- bare verb phrase in passive, and putting the complement before +-- the verb ("auttaa minua" - "minua autetaan"). + + passPredVerbPhrase : VerbPhrase -> Sentence = \auttaaminua -> + let {p = Pass True} in + {s = auttaaminua.s2 ! p ++ auttaaminua.s ! p} ; + +-- *Ditransitive verbs* are verbs with three argument places. +-- We treat so far only the rule in which the ditransitive +-- verb takes both complements to form a verb phrase. + + DitransVerb = TransVerb ** {s5, s6 : Str ; c2 : ComplCase} ; + + complDitransVerb : DitransVerb -> NounPhrase -> NounPhrase -> VerbGroup = + \ostaa,talo,me -> + let { + ostan = predVerb ostaa ; + talon : Bool => VForm => Str = \\b,v => + ostaa.s3 ++ talo.s ! complementCase b ostaa.c v ++ ostaa.s4 ; + meille : Bool => VForm => Str = \\b,v => + ostaa.s5 ++ me.s ! complementCase b ostaa.c2 v ++ ostaa.s6 + } + in { + s = ostan.s ; + s2 = \\b,v => ostan.s2 ! b ! v ++ talon ! b ! v ++ meille ! b ! v ; + c = CCase Nom + } ; + + +--2 Adverbials +-- +-- Adverbials are not inflected (we ignore comparison, and treat +-- compared adverbials as separate expressions; this could be done another way). + + Adverb : Type = SS ; + +-- This rule adds the adverbial as a prefix or a suffix to the complement, +-- in free variation. + + adVerbPhrase : VerbPhrase -> Adverb -> VerbPhrase = \laulaa, hyvin -> + {s = laulaa.s ; + s2 = \\v => bothWays (laulaa.s2 ! v) hyvin.s ; + c = laulaa.c + } ; + + advAdjPhrase : Adverb -> AdjPhrase -> AdjPhrase = \liian, iso -> + {s = \\p,a => liian.s ++ iso.s ! p ! a + } ; + +-- Adverbials are typically generated by case, prepositions, or postpositions. + + Preposition : Type = {s : Str ; c : Case ; isPrep : Bool} ; + + prepPrep : Str -> Case -> Preposition = \ennen,gen -> + {s = ennen ; c = gen ; isPrep = True} ; + + prepPostp : Str -> Case -> Preposition = \takana,gen -> + {s = takana ; c = gen ; isPrep = False} ; + + prepPostpGen : Str -> Preposition = \takana -> + prepPostp takana Gen ; + + prepCase : Case -> Preposition = \iness -> + {s = [] ; c = iness ; isPrep = False} ; + + prepPhrase : Preposition -> NounPhrase -> Adverb = \takana, talo -> + let talon = talo.s ! NPCase takana.c + in ss (if_then_Str takana.isPrep (takana.s ++ talon) (talon ++ takana.s)) ; + +-- This is a source of the "mann with a telescope" ambiguity, and may produce +-- strange things, like "autot aina" (while "autot tänään" is OK). +-- Semantics will have to make finer distinctions among adverbials. + + advCommNounPhrase : CommNounPhrase -> Adverb -> CommNounPhrase = \auto,nyt -> + {s = \\b,n,c => auto.s ! b ! n ! c ++ nyt.s ; + g = auto.g + } ; + +--2 Sentences +-- +-- Sentences are not inflected in this fragment of Finnish without tense. + + Sentence : Type = SS ; + +-- This is the traditional $S -> NP VP$ rule. It takes care of +-- agreement between subject and verb. Recall that the VP may already +-- contain negation. + + predVerbPhrase : NounPhrase -> VerbPhrase -> Sentence = \jussi,uida -> + let { + p = np2Person jussi.p ; + c = complementCase True uida.c Inf --- True,Inf don't matter here + } + in + ss (jussi.s ! c ++ uida.s ! Ind jussi.n p ++ uida.s2 ! Ind jussi.n p) ; + +--3 Sentence-complement verbs +-- +-- Sentence-complement verbs take sentences as complements. + + SentenceVerb : Type = Verb ; + +-- To generate "sanoo että Jussi ui" / "ei sano että Jussi ui" + + complSentVerb : SentenceVerb -> Sentence -> VerbGroup = + \sanoa,jussiui -> + let { + sanon = predVerb sanoa + } + in { + s = sanon.s ; + s2 = \\b,v => sanon.s2 ! b ! v ++ conjEtta ++ jussiui.s ; + c = CCase Nom + } ; + +--3 Verb-complement verbs +-- +-- Verb-complement verbs take verb phrases as complements. +-- In Finnish, they can be ordinary verbs ("haluta", "yrittää"), but +-- also verbs with a special subject case ("täytyy", "on pakko"). + + VerbVerb : Type = Verb ** {c : ComplCase} ; + + complVerbVerb : VerbVerb -> VerbGroup -> VerbGroup = \haluta, uida -> + let + hc = haluta.c ; + haluan = case hc of { + CCase Nom => predVerb haluta ; + _ => predVerb {s = table { + Imper Sg => haluta.s ! Imper Sg ; + ImpNegPl => haluta.s ! ImpNegPl ; + _ => haluta.s ! Ind Sg P3 + } + } + } + in { + s = haluan.s ; + s2 = \\b,v => haluan.s2 ! b ! v ++ uida.s ! True ! Inf ++ + uida.s2 ! True ! Inf ; + c = hc + } ; + +nomVerbVerb : Verb -> VerbVerb = \v -> v ** {c = CCase Nom} ; + +--2 Sentences missing noun phrases +-- +-- This is one instance of Gazdar's *slash categories*, corresponding to his +-- $S/NP$. +-- We cannot have - nor would we want to have - a productive slash-category former. +-- Perhaps a handful more will be needed. +-- +-- Notice that the slash category has a similar relation to sentences as +-- transitive verbs have to verbs: it's like a *sentence taking a complement*. +-- +-- Interestingly, the distinction between prepositions and postpositions +-- neutralizes: even prepositions are attached after relative and interrogative +-- pronouns: "jota ennen" cf. "ennen talvea". Otherwise, the category and +-- the rules are very similar to transitive verbs. Notice that the case gets +-- fixed by the Boolean parameter and the subject. + + SentenceSlashNounPhrase = Sentence ** {s2 : Str ; c : Case} ; + + slashTransVerb : Bool -> NounPhrase -> TransVerb -> SentenceSlashNounPhrase = + \b,jussi,ostaa -> + predVerbPhrase jussi (predVerbGroup b (predVerb ostaa)) ** { + s2 = ostaa.s3 ++ ostaa.s4 ; + c = npForm2Case jussi.n + (complementCase b ostaa.c (Ind jussi.n (np2Person jussi.p))) + } ; + +--2 Relative pronouns and relative clauses +-- +-- As described in $types.Fin.gf$, relative pronouns are inflected like +-- common nouns, in number and case. +-- +-- We get the simple relative pronoun "joka" from $morpho.Fin.gf$. + + identRelPron : RelPron = relPron ; + + funRelPron : Function -> RelPron -> RelPron = \vaimo, joka -> + {s = \\n,c => joka.s ! n ! npForm2Case n vaimo.c ++ vaimo.s ! False ! n ! c} ; + +-- Relative clauses can be formed from both verb phrases ("joka ui") and +-- slash expressions ("jonka sinä näet", "jonka kautta sinä käyt"). + + RelClause : Type = {s : Number => Str} ; + + relVerbPhrase : RelPron -> VerbPhrase -> RelClause = \joka,ui -> + {s = \\n => joka.s ! n ! npForm2Case n (complementCase True ui.c Inf) ++ + ui.s ! Ind n P3 ++ ui.s2 ! Ind n P3} ; + + relSlash : RelPron -> SentenceSlashNounPhrase -> RelClause = \joka,saat -> + {s = \\n => joka.s ! n ! saat.c ++ saat.s2 ++ saat.s} ; + +-- A 'degenerate' relative clause is the one often used in mathematics, e.g. +-- "luku x siten että x on parillinen". + + relSuch : Sentence -> RelClause = \A -> + {s = \\_ => advSiten ++ conjEtta ++ A.s} ; + +-- N.B. the construction "sellainen että" is not possible with the present +-- typing of the relative clause, since it should also be inflected in +-- case. Ordinary relative clauses have a fixed case. +-- +-- The main use of relative clauses is to modify common nouns. +-- The result is a common noun, out of which noun phrases can be formed +-- by determiners. We use no comma before these relative clauses, even though +-- conservative standard Finnish does. + + modRelClause : CommNounPhrase -> RelClause -> CommNounPhrase = \mies,jokaui -> + {s = \\b,n,c => mies.s ! b ! n ! c ++ jokaui.s ! n ; + g = mies.g + } ; + +-- N.B: the possessive suffix, if attached here, comes to wrong place! Solution: +-- make $CommNounPhrase$ discontinuos. + + +--2 Interrogative pronouns +-- +-- If relative pronouns are like common nouns (and adjectives), +-- interrogative pronouns are like noun phrases, having a fixed number. +-- They also need to handle an NP-like accusative case. But person is +-- not needed, since it is uniformly $NP3$. + + IntPron : Type = {s : NPForm => Str ; n : Number} ; + +-- In analogy with relative pronouns, we have a rule for applying a function +-- to a relative pronoun to create a new one. + + funIntPron : Function -> IntPron -> IntPron = \vaimo,kuka -> + {s = \\c => kuka.s ! vaimo.c ++ + vaimo.s ! False ! kuka.n ! npForm2Case kuka.n c ; + n = kuka.n + } ; + +-- There is a variety of simple interrogative pronouns: +-- "mikä talo" / "kuka mies", "kuka", "mikä". The construction with a noun +-- is the reason why nouns in Finnish need a gender. + + nounIntPron : Number -> CommNounPhrase -> IntPron = \n, talo -> + {s = \\c => let {nc = npForm2Case n c} in + mikakukaInt ! talo.g ! n ! nc ++ talo.s ! False ! n ! nc ; + n = n + } ; + + intPronWho : Number -> IntPron = \num -> { + s = \\c => mikakukaInt ! Human ! num ! (npForm2Case num c) ; + n = num + } ; + + intPronWhat : Number -> IntPron = \num -> { + s = \\c => mikakukaInt ! NonHuman ! num ! (npForm2Case num c) ; + n = num + } ; + + +--2 Utterances + +-- By utterances we mean complete phrases, such as +-- 'can be used as moves in a language game': indicatives, questions, imperative, +-- and one-word utterances. The rules are far from complete. +-- +-- N.B. we have not included rules for texts, which we find we cannot say much +-- about on this level. In semantically rich GF grammars, texts, dialogues, etc, +-- will of course play an important role as categories not reducible to utterances. +-- An example is proof texts, whose semantics show a dependence between premises +-- and conclusions. Another example is intersentential anaphora. + + Utterance = SS ; + + indicUtt : Sentence -> Utterance = \x -> ss (x.s ++ stopPunct) ; + interrogUtt : Question -> Utterance = \x -> ss (x.s ++ questPunct) ; + + +--2 Questions +-- +-- Questions are either direct or indirect, but the forms in Finnish are +-- always identical. So we don't need a $QuestForm$ parameter as in other languages. + +oper + Question = SS ; + +--3 Yes-no questions +-- +-- Yes-no questions are formed by inversed predication, with the clitic "ko" / "kö" +-- particle attached to the verb part of the verb phrase. + + questVerbPhrase : NounPhrase -> VerbPhrase -> Question = \jussi,ui -> + let {np = Ind jussi.n (np2Person jussi.p)} in + ss (ui.s ! np ++ koPart ++ jussi.s ! complementCase True ui.c Inf ++ ui.s2 ! np); + + onkoNounPhrase : NounPhrase -> Question = \kaljaa -> + ss ("onko" ++ kaljaa.s ! NPCase Nom) ; + +--3 Wh-questions +-- +-- Wh-questions are of two kinds: ones that are like $NP - VP$ sentences +-- ("kuka ui?") others that are line $S/NP - NP$ sentences ("kenet sinä tapaat?"). + + intVerbPhrase : IntPron -> VerbPhrase -> Question = \kuka,ui -> + predVerbPhrase (kuka ** {p = NP3}) ui ; + + intSlash : IntPron -> SentenceSlashNounPhrase -> Question = \kuka,tapaat -> + ss (kuka.s ! NPCase tapaat.c ++ tapaat.s2 ++ tapaat.s) ; + + +--3 Interrogative adverbials +-- +-- These adverbials will be defined in the lexicon: they include +-- "koska", "missä", "kuinka", "miksi", etc, which are all invariant one-word +-- expressions. In addition, they can be formed by adding cases and postpositions +-- to interrogative pronouns, in the same way as adverbials are formed +-- from noun phrases; notice that even prepositions are used as postpositions +-- when attached to interrogative pronouns. + + IntAdverb = SS ; + + prepIntAdverb : Str -> Case -> IntPron -> IntAdverb = \ennen,c,kuka -> + ss (kuka.s ! NPCase c ++ ennen) ; + +-- A question adverbial can be applied to anything, and whether this makes +-- sense is a semantic question. The syntax is very simple: just prefix the +-- adverbial to the predication. + + questAdverbial : IntAdverb -> NounPhrase -> VerbPhrase -> Question = + \miksi, jussi, ui -> + cc2 miksi (predVerbPhrase jussi ui) ; + +--2 Imperatives +-- +-- We only consider second-person imperatives. + + Imperative = SS1 Number ; + + imperVerbPhrase : VerbPhrase -> Imperative = \ui -> + {s = \\n => ui.s ! Imper n ++ ui.s2 ! Imper n} ; + + imperUtterance : Number -> Imperative -> Utterance = \n,I -> + ss (I.s ! n ++ exclPunct) ; + +--2 Sentence adverbials +-- +-- This class covers adverbials such as "muuten", "siksi", which are prefixed +-- to a sentence to form a phrase. + + advSentence : Adverb -> Sentence -> Utterance = \siksi,sataa -> + ss (siksi.s ++ sataa.s ++ ".") ; + + +--2 Coordination +-- +-- Coordination is to some extent orthogonal to the rest of syntax, and +-- has been treated in a generic way in the module $CO$ in the file +-- $coordination.gf$. The overall structure is independent of category, +-- but there can be differences in parameter dependencies. +-- +--3 Conjunctions +-- +-- Coordinated phrases are built by using conjunctions, which are either +-- simple ("ja", "tai") or distributed ("sekä - että", "joko - tai"). +-- +-- The conjunction has an inherent number, which is used when conjoining +-- noun phrases: "Jussi ja Mari ovat..." vs. "Jussi tai Mari on..."; in the +-- case of "tai", the result is however plural if any of the disjuncts is. + + Conjunction = CO.Conjunction ** {n : Number} ; + ConjunctionDistr = CO.ConjunctionDistr ** {n : Number} ; + +--3 Coordinating sentences +-- +-- We need a category of lists of sentences. It is a discontinuous +-- category, the parts corresponding to 'init' and 'last' segments +-- (rather than 'head' and 'tail', because we have to keep track of the slot between +-- the last two elements of the list). A list has at least two elements. + + ListSentence : Type = SD2 ; + + twoSentence : (_,_ : Sentence) -> ListSentence = CO.twoSS ; + + consSentence : ListSentence -> Sentence -> ListSentence = + CO.consSS CO.comma ; + +-- To coordinate a list of sentences by a simple conjunction, we place +-- it between the last two elements; commas are put in the other slots, +-- e.g. "du rauchst, er trinkt und ich esse". + + conjunctSentence : Conjunction -> ListSentence -> Sentence = \c,xs -> + ss (CO.conjunctX c xs) ; + +-- To coordinate a list of sentences by a distributed conjunction, we place +-- the first part (e.g. "either") in front of the first element, the second +-- part ("or") between the last two elements, and commas in the other slots. +-- For sentences this is really not used. + + conjunctDistrSentence : ConjunctionDistr -> ListSentence -> Sentence = + \c,xs -> + ss (CO.conjunctDistrX c xs) ; + + +--3 Coordinating adjective phrases +-- +-- The structure is the same as for sentences. Parameters are passed to components. + + ListAdjPhrase : Type = + {s1,s2 : AdjPos => AForm => Str} ; + + twoAdjPhrase : (_,_ : AdjPhrase) -> ListAdjPhrase = \x,y -> + CO.twoTable2 AdjPos AForm x y ; + + consAdjPhrase : ListAdjPhrase -> AdjPhrase -> ListAdjPhrase = \xs,x -> + CO.consTable2 AdjPos AForm CO.comma xs x ; + + conjunctAdjPhrase : Conjunction -> ListAdjPhrase -> AdjPhrase = \c,xs -> + CO.conjunctTable2 AdjPos AForm c xs ; + + conjunctDistrAdjPhrase : ConjunctionDistr -> ListAdjPhrase -> AdjPhrase = \c,xs -> + CO.conjunctDistrTable2 AdjPos AForm c xs ; + + +--3 Coordinating noun phrases +-- +-- The structure is the same as for sentences. The result is either always plural +-- or plural if any of the components is, depending on the conjunction. + + ListNounPhrase : Type = {s1,s2 : NPForm => Str ; n : Number ; p : NPPerson} ; + + twoNounPhrase : (_,_ : NounPhrase) -> ListNounPhrase = \x,y -> + CO.twoTable NPForm x y ** {n = conjNumber x.n y.n ; p = conjPerson x.p y.p} ; + + consNounPhrase : ListNounPhrase -> NounPhrase -> ListNounPhrase = \xs,x -> + CO.consTable NPForm CO.comma xs x ** + {n = conjNumber xs.n x.n ; p = conjPerson xs.p x.p} ; + + conjunctNounPhrase : Conjunction -> ListNounPhrase -> NounPhrase = \c,xs -> + CO.conjunctTable NPForm c xs ** {n = conjNumber c.n xs.n ; p = xs.p} ; + + conjunctDistrNounPhrase : ConjunctionDistr -> ListNounPhrase -> NounPhrase = + \c,xs -> + CO.conjunctDistrTable NPForm c xs ** {n = conjNumber c.n xs.n ; p = xs.p} ; + +-- We have to define a calculus of numbers of persons. For numbers, +-- it is like the conjunction with $Pl$ corresponding to $False$. + + conjNumber : Number -> Number -> Number = \m,n -> case of { + => Sg ; + _ => Pl + } ; + +-- For persons, we let the latter argument win ("either you or I am absent" +-- but "either I or you are absent"). This is not quite clear. + + conjPerson : NPPerson -> NPPerson -> NPPerson = \_,p -> + p ; + + + +--2 Subjunction +-- +-- Subjunctions ("kun", "jos", etc) +-- are a different way to combine sentences than conjunctions. +-- The main clause can be a sentences, an imperatives, or a question, +-- but the subjoined clause must be a sentence. +-- +-- There are uniformly two variant word orders, e.g. +-- "jos poltat minä suutun" +-- and "minä suutun jos poltat". + + Subjunction = SS ; + + subjunctSentence : Subjunction -> Sentence -> Sentence -> Sentence = + \if, A, B -> + ss (subjunctVariants if A.s B.s) ; + + subjunctImperative : Subjunction -> Sentence -> Imperative -> Imperative = + \if, A, B -> + {s = \\n => subjunctVariants if A.s (B.s ! n)} ; + + subjunctQuestion : Subjunction -> Sentence -> Question -> Question = + \if, A, B -> + {s = subjunctVariants if A.s B.s} ; + + subjunctVariants : Subjunction -> Str -> Str -> Str = \if,A,B -> + variants {if.s ++ A ++ commaPunct ++ B ; B ++ commaPunct ++ if.s ++ A} ; + + subjunctVerbPhrase : VerbPhrase -> Subjunction -> Sentence -> VerbPhrase = + \V, if, A -> + adVerbPhrase V (ss (if.s ++ A.s)) ; + +--2 One-word utterances +-- +-- An utterance can consist of one phrase of almost any category, +-- the limiting case being one-word utterances. These +-- utterances are often (but not always) in what can be called the +-- default form of a category, e.g. the nominative. +-- This list is far from exhaustive. + + useNounPhrase : NounPhrase -> Utterance = \john -> + postfixSS stopPunct (defaultNounPhrase john) ; + + useCommonNounPhrase : Number -> CommNounPhrase -> Utterance = \n,car -> + useNounPhrase (indefNounPhrase n car) ; + +-- Here are some default forms. + + defaultNounPhrase : NounPhrase -> SS = \john -> + ss (john.s ! NPCase Nom) ; + + defaultQuestion : Question -> SS = \whoareyou -> + whoareyou ; + + defaultSentence : Sentence -> Utterance = \x -> + x ; +} ; diff --git a/lib/resource/finnish/TypesFin.gf b/lib/resource/finnish/TypesFin.gf new file mode 100644 index 000000000..7fe0984c2 --- /dev/null +++ b/lib/resource/finnish/TypesFin.gf @@ -0,0 +1,134 @@ +--1 Finnish Word Classes and Morphological Parameters +-- +-- This is a resource module for Finnish morphology, defining the +-- morphological parameters and word classes of Finnish. It is aimed +-- to be complete w.r.t. the description of word forms. +-- However, it only includes those parameters that are needed for +-- analysing individual words: such parameters are defined in syntax modules. +-- +-- We use the language-independent prelude. + +resource TypesFin = open Prelude in { + +-- +--2 Enumerated parameter types +-- +-- These types are the ones found in school grammars. +-- Their parameter values are atomic. The accusative cases are only +-- defined in syntax; in morphology, there is a special accusative for +-- pronouns. + +param + Number = Sg | Pl ; + Case = Nom | Gen | Part | Transl | Ess + | Iness | Elat | Illat | Adess | Ablat | Allat + | Abess ; -- Comit, Instruct in NForm + Person = P1 | P2 | P3 ; + Degree = Pos | Comp | Sup ; + Gender = NonHuman | Human ; + +-- For data abstraction, we define + +oper + singular = Sg ; + plural = Pl ; + +--2 Word classes and hierarchical parameter types +-- +-- Real parameter types (i.e. ones on which words and phrases depend) +-- are often hierarchical. The alternative would be cross-products of +-- simple parameters, but this would usually overgenerate. +-- + +--3 Common nouns +-- +-- Common nouns are inflected in number and noun case. In noun case, we include +-- forms used in connection with possessive suffixes. + +param + NForm = NCase Number Case + | NComit | NInstruct -- no number dist + | NPossNom | NPossGenPl | NPossTransl Number | NPossIllat Number ; + +oper + CommonNoun : Type = {s : NForm => Str} ; + + useNForm : NForm -> (Number => Case => Str) -> Str = \nf,f -> case nf of { + NCase n c => f ! n ! c ; + NPossNom => f ! Sg ! Nom ; ---- "iso autoni"; also "isot autoni" etc + NPossGenPl => f ! Pl ! Gen ; + NPossTransl n => f ! n ! Transl ; + NPossIllat n => f ! n ! Illat ; + _ => f ! Sg ! Nom --- NComit, NInstruct ; should not happen + } ; + + +-- +--3 Adjectives +-- +-- The major division is between the comparison degrees, but it +-- is also good to leave room for adjectives that cannon be compared. +-- Such adjectives are like common nouns, except for the adverbial form. + +param + AForm = AN NForm | AAdv ; + +oper + Adjective : Type = {s : AForm => Str} ; + AdjDegr : Type = {s : Degree => AForm => Str} ; + +--3 Verbs +-- +-- We limit the grammar so far to verbs in the infinitive, second-person +-- imperative, and present tense indicative active and passive. +-- A special form is needed for +-- the negated plural imperative. + +param + VForm = + Inf + | Pres Number Person + | Impf Number Person + | Imper Number + | ImpNegPl + | Pass Bool + ; + +oper + Verb : Type = SS1 VForm ; + + vFormNeg = Imper Sg ; + + vform2number : VForm -> Number = \v -> case v of { + Pres n _ => n ; + Impf n _ => n ; + Imper n => n ; + ImpNegPl => Pl ; + _ => Sg --- + } ; + +-- +--3 Pronouns +-- +-- For pronouns, we need the noun case forms, plus an accusative. + +param + PForm = PCase Case | PAcc ; + +oper + Pronoun : Type = {s : PForm => Str ; n : Number ; p : Person} ; + +--3 Proper names +-- +-- Proper names only need case forms. + + ProperName : Type = SS1 Case ; + + +--3 Relative pronouns +-- +-- Relative pronouns are inflected like nouns, except for possessive suffixes. + + RelPron : Type = {s : Number => Case => Str} ; + +} ; diff --git a/src/GF/Shell/CommandL.hs b/src/GF/Shell/CommandL.hs index 62d3f9e87..63f4c4258 100644 --- a/src/GF/Shell/CommandL.hs +++ b/src/GF/Shell/CommandL.hs @@ -5,9 +5,9 @@ -- Stability : (stable) -- Portability : (portable) -- --- > CVS $Date: 2005/06/03 22:44:36 $ +-- > CVS $Date: 2005/06/10 15:59:58 $ -- > CVS $Author: aarne $ --- > CVS $Revision: 1.17 $ +-- > CVS $Revision: 1.18 $ -- -- (Description of the module) ----------------------------------------------------------------------------- @@ -122,6 +122,7 @@ pCommandMsg s = (m,pCommandWords $ words c) where "u" : _ -> CUndo "d" : _ -> CDelete "ac" : _ -> CAddClip + "pc": i : _ -> CRemoveClip (readIntArg i) "c" : s : _ -> CTermCommand s "a" : _ -> CRefineRandom --- *a*leatoire "m" : _ -> CMenu diff --git a/src/GF/Shell/Commands.hs b/src/GF/Shell/Commands.hs index d95cd51b1..99a7130e9 100644 --- a/src/GF/Shell/Commands.hs +++ b/src/GF/Shell/Commands.hs @@ -5,9 +5,9 @@ -- Stability : (stable) -- Portability : (portable) -- --- > CVS $Date: 2005/04/21 16:23:19 $ --- > CVS $Author: bringert $ --- > CVS $Revision: 1.37 $ +-- > CVS $Date: 2005/06/10 15:59:58 $ +-- > CVS $Author: aarne $ +-- > CVS $Revision: 1.38 $ -- -- temporary hacks for GF 2.0 -- @@ -91,6 +91,7 @@ data Command = | CRemoveOption Option | CDelete | CAddClip + | CRemoveClip Int | CUndo | CView | CMenu @@ -284,6 +285,7 @@ execECommand env c = case c of CRemoveOption o -> changeStOptions (removeOption o) CDelete -> action2commandNext $ deleteSubTree cgr CAddClip -> \s -> (addtoClip (actTree (stateSState s))) s + CRemoveClip n -> \s -> (removeClip n) s CUndo -> undoCommand CMenu -> \s -> changeMsg (menuState env s) s CView -> changeView diff --git a/src/GF/UseGrammar/Session.hs b/src/GF/UseGrammar/Session.hs index 34ffeed4a..4aabe9f60 100644 --- a/src/GF/UseGrammar/Session.hs +++ b/src/GF/UseGrammar/Session.hs @@ -5,9 +5,9 @@ -- Stability : (stable) -- Portability : (portable) -- --- > CVS $Date: 2005/04/21 16:23:51 $ --- > CVS $Author: bringert $ --- > CVS $Revision: 1.9 $ +-- > CVS $Date: 2005/06/10 15:59:59 $ +-- > CVS $Author: aarne $ +-- > CVS $Revision: 1.10 $ -- -- (Description of the module) ----------------------------------------------------------------------------- @@ -82,6 +82,9 @@ changeCands ts ss@((s,(_,cb),(_,b)):_) = (s,(ts,cb),(candInfo ts,b)) : ss addtoClip :: Clip -> ECommand addtoClip t ss@((s,(ts,cb),(i,b)):_) = (s,(ts,t:cb),(i,b)) : ss +removeClip :: Int -> ECommand +removeClip n ss@((s,(ts,cb),(i,b)):_) = (s,(ts, drop n cb),(i,b)) : ss + changeMsg :: [String] -> ECommand changeMsg m ((s,ts,(_,b)):ss) = (s,ts,(m,b)) : ss -- just change message