From b7d2916bbed9d1eec92066061d0fc0d5d35739b4 Mon Sep 17 00:00:00 2001 From: "ra.monique" Date: Mon, 23 Feb 2009 13:29:42 +0000 Subject: [PATCH] Romainian in next-lib --- next-lib/src/romanian/BeschRon.gf | 188 ++ next-lib/src/romanian/CatRon.gf | 70 + next-lib/src/romanian/GrammarRon.gf | 9 + next-lib/src/romanian/LangRon.gf | 10 + next-lib/src/romanian/LexiconRon.gf | 366 ++++ next-lib/src/romanian/MorphoRon.gf | 2428 +++++++++++++++++++++++++ next-lib/src/romanian/NumeralRon.gf | 249 +++ next-lib/src/romanian/ParadigmsRon.gf | 395 ++++ next-lib/src/romanian/ResRon.gf | 160 ++ 9 files changed, 3875 insertions(+) create mode 100644 next-lib/src/romanian/BeschRon.gf create mode 100644 next-lib/src/romanian/CatRon.gf create mode 100644 next-lib/src/romanian/GrammarRon.gf create mode 100644 next-lib/src/romanian/LangRon.gf create mode 100644 next-lib/src/romanian/LexiconRon.gf create mode 100644 next-lib/src/romanian/MorphoRon.gf create mode 100644 next-lib/src/romanian/NumeralRon.gf create mode 100644 next-lib/src/romanian/ParadigmsRon.gf create mode 100644 next-lib/src/romanian/ResRon.gf diff --git a/next-lib/src/romanian/BeschRon.gf b/next-lib/src/romanian/BeschRon.gf new file mode 100644 index 000000000..ec9c98cb6 --- /dev/null +++ b/next-lib/src/romanian/BeschRon.gf @@ -0,0 +1,188 @@ +resource BeschRon = open Prelude, MorphoRon,CatRon in { + +flags optimize=noexpand ; -- faster and smaller than =all + +oper VerbeN = {s: VForm => Str } ; +oper mkNV : Verbe -> V = \ve -> {s = ve ; lock_V = <> } ; +oper mkRV : Verbe -> V = \ve -> {s = ve ; lock_V = <>} ; + + +-- for Group 1 - verbs ending in a (last sylablle) - the default behaviour is conjugation with "ez" +-- with small mutation, depending on the second last letter (80 % verbs - especially neological) +-- for Group 2 - verbs ending in ea - there are relatively few verbs, most of them irregular +-- default behavior - covers almost 25 % +-- for Group 3 - verbs ending in e - most verbs have phonetical mutations in the stem, for different +-- tenses, difficult to find a pattern that describes this behavior +-- default conjugation - covers almost 20% +-- for Group 4 - verbs ending in i/î - the default behaviour is the conjugation with "sc", which +-- characterizes almost 75 % of the verbs +-- in general : Group 1 + Group 4 are the most frequent for verbs +-- the smart paradigm covers (60-70% cases for a reasonably big database) +-- (statistical tests also needed) + +oper regV : Str -> Verbe = \s -> +case s of +{ x + ("chea"|"ghea") => mkV61 s ; + x + "ea" => mkV69 s ; + x + "ca" => mkV8 s ; + x + "ga" => mkV9 s ; + x + "eia" => mkV11 s; + x + "ia" => mkV10 s; + x + "a" => mkV6 s ; + x + "e" => mkV79 s ; + x + "ui" => mkV121 s ; + x + "ii" => mkV120 s ; + x + "i" => mkV119 s ; + x + "î" => mkV141 s +}; + +oper mkV : Str -> V = \s -> mkNV (regV s) ; + + +oper conj : Str -> Verbe = mkV6 ; + + + +oper v_besch6 : Str -> VerbeN = \s -> mkNV (mkV6 s) ; +oper v_besch7 : Str -> VerbeN = \s -> mkNV (mkV7 s) ; +oper v_besch8 : Str -> VerbeN = \s -> mkNV (mkV8 s) ; +oper v_besch9 : Str -> VerbeN = \s -> mkNV (mkV9 s) ; +oper v_besch10 : Str -> VerbeN = \s -> mkNV (mkV10 s) ; +oper v_besch11 : Str -> VerbeN = \s -> mkNV (mkV11 s) ; +oper v_besch12 : Str -> VerbeN = \s -> mkNV (mkV12 s) ; +oper v_besch13 : Str -> VerbeN = \s -> mkNV (mkV13 s) ; +oper v_besch14 : Str -> VerbeN = \s -> mkNV (mkV14 s) ; +oper v_besch15 : Str -> VerbeN = \s -> mkNV (mkV15 s) ; +oper v_besch16 : Str -> VerbeN = \s -> mkNV (mkV16 s) ; +oper v_besch17 : Str -> VerbeN = \s -> mkNV (mkV17 s) ; +oper v_besch18 : Str -> VerbeN = \s -> mkNV (mkV18 s) ; +oper v_besch19 : Str -> VerbeN = \s -> mkNV (mkV19 s) ; +oper v_besch20 : Str -> VerbeN = \s -> mkNV (mkV20 s) ; +oper v_besch21 : Str -> VerbeN = \s -> mkNV (mkV21 s) ; +oper v_besch22 : Str -> VerbeN = \s -> mkNV (mkV22 s) ; +oper v_besch23 : Str -> VerbeN = \s -> mkNV (mkV23 s) ; +oper v_besch24 : Str -> VerbeN = \s -> mkNV (mkV24 s) ; +oper v_besch25 : Str -> VerbeN = \s -> mkNV (mkV25 s) ; +oper v_besch26 : Str -> VerbeN = \s -> mkNV (mkV26 s) ; +oper v_besch27 : Str -> VerbeN = \s -> mkNV (mkV27 s) ; +oper v_besch28 : Str -> VerbeN = \s -> mkNV (mkV28 s) ; +oper v_besch29 : Str -> VerbeN = \s -> mkNV (mkV29 s) ; +oper v_besch30 : Str -> VerbeN = \s -> mkNV (mkV30 s) ; +oper v_besch31 : Str -> VerbeN = \s -> mkNV (mkV31 s) ; +oper v_besch32 : Str -> VerbeN = \s -> mkNV (mkV32 s) ; +oper v_besch33 : Str -> VerbeN = \s -> mkNV (mkV33 s) ; +oper v_besch34 : Str -> VerbeN = \s -> mkNV (mkV34 s) ; +oper v_besch35 : Str -> VerbeN = \s -> mkNV (mkV35 s) ; +oper v_besch36 : Str -> VerbeN = \s -> mkNV (mkV36 s) ; +oper v_besch37 : Str -> VerbeN = \s -> mkNV (mkV37 s) ; +oper v_besch38 : Str -> VerbeN = \s -> mkNV (mkV38 s) ; +oper v_besch39 : Str -> VerbeN = \s -> mkNV (mkV39 s) ; +oper v_besch40 : Str -> VerbeN = \s -> mkNV (mkV40 s) ; +oper v_besch41 : Str -> VerbeN = \s -> mkNV (mkV41 s) ; +oper v_besch42 : Str -> VerbeN = \s -> mkNV (mkV42 s) ; +oper v_besch43 : Str -> VerbeN = \s -> mkNV (mkV43 s) ; +oper v_besch44 : Str -> VerbeN = \s -> mkNV (mkV44 s) ; +oper v_besch45 : Str -> VerbeN = \s -> mkNV (mkV45 s) ; +oper v_besch46 : Str -> VerbeN = \s -> mkNV (mkV46 s) ; +oper v_besch47 : Str -> VerbeN = \s -> mkNV (mkV47 s) ; +oper v_besch48 : Str -> VerbeN = \s -> mkNV (mkV48 s) ; +oper v_besch49 : Str -> VerbeN = \s -> mkNV (mkV49 s) ; +oper v_besch50 : Str -> VerbeN = \s -> mkNV (mkV50 s) ; +oper v_besch51 : Str -> VerbeN = \s -> mkNV (mkV51 s) ; +oper v_besch52 : Str -> VerbeN = \s -> mkNV (mkV52 s) ; +oper v_besch53 : Str -> VerbeN = \s -> mkNV (mkV53 s) ; +oper v_besch54 : Str -> VerbeN = \s -> mkNV (mkV54 s) ; +oper v_besch55 : Str -> VerbeN = \s -> mkNV (mkV55 s) ; +oper v_besch56 : Str -> VerbeN = \s -> mkNV (mkV56 s) ; +oper v_besch57 : Str -> VerbeN = \s -> mkNV (mkV57 s) ; +oper v_besch58 : Str -> VerbeN = \s -> mkNV (mkV58 s) ; +oper v_besch59 : Str -> VerbeN = \s -> mkNV (mkV59 s) ; +oper v_besch60 : Str -> VerbeN = \s -> mkNV (mkV60 s) ; +oper v_besch61 : Str -> VerbeN = \s -> mkNV (mkV61 s) ; +oper v_besch62 : Str -> VerbeN = \s -> mkNV (mkV62 s) ; +--oper v_besch63 : Str -> VerbeN = \s -> mkNV (mkV63 s) ; +oper v_besch64 : Str -> VerbeN = \s -> mkNV (mkV64 s) ; +oper v_besch65 : Str -> VerbeN = \s -> mkNV (mkV65 s) ; +oper v_besch66 : Str -> VerbeN = \s -> mkNV (mkV66 s) ; +oper v_besch67 : Str -> VerbeN = \s -> mkNV (mkV67 s) ; +oper v_besch68 : Str -> VerbeN = \s -> mkNV (mkV68 s) ; +oper v_besch69 : Str -> VerbeN = \s -> mkNV (mkV69 s) ; +oper v_besch70 : Str -> VerbeN = \s -> mkNV (mkV70 s) ; +oper v_besch71 : Str -> VerbeN = \s -> mkNV (mkV71 s) ; +oper v_besch72 : Str -> VerbeN = \s -> mkNV (mkV72 s) ; +oper v_besch73 : Str -> VerbeN = \s -> mkNV (mkV73 s) ; +oper v_besch74 : Str -> VerbeN = \s -> mkNV (mkV74 s) ; +--oper v_besch75 : Str -> VerbeN = \s -> mkNV (mkV75 s) ; +oper v_besch76 : Str -> VerbeN = \s -> mkNV (mkV76 s) ; +oper v_besch77 : Str -> VerbeN = \s -> mkNV (mkV77 s) ; +oper v_besch78 : Str -> VerbeN = \s -> mkNV (mkV78 s) ; +oper v_besch79 : Str -> VerbeN = \s -> mkNV (mkV79 s) ; +oper v_besch80 : Str -> VerbeN = \s -> mkNV (mkV80 s) ; +oper v_besch81 : Str -> VerbeN = \s -> mkNV (mkV81 s) ; +oper v_besch82 : Str -> VerbeN = \s -> mkNV (mkV82 s) ; +oper v_besch83 : Str -> VerbeN = \s -> mkNV (mkV83 s) ; +oper v_besch84 : Str -> VerbeN = \s -> mkNV (mkV84 s) ; +oper v_besch85 : Str -> VerbeN = \s -> mkNV (mkV85 s) ; +oper v_besch86 : Str -> VerbeN = \s -> mkNV (mkV86 s) ; +oper v_besch87 : Str -> VerbeN = \s -> mkNV (mkV87 s) ; +oper v_besch88 : Str -> VerbeN = \s -> mkNV (mkV88 s) ; +oper v_besch89 : Str -> VerbeN = \s -> mkNV (mkV89 s) ; +oper v_besch90 : Str -> VerbeN = \s -> mkNV (mkV90 s) ; +oper v_besch91 : Str -> VerbeN = \s -> mkNV (mkV91 s) ; +oper v_besch92 : Str -> VerbeN = \s -> mkNV (mkV92 s) ; +oper v_besch93 : Str -> VerbeN = \s -> mkNV (mkV93 s) ; +oper v_besch94 : Str -> VerbeN = \s -> mkNV (mkV94 s) ; +oper v_besch95 : Str -> VerbeN = \s -> mkNV (mkV95 s) ; +oper v_besch96 : Str -> VerbeN = \s -> mkNV (mkV96 s) ; +oper v_besch97 : Str -> VerbeN = \s -> mkNV (mkV97 s) ; +oper v_besch98 : Str -> VerbeN = \s -> mkNV (mkV98 s) ; +oper v_besch99 : Str -> VerbeN = \s -> mkNV (mkV99 s) ; +oper v_besch100 : Str -> VerbeN = \s -> mkNV (mkV100 s) ; +oper v_besch101 : Str -> VerbeN = \s -> mkNV (mkV101 s) ; +oper v_besch102 : Str -> VerbeN = \s -> mkNV (mkV102 s) ; +oper v_besch103 : Str -> VerbeN = \s -> mkNV (mkV103 s) ; +oper v_besch104 : Str -> VerbeN = \s -> mkNV (mkV104 s) ; +oper v_besch105 : Str -> VerbeN = \s -> mkNV (mkV105 s) ; +oper v_besch106 : Str -> VerbeN = \s -> mkNV (mkV106 s) ; +--oper v_besch107 : Str -> VerbeN = \s -> mkNV (mkV107 s) ; +oper v_besch108 : Str -> VerbeN = \s -> mkNV (mkV108 s) ; +oper v_besch109 : Str -> VerbeN = \s -> mkNV (mkV109 s) ; +oper v_besch110 : Str -> VerbeN = \s -> mkNV (mkV110 s) ; +--oper v_besch111 : Str -> VerbeN = \s -> mkNV (mkV111 s) ; +oper v_besch112 : Str -> VerbeN = \s -> mkNV (mkV112 s) ; +oper v_besch113 : Str -> VerbeN = \s -> mkNV (mkV113 s) ; +--oper v_besch114 : Str -> VerbeN = \s -> mkNV (mkV114 s) ; +oper v_besch115 : Str -> VerbeN = \s -> mkNV (mkV115 s) ; +oper v_besch116 : Str -> VerbeN = \s -> mkNV (mkV116 s) ; +oper v_besch117 : Str -> VerbeN = \s -> mkNV (mkV117 s) ; +oper v_besch118 : Str -> VerbeN = \s -> mkNV (mkV118 s) ; +oper v_besch119 : Str -> VerbeN = \s -> mkNV (mkV119 s) ; +oper v_besch120 : Str -> VerbeN = \s -> mkNV (mkV120 s) ; +oper v_besch121 : Str -> VerbeN = \s -> mkNV (mkV121 s) ; +oper v_besch122 : Str -> VerbeN = \s -> mkNV (mkV122 s) ; +oper v_besch123 : Str -> VerbeN = \s -> mkNV (mkV123 s) ; +oper v_besch124 : Str -> VerbeN = \s -> mkNV (mkV124 s) ; +oper v_besch125 : Str -> VerbeN = \s -> mkNV (mkV125 s) ; +oper v_besch126 : Str -> VerbeN = \s -> mkNV (mkV126 s) ; +oper v_besch127 : Str -> VerbeN = \s -> mkNV (mkV127 s) ; +oper v_besch128 : Str -> VerbeN = \s -> mkNV (mkV128 s) ; +oper v_besch129 : Str -> VerbeN = \s -> mkNV (mkV129 s) ; +oper v_besch130 : Str -> VerbeN = \s -> mkNV (mkV130 s) ; +oper v_besch131 : Str -> VerbeN = \s -> mkNV (mkV131 s) ; +oper v_besch132 : Str -> VerbeN = \s -> mkNV (mkV132 s) ; +oper v_besch133 : Str -> VerbeN = \s -> mkNV (mkV133 s) ; +oper v_besch134 : Str -> VerbeN = \s -> mkNV (mkV134 s) ; +oper v_besch135 : Str -> VerbeN = \s -> mkNV (mkV135 s) ; +oper v_besch136 : Str -> VerbeN = \s -> mkNV (mkV136 s) ; +oper v_besch137 : Str -> VerbeN = \s -> mkNV (mkV137 s) ; +oper v_besch138 : Str -> VerbeN = \s -> mkNV (mkV138 s) ; +oper v_besch139 : Str -> VerbeN = \s -> mkNV (mkV139 s) ; +oper v_besch140 : Str -> VerbeN = \s -> mkNV (mkV140 s) ; +oper v_besch141 : Str -> VerbeN = \s -> mkNV (mkV141 s) ; +oper v_besch142 : Str -> VerbeN = \s -> mkNV (mkV142 s) ; +oper v_besch143 : Str -> VerbeN = \s -> mkNV (mkV143 s) ; +oper v_besch144 : Str -> VerbeN = \s -> mkNV (mkV144 s) ; +oper v_have : VerbeN = mkNV (mkV1 "avea") ; + + +} diff --git a/next-lib/src/romanian/CatRon.gf b/next-lib/src/romanian/CatRon.gf new file mode 100644 index 000000000..f3e756e64 --- /dev/null +++ b/next-lib/src/romanian/CatRon.gf @@ -0,0 +1,70 @@ +--# -path=.:../Romance:../common:../abstract:../common:prelude + +concrete CatRon of Cat = + CommonX - [Temp,TTAnt,Tense,TPres,TPast,TFut,TCond] + ** open Prelude, ResRon, (R = ParamX) in { + + flags optimize=all_subs ; + + + + lincat + + +-- Verb + + -- VP = ResRon.VP ; + -- VPSlash = ResRon.VP ** {c2 : Compl} ; + -- Comp = {s : Agr => Str} ; + +-- Adjective + + AP = {s : AForm => Str ; isPre : Bool} ; + +-- Noun + + CN = {s : Number => Str ; g : Gender} ; + -- Pron = Pronoun ; + -- NP = NounPhrase ; + -- Det = { + -- s : Gender => Case => Str ; + -- n : Number ; + -- s2 : Str ; -- -ci + -- sp : Gender => Case => Str -- substantival: mien, mienne + -- } ; + -- Quant = { + -- s : Bool => Number => Gender => Case => Str ; + -- s2 : Str ; + -- sp : Number => Gender => Case => Str + Ord = {s : AForm => Str ; isPre : Bool} ; +-- Numeral + + Numeral = {s : ACase => CardOrd => NumF => Str ; size : Size } ; + Digits = {s : CardOrd => Str ; n : Size ; isDig : Bool} ; + + + +-- Structural + + Conj = {s1,s2 : Str ; n : Number} ; + Subj = {s : Str ; m : Mood} ; + Prep = {s : Str ; c : NCase ; isDir : Bool} ; + +-- Open lexical classes, e.g. Lexicon + Verb = {s : VForm => Str } ; + V ={s : VForm => Str } ; + VQ, VA = V ; + V2, VV, V2S, V2Q = V ** {c2 : Compl} ; + V3, V2A, V2V = V ** {c2,c3 : Compl} ; + VS = V ** {m : Polarity => Mood} ; + + A = {s : Degree => AForm => Str ; isPre : Bool} ; + A2 = {s : Degree => AForm => Str ; c2 : Compl} ; + + N = Noun ; + N2 = Noun ** {c2 : Compl} ; + N3 = Noun ** {c2,c3 : Compl} ; + PN = {s : ACase => Str ; g : Gender ; n : Number} ; + + +} diff --git a/next-lib/src/romanian/GrammarRon.gf b/next-lib/src/romanian/GrammarRon.gf new file mode 100644 index 000000000..4db46bbf6 --- /dev/null +++ b/next-lib/src/romanian/GrammarRon.gf @@ -0,0 +1,9 @@ +--# -path=.:../romance:../abstract:../common:prelude + +concrete GrammarRon of Grammar = + NumeralRon, + ** { + +flags startcat = Phr ; unlexer = text ; lexer = text ; + +} ; diff --git a/next-lib/src/romanian/LangRon.gf b/next-lib/src/romanian/LangRon.gf new file mode 100644 index 000000000..9663cb5d1 --- /dev/null +++ b/next-lib/src/romanian/LangRon.gf @@ -0,0 +1,10 @@ +--# -path=.:../romance:../abstract:../common + +concrete LangRon of Lang = + GrammarRon, + LexiconRon + ** { + +flags startcat = Phr ; unlexer = text ; lexer = text ; + +} ; diff --git a/next-lib/src/romanian/LexiconRon.gf b/next-lib/src/romanian/LexiconRon.gf new file mode 100644 index 000000000..c01c9bc09 --- /dev/null +++ b/next-lib/src/romanian/LexiconRon.gf @@ -0,0 +1,366 @@ +--# -path=.:../romance:../common:../abstract:../../prelude + +concrete LexiconRon of Lexicon = CatRon ** + open ParadigmsRon,BeschRon,MorphoRon in { + +flags + optimize=values ; + +lin + airplane_N = mkN "avion" ; + answer_V2S = mkV2S (mkV "răspunde") (noPrep Da) ; + apartment_N = mkN "apartament"; + apple_N = mkN "măr"; + art_N = mkN "artă" ; + ask_V2Q = mkV2Q (v_besch29 "întreba") (noPrep Ac) ; + baby_N = mkAnim (mkN "bebeluș" masculine) ; + bad_A = mk4A "rău" "rea" "răi" "rele" ; + bank_N = mkN "bancă" "bănci" ; + beautiful_A = mkRMut "frumos" ; + become_VA = mkVA (v_besch136 "deveni") ; + beer_N = mkN "bere" ; + beg_V2V = mkV2V (v_besch48 "ruga") (noPrep Ac) (noPrep Da) ; + big_A = regA "mare" ; + bike_N = mkN "bicicletă" ; + bird_N = mkN "pasăre" "păsări" ; + black_A = mkRMut "negru" ; + blue_A = regA "albastru" ; + boat_N = mkN "vapor" neuter ; + book_N = mkN "carte" "cărți" ; + boot_N = mkN "cizmă" ; + boss_N = mkAnim (mkN "șef" masculine) ; + boy_N = mkAnim (mkN "băiat" "băieți") ; + bread_N = mkN "pâine"; + break_V2 = dirV2 (v_besch97 "sparge") ; + broad_A = regA "larg" ; + brother_N2 = mkN2 (mkAnim(mkN "frate" masculine)) (noPrep Ge) ; + brown_A = invarA "maro" ; + butter_N = mkNR "unt"; + buy_V2 = dirV2 (v_besch35 "cumpăra"); + camera_N = compN (mkN "aparat" neuter) ["foto"] ; + cap_N = mkN "șapcă" "șepci" ; + car_N = mkN "mașină" ; + carpet_N = mkN "covor" neuter ; + cat_N = mkN "pisică" ; + ceiling_N = mkN "plafon" ; + chair_N = mkN "scaun" ; + cheese_N = mkN "brânză" "brânzeturi" "brânze" ; + child_N = mkAnim (mkN "copil" "copii" ) ; + church_N = mkN "biserică" ; + city_N = mkN "oraș" ; + clean_A = regA "curat" ; + clever_A = regA "deștept" ; + close_V2 = dirV2 (mkV "închide") ; + coat_N = mkN "haină" ; + cold_A = regA "rece" ; + come_V = v_besch136 "veni" ; + computer_N = mkN "calculator" neuter ; + country_N = mkN "țară" "țări" ; + cousin_N = mkAnim (mkN "văr" masculine) ; + cow_N = mkN "vacă" "vaci" ; + die_V = v_besch129 "muri" ; + dirty_A = regA "murdar" ; + distance_N3 = mkN3 (mkN "distanță") (mkPrep "de la" Ac) (mkPrep "la" Ac) ; + doctor_N = mkAnim (mkN "doctor") ; + dog_N = mkN "câine" masculine ; + door_N = mkN "ușă" "uși" ; + drink_V2 = dirV2 (v_besch73 "bea") ; + easy_A2V = mkA2V (mkRMut "ușor") (noPrep Ac) (noPrep Ac) ; + eat_V2 = dirV2 (v_besch52 "mânca") ; + empty_A = mkSMut "gol" ; + enemy_N = mkAnim (mkN "dușman" masculine) ; + factory_N = mkN "fabrică" ; + father_N2 = mkN2 (mkN "tată" "tați" masculine) (noPrep Ge); + fear_VS = mkVS (v_besch100 "teme") ; + fear_V2 = mmkV2 (mkRV (mkV100 "teme")) (mkPrep "de" Ac) ; + find_V2 = dirV2 (mkV "găsi") ; + fish_N = mkN "pește" masculine ; + floor_N = mkN "podea" ; + forget_V2 = dirV2 (v_besch18 "uita") ; + fridge_N = mkN "frigider" ; + friend_N = mkAnim (mkN "prieten") ; + fruit_N = mkN "fruct" ; + fun_AV = mkAV (regA "distractiv") (noPrep Ac) ; + garden_N = mkN "gradină" ; + girl_N = mkAnim (mkN "fată" "fete") ; + glove_N = mkN "mănușă" "mănuși" ; + gold_N = mkNR "aur" ; +good_A = mk5A "bun" "bună" "buni" "bune" "bine" ; +go_V = v_besch90 "merge" ; +green_A = regA "verde" ; +harbour_N = mkNR "port" ; +hate_V2 = dirV2 (mkV "urî") ; +hat_N = mkN "pălărie" ; +have_V2 = dirV2 (v_have) ; +hear_V2 = dirV2 (v_besch127 "auzi") ; +hill_N = mkNR "deal" ; +hope_VS = mkVS (v_besch17 "spera") ; +horse_N = mkN "cal" "cai" ; +hot_A = regA "cald" ; +house_N = mkN "casă" ; +important_A = regA "important" ; +industry_N = mkN "industrie" ; +iron_N = mkN "fier" masculine ; +king_N = mkAnim (mkN "rege" masculine) ; +know_V2 = dirV2 (v_besch122 "ști") ; +know_VS = mkVS (v_besch109 "cunoaște") ; +lake_N = mkNR "lac" ; +lamp_N = mkN "lampă" "lămpi" ; +learn_V2 = dirV2(v_besch45 "învăța") ; +leather_N = mkN "piele" "piei" ; +leave_V2 = dirV2 (mkV "părăsi") ; +like_V2 = dirV2 (v_besch71 "plăcea") ; +listen_V2 = dirV2 (v_besch18 "asculta") ; +live_V = mkV "trăi" ; +long_A = regA "lung" ; +lose_V2 = dirV2 (v_besch113 "pierde") ; +love_N = mkN "iubire" ; +love_V2 = dirV2 (mkV "iubi") ; +man_N = mkAnim (mkN "om" "oameni") ; +married_A2 = mkA2 (regA "căsătorit") (mkPrep "cu" Ac) ; +meat_N = mkN "carne" "cărnuri" "cărni" ; +milk_N = mkN "lapte" masculine ; +moon_N = mkN "lună" "luni" ; +mother_N2 = mkN2 (chV "mamă" (mkAnim (mkN "mamă"))) (noPrep Ge) ; +mountain_N = mkN "munte" masculine ; +music_N = mkN "muzică" ; +narrow_A = regA "îngust" ; +new_A = mk4A "nou" "nouă" "noi" "noi" ; +newspaper_N = mkN "ziar" ; +oil_N = mkNR "ulei" ; +old_A = regA "vechi" ; +open_V2 = dirV2 (mkV "deshide") ; +paint_V2A = mkV2A (mkV "picta") (noPrep Ac) (mkPrep "cu" Ac) ; +paper_N = mkN "hârtie" ; +paris_PN = mkPN "Paris" ; +peace_N = mkN "pace" "păci" ; +pen_N = mkNR "stilou" ; +planet_N = mkN "planetă" ; +plastic_N = mkN "plastic" ; +play_V2 = dirV2 (v_besch48 "juca") ; +policeman_N = mkAnim (mkN "polițist" masculine) ; +priest_N = mkAnim (mkN "preot" masculine) ; +probable_AS = mkAS (regA "probabil") ; +queen_N = mkAnim (mkN "regină" "regine") ; +radio_N = mkNR "radio"; +--rain_V0 = mkV0 (v_besch54 "ploua") ; +read_V2 = dirV2 (mkV "citi") ; +red_A = mk4A "roșu" "roșie" "roșii" "roșii" ; +religion_N = mkN "religie" ; +restaurant_N = mkN "restaurant" ; +river_N = mkN "fluviu" masculine ; +rock_N = mkN "piatră" "pietre" ; +roof_N = mkNR "acoperiș"; +rubber_N = mkNR "cauciuc"; + run_V = v_besch126 "fugi" ; + say_VS = mkVS (v_besch76 "spune") ; + school_N = mkN "școala" "școli" ; + science_N = mkN "știință" ; + sea_N = mkN "mare" "mări" ; + seek_V2 = dirV2 (v_besch24 "căuta") ; + see_V2 = dirV2 (v_besch67 "vedea") ; + sell_V3 = dirV3 (v_besch112 "vinde") ; + send_V3 = dirV3 (v_besch82 "trimite") ; + sheep_N = mkN "oaie" ; + ship_N = mkN "vapor" neuter ; + shirt_N = mkN "cămașă" "cămăși" ; + shoe_N = mkN "pantof" masculine ; + shop_N = mkN "magazin" ; + short_A = regA "scurt" ; + silver_N = mkN "argint" masculine ; + sister_N = mkAnim (mkN "soră" "surori") ; + sleep_V = v_besch128 "dormi" ; + small_A = mk4A "mic" "mică" "mici" "mici" ; + snake_N = mkN "șarpe" "șerpi" masculine ; + sock_N = mkN "șosetă" ; + speak_V2 = dirV2 (mkV "vorbi") ; + star_N = mkN "stea" ; + steel_N = mkNR "oțel" ; + stone_N = mkN "piatră" "pietre" ; + stove_N = mkN "sobă" ; + student_N = mkAnim (mkN "student" masculine) ; + stupid_A = regA "stupid" ; + sun_N = mkN "soare" "sori" masculine ; + switch8off_V2 = dirV2 (v_besch77 "stinge") ; + switch8on_V2 = dirV2 (mkV "aprinde") ; + table_N = mkN "masă" "mese" ; + talk_V3 = mmkV3 (mkV "vorbi") (noPrep Ac) (mkPrep "cu" Ac) ; + teacher_N = mkAnim (mkN "profesor") ; + teach_V2 = dirV2 (v_besch57 "preda") ; + television_N = mkN "televiziune" ; + thick_A = mkRMut "gros" ; + thin_A = regA "subțire" ; + train_N = mkNR "tren"; + travel_V = mkV "călători" ; + tree_N = mkN "copac" masculine ; + --trousers_N = mkN "pantalon" masculine ; + ugly_A = regA "urât" ; + understand_V2 = dirV2 (v_besch83 "înțelege") ; + university_N = mkN "universitate" ; + village_N = mkN "sat" neuter ; + wait_V2 = dirV2 (v_besch30 "aștepta") ; + walk_V = v_besch90 "merge" ; + warm_A = regA "calduț" ; + war_N = mkN "război" neuter ; + watch_V2 = dirV2 (mkV "privi") ; + water_N = mkN "apă" ; + white_A = regA "alb" ; + window_N = mkN "fereastră" "ferestre" ; + wine_N = mkNR "vin" ; + win_V2 = dirV2 (v_besch17 "câștiga") ; + woman_N = chV "femeie" (mkAnim (mkN "femeie")) ; + wonder_VQ = mkVQ (mkRV (regV "minuna")) ; + wood_N = mkN "lemn" ; + write_V2 = dirV2 (v_besch117 "scrie") ; + yellow_A = regA "galben" ; + young_A = mk5A "tânăr" "tânără" "tineri" "tinere" "tinerește" ; + + do_V2 = dirV2 (v_besch115 "face") ; + now_Adv = mkAdv "acum" ; + already_Adv = mkAdv "deja" ; + song_N = mkN "cântec" ; + add_V3 = dirV3 (v_besch23 "adăuga") ; + number_N = mkN "număr" ; + put_V2 = dirV2 (v_besch76 "pune") ; + stop_V = mkRV (regV "opri") ; + jump_V = v_besch118 "sări" ; + + left_Ord = mkOrd (regA "stâng") ; + right_Ord = mkOrd (mkRMut "drept") ; +far_Adv = mkAdv "departe" ; +correct_A = regA "corect" ; +dry_A = regA "uscat" ; +dull_A = regA "monoton"; +full_A = regA "plin" ; +heavy_A = mk4A "greu" "grea" "grei" "grele"; +near_A = regA "apropiat" ; +rotten_A = regA "stricat" ; +round_A = regA "rotund" ; +sharp_A = regA "ascuțit" ; +smooth_A = regA "neted" ; +straight_A = mkRMut "drept" ; +wet_A = regA "ud" ; +wide_A = regA "adânc" ; + animal_N = mkN "animal" ; + ashes_N = mkN "cenușă" "cenuși" ; + back_N = mkN "spate" "spate" neuter ; + bark_N = mkNR "lătrat" ; + belly_N = mkN "pântec" ; + blood_N = mkNR "sânge" ; + bone_N = mkN "os" ; + breast_N = mkNR "piept" ; + cloud_N = mkN "nor" ; + day_N = mkN "zi" feminine ; + dust_N = mkNR "praf" ; + ear_N = mkN "ureche" ; + earth_N = mkNR "pământ" ; + egg_N = mkN "ou" "ouă" neuter ; + eye_N = mkN "ochi" masculine ; + fat_N = mkN "grăsime" ; + feather_N = mkN "pană" "pene" ; + fingernail_N = mkN "unghie" ; + fire_N = mkNR "foc" ; + flower_N = mkN "floare" "flori" ; + fog_N = mkN "ceață" "cețuri" "ceți" ; + foot_N = mkN "picior" neuter ; + forest_N = mkN "pădure" ; + grass_N = mkN "iarbă" "ierburi" "ierbi" ; + guts_N = mkN "intestin" ; + hair_N = mkN "păr" masculine ; + hand_N = mkN "mână" "mâini" ; + head_N = mkN "cap" "capete" neuter ; + heart_N = mkN "inimă" ; + horn_N = mkNR "corn" ; + husband_N = mkAnim (mkN "soț" masculine) ; + ice_N = mkN "gheață" "ghețuri" "gheți" ; + knee_N = mkN "genunchi" masculine ; + leaf_N = mkN "frunză" ; + leg_N = mkN "picior" neuter ; + liver_N = mkN "ficat" ; + louse_N = mkN "păduche" masculine ; + mouth_N = mkN "gură" ; + name_N = mkN "nume" "nume" neuter ; + neck_N = mkNR "gât" ; + night_N = mkN "noapte" "nopți" ; + nose_N = mkNR "nas" ; + person_N = mkAnim (mkN "persoană") ; + rain_N = mkN "ploaie" ; + road_N = mkNR "drum" ; + root_N = mkN "rădăcină" ; + rope_N = mkN "sfoară" "sfori" ; + salt_N = mkN "sare" "săruri" "sări"; + sand_N = mkNR "nisip" ; + seed_N = mkN "sămânță" "semințe" ; + skin_N = mkN "piele" "pieli" "piei" ; + sky_N = mkNR "cer" ; + smoke_N = mkNR "fum" ; + snow_N = mkN "zăpadă" "zăpezi" ; + stick_N = mkN "băț" ; + tail_N = mkN "coadă" "cozi" ; -- mkN "coadă" feminine - certain kind of tails + tongue_N = mkN "limbă" "limbi"; + tooth_N = mkN "dinte" masculine ; + wife_N = mkAnim (mkN "soție"); + wind_N = mkNR "vânt" ; + wing_N = mkN "aripă" ; + worm_N = mkN "vierme" masculine; + year_N = mkN "an" masculine; + bite_V2 = dirV2 (v_besch22 "mușca") ; + blow_V = v_besch55 "sufla" ; + breathe_V = v_besch17 "respira" ; + burn_V = mkV "arde" ; + count_V2 = dirV2 (v_besch35 "număra" ) ; + cut_V2 = dirV2(v_besch14 "tăia") ; + dig_V = v_besch23 "săpa" ; + fall_V = v_besch65 "cădea" ; + fight_V2 = dirV2 (v_besch18 "lupta") ; + float_V = mkV "pluti" ; + flow_V = v_besch89 "curge" ; + fly_V = v_besch48 "zbura" ; + freeze_V = v_besch29 "îngheța" ; + give_V3 = dirV3 (v_besch60 "da") ; + hit_V2 = dirV2 (mkV "lovi") ; + hunt_V2 = dirV2 (mkV "vâna") ; + kill_V2 = dirV2 (v_besch81 "ucide") ; + laugh_V = v_besch91 "râde" ; + lie_V = mkRV (regV "întinde") ; + play_V = mkNV (mkV48 "juca") ; + pull_V2 = dirV2 (v_besch78 "trage") ; + push_V2 = dirV2 (v_besch77 "împinge") ; + rub_V2 = dirV2 (v_besch29 "freca") ; + scratch_V2 = dirV2 (v_besch23 "scărpina") ; + sew_V = v_besch110 "coase" ; + sing_V = v_besch18 "cânta" ; + sit_V = mkRV (mkV41 "așeza") ; + smell_V = v_besch133 "mirosi" ; + spit_V = v_besch17 "scuipa" ; + squeeze_V2 = dirV2 (v_besch88 "stoarce") ; + stab_V2 = dirV2 (v_besch12 "înjunghia") ; + stand_V = v_besch17 "ridica" ; + suck_V2 = dirV2 (v_besch95 "suge") ; + swell_V = v_besch55 "umfla" ; + swim_V = v_besch32 "înota" ; + think_V = mkV "gândi" ; + throw_V2 = dirV2 (v_besch17 "arunca") ; + tie_V2 = dirV2 (v_besch29 "lega") ; + turn_V = v_besch88 "întoarce" ; + vomit_V = v_besch18 "vomita" ; + wash_V2 = dirV2 (v_besch45 "spăla") ; + wipe_V2 = dirV2 (v_besch83 "șterge") ; + + hold_V2 = dirV2 (v_besch108 "ține") ; + split_V2 = dirV2 (v_besch134 "despărți"); + -- sit_V = v_besch41 "așeza" ; + +grammar_N = mkN "gramatică" ; +language_N = mkN "limbă" "limbi" ; +rule_N = mkN "regulă" "reguli" ; + +john_PN = mkPN "Ion" ; +question_N = mkN "întrebare" ; +ready_A = regA "pregătit" ; +reason_N = mkN "motiv" ; +today_Adv = mkAdv "astăzi" ; +uncertain_A = regA "nesigur" ; + + +} ; diff --git a/next-lib/src/romanian/MorphoRon.gf b/next-lib/src/romanian/MorphoRon.gf new file mode 100644 index 000000000..de66be4ce --- /dev/null +++ b/next-lib/src/romanian/MorphoRon.gf @@ -0,0 +1,2428 @@ +--# -path=.:../Romance:../common:../../prelude + +resource MorphoRon = ResRon ** + open Prelude, Predef in { + +flags optimize=noexpand ; + +--------------------------------------------------------------------------------- +------------------------------ARTICLES------------------------------------------- +--------------------------------------------------------------------------------- + +--defined article (enclitic) +-- we need two forms, as the Singular AGenDat form for Feminine is obtained from the +-- Plural form, except for irregular nouns that need an additional form + +oper artDf : Str -> Str -> Gender -> Number -> ACase -> Str = +\bun, buni, g, n, a -> +case of +{ => case last bun of + { "u" => bun + "l"; + "e" => bun + "le"; + "ă" => bun + "a"; + _ => bun + "ul" + }; + => case last bun of + {("u"|"e" ) => bun + "lui" ; + _ => bun + "ului" + }; + => case bun of + { x+"u" => bun + "le"; + x + "itor" => bun + "ule" ; + x + ("en"|"or") => bun + "e" ; + x+("e"|"ă") => bun; + _ => bun + "ule" + }; + => buni + "i"; + => buni + "lor"; + => case bun of + { x + ("a"|"i") => bun + "ua"; + x + "ie" => x + "ia"; + x + "ă" => x + "a"; + _ => bun + "a" + }; + + => case bun of + { x + ("a"|"e")+"ie" => buni+"i"; + x + "ie" => bun + "i"; + _ => buni + "i" + }; + + => case bun of + { x + "ă" => x + "o"; + x + "ie" => x + "io"; + _ => bun + "o" + }; + => buni + "le"; + => buni + "lor" + }; + +--Undefined article (proclitical) -- +--we keep the non-articled form of the noun and glue it with the article on syntactical level + +oper artUndef : Gender -> Number -> NCase -> Str = \g,n,a -> +case of +{ => "un"; => "un" ; => "unui"; => "unui" ;<_,_,Vo> => "" ; + <_,Pl,No> => "niște"; <_,Pl,Ac> => "niște"; <_,Pl,Da> => "unor"; <_,Pl,Ge> => "unor" ; + => "o"; => "o"; => "unei"; => "unei" +}; + +--possesive article +-- used for Cardinals and for Genitive case + +oper artPos : Gender -> Number -> Str = \g,n -> + case of +{ => "al"; + => "ai"; + => "a"; + => "ale" +}; + + +--demonstrative article +-- used as Determined article in order to emphasise on the noun/adjective, and for Dative/Genitive for of ordinals + +oper artDem : Gender -> Number -> ACase -> Str = \g,n,c -> + case of +{ => "cel"; => "cei"; => "celui"; + => "cea"; => "cele"; => "celei"; + <_,Pl,AGenDat> => "celor"; + => "cel"; + => "cei"; => "cea"; => "cele" + +}; + +--flexion forms of a noun without article + +oper artUnf : Str -> Str -> Gender -> Number -> ACase -> Str = \buna,bune,g,n,a -> +case of +{ => buna ; => bune ; + => buna ; => bune ; => buna; + => bune +} ; + +--undefined article form + +oper artUndefMasc : Str -> Number -> ACase -> Str = \s,n,a -> s; + +oper artUndefFem : Str -> Str -> Number -> ACase -> Str = \buna, bune, n, a -> +case of +{ + => buna; + => bune; + => buna; + => bune +}; + + + +--------------------------------------------------------------------------------- +------------------------------- NOUNS-------------------------------------------- +--------------------------------------------------------------------------------- + +-- the irregular nouns (of feminine gender) need 3 forms in order to build the +-- morfological table : (Singular ANomAcc Indef, Plural ANomAcc Indef and +-- Singular AGenDat Indef) + + +oper mkNomVIrreg : Str -> Str -> Str -> Noun = \iarba, ierburi, ierbi -> +let noun = mkNomIrreg iarba ierburi NFem + in + {s = \\n,a,c => case n of + {Sg => case c of + {AGenDat => case a of {Indef => ierbi; + Def => artDf iarba ierbi Fem Sg AGenDat + }; + _ => noun.s ! Sg ! a ! c + }; + Pl => noun.s ! Pl ! a ! c + }; + g = NFem ; + a = Animate + }; + +-- usual nouns need two forms (Singular + Plural ANomAcc Indef) +-- because the Neuter behaves like Masculine for Singular and Feminine for Plural, +-- we pass 2 parameters - gender for Singular and for Plural, so that we can define +-- the forms for Neuter as a combination of Feminine and Masculine + + +oper mkNomIrreg : Str -> Str -> NGender -> Noun = \obiect, obiecte , gen -> + case gen of + { NMasc => {s = mkNom obiect obiecte Masc Masc ; g = gen ; a = Animate }; + NFem => {s = mkNom obiect obiecte Fem Fem ; g = gen ; a = Animate }; + NNeut => {s = mkNom obiect obiecte Masc Fem ; g = gen ; a = Animate } + }; + +--creates the table for a noun : + +oper mkNom : Str -> Str -> Gender -> Gender -> Number => Species => ACase => Str = \obiect, obiecte, gs, gp -> + table { Sg => table {Def => \\p => artDf obiect obiecte gs Sg p; + Indef => \\p => artUnf obiect obiecte gs Sg p + }; + Pl => table { Def => \\p => artDf obiect obiecte gp Pl p ; + Indef => \\p => artUnf obiect obiecte gp Pl p + } + } ; + + +-- for regular nouns, we need just the Singular ANomAcc Indef form : +-- for obtaining the plural form, we apply almost the same rules as for adjectives +-- for Neuter we treat the Singular ANomAcc Indef for as the Masculine Singular form of an Adjective +-- and we obtains it's plural form as the Feminine Plural form of the adjective +-- (with potential o -> oa mutations, that occur in most of the cases) + +mkNomReg : Str -> NGender -> Noun = \obiect, g -> +case g of + {NMasc => mkNomIrreg obiect ((mkAdjReg obiect).s ! (AF Masc Pl Indef ANomAcc)) NMasc ; + NFem => case (Predef.dp 4 obiect) of + { "ai"+x+"ă" => mkNomIrreg obiect (init obiect + "e") NFem ; --always + _ => case (Predef.dp 3 obiect) of + {"i"+("c"|"n"|"m"|"p")+"ă" => mkNomIrreg obiect (init obiect + "i") NFem ; -- 60% cases frequently used words, not frequent for neological words + _ => mkNomIrreg obiect (mkFemPl obiect) NFem + } + }; + NNeut => if_then_else Noun (pbool2bool (Predef.occur "o" (Predef.dp 3 obiect) )) + (mkNomIrreg obiect ((mkAdjRegO obiect).s ! (AF Fem Pl Indef ANomAcc)) NNeut) + (mkNomIrreg obiect ((mkAdjReg obiect).s ! (AF Fem Pl Indef ANomAcc)) NNeut) + }; + +--for nouns that have a different vocative form than the one inferred + +mkVocc : Noun -> Str -> Noun = \n -> \vo -> + {s = table{ Sg => \\p, c => case c of + { AVoc => vo ; + _ => n.s ! Sg ! p ! c + }; + Pl => \\p,c => n.s ! Pl ! p ! c + }; + g = n.g ; + a = n.a + + }; + + -- composes a noun with an invariable string ( Ex camera foto) + -- with/without dash + + ccompose : Noun -> Str -> Noun = \noun, y -> + { s = \\n,p,c => noun.s ! n ! p ! c +"-"+ y ; + g = noun.g ; + a = noun.a + }; + + + composeN : Noun -> Str -> Noun = \noun, y -> + { s = \\n,p,c => noun.s ! n ! p ! c ++ y ; + g = noun.g ; + a = noun.a + }; + + -- changes the Animacy attribute + + mkInanimate : Noun -> Noun = \n -> + {s = table { Sg => \\p,c => case c of + {AVoc => n.s ! Sg ! Indef ! ANomAcc ; + _ => n.s ! Sg ! p ! c + }; + Pl => \\p, c => n.s ! Pl ! p ! c + }; + g = n.g ; + a = Inanimate + }; + + mkAnimate : Noun -> Noun = \n -> + let ob = n.s ! Sg ! Indef ! ANomAcc ; + obs = n.s ! Pl ! Indef ! ANomAcc + in + {s = table { Sg => \\p,c => case of + { => n.s ! Sg ! Indef ! ANomAcc ; + => case (n.g) of + {NFem => artDf ob obs Fem Sg AVoc ; + _ => artDf ob obs Masc Sg AVoc + } ; + _ => n.s ! Sg ! p ! c + }; + Pl => \\p, c => n.s ! Pl ! p ! c + }; + g = n.g ; + a = Animate +}; + +--a special case of neuter nouns -- the ones that just add -ri/-uri to the Singular Form + +mkNomNeut : Str -> Noun = \obiect -> +case last obiect of +{"u" => mkNomIrreg obiect (obiect + "ri") NNeut; + _ => mkNomIrreg obiect (obiect + "uri") NNeut +}; + + +--------------------------------------------------------------------------------- +-----------------------------ADJECTIVES------------------------------------------ +--------------------------------------------------------------------------------- + + + +-- in the worst case, the adjective needs 5 forms for Singular/Plural - Masculine/Feminine + Adverb + + +oper mkAdjSSpec : Str -> Str -> Str -> Str -> Str -> Adj += \bun -> \buna -> \buni -> \bune -> \bine -> +{ s = table {AF Masc Sg Def c => artDf bun buni Masc Sg c ; + AF Fem Sg Def c => artDf buna bune Fem Sg c ; + AF Masc Pl Def c => artDf bun buni Masc Pl c; + AF Fem Pl Def c => artDf buna bune Fem Pl c ; + AF Masc Pl Indef c => artUndefMasc buni Pl c; + AF Fem Pl Indef c => artUndefFem buna bune Pl c; + AF Masc Sg Indef c => artUndefMasc bun Sg c; + AF Fem Sg Indef c => artUndefFem buna bune Sg c; + AA => bine + } + +}; + +-- usually the determined adverb is identical to the Singular Masculine form of the adjective + +oper mkAdjSpec : Str -> Str -> Str -> Str -> Adj += \bun -> \buna -> \buni -> \bune -> + mkAdjSSpec bun buna buni bune bun ; + + +-- special classes of adjectives : + +oper adjAuriu : Str -> Adj = \s -> + let f = init s + "e"; + pl = init s + "i" + in + mkAdjSpec s f pl pl ; + +oper adjMuncitor : Str -> Adj = \s -> + let f = Predef.tk 2 s + "oare"; + pl = s + "i"; + adv = s + "ește" + in + mkAdjSSpec s f pl f adv ; + + oper adjRomanesc : Str -> Adj = \s -> + let f = Predef.tk 2 s + "ască"; + pl = Predef.tk 2 s + "ști"; + adv = Predef.tk 2 s + "ște" + in + mkAdjSSpec s f pl pl adv ; + +oper adjMare : Str -> Adj = \s -> + let pl = mkStemPlReg s + in + mkAdjSpec s s pl pl; + +oper adjDimin : Str -> Adj = \s -> + let f = Predef.tk 2 s + "ică"; + pl = init s + "i"; + plf = s + "e" + in + mkAdjSpec s f pl plf; + + + -- the phonetical mutations that occur in Romanian (Singular Masculine -> Singular Feminine) are + -- o -> oa (Ex : frumos -> frumoasă) + -- e -> ea / ie -> ia (Ex : des -> deasă) + -- on the last occurence of o/e in the word (usually 2rd or 3rd last letter) + + mkStemMutE : Str -> Str = \s -> + let s1 = if_then_Str (pbool2bool (Predef.occur "ie" (Predef.dp 4 s))) ((Predef.tk 3 s) +"a"+(Predef.dp 2 s)) ((Predef.tk 3 s) +"ea" + (Predef.dp 2 s)); + s2 = if_then_Str (pbool2bool (Predef.occur "ie" (Predef.dp 3 s))) ((Predef.tk 2 s) +"a" + (last s)) ((Predef.tk 2 s) +"ea" + (last s)) + in + case Predef.dp 3 s of + {"e"+x => s1; + _ => s2 + }; + + mkStemMutO : Str -> Str = \s -> + case Predef.dp 3 s of + {"o"+x => (Predef.tk 3 s) +"oa" + x; + _ => (Predef.tk 2 s) + "oa" + (last s) + }; + + -- another phonetical mutation is ă -> e (Ex : proaspătă -> proaspete) + -- Singular Feminine -> Plural Feminine + -- on the last occurence of ă -- 2nd last letter of the root + + mkStemMutA : Str -> Str = \s -> + case (Predef.dp 2 s) of + { "ă" + x => (Predef.tk 2 s) + "e" + (last s); + _ => s + }; + + +-- obtaining the Masculine Plural form from the Masculine Singular +-- contains most usual mutations + +oper mkStemPlReg : Str -> Str = \s -> +case s of +{x + ("st"|"sc"|"șc")=> x + "ști"; -- always -- usually the nouns/adj can end in an "u", but we eliminate that first + x + "str" => x + "ștri"; + x + "s" => x + "și"; + x + "x" => x + "cși"; + x + "xt" => x + "cști"; + x + "ian" => x + "ieni"; + x + "ean" => x + "eni"; + x + "ead" => x + "ezi"; + x + ("de"|"d") => x + "zi"; + x + ("te"|"tă"|"t") => x + "ți"; + x + ("e"|"i"|"a"|"ă")=> x + "i"; + _ => s + "i" +}; --all the mutations occur always for adjectives, appart from the exception that mutate other syllables from the word + + +-- special cases that imply other mutations that don't occur for all words +-- because these rules don't apply for neological words, which are more frequent, they are treated +-- separately + +oper mkStemPlSpec : Str -> Str = \s -> +case s of +{x + "l" => x + "i"; + x + "z" => x + "j"; + _ => s +}; + + +--obtaining the Feminine Singular form from the Masculine Singular one for Adjectives : + +mkFemSg : Str -> Str = \s -> +case s of +{x + "hi" => x + "he"; + x + "i" => s + "e"; + x + "iu" => x + "ie"; + x + "u" => x + "ă"; + _ => s + "ă" +}; + +-- obtaining the Feminine Plural from Feminine Singular for Nouns : + +mkFemPl : Str -> Str = \s -> +case s of +{ x + "are" => x + "ări"; --always + x + ("ui"|"ai") => s + "e"; -- from Masc (adjectives) + x + "ură" => x + "uri"; -- always + x + "oaie" => x + "oi"; -- almost always + x + "aie" => x + "ăi"; --always + x + "eie" => x + "ei"; --always + x + "i" => s + "le" ; --always - special cases of Feminines ending in "i" like zi = day + x + "a" => x + "le"; --always - special cases of Feminines ending in "a" -- most of Turkish origine like cafea = coffee + x + "une" => x + "uni"; --always - abstract collective nouns like "națiune" = nation, French origine + x + "ate" => x + "ăți"; --always same as above like "libertate" = freedom-- x + "șă" => x + "și"; -- 70% of cases + x + "re" => x + "ri"; -- almost always, exception nouns ending in "oare" which are treated as special case in adjReg + x + "e" => x + "i"; -- almost always for Nouns, always for Adjectives + _ => case init s of + { + x + ("g"|"h"|"nc") => (init s) + "i"; -- always for Adjectives, almost always for Nouns (g - ending has exceptions) + + x + "ăt" => x + "ete"; --always + x + "ânt" => x + "inte"; --always + _ => case s of + { x + "ă" => x + "e" ; -- default -- exception occur + _ => s + "e" -- worst case + } + + } +}; + + +--obtainint Feminine Plural from Masculine Singular for Adjectives : + +mkFemAdj : Str -> Str = \s -> +case s of +{ x + ("g"|"h"|"nc") => s + "i"; + x + "ânt" => x + "inte"; + x + "ăt" => x + "ete"; + _ => s + "e" + +}; + + +--------------------------------------------------------------- + +-- invariable adjective - where all the forms are identical + +mkAdjInvar : Str -> Adj = \s -> +{s = table {AF g n a c => s ; + AA => s + } + }; + +-- regular adjective - just the Masculine Singular Form is needed + +mkAdjReg : Str -> Adj = \s -> + let r = mkStemMutA s ; + rad = if_then_Str (pbool2bool (Predef.occur "u" (last r))) (init r) r; + radF = if_then_Str (pbool2bool (Predef.occur "u" (last s))) (init s) s + in + case s of + {x + "tor" => adjMuncitor s; + x + "esc" => adjRomanesc s; + x + "e" => adjMare s; + x + "iu" => adjAuriu s; + x + "el" => adjDimin s; + _ => mkAdjSpec s (mkFemSg radF) (mkStemPlReg rad) (mkFemAdj rad) + + }; + + -- regular adjective that has the e -> ea mutation from Masculine Singular to Feminine Singular + + mkAdjRegE : Str -> Adj = \s -> + let rad = if_then_Str (pbool2bool (Predef.occur "u" (last s))) (init s) s + in + mkAdjSpec s (mkFemSg (mkStemMutE rad)) (mkStemPlReg rad) (mkFemAdj rad); + + +-- regular adjective that has the e -> ea mutation as above, and also the l -> _ / z -> j +-- mutations from Masculine Singular -> Masculine Plural + + mkAdjSpecE : Str -> Adj = \s -> + let rad = if_then_Str (pbool2bool (Predef.occur "u" (last s))) (init s) s + in + mkAdjSpec s (mkFemSg (mkStemMutE rad)) (mkStemPlSpec rad) (mkFemAdj rad); + +-- regular adjective that has the o -> oa mutation from Masculine Singular to Feminine Singular + + mkAdjRegO : Str -> Adj = \s -> + let rad = if_then_Str (pbool2bool (Predef.occur "u" (last s))) (init s) s + in + mkAdjSpec s (mkFemSg (mkStemMutO rad)) (mkStemPlReg rad) (mkFemPl (mkStemMutO rad)); + + -- regular adjective that has the o -> oa mutation as above and also the l -> _ / z -> j + -- mutations from Masculine Singular -> Masculine Plural + + mkAdjSpecO : Str -> Adj = \s -> + let rad = if_then_Str (pbool2bool (Predef.occur "u" (last s))) (init s) s + in + mkAdjSpec s (mkFemSg (mkStemMutO rad)) (mkStemPlSpec rad) (mkFemPl (mkStemMutO rad)); + + + -- the two categories mkAdjRegE and mkAdjRegO have been merge into one category of adjectives + -- that have mutations from Masculine Singular to Feminine Singular + + mkRegMut : Str -> Adj = \s -> + let rad = if_then_Str (pbool2bool (Predef.occur "u" (last s))) (init s) s + in + if_then_else Adj (pbool2bool (Predef.occur "o" (Predef.dp 3 rad))) + (mkAdjSpec s (mkFemSg (mkStemMutO rad)) (mkStemPlReg rad) (mkFemPl (mkStemMutO rad))) + (mkAdjSpec s (mkFemSg (mkStemMutE rad)) (mkStemPlReg rad) (mkFemAdj rad)); + + -- the two categories mkAdjSpecE and mkAdjSpecO have been merge into one category of adjectives + -- that have mutations from Masculine Singular to Feminine Singular + -- and also from Masculine Singular to Masculine Plural + +mkSpecMut : Str -> Adj = \s -> + let rad = if_then_Str (pbool2bool (Predef.occur "u" (last s))) (init s) s + in + if_then_else Adj (pbool2bool (Predef.occur "o" (Predef.dp 3 rad))) + (mkAdjSpec s (mkFemSg (mkStemMutO rad)) (mkStemPlSpec rad) (mkFemPl (mkStemMutO rad))) + (mkAdjSpec s (mkFemSg (mkStemMutE rad)) (mkStemPlSpec rad) (mkFemAdj rad)); + + + + + + +----------------------------------------------------------------------------------- +------------------------------VERBS------------------------------------------------ +----------------------------------------------------------------------------------- + +--with rules based on the book "Conjugarea verbelor romanesti" by Ana-Maria Barbu-- + + +-- for building the table for a verb, there are needed 29 forms +-- infinitive - 1 form +-- tables for Present, Imperfect, Past Simple, Past Perfect - 24 forms +-- 3rd person Singular form for Conjunctive Present (= 3rd person Plural) - 1 form +-- Adjective that describes the Past Participe Form (regular adjective)- 1 form +-- Gerund - 1 form +-- 2nd person Singular form for Imperative - 1 form + + Verbe : Type = VForm => Str ; + + verbAffixes : + Str-> (a,b,c,d: Number => Person => Str) -> Str -> Adj -> Str -> Str -> Verbe = + \fi,pres, imperf, pSimple, pPerf, subj, adj, ger, imp -> + table { + Inf => fi ; + Indi Presn n p => pres ! n ! p ; + Indi Imparf n p => imperf ! n ! p; + Indi PSimple n p => pSimple ! n ! p ; + Indi PPerfect n p => pPerf ! n ! p ; + Subjo SPres n P3 => subj ; + Subjo SPres n p => pres ! n ! p; + Imper SgP2 => imp ; + Imper PlP2 => pres ! Pl ! P2 ; + Imper PlP1 => pres ! Pl ! P1 ; + Ger => ger ; + PPasse g n a d => adj. s ! (AF g n a d) + } ; + + +-- syntactical verb : +-- obtains all the verb forms present in Romanian, based on the primitive forms found in Verbe + +SVerbe : Type = VerbForm => Str ; + + mkVerb : Verbe -> SVerbe = \vb -> + table { + TInf => "a" ++ vb ! Inf ; + TIndi TPresn n p => vb ! (Indi Presn n p) ; + TIndi TImparf n p => vb ! (Indi Imparf n p); + TIndi TPComp n p => pComp ! n ! p ++ vb ! (PPasse Masc Sg Indef ANomAcc) ; + TIndi TPSimple n p => vb ! (Indi PSimple n p) ; + TIndi TPPerfect n p => vb ! (Indi PPerfect n p) ; + TIndi TFutur n p => pFut ! n ! p ++ vb ! Inf ; + TSubjo TSPres n p => "să" ++ vb ! (Subjo SPres n p) ; + TSubjo TSPast n p => "să" ++ "fi" ++ vb ! (PPasse Masc Sg Indef ANomAcc) ; + TCondi n p => pCond ! n ! p ++ vb ! Inf ; + TImper PlP1 => "să" ++ vb ! (Imper PlP1) ; + TImper p => vb ! (Imper p) ; + TGer => vb ! Ger ; + TPPasse g n a d => vb ! (PPasse g n a d) + }; + +-- auxiliary for Past Composite (to have - as auxiliary) : + +pComp : Number => Person => Str = table {Sg => table {P1 => "am" ; P2 => "ai" ; P3 => "a"} ; + Pl => table {P1 => "am" ; P2 => "ați"; P3 => "au"} + }; + +-- auxiliary for Future Simple : + +pFut : Number => Person => Str = table {Sg => table {P1 => "voi" ; P2 => "vei" ; P3 => "va"} ; + Pl => table {P1 => "vom" ; P2 => "veți"; P3 => "vor"} + }; + +--auxiliary for Condional Present : + +pCond : Number => Person => Str = table {Sg => table {P1 => "aș" ; P2 => "ai" ; P3 => "ar"} ; + Pl => table {P1 => "am" ; P2 => "ați"; P3 => "ar"} + }; + +-- make Reflexive verbe : ? with variants ? +-- syntactical category of reflexive verbs based on the primitive forms in Verbe + +mkVerbRefl : Verbe -> SVerbe = \vb -> +table { + TInf => "a" ++ "se" ++ vb ! Inf ; + TIndi TPresn n p => pronRefl ! n ! p ++ vb ! (Indi Presn n p) ; + TIndi TImparf n p => pronRefl !n ! p ++ vb ! (Indi Imparf n p); + TIndi TPComp n p => pronReflClit ! n ! p + "-" + pComp ! n ! p ++ vb ! (PPasse Masc Sg Indef ANomAcc) ; + TIndi TPSimple n p => pronRefl ! n ! p ++ vb ! (Indi PSimple n p) ; + TIndi TPPerfect n p => pronRefl ! n ! p ++ vb ! (Indi PPerfect n p) ; + TIndi TFutur n p => pronRefl ! n ! p ++ pFut ! n ! p ++ vb ! Inf ; + TSubjo TSPres n p => "să" ++ pronRefl ! n ! p ++ vb ! (Subjo SPres n p) ; + TSubjo TSPast n p => "să" ++ pronRefl ! n ! p ++ "fi" ++ vb ! (PPasse Masc Sg Indef ANomAcc) ; + TCondi n p => pronReflClit ! n ! p + "-" + pCond ! n ! p ++ vb ! Inf ; + TImper PlP1 => "să" ++ pronRefl ! Pl ! P1 ++ vb ! (Imper PlP1) ; + TImper PlP2 => vb ! (Imper PlP2) + "-"+ pronRefl ! Pl ! P2 ; + TImper SgP2 => vb ! (Imper SgP2) + "-"+ pronRefl ! Sg ! P2 ; + TGer => vb ! Ger + "u" + "-" + pronRefl ! Sg ! P3 ; + TPPasse g n a d => vb ! (PPasse g n a d) + }; + +-- reflexive pronouns - full form + +pronRefl : Number => Person => Str = +table {Sg => table {P1 => "mă" ; P2 => "te" ; P3 => "se"}; + Pl => table {P1 => "ne" ; P2 => "vă" ; P3 => "se" } +}; + +-- reflexive pronouns - short form (clitics) + +pronReflClit : Number => Person => Str = +table {Sg => table {P1 => "m" ; P2 => "te" ; P3 => "s"}; + Pl => table {P1 => "ne" ; P2 => "v" ; P3 => "s" } +}; + + +{- + verbAffixes1 : + Str-> (a,b,c,d: Number => Person => Str) -> (e,f,g,h : Str) -> Verbe = + \fi,pres, imperf, pSimple, pPerf, subj, part, ger, imp -> + table { + Inf => fi ; + Indi Presn n p => pres ! n ! p ; + Indi Imparf n p => imperf ! n ! p; + Indi PComp n p => "aa" ++ part ; + Indi PSimple n p => pSimple ! n ! p ; + Indi PPerf n p => pPerf ! n ! p ; + Indi Futur n p => "va" ++ fi ; + Condi n p => "as" ++ fi ; + Subjo SPres n P3 => subj ; + Subjo SPres n p => pres ! n ! p; + Subjo SPast n p => "sa" ++ "fi" ++ part ; + Imper SgP2 => imp ; + Imper PlP2 => pres ! Pl ! P2 ; + Imper PlP1 => "sa" ++ pres ! Pl ! P1 ; + Part PPres => ger ; + Part (PPasse g n a d) => (mkAdjReg part). s ! (AF g n a d) + } ; +-} + +-- This is a conversion to the type in $CommonRomance$. + +oper + vvf : (VerbForm => Str) -> (VF => Str) = \aller -> table { + VInfin _ => aller ! TInf ; + VFin (VPres Indic) n p => aller ! TIndi TPresn n p ; + VFin (VPres Subjunct) n p => aller ! TSubjo TSPres n p ; + VFin (VImperf Indic) n p => aller ! TIndi TImparf n p ; --# notpresent + VFin (VImperf Subjunct) n p => aller ! TSubjo TSPast n p ; --# notpresent + VFin VPasse n p => aller ! TIndi TPComp n p ; --# notpresent + VFin VFut n p => aller ! TIndi TFutur n p ; --# notpresent + VFin VCondit n p => aller ! TCondi n p ; --# notpresent + VImper np => aller ! TImper np ; + VPart g n a d => aller ! TPPasse g n a d ; + VGer => aller ! TGer + } ; + + + +-- vowells in Romanian - used for clitics + + vocale : Str = ("a"|"e"|"i"|"u"|"ă"|"î"|"â"); + +-- phonetical mutations that occur when declining verbs : + +-- last ă in the word -> a + +modALast : Str -> Str = \root -> +if_then_Str (pbool2bool (Predef.occur "ă" (Predef.dp 2 root))) + ((Predef.tk 2 root) + "a" + (last root)) ((Predef.tk 3 root) + "a" + (Predef.dp 2 root)); + +-- last u in the word -> o + +modU : Str -> Str = \root -> +if_then_Str (pbool2bool (Predef.occur "u" (Predef.dp 2 root))) + ((Predef.tk 2 root) + "o" + (last root)) ((Predef.tk 3 root) + "o" + (Predef.dp 2 root)); + +-- first ă in the word -> a + +modAFirst : Str -> Str = \root -> +if_then_Str (pbool2bool (Predef.occur "ă" (Predef.take 2 root))) + ((Predef.take 1 root) + "a" + (Predef.drop 2 root)) ((Predef.take 2 root) + "a" + (Predef.drop 3 root)); + +-- ă -> a (general) + +modA : Str -> Str = \root -> + if_then_Str (pbool2bool (Predef.occur "ă" (Predef.dp 3 root))) (modALast root) (modAFirst root) ; + + +-- e -> ea mutation (general) + +mkMutE : Str -> Str = \root -> + if_then_Str (pbool2bool (Predef.occur "e" (Predef.dp 3 root))) (mkStemMutE root) + (mkStemMutE (Predef.take 4 root) + (Predef.drop 4 root)) ; + +-- o -> oa mutation (general) + +mkMutO : Str -> Str = \root -> + if_then_Str (pbool2bool (Predef.occur "o" (Predef.dp 3 root))) (mkStemMutO root) + (mkStemMutO (Predef.take 4 root) + (Predef.drop 4 root)) ; + +-- general mutation - last occurence of a letter in the word is replaced by other string +-- the letter should occurd 2nd or 3rd last in the word + +--for replacing 1 character with a string +genMut : Str -> Str -> Str -> Str = \root, e, a -> + if_then_Str (pbool2bool (Predef.occur e (Predef.dp 2 root))) + ((Predef.tk 2 root) + a + (last root)) ((Predef.tk 3 root) + a + (Predef.dp 2 root)); + +-- for replacing 2 characters with a string + +genMut2 : Str -> Str -> Str -> Str = \root,e , a -> + if_then_Str (pbool2bool (Predef.occur e (Predef.dp 3 root))) + ((Predef.tk 3 root) + a + (last root)) ((Predef.tk 4 root) + a + (Predef.dp 2 root)); + + +-- oa -> o mutation (last occurence in the word) + +mkStemMutOa : Str -> Str = \s -> + case Predef.dp 4 s of + {"oa" + x => (Predef.tk 4 s) + "o" + x; + _ => (Predef.tk 3 s) + "o" + (last s) + }; + + +-- Affixes : +-- It is convenient to have sets of affixes as data objects. + + Affixe : Type = Person => Str ; + + afixe : (_,_,_ : Str) -> Affixe = \x,y,z -> table { + P1 => x ; + P2 => y ; + P3 => z + } ; + +-- Empty table (for verbs that lack certain tenses and moods ) + +empty : Number => Person => Str = \\n,p => nonExist ; + +specTab : Str -> Str -> Number => Person => Str = \ploua, plouau -> +\\n,p => case of + { => ploua ; + => plouau ; + _ => nonExist + }; + +-- VERB GROUPS : + + +--------------------------------------------------- +-----------Group 1 - ending in -a, with exceptions +--------------------------------------------------- + +-- Much of variation can be described in terms of affix sets: +--------------------------------- +--for Present : +--------------------------------- +--for subGroups 1,13 + + affixSgGr1Ez : Affixe = afixe "ez" "ezi" "ează" ; + affixPlGr1Ez : Affixe = afixe "ăm" "ați" "ează" ; +------ +--for subGroups 2-3 + affixSgGr1EzI : Affixe = afixe "ez" "ezi" "ază" ; + affixPlGr1EzI : Affixe = afixe "em" "ați" "ază" ; +------ +--for subGroup 4 + affixSgGr1I : Affixe = afixe "i" "i" "e" ; + affixPlGr1I : Affixe = afixe "em" "ați" "e"; +------ +--for subGroup 5 + affixSgGr1VI : Affixe = afixe "" "" "e" ; + affixPlGr1VI : Affixe = affixPlGr1I ; +------ +--for subGroups 6-7 + affixSgGr1 : Affixe = afixe "" "i" "ă" ; + affixPlGr1 : Affixe = afixe "ăm" "ați" "ă" ; +------ +--for subGroup 8 + affixSgGr1U : Affixe = afixe "u" "i" "ă" ; + affixPlGr1U : Affixe = affixPlGr1 ; +------ +--for subGroup 9,11,12 + affixSgGr1AU : Affixe = afixe "au" "ai" "ă" ; + affixPlGr1AU : Affixe = afixe "ăm" "ați" "au" ; +------- +--for subGroup 10 + affixSgGr1EU : Affixe = afixe "au" "ei" "a" ; + affixPlGr1EU : Affixe = afixe "ăm" "ați" "au" ; +------- + --for subGroup 14 + affixSgGr1CI : Affixe = afixe "i" "i" "e" ; + affixPlGr1CI : Affixe = afixe "em" "eați" "e"; +----- + + +------------------------- +--for Imperfect : +------------------------- +--for subGroups 1-10 + affixSgI : Affixe = afixe "am" "ai" "a" ; + affixPlI : Affixe = afixe "am" "ați" "au" ; + +--for subGroups 11-14 + affixSgII : Affixe = afixe "eam" "eai" "ea" ; + affixPlII : Affixe = afixe "eam" "eați" "eau" ; + +--------------------------- + --for Perfect Simple : + --------------------------- + --for subGroups 1, 6-10 + + affixSgPS1 : Affixe = afixe "ai" "ași" "ă" ; + affixPlPS1 : Affixe = afixe "arăm" "arăți" "ară" ; + + --for subGroups 2-5 + + affixSgPS2 : Affixe = afixe "ai" "ași" "e" ; + affixPlPS2 : Affixe = afixe "arăm" "arăți" "ară" ; + + --for subGroups 11-12 + + affixSgPS3 : Affixe = afixe "ui" "uși" "u" ; + affixPlPS3 : Affixe = afixe "urăm" "urăți" "ură" ; + + --for subGroups 13-14 + + affixSgPS4 : Affixe = afixe "eai" "eași" "e" ; + affixPlPS4 : Affixe = afixe "earăm" "earăți" "eară" ; + +-------------------------- +-- for Past Perfect : +--------------------------- + +--for subGroups 1-10 + +affixSgPP : Affixe = afixe "asem" "aseși" "ase" ; +affixPlPP : Affixe = afixe "aserăm" "aserăți" "aseră" ; + +--for subGroups 11-12 + +affixSgPP2 : Affixe = afixe "usem" "useși" "use" ; +affixPlPP2 : Affixe = afixe "userăm" "userăți" "useră" ; + +--for subGroups 13-14 + +affixSgPP3 : Affixe = afixe "easem" "easeși" "ease" ; +affixPlPP3 : Affixe = afixe "easerăm" "easerăți" "easeră" ; + + +-- functions that build a tense table for a verb : + + +-- worst case : we need 5 forms and an affixe - +-- root, 1st Sg, 2nd Sg, 3rd Sg, 3rd Pl and affixe + +mkTab : (a,b,c,d,e : Str) -> Affixe -> Number => Person => Str = +\lua -> \iau -> \iei -> \ia -> \iaP -> \aff -> +table {Sg => table {P1 => iau; P2 => iei; P3 => ia}; + Pl => table {P3 => iaP; p => lua + aff ! p} + }; + + +-- regular case : we need just the root and affixes for Singular and Plural + +mkFromAffix : Str -> Affixe -> Affixe -> Number => Person => Str = \ar,affSg,affPl -> + table {Sg => table {p => ar + affSg ! p}; + Pl => table {p => ar + affPl ! p} + }; + +-- case where we need 2 roots and two affixes + + +mkFromAffixes1 : Str -> Str -> Affixe -> Affixe -> Number => Person => Str = +\ar,arr,affSg, affPl -> +table {Sg => table {p => ar + affSg ! p }; + Pl => table {P3 => ar + affSg ! P3 ; + p => arr + affPl ! p + } + }; + + +mkFromAffixes2 : Str -> Str -> Affixe -> Affixe -> Number => Person => Str = +\ar,arr,affSg, affPl -> +table {Sg => table {p => ar + affSg ! p}; + Pl => table {P3 => ar + affPl ! P3; + p => arr + affPl ! p + } + }; + +-- cases where the 3rd Person Singular is formed with a different root : + +mkAffixSpec1 : Str -> Str -> Affixe -> Affixe -> Number => Person => Str = +\ar, arr, affSg, affPl -> +table {Sg => table {P3 => arr + affSg ! P3 ; + p => ar + affSg ! p + }; + Pl => table {P3 => arr + affSg ! P3 ; + p => ar + affPl ! p + } + }; + +mkAffixSpec2 : Str -> Str -> Affixe -> Affixe -> Number => Person => Str = +\ar, arr, affSg, affPl -> +table {Sg => table {P3 => arr + affSg ! P3 ; + p => ar + affSg ! p + }; + Pl => table {P3 => ar + affSg ! P1 ; + p => ar + affPl ! p + } + }; + + +-- case where the 2nd person Singular has a different form, than the usual one : + +changeP2 : Str -> (Number => Person => Str) -> Number => Person => Str = +\ari -> \pres -> +table {Sg => table {P2 => ari; + p => pres ! Sg ! p}; + Pl => \\p => pres ! Pl ! p + }; + +-- case where the 1st person Singular has a different form than the usual one : + +changeP1 : Str -> (Number => Person => Str) -> Number => Person => Str = +\ari -> \pres -> +table {Sg => table {P1 => ari; + p => pres ! Sg ! p}; + Pl => \\p => pres ! Pl ! p + }; + + +--subGroup 1 +mkV6: Str -> Verbe = \lucra -> + let root = init lucra in +verbAffixes lucra (mkFromAffix root affixSgGr1Ez affixPlGr1Ez) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (root + "eze") (mkAdjReg(root + "at")) + (root + "ând") (root + "ează") ; + + +mkV7 : Str -> Verbe = \crea -> + mkV6 crea ; + +mkV8 : Str -> Verbe = \parca -> + let r = init parca ; + root = r + "h" + in +verbAffixes parca (mkFromAffixes1 r root affixSgGr1Ez affixPlGr1Ez) + (mkFromAffix r affixSgI affixPlI) (mkFromAffix r affixSgPS1 affixPlPS1) + (mkFromAffix r affixSgPP affixPlPP) (root + "eze") (mkAdjReg (r + "at")) + (r + "ând") (root + "ează") ; + +mkV9 : Str -> Verbe = \divaga -> + mkV8 divaga ; + + +--subGroup 2 + +mkV10 : Str -> Verbe = \studia -> + let root = init studia in + verbAffixes studia (mkFromAffix root affixSgGr1EzI affixPlGr1EzI) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS2 affixPlPS2) + (mkFromAffix root affixSgPP affixPlPP) (root + "eze") (mkAdjReg (root + "at")) + (root + "ind") (root + "ază") ; + +--subGroup 3 + +mkV11 : Str -> Verbe = \ardeia -> + let root = init ardeia in + verbAffixes ardeia (mkFromAffix root affixSgGr1EzI affixPlGr1EzI) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS2 affixPlPS2) + (mkFromAffix root affixSgPP affixPlPP) (root + "eze") (mkAdjReg (root + "at")) + (root + "nd") (root + "ază") ; + +--subGroup 4 + +mkV12 : Str -> Verbe = \speria -> + let root = init speria in + verbAffixes speria (mkFromAffix root affixSgGr1I affixPlGr1I) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS2 affixPlPS2) + (mkFromAffix root affixSgPP affixPlPP) (root + "e") (mkAdjReg (root + "at")) + (root + "ind") (root + "e") ; + +--subGroup 5 + +mkV13 : Str -> Verbe = \incuia -> + let root = init incuia in + verbAffixes incuia (mkFromAffix root affixSgGr1VI affixPlGr1VI) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS2 affixPlPS2) + (mkFromAffix root affixSgPP affixPlPP) (root + "e") (mkAdjReg (root + "at")) + (root + "nd") (root + "e") ; + +mkV14 : Str -> Verbe = \taia -> + let root = init taia ; + r = modA root + in +verbAffixes taia (mkFromAffixes1 r root affixSgGr1VI affixPlGr1VI) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS2 affixPlPS2) + (mkFromAffix root affixSgPP affixPlPP) (r + "e") (mkAdjReg (root + "at")) + (root + "nd") (r + "e") ; + +mkV15 : Str -> Verbe = \infoia -> + let root = init infoia ; + r = mkStemMutO root + in + verbAffixes infoia (mkAffixSpec1 root r affixSgGr1VI affixPlGr1VI) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS2 affixPlPS2) + (mkFromAffix root affixSgPP affixPlPP) (r + "e") (mkAdjReg (root + "at")) + (root + "nd") (r + "e") ; + +mkV16 : Str -> Verbe = \muia -> + let root = init muia ; + r1 = modU root ; + r2 = mkStemMutO r1 + in + verbAffixes muia (mkTab root r1 r1 (r2 + "e") (r2+"e") affixPlGr1VI) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS2 affixPlPS2) + (mkFromAffix root affixSgPP affixPlPP) (r2 + "e") (mkAdjReg (root + "at")) + (root + "nd") (r2 + "e") ; + +--subGroup 6 + +mkV17 : Str -> Verbe = \acuza -> + let root = init acuza + in + verbAffixes acuza (mkFromAffix root affixSgGr1 affixPlGr1) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (root + "e") (mkAdjReg (root + "at")) + (root + "ând") (root + "ă") ; + +mkV18 : Str -> Verbe = \ajuta -> + let root = init ajuta ; + newF = mkStemPlReg root; + pres = changeP2 newF (mkFromAffix root affixSgGr1 affixPlGr1) +in +verbAffixes ajuta pres + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (root + "e") (mkAdjReg (root + "at")) + (root + "ând") (root + "ă") ; + + +mkV19 : Str -> Verbe = \acorda -> + mkV18 acorda ; + +mkV20 : Str -> Verbe = \asista -> + mkV18 asista ; + + + +mkV21 : Str -> Verbe = \risca -> + let root = init risca ; + newF = mkStemPlReg root ; + newP = init newF + "e" ; + pres = changeP2 newF (mkFromAffix root affixSgGr1 affixPlGr1) +in +verbAffixes risca pres + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) newP (mkAdjReg (root + "at")) + (root + "ând") (root + "ă") ; + + + mkV22 : Str -> Verbe = \misca -> + mkV21 misca ; + + mkV23 : Str -> Verbe = \calca -> + let root = init calca ; + r = modA root + in + verbAffixes calca (mkFromAffixes1 r root affixSgGr1 affixPlGr1) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (r + "e") (mkAdjReg (root + "at")) + (root + "ând") (r + "ă") ; + +mkV24 : Str -> Verbe = \cauta -> + let root = init cauta ; + r = modA root ; + newF = mkStemPlReg r ; + pres = changeP2 newF (mkFromAffixes1 r root affixSgGr1 affixPlGr1) + in + verbAffixes cauta pres + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (r + "e") (mkAdjReg (root + "at")) + (root + "ând") (r + "ă") ; + +mkV25 : Str -> Verbe = \lauda -> + mkV24 lauda ; + +mkV26 : Str -> Verbe = \lasa -> + mkV24 lasa ; + +mkV27 : Str -> Verbe = \adasta -> + mkV24 adasta ; + +mkV28 : Str -> Verbe = \casca -> + let root = init casca ; + r = modA root ; + newF = mkStemPlReg r ; + newP = init newF + "e" + in + verbAffixes casca (changeP2 newF (mkFromAffixes1 r root affixSgGr1 affixPlGr1)) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) newP (mkAdjReg (root + "at")) + (root + "ând") (r + "ă") ; + + mkV29 : Str -> Verbe = \chema -> + let root = init chema ; + r = mkMutE root + in + verbAffixes chema (mkAffixSpec1 root r affixSgGr1 affixPlGr1) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (root+"e") (mkAdjReg (root + "at")) + (root + "ând") (r + "ă") ; + + mkV30 : Str -> Verbe = \certa -> + let root = init certa ; + newF = mkStemPlReg root ; + newP = mkMutE root + "ă" + in + verbAffixes certa (mkTab root root newF newP newP affixPlGr1) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (root+"e") (mkAdjReg (root + "at")) + (root + "ând") newP ; + + mkV31 : Str -> Verbe = \toca -> + let root = init toca ; + r = mkStemMutO root + in + verbAffixes toca (mkAffixSpec1 root r affixSgGr1 affixPlGr1) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (root+"e") (mkAdjReg (root + "at")) + (root + "ând") (r + "ă") ; + + mkV32 : Str -> Verbe = \inota -> + let root = init inota ; + newF = mkStemPlReg root ; + newP = mkStemMutO root + "ă" + in + verbAffixes inota (mkTab root root newF newP newP affixPlGr1) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (root+"e") (mkAdjReg (root + "at")) + (root + "ând") newP ; + + mkV33 : Str -> Verbe = \innoda -> + mkV32 innoda ; + + mkV34 : Str -> Verbe = \improsca -> + let root = init improsca ; + newF = mkStemPlReg root ; + newS = mkStemMutO (init newF) + "e" ; + newP = mkStemMutO root + "ă" + in + verbAffixes improsca (mkTab root root newF newP newP affixPlGr1) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) newS (mkAdjReg (root + "at")) + (root + "ând") newP ; + + mkV35 : Str -> Verbe = \apara -> + let root = init apara ; + newP = mkStemMutA root ; + pres = changeP2 (newP + "i") (mkFromAffix root affixSgGr1 affixPlGr1) + in + verbAffixes apara pres + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (newP + "e") (mkAdjReg (root + "at")) + (root + "ând") (root + "ă") ; + + mkV36 : Str -> Verbe = \semana -> + let root = init semana ; + newP = mkStemMutA root ; + newF = mkMutE root + "ă" + in + verbAffixes semana (mkTab root root (newP+"i") newF newF affixPlGr1) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (newP + "e") (mkAdjReg (root + "at")) + (root + "ând") newF ; + + mkV37 : Str -> Verbe = \fremata -> + let root = init fremata ; + r = mkMutE root ; + newC = (mkStemMutA root) + "e" ; + newP = mkStemPlReg r ; + newF = r + "ă" + in + verbAffixes fremata (mkTab root r newP newF newF affixPlGr1) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) newC (mkAdjReg (root + "at")) + (root + "ând") newF ; + + mkV38 : Str -> Verbe = \lepada -> + mkV37 lepada ; + + mkV39 : Str -> Verbe = \scapara -> + let root = init scapara ; + r = modAFirst root ; + newP = mkStemMutA r ; + newF = r + "ă" + in + verbAffixes scapara (mkTab root r (newP + "i") newF newF affixPlGr1) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (newP + "e") (mkAdjReg (root + "at")) + (root + "ând") newF ; + + mkV40 : Str -> Verbe = \capata -> + let root = init capata ; + r = modAFirst root ; + newC = mkStemMutA r + "e" ; + newP = mkStemPlReg(mkStemMutA r) ; + newF = r + "ă" + in + verbAffixes capata (mkTab root r newP newF newF affixPlGr1) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) newC (mkAdjReg (root + "at")) + (root + "ând") newF ; + + mkV41 : Str -> Verbe = \aseza -> + let root = init aseza ; + r = genMut root "e" "a" + in + verbAffixes aseza (mkAffixSpec1 root r affixSgGr1 affixPlGr1) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (root+"e") (mkAdjReg (root + "at")) + (root + "ând") (r +"ă") ; + + mkV42 : Str -> Verbe = \ierta -> + mkV30 ierta ; + + mkV43 : Str -> Verbe = \dezmierda -> + mkV30 dezmierda ; + + mkV44 : Str -> Verbe = \pieptana -> + mkV36 pieptana ; + + mkV45 : Str -> Verbe = \invata -> + let root = init invata ; + newP = mkStemMutA root ; + r = genMut root "ă" "a" + in + verbAffixes invata (mkTab root root (newP + "i") (r+"ă") (r+"ă") affixPlGr1) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (newP +"e") (mkAdjReg (root + "at")) + (root + "ând") (r +"ă") ; + + mkV46 : Str -> Verbe = \imbata -> + let root = init imbata ; + newP = mkStemMutA root ; + r = genMut root "ă" "a" + in + verbAffixes imbata (mkTab root root (mkStemPlReg newP) (r+"ă") (r+"ă") affixPlGr1) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (newP +"e") (mkAdjReg (root + "at")) + (root + "ând") (r +"ă") ; + + mkV47 : Str -> Verbe = \varsa -> + mkV46 varsa ; + + mkV48 : Str -> Verbe = \juca -> + let root = init juca ; + r1 = modU root ; + r2 = mkStemMutO r1 + in + verbAffixes juca (mkTab root r1 (mkStemPlReg r1) (r2+"ă") (r2+"ă") affixPlGr1) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (r2 +"e") (mkAdjReg (root + "at")) + (root + "ând") (r2 +"ă") ; + + mkV49 : Str -> Verbe = \purta -> + mkV48 purta ; + + mkV50 : Str -> Verbe = \prezenta -> + let root = init prezenta ; + r1 = genMut root "e" "i" + in + verbAffixes prezenta (mkTab root r1 (mkStemPlReg r1) (r1+"ă") (r1+"ă") affixPlGr1) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (r1 +"e") (mkAdjReg (root + "at")) + (root + "ând") (r1 +"ă") ; + + mkV51 : Str -> Verbe = \usca -> + let root = init usca ; + r = "usuc" + in + verbAffixes usca (mkTab root r (r + "i") (r+"ă") (r+"ă") affixPlGr1) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (r +"e") (mkAdjReg (root + "at")) + (root + "ând") (r +"ă") ; + + mkV52 : Str -> Verbe = \manca -> + let root = init manca ; + r = "mănânc" + in + verbAffixes manca (mkTab root r (r + "i") (r+"ă") (r+"ă") affixPlGr1) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (r +"e") (mkAdjReg (root + "at")) + (root + "ând") (r +"ă") ; + + --subGroup 7 + mkV53 : Str -> Verbe = \preceda -> + let root = init preceda ; + newP = mkStemPlReg root ; + newC = mkMutE root + in + verbAffixes preceda (changeP2 newP (mkFromAffix root affixSgGr1 affixPlGr1)) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (newC +"ă") (mkAdjReg (root + "at")) + (root + "ând") (root +"ă") ; + + mkV54 : Str -> Verbe = \ploua -> + let root = init ploua + in + verbAffixes ploua (specTab (root + "ă") (root + "ă")) (specTab ploua (ploua+ "u")) + (specTab (root + "ă") (root + "ară")) (specTab (root + "ase") (root + "aseră")) + (root + "ă") (mkAdjReg (root + "at")) (root + "ând") (root + "ă") ; + + --subGroup8 + mkV55 : Str -> Verbe = \umbla -> + let root = init umbla + in + verbAffixes umbla (mkFromAffix root affixSgGr1U affixPlGr1U) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (root +"e") (mkAdjReg (root + "at")) + (root + "ând") (root +"ă") ; + + mkV56 : Str -> Verbe = \latra -> + let root = init latra ; + r = genMut root "ă" "a" + in + verbAffixes latra (mkFromAffixes1 r root affixSgGr1U affixPlGr1U) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (r +"e") (mkAdjReg (root + "at")) + (root + "ând") (r +"ă") ; + + --subGroup 9 + + mkV57 : Str -> Verbe = \reda -> + let root = init reda + in + verbAffixes reda (mkFromAffix root affixSgGr1AU affixPlGr1AU) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (root +"ea") (mkAdjReg (root + "at")) + (root + "ând") (root +"ă") ; + + --subGroup 10 + mkV58 : Str -> Verbe = \lua -> + let root = init lua ; + r = Predef.tk 2 root + "i" + in + verbAffixes lua (mkFromAffixes1 r root affixSgGr1EU affixPlGr1EU) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS1 affixPlPS1) + (mkFromAffix root affixSgPP affixPlPP) (r +"a") (mkAdjReg (root + "at")) + (root + "ând") (r +"a") ; + + --subGroup 11 + mkV59 : Str -> Verbe = \sta -> + let root = init sta ; + r = Predef.tk 2 root + "stăt" + in + verbAffixes sta (mkFromAffix root affixSgGr1AU affixPlGr1AU) + (mkFromAffix r affixSgII affixPlII) (mkFromAffix r affixSgPS3 affixPlPS3) + (mkFromAffix r affixSgPP2 affixPlPP2) (root +"ea") (mkAdjReg (root + "at")) + (root + "ând") (root +"ai") ; + + --subGroups 12 + mkV60 : Str -> Verbe = \da -> + let root = init da ; + r = init root + "dăd" + in + verbAffixes da (mkFromAffix root affixSgGr1AU affixPlGr1AU) + (mkFromAffix r affixSgII affixPlII) (mkFromAffix r affixSgPS3 affixPlPS3) + (mkFromAffix r affixSgPP2 affixPlPP2) (root +"ea") (mkAdjReg (root + "at")) + (root + "ând") (root +"ai") ; + + --subGroups 13 + mkV61 : Str -> Verbe = \veghea -> + let root = Predef.tk 2 veghea + in + verbAffixes veghea (mkFromAffix root affixSgGr1Ez affixPlGr1Ez) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS4 affixPlPS4) + (mkFromAffix root affixSgPP3 affixPlPP3) (root +"eze") (mkAdjReg (root + "eat")) + (root + "ind") (root +"ează") ; + +--subGroups 14 +mkV62 : Str -> Verbe = \deochea -> + let root = Predef.tk 2 deochea ; + newP = mkMutO root + in + verbAffixes deochea (mkAffixSpec1 root newP affixSgGr1CI affixPlGr1CI) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS4 affixPlPS4) + (mkFromAffix root affixSgPP3 affixPlPP3) (newP +"e") (mkAdjReg (root + "eat")) + (root + "ind") (newP + "e") ; + +----------------------------------- +---------GROUP 2 -- verbs ending in -ea (same syllable) +----------------------------------- +---------- +--Present +---------- + +--subGroup 1-2 +affixSgGr21 : Affixe = afixe "" "i" "e" ; +affixPlGr21 : Affixe = afixe "em" "eți" "" ; + +--subGroup 3 +affixSgGr23 : Affixe = afixe "eau" "ei" "ea" ; +affixPlGr23 : Affixe = afixe "em" "eți" "eau" ; + +--subGroup 4 +affixSgGr24 : Affixe = afixe "eau" "ei" "ea" ; +affixPlGr24 : Affixe = afixe "em" "eți" "" ; + +---------- +--Imperf +---------- + +--subGroups 1-3 +--affixSgII and affixPlII + +--subGroup 4 +affixSgI2 : Affixe = afixe "iam" "iai" "ia" ; +affixPlI2 : Affixe = afixe "iam" "iați" "iau" ; + +--------------- +--Past Simple +-------------- +--affixSgPS3 and affixPlPS3 + +-------------- +--Past Perfect +-------------- +-- for subGroups 1-3 +-- affixSgPP2 and affixPlPP2 + +--for subGroup 4 +affixSgPP4 : Affixe = afixe "usem" "useși" "use" ; +affixPlPP4 : Affixe = afixe "useserăm" "useserăți" "useseră" ; + + +----------------- + +-- subGroup 1 + +mkV64 : Str -> Verbe = \aparea -> + let root = Predef.tk 2 aparea ; + r = genMut root "ă" "a" + in + verbAffixes aparea (mkFromAffixes2 r root affixSgGr21 affixPlGr21) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS3 affixPlPS3) + (mkFromAffix r affixSgPP2 affixPlPP2) (r +"ă") (mkAdjReg (root + "ut")) + (root + "ând") (r + "i") ; + +mkV65 : Str -> Verbe = \cadea -> + let root = Predef.tk 2 cadea ; + r = genMut root "ă" "a"; + rad = init (mkStemPlReg root) + in + verbAffixes cadea (changeP2 (mkStemPlReg r) (mkFromAffixes2 r root affixSgGr21 affixPlGr21) ) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix rad affixSgPS3 affixPlPS3) + (mkFromAffix rad affixSgPP2 affixPlPP2) (r +"ă") (mkAdjReg (rad + "ut")) + (rad + "ând") (mkStemPlReg r) ; + +mkV66 : Str -> Verbe = \sedea -> + let root = Predef.tk 2 sedea ; + r = genMut root "e" "a"; + rad = init (mkStemPlReg root) + in + verbAffixes sedea (mkTab root root (mkStemPlReg root) (r + "e") root affixPlGr21) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix rad affixSgPS3 affixPlPS3) + (mkFromAffix rad affixSgPP2 affixPlPP2) (r +"ă") (mkAdjReg (rad + "ut")) + (rad + "ând") (rad + "i") ; + +mkV67 : Str -> Verbe = \vedea -> + let root = Predef.tk 2 vedea ; + r = genMut root "e" "ă" ; + newC = genMut root "e" "a" ; + rad = init (mkStemPlReg r) + in + verbAffixes vedea (mkTab root r (mkStemPlReg root) (root + "e") r affixPlGr21) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix rad affixSgPS3 affixPlPS3) + (mkFromAffix rad affixSgPP2 affixPlPP2) (newC +"ă") (mkAdjReg (rad + "ut")) + (rad + "ând") (mkStemPlReg root) ; + +mkV68 : Str -> Verbe = \putea -> + let root = Predef.tk 2 putea ; + r = modU root ; + newP = mkMutO r + in + verbAffixes putea (mkTab root r (mkStemPlReg r) (newP + "e") r affixPlGr21) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS3 affixPlPS3) + (mkFromAffix root affixSgPP2 affixPlPP2) (newP +"ă") (mkAdjReg (root + "ut")) + (root + "ând") (mkStemPlReg r) ; + +--subGroup 2 + + mkV69 : Str -> Verbe = \scadea -> + let root = Predef.tk 2 scadea ; + r = genMut root "ă" "a"; + rad = init (mkStemPlReg root) + in + verbAffixes scadea (changeP2 (mkStemPlReg r) (mkFromAffixes2 r root affixSgGr21 affixPlGr21) ) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix rad affixSgPS3 affixPlPS3) + (mkFromAffix rad affixSgPP2 affixPlPP2) (r +"ă") (mkAdjReg (rad + "ut")) + (rad + "ând") (r + "e") ; + + mkV70 : Str -> Verbe = \prevedea -> + let root = Predef.tk 2 prevedea ; + r = genMut root "e" "ă" ; + newC = genMut root "e" "a" ; + rad = init (mkStemPlReg r) + in + verbAffixes prevedea (mkTab root r (mkStemPlReg root) (root + "e") r affixPlGr21) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix rad affixSgPS3 affixPlPS3) + (mkFromAffix rad affixSgPP2 affixPlPP2) (newC +"ă") (mkAdjReg (rad + "ut")) + (rad + "ând") (root + "e") ; + + mkV71 : Str -> Verbe = \placea -> + let root = Predef.tk 2 placea ; + r = genMut root "ă" "a" + in + verbAffixes placea (mkFromAffixes2 r root affixSgGr21 affixPlGr21) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS3 affixPlPS3) + (mkFromAffix r affixSgPP2 affixPlPP2) (r +"ă") (mkAdjReg (root + "ut")) + (root + "ând") (r + "e") ; + + mkV72 : Str -> Verbe = \durea -> + mkV68 durea ; + +--subGroup 3 + + mkV73 : Str -> Verbe = \bea -> + let root = Predef.tk 2 bea ; + r = root + "ă" + in + verbAffixes bea (mkFromAffix root affixSgGr23 affixPlGr23) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS3 affixPlPS3) + (mkFromAffix r affixSgPP2 affixPlPP2) (root +"ea") (mkAdjReg (r + "ut")) + (root + "ând") (root + "ea") ; + +--subGroup 4 + + mkV74 : Str -> Verbe = \vrea -> + let root = Predef.tk 2 vrea ; + r = root + "o" + in + verbAffixes vrea (mkTab root (root+"eau") (root+"ei")(root +"ea") (init root + "or") affixPlGr24) + (mkFromAffix r affixSgII affixPlII) (mkFromAffix root affixSgPS3 affixPlPS3) + (mkFromAffix root affixSgPP4 affixPlPP4) (root +"ea") (mkAdjReg (r + "ut")) + (root + "ând") (root + "ei") ; + + ---------------------------------------------------------------------- + -------Group 3 -- verbs ending in -e + ------------------------------------------------------------------------- + ----------------------- + --Present + ----------------------- +--subGroups 1-6 +--affixSgGr21 + affixPlGr21 + +--subGroup 7-8 +affixSgGr31 : Affixe = afixe "u" "i" "e" ; +affixPlGr31 : Affixe = afixe "em" "eți" "u" ; + +---------------- +--Imperfect +---------------- +--subGroups 1-6 affixSgII affixPlII + +--subGroups 7-8 affixSgI affixPlI + +---------------- +--Past Simple +---------------- +--subGroups 1-4,8 +affixSgPS5 : Affixe = afixe "sei" "seși" "se" ; +affixPlPS5 : Affixe = afixe "serăm" "serăți" "seră" ; + +--subGroups 5-7 affixSgPS3 + affixPlPS3 + +--------------- +--P Perfect +--------------- +--subGroups 1-4,8 +affixSgPP5 : Affixe = afixe "sesem" "seseși" "sese" ; +affixPlPP5 : Affixe = afixe "seserăm" "seserăți" "seseră" ; + +--subGroups 5-7 +--affixSgPP2 and affixPlPP2 + +--subGroup 1 + +mkV76 : Str -> Verbe = \pune -> + let root = init pune ; + r = init root + in +verbAffixes pune (changeP2 (r+"i") (mkFromAffix root affixSgGr21 affixPlGr21) ) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS5 affixPlPS5) + (mkFromAffix r affixSgPP5 affixPlPP5) (root +"ă") (mkAdjReg (r + "s")) + (root + "ând") (root + "e") ; + +mkV77 : Str -> Verbe = \atinge -> + let root = init atinge ; + r = init root + in +verbAffixes atinge (mkFromAffix root affixSgGr21 affixPlGr21) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS5 affixPlPS5) + (mkFromAffix r affixSgPP5 affixPlPP5) (root +"ă") (mkAdjReg (r + "s")) + (root + "ând") (root + "e") ; + +mkV78 : Str -> Verbe = \trage -> + let root = init trage ; + rad1 = genMut root "a" "ă" ; + r = init root ; + rad2 = genMut r "a" "ă" + in +verbAffixes trage (mkFromAffix root affixSgGr21 affixPlGr21) + (mkFromAffix rad1 affixSgII affixPlII) + (mkTab rad2 (r + "ei") (r + "seși") (rad2 + "e") (rad2 + "eră") affixPlPS5) + (mkFromAffix rad2 affixSgPP5 affixPlPP5) (root +"ă") (mkAdjReg (r + "s")) + (rad1 + "ând") (root + "e") ; + +mkV79 : Str -> Verbe = \decide -> + let root = init decide ; + r = init root + in +verbAffixes decide (changeP2 (mkStemPlReg root) (mkFromAffix root affixSgGr21 affixPlGr21)) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS5 affixPlPS5) + (mkFromAffix r affixSgPP5 affixPlPP5) (root +"ă") (mkAdjReg (r + "s")) + (r + "zând") (root + "e") ; + +mkV80 : Str -> Verbe = \rade -> + let root = init rade ; + rad1 = genMut root "a" "ă" ; + r = init root ; + rad2 = genMut r "a" "ă" + in +verbAffixes rade (changeP2 (mkStemPlReg root) (mkFromAffix root affixSgGr21 affixPlGr21)) + (mkFromAffix rad1 affixSgII affixPlII) + (mkTab rad2 (r + "ei") (r + "seși") (rad2 + "e") (rad2 + "eră") affixPlPS5) + (mkFromAffix rad2 affixSgPP5 affixPlPP5) (root +"ă") (mkAdjReg (r + "s")) + (rad2 + "zând") (root + "e") ; + +mkV81 : Str -> Verbe = \ucide -> + let root = init ucide ; + r = init root + in +verbAffixes ucide (changeP2 (mkStemPlReg root) (mkFromAffix root affixSgGr21 affixPlGr21)) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS5 affixPlPS5) + (mkFromAffix r affixSgPP5 affixPlPP5) (root +"ă") (mkAdjReg (r + "s")) + (r + "gând") (root + "e") ; + +mkV82 : Str -> Verbe = \admite -> + let root = init admite ; + r = init root + in +verbAffixes admite (changeP2 (mkStemPlReg root) (mkFromAffix root affixSgGr21 affixPlGr21)) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS5 affixPlPS5) + (mkFromAffix r affixSgPP5 affixPlPP5) (root +"ă") (mkAdjReg (r + "s")) + (r + "țând") (root + "e") ; + +mkV83 : Str -> Verbe = \alege -> + let root = init alege ; + r = init root ; + newP = mkMutE root + in +verbAffixes alege (mkFromAffix root affixSgGr21 affixPlGr21) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS5 affixPlPS5) + (mkFromAffix r affixSgPP5 affixPlPP5) (newP +"ă") (mkAdjRegE (r + "s")) + (root + "ând") (root + "e") ; + +mkV84 : Str -> Verbe = \sumete -> + let root = init sumete ; + r = init root ; + newP = mkMutE root + in +verbAffixes sumete (changeP2 (mkStemPlReg root) (mkAffixSpec2 root newP affixSgGr21 affixPlGr21)) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS5 affixPlPS5) + (mkFromAffix r affixSgPP5 affixPlPP5) (newP +"ă") (mkAdjRegE (r + "s")) + (r + "țând") (root + "e") ; + +mkV85 : Str -> Verbe = \scoate -> + let root = init scoate ; + r = mkStemMutOa root ; + rad = init r ; + rad1 = init root + in +verbAffixes scoate (mkTab root r (mkStemPlReg r) scoate r affixPlGr21) + (mkFromAffix r affixSgII affixPlII) + (mkTab rad1 (rad + "sei") (rad + "seși") (rad1 + "se") (rad1 + "eră") affixPlPS5) + (mkFromAffix rad affixSgPP5 affixPlPP5) (root +"ă") (mkAdjRegO (rad + "s")) + (rad + "țând") (root + "e") ; + + +mkV86 : Str -> Verbe = \roade -> + let root = init roade ; + r = mkStemMutOa root ; + rad = init r ; + rad1 = init root + in +verbAffixes roade (mkTab root r (mkStemPlReg r) roade r affixPlGr21) + (mkFromAffix r affixSgII affixPlII) + (mkTab rad1 (rad + "sei") (rad + "seși") (rad1 + "se") (rad1 + "eră") affixPlPS5) + (mkFromAffix rad affixSgPP5 affixPlPP5) (root +"ă") (mkAdjRegO (rad + "s")) + (rad + "zând") (root + "e") ; + + +mkV87 : Str -> Verbe = \purcede -> + let root = init purcede ; + r = init root ; + newP = mkMutE root + in +verbAffixes purcede (changeP2 (mkStemPlReg root) (mkFromAffix root affixSgGr21 affixPlGr21)) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS5 affixPlPS5) + (mkFromAffix r affixSgPP5 affixPlPP5) (newP +"ă") (mkAdjRegE (r + "s")) + (r + "zând") (root + "e") ; + + +mkV88 : Str -> Verbe = \toarce -> + let root = init toarce ; + r = mkStemMutOa root ; + rad = init r ; + rad1 = init root + in +verbAffixes toarce (mkTab root r (mkStemPlReg r) toarce r affixPlGr21) + (mkFromAffix r affixSgII affixPlII) + (mkTab rad1 (rad + "sei") (rad + "seși") (rad1 + "se") (rad1 + "eră") affixPlPS5) + (mkFromAffix rad affixSgPP5 affixPlPP5) (root +"ă") (mkAdjRegO (rad + "s")) + (rad + "când") (root + "e") ; + +--subGroup 2 + +mkV89 : Str -> Verbe = \curge -> + let root = init curge ; + r = init root + in + verbAffixes curge (mkFromAffix root affixSgGr21 affixPlGr21) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS5 affixPlPS5) + (mkFromAffix r affixSgPP5 affixPlPP5) (root +"ă") (mkAdjReg (r + "s")) + (root + "ând") (root + "i") ; + +mkV90 : Str -> Verbe = \merge -> +let root = init merge ; + r = init root ; + newP = mkMutE root + in +verbAffixes merge (mkFromAffix root affixSgGr21 affixPlGr21) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS5 affixPlPS5) + (mkFromAffix r affixSgPP5 affixPlPP5) (newP +"ă") (mkAdjRegE (r + "s")) + (root + "ând") (root + "i") ; + +mkV91 : Str -> Verbe = \ride -> +let root = init ride ; + r = init root + in +verbAffixes ride (changeP2 (mkStemPlReg root) (mkFromAffix root affixSgGr21 affixPlGr21)) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS5 affixPlPS5) + (mkFromAffix r affixSgPP5 affixPlPP5) (root +"ă") (mkAdjReg (r + "s")) + (r + "zând") (mkStemPlReg root) ; + + +mkV92 : Str -> Verbe = \ramane -> +let root = init ramane ; + r = init root ; + r1 = genMut root "â" "ă" ; + r2 = genMut root "â" "a" + in +verbAffixes ramane (changeP2 (r + "i") (mkFromAffix root affixSgGr21 affixPlGr21)) + (mkFromAffix root affixSgII affixPlII) + (mkTab (init r2) (init r1 + "sei") (init r1 + "seși") (init r2 + "se") (init r2 + "seră") affixPlPS5) + (mkFromAffix (init r1) affixSgPP5 affixPlPP5) (root +"ă") (mkAdjReg (init r2 + "s")) + (root + "ând") (r + "i") ; + +--subGroup 3 : + +mkV93 : Str -> Verbe = \zice -> + let root = init zice ; + r = init root + in +verbAffixes zice (mkFromAffix root affixSgGr21 affixPlGr21) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS5 affixPlPS5) + (mkFromAffix r affixSgPP5 affixPlPP5) (root +"ă") (mkAdjReg (r + "s")) + (root + "ând") r ; + +--subGroup 4 : + +mkV94 : Str -> Verbe = \rupe -> + let root = init rupe + in +verbAffixes rupe (mkFromAffix root affixSgGr21 affixPlGr21) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS5 affixPlPS5) + (mkFromAffix root affixSgPP5 affixPlPP5) (root +"ă") (mkAdjReg (root + "t")) + (root + "ând") rupe ; + +mkV95 : Str -> Verbe = \frige -> + let root = init frige ; + r = init root + "p" + in +verbAffixes frige (mkFromAffix root affixSgGr21 affixPlGr21) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS5 affixPlPS5) + (mkFromAffix r affixSgPP5 affixPlPP5) (root +"ă") (mkAdjReg (r + "t")) + (root + "ând") frige ; + + +mkV96 : Str -> Verbe = \frange -> + let root = init frange ; + r = init root + in +verbAffixes frange (mkFromAffix root affixSgGr21 affixPlGr21) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS5 affixPlPS5) + (mkFromAffix r affixSgPP5 affixPlPP5) (root +"ă") (mkAdjReg (r + "t")) + (root + "ând") frange ; + +mkV97 : Str -> Verbe = \sparge -> + let root = init sparge ; + r = init root ; + r1 = genMut root "a" "ă"; + r2 = genMut r "a" "ă" + in +verbAffixes sparge (mkFromAffix root affixSgGr21 affixPlGr21) + (mkFromAffix r1 affixSgII affixPlII) + (mkTab r2 (init r1 + "sei") (init r1 + "seși") (r2 + "se") (r2 + "seră") affixPlPS5) + (mkFromAffix r2 affixSgPP5 affixPlPP5) (root +"ă") (mkAdjReg (r + "t")) + (r1 + "ând") sparge ; + +mkV98 : Str -> Verbe = \fierbe -> + let root = init fierbe ; + r = init root ; + r1 = genMut root "e" "a" + in +verbAffixes fierbe (mkFromAffix root affixSgGr21 affixPlGr21) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS5 affixPlPS5) + (mkFromAffix r affixSgPP5 affixPlPP5) (r1 +"ă") (mkAdjRegE (r + "t")) + (root + "ând") fierbe ; + +mkV99 : Str -> Verbe = \coace -> + let root = init coace ; + r = genMut2 root "oa" "o" ; + r1 = init r + "p" + in +verbAffixes coace (mkTab root r1 (r1+"i") (root+"e") r1 affixPlGr21) + (mkFromAffix r affixSgII affixPlII) (mkFromAffix r1 affixSgPS5 affixPlPS5) + (mkFromAffix r1 affixSgPP5 affixPlPP5) (root +"ă") (mkAdjRegO (r1 + "t")) + (r + "ând") coace ; +--subGroup 5 : + +mkV100 : Str -> Verbe = \cere -> + let root = init cere ; + r = mkMutE root + in +verbAffixes cere (mkFromAffix root affixSgGr21 affixPlGr21) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS3 affixPlPS3) + (mkFromAffix r affixSgPP2 affixPlPP2) (r +"ă") (mkAdjReg (root + "ut")) + (root + "ând") cere ; + + +mkV101 : Str -> Verbe = \crede -> + let root = init crede ; + newP = init (mkStemPlReg root) ; + r = mkMutE root + in +verbAffixes crede (changeP2 (newP + "i") (mkFromAffix root affixSgGr21 affixPlGr21)) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix newP affixSgPS3 affixPlPS3) + (mkFromAffix newP affixSgPP2 affixPlPP2) (r +"ă") (mkAdjReg (newP + "ut")) + (newP + "ând") crede ; + +mkV102 : Str -> Verbe = \tese -> + let root = init tese ; + newP = init (mkStemPlReg root) ; + r = mkMutE root + in +verbAffixes tese (changeP2 (newP + "i") (mkFromAffix root affixSgGr21 affixPlGr21)) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS3 affixPlPS3) + (mkFromAffix root affixSgPP2 affixPlPP2) (r +"ă") (mkAdjReg (root + "ut")) + (root + "ând") tese ; + +mkV103 : Str -> Verbe = \creste -> + let root = init creste ; + r = Predef.tk 2 root + "sc" ; + newC = mkMutE r + in +verbAffixes creste (changeP1 r (mkFromAffix root affixSgGr21 affixPlGr21)) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS3 affixPlPS3) + (mkFromAffix r affixSgPP2 affixPlPP2) (newC +"ă") (mkAdjReg (r + "ut")) + (r + "ând") creste ; + + +mkV104 : Str -> Verbe = \investe -> + let root = init investe ; + r = Predef.tk 2 root + "sc" ; + newC = mkMutE r ; + rad = genMut r "e" "ă" + in +verbAffixes investe (changeP1 r (mkFromAffix root affixSgGr21 affixPlGr21)) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix rad affixSgPS3 affixPlPS3) + (mkFromAffix rad affixSgPP2 affixPlPP2) (newC +"ă") (mkAdjReg (rad + "ut")) + (rad + "ând") investe ; + + +mkV105 : Str -> Verbe = \bate -> + let root = init bate ; + r = genMut root "a" "ă" + in +verbAffixes bate (changeP2 (mkStemPlReg root) (mkFromAffix root affixSgGr21 affixPlGr21)) + (mkFromAffix r affixSgII affixPlII) (mkFromAffix r affixSgPS3 affixPlPS3) + (mkFromAffix r affixSgPP2 affixPlPP2) (root +"ă") (mkAdjReg (r + "ut")) + (r + "ând") bate ; + +mkV106 : Str -> Verbe = \naste -> + let root = init naste ; + r = Predef.tk 2 root + "sc" ; + rad = genMut r "a" "ă" + in +verbAffixes naste (changeP1 r (mkFromAffix root affixSgGr21 affixPlGr21)) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix rad affixSgPS3 affixPlPS3) + (mkFromAffix rad affixSgPP2 affixPlPP2) (r +"ă") (mkAdjReg (rad + "ut")) + (rad + "ând") naste ; + +--mkV107 : Str -> Verbe = \rage -> + + +mkV108 : Str -> Verbe = \tine -> +let root = init tine ; + r = init root + "i" + in +verbAffixes tine (changeP2 r (mkFromAffix root affixSgGr21 affixPlGr21)) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS3 affixPlPS3) + (mkFromAffix root affixSgPP2 affixPlPP2) (root +"ă") (mkAdjReg (root + "ut")) + (root + "ând") tine ; + +mkV109 : Str -> Verbe = \cunoaste -> +let root = init cunoaste ; + newC = Predef.tk 2 root + "sc" ; + r = mkStemMutOa newC ; + rad = mkStemMutOa root + in +verbAffixes cunoaste (mkTab root r (mkStemPlReg r) cunoaste r affixPlGr21) + (mkFromAffix rad affixSgII affixPlII) (mkFromAffix r affixSgPS3 affixPlPS3) + (mkFromAffix r affixSgPP2 affixPlPP2) (newC +"ă") (mkAdjReg (r + "ut")) + (r + "ând") cunoaste ; + +mkV110 : Str -> Verbe = \coase -> +let root = init coase ; + r = mkStemMutOa root ; + rad = genMut2 root "oa" "u" + in +verbAffixes coase (mkTab root r (mkStemPlReg r) coase r affixPlGr21) + (mkFromAffix r affixSgII affixPlII) (mkFromAffix rad affixSgPS3 affixPlPS3) + (mkFromAffix rad affixSgPP2 affixPlPP2) (root +"ă") (mkAdjReg (rad + "ut")) + (r + "ând") coase ; + +mkV111 : Str -> Verbe = \divide -> +let root = init divide ; + newP = mkStemPlReg root + in +verbAffixes divide (changeP2 newP (mkFromAffix root affixSgGr21 affixPlGr21)) + empty empty empty (root +"ă") (variants{}) + (root + "ând") divide ; + +mkV112 : Str -> Verbe = \vinde -> +let root = init vinde ; + r = genMut root "i" "â" ; + in +verbAffixes vinde (mkTab root r (mkStemPlReg root) vinde r affixPlGr21) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix r affixSgPS3 affixPlPS3) + (mkFromAffix r affixSgPP2 affixPlPP2) (root +"ă") (mkAdjReg (r + "ut")) + (init r + "zând") vinde ; + +mkV113 : Str -> Verbe = \pierde -> +let root = init pierde ; + r = mkMutE root ; + rad = init (mkStemPlReg root) + in +verbAffixes pierde (changeP2 (rad + "i") (mkFromAffix root affixSgGr21 affixPlGr21)) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS3 affixPlPS3) + (mkFromAffix root affixSgPP2 affixPlPP2) (r +"ă") (mkAdjReg (root + "ut")) + (rad + "ând") pierde ; + +--mkV114 : Str -> Verbe = \exige -> + + +--subGroup 6 + +mkV115 : Str -> Verbe = \face -> +let root = init face ; + r = genMut root "a" "ă" + in +verbAffixes face (mkFromAffix root affixSgGr21 affixPlGr21) + (mkFromAffix r affixSgII affixPlII) (mkFromAffix r affixSgPS3 affixPlPS3) + (mkFromAffix r affixSgPP2 affixPlPP2) (root +"ă") (mkAdjReg (r + "ut")) + (r + "ând") (init r) ; +--subGroup 7 +mkV116 : Str -> Verbe = \umple -> +let root = init umple + in +verbAffixes umple (mkFromAffix root affixSgGr31 affixPlGr31) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS3 affixPlPS3) + (mkFromAffix root affixSgPP2 affixPlPP2) (root +"e") (mkAdjReg (root + "ut")) + (root + "ând") umple ; + +--subGroup 8 +mkV117 : Str -> Verbe = \scrie -> +let root = init scrie + in +verbAffixes scrie (mkFromAffix root affixSgGr31 affixPlGr31) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS5 affixPlPS5) + (mkFromAffix root affixSgPP5 affixPlPP5) (root +"e") (mkAdjReg (root + "s")) + (root + "ind") scrie ; + +------------------------------------ +---GROUP 4 -- verbs ending in -i/-î +------------------------------------ +-------------- +--Present +-------------- + +--subGroups 1-2 +affixSgGr41 : Affixe = afixe "esc" "ești" "ește" ; +affixPlGr41 : Affixe = afixe "im" "iți" "esc" ; + +--subGroup 3 + +affixSgGr43 : Affixe = afixe "iesc" "iești" "iește" ; +affixPlGr43 : Affixe = afixe "im" "iți" "iesc" ; + +--subGroup 4 + +affixSgGr44 : Affixe = afixe "iu" "ii" "ie" ; +affixPlGr44 : Affixe = afixe "im" "iți" "iu" ; + +--subGroup 5 + +affixSgGr45 : Affixe = afixe "i" "i" "ie" ; +affixPlGr45 : Affixe = afixe "im" "iți" "ie" ; + +--subGroups 6 -8 + +affixSgGr468 : Affixe = afixe "" "i" "e" ; +affixPlGr468 : Affixe = afixe "im" "iți" "" ; + +--subGroup 9 + +affixSgGr49 : Affixe = afixe "" "i" "ă" ; +affixPlGr49 : Affixe = afixe "im" "iți" "ă" ; + +--subGroup 10 + +affixSgGr410 : Affixe = afixe "" "i" "e" ; +affixPlGr410 : Affixe = afixe "im" "iți" "e" ; + +--subGroup 11 + +affixSgGr411 : Affixe = afixe "" "" "ie" ; +affixPlGr411 : Affixe = afixe "" "" "ie" ; + +--subGroup 12 + +affixSgGr412 : Affixe = afixe "ăsc" "ăști" "ăște" ; +affixPlGr412 : Affixe = afixe "âm" "âți" "ăsc" ; + +--subGroup 13 + +affixSgGr413 : Affixe = afixe "" "i" "ă" ; +affixPlGr413 : Affixe = afixe "âm" "âți" "ă" ; + + +------------------------- +--Imperfect +------------------------- + +--subGroup 1,6-10 +--affixSgII + affixPlII + +--subGroup 2, 12-13 +--affixSgI + affixPlI + +--subGroups 3-5 +--affixSgI2 + affixPlI2 + +--subGroup 11 +affixSgI4 : Affixe = afixe "" "" "ia" ; +affixPlI4 : Affixe = afixe "" "" "iau" ; + +------------------------ +--Past Simple +------------------------ +--subGroups 1-3,5-10 +affixSgPS6 : Affixe = afixe "ii" "iși" "i" ; +affixPlPS6 : Affixe = afixe "irăm" "irăți" "iră" ; + +--subGroup 4 +affixSgPS7 : Affixe = afixe "iui" "iuși" "iu" ; +affixPlPS7 : Affixe = afixe "iurăm" "iurăți" "iură" ; + +--subGroup 11 +affixSgPS8 : Affixe = afixe "" "" "i" ; +affixPlPS8 : Affixe = afixe "" "" "iră" ; + +--subGroup 12-13 +affixSgPS9 : Affixe = afixe "âi" "âși" "î" ; +affixPlPS9 : Affixe = afixe "ârăm" "ârăți" "âră" ; + +----------------------- +--Past Perfect +----------------------- +--subGroups 1-3,5 + 10 +affixSgPP6 : Affixe = afixe "isem" "iseși" "ise" ; +affixPlPP6 : Affixe = afixe "iserăm" "iserăți" "iseră" ; + +--subGroup 4 + +affixSgPP7 : Affixe = afixe "iusem" "iuseși" "iuse" ; +affixPlPP7 : Affixe = afixe "iuserăm" "iuserăți" "iuseră" ; + +--subGroup 11 +affixSgPP8 : Affixe = afixe "" "" "ise" ; +affixPlPP8 : Affixe = afixe "" "" "iseră" ; + +--subGroup 12-13 +affixSgPP9 : Affixe = afixe "âsem" "âseși" "âse" ; +affixPlPP9 : Affixe = afixe "âserăm" "âserăți" "âseră" ; + + +--subGroup 1 + + + +mkV119 : Str -> Verbe = \povesti -> + let root = init povesti + in +verbAffixes povesti (mkFromAffix root affixSgGr41 affixPlGr41) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (root +"ească") (mkAdjReg (root + "it")) + (root + "ind") (root + "ește") ; +--subGroup 2 +mkV120 : Str -> Verbe = \pustii -> +let root = init pustii +in +verbAffixes pustii (mkFromAffix root affixSgGr41 affixPlGr41) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (root +"ască") (mkAdjReg (root + "it")) + (root + "ind") (root + "ește") ; +--subGroup 3 +mkV121 : Str -> Verbe = \locui -> +let root = init locui +in +verbAffixes locui (mkFromAffix root affixSgGr43 affixPlGr44) + (mkFromAffix root affixSgI2 affixPlI2) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (root +"iască") (mkAdjReg (root + "it")) + (root + "ind") (root + "ește") ; +--subGroup 4 +mkV122 : Str -> Verbe = \sti -> +let root = init sti +in +verbAffixes sti (mkFromAffix root affixSgGr44 affixPlGr44) + (mkFromAffix root affixSgI2 affixPlI2) (mkFromAffix root affixSgPS7 affixPlPS7) + (mkFromAffix root affixSgPP7 affixPlPP7) (root +"ie") (mkAdjReg (root + "iut")) + (root + "iind") (variants{}) ; +--subGroup 5 +mkV123 : Str -> Verbe = \sui -> +let root = init sui +in +verbAffixes sui (mkFromAffix root affixSgGr45 affixPlGr45) + (mkFromAffix root affixSgI2 affixPlI2) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (root +"ie") (mkAdjReg (root + "it")) + (root + "ind") (sui+"e") ; + +mkV124 : Str -> Verbe = \indoi -> +let root = init indoi ; + r = init (mkMutO indoi) + in +verbAffixes indoi (mkAffixSpec1 root r affixSgGr45 affixPlGr45) + (mkFromAffix root affixSgI2 affixPlI2) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (r +"ie") (mkAdjReg (root + "it")) + (root + "ind") (r+"ie") ; + +mkV125 : Str -> Verbe = \jupui -> +let root = init jupui ; + r1 = genMut jupui "u" "o" ; + r2 = genMut jupui "u" "oa" +in +verbAffixes jupui (mkTab root r1 r1 (r2+"e") (r2+"e") affixPlGr45) + (mkFromAffix root affixSgI2 affixPlI2) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (r2 +"e") (mkAdjReg (root + "it")) + (root + "ind") (r2+"e") ; + +--subGroup 6 +mkV126 : Str -> Verbe = \fugi -> +let root = init fugi +in +verbAffixes fugi (mkFromAffix root affixSgGr468 affixPlGr468) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (root +"ă") (mkAdjReg (root + "it")) + (root + "ind") fugi ; + +mkV127 : Str -> Verbe = \auzi -> +let root = init auzi ; + r = init root + "d" + in +verbAffixes auzi (mkTab root r auzi (r+"e") r affixPlGr468) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (r +"ă") (mkAdjReg (root + "it")) + (root + "ind") auzi ; + +mkV128 : Str -> Verbe = \dormi -> +let root = init dormi ; + r = mkMutO root + in +verbAffixes dormi (mkAffixSpec2 root r affixSgGr468 affixPlGr468) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (r +"ă") (mkAdjReg (root + "it")) + (root + "ind") dormi ; + +mkV129 : Str -> Verbe = \muri -> +let root = init muri ; + r1 = modU root ; + r2 = mkStemMutO r1 + in +verbAffixes muri (mkTab root r1 (r1 + "i") (r2 + "e") r1 affixPlGr468) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (r2 +"ă") (mkAdjReg (root + "it")) + (root + "ind") (r1 + "i") ; +--subGroup 7 +mkV130 : Str -> Verbe = \simti -> +let root = init simti ; + r = init root + "t" + in +verbAffixes simti (mkTab root r (mkStemPlReg r) (r+"e") r affixPlGr468) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (r +"ă") (mkAdjReg (root + "it")) + (root + "ind") (r+"e") ; + +mkV131 : Str -> Verbe = \sorbi -> +let root = init sorbi ; + r = mkMutO root + in +verbAffixes sorbi (mkAffixSpec2 root r affixSgGr468 affixPlGr468) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (r +"ă") (mkAdjReg (root + "it")) + (root + "ind") (r + "e") ; + +mkV132 : Str -> Verbe = \slobozi -> +let root = init slobozi ; + rad = init root + "d" ; + r = mkMutO rad + in +verbAffixes slobozi (mkTab root rad root (r+"e") rad affixPlGr468) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (r +"ă") (mkAdjReg (root + "it")) + (root + "ind") (r+"e") ; + +mkV133 : Str -> Verbe = \mirosi -> +let root = init mirosi ; + r = mkMutO root + in +verbAffixes mirosi (mkAffixSpec2 root r affixSgGr468 affixPlGr468) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (r +"ă") (mkAdjReg (root + "it")) + (root + "ind") (r+"e") ; + +mkV134 : Str -> Verbe = \imparti -> +let root = init imparti ; + rad = init root + "t" ; + r = genMut rad "ă" "a" + in +verbAffixes imparti (mkFromAffixes1 r root affixSgGr468 affixPlGr468) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (r +"ă") (mkAdjReg (root + "it")) + (root + "ind") (r+"e") ; + +mkV118 : Str -> Verbe = \sari -> +let root = init sari ; + r = genMut root "ă" "a" + in +verbAffixes sari (mkFromAffixes2 r root affixSgGr468 affixPlGr468) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (r +"ă") (mkAdjReg (root + "it")) + (root + "ind") (r+"i") ; + + +mkV135 : Str -> Verbe = \repezi -> +let root = init repezi ; + rad = init root + "d" ; + r = mkMutE rad + in +verbAffixes repezi (mkTab root rad repezi (rad + "e") r affixPlGr468) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (r +"ă") (mkAdjReg (root + "it")) + (root + "ind") (rad + "e") ; + +--subGroup 8 +mkV136 : Str -> Verbe = \veni -> +let root = init veni ; + rad = init root ; + r = genMut root "e" "i" + in +verbAffixes veni (mkTab root r (init r + "i") (r + "e") r affixPlGr468) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (r +"ă") (mkAdjReg (root + "it")) + (root + "ind") (r + "o") ; +--subGroup 9 +mkV137 : Str -> Verbe = \oferi -> +let root = init oferi +in +verbAffixes oferi (mkFromAffix root affixSgGr49 affixPlGr49) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (root +"e") (mkAdjReg (root + "it")) + (root + "ind") (root + "ă") ; + +mkV138 : Str -> Verbe = \acoperi -> +let root = init acoperi; + r = genMut root "e" "ă" + in +verbAffixes acoperi (mkTab root r acoperi (root + "ă") (root + "ă") affixPlGr49) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (root +"e") (mkAdjReg (root + "it")) + (root + "ind") (root + "ă") ; + +--subGroup 10 +mkV139 : Str -> Verbe = \bombani -> +let root = init bombani +in +verbAffixes bombani (mkFromAffix root affixSgGr410 affixPlGr410) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS6 affixPlPS6) + (mkFromAffix root affixSgPP6 affixPlPP6) (root +"e") (mkAdjReg (root + "it")) + (root + "ind") (root + "e") ; + +--subGroup 11 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +mkV140 : Str -> Verbe = \trebui -> +let root = init trebui +in +verbAffixes trebui (mkFromAffix root affixSgGr411 affixPlGr411) + (mkFromAffix root affixSgI4 affixPlI4) (mkFromAffix root affixSgPS8 affixPlPS8) + (mkFromAffix root affixSgPP8 affixPlPP8) (root +"iască") (mkAdjReg (root + "it")) + (root + "ind") nonExist ; + +--subGroup 12 +mkV141 : Str -> Verbe = \uri -> +let root = init uri +in +verbAffixes uri (mkFromAffix root affixSgGr412 affixPlGr412) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS9 affixPlPS9) + (mkFromAffix root affixSgPP9 affixPlPP9) (root +"ască") (mkAdjReg (root + "ât")) + (root + "ând") (root + "ăște") ; +--subGroup 13 + +mkV142 : Str -> Verbe = \vari -> +let root = init vari +in +verbAffixes vari (mkFromAffix root affixSgGr413 affixPlGr413) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS9 affixPlPS9) + (mkFromAffix root affixSgPP9 affixPlPP9) (root +"e") (mkAdjReg (root + "ât")) + (root + "ând") (root + "ă") ; + +mkV143 : Str -> Verbe = \cobori -> +let root = init cobori ; + r = mkMutO root + in +verbAffixes cobori (mkAffixSpec1 root r affixSgGr413 affixPlGr413) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS9 affixPlPS9) + (mkFromAffix root affixSgPP9 affixPlPP9) (r +"e") (mkAdjReg (root + "ât")) + (root + "ând") (r + "ă") ; + +mkV144 : Str -> Verbe = \tabari -> +let root = init tabari ; + rad = modAFirst root ; + r = mkStemPlReg rad + in +verbAffixes tabari (mkTab root rad r (rad + "ă") (rad + "ă") affixPlGr413) + (mkFromAffix root affixSgI affixPlI) (mkFromAffix root affixSgPS9 affixPlPS9) + (mkFromAffix root affixSgPP9 affixPlPP9) (init r +"e") (mkAdjReg (root + "ât")) + (root + "ând") (rad + "ă") ; + + +--------------------------------------- +--Special verbs : + +--to have : + +mkV1 : Str -> Verbe = \avea -> +let root = Predef.tk 2 avea + in +verbAffixes avea (mkTab root "am" "ai" "are" "au" affixPlGr21) + (mkFromAffix root affixSgII affixPlII) (mkFromAffix root affixSgPS3 affixPlPS3) + (mkFromAffix root affixSgPP2 affixPlPP2) "aibă" (mkAdjReg (root + "ut")) + (root + "ând") "ai" ; + +--to be : +{- +mkV2 : Str -> Verbe = \fi -> +let root = init fi ; + pres : Number => Person => Str = table {Sg => table {P1 => "sunt"; P2 => "ești"; P3 => "este"}; + Pl => table {P1 => "suntem"; P2 => "sunteți"; P3 => "sunt"} + }; + ps : Number => Person => Str = table {Sg => table {P1 => "fusei"; P2 => "fuseși"; P3 => "fuse"}; + Pl => table {P1 => "fuserăm"; P2 => "fuserăți"; P3 => "fuseră"} + }; + pp : Number => Person => Str = table {Sg => table {P1 => "fusesem"; P2 => "fuseseși"; P3 => "fusese"}; + Pl => table {P1 => "fuseserăm"; P2 => "fuseserăți"; P3 => "fuseseră"} + } + in + verbAffixes fi pres (mkFromAffix "er" affixSgI affixPlI) ps pp + +-} +} ; \ No newline at end of file diff --git a/next-lib/src/romanian/NumeralRon.gf b/next-lib/src/romanian/NumeralRon.gf new file mode 100644 index 000000000..aa310f20e --- /dev/null +++ b/next-lib/src/romanian/NumeralRon.gf @@ -0,0 +1,249 @@ +concrete NumeralRon of Numeral = CatRon ** + open MorphoRon, CatRon, Prelude in { + +param DForm = unit | teen | ten | teen_inf | attr; + +lincat Digit = {s : CardOrd => DForm => Str ; size : Size} ; +lincat Sub10 = {s : CardOrd => DForm => Str ; size : Size} ; +lincat Sub100 = {s : CardOrd => NumF => Str ; size : Size} ; +lincat Sub1000 = {s : CardOrd => NumF => Str ; size : Size} ; +lincat Sub1000000 = { s : CardOrd => NumF => Str; size : Size } ; + + + +oper mkOrdinalForm : Str -> Gender -> Str = +\two, g -> case g of + { Masc => case two of + {x+"t" => two+"ulea"; + x + "ie" => x + "iilea"; + _ => two+"lea" + }; + Fem => case two of + { x + "a" => two ; + x + ("ă"|"u") => x +"a"; + x + "ei" => two + "a"; + x + "ii" => x + "ia" ; + x + "i" => x + "ea"; + x + "ie" => x +"a" ; + _ => two +"a" + } + }; + + +oper mkOrdinal : Str -> Gender -> ACase -> Str = +\two, g, fl -> mkOrd (mkOrdinalForm two g) g fl; + +oper mkOrd : Str -> Gender -> ACase -> Str = +\two, g, fl -> let cc = variants{(artPos g Sg)++ two ; + (artDem g Sg ANomAcc) ++ "de-"+(artPos g Sg) ++ two + } in + case fl of + { ANomAcc => cc ; + AGenDat => (artDem g Sg AGenDat)++"de-"+(artPos g Sg)++ two ; + AVoc => cc + }; + + +oper mkNum : Str -> Str -> Str -> Str -> Digit = + \two -> \twelve -> \twenty -> \doispe -> mkNumVSpc two twelve twelve twenty two doispe doispe (mkOrdinalForm two Masc) (mkOrdinalForm two Fem) two two; + + +oper mkNumVSpc : Str -> Str -> Str -> Str -> Str -> Str -> Str -> Str -> Str -> Str -> Str -> Digit = + \two -> \twelve -> \douasprezece -> \twenty -> \dou -> \doispe -> \douaspe -> \doilea -> \doua -> + \unu -> \una -> + {s = table { + NCard Masc => table {unit => two ; teen => twelve ; + ten => twenty ; teen_inf => doispe ; attr => unu + } ; + NCard Fem => table {unit => dou ; teen => douasprezece ; + ten => twenty ; teen_inf => douaspe ; attr => una + } ; + NOrd Masc => table {unit => doilea ; + teen => mkOrdinalForm twelve Masc ; + ten => mkOrdinalForm twenty Masc ; + teen_inf => mkOrdinalForm doispe Masc ; + attr => mkOrdinalForm unu Masc + } ; + NOrd Fem => table {unit => doua ; + teen => mkOrdinalForm douasprezece Fem ; + ten => mkOrdinalForm twenty Fem ; + teen_inf => mkOrdinalForm douaspe Fem ; + attr => mkOrdinalForm una Fem + } + } ; + size = less20 ; + lock_Digit = <> + } ; + +oper regNum : Str -> Digit = + \trei -> mkNum trei (trei + "sprezece") (trei + "zeci") (trei + "șpe") ; + + +oper mkMidF : Str -> Str -> Sub100 = +\unsprezece, unspe -> +{ s = table {NCard g => table { Formal => unsprezece ; + Informal => unspe + }; + NOrd g => table {Formal => mkOrdinalForm unsprezece g; + Informal => mkOrdinalForm unspe g + } + }; + + size = less20 ; + lock_Sub100 = <> + }; + + +lin num = \d -> + { s = \\cse => table { NCard g => \\f => d.s ! (NCard g) ! f ; + NOrd g => \\f => let ss = d.s ! (NOrd g) ! f + in + case d.size of + { sg => (artDem g Sg cse) ++ ss ; + _ => mkOrd ss g cse + } + }; + size = d.size + } ; +-- Latin A Supplement chars + +lin n2 = mkNumVSpc "doi" "doispreze" "douăsprezece" "douăzeci" "două" "doișpe" "douășpe" "doilea" "doua" "doi" "două"; +lin n3 = regNum "trei"; +lin n4 = mkNum "patru" "paisprezece" "patruzeci" "paișpe"; +lin n5 = mkNum "cinci" "cinsprezece" "cincizeci" "cinșpe"; +lin n6 = mkNum "șase" "șaisprezece" "șaizeci" "șaișpe"; +lin n7 = mkNum "șapte" "șaptesprezece" "șaptezeci" "șaptișpe"; +lin n8 = mkNum "opt" "optsprezece" "optzeci" "optișpe"; +lin n9 = regNum "nouă"; + +lin pot01 = let num = mkNumVSpc "un" "unsprezece" "unsprezece" "zece" "o" "unșpe" "unșpe" "dintâi" "dintâi" "unu" "una" + in + { s = \\o,c => num.s ! o ! c ; + size = sg + }; + +lin pot0 d = { s = \\o, c => d.s ! o ! c ; + size = less20 + }; + +lin pot110 = mkMidF "zece" "zece" ; + +lin pot111 = mkMidF "unsprezece" "unșpe" ; + +lin pot1to19 = \d -> + {s = \\c => table { Formal => d.s ! c ! teen ; + Informal => d.s ! c ! teen_inf + }; + size = less20 + }; + +lin pot0as1 = \d -> + {s = \\c,_ => d.s ! c ! unit ; + size = d.size + }; + +lin pot1 = \d -> + {s = \\c,_ => d.s ! c ! ten ; + size = pl + }; + + + +lin pot1plus d e = + {s = table { + NCard g => \\_ => d.s ! (NCard g) ! ten ++ "și" ++ e.s ! (NCard g) ! attr ; + NOrd g => \\_ => d.s ! (NCard g) ! ten ++ "și" ++ e.s ! (NOrd g) ! attr + }; + size = pl + }; + +lin pot1as2 n = n ; + +lin pot2 d = + {s = table { + NCard g => \\_ => d.s ! (NCard Fem) ! unit ++ (mksute d.size) ; + NOrd g => \\_ => d.s ! (NCard Fem) ! unit ++ (mkSute d.size g) + }; + + size = pl} ; + +lin pot2plus d e = + {s = \\c,f => d.s ! (NCard Fem) ! unit ++ (mksute d.size) ++ e.s ! c ! f ; + size = pl} ; + +lin pot2as3 n = n ; + +lin pot3 n = + {s = table { + NCard g => \\f => mkmie n.size (n.s ! (NCard Fem) ! f ) ; + NOrd g => \\f => mkMie n.size g (n.s ! (NCard Fem) ! f ) + }; + size = pl + } ; + + +lin pot3plus n m = + {s = \\c, f => mkmie n.size (n.s ! (NCard Fem) ! f ) ++ m.s ! c ! f ; + size = pl + }; + +oper mksute : Size -> Str = \sz -> table {sg => "sută" ; _ => "sute" } ! sz ; +oper mkSute : Size -> Gender -> Str = \sz, g -> +table {sg => mkOrdinalForm "sută" g ; + _ => mkOrdinalForm "sute" g } ! sz ; + +oper mkmie : Size -> Str -> Str = \sz, attr -> + table {sg => "o" ++ "mie" ; + less20 => attr ++ "mii" ; + pl => attr ++ "de" ++ "mii"} ! sz ; + + +oper mkMie : Size -> Gender -> Str -> Str = \sz, g, attr -> +table { sg => "o" ++ mkOrdinalForm "mie" g ; + less20 => attr ++ mkOrdinalForm "mii" g ; + pl => attr ++ "de" ++ mkOrdinalForm "mii" g } ! sz ; + + + +--numerals as sequences of digits : + +lincat + Dig = {s : CardOrd => Str; n : Size ; isDig : Bool} ; + +lin + IDig d = d ; + + IIDig d i = { + s = \\o => d.s ! NCard Masc ++ i.s ! o ; + n = case d.n of + { sg => if_then_else Size (i.isDig) less20 pl ; + _ => pl + }; + isDig = False + } ; +lin + D_0 = mkDig "0" ; + D_1 = mk3Dig "1" "1ul" "1a" sg ; + D_2 = mkDig "2"; + D_3 = mkDig "3" ; + D_4 = mkDig "4" ; + D_5 = mkDig "5" ; + D_6 = mkDig "6" ; + D_7 = mkDig "7" ; + D_8 = mkDig "8" ; + D_9 = mkDig "9" ; + + +oper mkDig : Str -> Dig = \c -> mk3Dig c (c + "lea") (c + "a") less20 ; + +oper mk3Dig : Str -> Str -> Str-> Size -> Dig = \c,u,o,n -> { + s = table {NCard g => c ; NOrd Masc => u ; NOrd Fem => o } ; + n = n; + isDig = True ; + lock_Dig = <> + } ; + + TDigit = {s : CardOrd => Str; n : Size ; isDig : Bool} ; + + +} diff --git a/next-lib/src/romanian/ParadigmsRon.gf b/next-lib/src/romanian/ParadigmsRon.gf new file mode 100644 index 000000000..57735c093 --- /dev/null +++ b/next-lib/src/romanian/ParadigmsRon.gf @@ -0,0 +1,395 @@ +--# -path=.:../romance:../common:../abstract:../../prelude + +--1 Romanian Lexical Paradigms +-- +-- Ramona Enache 2008 - 2009 +-- + + +resource ParadigmsRon = + open + (Predef=Predef), + Prelude, + MorphoRon, + CatRon in { + + flags optimize=all ; + +--2 Parameters +-- +-- To abstract over gender names, we define the following identifiers. + +oper + NGender : Type ; + + masculine : NGender ; + feminine : NGender ; + neuter : NGender ; + + Gender : Type ; + + Masculine : Gender ; + Feminine : Gender ; + +--To abstract over animacy, we define the following : + + Anim : Type ; + + animate : Anim ; + inanimate : Anim; + +-- To abstract over number names, we define the following. + + Number : Type ; + + singular : Number ; + plural : Number ; + +-- prepositions which require cases : + + Preposition : Type ; + + NCase : Type ; + Acc : NCase ; + Dat : NCase ; + Gen : NCase ; + + mkPrep : Str -> NCase -> Prep ; + noPrep : NCase -> Prep ; + +--2 Nouns + + + +--3 Relational nouns +-- +-- Relational nouns need a noun and a preposition. + + mkN2 : N -> Prep -> N2 ; + mkN2 n p = n ** {lock_N2 = <> ; c2 = p}; + +-- Three-place relational nouns need two prepositions. + +mkN3 : N -> Prep -> Prep -> N3 ; +mkN3 n p q = n ** {lock_N3 = <> ; c2 = p ; c3 = q }; + + + +--3 Proper names and noun phrases +-- +-- Proper names need a string and a gender. If no gender is given, the +-- feminine is used for strings ending with "e", the masculine for other strings. + + mkPN = overload { + mkPN : Str -> PN = mkPropN ; + mkPN : Str -> Gender -> PN = mkPropNoun ; + mkPN : Str -> Gender -> Number -> PN = mkProperNoun; + } ; + + +mkPropN : Str -> PN = \Ion -> +case last Ion of +{ "a" => mkPropNoun Ion Feminine ; + _ => mkPropNoun Ion Masculine +}; + +mkPropNoun : Str -> Gender -> PN = \Ion, gen -> + mkProperNoun Ion gen singular ; + +mkProperNoun : Str -> Gender -> Number -> PN = \Ion, gen, num -> +{s = table {ANomAcc => Ion; + AGenDat => case of + { <"a",Fem> => init Ion + "ei" ; + _ => "lui" ++ Ion + }; + AVoc => Ion + }; +g = gen ; +n = num ; +lock_PN = <> +}; + + + + +--3 Two-place adjectives +-- +-- Two-place adjectives need a preposition for their second argument. + + mkA2 : A -> Prep -> A2 ; + mkA2 a p = a ** {c2 = p ; lock_A2 = <>} ; + +--. +--2 Definitions of the paradigms +-- +-- The definitions should not bother the user of the API. So they are +-- hidden from the document. + + + NGender = MorphoRon.NGender ; + Number = MorphoRon.Number ; + Anim = MorphoRon.Animacy ; + Gender = MorphoRon.Gender ; + NCase = MorphoRon.NCase ; + + masculine = NMasc ; + feminine = NFem ; + neuter = NNeut ; + + singular = Sg ; + plural = Pl ; + + animate = Animate ; + inanimate = Inanimate ; + + Masculine = Masc ; + Feminine = Fem ; + + Acc = Ac ; + Dat = Da ; + Gen = Ge ; + + + Preposition = Compl ; + mkPrep ss cc = {s = ss ; c = cc; isDir = True; lock_Prep = <>} ; + noPrep cc = mkPrep [] cc ; + + +compN : N -> Str -> N ; +compN x y = composeN x y ** {lock_N = <>} ; + +ccompN : N -> Str -> N ; +ccompN x y = ccompose x y ** {lock_N = <>} ; + +mkNI : Str -> Str -> NGender -> N; +mkNI s ss g = mkIn (mkNomIrreg s ss g) ** {lock_N = <>} ; + +regN : Str -> NGender -> N ; +regN s g = mkIn (mkNomReg s g) ** {lock_N = <>}; + + +mkVI : Str -> Str -> Str -> N; +mkVI s ss sss = mkIn (mkNomVIrreg s ss sss) ** {lock_N = <>} ; + +mkIn : N -> N ; +mkIn n = mkInanimate n ** {lock_N = <> }; + +mkAnim : N -> N ; +mkAnim n = mkAnimate n ** {lock_N = <> }; + +chV : Str -> N -> N ; +chV s n = mkVocc n s ** {lock_N = <> } ; + + +--smart paradigm for inferring the gender of the nouns +--partly based on the paper +--"COVERT SEMANTIC AND MORPHOPHONEMIC CATEGORIES IN THE ROMANIAN GENDER SYSTEM" +-- by Jan Louis Perkowski, Emil Vrabie + +mkSPN : Str -> N ; +mkSPN s = case s of + { x + ("ă"|"e"|"a") => regN s feminine ; + x + ("el"|"mp"|"mb"|"en"|"id"|"at"|"ete"|"ol"|"et"|"or") => regN s masculine ; + _ => regN s neuter + }; + +mkNN : Str -> Str -> N ; +mkNN s ss = case s of + { x + ("ă"|"e"|"a") => mkNI s ss feminine ; + _ => case ss of + {x + "uri" => mkNI s ss neuter ; + x + "e" => mkNI s ss neuter ; + _ => mkNI s ss masculine + + } + }; + + mkN = overload { + mkN : Str -> Str -> NGender -> N = mkNI; -- worst case - we need Singular + Plural form + gender + mkN : Str -> Str -> Str -> N = mkVI; -- very irregular nouns - feminine + mkN : Str -> Str -> N = mkNN; -- needed Singular + Plural form, infers gender + mkN : Str -> NGender -> N = regN; -- needed Singular + gender, infers Plural form + mkN : Str -> N = mkSPN; -- needed Singular form, infers gender and Plural form + } ; + +--because the plurals ending in "uri" are becoming less and less frequent for neuter nouns, +--and because there is no way of infering the plural form by looking at the structure of the word +--we treat this case separately : + +mkNR : Str -> N; +mkNR s = mkIn (mkNomNeut s) ** {lock_N = <>} ; + +-------------------------------------------------------------------- + +mk4A : Str -> Str -> Str -> Str -> A; +mk4A a b c d = +let adj = mkAdjSpec a b c d in +{s = table { Posit => adj.s ; + Compar => \\f => "mai" ++ (adj.s ! f) ++ "decât"; + Superl => table {AF g n a c => artDem g n c ++ "mai" ++ adj.s ! (AF g n Indef c) ; + AA => artDem Masc Sg ANomAcc ++ "mai" ++ adj.s ! AA + + } + }; isPre = False ; lock_A = <>} ; + +mk5A : Str -> Str -> Str -> Str -> Str -> A ; +mk5A a b c d e = +let adj = mkAdjSSpec a b c d e in +{s = table { Posit => adj.s ; + Compar => \\f => "mai" ++ (adj.s ! f) ++ "decât"; + Superl => table {AF g n a c => artDem g n c ++ "mai" ++ adj.s ! (AF g n Indef c); + AA => artDem Masc Sg ANomAcc ++ "mai" ++ adj.s ! AA + + } + }; isPre = False ; lock_A = <>} ; + +regA : Str -> A = \auriu -> let adj = mkAdjReg auriu in + {s = table {Posit => adj.s ; + Compar => \\f => "mai" ++ (adj.s ! f) ++ "decât"; + Superl => table {AF g n a c => artDem g n c ++ "mai" ++ adj.s ! (AF g n Indef c); + AA => artDem Masc Sg ANomAcc ++ "mai" ++ adj.s ! AA + } + }; isPre = False ; lock_A = <> } ; + +invarA : Str -> A = \auriu -> +let adj =mkAdjInvar auriu in +{s = table { Posit => adj.s ; + Compar => \\f => "mai" ++ (adj.s ! f) ++ "decât"; + Superl => table {AF g n a c => artDem g n c ++ "mai" ++ adj.s ! (AF g n Indef c); + AA => artDem Masc Sg ANomAcc ++ "mai" ++ adj.s ! AA + + } + }; isPre = False ; lock_A = <>} ; + +mkRMut : Str -> A = \auriu -> +let adj = mkRegMut auriu in +{s = table { Posit => adj.s ; + Compar => \\f => "mai" ++ (adj.s ! f) ++ "decât"; + Superl => table {AF g n a c => artDem g n c ++ "mai" ++ adj.s ! (AF g n Indef c); + AA => artDem Masc Sg ANomAcc ++ "mai" ++ adj.s ! AA + + } + }; isPre = False ; lock_A = <>} ; + +mkSMut : Str -> A = \auriu -> +let adj = mkSpecMut auriu in +{s = table { Posit => adj.s ; + Compar => \\f => "mai" ++ (adj.s ! f) ++ "decât"; + Superl => table {AF g n a c => artDem g n c ++ "mai" ++ adj.s ! (AF g n Indef c); + AA => artDem Masc Sg ANomAcc ++ "mai" ++ adj.s ! AA + + } + }; isPre = False ; lock_A = <>} ; + + mkADeg : A -> A -> A ; + noComp : A -> A ; + + + prefA : A -> A ; + +mkADeg a b = + {s = table {Posit => a.s ! Posit ; _ => b.s ! Posit} ; isPre = a.isPre ; lock_A = <>} ; + +noComp a = + {s = \\_ => a.s ! Posit ; + isPre = a.isPre ; + lock_A = <>} ; + +prefA a = {s = a.s ; isPre = True ; lock_A = <>} ; + +--Adverbs : + + mkAdv : Str -> Adv ; + mkAdV : Str -> AdV ; + mkAdA : Str -> AdA ; + + mkAdv x = ss x ** {lock_Adv = <>} ; + mkAdV x = ss x ** {lock_AdV = <>} ; + mkAdA x = ss x ** {lock_AdA = <>} ; + + + mkV2S : V -> Prep -> V2S ; +-- mkVV : V -> VV ; + mkV2V : V -> Prep -> Prep -> V2V ; + mkVA : V -> VA ; + mkV2A : V -> Prep -> Prep -> V2A ; + mkVQ : V -> VQ ; + mkV2Q : V -> Prep -> V2Q ; + + mkAS : A -> AS ; + mkA2S : A -> Prep -> A2S ; + mkAV : A -> Prep -> AV ; + mkA2V : A -> Prep -> Prep -> A2V ; + + + mmkV3 : V -> Prep -> Prep -> V3; + mmkV3 v p q = v ** {c2 = p ; c3 = q ; lock_V3 = <>} ; + + dirV3 : V -> V3 ; + dirV3 v = mmkV3 v (noPrep Ac) (noPrep Da) ; + + mkV3 = overload { + mkV3 : V -> V3 = dirV3 ; + mkV3 : V -> Prep -> Prep -> V3 = mmkV3 + } ; + + V0 : Type = V ; + AS, AV : Type = A ; + A2S, A2V : Type = A2 ; + mkV0 : V -> V0 ; + mkV0 v = v ** {lock_V0 = <>} ; + + mmkV2 : V -> Prep -> V2 ; + mmkV2 v p = v ** {c2 = p ; lock_V2 = <>} ; + + dirV2 : V -> V2 ; + dirV2 v = mmkV2 v (noPrep Ac) ; + + mmkV3 : V -> Prep -> Prep -> V3 ; + mmkV3 v p q = v ** {c2 = p ; c3 = q ; lock_V3 = <>} ; + + mkVS : V -> VS ; + mkVS v = v ** {m = \\_ => Indic ; lock_VS = <>} ; + mkV2S v p = mmkV2 v p ** {mn,mp = Indic ; lock_V2S = <>} ; +-- mkVV v = v ** {c2 = complAcc ; lock_VV = <>} ; +-- deVV v = v ** {c2 = complGen ; lock_VV = <>} ; +--aVV v = v ** {c2 = complDat ; lock_VV = <>} ; + mkV2V v p q = mmkV3 v p q ** {lock_V2V = <>} ; + mkVA v = v ** {lock_VA = <>} ; + mkV2A v p q = mmkV3 v p q ** {lock_V2A = <>} ; + mkVQ : V -> VQ ; + mkVQ v = v ** {lock_VQ = <>} ; + mkV2Q : V -> Prep -> V2Q ; + mkV2Q v p = mmkV2 v p ** {lock_V2Q = <>} ; + + mkAS v = v ** {lock_AS = <>} ; ---- more moods + mkA2S v p = mkA2 v p ** {lock_A2S = <>} ; + mkAV v p = v ** {c = p.p1 ; s2 = p.p2 ; lock_AV = <>} ; + mkA2V v p q = mkA2 v p ** {s3 = q.p2 ; c3 = q.p1 ; lock_A2V = <>} ; + + + + +mkOrd : A -> Ord ; +mkOrd a = {s = a.s ! Posit ; isPre = a.isPre ; lock_Ord = <>} ; + + + +--mkComp a = +--let adj = a.s ! Posit in +--{ s = table {Posit => adj ; +-- Compar => \\f => "mai" ++ adj ! f ++ "decât"; +-- Superl => table {AF g n a c => (artDem g n c) ++ "mai" ++ adj ! (AF g n a c); +-- AA => "cel"++"mai" ++ adj ! AA +-- } +-- }; +-- isPre = a.isPre ; +-- lock_A = <> +-- }; + + + + + + +} ; diff --git a/next-lib/src/romanian/ResRon.gf b/next-lib/src/romanian/ResRon.gf new file mode 100644 index 000000000..945344d6c --- /dev/null +++ b/next-lib/src/romanian/ResRon.gf @@ -0,0 +1,160 @@ +--1 Romance auxiliary operations. +-- + +resource ResRon = ParamX ** open Prelude in { + +flags optimize=all ; + + flags optimize=all ; + +--2 Enumerated parameter types for morphology +-- +-- These types are the ones found in school grammars. +-- Their parameter values are atomic. + +param + + Gender = Masc | Fem ; + + NGender = NMasc | NFem | NNeut ; + + Mood = Indic | Conjunct ; + + Direct = DDir | DInv ; + + NumF = Formal | Informal ; + + Animacy = Animate | Inanimate ; + + param Size = sg | less20 | pl ; + + Case = Acc | Dat | Gen ; + +-- Adjectives are inflected in number, gender, have specific form for enclitic determined +--article, and specific forms for Nom-Accusative/Dative-Genitive/Voccative + + AForm = AF Gender Number Species ACase | AA ; + +-- Gender is not morphologically determined for first and second person pronouns. + + PronGen = PGen Gender | PNoGen ; + +-- Cardinal numerals have gender, ordinal numerals have full number as well. + + ACase = ANomAcc | AGenDat | AVoc ; + Species = Def | Indef ; + NCase = No | Da | Ac | Ge | Vo ; + + + CardOrd = NCard Gender | NOrd Gender; + + +--3 Verbs + + +-- the form we build on syntactical level, based on VForm +-- it represents the main verb forms in Romanian + +param + Temps1 = TPresn | TImparf | TPComp | TPSimple | TPPerfect | TFutur ; + TSubj1 = TSPres | TSPast ; + -- TPart1 = TGer | TPPasse Gender Number Species ACase; + + VerbForm = TInf + | TIndi Temps1 Number Person + | TCondi Number Person + | TSubjo TSubj1 Number Person + | TImper NumPersI + | TGer + | TPPasse Gender Number Species ACase ; + + -- the form we build on morphological level : + + Temps = Presn | Imparf | PSimple | PPerfect ; + TSubj = SPres ; + --TPart = PPasse Gender Number Species ACase; + + VForm = Inf + | Indi Temps Number Person + | Subjo TSubj Number Person + | Imper NumPersI + | Ger + | PPasse Gender Number Species ACase ; + +-- form for compatibility with the other Romance languages, to be used in case that +-- Romanian will be integrated in the Romance category + +param + VF = + VInfin Bool + | VFin TMood Number Person + | VImper NumPersI + | VPart Gender Number Species ACase + | VGer + ; + + TMood = + VPres Mood + | VImperf Mood --# notpresent + | VPasse --# notpresent + | VFut --# notpresent + | VCondit --# notpresent + ; + + NumPersI = SgP2 | PlP1 | PlP2 ; + + VPForm = + VPFinite TMood Anteriority + | VPImperat + | VPGerund + | VPInfinit Anteriority Bool ; + + RTense = + RPres + | RPast --# notpresent + | RPasse --# notpresent + | RFut --# notpresent + | RCond --# notpresent + ; + +-- Agreement of adjectives, verb phrases, and relative pronouns. + +oper + AAgr : Type = {g : Gender ; n : Number} ; + Agr : Type = AAgr ** {p : Person} ; + +param + RAgr = RAg {g : Gender ; n : Number} | RNoAg ; --- AAgr + + + oper + genForms : Str -> Str -> Gender => Str = \bon,bonne -> + table { + Masc => bon ; + Fem => bonne + } ; + + aagrForms : (x1,_,_,x4 : Str) -> (AAgr => Str) = \tout,toute,tous,toutes -> + table { + {g = g ; n = Sg} => genForms tout toute ! g ; + {g = g ; n = Pl} => genForms tous toutes ! g + } ; + + Noun = {s : Number => Species => ACase => Str; g : NGender; a : Animacy} ; + Adj = {s : AForm => Str} ; + -- A = {s : Degree => AForm => Str ; isPre : Bool} ; + + Compl : Type = {s : Str ; c : NCase ; isDir : Bool} ; + +-- complAcc : Compl = {s = [] ; c = Acc ; isDir = True} ; +-- complGen : Compl = {s = [] ; c = Gen ; isDir = True} ; +-- complDat : Compl = {s = [] ; c = Dat ; isDir = True} ; + + + + + + + + +}