From 2994111b957239a91b764d3dfc927f8e1136c1b1 Mon Sep 17 00:00:00 2001 From: aarne Date: Fri, 7 Mar 2008 14:47:10 +0000 Subject: [PATCH] new Finnish paradigms integrated --- lib/resource/finnish/ExtraFin.gf | 5 + lib/resource/finnish/ExtraFinAbs.gf | 2 +- lib/resource/finnish/LexiconFin.gf | 677 ++++++----- lib/resource/finnish/MorphoFin.gf | 1536 +++++++++++++------------ lib/resource/finnish/NumeralFin.gf | 12 +- lib/resource/finnish/ParadigmsFin.gf | 653 +++++------ lib/resource/finnish/StructuralFin.gf | 47 +- src/GF/Compile/Rename.hs | 3 +- 8 files changed, 1444 insertions(+), 1491 deletions(-) diff --git a/lib/resource/finnish/ExtraFin.gf b/lib/resource/finnish/ExtraFin.gf index c8599755a..104b1bde0 100644 --- a/lib/resource/finnish/ExtraFin.gf +++ b/lib/resource/finnish/ExtraFin.gf @@ -71,4 +71,9 @@ concrete ExtraFin of ExtraFinAbs = CatFin ** vai_Conj = {s = "vai" ; n = Sg} ; + + CompPartAP ap = { + s = \\agr => ap.s ! False ! AN (NCase agr.n Part) + } ; + } diff --git a/lib/resource/finnish/ExtraFinAbs.gf b/lib/resource/finnish/ExtraFinAbs.gf index 035850c87..824411120 100644 --- a/lib/resource/finnish/ExtraFinAbs.gf +++ b/lib/resource/finnish/ExtraFinAbs.gf @@ -15,5 +15,5 @@ abstract ExtraFinAbs = Extra [ vai_Conj : Conj ; -- minä vai sinä? ("or" in question) - vai_Conj : Conj ; + CompPartAP : AP -> Comp ; -- kahvi on valmista } diff --git a/lib/resource/finnish/LexiconFin.gf b/lib/resource/finnish/LexiconFin.gf index 7d78cd6c3..f649aa706 100644 --- a/lib/resource/finnish/LexiconFin.gf +++ b/lib/resource/finnish/LexiconFin.gf @@ -7,378 +7,377 @@ flags lin - airplane_N = regN "lentokone" ; - answer_V2S = mkV2S (regV "vastata") (casePrep allative) ; - apartment_N = regN "asunto" ; - apple_N = nLukko "omena" ; --- omenia, not omenoita - art_N = regN "taide" ; - ask_V2Q = mkV2Q (regV "kysyä") (casePrep ablative) ; - baby_N = nLukko "vauva" ; - bad_A = mkADeg (nLukko "paha") "pahempi" "pahin" ; - bank_N = regN "pankki" ; - beautiful_A = mkADeg (regN "kaunis") "kauniimpi" "kaunein" ; - become_VA = mkVA (regV "tulla") (casePrep translative) ; - beer_N = regN "olut" ; - beg_V2V = mkV2V (reg2V "pyytää" "pyysi") (casePrep partitive) ; - big_A = mkADeg (sgpartN (nArpi "suuri") "suurta") "suurempi" "suurin" ; - bike_N = nLukko "polkupyörä" ; --- for correct vowel harmony - bird_N = nLukko "lintu" ; - black_A = mkADeg (nLukko "musta") "mustempi" "mustin" ; - blue_A = mkADeg (regN "sininen") "sinisempi" "sinisin" ; - boat_N = regN "vene" ; - book_N = nLukko "kirja" ; - boot_N = regN "saapas" ; - boss_N = nLukko "pomo" ; - boy_N = nKukko "poika" "pojan" "poikia" ; - bread_N = nLukko "leipä" ; - break_V2 = dirV2 (regV "rikkoa") ; - broad_A = mkADeg (regN "leveä") "leveämpi" "levein" ; - brother_N2 = genN2 ( + 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" ; + 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 = mkADeg (regN "ruskea") "ruskeampi" "ruskein" ; - butter_N = reg3N "voi" "voin" "voita" ; ---- errors in Part - buy_V2 = dirV2 (regV "ostaa") ; - camera_N = nLukko "kamera" ; - cap_N = regN "lakki" ; - car_N = reg3N "auto" "auton" "autoja" ; -- regN: audon - carpet_N = nLukko "matto" ; - cat_N = nLukko "kissa" ; - ceiling_N = nLukko "katto" ; - chair_N = regN "tuoli" ; - cheese_N = nLukko "juusto" ; + 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 = mk3N "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" "lapsena" "lasta" "lapseen" "lapsina" "lapsissa" "lasten" "lapsia" "lapsiin" ; - church_N = nLukko "kirkko" ; - city_N = regN "kaupunki" ; - clean_A = regA "puhdas" ; - clever_A = regA "viisas" ; - close_V2 = dirV2 (regV "sulkea") ; - coat_N = regN "takki" ; - cold_A = mkADeg (nLukko "kylmä") "kylmempi" "kylmin" ; - come_V = regV "tulla" ; - computer_N = regN "tietokone" ; - country_N = regN "maa" ; - cousin_N = nLukko "serkku" ; - cow_N = nLukko "lehmä" ; - die_V = regV "kuolla" ; - dirty_A = mkADeg (regN "likainen") "likaisempi" "likaisin" ; - distance_N3 = mkN3 (regN "etäisyys") (casePrep elative) (casePrep illative) ; - doctor_N = reg2N "tohtori" "tohtoreita" ; - dog_N = nLukko "koira" ; - door_N = nArpi "ovi" ; - drink_V2 = dirV2 (regV "juoda") ; - easy_A2V = mkA2V (mkADeg (nLukko "helppo") "helpompi" "helpoin") + church_N = mkN "kirkko" ; + city_N = mkN "kaupunki" ; + clean_A = mkA "puhdas" ; + clever_A = mkA "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 = dirV2 (regV "syödä") ; - empty_A = mkADeg (nLukko "tyhjä") "tyhjempi" "tyhjin" ; - enemy_N = regN "vihollinen" ; - factory_N = regN "tehdas" ; - father_N2 = genN2 (nLukko "isä") ; - fear_VS = mkVS (reg2V "pelätä" "pelkäsi") ; - find_V2 = dirV2 (reg2V "löytää" "löysi") ; - fish_N = nLukko "kala" ; - floor_N = reg2N "lattia" "lattioita" ; - forget_V2 = dirV2 (regV "unohtaa") ; - fridge_N = regN "jääkaappi" ; - friend_N = nLukko "ystävä" ; - fruit_N = nLukko "hedelmä" ; - fun_AV = mkAV (mkADeg (nLukko "hauska") "hauskempi" "hauskin") ; - garden_N = nKukko "puutarha" "puutarhan" "puutarhoja" ; - girl_N = nLukko "tyttö" ; - glove_N = regN "käsine" ; - gold_N = nLukko "kulta" ; - good_A = mkADeg (nLukko "hyvä") "parempi" "parhain" ; --- paras - go_V = regV "mennä" ; - green_A = mkADeg (regN "vihreä") "vihreämpi" "vihrein" ; - harbour_N = nKukko "satama" "sataman" "satamia" ; - hate_V2 = mkV2 (regV "vihata") cpartitive ; - hat_N = nLukko "hattu" ; - have_V2 = dirV2 (caseV adessive vOlla) ; - hear_V2 = dirV2 (regV "kuulla") ; - hill_N = nLukko "kukkula" ; - hope_VS = mkVS (regV "toivoa") ; - horse_N = regN "hevonen" ; - hot_A = mkADeg (nLukko "kuuma") "kuumempi" "kuumin" ; - house_N = nLukko "talo" ; - important_A = mkADeg (regN "tärkeä") "tärkeämpi" "tärkein" ; - industry_N = regN "teollisuus" ; - iron_N = nLukko "rauta" ; - king_N = regN "kuningas" ; - know_V2 = dirV2 (reg2V "tietää" "tiesi") ; --- tuntea; gives tietänyt - lake_N = nSylki "järvi" ; - lamp_N = nLukko "lamppu" ; + 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 = - dirV2 (mk12V "oppia" "oppii" "opin" "oppivat" "oppikaa" "opitaan" + mkV2 (mk12V "oppia" "oppii" "opin" "oppivat" "oppikaa" "opitaan" "oppi" "opin" "oppisi" "oppinut" "opittu" "opitun") ; - leather_N = nLukko "nahka" ; --- nahan - leave_V2 = dirV2 (regV "jättää") ; - like_V2 = caseV2 (regV "pitää") elative ; - listen_V2 = caseV2 (reg3V "kuunnella" "kuuntelen" "kuunteli") partitive ; - live_V = regV "elää" ; - long_A = mkADeg (nLukko "pitkä") "pitempi" "pisin" ; - lose_V2 = dirV2 (regV "hävitä") ; --- hukata - love_N = reg3N "rakkaus" "rakkauden" "rakkauksia" ; - love_V2 = caseV2 (regV "rakastaa") partitive ; + leather_N = mkN "nahka" ; --- nahan + leave_V2 = mkV2 (mkV "jättää") ; + like_V2 = mkV2 (mkV "pitää") elative ; + listen_V2 = mkV2 (mkV "kuunnella" "kuuntelen" "kuunteli") partitive ; + live_V = mkV "elää" ; + long_A = mkA (mkN "pitkä") "pitempi" "pisin" ; + lose_V2 = mkV2 (mkV "hävitä") ; --- hukata + love_N = mk3N "rakkaus" "rakkauden" "rakkauksia" ; + love_V2 = mkV2 (mkV "rakastaa") partitive ; man_N = mkN "mies" "miehen" "miehenä" "miestä" "mieheen" "miehinä" "miehissä" "miesten" "miehiä" "miehiin" ; - married_A2 = - mkA2 (mkA (nRae "avioitunut" "avioituneena")) (postPrep genitive "kanssa") ; - meat_N = nLukko "liha" ; - milk_N = nLukko "maito" ; - moon_N = regN "kuu" ; - mother_N2 = genN2 (regN "äiti") ; - mountain_N = nArpi "vuori" ; - music_N = regN "musiikki" ; - narrow_A = mkADeg (regN "kapea") "kapeampi" "kapein" ; - new_A = mkADeg (reg3N "uusi" "uuden" "uusia") "uudempi" "uusin" ; - newspaper_N = nSylki "sanomalehti" ; --- for correct vowel harmony - oil_N = nLukko "öljy" ; - old_A = mkADeg (nLukko "vanha") "vanhempi" "vanhin" ; - open_V2 = dirV2 (regV "avata") ; - paint_V2A = mkV2A (regV "maalata") accPrep (casePrep translative) ; - paper_N = reg2N "paperi" "papereita" ; - paris_PN = mkPN (regN "Pariisi") ; - peace_N = nLukko "rauha" ; - pen_N = nLukko "kynä" ; - planet_N = nLukko "planeetta" ; - plastic_N = regN "muovi" ; - play_V2 = mkV2 (regV "pelata") cpartitive ; --- leikkiä, soittaa - policeman_N = regN "poliisi" ; - priest_N = regN "pappi" ; + 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") ; + 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 - (mkADeg (nNainen "todennäköistä") "tonennäköisempi" "todennälöisin") ; - queen_N = regN "kuningatar" ; - radio_N = reg2N "radio" "radioita" ; - rain_V0 = mkV0 (reg2V "sataa" "satoi") ; - read_V2 = dirV2 (regV "lukea") ; - red_A = regA "punainen" ; - religion_N = nLukko "uskonto" ; - restaurant_N = nLukko "ravintola" ; - river_N = nArpi "joki" ; - rock_N = reg2N "kallio" "kallioita" ; - roof_N = nLukko "katto" ; - rubber_N = regN "kumi" ; - run_V = reg2V "juosta" "juoksi" ; - say_VS = mkVS (regV "sanoa") ; - school_N = nLukko "koulu" ; - science_N = regN "tiede" ; - sea_N = nMeri "meri" ; - seek_V2 = mkV2 (regV "etsiä") cpartitive ; - see_V2 = dirV2 ( + (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äkee" "näen" "näkevät" "nähkää" "nähdään" "näki" "näin" "näkisi" "nähnyt" "nähty" "nähdyn") ; - sell_V3 = dirV3 (regV "myydä") allative ; - send_V3 = dirV3 (regV "lähettää") allative ; - sheep_N = regN "lammas" ; - ship_N = nLukko "laiva" ; - shirt_N = nLukko "paita" ; - shoe_N = nLukko "kenkä" ; - shop_N = nLukko "kauppa" ; - short_A = regA "lyhyt" ; - silver_N = regN "hopea" ; - sister_N = nLukko "sisko" ; - sleep_V = regV "nukkua" ; - small_A = mkADeg (reg2N "pieni" "pieniä") "pienempi" "pienin" ; - snake_N = regN "käärme" ; - sock_N = nLukko "sukka" ; - speak_V2 = mkV2 (regV "puhua") cpartitive ; - star_N = nSylki "tähti" ; - steel_N = regN "teräs" ; - stone_N = nSylki "kivi" ; - stove_N = reg3N "liesi" "lieden" "liesiä" ; - student_N = reg2N "opiskelija" "opiskelijoita" ; - stupid_A = regA "tyhmä" ; - sun_N = nLukko "aurinko" ; - switch8off_V2 = dirV2 (regV "sammuttaa") ; --- - switch8on_V2 = dirV2 (regV "sytyttää") ; --- - table_N = nLukko "pöytä" ; - talk_V3 = mkV3 (regV "puhua") (casePrep allative) (casePrep elative) ; - teacher_N = nLukko "opettaja" ; - teach_V2 = dirV2 (regV "opettaa") ; - television_N = reg2N "televisio" "televisioita" ; - thick_A = regA "paksu" ; - thin_A = regA "ohut" ; - train_N = nLukko "juna" ; - travel_V = regV "matkustaa" ; - tree_N = regN "puu" ; - ---- trousers_N = regN "trousers" ; - ugly_A = mkADeg (nLukko "ruma") "rumempi" "rumin" ; - understand_V2 = dirV2 (reg3V "ymmärtää" "ymmärrän" "ymmärsi") ; - university_N = nLukko "yliopisto" ; - village_N = nLukko "kylä" ; - wait_V2 = caseV2 (regV "odottaa") partitive ; - walk_V = regV "kävellä" ; - warm_A = mkADeg + 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 "lyhyt" ; + 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 "ohut" ; + 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ä" ; + 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 = nLukko "sota" ; - watch_V2 = mkV2 (regV "katsella") cpartitive ; - water_N = reg3N "vesi" "veden" "vesiä" ; - white_A = regA "valkoinen" ; - window_N = reg2N "ikkuna" "ikkunoita" ; - wine_N = regN "viini" ; - win_V2 = dirV2 (regV "voittaa") ; - woman_N = regN "nainen" ; - wonder_VQ = mkVQ (regV "ihmetellä") ; - wood_N = regN "puu" ; - write_V2 = dirV2 (regV "kirjoittaa") ; - yellow_A = regA "keltainen" ; - young_A = mkADeg (nArpi "nuori") "nuorempi" "nuorin" ; + 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 = dirV2 ( + do_V2 = mkV2 ( mk12V "tehdä" "tekee" "teen" "tekevät" "tehkää" "tehdään" "teki" "tein" "tekisi" "tehnyt" "tehty" "tehdyn") ; now_Adv = mkAdv "nyt" ; already_Adv = mkAdv "jo" ; - song_N = nLukko "laulu" ; - add_V3 = dirV3 (regV "lisätä") illative ; - number_N = reg2N "numero" "numeroita" ; - put_V2 = dirV2 (regV "panna") ; - stop_V = regV "pysähtyä" ; - jump_V = regV "hypätä" ; - left_Ord = mkOrd (regN "vasen") ; - right_Ord = mkOrd (regN "oikea") ; + 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 = regA "oikea" ; - dry_A = mkADeg (regN "kuiva") "kuivempi" "kuivin" ; - dull_A = mkADeg (regN "tylsä") "tylsempi" "tylsin" ; - full_A = mkADeg (reg3N "täysi" "täyden" "täysiä") "täydempi" "täysin" ; - heavy_A = regA "raskas" ; - near_A = regA "läheinen" ; - rotten_A = regA "mätä" ; - round_A = regA "pyöreä" ; - sharp_A = regA "terävä" ; - smooth_A = regA "sileä" ; - straight_A = mkADeg (regN "suora") "suorempi" "suorin" ; - wet_A = mkADeg (regN "märkä") "märempi" "märin" ; - wide_A = regA "leveä" ; - animal_N = reg3N "eläin" "eläimen" "eläimiä" ; - ashes_N = regN "tuhka" ; - back_N = regN "selkä" ; - bark_N = regN "kaarna" ; - belly_N = regN "vatsa" ; - blood_N = nMeri "veri" ; - bone_N = regN "luu" ; - breast_N = regN "rinta" ; - cloud_N = reg2N "pilvi" "pilviä" ; - day_N = regN "päivä" ; - dust_N = regN "pöly" ; - ear_N = regN "korva" ; - earth_N = regN "maa" ; - egg_N = regN "muna" ; - eye_N = regN "silmä" ; - fat_N = regN "rasva" ; - feather_N = reg3N "höyhen" "höyhenen" "höyheniä" ; - fingernail_N = reg3N "kynsi" "kynnen" "kynsiä" ; - fire_N = reg2N "tuli" "tulia" ; - flower_N = regN "kukka" ; - fog_N = regN "sumu" ; - foot_N = regN "jalka" ; - forest_N = regN "metsä" ; - grass_N = regN "ruoho" ; - guts_N = regN "sisälmys" ; --- suoli - hair_N = regN "hius" ; - hand_N = reg3N "käsi" "käden" "käsiä" ; - head_N = regN "pää" ; - heart_N = reg3N "sydän" "sydämen" "sydämiä" ; - horn_N = reg2N "sarvi" "sarvia" ; + 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 "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 = mk3N "sydän" "sydämen" "sydämiä" ; + horn_N = mk2N "sarvi" "sarvia" ; husband_N = mkN "mies" "miehen" "miehenä" "miestä" "mieheen" "miehinä" "miehissä" "miesten" "miehiä" "miehiin" ; - ice_N = regN "jää" ; - knee_N = reg2N "polvi" "polvia" ; - leaf_N = reg2N "lehti" "lehtiä" ; - leg_N = regN "jalka" ; --- sääri - liver_N = regN "maksa" ; - louse_N = regN "lude" ; - mouth_N = regN "suu" ; - name_N = reg2N "nimi" "nimiä" ; - neck_N = regN "niska" ; - night_N = regN "yö" ; - nose_N = regN "nenä" ; - person_N = regN "henkilö" ; - rain_N = regN "sade" ; - road_N = regN "tie" ; - root_N = reg2N "juuri" "juuria" ; - rope_N = reg3N "köysi" "köyden" "köysiä" ; - salt_N = regN "suola" ; - sand_N = regN "hiekka" ; - seed_N = regN "siemen" ; - skin_N = regN "nahka" ; - sky_N = reg3N "taivas" "taivaan" "taivaita" ; - smoke_N = regN "savu" ; - snow_N = sgpartN (nMeri "lumi") "lunta" ; - stick_N = regN "keppi" ; - tail_N = regN "häntä" ; - tongue_N = reg2N "kieli" "kieliä" ; - tooth_N = regN "hammas" ; - wife_N = regN "vaimo" ; - wind_N = reg2N "tuuli" "tuulia" ; - wing_N = reg2N "siipi" "siipiä" ; - worm_N = regN "mato" ; - year_N = reg3N "vuosi" "vuoden" "vuosia" ; - bite_V2 = dirV2 (regV "purra") ; - blow_V = regV "puhaltaa" ; - burn_V = regV "palaa" ; - count_V2 = dirV2 (regV "laskea") ; - cut_V2 = dirV2 (reg2V "leikata" "leikkasi") ; - dig_V = regV "kaivaa" ; - fall_V = reg3V "pudota" "putoan" "putosi" ; - fear_V2 = mkV2 (reg3V "pelätä" "pelkään" "pelkäsi") cpartitive ; - fight_V2 = mkV2 (regV "taistella") (postPrep partitive "vastaan") ; - float_V = regV "kellua" ; - flow_V = reg3V "virrata" "virtaan" "virtasi" ; - fly_V = regV "lentää" ; - freeze_V = regV "jäätyä" ; - give_V3 = dirdirV3 (reg3V "antaa" "annan" "antoi") ; - hit_V2 = mkV2 (regV "lyödä") cpartitive ; - hold_V2 = mkV2 (regV "pitää") cpartitive ; - hunt_V2 = mkV2 (regV "metsästää") cpartitive ; - kill_V2 = dirV2 (regV "tappaa") ; - laugh_V = reg3V "nauraa" "nauran" "nauroi" ; - lie_V = reg3V "maata" "makaan" "makasi" ; - play_V = regV "pelata" ; - pull_V2 = dirV2 (regV "vetää") ; - push_V2 = dirV2 (regV "työntää") ; - rub_V2 = mkV2 (regV "hieroa") cpartitive ; - scratch_V2 = mkV2 (regV "raapia") cpartitive ; - sew_V = regV "kylvää" ; - sing_V = regV "laulaa" ; - sit_V = regV "istua" ; - smell_V = reg2V "haistaa" "haistoi" ; - spit_V = regV "sylkeä" ; - split_V2 = dirV2 (reg2V "halkaista" "halkaisi") ; - squeeze_V2 = mkV2 (regV "puristaa") cpartitive ; - stab_V2 = mkV2 (regV "pistää") cpartitive ; + 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" "nauran" "nauroi" ; + lie_V = mkV "maata" "makaan" "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ä" "seisoo" "seison" "seisovat" "seiskää" "seistään" "seisoi" "seisoin" "seisoisi" "seissyt" "seisty" "seistyn" ; --- *seisoivät - suck_V2 = mkV2 (regV "imeä") cpartitive ; + suck_V2 = mkV2 (mkV "imeä") cpartitive ; swell_V = mk12V "turvota" "turpoaa" "turpoan" "turpoavat" "turvotkaa" "turvotaan" "turposi" "turposin" "turpoaisi" "turvonnut" "turvottu" "turvotun" ; - swim_V = reg3V "uida" "uin" "ui" ; - think_V = reg3V "ajatella" "ajattelen" "ajatteli" ; - throw_V2 = dirV2 (regV "heittää") ; - tie_V2 = dirV2 (regV "sitoa") ; - turn_V = regV "kääntyä" ; - vomit_V = regV "oksentaa" ; - wash_V2 = dirV2 (regV "pestä") ; - wipe_V2 = dirV2 (regV "pyyhkiä") ; + 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 = regV "hengittää" ; + breathe_V = mkV "hengittää" ; - grammar_N = regN "kielioppi" ; - language_N = reg2N "kieli" "kieliä" ; - rule_N = regN "sääntö" ; + grammar_N = mkN "kielioppi" ; + language_N = mk2N "kieli" "kieliä" ; + rule_N = mkN "sääntö" ; - john_PN = regPN "Jussi" ; - question_N = regN "kysymys" ; - ready_A = regA "valmis" ; - reason_N = regN "syy" ; + john_PN = mkPN "Jussi" ; + question_N = mkN "kysymys" ; + ready_A = mkA "valmis" ; + reason_N = mkN "syy" ; today_Adv = mkAdv "tänään" ; - uncertain_A = regA "epävarma" ; + uncertain_A = mkA "epävarma" ; oper mkOrd : N -> Ord ; diff --git a/lib/resource/finnish/MorphoFin.gf b/lib/resource/finnish/MorphoFin.gf index 08f8ab513..6c918af7c 100644 --- a/lib/resource/finnish/MorphoFin.gf +++ b/lib/resource/finnish/MorphoFin.gf @@ -1,4 +1,4 @@ ---# -path=.:../../prelude +--# -path=.:../common:prelude --1 A Simple Finnish Resource Morphology -- @@ -12,421 +12,748 @@ resource MorphoFin = ResFin ** open Prelude in { flags optimize=all ; ---- flags optimize=noexpand ; + oper ---2 Nouns --- - -oper - - --- A user-friendly variant takes existing forms and infers the vowel harmony. - - mkNoun : (_,_,_,_,_,_,_,_,_,_ : Str) -> CommonNoun = - \talo,talon,talona,taloa,taloon,taloina,taloissa,talojen,taloja,taloihin -> - nhn (mkSubst (ifTok Str (Predef.dp 1 talona) "a" "a" "ä") - talo (Predef.tk 1 talon) (Predef.tk 2 talona) taloa taloon - (Predef.tk 2 taloina) (Predef.tk 3 taloissa) talojen taloja taloihin) ; - - --- Here some useful special cases; more are given in $ParadigmsFin.gf$. --- - - sLukko : Str -> NounH = \lukko -> - let - o = last lukko ; - lukk = init lukko ; - a = getHarmony o ; - lukkoja = case o of { - "a" => lukk + if_then_Str (pbool2bool (Predef.occurs "ou" lukk)) "ia" "oja" ; - "ä" => lukk + "iä" ; - _ => lukko + "j" + a - } - in - sKukko lukko (weakGrade lukko + "n") lukkoja ; - --- The special case with no alternations. - - sTalo : Str -> NounH = sLukko ; - - sBaari : Str -> NounH = \baaria -> + dLujuus : Str -> NForms = \lujuus -> let - baari = Predef.tk 1 baaria ; - baar = Predef.tk 1 baari ; - a = getHarmony (Predef.dp 1 baaria) - in - sKukko baari (weakGrade baari + "n") (baar + ("ej" + a)) ; + 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") ; - sKorpi : (_,_,_ : Str) -> NounH = \korpi,korven,korpena -> + 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 = Predef.dp 1 korpena ; - korpe = Predef.tk 2 korpena ; - korp = init korpi ; - korpea = case last korp of { - "r" | "l" | "n" => korp + "t" + a ; - _ => korpe + a - } ; - korve = Predef.tk 1 korven ; - korvi = Predef.tk 1 korve + "i" ; - korpien = case last korp of { - "r" | "l" | "n" => korp + "ten" ; - _ => korpi + "en" - } ; - in - mkSubst a - korpi - korve - korpe - korpea - (korpe + "en") - korpi - korvi - korpien - (korpi + a) - (korpi + "in") ; + 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") ; - sArpi : Str -> NounH = \arpi -> - sKorpi arpi (init (weakGrade arpi) + "en") (init arpi + "ena") ; - sSylki : Str -> NounH = \sylki -> - sKorpi sylki (init (weakGrade sylki) + "en") (init sylki + "enä") ; - - sKoira : Str -> NounH = \koira -> - let a = getHarmony (last koira) in - sKukko koira (koira + "n") (init koira + "i" + a) ; - --- Loan words ending in consonants are actually similar to words like --- "malli"/"mallin"/"malleja", with the exception that the "i" is not attached --- to the singular nominative. - - sLinux : Str -> NounH = \linuxia -> - let { - linux = Predef.tk 2 linuxia ; - a = getHarmony (Predef.dp 1 linuxia) ; - linuxi = linux + "i" - } in - mkSubst a - linux - linuxi - linuxi - (linuxi + a) - (linuxi + "in") - (linux + "ei") - (linux + "ei") - (linux + "ien") - (linux + "ej" + a) - (linux + "eihin") ; - --- Nouns of at least 3 syllables ending with "a" or "ä", like "peruna", "rytinä". - - sPeruna : Str -> NounH = \peruna -> - let { - a = Predef.dp 1 peruna ; - perun = Predef.tk 1 peruna ; - perunoi = perun + (ifTok Str a "a" "o" "ö" + "i") - } - in - mkSubst a - peruna - peruna - peruna - (peruna + a) - (peruna + a + "n") - perunoi - perunoi - (perunoi + "den") - (perunoi + ("t" + a)) - (perunoi + "hin") ; - - sTohtori : Str -> NounH = \tohtoria -> + dPuu : Str -> NForms = \puu -> let - a = last tohtoria ; - tohtori = init tohtoria ; - tohtorei = init tohtori + "ei" ; - in - mkSubst a - tohtori - tohtori - tohtori - tohtoria - (tohtori + "in") - tohtorei - tohtorei - (tohtorei + "den") - (tohtorei + "t" + a) - (tohtorei + "hin") ; + 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") ; - sRadio : Str -> NounH = \radio -> + dSuo : Str -> NForms = \suo -> let - o = last radio ; - a = getHarmony o ; - radioi = radio + "i" ; - in - mkSubst a - radio - radio - radio - (radio + "t" + a) - (radio + o + "n") - radioi - radioi - (radioi + "den") - (radioi + "t" + a) - (radioi + "hin") ; + 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") ; - - sSusi : (_,_,_ : Str) -> NounH = \susi,suden,sutena -> + dKorkea : Str -> NForms = \korkea -> let - a = Predef.dp 1 sutena ; - sude = Predef.tk 1 suden ; - sute = Predef.tk 2 sutena ; - sutt = Predef.tk 1 sute + "t" - in - mkSubst a - susi - sude - sute - (sutt + a) - (sute + "en") - susi - susi - (sutt + "en") --- var susi + "en" bad with suuri - (susi + a) - (susi + "in") ; + 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 - sPuu : Str -> NounH = \puu -> - let { - u = Predef.dp 1 puu ; - a = getHarmony u ; - pu = Predef.tk 1 puu ; - pui = pu + "i" - } - in - mkSubst a - puu - puu - puu - (puu + ("t" + a)) - (puu + ("h" + u + "n")) - pui - pui - (pui + "den") - (pui + ("t" + a)) - (pui + "hin") ; - - sSuo : Str -> NounH = \suo -> - let { - o = Predef.dp 1 suo ; - a = getHarmony o ; - soi = Predef.tk 2 suo + (o + "i") - } - in - mkSubst a - suo - suo - suo - (suo + ("t" + a)) - (suo + ("h" + o + "n")) - soi - soi - (soi + "den") - (soi + ("t" + a)) - (soi + "hin") ; - --- Here in fact it is handy to use the partitive form as the only stem. - - sNainen : Str -> NounH = \naista -> - let { - nainen = Predef.tk 3 naista + "nen" ; - nais = Predef.tk 2 naista ; - naise = nais + "e" ; - naisi = nais + "i" ; - a = Predef.dp 1 naista - } - in - mkSubst a - nainen - naise - naise - (nais + ("t" + a)) - (nais + "een") - naisi - naisi - (nais + "ten") - (nais + ("i" + a)) - (nais + "iin") ; - --- The following covers: "tilaus", "kaulin", "paimen", "laidun", "sammal", --- "kyynel" (excep $Sg Iness$ for the last two?). - - sTilaus : (_,_ : Str) -> NounH = \tilaus, tilauksena -> - let { - tilauks = Predef.tk 3 tilauksena ; - tilaukse = tilauks + "e" ; - tilauksi = tilauks + "i" ; - a = Predef.dp 1 tilauksena - } - in - mkSubst a - tilaus - tilaukse - tilaukse - (tilaus + ("t" + a)) - (tilauks + "een") - tilauksi - tilauksi - (tilaus + "ten") - (tilauks + ("i" + a)) - (tilauks + "iin") ; - --- Some words have the three grades ("rakkaus","rakkauden","rakkautena"), which --- are however derivable from the stem. - - sRakkaus : Str -> NounH = \rakkaus -> - let { - rakkau = Predef.tk 1 rakkaus ; - rakkaut = rakkau + "t" ; - rakkaute = rakkau + "te" ; - rakkaude = rakkau + "de" ; - rakkauksi = rakkau + "ksi" ; - u = Predef.dp 1 rakkau ; - a = ifTok Str u "u" "a" "ä" - } - in - mkSubst a - rakkaus - rakkaude - rakkaute - (rakkaut + ("t" + a)) - (rakkaut + "een") - rakkauksi - rakkauksi - (rakkauksi + "en") - (rakkauksi + a) - (rakkauksi + "in") ; - --- The following covers nouns like "nauris" and adjectives like "kallis", "tyyris". - - sNauris : (_ : Str) -> NounH = \naurista -> - let { - a = Predef.dp 1 naurista ; - nauris = Predef.tk 2 naurista ; - nauri = Predef.tk 3 naurista ; - i = Predef.dp 1 nauri ; - naurii = nauri + i ; - naurei = nauri + "i" - } - in - mkSubst a - nauris - naurii - naurii - (nauris + ("t" + a)) - (naurii + "seen") - naurei - naurei - (naurei + "den") - (naurei + ("t" + a)) - (naurei + "siin") ; - --- Words of the form "siitin", "avain", "höyhen" (w or wo grade alternation). - - sLiitin : Str -> Str -> NounH = \liitin,liittimen -> + dKaunis : Str -> NForms = \kaunis -> let - liittime = init liittimen ; - liitti = Predef.tk 2 liittime ; - m = last (init liittime) ; - liittimi = liitti + m + "i" ; - a = vowelHarmony liitin ; - in - mkSubst a - liitin - liittime - liittime - (liitin + "t" + a) - (liittime + "en") - (liittimi) - (liittimi) - (liittimi + "en") - (liittimi + a) - (liittimi + "in") ; + 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") ; --- The following covers adjectives like "kapea", "leveä". - - sKapea : (_ : Str) -> NounH = \kapea -> + dLiitin : (_,_ : Str) -> NForms = \liitin,liittimen -> let - a = last kapea ; - kape = init kapea ; - kapei = kape + "i" + 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 - mkSubst a - kapea - kapea - kapea - (kapea + a) - (kapea + a+"n") - kapei - kapei - (kapei + "den") - (kapei + ("t" + a)) - (kapei + "siin") ; + nForms10 + nukke nuken (nukke + a) (nukk +"en" + a) (nukk + "een") + (nukk + "ien") (nukk + "ej" + a) (nukk + "ein" + a) + (nuke + "iss" + a) (nukk + "eihin") ; --- The following two are used for adjective comparison. + 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") ; - sSuurempi : Str -> NounH = \suurempaa -> - let { - a = Predef.dp 1 suurempaa ; - suure = Predef.tk 4 suurempaa ; - suurempi = suure + "mpi" ; - suurempa = suure + ("mp" + a) ; - suuremm = suure + "mm" - } - in - mkSubst a - suurempi - (suuremm + a) - suurempa - (suurempa + a) - (suurempa + (a + "n")) - suurempi - (suuremm + "i") - (suurempi + "en") - (suurempi + a) - (suurempi + "in") ; + 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) ; - sSuurin : Str -> NounH = \suurinta -> - let { - a = Predef.dp 1 suurinta ; - suuri = Predef.tk 3 suurinta ; - suurin = suuri + "n" ; - suurimma = suuri + ("mm" + a) ; - suurimpa = suuri + ("mp" + a) ; - suurimpi = suuri + "mpi" ; - suurimmi = suuri + "mmi" - } - in - mkSubst a - suurin - suurimma - suurimpa - (suurin + ("t" + a)) - (suurimpa + (a + "n")) - suurimpi - suurimmi - (suurimpi + "en") - (suurimpi + a) - (suurimpi + "in") ; +-- for adjective comparison --- This auxiliary resolves vowel harmony from a given letter. + 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") ; -getHarmony : Str -> Str = \u -> case u of { - "a"|"o"|"u" => "a" ; - _ => "ä" + 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 } ; --- This function inspects the whole word. +-- Adjective forms -vowelHarmony : Str -> Str = \liitin -> - if_then_Str (pbool2bool (Predef.occurs "aou" liitin)) "a" "ä" ; + 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 @@ -460,69 +787,60 @@ vowelHarmony : Str -> Str = \liitin -> _ => kukko } ; ---- This is only used to analyse nouns "rae", "hake", etc. +-- This is used to analyse nouns "rae", "hake", "rengas", "laidun", etc. - strongGrade : Str -> Str = \hake -> + strongGrade : Str -> Str = \hanke -> let - ha = Predef.tk 2 hake ; - e = last hake ; - hak = init hake ; - hd = Predef.dp 2 hak - in - case hd of { - "ng" => ha + "k" ; - "nn" => ha + "t" ; - "mm" => ha + "p" ; - "rr" | "ll" => ha + "t" ; - "hj" | "lj" => ha + "k" ; -- pohje/lahje impossible - "hk" | "sk" | "sp" | "st" => hak ; - _ + "k" => ha + "kk" ; - _ + "p" => ha + "pp" ; - _ + "t" => ha + "tt" ; - _ + "d" => ha + "t" ; - _ + ("a" | "ä") => hak + "k" ; -- säe, tae - _ + "v" => ha + "p" ; -- rove/hyve impossible - _ => hak - } + e ; + 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 + } ; ---3 Proper names --- --- Proper names are similar to common nouns in the singular. - - ProperName = {s : Case => Str} ; - - mkProperName : CommonNoun -> ProperName = \jussi -> - {s = \\c => jussi.s ! NCase Sg c} ; - --- An ending given to a symbol cannot really be decided --- independently. The string $a$ gives the vowel harmony. --- Only some South-West dialects have the generally valid --- Illative form. - - caseEnding : Str -> Case -> Str = \a,c -> case c of { - Nom => [] ; - Gen => "n" ; - Part => a ; --- - Transl => "ksi" ; - Ess => "n" + a ; - Iness => "ss" + a ; - Elat => "st" + a ; - Illat => "sse" ; --- - Adess => "ll" + a ; - Ablat => "lt" + a ; - Allat => "lle" ; - Abess => "tt" + a + vowHarmony : Str -> Str = \s -> case s of { + _ + ("a" | "o" | "u") + _ => "a" ; + _ => "ä" } ; - symbProperName : Str -> ProperName = \x -> - {s = table { - Nom => x ; - c => glue x (":" + caseEnding "a" c) - } + 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? } ; ---2 Pronouns --- -- Here we define personal and relative pronouns. mkPronoun : (_,_,_,_,_ : Str) -> Number -> Person -> @@ -562,41 +880,13 @@ vowelHarmony : Str -> Str = \liitin -> a = pro.a } ; --- Determiners - - 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? - } ; - - mkQuant : CommonNoun -> { - s1 : Number => Case => Str ; - s2 : Str ; - isPoss, isDef : Bool - } = \noun -> { - s1 = \\n,c => noun.s ! NCase n c ; - s2 = [] ; - isPoss = False ; - isDef = True --- does this hold for all new dets? - } ; - -- 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 = nhn (sSuo "jo")} in + let {jo = nForms2N (dSuo "jo")} in table { Sg => table { Nom => "joka" ; @@ -608,293 +898,7 @@ oper c => "j" + (jo.s ! NCase Pl c) } } ; - -caseTable : Number -> CommonNoun -> Case => Str = \n,cn -> - \\c => cn.s ! NCase n c ; - - ---2 Adjectives --- - - --- For the comparison of adjectives, three noun declensions --- are needed in the worst case. - - mkAdjective : (_,_,_ : Adj) -> Adjective = \hyva,parempi,paras -> - {s = table { - Posit => hyva.s ; - Compar => parempi.s ; - Superl => paras.s - } - } ; - --- However, it is usually enough to give the positive declension and --- the characteristic forms of comparative and superlative. - - regAdjective : CommonNoun -> Str -> Str -> Adjective = \kiva, kivempaa, kivinta -> - mkAdjective - (noun2adj kiva) - (noun2adjComp False (nhn (sSuurempi kivempaa))) - (noun2adjComp False (nhn (sSuurin kivinta))) ; - - - - regVerbH : Str -> VerbH = \soutaa -> - let - taa = Predef.dp 3 soutaa ; - juo = Predef.tk 2 soutaa ; - souda = weakGrade (init soutaa) ; - soudan = juo + "en" ; - o = Predef.dp 1 juo ; - a = last soutaa ; - u = ifTok Str a "a" "u" "y" ; - joi = Predef.tk 2 juo + (o + "i") - in - case taa of { - "it" + _ => vHarkita soutaa ; - ("st" | "nn" | "rr" | "ll") + _ => - vJuosta soutaa soudan (juo + o+u+"t") (juo + "t"+u) ; - _ + ("aa" | "ää") => vOttaa soutaa (souda + "n") ; - ("o" | "u" | "y" | "ö") + ("da" | "dä") => vJuoda soutaa joi ; - ("ata" | "ätä") => vOsata soutaa ; - _ => vHukkua soutaa souda - } ; - - reg2VerbH : (soutaa,souti : Str) -> VerbH = \soutaa,souti -> - let - soudan = weakGrade (init soutaa) + "n" ; - soudin = weakGrade souti + "n" ; - souden = init souti + "en" ; - juo = Predef.tk 2 soutaa ; - o = Predef.dp 1 juo ; - u = ifTok Str (last soutaa) "a" "u" "y" ; - taa = Predef.dp 3 soutaa ; - in - case taa of { - "taa" | "tää" => vHuoltaa soutaa soudan souti soudin ; - "ata" | "ätä" => vPalkata soutaa souti ; - "ota" | "ötä" => vPudota soutaa souti ; - "sta" | "stä" => vJuosta soutaa souden (juo + o+u+"t") (juo + "t"+u) ; - _ + ("da" | "dä") => vJuoda soutaa souti ; - _ => regVerbH soutaa - } ; - - reg3VerbH : (_,_,_ : Str) -> VerbH = \soutaa,soudan,souti -> - let - taa = Predef.dp 3 soutaa ; - souda = init soudan ; - juo = Predef.tk 2 soutaa ; - o = last juo ; - a = last taa ; - u = ifTok Str a "a" "u" "y" ; - soudin = weakGrade (init souti) + "in" ; - in case taa of { - "lla" | "llä" => vJuosta soutaa soudan (juo + o+u+"t") (juo + "t"+u) ; - "taa" | "tää" => vHuoltaa soutaa soudan souti soudin ; - _ => reg2VerbH soutaa souti - } ; - --- For "harppoa", "hukkua", "löytyä", with grade alternation. - - vHukkua : (_,_ : Str) -> VerbH = \hukkua,huku -> - let { - a = Predef.dp 1 hukkua ; - hukku = Predef.tk 1 hukkua ; - u = Predef.dp 1 huku ; - i = case u of { - "e" | "i" => [] ; - _ => u - } ; - y = case a of { - "a" => "u" ; - _ => "y" - } ; - hukkui = init hukku + i + "i" ; - hukui = init huku + i + "i" ; - } in - mkVerbH - hukkua - (hukku + u) - (huku + "n") - (hukku + "v" + a + "t") - (hukku + (("k" + a) + a)) - (huku + ((("t" + a) + a) + "n")) - (hukkui) - (hukui + "n") - (hukkui + "si") - (hukku + "n" + y + "t") - (huku + "tt" + y) - (huku + "t" + y + "t") ; - --- For cases with or without alternation: "sanoa", "valua", "kysyä". - - vSanoa : Str -> VerbH = \sanoa -> - vHukkua sanoa (Predef.tk 1 sanoa) ; ----- vHukkua sanoa (weakGrade (Predef.tk 1 sanoa)) ; ----- The gfr file becomes 6* bigger if this change is done - --- For "ottaa", "käyttää", "löytää", "huoltaa", "hiihtää", "siirtää". - - vHuoltaa : (_,_,_,_ : Str) -> VerbH = \ottaa,otan,otti,otin -> - let { - a = Predef.dp 1 ottaa ; - aa = a + a ; - u = case a of {"a" => "u" ; _ => "y"} ; - ota = Predef.tk 1 otan ; - otta = Predef.tk 1 ottaa ; - ote = Predef.tk 1 ota + "e" - } in - mkVerbH - ottaa - ottaa - otan - (otta + "v" + a + "t") - (otta + "k" + aa) - (ote + "t" + aa + "n") - otti - otin - (otta + "isi") - (otta + "n" + u + "t") - (ote + "tt" + u) - (ote + "t" + u + "n") ; - --- For cases where grade alternation is not affected by the imperfect "i". - - vOttaa : (_,_ : Str) -> VerbH = \ottaa,otan -> - let - i = "i" ; --- wrong rule if_then_Str (pbool2bool (Predef.occurs "ou" ottaa)) "i" "oi" - in - vHuoltaa ottaa otan (Predef.tk 2 ottaa + i) (Predef.tk 2 otan + i + "n") ; - --- For "poistaa", "ryystää". - - vPoistaa : Str -> VerbH = \poistaa -> - vOttaa poistaa ((Predef.tk 1 poistaa + "n")) ; - - --- For "osata", "lisätä"; grade alternation is unpredictable, as seen --- from "pelätä-pelkäsi" vs. "palata-palasi" - - - vOsata : Str -> VerbH = \osata -> - vPalkata osata (Predef.tk 2 osata + "si") ; - - vPalkata : Str -> Str -> VerbH = \palkata,palkkasi -> - let - a = Predef.dp 1 palkata ; - palka = Predef.tk 2 palkata ; - palkka = Predef.tk 2 palkkasi ; - u = case a of {"a" => "u" ; _ => "y"} - in - mkVerbH - palkata - (palkka + a) - (palkka + (a + "n")) - (palkka + (((a + "v") + a) + "t")) - (palka + ((("t" + "k") + a) + a)) - (palkata + (a + "n")) - (palkka + "si") - (palkka + "sin") - (palkka + "isi") - (palka + "nn" + u + "t") - (palka + "tt" + u) - (palka + "t" + u + "n") ; - - vPudota : Str -> Str -> VerbH = \pudota, putosi -> - let - a = Predef.dp 1 pudota ; - pudo = Predef.tk 2 pudota ; - puto = Predef.tk 2 putosi ; - putoa = puto + a ; - u = case a of {"a" => "u" ; _ => "y"} - in - mkVerbH - pudota - (putoa + a) - (putoa + "n") - (putoa + "v" + a + "t") - (pudo + "tk" + a + a) - (pudota + a + "n") - (puto + "si") - (puto + "sin") - (puto + a + "isi") - (pudo + "nn" + u + "t") - (pudo + "tt" + u) - (pudo + "t" + u + "n") ; - - vHarkita : Str -> VerbH = \harkita -> - let - a = Predef.dp 1 harkita ; - harki = Predef.tk 2 harkita ; - harkitse = harki + "tse" ; - harkitsi = harki + "tsi" ; - u = case a of {"a" => "u" ; _ => "y"} - in - mkVerbH - harkita - (harkitse + "e") - (harkitse + "n") - (harkitse + "v" + a + "t") - (harki + "tk"+ a + a) - (harkita + a + "n") - (harkitsi) - (harkitsi + "n") - (harkitsi + "si") - (harki + "nn" + u + "t") - (harki + "tt" + u) - (harki + "t" + u + "n") ; - - ------ tulla,tulee,tulen,tulevat,tulkaa,tullaan,tuli,tulin,tulisi,tullut,tultu,tullun - --- For "juosta", "piestä", "nousta", "rangaista", "kävellä", "surra", "panna". - - vJuosta : (_,_,_,_ : Str) -> VerbH = \juosta,juoksen,juossut,juostu -> - let - a = Predef.dp 1 juosta ; - t = last (init juosta) ; - juokse = Predef.tk 1 juoksen ; - juoksi = Predef.tk 2 juoksen + "i" ; - juos = Predef.tk 2 juosta ; - juostun = ifTok Str t "t" (juostu + "n") (init juossut + "n") ; - in - mkVerbH - juosta - (juokse + "e") - juoksen - (juokse + (("v" + a) + "t")) - (juos + (("k" + a) + a)) - (juosta + (a + "n")) - juoksi - (juoksi + "n") - (juoksi + "si") - juossut - juostu - juostun ; - --- For "juoda", "syödä", "viedä", "naida", "saada". - - vJuoda : (_,_ : Str) -> VerbH = \juoda, joi -> - let - a = Predef.dp 1 juoda ; - juo = Predef.tk 2 juoda ; - u = case a of {"a" => "u" ; _ => "y"} - in - mkVerbH - juoda - juo - (juo + "n") - (juo + (("v" + a) + "t")) - (juo + (("k" + a) + a)) - (juoda + (a + "n")) - joi - (joi + "n") - (joi + "si") - (juo + "n" + u + "t") - (juo + "t" + u) - (juo + "d" + u + "n") ; - -} ; - + ProperName = {s : Case => Str} ; +} diff --git a/lib/resource/finnish/NumeralFin.gf b/lib/resource/finnish/NumeralFin.gf index 6b20fe7a7..2103788ac 100644 --- a/lib/resource/finnish/NumeralFin.gf +++ b/lib/resource/finnish/NumeralFin.gf @@ -20,9 +20,9 @@ lin (nhn (mkSubst "a" "kolme" "kolme" "kolme" "kolmea" "kolmeen" "kolmi" "kolmi" "kolmien" "kolmia" "kolmiin")) (ordN "a" "kolmas") ; - n4 = co (regN "neljä") (ordN "ä" "neljäs") ; - n5 = co (reg3N "viisi" "viiden" "viisiä") (ordN "ä" "viides") ; - n6 = co (reg3N "kuusi" "kuuden" "kuusia") (ordN "a" "kuudes") ; + 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ä" @@ -105,12 +105,12 @@ oper "kymmeneen" "kymmeni" "kymmeni" "kymmenien" "kymmeniä" "kymmeniin")) (ordN "ä" "kymmenes") ; sataN = co - (nhn (sLukko "sata")) + (mkN "sata") (ordN "a" "sadas") ; tuhatN = co - (nhn (mkSubst "a" "tuhat" "tuhanne" "tuhante" "tuhatta" "tuhanteen" - "tuhansi" "tuhansi" "tuhansien" "tuhansia" "tuhansiin")) + (mkN "tuhat" "tuhannen" "tuhatta" "ruhantena" "tuhanteen" + "tuhansien" "tuhansia" "tuhansina" "tuhansissa" "tuhansiin") (ordN "a" "tuhannes") ; kymmentaN = diff --git a/lib/resource/finnish/ParadigmsFin.gf b/lib/resource/finnish/ParadigmsFin.gf index 49a075ee0..2e5763511 100644 --- a/lib/resource/finnish/ParadigmsFin.gf +++ b/lib/resource/finnish/ParadigmsFin.gf @@ -2,14 +2,14 @@ --1 Finnish Lexical Paradigms -- --- Aarne Ranta 2003--2005 +-- 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, $Structural.gf$. +-- 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 @@ -17,10 +17,9 @@ -- than stems, as string arguments of the paradigms. -- -- The structure of functions for each word class $C$ is the following: --- first we give a handful of patterns that aim to cover all --- regular cases. Then we give a worst-case function $mkC$, which serves as an --- escape to construct the most irregular words of type $C$. --- However, this function should only seldom be needed. +-- 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), @@ -82,119 +81,25 @@ oper -- 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 --- "sydän - sydämen - sydämiä", which would otherwise become --- "sydän - sytämen". +-- "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 : (olo,oln,olona,oloa,oloon,oloina,oloissa,olojen,oloja,oloihin : 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 ; } ; - --- Some nouns have an unexpected singular partitive, e.g. "meri", "lumi". - - sgpartN : (meri : N) -> (merta : Str) -> N ; - nMeri : (meri : Str) -> N ; - --- The rest of the noun paradigms are mostly covered by the three --- heuristics. --- --- Nouns with partitive "a","ä" are a large group. --- To determine for grade and vowel alternation, three forms are usually needed: --- singular nominative and genitive, and plural partitive. --- Examples: "talo", "kukko", "huippu", "koira", "kukka", "syylä", "särki"... - - nKukko : (kukko,kukon,kukkoja : Str) -> N ; - --- A special case: --- the vowel harmony is inferred from the last letter, --- which must be one of "o", "u", "ö", "y". Regular weak-grade alternation --- is performed. - - nTalo : (talo : Str) -> N ; - --- Another special case are nouns where the last two consonants --- undergo regular weak-grade alternation: --- "kukko - kukon", "rutto - ruton", "hyppy - hypyn", "sampo - sammon", --- "kunto - kunnon", "sisältö - sisällön", . - - nLukko : (lukko : Str) -> N ; - --- "arpi - arven", "sappi - sapen", "kampi - kammen";"sylki - syljen" - - nArpi : (arpi : Str) -> N ; - nSylki : (sylki : Str) -> N ; - --- Foreign words ending in consonants are actually similar to words like --- "malli"-"mallin"-"malleja", with the exception that the "i" is not attached --- to the singular nominative. Examples: "linux", "savett", "screen". --- The singular partitive form is used to get the vowel harmony. --- (N.B. more than 1-syllabic words ending in "n" would have variant --- plural genitive and partitive forms, like --- "sultanien", "sultaneiden", which are not covered.) - - nLinux : (linuxia : Str) -> N ; - --- Nouns of at least 3 syllables ending with "a" or "ä", like "peruna", "tavara", --- "rytinä". - - nPeruna : (peruna : Str) -> N ; - --- The following paradigm covers both nouns ending in an aspirated "e", such as --- "rae", "perhe", "savuke", and also many ones ending in a consonant --- ("rengas", "kätkyt"). The singular nominative and essive are given. - - nRae : (rae, rakeena : Str) -> N ; - --- The following covers nouns with partitive "ta","tä", such as --- "susi", "vesi", "pieni". To get all stems and the vowel harmony, it takes --- the singular nominative, genitive, and essive. - - nSusi : (susi,suden,sutta : Str) -> N ; - --- Nouns ending with a long vowel, such as "puu", "pää", "pii", "leikkuu", --- are inflected according to the following. - - nPuu : (puu : Str) -> N ; - --- One-syllable diphthong nouns, such as "suo", "tie", "työ", are inflected by --- the following. - - nSuo : (suo : Str) -> N ; - --- Many adjectives but also nouns have the nominative ending "nen" which in other --- cases becomes "s": "nainen", "ihminen", "keltainen". --- To capture the vowel harmony, we use the partitive form as the argument. - - nNainen : (naista : Str) -> N ; - --- The following covers some nouns ending with a consonant, e.g. --- "tilaus", "kaulin", "paimen", "laidun". - - nTilaus : (tilaus,tilauksena : Str) -> N ; - --- Special case: - - nKulaus : (kulaus : Str) -> N ; - --- The following covers nouns like "nauris" and adjectives like "kallis", "tyyris". --- The partitive form is taken to get the vowel harmony. - - nNauris : (naurista : Str) -> N ; - --- Separately-written compound nouns, like "sambal oelek", "Urho Kekkonen", --- have only their last part inflected. - - compN : Str -> N -> N ; - -- Nouns used as functions need a case, of which the default is -- the genitive. - mkN2 = overload { - mkN2 : N -> N2 = genN2 ; - mkN2 : N -> Prep -> N2 = mmkN2 + mkN2 : overload { + mkN2 : N -> N2 ; + mkN2 : N -> Prep -> N2 } ; mkN3 : N -> Prep -> Prep -> N3 ; @@ -219,12 +124,13 @@ oper mkA : overload { mkA : Str -> A ; mkA : N -> A ; - mkA : N -> (kivempaa,kivinta : Str) -> 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 ; + mkA2 : A -> Prep -> A2 = \a,p -> a ** {c2 = p ; lock_A2 = <>}; @@ -235,45 +141,15 @@ oper -- a table. -- The worst case needs twelve forms, as shown in the following. - --- The following heuristics cover more and more verbs. - - mkV : overload { - mkV : (soutaa : Str) -> V ; - mkV : (soutaa,souti : Str) -> V ; - mkV : (soutaa,soudan,souti : Str) -> V ; - mkV : (tulla,tulee,tulen,tulevat,tulkaa,tullaan,tuli,tulin,tulisi,tullut,tultu,tullun : Str) -> V ; - --- The subject case of verbs is by default nominative. This function can change it. - - mkV : V -> Case -> V + mkV = overload { + mkV : (huutaa : Str) -> V = mk1V ; + mkV : (huutaa,huusi : Str) -> V = mk2V ; + mkV : (huutaa,huudan,huusi : Str) -> V = \x,_,y -> mk2V x y ; ---- + mkV : ( + huutaa,huudan,huutaa,huutavat,huutakaa,huudetaan, + huusin,huusi,huusisi,huutanut,huudettu,huutanee : Str) -> V = mk12V ; } ; - --- The rest of the paradigms are special cases mostly covered by the heuristics. --- A simple special case is the one with just one stem and without grade alternation. - - vValua : (valua : Str) -> V ; - --- With two forms, the following function covers a variety of verbs, such as --- "ottaa", "käyttää", "löytää", "huoltaa", "hiihtää", "siirtää". - - vKattaa : (kattaa, katan : Str) -> V ; - --- When grade alternation is not present, just a one-form special case is needed --- ("poistaa", "ryystää"). - - vOstaa : (ostaa : Str) -> V ; - --- The following covers --- "juosta", "piestä", "nousta", "rangaista", "kävellä", "surra", "panna". - - vNousta : (nousta, nousen : Str) -> V ; - --- This is for one-syllable diphthong verbs like "juoda", "syödä". - - vTuoda : (tuoda : Str) -> V ; - -- All the patterns above have $nominative$ as subject case. -- If another case is wanted, use the following. @@ -283,6 +159,7 @@ oper vOlla : V ; + --3 Two-place verbs -- -- Two-place verbs need an object case, and can have a pre- or postposition. @@ -367,202 +244,305 @@ oper \c -> {c = NPCase c ; s = [] ; isPre = True ; lock_Prep = <>} ; accPrep = {c = NPAcc ; s = [] ; isPre = True ; lock_Prep = <>} ; - mk10N= \a,b,c,d,e,f,g,h,i,j -> - mkNoun a b c d e f g h i j ** {lock_N = <>} ; - mkN = overload { - mkN : (talo : Str) -> N = regN ; - mkN : (savi,savia : Str) -> N = reg2N ; - mkN : (vesi,veden,vesiä : Str) -> N = reg3N ; - mkN : (talo, talon, talona, taloa, taloon, - taloina,taloissa,talojen,taloja,taloihin : Str) -> N = mk10N + 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 ; } ; - regN = \vesi -> - let - esi = Predef.dp 3 vesi ; -- analysis: suffixes - a = if_then_Str (pbool2bool (Predef.occurs "aou" vesi)) "a" "ä" ; - ves = init vesi ; -- synthesis: prefixes - vet = strongGrade ves ; - ve = init ves ; - in nhn ( - case esi of { - "uus" | "yys" => sRakkaus vesi ; - _ + "nen" => sNainen (Predef.tk 3 vesi + ("st" + a)) ; - _ + ("aa" | "ee" | "ii" | "oo" | "uu" | "yy" | "ää" | "öö") => sPuu vesi ; - _ + ("ie" | "uo" | "yö") => sSuo vesi ; - _ + ("ea" | "eä") => - mkSubst - a - vesi (vesi) (vesi) (vesi + a) (vesi + a+"n") - (ves + "i") (ves + "i") (ves + "iden") (ves + "it"+a) - (ves + "isiin") ; - _ + "is" => sNauris (vesi + ("t" + a)) ; - _ + ("ut" | "yt") => sRae vesi (ves + ("en" + a)) ; - _ + ("as" | "äs") => sRae vesi (vet + (a + "n" + a)) ; - _ + ("ar" | "är") => sRae vesi (vet + ("ren" + a)) ; - _ + "n" => sLiitin vesi (vet + "men") ; - _ + "s" => sTilaus vesi (ves + ("ksen" + a)) ; - _ + "i" => sBaari (vesi + a) ; - _ + "e" => sRae vesi (strongGrade vesi + "en" + a) ; - _ + ("a" | "o" | "u" | "y" | "ä" | "ö") => sLukko vesi ; - _ => sLinux (vesi + "i" + a) - } - ) ** {lock_N = <>} ; + mk1A : Str -> A = \jalo -> aForms2A (nforms2aforms (nForms1 jalo)) ; + mkNA : N -> A = \suuri -> aForms2A (nforms2aforms (n2nforms suuri)) ; - reg2N : (savi,savia : Str) -> N = \savi,savia -> - let - savit = regN savi ; - ia = Predef.dp 2 savia ; - i = init ia ; - a = last ia ; - o = last savi ; - savin = weakGrade savi + "n" ; - in - case of { - <"i","ia"> => nhn (sArpi savi) ; - <"i","iä"> => nhn (sSylki savi) ; - <"o","ta"> | <"ö","tä"> => nhn (sRadio savi) ; - <"a","ta"> | <"ä","tä"> => nhn (sPeruna savi) ; - <"i","ta"> | <"i","tä"> => nhn (sTohtori (savi + a)) ; -- from 10 to 90 ms --- <"a","ia"> | <"a","ja"> => nhn (sKukko savi savin savia) ; ---needless? - _ => savit - } - ** {lock_N = <>} ; + 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) ; -reg3N = \vesi,veden,vesiä -> - let - si = Predef.dp 2 vesi ; - a = last vesiä - in - case si of { - "us" | "ys" => - nhn (case Predef.dp 3 veden of { - "den" => sRakkaus vesi ; - _ => sTilaus vesi (veden + a) - }) ; - "as" | "äs" => nhn (sRae vesi (veden + a)) ; - "li" | "ni" | "ri" => nhn (sSusi vesi veden (init vesi + ("en" + a))) ; - "si" => nhn (sSusi vesi veden (Predef.tk 2 vesi + ("ten" + a))) ; - "in" | "en" | "än" => nhn (sLiitin vesi veden) ; - _ + ("a" | "o" | "u" | "y" | "ä" | "ö") => nhn (sKukko vesi veden vesiä) ; - _ {- + "i" -} => nhn (sKorpi vesi veden (init veden + "n" + a)) - } - ** {lock_N = <>} ; + 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 - nKukko = \a,b,c -> nhn (sKukko a b c) ** {lock_N = <>} ; + 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") => dRae ukko (ukk + "en") ; + _ + ("as" | "äs") => dRae ukko (renka + last renka + "n") ; + _ + ("uus" | "yys" | "eus" | "eys") => dLujuus ukko ; + _ + "s" => dJalas ukko ; - nLukko = \a -> nhn (sLukko a) ** {lock_N = <>} ; - nTalo = \a -> nhn (sTalo a) ** {lock_N = <>} ; - nArpi = \a -> nhn (sArpi a) ** {lock_N = <>} ; - nSylki = \a -> nhn (sSylki a) ** {lock_N = <>} ; - nLinux = \a -> nhn (sLinux a) ** {lock_N = <>} ; - nPeruna = \a -> nhn (sPeruna a) ** {lock_N = <>} ; - nRae = \a,b -> nhn (sRae a b) ** {lock_N = <>} ; - nSusi = \a,b,c -> nhn (sSusi a b c) ** {lock_N = <>} ; - nPuu = \a -> nhn (sPuu a) ** {lock_N = <>} ; - nSuo = \a -> nhn (sSuo a) ** {lock_N = <>} ; - nNainen = \a -> nhn (sNainen a) ** {lock_N = <>} ; - nTilaus = \a,b -> nhn (sTilaus a b) ** {lock_N = <>} ; - nKulaus = \a -> nTilaus a (init a + "ksen" + getHarmony (last - (init a))) ; - nNauris = \a -> nhn (sNauris a) ** {lock_N = <>} ; - sgpartN noun part = { - s = table { - NCase Sg Part => part ; - c => noun.s ! c +{- heuristics for 3-syllable nouns ending a/ä + _ + ("a" | "e" | "i" | "o" | "u" | "y" | "ä" | "ö") + C_ + + _ + "i" + C_ + a@("a" | "ä") => + dSilakka ukko (ukko + "n") (ukk + o + "it" + a) ; + _ + ("a" | "e" | "i" | "o" | "u" | "y" | "ä" | "ö") + C_ + _ + + ("a" | "e" | "o" | "u" | "y" | "ä" | "ö") + + ("l" | "r" | "n") + a@("a" | "ä") => + dSilakka ukko (ukko + "n") (ukk + o + "it" + a) ; + _ + ("a" | "e" | "i" | "o" | "u" | "y" | "ä" | "ö") + C_ + _ + + ("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" | "ä" | "ö") + C_ + _ + + ("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") + C_ + _ + + ("a" | "e" | "o" | "u") + C_ + "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 ; + <_ + "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) } ; - g = noun.g ; - lock_N = noun.lock_N - } ; - nMeri meri = - let a = vowelHarmony meri in - sgpartN (reg2N meri (meri + a)) (init meri + "ta") ; - compN = \s,n -> {s = \\c => s ++ n.s ! c ; g = n.g ; lock_N = <>} ; + 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", _ + ("a" | "ä")> => + 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) + } ; - makeNP : N -> Number -> CatFin.NP ; - makeNP noun num = { - s = \\c => noun.s ! NCase num (npform2case num c) ; - a = agrP3 num ; - isPron = False ; - lock_NP = <> + 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 = regPN ; - mkPN : N -> PN = mmkPN + mkPN : Str -> PN = \s -> {s = \\c => (mk1N s).s ! NCase Sg c ; lock_PN = <>} ; + mkPN : N -> PN = \s -> {s = \\c => s.s ! NCase Sg c ; lock_PN = <>} ; } ; +-- adjectives + mkA = overload { - mkA : Str -> A = regA ; - mkA : N -> A = mk1A ; - mkA : N -> (kivempaa,kivinta : Str) -> A = mkADeg + mkA : Str -> A = \s -> noun2adjDeg (mk1N s) ** {lock_A = <>} ; + 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 ; } ; - mk1A = \x -> {s = \\_ => (noun2adj x).s ; lock_A = <>} ; - ---- mkADeg (noun2adj x).s ... +-- 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 + (init (suuri.s ! NCase Pl Part) + "n") ; ---- + - mkA2 = \x,c -> x ** {c2 = c ; lock_A2 = <>} ; - mkADeg x kivempi kivin = + + +-- verbs + + mk1V : Str -> V = \s -> vforms2V (vForms1 s) ** {sc = NPCase Nom ; lock_V = <>} ; + mk2V : (_,_ : Str) -> V = \s,t -> vforms2V (vForms2 s t) ** {sc = NPCase Nom ; lock_V = <>} ; + + 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 (x.s ! ((NCase Sg Part))) ; ---- gives "kivinta" - kivempaa = init kivempi + a + a ; - kivinta = kivin + "t" + a + 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 - regAdjective x kivempaa kivinta ** {lock_A = <>} ; + 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") ; + ("" | C_) + ("a" | "e" | "i" | "o" | "u") + C_ + _ + + ("a" | "e" | "i" | "o" | "u") + _ + "aa" => + cOttaa ottaa (ota + "n") (ot + "in") (ott + "i") ; + ("" | C_) + ("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) + } ; - regA suuri = - let suur = regN suuri in - mkADeg - suur - (init (suur.s ! NCase Sg Gen) + "mpi") - (init (suur.s ! NCase Pl Ess)) ; + 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 + } ; - regADeg = regA ; -- for bw compat - mk12V a b c d e f g h i j k l = mkVerb a b c d e f g h i j k l ** - {sc = NPCase Nom ; lock_V = <>} ; - mkV = overload { - mkV : (soutaa : Str) -> V = regV ; - mkV : (soutaa,souti : Str) -> V = reg2V ; - mkV : (soutaa,soudan,souti : Str) -> V = reg3V ; - mkV : (tulla,tulee,tulen,tulevat,tulkaa,tullaan, - tuli,tulin,tulisi,tullut,tultu,tullun : Str) -> V = mk12V ; - mkV : V -> Case -> V = subjcaseV - } ; - - regV soutaa = v2v (regVerbH soutaa) ** {sc = NPCase Nom ; lock_V = <>} ; - - reg2V : (soutaa,souti : Str) -> V = \soutaa,souti -> - v2v (reg2VerbH soutaa souti) ** {sc = NPCase Nom ; lock_V = <>} ; - - reg3V soutaa soudan souti = - v2v (reg3VerbH soutaa soudan souti) ** {sc = NPCase Nom ; lock_V = <>} ; - - subjcaseV v c = {s = v.s ; sc = NPCase c ; lock_V = v.lock_V} ; - - vValua v = v2v (vSanoa v) ** {sc = NPCase Nom ; lock_V = <>} ; - vKattaa v u = v2v (vOttaa v u) ** {sc = NPCase Nom ; lock_V = <>} ; - vOstaa v = v2v (vPoistaa v) ** {sc = NPCase Nom ; lock_V = <>} ; - vNousta v u = v2v (vJuosta v u [] []) ** {sc = NPCase Nom ; lock_V = <>} ; ----- - vTuoda v = v2v (vJuoda v []) ** {sc = NPCase Nom ; lock_V = <>} ; ----- caseV c v = {s = v.s ; sc = NPCase c ; lock_V = <>} ; vOlla = verbOlla ** {sc = NPCase Nom ; lock_V = <>} ; - vHuoltaa : (_,_,_,_ : Str) -> Verb = \ottaa,otan,otti,otin -> - v2v (MorphoFin.vHuoltaa ottaa otan otti otin) ** {sc = NPCase Nom ; lock_V = <>} ; - - - mk2V2 = \v,c -> v ** {c2 = c ; lock_V2 = <>} ; - caseV2 = \v,c -> mk2V2 v (casePrep c) ; + 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) ; @@ -578,62 +558,15 @@ reg3N = \vesi,veden,vesi A2V : Type = A2 ; mkV0 v = v ** {lock_V = <>} ; - mkV2S v p = mk2V2 v p ** {lock_V2 = <>} ; - mkV2V v p = mk2V2 v p ** {lock_V2 = <>} ; +-- mkV2S v p = mk2V2 v p ** {lock_V2 = <>} ; +-- mkV2V v p = mk2V2 v p ** {lock_V2 = <>} ; 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_V2 = <>} ; +-- mkV2Q v p = mk2V2 v p ** {lock_V2 = <>} ; 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 = <>} ; - ---- old stuff - - reg2N : (savi,savia : Str) -> N ; - reg3N : (vesi,veden,vesiä : Str) -> N ; - - mk10N: (talo, talon, talona, taloa, taloon, - taloina,taloissa,talojen,taloja,taloihin : Str) -> N ; - - regN : (talo : Str) -> N ; - - mmkN2 : N -> Prep -> N2 = \n,c -> n ** {c2 = c ; lock_N2 = <>} ; - mkN3 = \n,c,e -> n ** {c2 = c ; c3 = e ; lock_N3 = <>} ; - genN2 = \n -> mmkN2 n (casePrep genitive) ; - regPN m = mmkPN (regN m) ; - mmkPN : N -> PN = \n -> mkProperName n ** {lock_PN = <>} ; - - genN2 : N -> N2 ; - - - mk1A : N -> A ; - mkADeg : (kiva : N) -> (kivempaa,kivinta : Str) -> A ; - regA : (punainen : Str) -> A ; - - mk12V : (tulla,tulee,tulen,tulevat,tulkaa,tullaan, - tuli,tulin,tulisi,tullut,tultu,tullun : Str) -> V ; - - regV : (soutaa : Str) -> V ; - reg2V : (soutaa,souti : Str) -> V ; - reg3V : (soutaa,soudan,souti : Str) -> V ; - - subjcaseV : V -> Case -> V ; - - regPN : Str -> PN ; - - mkV2 = overload { - mkV2 : Str -> V2 = \s -> dirV2 (regV s) ; - mkV2 : V -> V2 = dirV2 ; - mkV2 : V -> Case -> V2 = caseV2 ; - mkV2 : V -> Prep -> V2 = mk2V2 ; - } ; - - dirV2 : V -> V2 ; - mk2V2 : V -> Prep -> V2 ; - caseV2 : V -> Case -> V2 ; - dirV2 : V -> V2 ; - } ; diff --git a/lib/resource/finnish/StructuralFin.gf b/lib/resource/finnish/StructuralFin.gf index c9ab00c51..040253550 100644 --- a/lib/resource/finnish/StructuralFin.gf +++ b/lib/resource/finnish/StructuralFin.gf @@ -9,7 +9,7 @@ concrete StructuralFin of Structural = CatFin ** all_Predet = {s = \\n,c => let - kaiket = caseTable n (nhn (sKorpi "kaikki" "kaiken" "kaikkena")) + kaiket = caseTable n ((mkN "kaikki" "kaiken" "kaikkena")) in case npform2case n c of { Nom => "kaikki" ; @@ -28,17 +28,17 @@ concrete StructuralFin of Structural = CatFin ** but_PConj = ss "mutta" ; by8agent_Prep = postGenPrep "toimesta" ; by8means_Prep = casePrep adessive ; - can8know_VV = reg2V "osata" "osasi" ; - can_VV = reg2V "voida" "voi" ; + can8know_VV = mkV "osata" "osasi" ; + can_VV = mkV "voida" "voi" ; during_Prep = postGenPrep "aikana" ; either7or_DConj = sd2 "joko" "tai" ** {n = Sg} ; - everybody_NP = makeNP (regN "jokainen") Sg ; - every_Det = mkDet Sg (regN "jokainen") ; - everything_NP = makeNP ((nhn (sKorpi "kaikki" "kaiken" "kaikkena")) ** + 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 (regN "harva") ; ---- first_Ord = {s = \\n,c => (regN "ensimmäinen").s ! NCase n c} ; + 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 ; @@ -47,7 +47,7 @@ concrete StructuralFin of Structural = CatFin ** here7from_Adv = ss "täältä" ; how_IAdv = ss "miten" ; how8many_IDet = - {s = \\c => "kuinka" ++ (reg2N "moni" "monia").s ! NCase Sg c ; n = Sg} ; + {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 ; @@ -58,11 +58,11 @@ concrete StructuralFin of Structural = CatFin ** isPron = False } ; less_CAdv = ss "vähemmän" ; - many_Det = mkDet Sg (reg2N "moni" "monia") ; + many_Det = mkDet Sg (mkN "moni" "monia") ; more_CAdv = ss "enemmän" ; - most_Predet = {s = \\n,c => (nhn (sSuurin "useinta")).s ! NCase n (npform2case n c)} ; + most_Predet = {s = \\n,c => (nForms2N (dSuurin "useinta")).s ! NCase n (npform2case n c)} ; much_Det = mkDet Sg {s = \\_ => "paljon"} ; - must_VV = subjcaseV (regV "täytyä") genitive ; + must_VV = caseV genitive (mkV "täytyä") ; no_Phr = ss "ei" ; on_Prep = casePrep adessive ; --- one_Quant = mkDet Sg DEPREC @@ -140,7 +140,7 @@ concrete StructuralFin of Structural = CatFin ** to_Prep = casePrep illative ; --- allative under_Prep = postGenPrep "alla" ; very_AdA = ss "erittäin" ; - want_VV = regV "tahtoa" ; + 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} ; @@ -181,8 +181,8 @@ concrete StructuralFin of Structural = CatFin ** oper jokuPron : MorphoFin.Number => (MorphoFin.Case) => Str = let - ku = nhn (sPuu "ku") ; - kui = nhn (sPuu "kuu") + ku = mkN "ku" ; + kui = mkN "kuu" in table { Sg => table { @@ -211,7 +211,7 @@ oper mikaInt : MorphoFin.Number => (MorphoFin.Case) => Str = let { - mi = nhn (sSuo "mi") + mi = mkN "mi" } in table { Sg => table { @@ -228,8 +228,8 @@ oper kukaInt : MorphoFin.Number => (MorphoFin.Case) => Str = let { - ku = nhn (sRae "kuka" "kenenä") ; - ket = nhn (sRae "kuka" "keinä")} in + ku = mkN "kuka" "keitä" ; ----- + ket = mkN "kuka" "keitä"} in table { Sg => table { Nom => "kuka" ; @@ -301,5 +301,16 @@ oper } ; +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/src/GF/Compile/Rename.hs b/src/GF/Compile/Rename.hs index bc5925d22..2ac992fd2 100644 --- a/src/GF/Compile/Rename.hs +++ b/src/GF/Compile/Rename.hs @@ -103,7 +103,8 @@ renameIdentTerm env@(act,imps) t = [] -> alt c ("constant not found:" +++ prt c) fs -> case nub [f c | f <- fs] of [tr] -> return tr - ts -> return $ Strs $ (cnIC "#conflict") : reverse ts + ts@(t:_) -> trace ("WARNING: conflict" +++ unwords (map prt ts)) (return t) +---- ts -> return $ Strs $ (cnIC "#conflict") : reverse ts -- a warning will be generated in CheckGrammar, and the head returned -- in next V: -- Bad $ "conflicting imports:" +++ unwords (map prt ts)