From ac9ce7d7e8063a6057e348e41d2ad906223ae10a Mon Sep 17 00:00:00 2001 From: aarne Date: Fri, 30 May 2008 09:39:29 +0000 Subject: [PATCH] started Finnish 1.4 --- lib/resource-1.4/finnish/AdjectiveFin.gf | 40 + lib/resource-1.4/finnish/AdverbFin.gf | 21 + lib/resource-1.4/finnish/CatFin.gf | 99 +++ lib/resource-1.4/finnish/ConjunctionFin.gf | 36 + lib/resource-1.4/finnish/ExtraFin.gf | 79 ++ lib/resource-1.4/finnish/ExtraFinAbs.gf | 19 + lib/resource-1.4/finnish/Finnish.gf | 6 + lib/resource-1.4/finnish/FinnishAbs.gf | 4 + lib/resource-1.4/finnish/GrammarFin.gf | 21 + lib/resource-1.4/finnish/IdiomFin.gf | 73 ++ lib/resource-1.4/finnish/LangFin.gf | 10 + lib/resource-1.4/finnish/LexiconFin.gf | 387 +++++++++ lib/resource-1.4/finnish/MorphoFin.gf | 904 +++++++++++++++++++++ lib/resource-1.4/finnish/NounFin.gf | 165 ++++ lib/resource-1.4/finnish/NumeralFin.gf | 179 ++++ lib/resource-1.4/finnish/ParadigmsFin.gf | 585 +++++++++++++ lib/resource-1.4/finnish/PhraseFin.gf | 24 + lib/resource-1.4/finnish/QuestionFin.gf | 69 ++ lib/resource-1.4/finnish/RelativeFin.gf | 50 ++ lib/resource-1.4/finnish/ResFin.gf | 575 +++++++++++++ lib/resource-1.4/finnish/SentenceFin.gf | 84 ++ lib/resource-1.4/finnish/StructuralFin.gf | 299 +++++++ lib/resource-1.4/finnish/VerbFin.gf | 102 +++ src-3.0/Makefile | 2 +- 24 files changed, 3832 insertions(+), 1 deletion(-) create mode 100644 lib/resource-1.4/finnish/AdjectiveFin.gf create mode 100644 lib/resource-1.4/finnish/AdverbFin.gf create mode 100644 lib/resource-1.4/finnish/CatFin.gf create mode 100644 lib/resource-1.4/finnish/ConjunctionFin.gf create mode 100644 lib/resource-1.4/finnish/ExtraFin.gf create mode 100644 lib/resource-1.4/finnish/ExtraFinAbs.gf create mode 100644 lib/resource-1.4/finnish/Finnish.gf create mode 100644 lib/resource-1.4/finnish/FinnishAbs.gf create mode 100644 lib/resource-1.4/finnish/GrammarFin.gf create mode 100644 lib/resource-1.4/finnish/IdiomFin.gf create mode 100644 lib/resource-1.4/finnish/LangFin.gf create mode 100644 lib/resource-1.4/finnish/LexiconFin.gf create mode 100644 lib/resource-1.4/finnish/MorphoFin.gf create mode 100644 lib/resource-1.4/finnish/NounFin.gf create mode 100644 lib/resource-1.4/finnish/NumeralFin.gf create mode 100644 lib/resource-1.4/finnish/ParadigmsFin.gf create mode 100644 lib/resource-1.4/finnish/PhraseFin.gf create mode 100644 lib/resource-1.4/finnish/QuestionFin.gf create mode 100644 lib/resource-1.4/finnish/RelativeFin.gf create mode 100644 lib/resource-1.4/finnish/ResFin.gf create mode 100644 lib/resource-1.4/finnish/SentenceFin.gf create mode 100644 lib/resource-1.4/finnish/StructuralFin.gf create mode 100644 lib/resource-1.4/finnish/VerbFin.gf diff --git a/lib/resource-1.4/finnish/AdjectiveFin.gf b/lib/resource-1.4/finnish/AdjectiveFin.gf new file mode 100644 index 000000000..78e7d4a7c --- /dev/null +++ b/lib/resource-1.4/finnish/AdjectiveFin.gf @@ -0,0 +1,40 @@ +concrete AdjectiveFin of Adjective = CatFin ** open ResFin, Prelude in { + + flags optimize=all_subs ; -- gfc size from 2864336 to 6786 - i.e. factor 422 + + lin + + PositA a = { + s = \\_ => a.s ! Posit + } ; + ComparA a np = { + s = \\isMod,af => case isMod of { + True => np.s ! NPCase Part ++ a.s ! Compar ! af ; -- minua isompi + _ => a.s ! Compar ! af ++ "kuin" ++ np.s ! NPCase Nom -- isompi kuin minä + } + } ; + +-- $SuperlA$ belongs to determiner syntax in $Noun$. + + ComplA2 adj np = { + s = \\isMod,af => + preOrPost isMod (appCompl True Pos adj.c2 np) (adj.s ! Posit ! af) + } ; + + ReflA2 adj = { + s = \\isMod,af => + preOrPost isMod + (appCompl True Pos adj.c2 (reflPron (agrP3 Sg))) (adj.s ! Posit ! af) + } ; + + SentAP ap sc = { + s = \\b,a => ap.s ! b ! a ++ sc.s + } ; + + AdAP ada ap = { + s = \\b,af => ada.s ++ ap.s ! b ! af + } ; + + UseA2 a = a ; + +} diff --git a/lib/resource-1.4/finnish/AdverbFin.gf b/lib/resource-1.4/finnish/AdverbFin.gf new file mode 100644 index 000000000..a331f985a --- /dev/null +++ b/lib/resource-1.4/finnish/AdverbFin.gf @@ -0,0 +1,21 @@ +concrete AdverbFin of Adverb = CatFin ** open ResFin, Prelude in { + + lin + PositAdvAdj a = {s = a.s ! Posit ! AAdv} ; + ComparAdvAdj cadv a np = { + s = cadv.s ++ a.s ! Posit ! AAdv ++ "kuin" ++ np.s ! NPCase Nom + } ; + ComparAdvAdjS cadv a s = { + s = cadv.s ++ a.s ! Posit ! AAdv ++ "kuin" ++ s.s + } ; + + PrepNP prep np = {s = preOrPost prep.isPre prep.s (np.s ! prep.c)} ; + + AdAdv = cc2 ; + + SubjS = cc2 ; +----b AdvSC s = s ; + + AdnCAdv cadv = {s = cadv.s ++ "kuin"} ; + +} diff --git a/lib/resource-1.4/finnish/CatFin.gf b/lib/resource-1.4/finnish/CatFin.gf new file mode 100644 index 000000000..a33c5566b --- /dev/null +++ b/lib/resource-1.4/finnish/CatFin.gf @@ -0,0 +1,99 @@ +concrete CatFin of Cat = CommonX ** open ResFin, Prelude in { + + flags optimize=all_subs ; + + lincat + +-- Tensed/Untensed + + S = {s : Str} ; + QS = {s : Str} ; + RS = {s : Agr => Str ; c : NPForm} ; + SSlash = {s : Str ; c2 : Compl} ; + +-- Sentence + + Cl = {s : ResFin.Tense => Anteriority => Polarity => SType => Str} ; + ClSlash = {s : ResFin.Tense => Anteriority => Polarity => Str ; c2 : Compl} ; + Imp = {s : Polarity => Number => Str} ; + +-- Question + + QCl = {s : ResFin.Tense => Anteriority => Polarity => Str} ; + IP = {s : NPForm => Str ; n : Number} ; + IComp = {s : Agr => Str} ; + IDet = {s : Case => Str ; n : Number} ; + IQuant = {s : Number => Case => Str} ; + +-- Relative + + RCl = {s : ResFin.Tense => Anteriority => Polarity => Agr => Str ; c : NPForm} ; + RP = {s : Number => NPForm => Str ; a : RAgr} ; + +-- Verb + + VP = ResFin.VP ; + Comp = {s : Agr => Str} ; + +-- Adjective + +-- The $Bool$ tells whether usage is modifying (as opposed to +-- predicative), e.g. "x on suurempi kuin y" vs. "y:tä suurempi luku". + + AP = {s : Bool => AForm => Str} ; + +-- Noun + +-- The $Bool$ tells if a possessive suffix is attached, which affects the case. + + CN = {s : NForm => Str} ; + Pron = {s : NPForm => Str ; a : Agr} ; + NP = {s : NPForm => Str ; a : Agr ; isPron : Bool} ; + Det = { + s1 : Case => Str ; -- minun kolme + s2 : Str ; -- -ni + n : Number ; -- Pl (agreement feature for verb) + isNum : Bool ; -- True (a numeral is present) + isPoss : Bool ; -- True (a possessive suffix is present) + isDef : Bool -- True (verb agrees in Pl, Nom is not Part) + } ; +---- QuantSg, QuantPl = {s1 : Case => Str ; s2 : Str ; isPoss, isDef : Bool} ; + Ord = {s : Number => Case => Str} ; + Predet = {s : Number => NPForm => Str} ; + Quant = {s1 : Number => Case => Str ; s2 : Str ; isPoss, isDef : Bool} ; + Art = {s1 : Number => Case => Str ; s2 : Str ; isPoss, isDef : Bool} ; + Card = {s : Number => Case => Str ; n : Number} ; + Num = {s : Number => Case => Str ; isNum : Bool ; n : Number} ; + +-- Numeral + + Numeral = {s : CardOrd => Str ; n : Number} ; + Digits = {s : CardOrd => Str ; n : Number} ; + +-- Structural + + Conj = {s1,s2 : Str ; n : Number} ; +----b DConj = {s1,s2 : Str ; n : Number} ; + Subj = {s : Str} ; + Prep = Compl ; + +-- Open lexical classes, e.g. Lexicon + + V, VS, VQ = Verb1 ; -- = {s : VForm => Str ; sc : Case} ; + V2, VA, V2Q, V2S = Verb1 ** {c2 : Compl} ; + V2A = Verb1 ** {c2, c3 : Compl} ; + VV = Verb1 ; ---- infinitive form + V2V = Verb1 ** {c2 : Compl} ; ---- infinitive form + V3 = Verb1 ** {c2, c3 : Compl} ; + + A = {s : Degree => AForm => Str} ; + A2 = {s : Degree => AForm => Str ; c2 : Compl} ; + + N = {s : NForm => Str} ; + N2 = {s : NForm => Str} ** {c2 : Compl} ; + N3 = {s : NForm => Str} ** {c2,c3 : Compl} ; + PN = {s : Case => Str} ; + +oper Verb1 = {s : VForm => Str ; sc : NPForm} ; + +} diff --git a/lib/resource-1.4/finnish/ConjunctionFin.gf b/lib/resource-1.4/finnish/ConjunctionFin.gf new file mode 100644 index 000000000..94cea7f8c --- /dev/null +++ b/lib/resource-1.4/finnish/ConjunctionFin.gf @@ -0,0 +1,36 @@ +concrete ConjunctionFin of Conjunction = + CatFin ** open ResFin, Coordination, Prelude in { + + flags optimize=all_subs ; + + lin + + ConjS = conjunctDistrSS ; + + ConjAdv = conjunctDistrSS ; + + ConjNP conj ss = conjunctDistrTable NPForm conj ss ** { + a = {n = conjNumber conj.n ss.a.n ; p = ss.a.p} ; + isPron = False + } ; + + ConjAP conj ss = conjunctDistrTable2 Bool AForm conj ss ; + +-- These fun's are generated from the list cat's. + + BaseS = twoSS ; + ConsS = consrSS comma ; + BaseAdv = twoSS ; + ConsAdv = consrSS comma ; + BaseNP x y = twoTable NPForm x y ** {a = conjAgr x.a y.a} ; + ConsNP xs x = consrTable NPForm comma xs x ** {a = conjAgr xs.a x.a} ; + BaseAP x y = twoTable2 Bool AForm x y ; + ConsAP xs x = consrTable2 Bool AForm comma xs x ; + + lincat + [S] = {s1,s2 : Str} ; + [Adv] = {s1,s2 : Str} ; + [NP] = {s1,s2 : NPForm => Str ; a : Agr} ; + [AP] = {s1,s2 : Bool => AForm => Str} ; + +} diff --git a/lib/resource-1.4/finnish/ExtraFin.gf b/lib/resource-1.4/finnish/ExtraFin.gf new file mode 100644 index 000000000..104b1bde0 --- /dev/null +++ b/lib/resource-1.4/finnish/ExtraFin.gf @@ -0,0 +1,79 @@ +--# -path=.:abstract:common:prelude + +concrete ExtraFin of ExtraFinAbs = CatFin ** + open ResFin, MorphoFin, Coordination, Prelude, NounFin, StructuralFin in { + + lin + GenNP np = { + s1 = \\_,_ => np.s ! NPCase Gen ; + s2 = [] ; + isNum = False ; + isPoss = False ; + isDef = True --- "Jussin kolme autoa ovat" ; thus "...on" is missing + } ; + + + lincat + VPI = {s : Str} ; + [VPI] = {s1,s2 : Str} ; + lin + BaseVPI = twoSS ; + ConsVPI = consrSS comma ; + + MkVPI vp = {s = infVP (NPCase Nom) Pos (agrP3 Sg) vp} ; + ConjVPI = conjunctSS ; + ComplVPIVV vv vpi = + insertObj (\\_,_,_ => vpi.s) (predV vv) ; + + AdvExistNP adv np = + mkClause (\_ -> adv.s) np.a (insertObj + (\\_,b,_ => np.s ! NPCase Nom) (predV (verbOlla ** {sc = NPCase Nom}))) ; + + RelExistNP prep rp np = { + s = \\t,ant,bo,ag => + let cl = + mkClause + (\_ -> appCompl True Pos prep (rp2np ag.n rp)) + np.a + (insertObj + (\\_,b,_ => np.s ! NPCase Nom) + (predV (verbOlla ** {sc = NPCase Nom}))) ; + in + cl.s ! t ! ant ! bo ! SDecl ; + c = NPCase Nom + } ; + + AdvPredNP adv v np = + mkClause (\_ -> adv.s) np.a (insertObj + (\\_,b,_ => np.s ! NPCase Nom) (predV v)) ; + + i_implicPron = mkPronoun [] "minun" "minua" "minuna" "minuun" Sg P1 ; + whatPart_IP = { + s = table { + NPCase Nom | NPAcc => "mitä" ; + c => whatSg_IP.s ! c + } ; + n = Sg + } ; + + PartCN cn = + let + acn = DetCN (DetSg IndefArt NoOrd) cn + in { + s = table { + NPCase Nom | NPAcc => acn.s ! NPCase Part ; + c => acn.s ! c + } ; + a = acn.a ; + isPron = False + } ; + + + vai_Conj = {s = "vai" ; n = Sg} ; + + + CompPartAP ap = { + s = \\agr => ap.s ! False ! AN (NCase agr.n Part) + } ; + +} diff --git a/lib/resource-1.4/finnish/ExtraFinAbs.gf b/lib/resource-1.4/finnish/ExtraFinAbs.gf new file mode 100644 index 000000000..824411120 --- /dev/null +++ b/lib/resource-1.4/finnish/ExtraFinAbs.gf @@ -0,0 +1,19 @@ +abstract ExtraFinAbs = Extra [ + GenNP,VPI,ListVPI,BaseVPI,ConsVPI,MkVPI,ComplVPIVV,ConjVPI, + VV,VP,Conj,NP,Quant] ** { + + fun + AdvExistNP : Adv -> NP -> Cl ; -- kuvassa olemme me + AdvPredNP : Adv -> V -> NP -> Cl ; -- kuvassa hymyilee Veikko + + RelExistNP : Prep -> RP -> NP -> RCl ; -- jossa on jazzia + + i_implicPron : Pron ; -- (minä), minut, ... + whatPart_IP : IP ; + + PartCN : CN -> NP ; -- olutta + + vai_Conj : Conj ; -- minä vai sinä? ("or" in question) + + CompPartAP : AP -> Comp ; -- kahvi on valmista +} diff --git a/lib/resource-1.4/finnish/Finnish.gf b/lib/resource-1.4/finnish/Finnish.gf new file mode 100644 index 000000000..dc8d232a9 --- /dev/null +++ b/lib/resource-1.4/finnish/Finnish.gf @@ -0,0 +1,6 @@ +--# -path=.:../abstract:../common:prelude + +concrete Finnish of FinnishAbs = + LangFin, + ExtraFin + ** {} ; diff --git a/lib/resource-1.4/finnish/FinnishAbs.gf b/lib/resource-1.4/finnish/FinnishAbs.gf new file mode 100644 index 000000000..017946917 --- /dev/null +++ b/lib/resource-1.4/finnish/FinnishAbs.gf @@ -0,0 +1,4 @@ +abstract FinnishAbs = + Lang, + ExtraFinAbs + ** {} ; diff --git a/lib/resource-1.4/finnish/GrammarFin.gf b/lib/resource-1.4/finnish/GrammarFin.gf new file mode 100644 index 000000000..6ae2ee9ea --- /dev/null +++ b/lib/resource-1.4/finnish/GrammarFin.gf @@ -0,0 +1,21 @@ +--# -path=.:../abstract:../common:prelude + +concrete GrammarFin of Grammar = + NounFin, + VerbFin, + AdjectiveFin, + AdverbFin, + NumeralFin, + SentenceFin, + QuestionFin, + RelativeFin, + ConjunctionFin, + PhraseFin, + TextX, + IdiomFin, + StructuralFin + ** { + +flags startcat = Phr ; unlexer = finnish ; lexer = text ; + +} ; diff --git a/lib/resource-1.4/finnish/IdiomFin.gf b/lib/resource-1.4/finnish/IdiomFin.gf new file mode 100644 index 000000000..983cb1496 --- /dev/null +++ b/lib/resource-1.4/finnish/IdiomFin.gf @@ -0,0 +1,73 @@ +concrete IdiomFin of Idiom = CatFin ** + open MorphoFin, ParadigmsFin, Prelude in { + + flags optimize=all_subs ; + + lin + ExistNP np = + let + cas : Polarity -> NPForm = \p -> case p of { + Pos => NPCase Nom ; -- on olemassa luku + Neg => NPCase Part -- ei ole olemassa lukua + } + in + mkClause noSubj (agrP3 Sg) (insertObj + (\\_,b,_ => "olemassa" ++ np.s ! cas b) (predV olla)) ; + + ExistIP ip = + let + cas : NPForm = NPCase Part ; --- dep on num, pol? + vp = insertObj (\\_,b,_ => "olemassa") (predV olla) ; + cl = mkClause (subjForm (ip ** {isPron = False ; a = agrP3 Sg}) cas) (agrP3 Sg) vp + in { + s = \\t,a,p => cl.s ! t ! a ! p ! SDecl + } ; + +-- Notice the nominative in the cleft $NP$: "se on Matti josta Liisa pitää" + + CleftNP np rs = mkClause (\_ -> "se") (agrP3 Sg) + (insertExtrapos (rs.s ! np.a) + (insertObj (\\_,_,_ => np.s ! NPCase Nom) (predV olla))) ; + +-- This gives the almost forbidden "se on Porissa kun Matti asuu". + + CleftAdv ad s = mkClause (\_ -> "se") (agrP3 Sg) + (insertExtrapos ("kun" ++ s.s) + (insertObj (\\_,_,_ => ad.s) (predV olla))) ; + + ImpersCl vp = mkClause noSubj (agrP3 Sg) vp ; + + GenericCl vp = mkClause noSubj (agrP3 Sg) { + s = \\_ => vp.s ! VIPass ; + s2 = vp.s2 ; + ext = vp.ext ; + sc = vp.sc + } ; + + ProgrVP vp = + let + inf = (vp.s ! VIInf Inf3Iness ! Simul ! Pos ! agrP3 Sg).fin ; + on = predV olla + in { + s = on.s ; + s2 = \\b,p,a => inf ++ vp.s2 ! b ! p ! a ; + ext = vp.ext ; + sc = vp.sc + } ; + +-- This gives "otetaan oluet" instead of "ottakaamme oluet". +-- The imperative is not available in a $VP$. + + ImpPl1 vp = + let vps = vp.s ! VIPass ! Simul ! Pos ! {n = Pl ; p = P1} + in + {s = vps.fin ++ vps.inf ++ + vp.s2 ! True ! Pos ! {n = Pl ; p = P1} ++ vp.ext + } ; + + oper + olla = verbOlla ** {sc = NPCase Nom} ; + + noSubj : Polarity -> Str = \_ -> [] ; +} + diff --git a/lib/resource-1.4/finnish/LangFin.gf b/lib/resource-1.4/finnish/LangFin.gf new file mode 100644 index 000000000..3cd551a18 --- /dev/null +++ b/lib/resource-1.4/finnish/LangFin.gf @@ -0,0 +1,10 @@ +--# -path=.:../abstract:../common:prelude + +concrete LangFin of Lang = + GrammarFin, + LexiconFin + ** { + +flags startcat = Phr ; unlexer = text ; lexer = finnish ; + +} ; diff --git a/lib/resource-1.4/finnish/LexiconFin.gf b/lib/resource-1.4/finnish/LexiconFin.gf new file mode 100644 index 000000000..7a19a2521 --- /dev/null +++ b/lib/resource-1.4/finnish/LexiconFin.gf @@ -0,0 +1,387 @@ +--# -path=.:prelude + +concrete LexiconFin of Lexicon = CatFin ** open MorphoFin, ParadigmsFin in { + +flags + optimize=values ; + + +lin + airplane_N = mkN "lentokone" ; + answer_V2S = mkV2 (mkV "vastata") (casePrep allative) ; + apartment_N = mkN "asunto" ; + apple_N = mkN "omena" ; --- omenia, not omenoita + art_N = mkN "taide" ; + ask_V2Q = mkV2 (mkV "kysyä") (casePrep ablative) ; + baby_N = mkN "vauva" ; + bad_A = mkA (mkN "paha") "pahempi" "pahin" ; + bank_N = mkN "pankki" ; + beautiful_A = mkA (mkN "kaunis") "kauniimpi" "kaunein" ; + become_VA = mkVA (mkV "tulla") (casePrep translative) ; + beer_N = mkN "olut" "oluita" ; + beg_V2V = mkV2 (mk2V "pyytää" "pyysi") (casePrep partitive) ; + big_A = mkA (mkN "suuri" "suuria") "suurempi" "suurin" ; + bike_N = mkN "polkupyörä" ; --- for correct vowel harmony + bird_N = mkN "lintu" ; + black_A = mkA (mkN "musta") "mustempi" "mustin" ; + blue_A = mkA (mkN "sininen") "sinisempi" "sinisin" ; + boat_N = mkN "vene" ; + book_N = mkN "kirja" ; + boot_N = mkN "saapas" ; + boss_N = mkN "pomo" ; + boy_N = mkN "poika" "pojan" "poikia" ; + bread_N = mkN "leipä" ; + break_V2 = mkV2 (mkV "rikkoa") ; + broad_A = mkA (mkN "leveä") "leveämpi" "levein" ; + brother_N2 = mkN2 ( + mkN "veli" "veljen" "veljenä" "veljeä" "veljeen" + "veljinä" "veljissä" "veljien" "veljiä" "veljiin") ; + brown_A = mkA (mkN "ruskea") "ruskeampi" "ruskein" ; + butter_N = mk3N "voi" "voin" "voita" ; ---- errors in Part + buy_V2 = mkV2 (mkV "ostaa") ; + camera_N = mkN "kamera" ; + cap_N = mkN "lakki" ; + car_N = mkN "auto" "auton" "autoja" ; -- mkN: audon + carpet_N = mkN "matto" ; + cat_N = mkN "kissa" ; + ceiling_N = mkN "katto" ; + chair_N = mkN "tuoli" ; + cheese_N = mkN "juusto" ; + child_N = mkN "lapsi" "lapsen" "lasta" "lapsena" "lapseen" + "lasten" "lapsia" "lapsina" "lapsissa" "lapsiin" ; + church_N = mkN "kirkko" ; + city_N = mkN "kaupunki" ; + clean_A = mkA (mkN "puhdas") ; + clever_A = mkA (mkN "viisas") ; + close_V2 = mkV2 (mkV "sulkea") ; + coat_N = mkN "takki" ; + cold_A = mkA (mkN "kylmä") "kylmempi" "kylmin" ; + come_V = mkV "tulla" ; + computer_N = mkN "tietokone" ; + country_N = mkN "maa" ; + cousin_N = mkN "serkku" ; + cow_N = mkN "lehmä" ; + die_V = mkV "kuolla" ; + dirty_A = mkA (mkN "likainen") "likaisempi" "likaisin" ; + distance_N3 = mkN3 (mkN "etäisyys") (casePrep elative) (casePrep illative) ; + doctor_N = mk2N "tohtori" "tohtoreita" ; + dog_N = mkN "koira" ; + door_N = mkN "ovi" "ovia" ; + drink_V2 = mkV2 (mkV "juoda") ; + easy_A2V = mkA2 (mkA (mkN "helppo") "helpompi" "helpoin") + (casePrep allative) ; + eat_V2 = mkV2 (mkV "syödä") ; + empty_A = mkA (mkN "tyhjä") "tyhjempi" "tyhjin" ; + enemy_N = mkN "vihollinen" ; + factory_N = mkN "tehdas" ; + father_N2 = mkN2 (mkN "isä") ; + fear_VS = mkVS (mk2V "pelätä" "pelkäsi") ; + find_V2 = mkV2 (mk2V "löytää" "löysi") ; + fish_N = mkN "kala" ; + floor_N = mk2N "lattia" "lattioita" ; + forget_V2 = mkV2 (mkV "unohtaa") ; + fridge_N = mkN "jääkaappi" ; + friend_N = mkN "ystävä" ; + fruit_N = mkN "hedelmä" ; + fun_AV = mkAV (mkA (mkN "hauska") "hauskempi" "hauskin") ; + garden_N = mkN "puutarha" "puutarhan" "puutarhoja" ; + girl_N = mkN "tyttö" ; + glove_N = mkN "käsine" ; + gold_N = mkN "kulta" ; + good_A = mkA (mkN "hyvä") "parempi" "parhain" ; --- paras + go_V = mkV "mennä" ; + green_A = mkA (mkN "vihreä") "vihreämpi" "vihrein" ; + harbour_N = mkN "satama" "sataman" "satamia" ; + hate_V2 = mkV2 (mkV "vihata") cpartitive ; + hat_N = mkN "hattu" ; + have_V2 = mkV2 (caseV adessive vOlla) ; + hear_V2 = mkV2 (mkV "kuulla") ; + hill_N = mkN "kukkula" ; + hope_VS = mkVS (mkV "toivoa") ; + horse_N = mkN "hevonen" ; + hot_A = mkA (mkN "kuuma") "kuumempi" "kuumin" ; + house_N = mkN "talo" ; + important_A = mkA (mkN "tärkeä") "tärkeämpi" "tärkein" ; + industry_N = mkN "teollisuus" ; + iron_N = mkN "rauta" ; + king_N = mkN "kuningas" ; + know_V2 = mkV2 (mk2V "tietää" "tiesi") ; --- tuntea; gives tietänyt + lake_N = mkN "järvi" "järviä" ; + lamp_N = mkN "lamppu" ; + learn_V2 = + mkV2 (mk12V "oppia" "opin" "oppii" "oppivat" "oppikaa" "opitaan" + "opin" "oppi" "oppisi" "oppinut" "opittu" "opitun") ; + leather_N = mkN "nahka" ; --- nahan + leave_V2 = mkV2 (mkV "jättää") ; + like_V2 = mkV2 (mkV "pitää") elative ; + listen_V2 = mkV2 (mkV "kuunnella" "kuunteli") partitive ; + live_V = mkV "elää" ; + long_A = mkA (mkN "pitkä") "pitempi" "pisin" ; + lose_V2 = mkV2 (mkV "hävitä" "hävisi") ; --- hukata + love_N = mk3N "rakkaus" "rakkauden" "rakkauksia" ; + love_V2 = mkV2 (mkV "rakastaa") partitive ; + man_N = mkN "mies" "miehen" "miestä" "miehenä" "mieheen" + "miesten" "miehiä" "miehinä" "miehissä" "miehiin" ; + married_A2 = mkA2 (mkA "avioitunut") (postPrep genitive "kanssa") ; ---- infl + meat_N = mkN "liha" ; + milk_N = mkN "maito" ; + moon_N = mkN "kuu" ; + mother_N2 = mkN2 (mkN "äiti") ; + mountain_N = mkN "vuori" "vuoria" ; + music_N = mkN "musiikki" ; + narrow_A = mkA (mkN "kapea") "kapeampi" "kapein" ; + new_A = mkA (mk3N "uusi" "uuden" "uusia") "uudempi" "uusin" ; + newspaper_N = mkN "sanoma" (mkN "lehti" "lehtiä") ; --- for correct vowel harmony + oil_N = mkN "öljy" ; + old_A = mkA (mkN "vanha") "vanhempi" "vanhin" ; + open_V2 = mkV2 (mkV "avata" "avasi") ; + paint_V2A = mkV2A (mkV "maalata") accPrep (casePrep translative) ; + paper_N = mk2N "paperi" "papereita" ; + paris_PN = mkPN (mkN "Pariisi") ; + peace_N = mkN "rauha" ; + pen_N = mkN "kynä" ; + planet_N = mkN "planeetta" ; + plastic_N = mkN "muovi" ; + play_V2 = mkV2 (mkV "pelata") cpartitive ; --- leikkiä, soittaa + policeman_N = mkN "poliisi" ; + priest_N = mkN "pappi" ; + probable_AS = mkAS --- for vowel harmony + (mkA (mkN "todennäköinen") "tonennäköisempi" "todennälöisin") ; ---- sta + queen_N = mkN "kuningatar" ; + radio_N = mk2N "radio" "radioita" ; + rain_V0 = mkV0 (mk2V "sataa" "satoi") ; + read_V2 = mkV2 (mkV "lukea") ; + red_A = mkA "punainen" ; + religion_N = mkN "uskonto" ; + restaurant_N = mkN "ravintola" ; + river_N = mkN "joki" "jokia" ; + rock_N = mk2N "kallio" "kallioita" ; + roof_N = mkN "katto" ; + rubber_N = mkN "kumi" ; + run_V = mk2V "juosta" "juoksi" ; + say_VS = mkVS (mkV "sanoa") ; + school_N = mkN "koulu" ; + science_N = mkN "tiede" ; + sea_N = mkN "meri" "meren" "meriä" "merta" ; + seek_V2 = mkV2 (mkV "etsiä") cpartitive ; + see_V2 = mkV2 ( + mk12V "nähdä" "näen" "näkee" "näkevät" "nähkää" "nähdään" + "näin" "näki" "näkisi" "nähnyt" "nähty" "nähdyn") ; + sell_V3 = mkV3 (mkV "myydä") accPrep (casePrep allative) ; + send_V3 = mkV3 (mkV "lähettää") accPrep (casePrep allative) ; + sheep_N = mkN "lammas" ; + ship_N = mkN "laiva" ; + shirt_N = mkN "paita" ; + shoe_N = mkN "kenkä" ; + shop_N = mkN "kauppa" ; + short_A = mkA (mkN "lyhyt" "lyhyitä") ; + silver_N = mkN "hopea" ; + sister_N = mkN "sisko" ; + sleep_V = mkV "nukkua" ; + small_A = mkA (mk2N "pieni" "pieniä") "pienempi" "pienin" ; + snake_N = mkN "käärme" ; + sock_N = mkN "sukka" ; + speak_V2 = mkV2 (mkV "puhua") cpartitive ; + star_N = mkN "tähti" "tähtiä" ; + steel_N = mkN "teräs" ; + stone_N = mkN "kivi" "kiviä" ; + stove_N = mk3N "liesi" "lieden" "liesiä" ; + student_N = mk2N "opiskelija" "opiskelijoita" ; + stupid_A = mkA "tyhmä" ; + sun_N = mkN "aurinko" ; + switch8off_V2 = mkV2 (mkV "sammuttaa") ; --- + switch8on_V2 = mkV2 (mkV "sytyttää") ; --- + table_N = mkN "pöytä" ; + talk_V3 = mkV3 (mkV "puhua") (casePrep allative) (casePrep elative) ; + teacher_N = mkN "opettaja" ; + teach_V2 = mkV2 (mkV "opettaa") ; + television_N = mk2N "televisio" "televisioita" ; + thick_A = mkA "paksu" ; + thin_A = mkA (mkN "ohut" "ohuita") ; + train_N = mkN "juna" ; + travel_V = mkV "matkustaa" ; + tree_N = mkN "puu" ; + ---- trousers_N = mkN "trousers" ; + ugly_A = mkA (mkN "ruma") "rumempi" "rumin" ; + understand_V2 = mkV2 (mkV "ymmärtää" "ymmärrän" "ymmärsi") ; + university_N = mkN "yliopisto" ; + village_N = mkN "kylä" ; + wait_V2 = mkV2 (mkV "odottaa") partitive ; + walk_V = mkV "kävellä" "käveli" ; + warm_A = mkA + (mkN "lämmin" "lämpimän" "lämpimänä" "lämmintä" "lämpimään" + "lämpiminä" "lämpimissä" "lämpimien" "lämpimiä" "lämpimiin" + ) + "lämpimämpi" "lämpimin" ; + war_N = mkN "sota" ; + watch_V2 = mkV2 (mkV "katsella") cpartitive ; + water_N = mk3N "vesi" "veden" "vesiä" ; + white_A = mkA "valkoinen" ; + window_N = mk2N "ikkuna" "ikkunoita" ; + wine_N = mkN "viini" ; + win_V2 = mkV2 (mkV "voittaa") ; + woman_N = mkN "nainen" ; + wonder_VQ = mkVQ (mkV "ihmetellä") ; + wood_N = mkN "puu" ; + write_V2 = mkV2 (mkV "kirjoittaa") ; + yellow_A = mkA "keltainen" ; + young_A = mkA (mkN "nuori" "nuoria") "nuorempi" "nuorin" ; + + do_V2 = mkV2 ( + mkV "tehdä" "teen" "tekee" "tekevät" "tehkää" "tehdään" + "tein" "teki" "tekisi" "tehnyt" "tehty" "tehdyn") ; + + now_Adv = mkAdv "nyt" ; + already_Adv = mkAdv "jo" ; + song_N = mkN "laulu" ; + add_V3 = mkV3 (mkV "lisätä") accPrep (casePrep illative) ; + number_N = mk2N "numero" "numeroita" ; + put_V2 = mkV2 (mkV "panna") ; + stop_V = mkV "pysähtyä" ; + jump_V = mkV "hypätä" ; + left_Ord = mkOrd (mkN "vasen") ; + right_Ord = mkOrd (mkN "oikea") ; + far_Adv = mkAdv "kaukana" ; + correct_A = mkA "oikea" ; + dry_A = mkA (mkN "kuiva") "kuivempi" "kuivin" ; + dull_A = mkA (mkN "tylsä") "tylsempi" "tylsin" ; + full_A = mkA (mk3N "täysi" "täyden" "täysiä") "täydempi" "täysin" ; + heavy_A = mkA "raskas" ; + near_A = mkA (mkN "läheinen") ; + rotten_A = mkA "mätä" ; + round_A = mkA "pyöreä" ; + sharp_A = mkA "terävä" ; + smooth_A = mkA "sileä" ; + straight_A = mkA (mkN "suora") "suorempi" "suorin" ; + wet_A = mkA (mkN "märkä") "märempi" "märin" ; + wide_A = mkA "leveä" ; + animal_N = mk3N "eläin" "eläimen" "eläimiä" ; + ashes_N = mkN "tuhka" ; + back_N = mkN "selkä" ; + bark_N = mkN "kaarna" ; + belly_N = mkN "vatsa" ; + blood_N = mkN "veri" "veren" "veriä" "verta" ; + bone_N = mkN "luu" ; + breast_N = mkN "rinta" ; + cloud_N = mk2N "pilvi" "pilviä" ; + day_N = mkN "päivä" ; + dust_N = mkN "pöly" ; + ear_N = mkN "korva" ; + earth_N = mkN "maa" ; + egg_N = mkN "muna" ; + eye_N = mkN "silmä" ; + fat_N = mkN "rasva" ; + feather_N = mk3N "höyhen" "höyhenen" "höyheniä" ; + fingernail_N = mk3N "kynsi" "kynnen" "kynsiä" ; + fire_N = mk2N "tuli" "tulia" ; + flower_N = mkN "kukka" ; + fog_N = mkN "sumu" ; + foot_N = mkN "jalka" ; + forest_N = mkN "metsä" ; + grass_N = mkN "ruoho" ; + guts_N = mkN "sisälmys" ; --- suoli + hair_N = mkN "hius" ; + hand_N = mk3N "käsi" "käden" "käsiä" ; + head_N = mkN "pää" ; + heart_N = mkN "sydän" "sydämen" "sydäntä" "sydämenä" "sydämeen" + "sydänten" "sydämiä" "sydäminä" "sydämissä" "sydämiin" ; + horn_N = mk2N "sarvi" "sarvia" ; + husband_N = mkN "mies" "miehen" "miestä" "miehenä" "mieheen" + "miesten" "miehiä" "miehinä" "miehissä" "miehiin" ; + ice_N = mkN "jää" ; + knee_N = mk2N "polvi" "polvia" ; + leaf_N = mk2N "lehti" "lehtiä" ; + leg_N = mkN "jalka" ; --- sääri + liver_N = mkN "maksa" ; + louse_N = mkN "lude" ; + mouth_N = mkN "suu" ; + name_N = mk2N "nimi" "nimiä" ; + neck_N = mkN "niska" ; + night_N = mkN "yö" ; + nose_N = mkN "nenä" ; + person_N = mkN "henkilö" ; + rain_N = mkN "sade" ; + road_N = mkN "tie" ; + root_N = mk2N "juuri" "juuria" ; + rope_N = mk3N "köysi" "köyden" "köysiä" ; + salt_N = mkN "suola" ; + sand_N = mkN "hiekka" ; + seed_N = mkN "siemen" ; + skin_N = mkN "nahka" ; + sky_N = mk3N "taivas" "taivaan" "taivaita" ; + smoke_N = mkN "savu" ; + snow_N = mkN "lumi" "lumen" "lumia" "lunta" ; + stick_N = mkN "keppi" ; + tail_N = mkN "häntä" ; + tongue_N = mk2N "kieli" "kieliä" ; + tooth_N = mkN "hammas" ; + wife_N = mkN "vaimo" ; + wind_N = mk2N "tuuli" "tuulia" ; + wing_N = mk2N "siipi" "siipiä" ; + worm_N = mkN "mato" ; + year_N = mk3N "vuosi" "vuoden" "vuosia" ; + bite_V2 = mkV2 (mkV "purra") ; + blow_V = mkV "puhaltaa" ; + burn_V = mkV "palaa" ; + count_V2 = mkV2 (mkV "laskea") ; + cut_V2 = mkV2 (mk2V "leikata" "leikkasi") ; + dig_V = mkV "kaivaa" ; + fall_V = mkV "pudota" "putoan" "putosi" ; + fear_V2 = mkV2 (mkV "pelätä" "pelkään" "pelkäsi") cpartitive ; + fight_V2 = mkV2 (mkV "taistella") (postPrep partitive "vastaan") ; + float_V = mkV "kellua" ; + flow_V = mkV "virrata" "virtaan" "virtasi" ; + fly_V = mkV "lentää" ; + freeze_V = mkV "jäätyä" ; + give_V3 = mkV3 (mkV "antaa" "annan" "antoi") accPrep (casePrep allative) ; + hit_V2 = mkV2 (mkV "lyödä") cpartitive ; + hold_V2 = mkV2 (mkV "pitää") cpartitive ; + hunt_V2 = mkV2 (mkV "metsästää") cpartitive ; + kill_V2 = mkV2 (mkV "tappaa") ; + laugh_V = mkV "nauraa" "nauroi" ; + lie_V = mkV "maata" "makasi" ; + play_V = mkV "pelata" ; + pull_V2 = mkV2 (mkV "vetää") ; + push_V2 = mkV2 (mkV "työntää") ; + rub_V2 = mkV2 (mkV "hieroa") cpartitive ; + scratch_V2 = mkV2 (mkV "raapia") cpartitive ; + sew_V = mkV "kylvää" ; + sing_V = mkV "laulaa" ; + sit_V = mkV "istua" ; + smell_V = mk2V "haistaa" "haistoi" ; + spit_V = mkV "sylkeä" ; + split_V2 = mkV2 (mk2V "halkaista" "halkaisi") ; + squeeze_V2 = mkV2 (mkV "puristaa") cpartitive ; + stab_V2 = mkV2 (mkV "pistää") cpartitive ; + stand_V = mk12V "seistä" "seison" "seisoo" "seisovat" "seiskää" "seistään" + "seisoin" "seisoi" "seisoisi" "seissyt" "seisty" "seistyn" ; --- *seisoivät + suck_V2 = mkV2 (mkV "imeä") cpartitive ; + swell_V = mkV "turvota" "turposi" ; + swim_V = mkV "uida" "uin" "ui" ; + think_V = mkV "ajatella" "ajattelen" "ajatteli" ; + throw_V2 = mkV2 (mkV "heittää") ; + tie_V2 = mkV2 (mkV "sitoa") ; + turn_V = mkV "kääntyä" ; + vomit_V = mkV "oksentaa" ; + wash_V2 = mkV2 (mkV "pestä") ; + wipe_V2 = mkV2 (mkV "pyyhkiä") ; + + breathe_V = mkV "hengittää" ; + + grammar_N = mkN "kielioppi" ; + language_N = mk2N "kieli" "kieliä" ; + rule_N = mkN "sääntö" ; + + john_PN = mkPN "Jussi" ; + question_N = mkN "kysymys" ; + ready_A = mkA (mkN "valmis") ; + reason_N = mkN "syy" ; + today_Adv = mkAdv "tänään" ; + uncertain_A = mkA "epävarma" ; + + oper + mkOrd : N -> Ord ; + mkOrd x = {s = \\n,c => x.s ! NCase n c; lock_Ord = <> } ; + cpartitive = casePrep partitive ; + +} ; diff --git a/lib/resource-1.4/finnish/MorphoFin.gf b/lib/resource-1.4/finnish/MorphoFin.gf new file mode 100644 index 000000000..6c918af7c --- /dev/null +++ b/lib/resource-1.4/finnish/MorphoFin.gf @@ -0,0 +1,904 @@ +--# -path=.:../common:prelude + +--1 A Simple Finnish Resource Morphology +-- +-- Aarne Ranta 2002 -- 2005 +-- +-- This resource morphology contains definitions needed in the resource +-- syntax. To build a lexicon, it is better to use $ParadigmsFin$, which +-- gives a higher-level access to this module. + +resource MorphoFin = ResFin ** open Prelude in { + + flags optimize=all ; + + oper + + dLujuus : Str -> NForms = \lujuus -> + let + lujuu = init lujuus ; + lujuuksi = lujuu + "ksi" ; + a = vowHarmony (last lujuu) ; + in nForms10 + lujuus (lujuu + "den") (lujuu + "tt" + a) + (lujuu + "ten" + a) (lujuu + "teen") + (lujuuksi + "en") (lujuuksi + a) + (lujuuksi + "n" + a) (lujuuksi + "ss" + a) (lujuuksi + "in") ; + + dNainen : Str -> NForms = \nainen -> + let + a = vowHarmony nainen ; + nais = Predef.tk 3 nainen + "s" + in nForms10 + nainen (nais + "en") (nais + "t" + a) (nais + "en" + a) (nais + "een") + (nais + "ten") (nais + "i" + a) + (nais + "in" + a) (nais + "iss" + a) (nais + "iin") ; + + dPaluu : Str -> NForms = \paluu -> + let + a = vowHarmony paluu ; + palui = init paluu + "i" ; + u = last paluu ; + in nForms10 + paluu (paluu + "n") (paluu + "t" + a) (paluu + "n" + a) (paluu + "seen") + (palui + "den") (palui + "t" + a) + (palui + "n" + a) (palui + "ss" + a) (palui + "siin") ; + + dPuu : Str -> NForms = \puu -> + let + a = vowHarmony puu ; + pui = init puu + "i" ; + u = last puu ; + in nForms10 + puu (puu + "n") (puu + "t" + a) (puu + "n" + a) (puu + "h" + u + "n") + (pui + "den") (pui + "t" + a) + (pui + "n" + a) (pui + "ss" + a) (pui + "hin") ; + + dSuo : Str -> NForms = \suo -> + let + o = last suo ; + a = vowHarmony o ; + soi = Predef.tk 2 suo + o + "i" ; + in nForms10 + suo (suo + "n") (suo + "t" + a) (suo + "n" + a) (suo + "h" + o + "n") + (soi + "den") (soi + "t" + a) + (soi + "n" + a) (soi + "ss" + a) (soi + "hin") ; + + dKorkea : Str -> NForms = \korkea -> + let + a = last korkea ; + korke = init korkea ; + in nForms10 + korkea (korkea + "n") (korkea + a) + (korkea + "n" + a) (korkea + a + "n") + (korke + "iden") (korke + "it" + a) + (korke + "in" + a) (korke + "iss" + a) + (korke + "isiin") ; --- NSSK: korkeihin + + dKaunis : Str -> NForms = \kaunis -> + let + a = vowHarmony kaunis ; + kaunii = init kaunis + "i" ; + in nForms10 + kaunis (kaunii + "n") (kaunis + "t" + a) + (kaunii + "n" + a) (kaunii + "seen") + (kaunii + "den") (kaunii + "t" + a) + (kaunii + "n" + a) (kaunii + "ss" + a) + (kaunii + "siin") ; + + dLiitin : (_,_ : Str) -> NForms = \liitin,liittimen -> + let + a = vowHarmony liitin ; + liittim = Predef.tk 2 liittimen ; + in nForms10 + liitin (liittim + "en") (liitin + "t" + a) + (liittim + "en" + a) (liittim + "een") + (liittim + "ien") (liittim + "i" + a) + (liittim + "in" + a) (liittim + "iss" + a) + (liittim + "iin") ; + + dOnneton : Str -> NForms = \onneton -> + let + a = vowHarmony onneton ; + onnettom = Predef.tk 2 onneton + "t" + last (init onneton) + "m" ; + in nForms10 + onneton (onnettom + a + "n") (onneton + "t" + a) + (onnettom + a + "n" + a) (onnettom + a + a + "n") + (onnettom + "ien") (onnettom + "i" + a) + (onnettom + "in" + a) (onnettom + "iss" + a) + (onnettom + "iin") ; + + -- 2-syllable a/ä, o/ö, u/y + dUkko : (_,_ : Str) -> NForms = \ukko,ukon -> + let + o = last ukko ; + a = vowHarmony o ; + ukk = init ukko ; + uko = init ukon ; + uk = init uko ; + ukkoja = case of { + _ + "ä" => -- kylä,kyliä,kylien,kylissä,kyliin + ; + _ + ("au" | "eu") + _ + "a" => -- kauhojen,seurojen + ; + _ + ("o" | "u") + _ + "a" => -- pula,pulia,pulien,pulissa,puliin + ; + _ + "a" => -- kala,kaloja,kalojen,-oissa,-oihin + ; + _ => -- suku,sukuja,sukujen,-uissa,-uihin + + } ; + ukkoina = ukkoja.p3 + "in" + a ; + ukoissa = ukkoja.p4 + "iss" + a ; + in nForms10 + ukko ukon (ukko + a) (ukko + "n" + a) (ukko + o + "n") + ukkoja.p2 ukkoja.p1 + ukkoina ukoissa ukkoja.p5 ; + + -- 3-syllable a/ä/o/ö + dSilakka : (_,_,_ : Str) -> NForms = \silakka,silakan,silakoita -> + let + o = last silakka ; + a = getHarmony o ; + silakk = init silakka ; + silaka = init silakan ; + silak = init silaka ; + silakkaa = silakka + case o of { + "o" | "ö" => "t" + a ; -- radiota + _ => a -- sammakkoa + } ; + silakoiden = case of { + _ + "i" + ("a" | "ä") => -- asemia + ; + _ + O@("o" | "ö" | "u" | "y" | "e") + ("ja" | "jä") => -- pasuunoja + ; + _ + O@("o" | "ö" | "u" | "y" | "e") + ("ita" | "itä") => -- silakoita + ; + _ => Predef.error silakoita + } ; + silakkoina = silakoiden.p3 + "in" + a ; + silakoissa = silakoiden.p4 + "iss" + a ; + in nForms10 + silakka silakan silakoiden.p1 (silakka + "n" + a) (silakka + o + "n") + silakoiden.p2 silakoita + silakkoina silakoissa silakoiden.p5 ; + + dArpi : (_,_ : Str) -> NForms = \arpi,arven -> + let + a = vowHarmony arpi ; + arp = init arpi ; + arv = Predef.tk 2 arven ; + ar = init arp ; + arpe = case last arp of { + "s" => case last arv of { + "d" | "l" | "n" | "r" => -- suden,sutta ; jälsi ; kansi ; hirsi + ; + _ => -- kuusta,kuusien + + } ; + "r" | "n" => -- suurta,suurten + ; + "l" | "h" => -- tuulta,tuulien + ; + _ => -- arpea,arpien,arvissa + + } ; ---- pieni,pientä; uni,unta + in nForms10 + arpi arven arpe.p1 (arpe.p4 + "en" + a) (arpe.p4 + "een") + arpe.p2 (arpi + a) + (arp + "in" + a) (arpe.p3 + "ss" + a) (arp + "iin") ; + + dRae : (_,_ : Str) -> NForms = \rae,rakeen -> + let + a = vowHarmony rae ; + rakee = init rakeen ; + rakei = init rakee + "i" ; + raetta = case of { + _ + "e" => + ; -- raetta,rakeeseen + _ + "s" => + ; -- rengasta,renkaaseen + _ + "t" => + ; -- olutta,olueen + _ + "r" => + ; -- sisarta,sisareen + _ => Predef.error (["expected ending e/t/s/r, found"] ++ rae) + } ; + in nForms10 + rae rakeen raetta.p1 (rakee + "n"+ a) raetta.p2 + (rakei + "den") (rakei + "t" + a) + (rakei + "n" + a) (rakei + "ss" + a) (rakei + "siin") ; ---- sisariin + + dPaatti : (_,_ : Str) -> NForms = \paatti,paatin -> + let + a = vowHarmony paatti ; + paatte = init paatti + "e" ; + paati = init paatin ; + paate = init paati + "e" ; + in nForms10 + paatti paatin (paatti + a) (paatti + "n" + a) (paatti + "in") + (paatti + "en") (paatte + "j" + a) + (paatte + "in" + a) (paate + "iss" + a) (paatte + "ihin") ; + + dTohtori : (_ : Str) -> NForms = \tohtori -> + let + a = vowHarmony tohtori ; + tohtor = init tohtori ; + in nForms10 + tohtori (tohtori+"n") (tohtori + a) (tohtori + "n" + a) (tohtori + "in") + (tohtor + "eiden") (tohtor + "eit" + a) + (tohtor + "ein" + a) (tohtor + "eiss" + a) (tohtor + "eihin") ; + + dPiennar : (_,_ : Str) -> NForms = \piennar,pientaren -> + let + a = vowHarmony piennar ; + pientar = Predef.tk 2 pientaren ; + in nForms10 + piennar pientaren (piennar +"t" + a) + (pientar + "en" + a) (pientar + "een") + (piennar + "ten") (pientar + "i" + a) (pientar + "in" + a) + (pientar + "iss" + a) (pientar + "iin") ; + + dUnix : (_ : Str) -> NForms = \unix -> + let + a = vowHarmony unix ; + unixi = unix + "i" ; + unixe = unix + "e" ; + in nForms10 + unix (unixi + "n") (unixi + a) (unixi + "n" + a) (unixi + "in") + (unixi + "en") (unixe + "j" + a) (unixe + "in" + a) + (unixe + "iss" + a) (unixe + "ihin") ; + + dNukke : (_,_ : Str) -> NForms = \nukke,nuken -> + let + a = vowHarmony nukke ; + nukk = init nukke ; + nuke = init nuken ; + in + nForms10 + nukke nuken (nukke + a) (nukk +"en" + a) (nukk + "een") + (nukk + "ien") (nukk + "ej" + a) (nukk + "ein" + a) + (nuke + "iss" + a) (nukk + "eihin") ; + + dJalas : Str -> NForms = \jalas -> + let + a = vowHarmony jalas ; + jalaks = init jalas + "ks" ; + jalaksi = jalaks + "i" ; + in nForms10 + jalas (jalaks + "en") (jalas + "t" + a) + (jalaks + "en" + a) (jalaks + "een") + (jalas + "ten") (jalaksi + a) + (jalaksi + "n" + a) (jalaksi + "ss" + a) (jalaksi + "in") ; + + dSDP : Str -> NForms = \SDP -> + let + c = case last SDP of { + "A" => + <"n","ta","na","han","iden","ita","ina","issa","ihin"> ; + "B" | "C" | "D" | "E" | "G" | "P" | "T" | "V" | "W" => + <"n","tä","nä","hen","iden","itä","inä","issä","ihin"> ; + "F" | "L" | "M" | "N" | "R" | "S" | "X" => + <"n","ää","nä","ään","ien","iä","inä","issä","iin"> ; + "H" | "K" | "O" | "Å" => + <"n","ta","na","hon","iden","ita","ina","issa","ihin"> ; + "I" | "J" => + <"n","tä","nä","hin","iden","itä","inä","issä","ihin"> ; + "Q" | "U" => + <"n","ta","na","hun","iden","ita","ina","issa","ihin"> ; + "Z" => + <"n","aa","na","aan","ojen","oja","oina","oissa","oihin"> ; + "Ä" => + <"n","tä","nä","hän","iden","itä","inä","issä","ihin"> ; + "Ö" => + <"n","tä","nä","hön","iden","itä","inä","issä","ihin"> ; + _ => Predef.error (["illegal abbreviation"] ++ SDP) + } ; + in nForms10 + SDP (SDP + ":" + c.p1) (SDP + ":" + c.p2) (SDP + ":" + c.p3) + (SDP + ":" + c.p4) (SDP + ":" + c.p5) (SDP + ":" + c.p6) + (SDP + ":" + c.p7) (SDP + ":" + c.p8) (SDP + ":" + c.p9) ; + +-- for adjective comparison + + dSuurempi : Str -> NForms = \suurempi -> + let + a = vowHarmony suurempi ; + suuremp = init suurempi ; + suuremm = Predef.tk 2 suurempi + "m" ; + in nForms10 + suurempi (suuremm + a + "n") (suuremp + a + a) + (suuremp + a + "n" + a) (suuremp + a + a + "n") + (suuremp + "ien") (suurempi + a) + (suurempi + "n" + a) (suuremm + "iss" + a) (suurempi + "in") ; + + dSuurin : Str -> NForms = \suurin -> + let + a = vowHarmony suurin ; + suurimm = init suurin + "mm" ; + suurimp = init suurimm + "p" ; + in nForms10 + suurin (suurimm + a + "n") (suurin + "t" + a) + (suurimp + a + "n" + a) (suurimp + a + a + "n") + (suurimp + "ien") (suurimp + "i" + a) + (suurimp + "in" + a) (suurimm + "iss" + a) (suurimp + "iin") ; + +-- for verb participle forms + + dOttanut : Str -> NForms = \ottanut -> + let + a = vowHarmony ottanut ; + ottane = Predef.tk 2 ottanut + "e" ; + ottanee = ottane + "e" ; + in nForms10 + ottanut (ottanee + "n") (ottanut + "t" + a) + (ottanee + "n" + a) (ottanee + "seen") + (ottane + "iden") (ottane + "it" + a) + (ottane + "in" + a) (ottane + "iss" + a) (ottane + "isiin") ; + +------------------- +-- auxiliaries ---- +------------------- + +-- the maximal set of technical stems + + NForms : Type = Predef.Ints 9 => Str ; + + nForms10 : (x1,_,_,_,_,_,_,_,_,x10 : Str) -> NForms = + \Ukko,ukon,ukkoa,ukkona,ukkoon, + ukkojen,ukkoja,ukkoina,ukoissa,ukkoihin -> table { + 0 => Ukko ; + 1 => ukon ; + 2 => ukkoa ; + 3 => ukkona ; + 4 => ukkoon ; + 5 => ukkojen ; + 6 => ukkoja ; + 7 => ukkoina ; + 8 => ukoissa ; + 9 => ukkoihin + } ; + + Noun = {s : NForm => Str} ; + + nForms2N : NForms -> Noun = \f -> + let + Ukko = f ! 0 ; + ukon = f ! 1 ; + ukkoa = f ! 2 ; + ukkona = f ! 3 ; + ukkoon = f ! 4 ; + ukkojen = f ! 5 ; + ukkoja = f ! 6 ; + ukkoina = f ! 7 ; + ukoissa = f ! 8 ; + ukkoihin = f ! 9 ; + a = last ukkoja ; + uko = init ukon ; + ukko = Predef.tk 2 ukkona ; + ukkoi = Predef.tk 2 ukkoina ; + ukoi = Predef.tk 3 ukoissa ; + in + {s = table { + NCase Sg Nom => Ukko ; + NCase Sg Gen => uko + "n" ; + NCase Sg Part => ukkoa ; + NCase Sg Transl => uko + "ksi" ; + NCase Sg Ess => ukkona ; + NCase Sg Iness => uko + ("ss" + a) ; + NCase Sg Elat => uko + ("st" + a) ; + NCase Sg Illat => ukkoon ; + NCase Sg Adess => uko + ("ll" + a) ; + NCase Sg Ablat => uko + ("lt" + a) ; + NCase Sg Allat => uko + "lle" ; + NCase Sg Abess => uko + ("tt" + a) ; + + NCase Pl Nom => uko + "t" ; + NCase Pl Gen => ukkojen ; + NCase Pl Part => ukkoja ; + NCase Pl Transl => ukoi + "ksi" ; + NCase Pl Ess => ukkoina ; + NCase Pl Iness => ukoissa ; + NCase Pl Elat => ukoi + ("st" + a) ; + NCase Pl Illat => ukkoihin ; + NCase Pl Adess => ukoi + ("ll" + a) ; + NCase Pl Ablat => ukoi + ("lt" + a) ; + NCase Pl Allat => ukoi + "lle" ; + NCase Pl Abess => ukoi + ("tt" + a) ; + + NComit => ukkoi + "ne" ; + NInstruct => ukoi + "n" ; + + NPossNom _ => ukko ; + NPossGen Sg => ukko ; + NPossGen Pl => init ukkojen ; + NPossTransl Sg => uko + "kse" ; + NPossTransl Pl => ukoi + "kse" ; + NPossIllat Sg => init ukkoon ; + NPossIllat Pl => init ukkoihin + } ; + lock_N = <> + } ; + + n2nforms : Noun -> NForms = \ukko -> table { + 0 => ukko.s ! NCase Sg Nom ; + 1 => ukko.s ! NCase Sg Gen ; + 2 => ukko.s ! NCase Sg Part ; + 3 => ukko.s ! NCase Sg Ess ; + 4 => ukko.s ! NCase Sg Illat ; + 5 => ukko.s ! NCase Pl Gen ; + 6 => ukko.s ! NCase Pl Part ; + 7 => ukko.s ! NCase Pl Ess ; + 8 => ukko.s ! NCase Pl Iness ; + 9 => ukko.s ! NCase Pl Illat + } ; + +-- Adjective forms + + AForms : Type = { + posit : NForms ; + compar : NForms ; + superl : NForms ; + adv_posit, adv_compar, adv_superl : Str ; + } ; + + aForms2A : AForms -> Adjective = \afs -> { + s = table { + Posit => table { + AN n => (nForms2N afs.posit).s ! n ; + AAdv => afs.adv_posit + } ; + Compar => table { + AN n => (nForms2N afs.compar).s ! n ; + AAdv => afs.adv_compar + } ; + Superl => table { + AN n => (nForms2N afs.superl).s ! n ; + AAdv => afs.adv_superl + } + } ; + lock_A = <> + } ; + + nforms2aforms : NForms -> AForms = \nforms -> + let + suure = init (nforms ! 1) ; + suur = Predef.tk 4 (nforms ! 8) ; + in { + posit = nforms ; + compar = dSuurempi (suure ++ "mpi") ; + superl = dSuurin (suur ++ "in") ; + adv_posit = suure + "sti" ; + adv_compar = suure + "mmin" ; + adv_superl = suur + "immin" ; + } ; + + + oper + + cHukkua : (_,_ : Str) -> VForms = \hukkua,hukun -> + let + a = last hukkua ; + hukku = init hukkua ; + huku = init hukun ; + u = last huku ; + i = case u of { + "e" | "i" => [] ; + _ => u + } ; + y = uyHarmony a ; + hukkui = init hukku + i + "i" ; + hukui = init huku + i + "i" ; + in vForms12 + hukkua + hukun + (hukku + u) + (hukku + "v" + a + "t") + (hukku + "k" + a + a) + (huku + "t" + a + a + "n") + (hukui + "n") + hukkui + (hukkui + "si") + (hukku + "n" + y + "t") + (huku + "tt" + y) + (hukku + "nee") ; + + cOttaa : (_,_,_,_ : Str) -> VForms = \ottaa,otan,otin,otti -> + let + a = last ottaa ; + aa = a + a ; + u = uyHarmony a ; + ota = init otan ; + otta = init ottaa ; + ote = init ota + "e" ; + in vForms12 + ottaa + otan + ottaa + (otta + "v" + a + "t") + (otta + "k" + aa) + (ote + "t" + aa + "n") + otin + otti + (otta + "isi") + (otta + "n" + u + "t") + (ote + "tt" + u) + (otta + "nee") ; + + cJuosta : (_,_ : Str) -> VForms = \juosta,juoksen -> + let + a = last juosta ; + juos = Predef.tk 2 juosta ; + juoss = juos + last juos ; + juokse = init juoksen ; + juoks = init juokse ; + u = uyHarmony a ; + juoksi = juoks + "i" ; + in vForms12 + juosta + (juoksen) + (juokse + "e") + (juokse + "v" + a + "t") + (juos + "k" + a + a) + (juosta + a + "n") + (juoks + "in") + (juoks + "i") + (juoks + "isi") + (juoss + u + "t") + (juos + "t" + u) + (juoss + "ee") ; + + cJuoda : (_ : Str) -> VForms = \juoda -> + let + a = last juoda ; + juo = Predef.tk 2 juoda ; + joi = case last juo of { + "i" => juo ; -- naida + o => Predef.tk 2 juo + o + "i" + } ; + u = uyHarmony a ; + in vForms12 + juoda + (juo + "n") + (juo) + (juo + "v" + a + "t") + (juo + "k" + a + a) + (juoda + a + "n") + (joi + "n") + (joi) + (joi + "si") + (juo + "n" + u + "t") + (juo + "t" + u) + (juo + "nee") ; + + cPudota : (_,_ : Str) -> VForms = \pudota,putosi -> + let + a = last pudota ; + pudot = init pudota ; + pudo = init pudot ; + ai = case last pudo of { + "a" | "ä" => <[], "i"> ; + _ => + } ; + puto = Predef.tk 2 putosi ; + u = uyHarmony a ; + in vForms12 + pudota + (puto + a + "n") + (puto + ai.p1 + a) + (puto + a + "v" + a + "t") + (pudot + "k" + a + a) + (pudot + a + a + "n") + (puto + "sin") + (puto + "si") + (puto + ai.p2 + "si") + (pudo + "nn" + u + "t") + (pudot + "t" + u) + (pudo + "nnee") ; + + cHarkita : (_ : Str) -> VForms = \harkita -> + let + a = last harkita ; + harkit = init harkita ; + harki = init harkit ; + u = uyHarmony a ; + in vForms12 + harkita + (harkit + "sen") + (harkit + "se") + (harkit + "sev" + a + "t") + (harkit + "k" + a + a) + (harkit + a + a + "n") + (harkit + "sin") + (harkit + "si") + (harkit + "sisi") + (harki + "nn" + u + "t") + (harkit + "t" + u) + (harki + "nnee") ; + + cValjeta : (_,_ : Str) -> VForms = \valjeta,valkeni -> + let + a = last valjeta ; + valjet = init valjeta ; + valken = init valkeni ; + valje = init valjet ; + u = uyHarmony a ; + in vForms12 + valjeta + (valken + "en") + (valken + "ee") + (valken + "ev" + a + "t") + (valjet + "k" + a + a) + (valjet + a + a + "n") + (valken + "in") + (valken + "i") + (valken + "isi") + (valje + "nn" + u + "t") + (valjet + "t" + u) + (valje + "nnee") ; + + cKuunnella : (_,_ : Str) -> VForms = \kuunnella,kuuntelin -> + let + a = last kuunnella ; + kuunnel = Predef.tk 2 kuunnella ; + kuuntel = Predef.tk 2 kuuntelin ; + u = uyHarmony a ; + in vForms12 + kuunnella + (kuuntel + "en") + (kuuntel + "ee") + (kuuntel + "ev" + a + "t") + (kuunnel + "k" + a + a) + (kuunnella + a + "n") + (kuuntel + "in") + (kuuntel + "i") + (kuuntel + "isi") + (kuunnel + "l" + u + "t") + (kuunnel + "t" + u) + (kuunnel + "lee") ; + +-- auxiliaries + + uyHarmony : Str -> Str = \a -> case a of { + "a" => "u" ; + _ => "y" + } ; + + VForms : Type = Predef.Ints 11 => Str ; + + vForms12 : (x1,_,_,_,_,_,_,_,_,_,_,x12 : Str) -> VForms = + \olla,olen,on,ovat,olkaa,ollaan,olin,oli,olisi,ollut,oltu,lienee -> + table { + 0 => olla ; + 1 => olen ; + 2 => on ; + 3 => ovat ; + 4 => olkaa ; + 5 => ollaan ; + 6 => olin ; + 7 => oli ; + 8 => olisi ; + 9 => ollut ; + 10 => oltu ; + 11 => lienee + } ; + + vforms2V : VForms -> Verb = \vh -> + let + tulla = vh ! 0 ; + tulen = vh ! 1 ; + tulee = vh ! 2 ; + tulevat = vh ! 3 ; + tulkaa = vh ! 4 ; + tullaan = vh ! 5 ; + tulin = vh ! 6 ; + tuli = vh ! 7 ; + tulisi = vh ! 8 ; + tullut = vh ! 9 ; + tultu = vh ! 10 ; + tullun = vh ! 11 ; + tule_ = init tulen ; + tuli_ = init tulin ; + a = last tulkaa ; + tulko = Predef.tk 2 tulkaa + (ifTok Str a "a" "o" "ö") ; + tulkoo = tulko + last tulko ; + tullee = Predef.tk 2 tullut + "ee" ; + tulleen = (nForms2N (dOttanut tullut)).s ; + tullu : Str = weakGrade tultu ; + tullun = (nForms2N (dUkko tultu (tullu + "n"))).s ; + tulema = Predef.tk 3 tulevat + "m" + a ; + vat = "v" + a + "t" + in + {s = table { + Inf Inf1 => tulla ; + Presn Sg P1 => tule_ + "n" ; + Presn Sg P2 => tule_ + "t" ; + Presn Sg P3 => tulee ; + Presn Pl P1 => tule_ + "mme" ; + Presn Pl P2 => tule_ + "tte" ; + Presn Pl P3 => tulevat ; + Impf Sg P1 => tuli_ + "n" ; --# notpresent + Impf Sg P2 => tuli_ + "t" ; --# notpresent + Impf Sg P3 => tuli ; --# notpresent + Impf Pl P1 => tuli_ + "mme" ; --# notpresent + Impf Pl P2 => tuli_ + "tte" ; --# notpresent + Impf Pl P3 => tuli + vat ; --# notpresent + Condit Sg P1 => tulisi + "n" ; --# notpresent + Condit Sg P2 => tulisi + "t" ; --# notpresent + Condit Sg P3 => tulisi ; --# notpresent + Condit Pl P1 => tulisi + "mme" ; --# notpresent + Condit Pl P2 => tulisi + "tte" ; --# notpresent + Condit Pl P3 => tulisi + vat ; --# notpresent + Imper Sg => tule_ ; + Imper Pl => tulkaa ; + ImperP3 Sg => tulkoo + "n" ; + ImperP3 Pl => tulkoo + "t" ; + ImperP1Pl => tulkaa + "mme" ; + ImpNegPl => tulko ; + Pass True => tullaan ; + Pass False => Predef.tk 2 tullaan ; + PastPartAct (AN n) => tulleen ! n ; + PastPartAct AAdv => tullee + "sti" ; + PastPartPass (AN n) => tullun ! n ; + PastPartPass AAdv => tullu + "sti" ; + Inf Inf3Iness => tulema + "ss" + a ; + Inf Inf3Elat => tulema + "st" + a ; + Inf Inf3Illat => tulema + a + "n" ; + Inf Inf3Adess => tulema + "ll" + a ; + Inf Inf3Abess => tulema + "tt" + a + } ; + sc = NPCase Nom ; + lock_V = <> + } ; + +----------------------------------------- +-- Auxiliaries +----------------------------------------- + +-- 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"; "vihje - vihjeen" not "vihkeen"). + + weakGrade : Str -> Str = \kukko -> + let + ku = Predef.tk 3 kukko ; + kko = Predef.dp 3 kukko ; + o = last kukko + in + case kko of { + "kk" + _ => ku + "k" + o ; + "pp" + _ => ku + "p" + o ; + "tt" + _ => ku + "t" + o ; + "nk" + _ => ku + "ng" + o ; + "nt" + _ => ku + "nn" + o ; + "mp" + _ => ku + "mm" + o ; + "rt" + _ => ku + "rr" + o ; + "lt" + _ => ku + "ll" + o ; + "lk" + ("i" | "e") => ku + "lj" + o ; + "rk" + ("i" | "e") => ku + "rj" + o ; + "lk" + _ => ku + "l" + o ; + "rk" + _ => ku + "r" + o ; + ("hk" | "tk") + _ => kukko ; -- *tahko-tahon, *pitkä-pitkän + "s" + ("k" | "p" | "t") + _ => kukko ; -- *lasku-lasvun, *raspi-rasvin, *lastu-lasdun + x + "ku" => ku + x + "vu" ; + x + "k" + ("a" | "e" | "i" | "o" | "u" | "y" | "ä" | "ö") => ku + x + o ; + x + "p" + ("a" | "e" | "i" | "o" | "u" | "y" | "ä" | "ö") => ku + x + "v" + o ; + x + "t" + ("a" | "e" | "i" | "o" | "u" | "y" | "ä" | "ö") => ku + x + "d" + o ; + _ => kukko + } ; + +-- This is used to analyse nouns "rae", "hake", "rengas", "laidun", etc. + + strongGrade : Str -> Str = \hanke -> + let + ha = Predef.tk 3 hanke ; + nke = Predef.dp 3 hanke ; + in + ha + case nke of { + "ng" + a => "nk" + a ; + "nn" + e => "nt" + e ; + "mm" + e => "mp" + e ; + "rr" + e => "rt" + e ; + "ll" + a => "lt" + a ; + h@("h" | "l") + "je" + e => h + "ke" ; -- pohje/lahje impossible + ("tk" | "hk" | "sk" | "sp" | "st") + _ => nke ; -- viuhke,kuiske + a + k@("k"|"p"|"t") + e@("e"|"a"|"ä"|"u"|"i"|"o"|"ö") => a + k + k + e ; + a + "d" + e@("e"|"a"|"ä"|"u"|"i"|"o"|"ö") => a + "t" + e ; + s + a@("a" | "ä") + "e" => s + a + "ke" ; -- säe, tae + a + "v" + e@("e"|"a"|"ä"|"u"|"i") => a + "p" + e ; -- taive/toive imposs + ase => ase + } ; + + vowHarmony : Str -> Str = \s -> case s of { + _ + ("a" | "o" | "u") + _ => "a" ; + _ => "ä" + } ; + + getHarmony : Str -> Str = \u -> case u of { + "a"|"o"|"u" => "a" ; + _ => "ä" + } ; + +----------------------- +-- for Structural +----------------------- + +caseTable : Number -> CommonNoun -> Case => Str = \n,cn -> + \\c => cn.s ! NCase n c ; + + mkDet : Number -> CommonNoun -> { + s1 : Case => Str ; -- minun kolme + s2 : Str ; -- -ni + n : Number ; -- Pl (agreement feature for verb) + isNum : Bool ; -- True (a numeral is present) + isPoss : Bool ; -- True (a possessive suffix is present) + isDef : Bool -- True (verb agrees in Pl, Nom is not Part) + } = \n, noun -> { + s1 = \\c => noun.s ! NCase n c ; + s2 = [] ; + n = n ; + isNum, isPoss = False ; + isDef = True --- does this hold for all new dets? + } ; + +-- Here we define personal and relative pronouns. + + mkPronoun : (_,_,_,_,_ : Str) -> Number -> Person -> + {s : NPForm => Str ; a : Agr} = + \mina, minun, minua, minuna, minuun, n, p -> + let { + minu = Predef.tk 2 minuna ; + a = Predef.dp 1 minuna + } in + {s = table { + NPCase Nom => mina ; + NPCase Gen => minun ; + NPCase Part => minua ; + NPCase Transl => minu + "ksi" ; + NPCase Ess => minuna ; + NPCase Iness => minu + ("ss" + a) ; + NPCase Elat => minu + ("st" + a) ; + NPCase Illat => minuun ; + NPCase Adess => minu + ("ll" + a) ; + NPCase Ablat => minu + ("lt" + a) ; + NPCase Allat => minu + "lle" ; + NPCase Abess => minu + ("tt" + a) ; + NPAcc => Predef.tk 1 minun + "t" + } ; + a = {n = n ; p = p} + } ; + + mkDemPronoun : (_,_,_,_,_ : Str) -> Number -> + {s : NPForm => Str ; a : Agr} = + \tuo, tuon, tuota, tuona, tuohon, n -> + let pro = mkPronoun tuo tuon tuota tuona tuohon n P3 + in { + s = table { + NPAcc => tuo ; + c => pro.s ! c + } ; + a = pro.a + } ; + +-- 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". + +oper + relPron : Number => Case => Str = + let {jo = nForms2N (dSuo "jo")} in + table { + Sg => table { + Nom => "joka" ; + Gen => "jonka" ; + c => jo.s ! NCase Sg c + } ; + Pl => table { + Nom => "jotka" ; + c => "j" + (jo.s ! NCase Pl c) + } + } ; + + ProperName = {s : Case => Str} ; + +} diff --git a/lib/resource-1.4/finnish/NounFin.gf b/lib/resource-1.4/finnish/NounFin.gf new file mode 100644 index 000000000..9913d0665 --- /dev/null +++ b/lib/resource-1.4/finnish/NounFin.gf @@ -0,0 +1,165 @@ +concrete NounFin of Noun = CatFin ** open ResFin, Prelude in { + + flags optimize=all_subs ; + + lin + +-- The $Number$ is subtle: "nuo autot", "nuo kolme autoa" are both plural +-- for verb agreement, but the noun form is singular in the latter. + + DetCN det cn = + let + n : Number = case det.isNum of { + True => Sg ; + _ => det.n + } ; + ncase : Case -> NForm = \c -> + case of { + <_, Nom, True,_,_> => NCase Sg Part ; -- kolme kytkintä(ni) + <_, _, True,False,_> => NCase Sg c ; -- kolmeksi kytkimeksi + => NCase Pl Part ; -- kytkimiä + <_, Nom,_,True,_> => NPossNom n ; -- kytkime+ni on/ovat... + <_, Gen,_,True,_> => NPossNom n ; -- kytkime+ni vika + <_, Transl,_,True,_> => NPossTransl n ; -- kytkim(e|i)kse+ni + <_, Illat,_,True,_> => NPossIllat n ; -- kytkim(ee|ii)+ni + + _ => NCase n c -- kytkin, kytkimen,... + } + in { + s = \\c => let k = npform2case n c in + det.s1 ! k ++ cn.s ! ncase k ++ det.s2 ; + a = agrP3 (case det.isDef of { + False => Sg ; -- autoja menee; kolme autoa menee + _ => det.n + }) ; + isPron = False + } ; + + UsePN pn = { + s = \\c => pn.s ! npform2case Sg c ; + a = agrP3 Sg ; + isPron = False + } ; + UsePron p = p ** {isPron = True} ; + + PredetNP pred np = { + s = \\c => pred.s ! np.a.n ! c ++ np.s ! c ; + a = np.a ; + isPron = np.isPron -- kaikki minun - ni + } ; + + PPartNP np v2 = { + s = \\c => np.s ! c ++ v2.s ! PastPartPass (AN (NCase np.a.n Ess)) ; + a = np.a ; + isPron = np.isPron -- minun täällä - ni + } ; + + AdvNP np adv = { + s = \\c => np.s ! c ++ adv.s ; + a = np.a ; + isPron = np.isPron -- minun täällä - ni + } ; +{- + DetSg quant ord = { + s1 = \\c => quant.s1 ! Sg ! c ++ ord.s ! Sg ! c ; + s2 = quant.s2 ; + n = Sg ; + isNum = False ; + isPoss = quant.isPoss ; + isDef = False -- doesn't matter with Sg + } ; +-} + DetQuantOrd quant num ord = { + s1 = \\c => quant.s1 ! num.n ! c ++ num.s ! Sg ! c ++ ord.s ! Pl ! c ; + s2 = quant.s2 ; + n = num.n ; + isNum = num.isNum ; + isPoss = quant.isPoss ; + isDef = quant.isDef + } ; + + PossPron p = { + s1 = \\_,_ => p.s ! NPCase Gen ; + s2 = BIND ++ possSuffix p.a ; + isNum = False ; + isPoss = True ; + isDef = True --- "minun kolme autoani ovat" ; thus "...on" is missing + } ; + + NumSg = {s = \\_,_ => [] ; isNum = False ; n = Sg} ; + NumPl = {s = \\_,_ => [] ; isNum = False ; n = Pl} ; + +----b NumInt n = {s = \\_,_ => n.s ; isNum = True ; n = Pl} ; --DEPREC +----b OrdInt n = {s = \\_,_ => n.s ++ "."} ; + + NumDigits numeral = { + s = \\n,c => numeral.s ! NCard (NCase n c) ; + n = numeral.n ; + isNum = True + } ; + OrdDigits numeral = {s = \\n,c => numeral.s ! NOrd (NCase n c)} ; + + NumNumeral numeral = { + s = \\n,c => numeral.s ! NCard (NCase n c) ; + n = numeral.n ; + isNum = True + } ; + OrdNumeral numeral = {s = \\n,c => numeral.s ! NOrd (NCase n c)} ; + + AdNum adn num = {s = \\n,c => adn.s ++ num.s ! n ! c ; isNum = num.isNum ; n = num.n} ; + + OrdSuperl a = {s = \\n,c => a.s ! Superl ! AN (NCase n c)} ; + + DefArt = { + s1 = \\_,_ => [] ; + s2 = [] ; + isNum,isPoss = False ; + isDef = True -- autot ovat + } ; + + IndefArt = { + s1 = \\_,_ => [] ; -- Nom is Part in Pl: use isDef in DetCN + s2 = [] ; + isNum,isPoss,isDef = False -- autoja on + } ; + +{- + MassDet = { + s1 = \\_,_ => [] ; --- Nom is Part ? + s2 = [] ; + isNum,isPoss,isDef = False + } ; +-} + UseN n = n ; + + UseN2 n = n ; +----b UseN3 n = n ; + +--- If a possessive suffix is added here it goes after the complements... + + ComplN2 f x = { + s = \\nf => appCompl True Pos f.c2 x ++ f.s ! nf + } ; + ComplN3 f x = { + s = \\nf => appCompl True Pos f.c2 x ++ f.s ! nf ; + c2 = f.c3 + } ; + + AdjCN ap cn = { + s = \\nf => ap.s ! True ! AN (n2nform nf) ++ cn.s ! nf + } ; + + RelCN cn rs = {s = \\nf => cn.s ! nf ++ rs.s ! agrP3 (numN nf)} ; + AdvCN cn ad = {s = \\nf => cn.s ! nf ++ ad.s} ; + + SentCN cn sc = {s = \\nf=> cn.s ! nf ++ sc.s} ; + + ApposCN cn np = {s = \\nf=> cn.s ! nf ++ np.s ! NPCase Nom} ; --- luvun x + + oper + numN : NForm -> Number = \nf -> case nf of { + NCase n _ => n ; + _ => Sg --- + } ; + +} diff --git a/lib/resource-1.4/finnish/NumeralFin.gf b/lib/resource-1.4/finnish/NumeralFin.gf new file mode 100644 index 000000000..2103788ac --- /dev/null +++ b/lib/resource-1.4/finnish/NumeralFin.gf @@ -0,0 +1,179 @@ +concrete NumeralFin of Numeral = CatFin ** open Prelude, ParadigmsFin, MorphoFin in { + +-- Notice: possessive forms are not used. They get wrong, since every +-- part is made to agree in them. + +flags optimize = all_subs ; + +lincat + Sub1000000 = {s : CardOrd => Str ; n : MorphoFin.Number} ; + Digit = {s : CardOrd => Str} ; + Sub10, Sub100, Sub1000 = {s : NumPlace => CardOrd => Str ; n : MorphoFin.Number} ; + +lin + num x = x ; + n2 = co + (nhn (mkSubst "a" "kaksi" "kahde" "kahte" "kahta" "kahteen" "kaksi" "kaksi" + "kaksien" "kaksia" "kaksiin")) + (ordN "a" "kahdes") ; --- toinen + n3 = co + (nhn (mkSubst "a" "kolme" "kolme" "kolme" "kolmea" "kolmeen" "kolmi" "kolmi" + "kolmien" "kolmia" "kolmiin")) + (ordN "a" "kolmas") ; + n4 = co (mkN "neljä") (ordN "ä" "neljäs") ; + n5 = co (mkN "viisi" "viiden" "viisiä") (ordN "ä" "viides") ; + n6 = co (mkN "kuusi" "kuuden" "kuusia") (ordN "a" "kuudes") ; + n7 = co + (nhn (mkSubst "ä" "seitsemän" "seitsemä" "seitsemä" "seitsemää" + "seitsemään" "seitsemi" "seitsemi" "seitsemien" "seitsemiä" + "seitsemiin")) + (ordN "ä" "seitsemäs") ; + n8 = co + (nhn (mkSubst "a" "kahdeksan" "kahdeksa" "kahdeksa" "kahdeksaa" + "kahdeksaan" "kahdeksi" "kahdeksi" "kahdeksien" "kahdeksia" + "kahdeksiin")) + (ordN "a" "kahdeksas") ; + n9 = co + (nhn (mkSubst "ä" "yhdeksän" "yhdeksä" "yhdeksä" "yhdeksää" + "yhdeksään" "yhdeksi" "yhdeksi" "yhdeksien" "yhdeksiä" "yhdeksiin")) + (ordN "ä" "yhdeksäs") ; + + pot01 = + {s = table { + NumAttr => \\_ => [] ; + NumIndep => yksiN.s + } ; + n = Sg + } ; + pot0 d = {n = Pl ; s = \\_ => d.s} ; + pot110 = + {s = \\_ => kymmenenN.s ; + n = Pl + } ; + + pot111 = {n = Pl ; s = \\_,c => yksiN.s ! c ++"toista"} ; ---- yhdes + pot1to19 d = {n = Pl ; s = \\_,c => d.s ! c ++"toista"} ; + pot0as1 n = n ; + + pot1 d = {n = Pl ; s = \\_,c => d.s ! c ++ kymmentaN.s ! c} ; + pot1plus d e = { + n = Pl ; + s = \\_,c => d.s ! c ++ kymmentaN.s ! c ++ e.s ! NumIndep ! c + } ; + pot1as2 n = n ; + pot2 d = {n = Pl ; s = \\_,c => d.s ! NumAttr ! c ++ sataaN.s ! d.n ! c} ; ---- + pot2plus d e = { + n = Pl ; + s = \\_,c => d.s ! NumAttr ! c ++ sataaN.s ! d.n ! c ++ e.s ! NumIndep ! c + } ; + pot2as3 n = {n = n.n ; s = n.s ! NumIndep} ; + pot3 d = {n = Pl ; s = \\c => d.s ! NumAttr ! c ++ tuhattaN.s ! d.n ! c} ; ---- + pot3plus d e = { + n = Pl ; + s = \\c => d.s ! NumAttr ! c ++ tuhattaN.s ! d.n ! c ++ e.s ! NumIndep ! c + } ; + +oper + co : (c,o : {s : NForm => Str}) -> {s : CardOrd => Str} = \c,o -> { + s = table { + NCard nf => c.s ! nf ; + NOrd nf => o.s ! nf + } + } ; + +-- Too much trouble to infer vowel, cf. "kuudes" vs. "viides". + + ordN : Str -> Str -> {s : NForm => Str} = \a,sadas -> + let + sada = init sadas + in + mkN + sadas (sada + "nnen") (sada + "nten" + a) (sada + "tt" + a) (sada + "nteen") + (sada + "nsin" + a) (sada + "nsiss" + a) (sada + "nsien") + (sada + "nsi" + a) (sada + "nsiin") ; + +param + NumPlace = NumIndep | NumAttr ; + +oper + yksiN = co + (nhn (mkSubst "ä" "yksi" "yhde" "yhte" "yhtä" "yhteen" "yksi" "yksi" + "yksien" "yksiä" "yksiin")) + (ordN "ä" "yhdes") ; ---- ensimmäinen + kymmenenN = co + (nhn (mkSubst "ä" "kymmenen" "kymmene" "kymmene" "kymmentä" + "kymmeneen" "kymmeni" "kymmeni" "kymmenien" "kymmeniä" "kymmeniin")) + (ordN "ä" "kymmenes") ; + sataN = co + (mkN "sata") + (ordN "a" "sadas") ; + + tuhatN = co + (mkN "tuhat" "tuhannen" "tuhatta" "ruhantena" "tuhanteen" + "tuhansien" "tuhansia" "tuhansina" "tuhansissa" "tuhansiin") + (ordN "a" "tuhannes") ; + + kymmentaN = + {s = table { + NCard (NCase Sg Nom) => "kymmentä" ; + k => kymmenenN.s ! k + } + } ; + + sataaN : {s : MorphoFin.Number => CardOrd => Str} = {s = table { + Sg => sataN.s ; + Pl => table { + NCard (NCase Sg Nom) => "sataa" ; + k => sataN.s ! k + } + } + } ; + + tuhattaN = {s = table { + Sg => tuhatN.s ; + Pl => table { + NCard (NCase Sg Nom) => "tuhatta" ; + k => tuhatN.s ! k + } + } + } ; + + + lincat + Dig = TDigit ; + + lin + IDig d = d ; + + IIDig d i = { + s = \\o => d.s ! NCard (NCase Sg Nom) ++ i.s ! o ; + n = Pl + } ; + + D_0 = mkDig "0" ; + D_1 = mk3Dig "1" "1." MorphoFin.Sg ; + D_2 = mkDig "2" ; + D_3 = mkDig "3" ; + D_4 = mkDig "4" ; + D_5 = mkDig "5" ; + D_6 = mkDig "6" ; + D_7 = mkDig "7" ; + D_8 = mkDig "8" ; + D_9 = mkDig "9" ; + + oper + mk2Dig : Str -> Str -> TDigit = \c,o -> mk3Dig c o MorphoFin.Pl ; + mkDig : Str -> TDigit = \c -> mk2Dig c (c + ".") ; + + mk3Dig : Str -> Str -> MorphoFin.Number -> TDigit = \c,o,n -> { + s = table {NCard _ => c ; NOrd _ => o} ; + n = n + } ; + + TDigit = { + n : MorphoFin.Number ; + s : CardOrd => Str + } ; + +} + diff --git a/lib/resource-1.4/finnish/ParadigmsFin.gf b/lib/resource-1.4/finnish/ParadigmsFin.gf new file mode 100644 index 000000000..bb9b2fb6b --- /dev/null +++ b/lib/resource-1.4/finnish/ParadigmsFin.gf @@ -0,0 +1,585 @@ +--# -path=.:../abstract:../common:../../prelude + +--1 Finnish Lexical Paradigms +-- +-- Aarne Ranta 2003--2008 +-- +-- This is an API to the user of the resource grammar +-- for adding lexical items. It gives functions for forming +-- expressions of open categories: nouns, adjectives, verbs. +-- +-- Closed categories (determiners, pronouns, conjunctions) are +-- accessed through the resource syntax API and $Structural.gf$. +-- +-- The main difference with $MorphoFin.gf$ is that the types +-- referred to are compiled resource grammar types. We have moreover +-- had the design principle of always having existing forms, rather +-- than stems, as string arguments of the paradigms. +-- +-- The structure of functions for each word class $C$ is the following: +-- there is a polymorphic constructor $mkC$, which takes one or +-- a few arguments. In Finnish, one argument is enough in 80-90% of +-- cases in average. + +resource ParadigmsFin = open + (Predef=Predef), + Prelude, + MorphoFin, + CatFin + in { + + flags optimize=noexpand ; + +--2 Parameters +-- +-- To abstract over gender, number, and (some) case names, +-- we define the following identifiers. The application programmer +-- should always use these constants instead of the constructors +-- defined in $ResFin$. + +oper + Number : Type ; + + singular : Number ; + plural : Number ; + + Case : Type ; + nominative : Case ; + genitive : Case ; + partitive : Case ; + translative : Case ; + inessive : Case ; + elative : Case ; + illative : Case ; + adessive : Case ; + ablative : Case ; + allative : Case ; + +-- The following type is used for defining *rection*, i.e. complements +-- of many-place verbs and adjective. A complement can be defined by +-- just a case, or a pre/postposition and a case. + + prePrep : Case -> Str -> Prep ; -- ilman, partitive + postPrep : Case -> Str -> Prep ; -- takana, genitive + postGenPrep : Str -> Prep ; -- takana + casePrep : Case -> Prep ; -- adessive + +--2 Nouns + +-- The worst case gives ten forms. +-- In practice just a couple of forms are needed to define the different +-- stems, vowel alternation, and vowel harmony. + +oper + +-- The regular noun heuristic takes just one form (singular +-- nominative) and analyses it to pick the correct paradigm. +-- It does automatic grade alternation, and is hence not usable +-- for words like "auto" (whose genitive would become "audon"). +-- +-- If the one-argument paradigm does not give the correct result, one can try and give +-- two or three forms. Most notably, the two-argument variant is used +-- for nouns like "kivi - kiviä", which would otherwise become like +-- "rivi - rivejä". Three arguments are used e.g. for +-- "auto - auton - autoja", which would otherwise become +-- "auto - audon". + + mkN : overload { + mkN : (talo : Str) -> N ; + mkN : (savi,savia : Str) -> N ; + mkN : (vesi,veden,vesiä : Str) -> N ; + mkN : (vesi,veden,vesiä,vettä : Str) -> N ; + mkN : (olo,olon,olona,oloa,oloon,olojen,oloja,oloina,oloissa,oloihin : Str) -> N ; + mkN : (pika : Str) -> (juna : N) -> N ; + mkN : (oma : N) -> (tunto : N) -> N ; + } ; + +-- Nouns used as functions need a case, of which the default is +-- the genitive. + + mkN2 : overload { + mkN2 : N -> N2 ; + mkN2 : N -> Prep -> N2 + } ; + + mkN3 : N -> Prep -> Prep -> N3 ; + +-- Proper names can be formed by using declensions for nouns. +-- The plural forms are filtered away by the compiler. + + mkPN : overload { + mkPN : Str -> PN ; + mkPN : N -> PN + } ; + +--2 Adjectives + +-- Non-comparison one-place adjectives are just like nouns. +-- The regular adjectives are based on $regN$ in the positive. +-- 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ä"). + + mkA : overload { + mkA : Str -> A ; + mkA : N -> A ; + mkA : N -> (kivempaa,kivinta : Str) -> A ; + mkA : (hyva,parempi,paras : N) -> (hyvin,paremmin,parhaiten : Str) -> A ; + } ; + +-- Two-place adjectives need a case for the second argument. + + mkA2 : A -> Prep -> A2 = \a,p -> a ** {c2 = p ; lock_A2 = <>}; + + + +--2 Verbs +-- +-- The grammar does not cover the potential mood and some nominal +-- forms. One way to see the coverage is to linearize a verb to +-- a table. +-- The worst case needs twelve forms, as shown in the following. + + mkV : overload { + mkV : (huutaa : Str) -> V ; + mkV : (huutaa,huusi : Str) -> V ; + mkV : (huutaa,huudan,huusi : Str) -> V ; + mkV : ( + huutaa,huudan,huutaa,huutavat,huutakaa,huudetaan, + huusin,huusi,huusisi,huutanut,huudettu,huutanee : Str) -> V ; + } ; + +-- All the patterns above have $nominative$ as subject case. +-- If another case is wanted, use the following. + + caseV : Case -> V -> V ; + +-- The verbs "be" is special. + + vOlla : V ; + + +--3 Two-place verbs +-- +-- Two-place verbs need an object case, and can have a pre- or postposition. +-- The default is direct (accusative) object. There is also a special case +-- with case only. The string-only argument case yields a regular verb with +-- accusative object. + + mkV2 : overload { + mkV2 : Str -> V2 ; + mkV2 : V -> V2 ; + mkV2 : V -> Case -> V2 ; + mkV2 : V -> Prep -> V2 ; + } ; + + +--3 Three-place verbs +-- +-- Three-place (ditransitive) verbs need two prepositions, of which +-- the first one or both can be absent. + + mkV3 : V -> Prep -> Prep -> V3 ; -- puhua, allative, elative + dirV3 : V -> Case -> V3 ; -- siirtää, (accusative), illative + dirdirV3 : V -> V3 ; -- antaa, (accusative), (allative) + + +--3 Other complement patterns +-- +-- Verbs and adjectives can take complements such as sentences, +-- questions, verb phrases, and adjectives. + + mkV0 : V -> V0 ; + mkVS : V -> VS ; + mkV2S : V -> Prep -> V2S ; + mkVV : V -> VV ; + mkV2V : V -> Prep -> V2V ; + mkVA : V -> Prep -> VA ; + mkV2A : V -> Prep -> Prep -> V2A ; + mkVQ : V -> VQ ; + mkV2Q : V -> Prep -> V2Q ; + + mkAS : A -> AS ; + mkA2S : A -> Prep -> A2S ; + mkAV : A -> AV ; + mkA2V : A -> Prep -> A2V ; + +-- Notice: categories $AS, A2S, AV, A2V$ are just $A$, +-- and the second argument is given +-- as an adverb. Likewise +-- $V0$ is just $V$. + + V0 : Type ; + AS, A2S, AV, A2V : Type ; + +--. +-- The definitions should not bother the user of the API. So they are +-- hidden from the document. + + Case = MorphoFin.Case ; + Number = MorphoFin.Number ; + + singular = Sg ; + plural = Pl ; + + nominative = Nom ; + genitive = Gen ; + partitive = Part ; + translative = Transl ; + inessive = Iness ; + elative = Elat ; + illative = Illat ; + adessive = Adess ; + ablative = Ablat ; + allative = Allat ; + + prePrep : Case -> Str -> Prep = + \c,p -> {c = NPCase c ; s = p ; isPre = True ; lock_Prep = <>} ; + postPrep : Case -> Str -> Prep = + \c,p -> {c = NPCase c ; s = p ; isPre = False ; lock_Prep = <>} ; + postGenPrep p = { + c = NPCase genitive ; s = p ; isPre = False ; lock_Prep = <>} ; + casePrep : Case -> Prep = + \c -> {c = NPCase c ; s = [] ; isPre = True ; lock_Prep = <>} ; + accPrep = {c = NPAcc ; s = [] ; isPre = True ; lock_Prep = <>} ; + + mkN = overload { + mkN : (talo : Str) -> N = mk1N ; + -- \s -> nForms2N (nForms1 s) ; + mkN : (talo,talon : Str) -> N = mk2N ; + -- \s,t -> nForms2N (nForms2 s t) ; + mkN : (talo,talon,taloja : Str) -> N = mk3N ; + -- \s,t,u -> nForms2N (nForms3 s t u) ; + mkN : (talo,talon,taloja,taloa : Str) -> N = mk4N ; + -- \s,t,u,v -> nForms2N (nForms4 s t u v) ; + mkN : + (talo,talon,taloa,talona,taloon,talojen,taloja,taloina,taloissa,taloihin + : Str) -> N = mk10N ; + mkN : (sora : Str) -> (tie : N) -> N = mkStrN ; + mkN : (oma,tunto : N) -> N = mkNN ; + } ; + + mk1A : Str -> A = \jalo -> aForms2A (nforms2aforms (nForms1 jalo)) ; + mkNA : N -> A = \suuri -> aForms2A (nforms2aforms (n2nforms suuri)) ; + + mk1N : (talo : Str) -> N = \s -> nForms2N (nForms1 s) ; + mk2N : (talo,talon : Str) -> N = \s,t -> nForms2N (nForms2 s t) ; + mk3N : (talo,talon,taloja : Str) -> N = \s,t,u -> nForms2N (nForms3 s t u) ; + mk4N : (talo,talon,taloa,taloja : Str) -> N = \s,t,u,v -> + nForms2N (nForms4 s t u v) ; + mk10N : + (talo,talon,taloa,talona,taloon,talojen,taloja,taloina,taloissa,taloihin + : Str) -> N = \a,b,c,d,e,f,g,h,i,j -> + nForms2N (nForms10 a b c d e f g h i j) ; + + mkStrN : Str -> N -> N = \sora,tie -> { + s = \\c => sora + tie.s ! c ; lock_N = <> + } ; + mkNN : N -> N -> N = \oma,tunto -> { + s = \\c => oma.s ! c + tunto.s ! c ; lock_N = <> + } ; ---- TODO: oma in possessive suffix forms + + nForms1 : Str -> NForms = \ukko -> + let + ukk = init ukko ; + uko = weakGrade ukko ; + ukon = uko + "n" ; + o = case last ukko of {"ä" => "ö" ; "a" => "o"} ; -- only used then + renka = strongGrade (init ukko) ; + rake = strongGrade ukko ; + in + case ukko of { + _ + "nen" => dNainen ukko ; + _ + ("aa" | "ee" | "ii" | "oo" | "uu" | "yy" |"ää"|"öö") => dPuu ukko ; + _ + ("ai" | "ei" | "oi" | "ui" | "yi" | "äi" | "öi") => dPuu ukko ; + _ + ("ie" | "uo" | "yö") => dSuo ukko ; + _ + ("ea" | "eä") => dKorkea ukko ; + _ + "is" => dKaunis ukko ; + _ + ("i" | "u") + "n" => dLiitin ukko (renka + "men") ; + _ + ("ton" | "tön") => dOnneton ukko ; + _ + "e" => dRae ukko (rake + "en") ; + _ + ("ut" | "yt") => dOttanut ukko ; + _ + ("as" | "äs") => dRae ukko (renka + last renka + "n") ; + _ + ("uus" | "yys" | "eus" | "eys") => dLujuus ukko ; + _ + "s" => dJalas ukko ; + +{- heuristics for 3-syllable nouns ending a/ä + _ + ("a" | "e" | "i" | "o" | "u" | "y" | "ä" | "ö") + ? + + _ + "i" + ? + a@("a" | "ä") => + dSilakka ukko (ukko + "n") (ukk + o + "it" + a) ; + _ + ("a" | "e" | "i" | "o" | "u" | "y" | "ä" | "ö") + ? + _ + + ("a" | "e" | "o" | "u" | "y" | "ä" | "ö") + + ("l" | "r" | "n") + a@("a" | "ä") => + dSilakka ukko (ukko + "n") (ukk + o + "it" + a) ; + _ + ("a" | "e" | "i" | "o" | "u" | "y" | "ä" | "ö") + ? + _ + + ("a" | "e" | "i" | "o" | "u" | "y" | "ä" | "ö") + + ("n" | "k" | "s") + "k" + a@("a" | "ä") => + dSilakka ukko (uko + "n") (init uko + o + "it" + a) ; + _ + ("a" | "e" | "i" | "o" | "u" | "y" | "ä" | "ö") + ? + _ + + ("a" | "e" | "i" | "o" | "u" | "y" | "ä" | "ö") + + ("n" | "t" | "s") + "t" + a@("a" | "ä") => + dSilakka ukko (uko + "n") (ukk + o + "j" + a) ; + _ + ("a" | "e" | "i" | "o" | "u") + ? + _ + + ("a" | "e" | "o" | "u") + ? + "a" => + dSilakka ukko (ukko + "n") (ukk + "ia") ; +-} + _ + "i" +o@("o"|"ö") => dSilakka ukko (ukko+"n") (ukko+"it"+getHarmony o); + _ + "i" + "a" => dSilakka ukko (ukko + "n") (ukk + "oita") ; + _ + "i" + "ä" => dSilakka ukko (ukko + "n") (ukk + "öitä") ; + _ + ("a" | "o" | "u" | "y" | "ä" | "ö") => dUkko ukko ukon ; + _ + "i" => dPaatti ukko ukon ; + _ + ("ar" | "är") => dPiennar ukko (renka + "ren") ; + _ + "e" + ("l" | "n") => dPiennar ukko (ukko + "en") ; + _ => dUnix ukko + } ; + + + nForms2 : (_,_ : Str) -> NForms = \ukko,ukkoja -> + let + ukot = nForms1 ukko ; + ukon = weakGrade ukko + "n" ; + in + case of { + <_ + "ea", _ + "oita"> => + dSilakka ukko ukon ukkoja ; -- idea, but not korkea + <_ + ("aa" | "ee" | "ii" | "oo" | "uu" | "yy" | "ää" | "öö" | + "ie" | "uo" | "yö" | "ea" | "eä" | + "ia" | "iä" | "io" | "iö"), _ + ("a" | "ä")> => + nForms1 ukko ; --- to protect --- how to get "dioja"? + <_ + ("a" | "ä" | "o" | "ö"), _ + ("a" | "ä")> => + dSilakka ukko ukon ukkoja ; + => + dArpi ukko (init (weakGrade ukko) + "en") ; + <_ + "i", _ + ("eita" | "eitä")> => + dTohtori ukko ; + <_ + ("ut" | "yt"),_ + ("uita" | "yitä")> => dRae ukko (init ukko + "en") ; + <_ + "e", nuk + ("eja" | "ejä")> => + dNukke ukko ukon ; + <_, _ + ":" + _ + ("a" | "ä")> => dSDP ukko ; + <_ + ("l" | "n" | "r" | "s"), _ + ("eja" | "ejä")> => dUnix ukko ; + <_, _ + ("a" | "ä")> => ukot ; + _ => + Predef.error + (["last argument should end in a/ä, not"] ++ ukkoja) + } ; + + nForms3 : (_,_,_ : Str) -> NForms = \ukko,ukon,ukkoja -> + let + ukk = init ukko ; + ukot = nForms2 ukko ukkoja ; + in + case of { + <_ + ("aa" | "ee" | "ii" | "oo" | "uu" | "yy" | "ää" | "öö" | + "ie" | "uo" | "yö" | "ea" | "eä" | + "ia" | "iä" | "io" | "iö" | "ja" | "jä"), _ + "n"> => + ukot ; --- to protect + <_ + ("a" | "o" | "u" | "y" | "ä" | "ö"), _ + "n"> => + dSilakka ukko ukon ukkoja ; -- auto,auton + <_ + "mpi", _ + ("emman" | "emmän")> => dSuurempi ukko ; + <_ + "in", _ + ("imman" | "immän")> => dSuurin ukko ; + => + dRae ukko ukon ; + => + dRae ukko ukon ; + => dRae ukko ukon ; + => dArpi ukko ukon ; + <_ + ("us" | "ys"), _ + "den"> => dLujuus ukko ; + <_, _ + ":n"> => dSDP ukko ; + <_, _ + "n"> => ukot ; + _ => + Predef.error (["second argument should end in n, not"] ++ ukon) + } ; + + nForms4 : (_,_,_,_ : Str) -> NForms = \ukko,ukon,ukkoja,ukkoa -> + let + ukot = nForms3 ukko ukon ukkoja ; + in + case of { + <_,_ + "n", _ + ("a" | "ä"), _ + ("a" | "ä")> => + table { + 2 => ukkoa ; + n => ukot ! n + } ; + _ => + Predef.error + (["last arguments should end in n, a/ä, and a/ä, not"] ++ + ukon ++ ukkoja ++ ukkoa) + } ; + + mkN2 = overload { + mkN2 : N -> N2 = \n -> mmkN2 n (casePrep genitive) ; + mkN2 : N -> Prep -> N2 = mmkN2 + } ; + + mmkN2 : N -> Prep -> N2 = \n,c -> n ** {c2 = c ; lock_N2 = <>} ; + mkN3 = \n,c,e -> n ** {c2 = c ; c3 = e ; lock_N3 = <>} ; + + mkPN = overload { + mkPN : Str -> PN = mkPN_1 ; + mkPN : N -> PN = \s -> {s = \\c => s.s ! NCase Sg c ; lock_PN = <>} ; + } ; + + mkPN_1 : Str -> PN = \s -> {s = \\c => (mk1N s).s ! NCase Sg c ; lock_PN = <>} ; + +-- adjectives + + mkA = overload { + mkA : Str -> A = mkA_1 ; + mkA : N -> A = \n -> noun2adjDeg n ** {lock_A = <>} ; + mkA : N -> (kivempaa,kivinta : Str) -> A = regAdjective ; +-- mkA : (hyva,parempi,paras : N) -> (hyvin,paremmin,parhaiten : Str) -> A ; + } ; + + mkA_1 : Str -> A = \x -> noun2adjDeg (mk1N x) ** {lock_A = <>} ; + +-- auxiliaries + mkAdjective : (_,_,_ : Adj) -> A = \hyva,parempi,paras -> + {s = table { + Posit => hyva.s ; + Compar => parempi.s ; + Superl => paras.s + } ; + lock_A = <> + } ; + regAdjective : Noun -> Str -> Str -> A = \kiva, kivempi, kivin -> + mkAdjective + (noun2adj kiva) + (noun2adjComp False (nForms2N (dSuurempi kivempi))) + (noun2adjComp False (nForms2N (dSuurin kivin))) ; + noun2adjDeg : Noun -> Adjective = \suuri -> + regAdjective + suuri + (init (suuri.s ! NCase Sg Gen) + "mpi") ---- to check + (suuri.s ! NInstruct) ; ---- + + + + +-- verbs + + mkV = overload { + mkV : (huutaa : Str) -> V = mk1V ; + mkV : (huutaa,huusi : Str) -> V = mk2V ; + mkV : (huutaa,huudan,huusi : Str) -> V = mk3V ; + mkV : ( + huutaa,huudan,huutaa,huutavat,huutakaa,huudetaan, + huusin,huusi,huusisi,huutanut,huudettu,huutanee : Str) -> V = mk12V ; + } ; + + mk1V : Str -> V = \s -> vforms2V (vForms1 s) ** {sc = NPCase Nom ; lock_V = <>} ; + mk2V : (_,_ : Str) -> V = \x,y -> vforms2V (vForms2 x y) ** {sc = NPCase Nom ; lock_V = <>} ; + mk3V : (huutaa,huudan,huusi : Str) -> V = \x,_,y -> mk2V x y ; ---- + mk12V : ( + huutaa,huudan,huutaa,huutavat,huutakaa,huudetaan, + huusin,huusi,huusisi,huutanut,huudettu,huutanee : Str) -> V = + \a,b,c,d,e,f,g,h,i,j,k,l -> + vforms2V (vForms12 a b c d e f g h i j k l) ** {sc = NPCase Nom ; lock_V = <>} ; + + vForms1 : Str -> VForms = \ottaa -> + let + a = last ottaa ; + otta = init ottaa ; + ott = init otta ; + ots = init ott + "s" ; + ota = weakGrade otta ; + otin = init (strongGrade (init ott)) + "elin" ; + ot = init ota ; + in + case ottaa of { + _ + ("e" | "i" | "o" | "u" | "y" | "ö") + ("a" | "ä") => + cHukkua ottaa (ota + "n") ; + _ + ("l" | "n" | "r") + ("taa" | "tää") => + cOttaa ottaa (ota + "n") (ots + "in") (ots + "i") ; + ("" | ?) + ("a" | "e" | "i" | "o" | "u") + ? + _ + + ("a" | "e" | "i" | "o" | "u") + _ + "aa" => + cOttaa ottaa (ota + "n") (ot + "in") (ott + "i") ; + ("" | ?) + ("a" | "e" | "i") + _ + "aa" => + cOttaa ottaa (ota + "n") (ot + "oin") (ott + "oi") ; + _ + ("aa" | "ää") => + cOttaa ottaa (ota + "n") (ot + "in") (ott + "i") ; + _ + ("ella" | "ellä") => + cKuunnella ottaa otin ; + _ + ("osta" | "östä") => + cJuosta ottaa (init ott + "ksen") ; + _ + ("st" | "nn" | "ll" | "rr") + ("a" | "ä") => + cJuosta ottaa (ott + "en") ; + _ + ("ita" | "itä") => + cHarkita ottaa ; + _ + ("eta" | "etä" | "ota" | "ata" | "uta" | "ytä" | "ätä" | "ötä") => + cPudota ottaa (strongGrade ott + "si") ; + _ + ("da" | "dä") => + cJuoda ottaa ; + _ => Predef.error (["expected infinitive, found"] ++ ottaa) + } ; + + vForms2 : (_,_ : Str) -> VForms = \huutaa,huusi -> + let + huuda = weakGrade (init huutaa) ; + huusin = weakGrade huusi + "n" ; + autoin = weakGrade (init huusi) + "in" ; + in + case of { + <_ + ("taa" | "tää"), _ + ("oi" | "öi")> => + cOttaa huutaa (huuda + "n") autoin huusi ; + <_ + ("aa" | "ää"), _ + "i"> => + cOttaa huutaa (huuda + "n") huusin huusi ; + <_ + ("eta" | "etä"), _ + "eni"> => + cValjeta huutaa huusi ; + <_ + ("sta" | "stä"), _ + "si"> => + vForms1 huutaa ; -- pestä, halkaista + <_ + ("ta" | "tä"), _ + "si"> => + cPudota huutaa huusi ; + <_ + ("lla" | "llä"), _ + "li"> => + cKuunnella huutaa huusin ; + _ => vForms1 huutaa + } ; + + + + caseV c v = {s = v.s ; sc = NPCase c ; lock_V = <>} ; + + vOlla = verbOlla ** {sc = NPCase Nom ; lock_V = <>} ; + + mk2V2 : V -> Prep -> V2 = \v,c -> v ** {c2 = c ; lock_V2 = <>} ; + caseV2 : V -> Case -> V2 = \v,c -> mk2V2 v (casePrep c) ; + dirV2 v = mk2V2 v accPrep ; + + mkAdv : Str -> Adv = \s -> {s = s ; lock_Adv = <>} ; + + mkV2 = overload { + mkV2 : Str -> V2 = \s -> dirV2 (mk1V s) ; + mkV2 : V -> V2 = dirV2 ; + mkV2 : V -> Case -> V2 = caseV2 ; + mkV2 : V -> Prep -> V2 = mk2V2 ; + } ; + + mk2V2 : V -> Prep -> V2 ; + caseV2 : V -> Case -> V2 ; + dirV2 : V -> V2 ; + + mkV3 v p q = v ** {c2 = p ; c3 = q ; lock_V3 = <>} ; + dirV3 v p = mkV3 v accPrep (casePrep p) ; + dirdirV3 v = dirV3 v allative ; + + mkVS v = v ** {lock_VS = <>} ; + mkVV v = v ** {lock_VV = <>} ; + mkVQ v = v ** {lock_VQ = <>} ; + + V0 : Type = V ; + AS, A2S, AV : Type = A ; + A2V : Type = A2 ; + + mkV0 v = v ** {lock_V = <>} ; + mkV2S v p = mk2V2 v p ** {lock_V2S = <>} ; + mkV2V v p = mk2V2 v p ** {lock_V2V = <>} ; + mkVA v p = v ** {c2 = p ; lock_VA = <>} ; + mkV2A v p q = v ** {c2 = p ; c3 = q ; lock_V2A = <>} ; + mkV2Q v p = mk2V2 v p ** {lock_V2Q = <>} ; + + mkAS v = v ** {lock_A = <>} ; + mkA2S v p = mkA2 v p ** {lock_A = <>} ; + mkAV v = v ** {lock_A = <>} ; + mkA2V v p = mkA2 v p ** {lock_A2 = <>} ; + +} ; diff --git a/lib/resource-1.4/finnish/PhraseFin.gf b/lib/resource-1.4/finnish/PhraseFin.gf new file mode 100644 index 000000000..48bbc7a11 --- /dev/null +++ b/lib/resource-1.4/finnish/PhraseFin.gf @@ -0,0 +1,24 @@ +concrete PhraseFin of Phrase = CatFin ** open ResFin in { + + lin + PhrUtt pconj utt voc = {s = pconj.s ++ utt.s ++ voc.s} ; + + UttS s = s ; + UttQS qs = {s = qs.s} ; + UttImpSg pol imp = {s = pol.s ++ imp.s ! pol.p ! Sg} ; + UttImpPl pol imp = {s = pol.s ++ imp.s ! pol.p ! Pl} ; + UttImpPol pol imp = {s = pol.s ++ imp.s ! pol.p ! Pl} ; + + UttIP ip = {s = ip.s ! NPCase Nom} ; + UttIAdv iadv = iadv ; + UttNP np = {s = np.s ! NPCase Nom} ; + UttVP vp = {s = infVP (NPCase Nom) Pos (agrP3 Sg) vp} ; + UttAdv adv = adv ; + + NoPConj = {s = []} ; + PConjConj conj = {s = conj.s2} ; + + NoVoc = {s = []} ; + VocNP np = {s = "," ++ np.s ! NPCase Nom} ; + +} diff --git a/lib/resource-1.4/finnish/QuestionFin.gf b/lib/resource-1.4/finnish/QuestionFin.gf new file mode 100644 index 000000000..5ae7a62b2 --- /dev/null +++ b/lib/resource-1.4/finnish/QuestionFin.gf @@ -0,0 +1,69 @@ +concrete QuestionFin of Question = CatFin ** open ResFin, Prelude in { + + flags optimize=all_subs ; + + lin + + QuestCl cl = { + s = \\t,a,p => cl.s ! t ! a ! p ! SQuest + } ; + + QuestVP ip vp = + let + cl = mkClause (subjForm (ip ** {isPron = False ; a = agrP3 ip.n}) vp.sc) (agrP3 ip.n) vp + in { + s = \\t,a,p => cl.s ! t ! a ! p ! SDecl + } ; + + QuestSlash ip slash = { + s = \\t,a,p => + let + cls = slash.s ! t ! a ! p ; + who = appCompl True p slash.c2 (ip ** {a = agrP3 ip.n ; isPron = False}) + in + who ++ cls + } ; + + QuestIAdv iadv cl = { + s = \\t,a,p => iadv.s ++ cl.s ! t ! a ! p ! SDecl + } ; + + QuestIComp icomp np = { + s = \\t,a,p => + let + vp = predV (verbOlla ** {sc = NPCase Nom}) ; + cl = mkClause (subjForm np vp.sc) np.a vp ; + in + icomp.s ! np.a ++ cl.s ! t ! a ! p ! SDecl + } ; + + PrepIP p ip = {s = + appCompl True Pos p (ip ** {a = agrP3 ip.n ; isPron = False})} ; + + AdvIP ip adv = { + s = \\c => ip.s ! c ++ adv.s ; + n = ip.n + } ; + +-- The computation of $ncase$ is a special case of that in $NounFin.DetCN$, +-- since we don't have possessive suffixes or definiteness. +--- It could still be nice to have a common oper... + +{- + IDetCN idet num ord cn = let n = idet.n in { + s = \\c => + let + k = npform2case n c ; + ncase = case of { + => NCase Sg Part ; -- mitkä kolme kytkintä + <_, True> => NCase Sg k ; -- miksi kolmeksi kytkimeksi + _ => NCase n k -- mitkä kytkimet + } + in + idet.s ! k ++ num.s ! Sg ! k ++ ord.s ! n ! k ++ cn.s ! ncase ; + n = n + } ; +-} + CompIAdv a = {s = \\_ => a.s} ; + +} diff --git a/lib/resource-1.4/finnish/RelativeFin.gf b/lib/resource-1.4/finnish/RelativeFin.gf new file mode 100644 index 000000000..9aab4e869 --- /dev/null +++ b/lib/resource-1.4/finnish/RelativeFin.gf @@ -0,0 +1,50 @@ +concrete RelativeFin of Relative = CatFin ** open Prelude, ResFin, MorphoFin in { + + flags optimize=all_subs ; + + lin + + RelCl cl = { + s = \\t,a,p,_ => "siten" ++ "että" ++ cl.s ! t ! a ! p ! SDecl ; + ---- sellainen + c = NPCase Nom + } ; + + RelVP rp vp = { + s = \\t,ant,b,ag => + let + agr = case rp.a of { + RNoAg => ag ; + RAg a => a + } ; + cl = mkClause + (subjForm {s = rp.s ! agr.n ; + a = agr ; isPron = False} vp.sc) agr vp + in + cl.s ! t ! ant ! b ! SDecl ; + c = NPCase Nom + } ; + + RelSlash rp slash = { + s = \\t,a,p,ag => + let + cls = slash.s ! t ! a ! p ; + who = appCompl True p slash.c2 (rp2np ag.n rp) + in + who ++ cls ; + c = slash.c2.c + } ; + + FunRP p np rp = { + s = \\n,c => appCompl True Pos p (rp2np n rp) ++ np.s ! c ; --- is c OK? + a = RAg np.a + } ; + + IdRP = { + s = \\n,c => relPron ! n ! npform2case n c ; + a = RNoAg + } ; + + + +} diff --git a/lib/resource-1.4/finnish/ResFin.gf b/lib/resource-1.4/finnish/ResFin.gf new file mode 100644 index 000000000..d309b2d79 --- /dev/null +++ b/lib/resource-1.4/finnish/ResFin.gf @@ -0,0 +1,575 @@ +--# -path=.:../abstract:../common:../../prelude + +--1 Finnish auxiliary operations. + +-- This module contains operations that are needed to make the +-- resource syntax work. To define everything that is needed to +-- implement $Test$, it moreover contains regular lexical +-- patterns needed for $Lex$. + +resource ResFin = ParamX ** open Prelude in { + + flags optimize=all ; + + +--2 Parameters for $Noun$ + +-- This is the $Case$ as needed for both nouns and $NP$s. + + param + Case = Nom | Gen | Part | Transl | Ess + | Iness | Elat | Illat | Adess | Ablat | Allat + | Abess ; -- Comit, Instruct in NForm + + NForm = NCase Number Case + | NComit | NInstruct -- no number dist + | NPossNom Number | NPossGen Number --- number needed for syntax of AdjCN + | NPossTransl Number | NPossIllat Number ; + +-- Agreement of $NP$ is a record. We'll add $Gender$ later. + + oper + Agr = {n : Number ; p : Person} ; + + NP = {s : NPForm => Str ; a : Agr ; isPron : Bool} ; + +-- +--2 Adjectives +-- +-- The major division is between the comparison degrees. A degree fixed, +-- an adjective is like common nouns, except for the adverbial form. + +param + AForm = AN NForm | AAdv ; + +oper + Adjective : Type = {s : Degree => AForm => Str} ; + +--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 | NPAcc ; + +oper + npform2case : Number -> NPForm -> Case = \n,f -> + +-- type signature: workaround for gfc bug 9/11/2007 + case < : NPForm * Number> of { + => c ; + => Gen ;-- appCompl does the job + => Nom + } ; + + n2nform : NForm -> NForm = \nf -> case nf of { + NPossNom n => NCase n Nom ; ---- + NPossGen n => NCase n Gen ; + NPossTransl n => NCase n Transl ; + NPossIllat n => NCase n Illat ; + _ => nf + } ; + + +--2 For $Verb$ + +-- A special form is needed for the negated plural imperative. + +param + VForm = + Inf InfForm + | Presn Number Person + | Impf Number Person --# notpresent + | Condit Number Person --# notpresent + | Imper Number + | ImperP3 Number + | ImperP1Pl + | ImpNegPl + | Pass Bool + | PastPartAct AForm + | PastPartPass AForm + ; + + InfForm = + Inf1 + | Inf3Iness -- 5 forms acc. to Karlsson + | Inf3Elat + | Inf3Illat + | Inf3Adess + | Inf3Abess + ; + + SType = SDecl | SQuest ; + +--2 For $Relative$ + + RAgr = RNoAg | RAg {n : Number ; p : Person} ; + +--2 For $Numeral$ + + CardOrd = NCard NForm | NOrd NForm ; + +--2 Transformations between parameter types + + oper + agrP3 : Number -> Agr = \n -> + {n = n ; p = P3} ; + + conjAgr : Agr -> Agr -> Agr = \a,b -> { + n = conjNumber a.n b.n ; + p = conjPerson a.p b.p + } ; + +--- + + Compl : Type = {s : Str ; c : NPForm ; isPre : Bool} ; + + appCompl : Bool -> Polarity -> Compl -> NP -> Str = \isFin,b,co,np -> + let + c = case of { + <_, Neg, NPAcc,_,_> => NPCase Part ; -- en näe taloa/sinua + <_, Pos, NPAcc,True,_> => NPAcc ; -- näen/täytyy sinut + => NPCase Gen ; -- näen talon + => NPCase Nom ; -- täytyy talo/sinut; näen talot + <_,_,coc,_,_> => coc + } ; + nps = np.s ! c + in + preOrPost co.isPre co.s nps ; + +-- For $Verb$. + + Verb : Type = { + s : VForm => Str + } ; + +param + VIForm = + VIFin Tense + | VIInf InfForm + | VIPass + | VIImper + ; + +oper + VP = { + s : VIForm => Anteriority => Polarity => Agr => {fin, inf : Str} ; + s2 : Bool => Polarity => Agr => Str ; -- talo/talon/taloa + ext : Str ; + sc : NPForm + } ; + + predV : (Verb ** {sc : NPForm}) -> VP = \verb -> { + s = \\vi,ant,b,agr => + let + + verbs = verb.s ; + part : Str = case vi of { + VIPass => verbs ! PastPartPass (AN (NCase agr.n Nom)) ; + _ => verbs ! PastPartAct (AN (NCase agr.n Nom)) + } ; + + eiv : Str = case agr of { + {n = Sg ; p = P1} => "en" ; + {n = Sg ; p = P2} => "et" ; + {n = Sg ; p = P3} => "ei" ; + {n = Pl ; p = P1} => "emme" ; + {n = Pl ; p = P2} => "ette" ; + {n = Pl ; p = P3} => "eivät" + } ; + + einegole : Str * Str * Str = case of { + => ; + => ; --# notpresent + => ; --# notpresent + => ; --# notpresent + => ; --# notpresent + => <"älä", verbs ! Imper Sg, "ole"> ; + => <"älkää", verbs ! ImpNegPl, "olko"> ; + => <"ei", verbs ! Pass False, "ole"> ; + => <"ei", verbs ! Inf i, "olla"> ---- + } ; + + ei : Str = einegole.p1 ; + neg : Str = einegole.p2 ; + ole : Str = einegole.p3 ; + + olla : VForm => Str = verbOlla.s ; + + vf : Str -> Str -> {fin, inf : Str} = \x,y -> + {fin = x ; inf = y} ; + mkvf : VForm -> {fin, inf : Str} = \p -> case of { + => vf (verbs ! p) [] ; + => vf (olla ! p) part ; --# notpresent + => vf ei (ole ++ part) ; --# notpresent + => vf ei neg + } + in + case vi of { + VIFin Past => mkvf (Impf agr.n agr.p) ; --# notpresent + VIFin Cond => mkvf (Condit agr.n agr.p) ; --# notpresent + VIFin Fut => mkvf (Presn agr.n agr.p) ; --# notpresent + VIFin Pres => mkvf (Presn agr.n agr.p) ; + VIImper => mkvf (Imper agr.n) ; + VIPass => mkvf (Pass True) ; + VIInf i => mkvf (Inf i) + } ; + + s2 = \\_,_,_ => [] ; + ext = [] ; + sc = verb.sc + } ; + + + insertObj : (Bool => Polarity => Agr => Str) -> VP -> VP = \obj,vp -> { + s = vp.s ; + s2 = \\fin,b,a => vp.s2 ! fin ! b ! a ++ obj ! fin ! b ! a ; + ext = vp.ext ; + sc = vp.sc + } ; + + insertExtrapos : Str -> VP -> VP = \obj,vp -> { + s = vp.s ; + s2 = vp.s2 ; + ext = vp.ext ++ obj ; + sc = vp.sc + } ; + +-- For $Sentence$. + + Clause : Type = { + s : Tense => Anteriority => Polarity => SType => Str + } ; + + mkClause : (Polarity -> Str) -> Agr -> VP -> Clause = + \sub,agr,vp -> { + s = \\t,a,b,o => + let + subj = sub b ; + agrfin = case vp.sc of { + NPCase Nom => ; + _ => -- minun täytyy, minulla on + } ; + verb = vp.s ! VIFin t ! a ! b ! agrfin.p1 ; + compl = vp.s2 ! agrfin.p2 ! b ! agr ++ vp.ext + in + case o of { + SDecl => subj ++ verb.fin ++ verb.inf ++ compl ; + SQuest => questPart verb.fin ++ subj ++ verb.inf ++ compl + } + } ; + +-- This is used for subjects of passives: therefore isFin in False. + + subjForm : NP -> NPForm -> Polarity -> Str = \np,sc,b -> + appCompl False b {s = [] ; c = sc ; isPre = True} np ; + + questPart : Str -> Str = \on -> on ++ BIND ++ "ko" ; ---- + + infVP : NPForm -> Polarity -> Agr -> VP -> Str = + \sc,pol,agr,vp -> + let + fin = case sc of { -- subject case + NPCase Nom => True ; -- minä tahdon nähdä auton + _ => False -- minun täytyy nähdä auto + } ; + verb = vp.s ! VIInf Inf1 ! Simul ! Pos ! agr ; -- no "ei" + compl = vp.s2 ! fin ! pol ! agr ++ vp.ext -- but compl. case propagated + in + verb.fin ++ verb.inf ++ compl ; + +-- The definitions below were moved here from $MorphoFin$ so that we the +-- auxiliary of predication can be defined. + + verbOlla : Verb = + let olla = mkVerb + "olla" "on" "olen" "ovat" "olkaa" "ollaan" + "oli" "olin" "olisi" "ollut" "oltu" "ollun" ; + in {s = table { + Inf Inf3Iness => "olemassa" ; + Inf Inf3Elat => "olemasta" ; + Inf Inf3Illat => "olemaan" ; + Inf Inf3Adess => "olemalla" ; + Inf Inf3Abess => "olematta" ; + v => olla.s ! v + } + } ; + + +--3 Verbs +-- +-- The present, past, conditional. and infinitive stems, acc. to Koskenniemi. +-- Unfortunately not enough (without complicated processes). +-- We moreover give grade alternation forms as arguments, since it does not +-- happen automatically. +--- A problem remains with the verb "seistä", where the infinitive +--- stem has vowel harmony "ä" but the others "a", thus "seisoivat" but "seiskää". + + + mkVerb : (_,_,_,_,_,_,_,_,_,_,_,_ : Str) -> Verb = + \tulla,tulee,tulen,tulevat,tulkaa,tullaan,tuli,tulin,tulisi,tullut,tultu,tullun -> + v2v (mkVerbH + tulla tulee tulen tulevat tulkaa tullaan tuli tulin tulisi tullut tultu tullun + ) ; + + v2v : VerbH -> Verb = \vh -> + let + tulla = vh.tulla ; + tulee = vh.tulee ; + tulen = vh.tulen ; + tulevat = vh.tulevat ; + tulkaa = vh.tulkaa ; + tullaan = vh.tullaan ; + tuli = vh.tuli ; + tulin = vh.tulin ; + tulisi = vh.tulisi ; + tullut = vh.tullut ; + tultu = vh.tultu ; + tultu = vh.tultu ; + tullun = vh.tullun ; + tuje = init tulen ; + tuji = init tulin ; + a = Predef.dp 1 tulkaa ; + tulko = Predef.tk 2 tulkaa + (ifTok Str a "a" "o" "ö") ; + o = last tulko ; + tulleena = Predef.tk 2 tullut + ("een" + a) ; + tulleen = (noun2adj (nhn (sRae tullut tulleena))).s ; + tullun = (noun2adj (nhn (sKukko tultu tullun (tultu + ("j"+a))))).s ; + tulema = Predef.tk 3 tulevat + "m" + a ; +---- tulema = tuje + "m" + a ; + vat = "v" + a + "t" + in + {s = table { + Inf Inf1 => tulla ; + Presn Sg P1 => tuje + "n" ; + Presn Sg P2 => tuje + "t" ; + Presn Sg P3 => tulee ; + Presn Pl P1 => tuje + "mme" ; + Presn Pl P2 => tuje + "tte" ; + Presn Pl P3 => tulevat ; + Impf Sg P1 => tuji + "n" ; --# notpresent + Impf Sg P2 => tuji + "t" ; --# notpresent + Impf Sg P3 => tuli ; --# notpresent + Impf Pl P1 => tuji + "mme" ; --# notpresent + Impf Pl P2 => tuji + "tte" ; --# notpresent + Impf Pl P3 => tuli + vat ; --# notpresent + Condit Sg P1 => tulisi + "n" ; --# notpresent + Condit Sg P2 => tulisi + "t" ; --# notpresent + Condit Sg P3 => tulisi ; --# notpresent + Condit Pl P1 => tulisi + "mme" ; --# notpresent + Condit Pl P2 => tulisi + "tte" ; --# notpresent + Condit Pl P3 => tulisi + vat ; --# notpresent + Imper Sg => tuje ; + Imper Pl => tulkaa ; + ImperP3 Sg => tulko + o + "n" ; + ImperP3 Pl => tulko + o + "t" ; + ImperP1Pl => tulkaa + "mme" ; + ImpNegPl => tulko ; + Pass True => tullaan ; + Pass False => Predef.tk 2 tullaan ; + PastPartAct n => tulleen ! n ; + PastPartPass n => tullun ! n ; + Inf Inf3Iness => tulema + "ss" + a ; + Inf Inf3Elat => tulema + "st" + a ; + Inf Inf3Illat => tulema + a + "n" ; + Inf Inf3Adess => tulema + "ll" + a ; + Inf Inf3Abess => tulema + "tt" + a + } + } ; + + VerbH : Type = { + tulla,tulee,tulen,tulevat,tulkaa,tullaan,tuli,tulin,tulisi,tullut,tultu,tullun + : Str + } ; + + mkVerbH : (_,_,_,_,_,_,_,_,_,_,_,_ : Str) -> VerbH = + \tulla,tulee,tulen,tulevat,tulkaa,tullaan,tuli,tulin,tulisi,tullut,tultu,tullun -> + {tulla = tulla ; + tulee = tulee ; + tulen = tulen ; + tulevat = tulevat ; + tulkaa = tulkaa ; + tullaan = tullaan ; + tuli = tuli ; + tulin = tulin ; + tulisi = tulisi ; + tullut = tullut ; + tultu = tultu ; + tullun = tullun + } ; + + noun2adj : CommonNoun -> Adj = noun2adjComp True ; + + noun2adjComp : Bool -> CommonNoun -> Adj = \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 + } + } ; + + CommonNoun = {s : NForm => Str} ; + +-- To form an adjective, it is usually enough to give a noun declension: the +-- adverbial form is regular. + + Adj : Type = {s : AForm => Str} ; + + NounH : Type = { + a,vesi,vede,vete,vetta,veteen,vetii,vesii,vesien,vesia,vesiin : Str + } ; + +-- worst-case macro + + mkSubst : Str -> (_,_,_,_,_,_,_,_,_,_ : Str) -> NounH = + \a,vesi,vede,vete,vetta,veteen,vetii,vesii,vesien,vesia,vesiin -> + {a = a ; + vesi = vesi ; + vede = vede ; + vete = vete ; + vetta = vetta ; + veteen = veteen ; + vetii = vetii ; + vesii = vesii ; + vesien = vesien ; + vesia = vesia ; + vesiin = vesiin + } ; + + nhn : NounH -> CommonNoun = \nh -> + let + a = nh.a ; + vesi = nh.vesi ; + vede = nh.vede ; + vete = nh.vete ; + vetta = nh.vetta ; + veteen = nh.veteen ; + vetii = nh.vetii ; + vesii = nh.vesii ; + vesien = nh.vesien ; + vesia = nh.vesia ; + vesiin = nh.vesiin + in + {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 => vetii + "ne" ; + NInstruct => vesii + "n" ; + + NPossNom _ => vete ; + NPossGen Sg => vete ; + NPossGen Pl => Predef.tk 1 vesien ; + NPossTransl Sg => vede + "kse" ; + NPossTransl Pl => vesii + "kse" ; + NPossIllat Sg => Predef.tk 1 veteen ; + NPossIllat Pl => Predef.tk 1 vesiin + } + } ; +-- Surpraisingly, making the test for the partitive, this not only covers +-- "rae", "perhe", "savuke", but also "rengas", "lyhyt" (except $Sg Illat$), etc. + + sRae : (_,_ : Str) -> NounH = \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") ; +-- 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) -> NounH = \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") ; + +-- Reflexive pronoun. +--- Possessive could be shared with the more general $NounFin.DetCN$. + +oper + reflPron : Agr -> NP = \agr -> + let + itse = (nhn (sKukko "itse" "itsen" "itsejä")).s ; + nsa = possSuffix agr + in { + s = table { + NPCase (Nom | Gen) | NPAcc => itse ! NPossNom Sg + nsa ; + NPCase Transl => itse ! NPossTransl Sg + nsa ; + NPCase Illat => itse ! NPossIllat Sg + nsa ; + NPCase c => itse ! NCase Sg c + nsa + } ; + a = agr ; + isPron = False -- no special acc form + } ; + + possSuffix : Agr -> Str = \agr -> + table Agr ["ni" ; "si" ; "nsa" ; "mme" ; "nne" ; "nsa"] ! agr ; + +oper + rp2np : Number -> {s : Number => NPForm => Str ; a : RAgr} -> NP = \n,rp -> { + s = rp.s ! n ; + a = agrP3 Sg ; -- does not matter (--- at least in Slash) + isPron = False -- has no special accusative + } ; +} diff --git a/lib/resource-1.4/finnish/SentenceFin.gf b/lib/resource-1.4/finnish/SentenceFin.gf new file mode 100644 index 000000000..b33349972 --- /dev/null +++ b/lib/resource-1.4/finnish/SentenceFin.gf @@ -0,0 +1,84 @@ +concrete SentenceFin of Sentence = CatFin ** open Prelude, ResFin in { + + flags optimize=all_subs ; + + lin + + PredVP np vp = mkClause (subjForm np vp.sc) np.a vp ; + + PredSCVP sc vp = mkClause (\_ -> sc.s) (agrP3 Sg) vp ; + + ImpVP vp = { + s = \\pol,n => + let + agr = {n = n ; p = P2} ; + verb = vp.s ! VIImper ! Simul ! pol ! agr ; + compl = vp.s2 ! False ! pol ! agr ++ vp.ext --- False = like inf (osta auto) + in + verb.fin ++ verb.inf ++ compl ; + } ; + +-- The object case is formed at the use site of $c2$, in $Relative$ and $Question$. + +{- + SlashV2 np v2 = { + s = \\t,a,p => (mkClause (subjForm np v2.sc) np.a (predV v2)).s ! t ! a ! p ! SDecl ; + c2 = v2.c2 + } ; + + SlashVVV2 np vv v2 = + let + sc = case v2.sc of { + NPCase Nom => vv.sc ; -- joka minun täytyy pestä + c => c -- joka minulla täytyy olla + } + in + {s = \\t,ag,p => + (mkClause + (subjForm np sc) np.a + (insertObj + (\\_,b,a => infVP vv.sc b a (predV v2)) + (predV vv) + ) + ).s ! t ! ag ! p ! SDecl ; + c2 = v2.c2 + } ; +-} + AdvSlash slash adv = { + s = \\t,a,b => slash.s ! t ! a ! b ++ adv.s ; + c2 = slash.c2 + } ; + + SlashPrep cl prep = { + s = \\t,a,p => cl.s ! t ! a ! p ! SDecl ; + c2 = prep + } ; + + SlashVS np vs slash = { + s = \\t,a,p => + (mkClause (subjForm np vs.sc) np.a + (insertExtrapos ("että" ++ slash.s) + (predV vs)) + ).s ! t ! a ! p ! SDecl ; + c2 = slash.c2 + } ; + + + EmbedS s = {s = "että" ++ s.s} ; + EmbedQS qs = {s = qs.s} ; + EmbedVP vp = {s = infVP (NPCase Nom) Pos (agrP3 Sg) vp} ; --- case,pol,agr + + UseCl t a p cl = {s = t.s ++ a.s ++ p.s ++ cl.s ! t.t ! a.a ! p.p ! SDecl} ; + UseQCl t a p cl = {s = t.s ++ a.s ++ p.s ++ cl.s ! t.t ! a.a ! p.p} ; + UseRCl t a p cl = { + s = \\r => t.s ++ a.s ++ p.s ++ cl.s ! t.t ! a.a ! p.p ! r ; + c = cl.c + } ; + UseSlash t a p cl = { + s = t.s ++ a.s ++ p.s ++ cl.s ! t.t ! a.a ! p.p ; + c2 = cl.c2 + } ; + + AdvS a s = {s = a.s ++ s.s} ; + +} diff --git a/lib/resource-1.4/finnish/StructuralFin.gf b/lib/resource-1.4/finnish/StructuralFin.gf new file mode 100644 index 000000000..b0ee68fab --- /dev/null +++ b/lib/resource-1.4/finnish/StructuralFin.gf @@ -0,0 +1,299 @@ +concrete StructuralFin of Structural = CatFin ** + open MorphoFin, ParadigmsFin, Prelude in { + + flags optimize=all ; + + lin + above_Prep = postGenPrep "yläpuolella" ; + after_Prep = postGenPrep "jälkeen" ; + + all_Predet = {s = \\n,c => + let + kaiket = caseTable n ((mkN "kaikki" "kaiken" "kaikkena")) + in + case npform2case n c of { + Nom => "kaikki" ; + k => kaiket ! k + } + } ; + almost_AdA, almost_AdN = ss "melkein" ; + although_Subj = ss "vaikka" ; + always_AdV = ss "aina" ; + and_Conj = {s1 = [] ; s2 = "ja" ; n = Pl} ; + because_Subj = ss "koska" ; + before_Prep = prePrep partitive "ennen" ; + behind_Prep = postGenPrep "takana" ; + between_Prep = postGenPrep "välissä" ; + both7and_DConj = sd2 "sekä" "että" ** {n = Pl} ; + but_PConj = ss "mutta" ; + by8agent_Prep = postGenPrep "toimesta" ; + by8means_Prep = casePrep adessive ; + can8know_VV = mkV "osata" "osasi" ; + can_VV = mkV "voida" "voi" ; + during_Prep = postGenPrep "aikana" ; + either7or_DConj = sd2 "joko" "tai" ** {n = Sg} ; + everybody_NP = makeNP (mkN "jokainen") Sg ; + every_Det = mkDet Sg (mkN "jokainen") ; + everything_NP = makeNP (((mkN "kaikki" "kaiken" "kaikkena")) ** + {lock_N = <>}) Sg ; + everywhere_Adv = ss "kaikkialla" ; + few_Det = mkDet Sg (mkN "harva") ; +--- first_Ord = {s = \\n,c => (mkN "ensimmäinen").s ! NCase n c} ; + for_Prep = casePrep allative ; + from_Prep = casePrep elative ; + he_Pron = mkPronoun "hän" "hänen" "häntä" "hänenä" "häneen" Sg P3 ; + here_Adv = ss "täällä" ; + here7to_Adv = ss "tänne" ; + here7from_Adv = ss "täältä" ; + how_IAdv = ss "miten" ; + how8many_IDet = + {s = \\c => "kuinka" ++ (mkN "moni" "monia").s ! NCase Sg c ; n = Sg} ; + if_Subj = ss "jos" ; + in8front_Prep = postGenPrep "edessä" ; + i_Pron = mkPronoun "minä" "minun" "minua" "minuna" "minuun" Sg P1 ; + in_Prep = casePrep inessive ; + it_Pron = { + s = \\c => pronSe.s ! npform2case Sg c ; + a = agrP3 Sg ; + isPron = False + } ; + less_CAdv = ss "vähemmän" ; + many_Det = mkDet Sg (mkN "moni" "monia") ; + more_CAdv = ss "enemmän" ; + most_Predet = {s = \\n,c => (nForms2N (dSuurin "useinta")).s ! NCase n (npform2case n c)} ; + much_Det = mkDet Sg {s = \\_ => "paljon"} ; + must_VV = caseV genitive (mkV "täytyä") ; + no_Utt = ss "ei" ; + on_Prep = casePrep adessive ; +--- one_Quant = mkDet Sg DEPREC + only_Predet = {s = \\_,_ => "vain"} ; + or_Conj = {s1 = [] ; s2 = "tai" ; n = Pl} ; + otherwise_PConj = ss "muuten" ; + part_Prep = casePrep partitive ; + please_Voc = ss ["ole hyvä"] ; --- number + possess_Prep = casePrep genitive ; + quite_Adv = ss "melko" ; + she_Pron = mkPronoun "hän" "hänen" "häntä" "hänenä" "häneen" Sg P3 ; + so_AdA = ss "niin" ; + somebody_NP = { + s = \\c => jokuPron ! Sg ! npform2case Sg c ; + a = agrP3 Sg ; + isPron = False + } ; + someSg_Det = { + s1 = jokuPron ! Sg ; + s2 = [] ; + isNum,isPoss = False ; isDef = True ; n = Sg + } ; + somePl_Det = { + s1 = jokuPron ! Pl ; + s2 = [] ; isNum,isPoss = False ; isDef = True ; + n = Pl + } ; + something_NP = { + s = \\c => jokinPron ! Sg ! npform2case Sg c ; + a = agrP3 Sg ; + isPron = False + } ; + somewhere_Adv = ss "jossain" ; + that_Quant = { + s1 = table (MorphoFin.Number) { + Sg => table (MorphoFin.Case) { + c => (mkPronoun "tuo" "tuon" "tuota" "tuona" "tuohon" Sg P3).s ! NPCase c + } ; + Pl => table (MorphoFin.Case) { + c => (mkPronoun "nuo" "noiden" "noita" "noina" "noihin" Sg P3).s ! NPCase c + } + } ; + s2 = [] ; isNum,isPoss = False ; isDef = True ; + } ; + there_Adv = ss "siellä" ; --- tuolla + there7to_Adv = ss "sinne" ; + there7from_Adv = ss "sieltä" ; + therefore_PConj = ss "siksi" ; + they_Pron = mkPronoun "he" "heidän" "heitä" "heinä" "heihin" Pl P3 ; --- ne + this_Quant = { + s1 = table (MorphoFin.Number) { + Sg => table (MorphoFin.Case) { + c => (mkPronoun "tämä" "tämän" "tätä" "tänä" "tähän" Sg P3).s ! NPCase c + } ; + Pl => table (MorphoFin.Case) { + c => (mkPronoun "nämä" "näiden" "näitä" "näinä" "näihin" Sg P3).s ! NPCase c + } + } ; + s2 = [] ; isNum,isPoss = False ; isDef = True ; + } ; + through_Prep = postGenPrep "kautta" ; + too_AdA = ss "liian" ; + to_Prep = casePrep illative ; --- allative + under_Prep = postGenPrep "alla" ; + very_AdA = ss "erittäin" ; + want_VV = mkV "tahtoa" ; + we_Pron = mkPronoun "me" "meidän" "meitä" "meinä" "meihin" Pl P1 ; + whatPl_IP = { + s = table {NPAcc => "mitkä" ; c => mikaInt ! Pl ! npform2case Pl c} ; + n = Pl + } ; + whatSg_IP = { + s = \\c => mikaInt ! Sg ! npform2case Sg c ; + n = Sg + } ; + when_IAdv = ss "milloin" ; + when_Subj = ss "kun" ; + where_IAdv = ss "missä" ; + which_IQuant = { + s = mikaInt + } ; + whoSg_IP = { + s = table {NPAcc => "kenet" ; c => kukaInt ! Sg ! npform2case Sg c} ; + n = Sg + } ; + whoPl_IP = { + s = table {NPAcc => "ketkä" ; c => kukaInt ! Pl ! npform2case Pl c} ; + n = Pl + } ; + why_IAdv = ss "miksi" ; + without_Prep = prePrep partitive "ilman" ; + with_Prep = postGenPrep "kanssa" ; + yes_Utt = ss "kyllä" ; + youSg_Pron = mkPronoun "sinä" "sinun" "sinua" "sinuna" "sinuun" Sg P2 ; + youPl_Pron = mkPronoun "te" "teidän" "teitä" "teinä" "teihin" Pl P2 ; + youPol_Pron = mkPronoun "te" "teidän" "teitä" "teinä" "teihin" Pl P2 ; --- Sg + + +oper + jokuPron : MorphoFin.Number => (MorphoFin.Case) => Str = + let + ku = mkN "ku" ; + kui = mkN "kuu" + in + table { + Sg => table { + Nom => "joku" ; + Gen => "jonkun" ; + c => relPron ! Sg ! c + ku.s ! NCase Sg c + } ; + Pl => table { + Nom => "jotkut" ; + c => relPron ! Pl ! c + kui.s ! NCase Pl c + } + } ; + + jokinPron : MorphoFin.Number => (MorphoFin.Case) => Str = + table { + Sg => table { + Nom => "jokin" ; + Gen => "jonkin" ; + c => relPron ! Sg ! c + "kin" + } ; + Pl => table { + Nom => "jotkin" ; + c => relPron ! Pl ! c + "kin" + } + } ; + + mikaInt : MorphoFin.Number => (MorphoFin.Case) => Str = + let { + mi = mkN "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 : MorphoFin.Number => (MorphoFin.Case) => Str = + let { + ku = mkN "kuka" "keitä" ; ----- + ket = mkN "kuka" "keitä"} 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 : MorphoFin.Number => (MorphoFin.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 : MorphoFin.Number => (MorphoFin.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" + } + } ; + + 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ä" + } ; + } ; + + +oper + makeNP : N -> Number -> CatFin.NP ; + makeNP noun num = { + s = \\c => noun.s ! NCase num (npform2case num c) ; + a = agrP3 num ; + isPron = False ; + lock_NP = <> + } ; + + + +} + diff --git a/lib/resource-1.4/finnish/VerbFin.gf b/lib/resource-1.4/finnish/VerbFin.gf new file mode 100644 index 000000000..b3db7bd0f --- /dev/null +++ b/lib/resource-1.4/finnish/VerbFin.gf @@ -0,0 +1,102 @@ +--1 Verb Phrases in Finnish + +concrete VerbFin of Verb = CatFin ** open Prelude, ResFin in { + + flags optimize=all_subs ; + + lin + UseV = predV ; +{- + ComplV2 v np = insertObj (\\fin,b,_ => appCompl fin b v.c2 np) (predV v) ; + + ComplV3 v np np2 = + insertObj + (\\fin,b,_ => appCompl fin b v.c2 np ++ appCompl fin b v.c3 np2) (predV v) ; +-} + ComplVV v vp = + insertObj + (\\_,b,a => infVP v.sc b a vp) + (predV {s = v.s ; + sc = case vp.sc of { + NPCase Nom => v.sc ; -- minun täytyy pestä auto + c => c -- minulla täytyy olla auto + } + } + ) ; + + ComplVS v s = insertExtrapos ("että" ++ s.s) (predV v) ; + ComplVQ v q = insertExtrapos ( q.s) (predV v) ; + ComplVA v ap = + insertObj + (\\_,b,agr => + ap.s ! False ! AN (NCase agr.n (npform2case agr.n v.c2.c))) --- v.cs.s ignored + (predV v) ; +{- + ComplV2S v np s = + insertExtrapos ("että" ++ s.s) + (insertObj (\\fin,b,_ => appCompl fin b v.c2 np) (predV v)) ; + ComplV2Q v np q = + insertExtrapos (q.s) + (insertObj (\\fin,b,_ => appCompl fin b v.c2 np) (predV v)) ; + ComplV2V v np vp = + insertObj (\\_,b,a => infVP v.sc b a vp) ---- different infinitives + (insertObj (\\fin,b,_ => appCompl fin b v.c2 np) (predV v)) ; + + ComplV2A v np ap = + insertObj + (\\fin,b,_ => appCompl fin b v.c2 np ++ + ap.s ! False ! AN (NCase np.a.n (npform2case np.a.n v.c3.c))) --agr to obj + (predV v) ; +-} + UseComp comp = + insertObj (\\_,_ => comp.s) (predV (verbOlla ** {sc = NPCase Nom})) ; + + AdvVP vp adv = insertObj (\\_,_,_ => adv.s) vp ; + + AdVVP adv vp = insertObj (\\_,_,_ => adv.s) vp ; + +---- ReflV2 v = insertObj (\\fin,b,agr => appCompl fin b v.c2 (reflPron agr)) (predV v) ; + + PassV2 v = let vp = predV v in { + s = \\_ => vp.s ! VIPass ; + s2 = \\_,_,_ => [] ; + ext = [] ; + sc = v.c2.c -- minut valitaan ; minua rakastetaan ; minulle kuiskataan + } ; ---- talon valitaan: should be marked like inf. + +----b UseVS, UseVQ = \v -> v ** {c2 = {s = [] ; c = NPAcc ; isPre = True}} ; + + CompAP ap = { + s = \\agr => + let + n = agr.n ; + c = case agr.n of { + Sg => Nom ; -- minä olen iso + Pl => Part -- me olemme isoja + } --- definiteness of NP ? + in ap.s ! False ! AN (NCase agr.n c) + } ; + CompNP np = {s = \\_ => np.s ! NPCase Nom} ; + CompAdv a = {s = \\_ => a.s} ; + +} + + +--2 The object case +-- +-- The rules involved are ComplV2 and ComplVV above. +-- The work is done jointly in ResFin.infVP and appCompl. +-- Cases to test: l -table (to see negated forms) +--``` +-- minun täytyy ostaa auto +-- PredVP (UsePron i_Pron) (ComplVV must_VV +-- (ComplV2 buy_V2 (DetCN (DetSg (SgQuant DefArt) NoOrd) (UseN car_N)))) +-- minä tahdon ostaa auton +-- PredVP (UsePron i_Pron) (ComplVV want_VV +-- (ComplV2 buy_V2 (DetCN (DetSg (SgQuant DefArt) NoOrd) (UseN car_N)))) +-- minulla täytyy olla auto +-- PredVP (UsePron i_Pron) (ComplVV must_VV +-- (ComplV2 have_V2 (DetCN (DetSg (SgQuant DefArt) NoOrd) (UseN car_N)))) +--``` +-- Unfortunately, there is no nice way to say "I want to have a car". +-- (Other than the paraphrases "I want a car" or "I want to own a car".) diff --git a/src-3.0/Makefile b/src-3.0/Makefile index 25034bac7..16a538925 100644 --- a/src-3.0/Makefile +++ b/src-3.0/Makefile @@ -30,7 +30,7 @@ EMBED = GF/Embed/TemplateApp # use the temporary binary file name 'gf-bin' to not clash with directory 'GF' # on case insensitive file systems (such as FAT) -GF_EXE=gf$(EXEEXT) +GF_EXE=gf3$(EXEEXT) GF_EXE_TMP=gf-bin$(EXEEXT) GF_DOC_EXE=gfdoc$(EXEEXT) GF3_EXE=gf3$(EXEEXT)