diff options
Diffstat (limited to 'grammars/resource/finnish')
| -rw-r--r-- | grammars/resource/finnish/Finnish.gf | 3 | ||||
| -rw-r--r-- | grammars/resource/finnish/MorphoFin.gf | 688 | ||||
| -rw-r--r-- | grammars/resource/finnish/ParadigmsFin.gf | 260 | ||||
| -rw-r--r-- | grammars/resource/finnish/ResFin.gf | 222 | ||||
| -rw-r--r-- | grammars/resource/finnish/SyntaxFin.gf | 1028 | ||||
| -rw-r--r-- | grammars/resource/finnish/TestFin.gf | 54 | ||||
| -rw-r--r-- | grammars/resource/finnish/TypesFin.gf | 126 |
7 files changed, 0 insertions, 2381 deletions
diff --git a/grammars/resource/finnish/Finnish.gf b/grammars/resource/finnish/Finnish.gf deleted file mode 100644 index b756afe96..000000000 --- a/grammars/resource/finnish/Finnish.gf +++ /dev/null @@ -1,3 +0,0 @@ ---# -path=.:../abstract:../../prelude - -resource Finnish = reuse ResFin ; diff --git a/grammars/resource/finnish/MorphoFin.gf b/grammars/resource/finnish/MorphoFin.gf deleted file mode 100644 index 5d0ebc1ee..000000000 --- a/grammars/resource/finnish/MorphoFin.gf +++ /dev/null @@ -1,688 +0,0 @@ ---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 (Predef = Predef), Prelude in { - ---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 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" ; - - 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") ; - --- The special case with no alternations: the vowel harmony is inferred from the --- last letter - which must be one of "o", "u", "ö", "y". - - sTalo : Str -> CommonNoun = \talo -> - let {a = getHarmony (Predef.dp 1 talo)} in - sKukko talo (talo + "n") (talo + ("j" + 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 ; - naurii = nauri + "i" - } - in - mkSubst a - nauris - naurii - naurii - (nauris + ("t" + a)) - (naurii + "seen") - naurii - naurii - (naurii + "den") - (naurii + ("t" + a)) - (naurii + "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") ; - --- This auxiliary resolves vowel harmony from a given letter. - -getHarmony : Str -> Str = \u -> - ifTok Str u "a" "a" ( - ifTok Str u "o" "a" ( - ifTok Str u "u" "a" "ä")) ; - - --- We could use an extension of the following for grade alternation, but we don't; --- in general, *whether there is* grade alternation must be given in the lexicon --- anyway (cf. "auto" - "auton", not "audon"). - - weakGrade : Str -> Str = \kukko -> - let { - ku = Predef.tk 3 kukko ; - kk = Predef.tk 1 (Predef.dp 3 kukko) ; - o = Predef.dp 1 kukko ; - ifkk = ifTok Str kk ; - k = - ifkk "kk" "k" ( - ifkk "pp" "p" ( - ifkk "tt" "t" ( - ifkk "nt" "nn" ( - ifkk "mp" "mm" ( - ifkk "rt" "rr" ( - ifkk "lt" "ll" ( - kk))))))) - } - in ku + k + o ; - - ---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" ; - 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 ; - --- 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" - } ; - } ; - --- 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 <n,p> of { - <Sg,P1> => "ni" ; - <Sg,P2> => "si" ; - <Sg,P3> => "nsa" ; - <Pl,P1> => "mme" ; - <Pl,P2> => "nne" ; - <Pl,P3> => "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 - } - } ; - -caseTable : Number -> CommonNoun -> Case => Str = \n,cn -> - \\c => cn.s ! NCase n c ; - - ---2 Adjectives --- --- For the comparison of adjectives, three noun declensions --- are needed in the worst case. - - mkAdjDegr : (_,_,_ : CommonNoun) -> 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 kiva (sSuurempi kivempaa) (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 ; - Ind Sg P1 => tulen ; - Ind Sg P2 => tule + "t" ; - Ind Sg P3 => tulee ; - Ind Pl P1 => tule + "mme" ; - Ind Pl P2 => tule + "tte" ; - Ind 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 - } - } ; - --- For "sanoa", "valua", "kysyä". - - vSanoa : Str -> Verb = \sanoa -> - let { - a = Predef.dp 1 sanoa ; - sano = Predef.tk 1 sanoa ; - o = Predef.dp 1 sano - } in - mkVerb - sanoa - (sano + "n") - (sano + o) - (sano + (("v" + a) + "t")) - (sano + (("k" + a) + a)) - (sano + ((("t" + a) + a) + "n")) ; - --- 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 "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 { - Ind 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 : Case => Str = - let {kaiket = caseTable Pl (sKukko "kaikki" "kaiken" "kaikkia")} in - table { - Nom => "kaikki" ; - c => kaiket ! c - } ; - - stopPunct = "." ; - commaPunct = "," ; - questPunct = "?" ; - exclPunct = "!" ; - - koPart = suff "ko" ; - -} ; diff --git a/grammars/resource/finnish/ParadigmsFin.gf b/grammars/resource/finnish/ParadigmsFin.gf deleted file mode 100644 index a970c4d85..000000000 --- a/grammars/resource/finnish/ParadigmsFin.gf +++ /dev/null @@ -1,260 +0,0 @@ ---1 Finnish Lexical Paradigms --- --- Aarne Ranta 2003 --- --- This is an API to the user of the resource grammar --- for adding lexical items. It give shortcuts for forming --- expressions of basic categories: nouns, adjectives, verbs. --- --- Closed categories (determiners, pronouns, conjunctions) are --- accessed through the resource syntax API, $resource.Abs.gf$. --- --- The main difference with $morpho.Fin.gf$ is that the types --- referred to are compiled resource grammar types. We have moreover --- had the design principle of always having existing forms as string --- arguments of the paradigms, not stems. --- --- This is the path to read the grammar from the same directory. ---# -path=.:../abstract:../../prelude --- --- The following modules are presupposed: - -resource ParadigmsFin = open (Predef=Predef), Prelude, SyntaxFin, Finnish in { - ---2 Parameters --- --- To abstract over gender, number, and (some) case names, --- we define the following identifiers. - -oper - human : Gender ; - nonhuman : Gender ; - - -- singular : Number ; - -- singular : Number ; - - nominative : Case ; - genitive : Case ; - partitive : Case ; - inessive : Case ; - elative : Case ; - illative : Case ; - adessive : Case ; - ablative : Case ; - allative : Case ; - ---2 Nouns - --- Worst case: give ten forms and the semantic gender. --- In practice just a couple of forms are needed, to define the different --- stems, vowel alternation, and vowel harmony. - -oper - mkN : (talo,talon,talona,taloa,taloon,taloina,taloissa,talojen,taloja,taloihin - : Str) -> Gender -> N ; - --- Nouns with partitive "a"/"ä" are a large group. --- To determine for grade and vowel alternation, three forms are usually needed: --- singular nominative and genitive, and plural partitive. --- Examples: "talo", "kukko", "huippu", "koira", "kukka", "syylä", "särki"... - - nKukko : (kukko,kukon,kukkoja : Str) -> Gender -> N ; - --- A special case are nouns with no alternations: --- the vowel harmony is inferred from the last letter, --- which must be one of "o", "u", "ö", "y". - - nTalo : (talo : Str) -> Gender -> N ; - --- Foreign 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. Examples: "linux", "savett", "screen". --- The singular partitive form is used to get the vowel harmony. (N.B. more than --- 1-syllabic words ending in "n" would have variant plural genitive and --- partitive forms, like "sultanien"/"sultaneiden", which are not covered.) - - nLinux : (linuxia : Str) -> Gender -> N ; - --- Nouns of at least 3 syllables ending with "a" or "ä", like "peruna", "tavara", --- "rytinä". - - nPeruna : (peruna : Str) -> Gender -> N ; - --- The following paradigm covers both nouns ending in an aspirated "e", such as --- "rae", "perhe", "savuke", and also many ones ending in a consonant --- ("rengas", "kätkyt"). The singular nominative and essive are given. - - nRae : (rae, rakeena : Str) -> Gender -> N ; - --- The following covers nouns with partitive "ta"/"tä", such as --- "susi", "vesi", "pieni". To get all stems and the vowel harmony, it takes --- the singular nominative, genitive, and essive. - - nSusi : (susi,suden,sutta : Str) -> Gender -> N ; - --- Nouns ending with a long vowel, such as "puu", "pää", "pii", "leikkuu", --- are inflected according to the following. - - nPuu : (puu : Str) -> Gender -> N ; - --- One-syllable diphthong nouns, such as "suo", "tie", "työ", are inflected by --- the following. - - nSuo : (suo : Str) -> Gender -> N ; - --- Many adjectives but also nouns have the nominative ending "nen" which in other --- cases becomes "s": "nainen", "ihminen", "keltainen". --- To capture the vowel harmony, we use the partitive form as the argument. - - nNainen : (naista : Str) -> Gender -> N ; - --- The following covers some nouns ending with a consonant, e.g. --- "tilaus", "kaulin", "paimen", "laidun". - - nTilaus : (tilaus,tilauksena : Str) -> Gender -> N ; - --- The following covers nouns like "nauris" and adjectives like "kallis", "tyyris". --- The partitive form is taken to get the vowel harmony. - - nNauris : (naurista : Str) -> Gender -> N ; - --- Separately-written compound nouns, like "sambal oelek", "Urho Kekkonen", --- have only their last part inflected. - - nComp : Str -> N -> N ; - --- Nouns used as functions need a case, of which by far the commonest is --- the genitive. - - mkFun : N -> Case -> Fun ; - fGen : N -> Fun ; - --- Proper names can be formed by using declensions for nouns. - - mkPN : N -> PN ; - - ---2 Adjectives - --- Non-comparison one-place adjectives are just like nouns. - - mkAdj1 : N -> Adj1 ; - --- Two-place adjectives need a case for the second argument. - - mkAdj2 : N -> Case -> Adj2 ; - --- Comparison adjectives have three forms. The comparative and the superlative --- are always inflected in the same way, so the nominative of them is actually --- enough (except for the superlative "paras" of "hyvä"). - - mkAdjDeg : (kiva : N) -> (kivempaa,kivinta : Str) -> AdjDeg ; - - ---2 Verbs --- --- The fragment only has present tense so far, but in all persons. --- The worst case needs five forms, as shown in the following. - - mkV : (tulla,tulen,tulee,tulevat,tulkaa,tullaan : Str) -> V ; - --- A simple special case is the one with just one stem and no grade alternation. --- It covers e.g. "sanoa", "valua", "kysyä". - - vValua : (valua : Str) -> V ; - --- With two forms, the following function covers a variety of verbs, such as --- "ottaa", "käyttää", "löytää", "huoltaa", "hiihtää", "siirtää". - - vKattaa : (kattaa, katan : Str) -> V ; - --- When grade alternation is not present, just a one-form special case is needed --- ("poistaa", "ryystää"). - - vOstaa : (ostaa : Str) -> V ; - --- The following covers --- "juosta", "piestä", "nousta", "rangaista", "kävellä", "surra", "panna". - - vNousta : (nousta, nousen : Str) -> V ; - --- This is for one-syllable diphthong verbs like "juoda", "syödä". - - vTuoda : (tuoda : Str) -> V ; - --- The verbs "be" and the negative auxiliary are special. - - vOlla : V ; - vEi : V ; - --- Two-place verbs need a case, and can have a pre- or postposition. --- At least one of the latter is empty, $[]$. - - mkTV : V -> Case -> (prep,postp : Str) -> TV ; - --- If both are empty, the following special function can be used. - - tvCase : V -> Case -> TV ; - --- Verbs with a direct (accusative) object --- are special, since their complement case is finally decided in syntax. - - tvDir : V -> TV ; - --- The definitions should not bother the user of the API. So they are --- hidden from the document. ---. - -- singular defined in types.Fin - -- plural defined in types.Fin - - human = Human ; - nonhuman = NonHuman ; - - nominative = Nom ; - genitive = Gen ; - partitive = Part ; - inessive = Iness ; - elative = Elat ; - illative = Illat ; - adessive = Adess ; - ablative = Ablat ; - allative = Allat ; - - mkN = \a,b,c,d,e,f,g,h,i,j,k -> - mkNoun a b c d e f g h i j ** {g = k ; lock_N = <>} ; - - nKukko = \a,b,c,g -> sKukko a b c ** {g = g ; lock_N = <>} ; - nTalo = \a,g -> sTalo a ** {g = g ; lock_N = <>} ; - nLinux = \a,g -> sLinux a ** {g = g ; lock_N = <>} ; - nPeruna = \a,g -> sPeruna a ** {g = g ; lock_N = <>} ; - nRae = \a,b,g -> sRae a b ** {g = g ; lock_N = <>} ; - nSusi = \a,b,c,g -> sSusi a b c ** {g = g ; lock_N = <>} ; - nPuu = \a,g -> sPuu a ** {g = g ; lock_N = <>} ; - nSuo = \a,g -> sSuo a ** {g = g ; lock_N = <>} ; - nNainen = \a,g -> sNainen a ** {g = g ; lock_N = <>} ; - nTilaus = \a,b,g -> sTilaus a b ** {g = g ; lock_N = <>} ; - nNauris = \a,g -> sNauris a ** {g = g ; lock_N = <>} ; - - - nComp = \s,n -> {s = \\c => s ++ n.s ! c ; g = n.g ; lock_N = <>} ; - mkFun = \n,c -> n2n n ** {c = NPCase c ; lock_Fun = <>} ; - fGen = \n -> mkFun n genitive ; - mkPN n = mkProperName n ** {lock_PN = <>} ; - - mkAdj1 = \x -> {s = x.s ; lock_Adj1 = <>} ; - mkAdj2 = \x,c -> mkAdj1 x ** {c = NPCase c ; lock_Adj2 = <>} ; - mkAdjDeg x y z = regAdjDegr x y z ** {lock_AdjDeg = <>} ; - - mkV a b c d e f = mkVerb a b c d e f ** {lock_V = <>} ; - vValua v = vSanoa v ** {lock_V = <>} ; - vKattaa v u = vOttaa v u ** {lock_V = <>} ; - vOstaa v = vPoistaa v ** {lock_V = <>} ; - vNousta v u = vJuosta v u ** {lock_V = <>} ; - vTuoda v = vJuoda v ** {lock_V = <>} ; - vOlla = verbOlla ** {lock_V = <>} ; - vEi = verbEi ** {lock_V = <>} ; - - 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/grammars/resource/finnish/ResFin.gf b/grammars/resource/finnish/ResFin.gf deleted file mode 100644 index d29eb7195..000000000 --- a/grammars/resource/finnish/ResFin.gf +++ /dev/null @@ -1,222 +0,0 @@ ---1 The Top-Level Finnish Resource Grammar --- --- Aarne Ranta 2002 -- 2003 --- --- This is the Finnish concrete syntax of the multilingual resource --- grammar. Most of the work is done in the file $syntax.Fin.gf$. --- However, for the purpose of documentation, we make here explicit the --- linearization types of each category, so that their structures and --- dependencies can be seen. --- Another substantial part are the linearization rules of some --- structural words. --- --- The users of the resource grammar should not look at this file for the --- linearization rules, which are in fact hidden in the document version. --- They should use $resource.Abs.gf$ to access the syntactic rules. --- This file can be consulted in those, hopefully rare, occasions in which --- one has to know how the syntactic categories are --- implemented. The parameter types are defined in $TypesFin.gf$. - -concrete ResFin of ResAbs = open Prelude, SyntaxFin in { - -flags - startcat=Phr ; - lexer=unglue ; - unlexer=glue ; - -lincat - N = CommNoun ; - -- = {s : NForm => Str ; g : Gender} - CN = CommNounPhrase ; - NP = {s : NPForm => Str ; n : Number ; p : NPPerson} ; - PN = {s : Case => Str} ; - Det = {s : Gender => Case => Str ; n : Number} ; - Fun = Function ; - -- = CommNounPhrase ** {c : NPForm} ; - Fun2 = Function ** {c2 : NPForm} ; - - Adj1 = Adjective ; - -- = CommonNoun - Adj2 = Adjective ** {c : NPForm} ; - AdjDeg = {s : Degree => NForm => Str} ; - AP = {s : AdjPos => Number => Case => Str} ; - - V = Verb ; - -- = {s : VForm => Str} - VP = Verb ** {s2 : VForm => Str ; c : ComplCase} ; - TV = TransVerb ; - -- = Verb ** {s3, s4 : Str ; c : ComplCase} ; - V3 = TransVerb ** {s5, s6 : Str ; c2 : ComplCase} ; - VS = Verb ; - - AdV = {s : Str} ; - - S = Sentence ; - -- = {s : Str} ; - Slash = Sentence ** {s2 : Str ; c : Case} ; - - RP = {s : Number => Case => Str} ; - RC = {s : Number => Str} ; - - IP = {s : NPForm => Str ; n : Number} ; - Qu = {s : Str} ; - Imp = {s : Number => Str} ; - Phr = {s : Str} ; - - Conj = {s : Str ; n : Number} ; - ConjD = {s1 : Str ; s2 : Str ; n : Number} ; - - ListS = {s1 : Str ; s2 : Str} ; - ListAP = {s1,s2 : AdjPos => Number => Case => Str} ; - ListNP = {s1,s2 : NPForm => Str ; n : Number ; p : NPPerson} ; - ---. - -lin - UseN = noun2CommNounPhrase ; - ModAdj = modCommNounPhrase ; - ModGenOne = npGenDet singular ; - ModGenMany = npGenDet plural ; - UsePN = nameNounPhrase ; - UseFun = funAsCommNounPhrase ; - AppFun = appFunComm ; - AppFun2 = appFun2 ; - AdjP1 = adj2adjPhrase ; - ComplAdj = complAdj ; - PositAdjP = positAdjPhrase ; - ComparAdjP = comparAdjPhrase ; - SuperlNP = superlNounPhrase ; - - DetNP = detNounPhrase ; - IndefOneNP = indefNounPhrase singular ; - IndefManyNP = indefNounPhrase plural ; - DefOneNP = defNounPhrase singular ; - DefManyNP = defNounPhrase plural ; - - CNthatS = nounThatSentence ; - - PredVP = predVerbPhrase ; - PosV = predVerb True ; - NegV = predVerb False ; - PosA = predAdjective True ; - NegA = predAdjective False ; - PosCN = predCommNoun True ; - NegCN = predCommNoun False ; - PosTV = complTransVerb True ; - NegTV = complTransVerb False ; - PosV3 = complDitransVerb True ; - NegV3 = complDitransVerb False ; - PosPassV = passVerb True ; - NegPassV = passVerb False ; - PosNP = predNounPhrase True ; - NegNP = predNounPhrase False ; - PosVS = complSentVerb True ; - NegVS = complSentVerb False ; - VTrans = transAsVerb ; - - AdvVP = adVerbPhrase ; - LocNP = locativeNounPhrase ; - AdvCN = advCommNounPhrase ; - AdvAP = advAdjPhrase ; - - PosSlashTV = slashTransVerb True ; - NegSlashTV = slashTransVerb False ; - OneVP = passPredVerbPhrase ; - - IdRP = identRelPron ; - FunRP = funRelPron ; - RelVP = relVerbPhrase ; - RelSlash = relSlash ; - ModRC = modRelClause ; - RelSuch = relSuch ; - - WhoOne = intPronWho singular ; - WhoMany = intPronWho plural ; - WhatOne = intPronWhat singular ; - WhatMany = intPronWhat plural ; - FunIP = funIntPron ; - NounIPOne = nounIntPron singular ; - NounIPMany = nounIntPron plural ; - - QuestVP = questVerbPhrase ; - IntVP = intVerbPhrase ; - IntSlash = intSlash ; - QuestAdv = questAdverbial ; - - ImperVP = imperVerbPhrase ; - - IndicPhrase = indicUtt ; - QuestPhrase = interrogUtt ; - ImperOne = imperUtterance singular ; - ImperMany = imperUtterance plural ; - - AdvS = advSentence ; - -lin - TwoS = twoSentence ; - ConsS = consSentence ; - ConjS = conjunctSentence ; - ConjDS = conjunctDistrSentence ; - - TwoAP = twoAdjPhrase ; - ConsAP = consAdjPhrase ; - ConjAP = conjunctAdjPhrase ; - ConjDAP = conjunctDistrAdjPhrase ; - - TwoNP = twoNounPhrase ; - ConsNP = consNounPhrase ; - ConjNP = conjunctNounPhrase ; - ConjDNP = conjunctDistrNounPhrase ; - - SubjS = subjunctSentence ; - SubjImper = subjunctImperative ; - SubjQu = subjunctQuestion ; - SubjVP = subjunctVerbPhrase ; - - PhrNP = useNounPhrase ; - PhrOneCN = useCommonNounPhrase singular ; - PhrManyCN = useCommonNounPhrase plural ; - PhrIP ip = ip ; - PhrIAdv ia = ia ; - - OnePhr p = p ; - ConsPhr = cc2 ; - -lin - INP = pronNounPhrase pronMina ; - ThouNP = pronNounPhrase pronSina ; - HeNP = pronNounPhrase pronHan ; - SheNP = pronNounPhrase pronHan ; - ItNP = nameNounPhrase pronSe ; - WeNP = pronNounPhrase pronMe ; - YeNP = pronNounPhrase pronTe ; - YouNP = pronNounPhrase pronTe ; - TheyNP = pronNounPhrase pronHe ; --- ne - - EveryDet = jokainenDet ; - AllDet = kaikkiDet ; - WhichDet = mikaDet ; - MostDet = useimmatDet ; - - HowIAdv = ss "kuinka" ; - WhenIAdv = ss "koska" ; - WhereIAdv = ss "missä" ; - WhyIAdv = ss "miksi" ; - - AndConj = ss "ja" ** {n = Pl} ; - OrConj = ss "tai" ** {n = Sg} ; - BothAnd = sd2 "sekä" "että" ** {n = Pl} ; - EitherOr = sd2 "joko" "tai" ** {n = Sg} ; - NeitherNor = sd2 "ei" "eikä" ** {n = Sg} ; - IfSubj = ss "jos" ; - WhenSubj = ss "kun" ; - - PhrYes = ss ("Kyllä" ++ stopPunct) ; - PhrNo = ss ("Ei" ++ stopPunct) ; - - VeryAdv = ss "hyvin" ; - TooAdv = ss "liian" ; - OtherwiseAdv = ss "muuten" ; - ThereforeAdv = ss "siksi" ; - -} ; diff --git a/grammars/resource/finnish/SyntaxFin.gf b/grammars/resource/finnish/SyntaxFin.gf deleted file mode 100644 index 1f7af543b..000000000 --- a/grammars/resource/finnish/SyntaxFin.gf +++ /dev/null @@ -1,1028 +0,0 @@ ---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 <n,c> of { - <_, Nom> => auto.s ! NPossNom ; - <Sg,Gen> => auto.s ! NPossNom ; - <Pl,Gen> => 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} ; - --- *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} ; - - - ---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} ; - - detNounPhrase : Determiner -> CommNounPhrase -> NounPhrase = \joku, mies -> - {s = \\f => let {c = npForm2Case joku.n f} in - joku.s ! mies.g ! c ++ mies.s ! False ! joku.n ! c ; - n = joku.n ; - p = NP3 - } ; - - mkDeterminerGen : Number -> (_,_ : Case => Str) -> Determiner = \n,mika,kuka -> - {s = table { - NonHuman => mika ; - Human => kuka - } ; - n = n - } ; - - mkDeterminer : Number -> (Case => Str) -> Determiner = \n,kaikki -> - mkDeterminerGen n kaikki kaikki ; - - jokainenDet = mkDeterminer Sg (caseTable Sg (sNainen "jokaista")) ; - kaikkiDet = mkDeterminer Pl kaikkiPron ; - useimmatDet = mkDeterminer Pl (caseTable Pl (sSuurin "useinta")) ; - mikaDet = mkDeterminerGen Sg (mikaInt ! Sg) (kukaInt ! Sg) ; - mitkaDet = mkDeterminerGen Pl (mikaInt ! Pl) (kukaInt ! Pl) ; - - indefNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n,mies -> - case n of { - Sg => singularNounPhrase mies ; - Pl => 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 - } ; - - 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 - } ; - ---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 => Number => Case => Str} ; - - adj2adjPhrase : Adjective -> AdjPhrase = \uusi -> - {s = \\_,n,c => uusi.s ! NCase n c} ; - - ---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 : Number => Case => Str = - \\n,c => te.s ! NPCase Part ++ iso.s ! Comp ! NCase n c} in - table { - APred => variants { - \\n,c => iso.s ! Comp ! NCase n c ++ 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 ! 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 : Number => Case => Str = \\n,c => hyva.s ! NCase n c ; - painissa : Str = paini.s ! hyva.c - } - in - {s = table { - AAttr => \\n,c => painissa ++ hyvat ! n ! c ; - APred => \\n,c => if_then_else Str - (isLocalNPForm hyva.c) - (variants { - hyvat ! n ! c ++ painissa ; - painissa ++ hyvat ! n ! c - } - ) - (painissa ++ hyvat ! n ! c) - } - } ; - - 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 ! 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} ; - --- The normal subject case is the nominative. - - nomVerbPhrase : (Verb ** {s2 : VForm => Str}) -> VerbPhrase = \v -> - v ** {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 : Bool -> Verb -> VerbPhrase = \b,walk -> - let { - noCompl : {s2 : VForm => Str} = {s2 = \\_ => []} ; - infCompl : {s2 : VForm => Str} = {s2 = table { - Imper Pl => walk.s ! ImpNegPl ; - _ => walk.s ! vFormNeg - } - } - } - in - if_then_else VerbPhrase b - (nomVerbPhrase (walk ** noCompl)) - (nomVerbPhrase (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 : Bool -> AdjPhrase -> VerbPhrase = \b,iso -> - let {isot : CommNounPhrase = {s = \\_ => iso.s ! APred ; g = NonHuman}} - in predCommNoun b isot ; - - predCommNoun : Bool -> CommNounPhrase -> VerbPhrase = \b,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 if_then_else VerbPhrase b - (nomVerbPhrase (verbOlla ** {s2 = miehia})) - (nomVerbPhrase (verbEi ** {s2 = olemiehia})) ; - - predNounPhrase : Bool -> NounPhrase -> VerbPhrase = \b,jussi -> - let {jussia : Bool => Number => Case => Str = \\_,_,_ => jussi.s ! NPCase Nom} - in predCommNoun b {s = jussia ; g = Human} ; --- 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 : Bool -> TransVerb -> NounPhrase -> VerbPhrase = \b,ostaa,talo -> - let { - ostan = predVerb b ostaa ; - talon : VForm => Str = \\v => - ostaa.s3 ++ talo.s ! complementCase b ostaa.c v ++ ostaa.s4 - } - in nomVerbPhrase { - s = ostan.s ; - s2 = \\v => ostan.s2 ! v ++ talon ! v - } ; - --- 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 : Bool -> TransVerb -> VerbPhrase = \b,tavata -> - {s = \\_ => if_then_else Str b (tavata.s ! Pass b) "ei" ; - s2 = \\_ => 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 : Bool -> Verb -> VerbPhrase = \b,uida -> - passTransVerb b (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 : - Bool -> DitransVerb -> NounPhrase -> NounPhrase -> VerbPhrase = - \b,ostaa,talo,me -> - let { - ostan = predVerb b ostaa ; - talon : VForm => Str = \\v => - ostaa.s3 ++ talo.s ! complementCase b ostaa.c v ++ ostaa.s4 ; - meille : VForm => Str = \\v => - ostaa.s5 ++ me.s ! complementCase b ostaa.c2 v ++ ostaa.s6 - } - in nomVerbPhrase { - s = ostan.s ; - s2 = \\v => ostan.s2 ! v ++ talon ! v ++ meille ! v - } ; - - ---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,n,c => liian.s ++ iso.s ! p ! n ! c - } ; - --- Adverbials are typically generated by case, prepositions, or postpositions. --- The rule for creating locative noun phrases by the inessive case --- is a shaky, since the adessive is often required. - - prepPhrase : Str -> Case -> NounPhrase -> Adverb = \ennen,c,talvi -> - ss (ennen ++ talvi.s ! NPCase c) ; - - postpPhrase : Str -> Case -> NounPhrase -> Adverb = \aikana,c,talvi -> - ss (talvi.s ! NPCase c ++ aikana) ; - - caseAdv : Case -> NounPhrase -> Adverb = prepPhrase [] ; - - locativeNounPhrase : NounPhrase -> Adverb = \np -> --- caseAdv Iness ; - ss (np.s ! NPCase Iness) ; - --- 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) ; - --- This is a macro for simultaneous predication and complementization. - - predTransVerb : Bool -> NounPhrase -> TransVerb -> NounPhrase -> Sentence = - \b,you,see,john -> - predVerbPhrase you (complTransVerb b see john) ; - ---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 : Bool -> SentenceVerb -> Sentence -> VerbPhrase = - \b,sanoa,jussiui -> - let { - sanon = predVerb b sanoa - } - in nomVerbPhrase { - s = sanon.s ; - s2 = \\v => sanon.s2 ! v ++ conjEtta ++ jussiui.s - } ; - - ---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 (predVerb b 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); - - ---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 => Number => Case => Str} ; - - twoAdjPhrase : (_,_ : AdjPhrase) -> ListAdjPhrase = \x,y -> - CO.twoTable3 AdjPos Number Case x y ; - - consAdjPhrase : ListAdjPhrase -> AdjPhrase -> ListAdjPhrase = \xs,x -> - CO.consTable3 AdjPos Number Case CO.comma xs x ; - - conjunctAdjPhrase : Conjunction -> ListAdjPhrase -> AdjPhrase = \c,xs -> - CO.conjunctTable3 AdjPos Number Case c xs ; - - conjunctDistrAdjPhrase : ConjunctionDistr -> ListAdjPhrase -> AdjPhrase = \c,xs -> - CO.conjunctDistrTable3 AdjPos Number Case 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 <m,n> of { - <Sg,Sg> => 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/grammars/resource/finnish/TestFin.gf b/grammars/resource/finnish/TestFin.gf deleted file mode 100644 index 5de29ffa8..000000000 --- a/grammars/resource/finnish/TestFin.gf +++ /dev/null @@ -1,54 +0,0 @@ --- use this path to read the grammar from the same directory ---# -path=.:../abstract:../../prelude - -concrete TestFin of TestAbs = ResFin ** open Prelude, SyntaxFin in { - -flags startcat=Phr ; lexer=unglue ; unlexer=glue ; - --- a random sample from the lexicon - -lin - Big = regAdjDegr (sTalo "iso") "isompaa" "isointa" ; - Small = regAdjDegr (sSusi "pieni" "pienen" "pienenä") "pienempää" "pienintä" ; - Old = regAdjDegr (sKukko "vanha" "vanhan" "vanhoja") "vanhempaa" "vanhinta" ; - Young = regAdjDegr (sSusi "nuori" "nuoren" "nuorena") "nuorempaa" "nuorinta" ; - American = sNainen "amerikkalaista" ; - Finnish = sNainen "suomalaista" ; - - Married = sKukko "vihitty" "vihityn" "vihittyjä" ** {c = NPCase Illat} ; - --- naimisissa ! - - Man = cnHum (mkNoun "mies" "miehen" "miehenä" "miestä" "mieheen" "miehinä" - "miehissä" "miesten" "miehiä" "miehiin") ; - Woman = cnHum (sNainen "naista") ; - Car = cnNoHum (sTalo "auto") ; - House = cnNoHum (sTalo "talo") ; - Light = cnNoHum (sTalo "valo") ; - - Walk = vJuosta "kävellä" "kävelen" ; - Run = vJuosta "juosta" "juoksen" ; - Say = vSanoa "sanoa" ; - Prove = vPoistaa "todistaa" ; - Send = mkTransVerbDir (vOttaa "lähettää" "lähetän") ; - Love = mkTransVerbCase (vPoistaa "rakastaa") Part ; - Wait = mkTransVerbCase (vOttaa "odottaa" "odotan") Part ; - Give = mkTransVerbDir (vOttaa "antaa" "annan") ** - {s5 = [] ; s6 = [] ; c2 = CCase Allat} ; - Prefer = mkTransVerbDir (vOttaa "asettaa" "asetan") ** - {s5 = [] ; s6 = "edelle" ; c2 = CCase Gen} ; --- pitää paremp(a/i)na - - Mother = funGen (n2n (cnHum (sKukko "äiti" "äidin" "äitejä"))) ; - Uncle = funGen (n2n (cnHum (sKukko "setä" "sedän" "setiä"))) ; --- eno! - Connection = n2n (cnNoHum (sRakkaus "yhteys")) ** - {c = NPCase Elat ; c2 = NPCase Illat} ; --- Tampereelle ! - - Always = ss "aina" ; - Well = ss "hyvin" ; - - SwitchOn = mkTransVerbDir (vOttaa "sytyttää" "sytytän") ; - SwitchOff = mkTransVerbDir (vOttaa "sammuttaa" "sammutan") ; - - John = mkProperName (sKukko "Jussi" "Jussin" "Jusseja") ; - Mary = mkProperName (sKukko "Mari" "Marin" "Mareja") ; - -} ; diff --git a/grammars/resource/finnish/TypesFin.gf b/grammars/resource/finnish/TypesFin.gf deleted file mode 100644 index 86d0645fb..000000000 --- a/grammars/resource/finnish/TypesFin.gf +++ /dev/null @@ -1,126 +0,0 @@ ---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. We omit three of the cases, not --- occurring in the resource syntax. 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 ; - 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 - | 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 - } ; - - --- ---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. - - Adjective : Type = CommonNoun ; - AdjDegr : Type = {s : Degree => NForm => 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 - | Ind Number Person - | Imper Number - | ImpNegPl - | Pass Bool - ; - -oper - Verb : Type = SS1 VForm ; - - vFormNeg = Imper Sg ; - - vform2number : VForm -> Number = \v -> case v of { - Ind 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} ; - -} ; |