diff --git a/lib/resource-0.6/finnish/CombinationsFin.gf b/lib/resource-0.6/finnish/CombinationsFin.gf index 20c375663..213907f1b 100644 --- a/lib/resource-0.6/finnish/CombinationsFin.gf +++ b/lib/resource-0.6/finnish/CombinationsFin.gf @@ -30,7 +30,8 @@ lincat CN = CommNounPhrase ; NP = {s : NPForm => Str ; n : Number ; p : NPPerson} ; PN = {s : Case => Str} ; - Det = {s : Gender => Case => Str ; n : Number} ; + Det = {s : Gender => Case => Str ; n : Number ; isNum : Bool} ; + Num = {s : NPForm => Str ; isNum : Bool} ; Fun = Function ; -- = CommNounPhrase ** {c : NPForm} ; Fun2 = Function ** {c2 : NPForm} ; @@ -38,18 +39,22 @@ lincat Adj1 = Adjective ; -- = CommonNoun Adj2 = Adjective ** {c : NPForm} ; - AdjDeg = {s : Degree => NForm => Str} ; - AP = {s : AdjPos => Number => Case => Str} ; + AdjDeg = {s : Degree => AForm => Str} ; + AP = {s : AdjPos => AForm => Str} ; V = Verb ; -- = {s : VForm => Str} VP = Verb ** {s2 : VForm => Str ; c : ComplCase} ; + VG = {s,s2 : Bool => VForm => Str ; c : ComplCase} ; TV = TransVerb ; -- = Verb ** {s3, s4 : Str ; c : ComplCase} ; V3 = TransVerb ** {s5, s6 : Str ; c2 : ComplCase} ; VS = Verb ; + VV = Verb ** {c : ComplCase} ; AdV = {s : Str} ; + Prep = {s : Str ; c : Case ; isPrep : Bool} ; + S = Sentence ; -- = {s : Str} ; @@ -67,7 +72,7 @@ lincat ConjD = {s1 : Str ; s2 : Str ; n : Number} ; ListS = {s1 : Str ; s2 : Str} ; - ListAP = {s1,s2 : AdjPos => Number => Case => Str} ; + ListAP = {s1,s2 : AdjPos => AForm => Str} ; ListNP = {s1,s2 : NPForm => Str ; n : Number ; p : NPPerson} ; --. @@ -76,7 +81,7 @@ lin UseN = noun2CommNounPhrase ; ModAdj = modCommNounPhrase ; ModGenOne = npGenDet singular ; - ModGenMany = npGenDet plural ; + ModGenMany = npGenDetNum ; UsePN = nameNounPhrase ; UseFun = funAsCommNounPhrase ; AppFun = appFunComm ; @@ -89,9 +94,12 @@ lin DetNP = detNounPhrase ; IndefOneNP = indefNounPhrase singular ; - IndefManyNP = indefNounPhrase plural ; + IndefManyNP = nounPhraseNum False ; DefOneNP = defNounPhrase singular ; - DefManyNP = defNounPhrase plural ; + DefManyNP = nounPhraseNum True ; + MassNP = partNounPhrase singular ; + NoNum = noNum ; + UseInt i = {s = \\_ => i.s ; isNum = True} ; --- case endings sometimes needed CNthatS = nounThatSentence ; @@ -111,14 +119,16 @@ lin PredVV = complVerbVerb ; VTrans = transAsVerb ; + AdjAdv a = ss (a.s ! AAttr ! AAdv) ; --- also APred? AdvVP = adVerbPhrase ; - LocNP = locativeNounPhrase ; + PrepNP = prepPhrase ; AdvCN = advCommNounPhrase ; AdvAP = advAdjPhrase ; PosSlashTV = slashTransVerb True ; NegSlashTV = slashTransVerb False ; OneVP = passPredVerbPhrase ; + ThereNP = onNounPhrase ; IdRP = identRelPron ; FunRP = funRelPron ; @@ -137,6 +147,7 @@ lin QuestVP = questVerbPhrase ; IntVP = intVerbPhrase ; + IsThereNP = onkoNounPhrase ; IntSlash = intSlash ; QuestAdv = questAdverbial ; diff --git a/lib/resource-0.6/finnish/MorphoFin.gf b/lib/resource-0.6/finnish/MorphoFin.gf index 5d0ebc1ee..aa1e3a77c 100644 --- a/lib/resource-0.6/finnish/MorphoFin.gf +++ b/lib/resource-0.6/finnish/MorphoFin.gf @@ -1,3 +1,5 @@ +--# -path=.:../../prelude + --1 A Simple Finnish Resource Morphology -- -- Aarne Ranta 2002 @@ -30,6 +32,7 @@ oper NCase Sg Adess => vede + ("ll" + a) ; NCase Sg Ablat => vede + ("lt" + a) ; NCase Sg Allat => vede + "lle" ; + NCase Sg Abess => vede + ("tt" + a) ; NCase Pl Nom => vede + "t" ; NCase Pl Gen => vesien ; @@ -42,6 +45,7 @@ oper NCase Pl Adess => vesii + ("ll" + a) ; NCase Pl Ablat => vesii + ("lt" + a) ; NCase Pl Allat => vesii + "lle" ; + NCase Pl Abess => vesii + ("tt" + a) ; NPossNom => vete ; NPossGenPl => Predef.tk 1 vesien ; @@ -97,6 +101,34 @@ oper let {a = getHarmony (Predef.dp 1 talo)} in sKukko talo (talo + "n") (talo + ("j" + a)) ; + sBaari : Str -> CommonNoun = \baaria -> + let + baari = Predef.tk 1 baaria ; + baar = Predef.tk 1 baari ; + a = getHarmony (Predef.dp 1 baaria) + in + sKukko baari (baari + "n") (baar + ("ej" + a)) ; + + sKorpi : (_,_,_ : Str) -> CommonNoun = \korpi,korven,korpena -> + let { + a = Predef.dp 1 korpena ; + korpe = Predef.tk 2 korpena ; + korve = Predef.tk 1 korven ; + korvi = Predef.tk 1 korve + "i" + } + in + mkSubst a + korpi + korve + korpe + (korpe + a) + (korpe + "en") + korpi + korvi + (korpi + "en") + (korpi + a) + (korpi + "in") ; + -- Loan words ending in consonants are actually similar to words like -- "malli"/"mallin"/"malleja", with the exception that the "i" is not attached -- to the singular nominative. @@ -300,7 +332,9 @@ oper a = Predef.dp 1 naurista ; nauris = Predef.tk 2 naurista ; nauri = Predef.tk 3 naurista ; - naurii = nauri + "i" + i = Predef.dp 1 nauri ; + naurii = nauri + i ; + naurei = nauri + "i" } in mkSubst a @@ -309,11 +343,11 @@ oper naurii (nauris + ("t" + a)) (naurii + "seen") - naurii - naurii - (naurii + "den") - (naurii + ("t" + a)) - (naurii + "siin") ; + naurei + naurei + (naurei + "den") + (naurei + ("t" + a)) + (naurei + "siin") ; -- The following two are used for adjective comparison. @@ -421,6 +455,7 @@ getHarmony : Str -> Str = \u -> PCase Adess => minu + ("ll" + a) ; PCase Ablat => minu + ("lt" + a) ; PCase Allat => minu + "lle" ; + PCase Abess => minu + ("tt" + a) ; PAcc => Predef.tk 1 minun + "t" } ; n = n ; p = p} ; @@ -433,6 +468,11 @@ getHarmony : Str -> Str = \u -> pronHe = mkPronoun "he" "heidän" "heitä" "heinä" "heihin" Pl P3 ; pronNe = mkPronoun "ne" "niiden" "niitä" "niinä" "niihin" Pl P3 ; + pronTama = mkPronoun "tämä" "tämän" "tätä" "tänä" "tähän" Sg P3 ; + pronNama = mkPronoun "nämä" "näiden" "näitä" "näinä" "näihin" Pl P3 ; + pronTuo = mkPronoun "tuo" "tuon" "tuota" "tuona" "tuohon" Sg P3 ; + pronNuo = mkPronoun "nuo" "noiden" "noita" "noina" "noihin" Pl P3 ; + -- The non-human pronoun "se" ('it') is even more irregular, -- Its accusative cases do not -- have a special form with "t", but have the normal genitive/nominative variation. @@ -451,7 +491,8 @@ getHarmony : Str -> Str = \u -> Illat => "siihen" ; Adess => "sillä" ; Ablat => "siltä" ; - Allat => "sille" + Allat => "sille" ; + Abess => "sittä" } ; } ; @@ -525,16 +566,63 @@ getHarmony : Str -> Str = \u -> } } ; + jokuPron : Number => Case => Str = + let + ku = sPuu "ku" ; + kui = sPuu "kuu" + in + table { + Sg => table { + Nom => "joku" ; + Gen => "jonkun" ; + c => relPron.s ! Sg ! c + ku.s ! NCase Sg c + } ; + Pl => table { + Nom => "jotkut" ; + c => relPron.s ! Pl ! c + kui.s ! NCase Pl c + } + } ; + + jokinPron : Number => Case => Str = + table { + Sg => table { + Nom => "jokin" ; + Gen => "jonkin" ; + c => relPron.s ! Sg ! c + "kin" + } ; + Pl => table { + Nom => "jotkin" ; + c => relPron.s ! Pl ! c + "kin" + } + } ; + +moniPron : Case => Str = caseTable singular (sSusi "moni" "monen" "monena") ; + caseTable : Number -> CommonNoun -> Case => Str = \n,cn -> \\c => cn.s ! NCase n c ; --2 Adjectives -- +-- To form an adjective, it is usually enough to give a noun declension: the +-- adverbial form is regular. + + noun2adj : CommonNoun -> Adjective = noun2adjComp True ; + + noun2adjComp : Bool -> CommonNoun -> Adjective = \isPos,tuore -> + let + tuoreesti = Predef.tk 1 (tuore.s ! NCase Sg Gen) + "sti" ; + tuoreemmin = Predef.tk 2 (tuore.s ! NCase Sg Gen) + "in" + in {s = table { + AN f => tuore.s ! f ; + AAdv => if_then_Str isPos tuoreesti tuoreemmin + } + } ; + -- For the comparison of adjectives, three noun declensions -- are needed in the worst case. - mkAdjDegr : (_,_,_ : CommonNoun) -> AdjDegr = \hyva,parempi,paras -> + mkAdjDegr : (_,_,_ : Adjective) -> AdjDegr = \hyva,parempi,paras -> {s = table { Pos => hyva.s ; Comp => parempi.s ; @@ -546,7 +634,10 @@ caseTable : Number -> CommonNoun -> Case => Str = \n,cn -> -- the characteristic forms of comparative and superlative. regAdjDegr : CommonNoun -> Str -> Str -> AdjDegr = \kiva, kivempaa, kivinta -> - mkAdjDegr kiva (sSuurempi kivempaa) (sSuurin kivinta) ; + mkAdjDegr + (noun2adj kiva) + (noun2adjComp False (sSuurempi kivempaa)) + (noun2adjComp False (sSuurin kivinta)) ; --3 Verbs @@ -574,21 +665,26 @@ caseTable : Number -> CommonNoun -> Case => Str = \n,cn -> } } ; --- For "sanoa", "valua", "kysyä". +-- For "harppoa", "hukkua", "löytyä", with grade alternation. - vSanoa : Str -> Verb = \sanoa -> + vHukkua : (_,_ : Str) -> Verb = \hukkua,huku -> let { - a = Predef.dp 1 sanoa ; - sano = Predef.tk 1 sanoa ; - o = Predef.dp 1 sano + a = Predef.dp 1 hukkua ; + hukku = Predef.tk 1 hukkua ; + u = Predef.dp 1 huku } in mkVerb - sanoa - (sano + "n") - (sano + o) - (sano + (("v" + a) + "t")) - (sano + (("k" + a) + a)) - (sano + ((("t" + a) + a) + "n")) ; + hukkua + (huku + "n") + (hukku + u) + (hukku + (("v" + a) + "t")) + (hukku + (("k" + a) + a)) + (huku + ((("t" + a) + a) + "n")) ; + +-- For cases without alternation: "sanoa", "valua", "kysyä". + + vSanoa : Str -> Verb = \sanoa -> + vHukkua sanoa (Predef.tk 1 sanoa) ; -- For "ottaa", "käyttää", "löytää", "huoltaa", "hiihtää", "siirtää". @@ -612,6 +708,21 @@ caseTable : Number -> CommonNoun -> Case => Str = \n,cn -> vPoistaa : Str -> Verb = \poistaa -> vOttaa poistaa (Predef.tk 1 poistaa + "n") ; +-- For "osata", "lisätä" + + vOsata : Str -> Verb = \osata -> + let { + a = Predef.dp 1 osata ; + osa = Predef.tk 2 osata + } in + mkVerb + osata + (osa + (a + "n")) + (osa + a) + (osa + ((("a" + "v") + a) + "t")) + (osa + ((("t" + "k") + a) + a)) + (osata + (a + "n")) ; + -- For "juosta", "piestä", "nousta", "rangaista", "kävellä", "surra", "panna". vJuosta : (_,_ : Str) -> Verb = \juosta,juoksen -> @@ -671,8 +782,8 @@ caseTable : Number -> CommonNoun -> Case => Str = \n,cn -> Human => kukaInt } ; - kaikkiPron : Case => Str = - let {kaiket = caseTable Pl (sKukko "kaikki" "kaiken" "kaikkia")} in + kaikkiPron : Number -> Case => Str = \n -> + let {kaiket = caseTable n (sKorpi "kaikki" "kaiken" "kaikkena")} in table { Nom => "kaikki" ; c => kaiket ! c diff --git a/lib/resource-0.6/finnish/StructuralFin.gf b/lib/resource-0.6/finnish/StructuralFin.gf index 20ef85c89..6e9e5b86c 100644 --- a/lib/resource-0.6/finnish/StructuralFin.gf +++ b/lib/resource-0.6/finnish/StructuralFin.gf @@ -12,16 +12,59 @@ concrete StructuralFin of Structural = ThouNP = pronNounPhrase pronSina ; HeNP = pronNounPhrase pronHan ; SheNP = pronNounPhrase pronHan ; - ItNP = nameNounPhrase pronSe ; - WeNP = pronNounPhrase pronMe ; - YeNP = pronNounPhrase pronTe ; + WeNP = pronWithNum pronMe ; + YeNP = pronWithNum pronTe ; YouNP = pronNounPhrase pronTe ; TheyNP = pronNounPhrase pronHe ; --- ne + ItNP = nameNounPhrase pronSe ; + ThisNP = pronNounPhraseNP pronTama ; + ThatNP = pronNounPhraseNP pronTuo ; + TheseNP = pronWithNum pronNama ; + ThoseNP = pronWithNum pronNuo ; + + EverybodyNP = { + s = \\f => kaikkiPron Pl ! (npForm2Case Pl f) ; -- näin kaikki + n = Pl ; + p = NP3 + } ; + EverythingNP = { + s = \\f => kaikkiPron Sg ! (npForm2Case Sg f) ; -- näin kaiken + n = Sg ; + p = NP3 + } ; + + SomebodyNP = { + s = \\f => jokuPron ! Sg ! (npForm2Case Sg f) ; + n = Sg ; + p = NP3 + } ; + SomethingNP = { + s = \\f => jokinPron ! Sg ! (npForm2Case Sg f) ; -- näin kaiken + n = Sg ; + p = NP3 + } ; + + EveryDet = jokainenDet ; - AllDet = kaikkiDet ; + AllDet = mkDeterminer singular (kaikkiPron Sg) ; + AllsDet = kaikkiDet ; WhichDet = mikaDet ; - MostDet = useimmatDet ; + WhichsDet n = mkDeterminerGenNum n (mikaInt ! Pl) (kukaInt ! Pl) ; + MostDet = mkDeterminer singular (caseTable singular (sSuurin "enintä")) ; + MostsDet = useimmatDet ; + ManyDet = mkDeterminer singular moniPron ; + MuchDet = mkDeterminer singular (caseTable singular (sNauris "runsasta")) ; + + + ThisDet = mkDeterminer Sg (\\c => pronTama.s ! PCase c) ; + ThatDet = mkDeterminer Sg (\\c => pronTuo.s ! PCase c) ; + TheseDet n = mkDeterminerNum n (\\c => pronNama.s ! PCase c) ; + ThoseDet n = mkDeterminerNum n (\\c => pronNuo.s ! PCase c) ; + + SomeDet = mkDeterminerGen Sg (jokinPron ! Sg) (jokuPron ! Sg) ; + SomesDet n = mkDeterminerGenNum n (jokinPron ! Pl) (jokuPron ! Pl) ; + HowIAdv = ss "kuinka" ; WhenIAdv = ss "koska" ; @@ -42,7 +85,41 @@ concrete StructuralFin of Structural = VeryAdv = ss "hyvin" ; TooAdv = ss "liian" ; + OtherwiseAdv = ss "muuten" ; ThereforeAdv = ss "siksi" ; + CanVV = nomVerbVerb (vJuoda "voida") ; + CanKnowVV = nomVerbVerb (vOsata "osata") ; + MustVV = vHukkua "täytyä" "täydy" ** {c = CCase Gen} ; + WantVV = nomVerbVerb (vOsata "haluta") ; + + EverywhereNP = ss "kaikkialla" ; + SomewhereNP = ss "jossain" ; + NowhereNP = ss ["ei missään"] ; + + AlthoughSubj = ss "vaikka" ; + + AlmostAdv = ss "melkein" ; + QuiteAdv = ss "aika" ; + + InPrep = prepCase Iness ; + OnPrep = prepCase Adess ; + ToPrep = prepCase Illat ; --- allat + ThroughPrep = prepPostpGen "kautta" ; + AbovePrep = prepPostpGen "yläpuolella" ; + UnderPrep = prepPostpGen "alla" ; + InFrontPrep = prepPostpGen "edessä" ; + BehindPrep = prepPostpGen "takana" ; + BetweenPrep = prepPostpGen "välissä" ; + FromPrep = prepCase Elat ; --- ablat + BeforePrep = prepPrep "ennen" Part ; + DuringPrep = prepPostpGen "aikana" ; + AfterPrep = prepPostpGen "jälkeen" ; + WithPrep = prepPostpGen "kanssa" ; + WithoutPrep = prepPrep "ilman" Part ; + ByMeansPrep = prepPostpGen "avulla" ; + PartPrep = prepCase Part ; + AgentPrep = prepPostpGen "toimesta" ; + } diff --git a/lib/resource-0.6/finnish/SyntaxFin.gf b/lib/resource-0.6/finnish/SyntaxFin.gf index 10b0e0dc2..b01af5b27 100644 --- a/lib/resource-0.6/finnish/SyntaxFin.gf +++ b/lib/resource-0.6/finnish/SyntaxFin.gf @@ -107,6 +107,16 @@ oper pronNounPhrase : Pronoun -> NounPhrase = \pron -> {s = \\f => pron.s ! npForm2PForm f ; n = pron.n ; p = NPP pron.p} ; + pronNounPhraseNP : Pronoun -> NounPhrase = \pron -> + {s = table { + NPAccNom => pron.s ! PCase Nom ; + NPAccGen => pron.s ! PCase Gen ; + f => pron.s ! npForm2PForm f + } ; + n = pron.n ; + p = NP3 + } ; + -- *Partitive noun phrases* use the partitive instead of the nominative -- and accusative forms. @@ -122,9 +132,11 @@ oper Numeral : Type = {s : NPForm => Str ; isNum : Bool} ; pronWithNum : Pronoun -> Numeral -> NounPhrase = \me,kaksi -> - {s = \\c => me.s ! npForm2PForm c ++ kaksi.s ! c ; + let meihin = pronNounPhraseNP me + in + {s = \\c => meihin.s ! c ++ kaksi.s ! c ; n = me.n ; - p = NPP me.p + p = NP3 -- meidän kahden talo (*talomme) } ; noNum : Numeral = {s = \\_ => [] ; isNum = False} ; @@ -179,7 +191,7 @@ oper mkDeterminerGenNum n kaikki kaikki ; jokainenDet = mkDeterminer Sg (caseTable Sg (sNainen "jokaista")) ; - kaikkiDet : Numeral -> Determiner = \n -> mkDeterminerNum n kaikkiPron ; + kaikkiDet : Numeral -> Determiner = \n -> mkDeterminerNum n (kaikkiPron Pl) ; useimmatDet = mkDeterminer Pl (caseTable Pl (sSuurin "useinta")) ; mikaDet = mkDeterminerGen Sg (mikaInt ! Sg) (kukaInt ! Sg) ; mitkaDet : Numeral -> Determiner = \n -> @@ -228,6 +240,19 @@ oper p = NP3 } ; + npGenDetNum : Numeral -> NounPhrase -> CommNounPhrase -> NounPhrase = + \viisi,jussi,talo -> + {s = \\c => jussi.s ! NPCase Gen ++ viisi.s ! c ++ + ifPossSuffix talo jussi.p jussi.n ( + case viisi.isNum of { + True => Part ; + _ => npForm2Case Pl c + } + ) ; + n = Pl ; + p = NP3 + } ; + ifPossSuffix : CommNounPhrase -> NPPerson -> Number -> Case -> Str = \talo,np,n,c -> case np of { NP3 => talo.s ! False ! n ! c ; @@ -248,6 +273,11 @@ oper g = idea.g } ; +-- The existential structure is simple. + + onNounPhrase : NounPhrase -> Sentence = \kaljaa -> + ss (kaljaa.s ! NPCase Nom ++ "on") ; + --2 Adjectives -- -- Adjectival phrases are used either as attributes or in predicative position. @@ -265,10 +295,10 @@ param AdjPos = APred | AAttr ; oper - AdjPhrase : Type = {s : AdjPos => Number => Case => Str} ; + AdjPhrase : Type = {s : AdjPos => AForm => Str} ; adj2adjPhrase : Adjective -> AdjPhrase = \uusi -> - {s = \\_,n,c => uusi.s ! NCase n c} ; + {s = \\_ => uusi.s} ; --3 Comparison adjectives @@ -284,11 +314,11 @@ oper -- adjectival phrases ("isompi kuin te"/"teitä isompi"). comparAdjPhrase : AdjDegr -> NounPhrase -> AdjPhrase = \iso, te -> - {s = let {teitaisompi : Number => Case => Str = - \\n,c => te.s ! NPCase Part ++ iso.s ! Comp ! NCase n c} in + {s = let {teitaisompi : AForm => Str = + \\a => te.s ! NPCase Part ++ iso.s ! Comp ! a} in table { APred => variants { - \\n,c => iso.s ! Comp ! NCase n c ++ kuinConj ++ te.s ! NPCase Nom ; + \\a => iso.s ! Comp ! a ++ kuinConj ++ te.s ! NPCase Nom ; teitaisompi } ; AAttr => teitaisompi @@ -300,7 +330,7 @@ oper superlNounPhrase : AdjDegr -> CommNounPhrase -> NounPhrase = \iso,talo -> {s = \\np => let {c = npForm2Case Sg np} in - iso.s ! Sup ! NCase Sg c ++ talo.s ! False ! Sg ! c ; + iso.s ! Sup ! AN (NCase Sg c) ++ talo.s ! False ! Sg ! c ; n = Sg ; p = NP3 } ; @@ -319,20 +349,20 @@ oper complAdj : AdjCompl -> NounPhrase -> AdjPhrase = \hyva,paini -> let { - hyvat : Number => Case => Str = \\n,c => hyva.s ! NCase n c ; + hyvat : AForm => Str = \\a => hyva.s ! a ; painissa : Str = paini.s ! hyva.c } in {s = table { - AAttr => \\n,c => painissa ++ hyvat ! n ! c ; - APred => \\n,c => if_then_else Str + AAttr => \\a => painissa ++ hyvat ! a ; + APred => \\a => if_then_else Str (isLocalNPForm hyva.c) (variants { - hyvat ! n ! c ++ painissa ; - painissa ++ hyvat ! n ! c + hyvat ! a ++ painissa ; + painissa ++ hyvat ! a } ) - (painissa ++ hyvat ! n ! c) + (painissa ++ hyvat ! a) } } ; @@ -358,7 +388,7 @@ oper -- given to the noun. modCommNounPhrase : AdjPhrase -> CommNounPhrase -> CommNounPhrase = \iso,mies -> - {s = \\p,n,c => iso.s ! AAttr ! n ! c ++ mies.s ! p ! n ! c ; + {s = \\p,n,c => iso.s ! AAttr ! AN (NCase n c) ++ mies.s ! p ! n ! c ; g = mies.g } ; @@ -503,7 +533,11 @@ oper -- in terms of the common noun rule. predAdjective : AdjPhrase -> VerbGroup = \iso -> - let {isot : CommNounPhrase = {s = \\_ => iso.s ! APred ; g = NonHuman}} + let + isot : CommNounPhrase = { + s = \\_,n,c => iso.s ! APred ! AN (NCase n c) ; + g = NonHuman + } in predCommNoun isot ; predCommNoun : CommNounPhrase -> VerbGroup = \mies -> @@ -589,17 +623,17 @@ oper -- Most two-place verbs can be used passively; the object case need not be -- the accusative, and it becomes the subject case in the passive sentence. - passTransVerb : Bool -> TransVerb -> VerbPhrase = \b,tavata -> - {s = \\_ => if_then_else Str b (tavata.s ! Pass b) "ei" ; - s2 = \\_ => if_then_else Str b [] (tavata.s ! Pass b) ; + passTransVerb : TransVerb -> VerbGroup = \tavata -> + {s = \\b,_ => if_then_else Str b (tavata.s ! Pass b) "ei" ; + s2 = \\b,_ => if_then_else Str b [] (tavata.s ! Pass b) ; c = tavata.c } ; -- The API function does not demand that the verb is two-place. -- Therefore, we can only give it the accusative case, as default. - passVerb : Bool -> Verb -> VerbPhrase = \b,uida -> - passTransVerb b (mkTransVerbDir uida) ; + passVerb : Verb -> VerbGroup = \uida -> + passTransVerb (mkTransVerbDir uida) ; -- Transitive verbs can be used elliptically as verbs. The semantics -- is left to applications. The definition is trivial, due to record @@ -656,23 +690,28 @@ oper } ; advAdjPhrase : Adverb -> AdjPhrase -> AdjPhrase = \liian, iso -> - {s = \\p,n,c => liian.s ++ iso.s ! p ! n ! c + {s = \\p,a => liian.s ++ iso.s ! p ! a } ; -- Adverbials are typically generated by case, prepositions, or postpositions. --- The rule for creating locative noun phrases by the inessive case --- is a shaky, since the adessive is often required. - prepPhrase : Str -> Case -> NounPhrase -> Adverb = \ennen,c,talvi -> - ss (ennen ++ talvi.s ! NPCase c) ; + Preposition : Type = {s : Str ; c : Case ; isPrep : Bool} ; - postpPhrase : Str -> Case -> NounPhrase -> Adverb = \aikana,c,talvi -> - ss (talvi.s ! NPCase c ++ aikana) ; + prepPrep : Str -> Case -> Preposition = \ennen,gen -> + {s = ennen ; c = gen ; isPrep = True} ; - caseAdv : Case -> NounPhrase -> Adverb = prepPhrase [] ; + prepPostp : Str -> Case -> Preposition = \takana,gen -> + {s = takana ; c = gen ; isPrep = False} ; - locativeNounPhrase : NounPhrase -> Adverb = \np -> --- caseAdv Iness ; - ss (np.s ! NPCase Iness) ; + prepPostpGen : Str -> Preposition = \takana -> + prepPostp takana Gen ; + + prepCase : Case -> Preposition = \iness -> + {s = [] ; c = iness ; isPrep = False} ; + + prepPhrase : Preposition -> NounPhrase -> Adverb = \takana, talo -> + let talon = talo.s ! NPCase takana.c + in ss (if_then_Str takana.isPrep (takana.s ++ talon) (talon ++ takana.s)) ; -- This is a source of the "mann with a telescope" ambiguity, and may produce -- strange things, like "autot aina" (while "autot tänään" is OK). @@ -732,24 +771,22 @@ oper let hc = haluta.c ; haluan = case hc of { - CC Nom => predVerb haluta ; - _ => predVerb haluta ----- {s = \\b,v => - } + CCase Nom => predVerb haluta ; + _ => predVerb {s = table { + Imper Sg => haluta.s ! Imper Sg ; + ImpNegPl => haluta.s ! ImpNegPl ; + _ => haluta.s ! Ind Sg P3 + } + } + } in { s = haluan.s ; - s2 = \\b,v => haluan.s2 ! b ! v ++ uida.s ; + s2 = \\b,v => haluan.s2 ! b ! v ++ uida.s ! True ! Inf ++ + uida.s2 ! True ! Inf ; c = hc } ; - {s = vilja.s ; - s2 = negation ; - s3 = \\g,n => - vilja.s1 ++ - if_then_Str vilja.isAux [] "att" ++ - simma.s ! VPres Infinit Act ++ simma.s2 ! True ++ simma.s3 ! g ! n - } ; - - +nomVerbVerb : Verb -> VerbVerb = \v -> v ** {c = CCase Nom} ; --2 Sentences missing noun phrases -- @@ -899,6 +936,8 @@ oper let {np = Ind jussi.n (np2Person jussi.p)} in ss (ui.s ! np ++ koPart ++ jussi.s ! complementCase True ui.c Inf ++ ui.s2 ! np); + onkoNounPhrase : NounPhrase -> Question = \kaljaa -> + ss ("onko" ++ kaljaa.s ! NPCase Nom) ; --3 Wh-questions -- @@ -1010,19 +1049,19 @@ oper -- The structure is the same as for sentences. Parameters are passed to components. ListAdjPhrase : Type = - {s1,s2 : AdjPos => Number => Case => Str} ; + {s1,s2 : AdjPos => AForm => Str} ; twoAdjPhrase : (_,_ : AdjPhrase) -> ListAdjPhrase = \x,y -> - CO.twoTable3 AdjPos Number Case x y ; + CO.twoTable2 AdjPos AForm x y ; consAdjPhrase : ListAdjPhrase -> AdjPhrase -> ListAdjPhrase = \xs,x -> - CO.consTable3 AdjPos Number Case CO.comma xs x ; + CO.consTable2 AdjPos AForm CO.comma xs x ; conjunctAdjPhrase : Conjunction -> ListAdjPhrase -> AdjPhrase = \c,xs -> - CO.conjunctTable3 AdjPos Number Case c xs ; + CO.conjunctTable2 AdjPos AForm c xs ; conjunctDistrAdjPhrase : ConjunctionDistr -> ListAdjPhrase -> AdjPhrase = \c,xs -> - CO.conjunctDistrTable3 AdjPos Number Case c xs ; + CO.conjunctDistrTable2 AdjPos AForm c xs ; --3 Coordinating noun phrases diff --git a/lib/resource-0.6/finnish/TestResourceFin.gf b/lib/resource-0.6/finnish/TestResourceFin.gf index 5de29ffa8..66a31edcf 100644 --- a/lib/resource-0.6/finnish/TestResourceFin.gf +++ b/lib/resource-0.6/finnish/TestResourceFin.gf @@ -1,7 +1,8 @@ -- use this path to read the grammar from the same directory --# -path=.:../abstract:../../prelude -concrete TestFin of TestAbs = ResFin ** open Prelude, SyntaxFin in { +concrete TestResourceFin of TestResource = + StructuralFin ** open Prelude, SyntaxFin in { flags startcat=Phr ; lexer=unglue ; unlexer=glue ; @@ -12,8 +13,9 @@ lin Small = regAdjDegr (sSusi "pieni" "pienen" "pienenä") "pienempää" "pienintä" ; Old = regAdjDegr (sKukko "vanha" "vanhan" "vanhoja") "vanhempaa" "vanhinta" ; Young = regAdjDegr (sSusi "nuori" "nuoren" "nuorena") "nuorempaa" "nuorinta" ; - American = sNainen "amerikkalaista" ; - Finnish = sNainen "suomalaista" ; + American = noun2adj (sNainen "amerikkalaista") ; + Finnish = noun2adj (sNainen "suomalaista") ; + Happy = regAdjDegr (sNainen "onnellista") "onnellisempaa" "onnellisinta" ; Married = sKukko "vihitty" "vihityn" "vihittyjä" ** {c = NPCase Illat} ; --- naimisissa ! @@ -21,8 +23,11 @@ lin Man = cnHum (mkNoun "mies" "miehen" "miehenä" "miestä" "mieheen" "miehinä" "miehissä" "miesten" "miehiä" "miehiin") ; Woman = cnHum (sNainen "naista") ; + Bottle = cnNoHum (sTalo "pullo") ; Car = cnNoHum (sTalo "auto") ; House = cnNoHum (sTalo "talo") ; + Bar = cnNoHum (sBaari "baaria") ; + Wine = cnNoHum (sBaari "viiniä") ; Light = cnNoHum (sTalo "valo") ; Walk = vJuosta "kävellä" "kävelen" ; @@ -30,6 +35,7 @@ lin Say = vSanoa "sanoa" ; Prove = vPoistaa "todistaa" ; Send = mkTransVerbDir (vOttaa "lähettää" "lähetän") ; + Drink = mkTransVerbDir (vJuoda "juoda") ; Love = mkTransVerbCase (vPoistaa "rakastaa") Part ; Wait = mkTransVerbCase (vOttaa "odottaa" "odotan") Part ; Give = mkTransVerbDir (vOttaa "antaa" "annan") ** diff --git a/lib/resource-0.6/finnish/TypesFin.gf b/lib/resource-0.6/finnish/TypesFin.gf index 86d0645fb..f24f1505c 100644 --- a/lib/resource-0.6/finnish/TypesFin.gf +++ b/lib/resource-0.6/finnish/TypesFin.gf @@ -14,15 +14,15 @@ resource TypesFin = open Prelude in { --2 Enumerated parameter types -- -- These types are the ones found in school grammars. --- Their parameter values are atomic. We omit three of the cases, not --- occurring in the resource syntax. The accusative cases are only +-- Their parameter values are atomic. The accusative cases are only -- defined in syntax; in morphology, there is a special accusative for -- pronouns. param Number = Sg | Pl ; Case = Nom | Gen | Part | Transl | Ess - | Iness | Elat | Illat | Adess | Ablat | Allat ; + | Iness | Elat | Illat | Adess | Ablat | Allat + | Abess ; ---- | Comit | Instruct ; Person = P1 | P2 | P3 ; Degree = Pos | Comp | Sup ; Gender = NonHuman | Human ; @@ -66,10 +66,14 @@ oper -- -- The major division is between the comparison degrees, but it -- is also good to leave room for adjectives that cannon be compared. --- Such adjectives are like common nouns. +-- Such adjectives are like common nouns, except for the adverbial form. - Adjective : Type = CommonNoun ; - AdjDegr : Type = {s : Degree => NForm => Str} ; +param + AForm = AN NForm | AAdv ; + +oper + Adjective : Type = {s : AForm => Str} ; + AdjDegr : Type = {s : Degree => AForm => Str} ; --3 Verbs -- diff --git a/lib/resource-0.6/german/CombinationsGer.gf b/lib/resource-0.6/german/CombinationsGer.gf new file mode 100644 index 000000000..84b103afc --- /dev/null +++ b/lib/resource-0.6/german/CombinationsGer.gf @@ -0,0 +1,198 @@ +--# -path=.:../abstract:../../prelude + +--1 The Top-Level German Resource Grammar +-- +-- Aarne Ranta 2002 -- 2003 +-- +-- This is the German concrete syntax of the multilingual resource +-- grammar. Most of the work is done in the file $syntax.Deu.gf$. +-- However, for the purpose of documentation, we make here explicit the +-- linearization types of each category, so that their structures and +-- dependencies can be seen. +-- Another substantial part are the linearization rules of some +-- structural words. +-- +-- The users of the resource grammar should not look at this file for the +-- linearization rules, which are in fact hidden in the document version. +-- They should use $resource.Abs.gf$ to access the syntactic rules. +-- This file can be consulted in those, hopefully rare, occasions in which +-- one has to know how the syntactic categories are +-- implemented. The parameter types are defined in $TypesGer.gf$. + +concrete CombinationsGer of Combinations = open Prelude, SyntaxGer in { + +flags + startcat=Phr ; + parser=chart ; + +lincat + CN = CommNounPhrase ; + -- = {s : Adjf => Number => Case => Str ; g : Gender} ; + N = CommNoun ; + -- = {s : Number => Case => Str ; g : Gender} ; + NP = NounPhrase ; + -- = {s : NPForm => Str ; n : Number ; p : Person ; pro : Bool} ; + PN = ProperName ; + -- = {s : Case => Str} ; + Det = {s : Gender => Case => Str ; n : Number ; a : Adjf} ; + Fun = Function ; + -- = CommNounPhrase ** {s2 : Preposition ; c : Case} ; + Fun2 = Function ** {s3 : Preposition ; c2 : Case} ; + Num = {s : Str} ; + Prep = {s : Str ; c : Case} ; + + Adj1 = Adjective ; + -- = {s : AForm => Str} ; + Adj2 = Adjective ** {s2 : Preposition ; c : Case} ; + AdjDeg = {s : Degree => AForm => Str} ; + AP = Adjective ** {p : Bool} ; + + V = Verb ; + -- = {s : VForm => Str ; s2 : Particle} ; + VG = {s : VForm => Str ; s2 : Str ; s3 : Bool => Number => Str ; s4 : Str} ; + VP = Verb ** {s3 : Number => Str ; s4 : Str} ; + TV = TransVerb ; + -- = Verb ** {s3 : Preposition ; c : Case} ; + V3 = TransVerb ** {s4 : Preposition ; c2 : Case} ; + VS = Verb ; + VV = Verb ** {isAux : Bool} ; + AdV = {s : Str} ; + + S = Sentence ; + -- = {s : Order => Str} ; + Slash = Sentence ** {s2 : Preposition ; c : Case} ; + + RP = {s : GenNum => Case => Str} ; + RC = {s : GenNum => Str} ; + + IP = ProperName ** {n : Number} ; + Qu = {s : QuestForm => Str} ; + Imp = {s : Number => Str} ; + Phr = {s : Str} ; + Text = {s : Str} ; + + Conj = {s : Str ; n : Number} ; + ConjD = {s1,s2 : Str ; n : Number} ; + + ListS = {s1,s2 : Order => Str} ; + ListAP = {s1,s2 : AForm => Str ; p : Bool} ; + ListNP = {s1,s2 : NPForm => Str ; n : Number ; p : Person ; pro : Bool} ; + +--. + +lin + UseN = noun2CommNounPhrase ; + ModAdj = modCommNounPhrase ; + ModGenOne = npGenDet singular noNum ; + ModGenMany = npGenDet plural ; + UsePN = nameNounPhrase ; + UseFun = funAsCommNounPhrase ; + AppFun = appFunComm ; + AppFun2 = appFun2 ; + AdjP1 = adj2adjPhrase ; + ComplAdj = complAdj ; + PositAdjP = positAdjPhrase ; + ComparAdjP = comparAdjPhrase ; + SuperlNP = superlNounPhrase ; + + DetNP = detNounPhrase ; + IndefOneNP = indefNounPhrase singular ; + IndefManyNP = plurDetNum ; + DefOneNP = defNounPhrase singular ; + DefManyNP nu = defNounPhraseNum nu plural ; + MassNP = massNounPhrase ; + UseInt i = i ; + NoNum = noNum ; + + CNthatS = nounThatSentence ; + PredVP = predVerbPhrase ; + PosVG = predVerbGroup True ; + NegVG = predVerbGroup False ; + + PredV = predVerb ; + PredAP = predAdjective ; + PredCN = predCommNoun ; + PredTV = complTransVerb ; + PredV3 = complDitransVerb ; + PredPassV = passVerb ; + PredNP = predNounPhrase ; + PredAdV = predAdverb ; + PredVS = complSentVerb ; + PredVV = complVerbVerb ; + VTrans = transAsVerb ; + + AdjAdv a = ss (a.s ! APred) ; + PrepNP = prepPhrase ; + AdvVP = adVerbPhrase ; + AdvCN = advCommNounPhrase ; + AdvAP = advAdjPhrase ; + + ThereNP A = predVerbPhrase (pronNounPhrase pronEs) + (predVerbGroup True (complTransVerb (transDir verbGeben) A)) ; + IsThereNP A = questVerbPhrase (pronNounPhrase pronEs) + (predVerbGroup True (complTransVerb (transDir verbGeben) A)) ; + + PosSlashTV = slashTransVerb True ; + NegSlashTV = slashTransVerb False ; + OneVP = predVerbPhrase (nameNounPhrase {s = \\_ => "man"}) ; + + IdRP = identRelPron ; + FunRP = funRelPron ; + RelVP = relVerbPhrase ; + RelSlash = relSlash ; + ModRC = modRelClause ; + RelSuch = relSuch ; + + WhoOne = intPronWho singular ; + WhoMany = intPronWho plural ; + WhatOne = intPronWhat singular ; + WhatMany = intPronWhat plural ; + FunIP = funIntPron ; + NounIPOne = nounIntPron singular ; + NounIPMany = nounIntPron plural ; + + QuestVP = questVerbPhrase ; + IntVP = intVerbPhrase ; + IntSlash = intSlash ; + QuestAdv = questAdverbial ; + + ImperVP = imperVerbPhrase ; + + IndicPhrase = indicUtt ; + QuestPhrase = interrogUtt ; + ImperOne = imperUtterance singular ; + ImperMany = imperUtterance plural ; + + AdvS = advSentence ; + +lin + TwoS = twoSentence ; + ConsS = consSentence ; + ConjS = conjunctSentence ; + ConjDS = conjunctDistrSentence ; + + TwoAP = twoAdjPhrase ; + ConsAP = consAdjPhrase ; + ConjAP = conjunctAdjPhrase ; + ConjDAP = conjunctDistrAdjPhrase ; + + TwoNP = twoNounPhrase ; + ConsNP = consNounPhrase ; + ConjNP = conjunctNounPhrase ; + ConjDNP = conjunctDistrNounPhrase ; + + SubjS = subjunctSentence ; + SubjImper = subjunctImperative ; + SubjQu = subjunctQuestion ; + SubjVP = subjunctVerbPhrase ; + + PhrNP = useNounPhrase ; + PhrOneCN = useCommonNounPhrase singular ; + PhrManyCN = useCommonNounPhrase plural ; + PhrIP ip = ip ; + PhrIAdv ia = ia ; + + OnePhr p = p ; + ConsPhr = cc2 ; + +} ; diff --git a/lib/resource-0.6/german/MorphoGer.gf b/lib/resource-0.6/german/MorphoGer.gf new file mode 100644 index 000000000..c96416abb --- /dev/null +++ b/lib/resource-0.6/german/MorphoGer.gf @@ -0,0 +1,399 @@ +--1 A Simple German Resource Morphology +-- +-- Aarne Ranta 2002 +-- +-- This resource morphology contains definitions needed in the resource +-- syntax. It moreover contains the most usual inflectional patterns. +-- +-- We use the parameter types and word classes defined in $types.Deu.gf$. + +resource MorphoGer = TypesGer ** open (Predef=Predef), Prelude in { + +--2 Nouns +-- +-- For conciseness and abstraction, we define a method for +-- generating a case-dependent table from a list of four forms. + +oper + caselist : (_,_,_,_ : Str) -> Case => Str = \n,a,d,g -> table { + Nom => n ; Acc => a ; Dat => d ; Gen => g} ; + +-- The *worst-case macro* for common nouns needs six forms: all plural forms +-- are always the same except for the dative. + + mkNoun : (_,_,_,_,_,_ : Str) -> Gender -> CommNoun = + \mann, mannen, manne, mannes, männer, männern, g -> {s = table { + Sg => caselist mann mannen manne mannes ; + Pl => caselist männer männer männern männer + } ; g = g} ; + +-- But we never need all the six forms at the same time. Often +-- we need just two, three, or four forms. + + mkNoun4 : (_,_,_,_ : Str) -> Gender -> CommNoun = \kuh,kuhes,kühe,kühen -> + mkNoun kuh kuh kuh kuhes kühe kühen ; + + mkNoun3 : (_,_,_ : Str) -> Gender -> CommNoun = \kuh,kühe,kühen -> + mkNoun kuh kuh kuh kuh kühe kühen ; + + mkNoun2n : (_,_ : Str) -> Gender -> CommNoun = \zahl, zahlen -> + mkNoun3 zahl zahlen zahlen ; + + mkNoun2es : (_,_ : Str) -> Gender -> CommNoun = \wort, wörter -> + mkNoun wort wort wort (wort + "es") wörter (wörter + "n") ; + + mkNoun2s : (_,_ : Str) -> Gender -> CommNoun = \vater, väter -> + mkNoun vater vater vater (vater + "s") väter (väter + "n") ; + + mkNoun2ses : (_,_ : Str) -> Gender -> CommNoun = \wort,wörter -> + mkNoun wort wort wort (wort + variants {"es" ; "s"}) wörter (wörter + "n") ; + +-- Here are the school grammar declensions with their commonest variations. +-- Unfortunately we cannot define *Umlaut* in GF, but have to give two forms. +-- +-- First declension, with plural "en"/"n", including weak masculins: + + declN1 : Str -> CommNoun = \zahl -> + mkNoun2n zahl (zahl + "en") Fem ; + + declN1e : Str -> CommNoun = \stufe -> + mkNoun2n stufe (stufe + "n") Fem ; + + declN1M : Str -> CommNoun = \junge -> let {jungen = junge + "n"} in + mkNoun junge jungen jungen jungen jungen jungen Masc ; + + declN1eM : Str -> CommNoun = \soldat -> let {soldaten = soldat + "en"} in + mkNoun soldat soldaten soldaten soldaten soldaten soldaten Masc ; + +-- Second declension, with plural "e": + + declN2 : Str -> CommNoun = \punkt -> + mkNoun2es punkt (punkt+"e") Masc ; + + declN2i : Str -> CommNoun = \onkel -> + mkNoun2s onkel onkel Masc ; + + declN2u : (_,_ : Str) -> CommNoun = \raum,räume -> + mkNoun2es raum räume Masc ; + + declN2uF : (_,_ : Str) -> CommNoun = \kuh,kühe -> + mkNoun3 kuh kühe (kühe + "n") Fem ; + +-- Third declension, with plural "er": + + declN3 : Str -> CommNoun = \punkt -> + mkNoun2es punkt (punkt+"er") Neut ; + + declN3u : (_,_ : Str) -> CommNoun = \buch,bücher -> + mkNoun2ses buch bücher Neut ; + + declN3uS : (_,_ : Str) -> CommNoun = \haus,häuser -> + mkNoun2es haus häuser Neut ; + +-- Plural with "s": + + declNs : Str -> CommNoun = \restaurant -> + mkNoun3 restaurant (restaurant+"s") (restaurant+"s") Neut ; + + +--2 Pronouns +-- +-- Here we define personal and relative pronouns. +-- All personal pronouns, except "ihr", conform to the simple +-- pattern $mkPronPers$. + + ProPN = {s : NPForm => Str ; n : Number ; p : Person} ; + + mkPronPers : (_,_,_,_,_ : Str) -> Number -> Person -> ProPN = + \ich,mich,mir,meines,mein,n,p -> { + s = table { + NPCase c => caselist ich mich mir meines ! c ; + NPPoss gn c => mein + pronEnding ! gn ! c + } ; + n = n ; + p = p + } ; + + pronEnding : GenNum => Case => Str = table { + GSg Masc => caselist "" "en" "em" "es" ; + GSg Fem => caselist "e" "e" "er" "er" ; + GSg Neut => caselist "" "" "em" "es" ; + GPl => caselist "e" "e" "en" "er" + } ; + + pronIch = mkPronPers "ich" "mich" "mir" "meines" "mein" Sg P1 ; + pronDu = mkPronPers "du" "dich" "dir" "deines" "dein" Sg P2 ; + pronEr = mkPronPers "er" "ihn" "ihm" "seines" "sein" Sg P3 ; + pronSie = mkPronPers "sie" "sie" "ihr" "ihres" "ihr" Sg P3 ; + pronEs = mkPronPers "es" "es" "ihm" "seines" "sein" Sg P3 ; + pronWir = mkPronPers "wir" "uns" "uns" "unser" "unser" Pl P1 ; + + pronSiePl = mkPronPers "sie" "sie" "ihnen" "ihrer" "ihr" Pl P3 ; + pronSSie = mkPronPers "Sie" "Sie" "Ihnen" "Ihrer" "Ihr" Pl P3 ; --- + +-- We still have wrong agreement with the complement of the polite "Sie": +-- it is in plural, like the verb, although it should be in singular. + +-- The peculiarity with "ihr" is the presence of "e" in forms without an ending. + + pronIhr = + {s = table { + NPPoss (GSg Masc) Nom => "euer" ; + NPPoss (GSg Neut) Nom => "euer" ; + NPPoss (GSg Neut) Acc => "euer" ; + pf => (mkPronPers "ihr" "euch" "euch" "euer" "eur" Pl P2).s ! pf + } ; + n = Pl ; + p = P2 + } ; + +-- Relative pronouns are like the definite article, except in the genitive and +-- the plural dative. The function $artDef$ will be defined right below. + + RelPron : Type = {s : GenNum => Case => Str} ; + + relPron : RelPron = {s = \\gn,c => + case of { + => "deren" ; + => "dessen" ; + => "denen" ; + => "deren" ; + _ => artDef ! gn ! c + } + } ; + + +--2 Articles +-- +-- Here are all forms the indefinite and definite article. +-- The indefinite article is like a large class of pronouns. +-- The definite article is more peculiar; we don't try to +-- subsume it to any general rule. + + artIndef : Gender => Case => Str = \\g,c => "ein" + pronEnding ! GSg g ! c ; + + artDef : GenNum => Case => Str = table { + GSg Masc => caselist "der" "den" "dem" "des" ; + GSg Fem => caselist "die" "die" "der" "der" ; + GSg Neut => caselist "das" "das" "dem" "des" ; + GPl => caselist "die" "die" "den" "der" + } ; + + +--2 Adjectives +-- +-- As explained in $types.Deu.gf$, it +-- would be superfluous to use the cross product of gender and number, +-- since there is no gender distinction in the plural. But it is handy to have +-- a function that constructs gender-number complexes. + + gNumber : Gender -> Number -> GenNum = \g,n -> + case n of { + Sg => GSg g ; + Pl => GPl + } ; + +-- It's also handy to have a function that finds out the number from such a complex. + + numGenNum : GenNum -> Number = \gn -> + case gn of { + GSg _ => Sg ; + GPl => Pl + } ; + +-- This function costructs parameters in the complex type of adjective forms. + + aMod : Adjf -> Gender -> Number -> Case -> AForm = \a,g,n,c -> + AMod a (gNumber g n) c ; + +-- The worst-case macro for adjectives (positive degree) only needs +-- two forms. + + mkAdjective : (_,_ : Str) -> Adjective = \böse,bös -> {s = table { + APred => böse ; + AMod Strong (GSg Masc) c => + caselist (bös+"er") (bös+"en") (bös+"em") (bös+"es") ! c ; + AMod Strong (GSg Fem) c => + caselist (bös+"e") (bös+"e") (bös+"er") (bös+"er") ! c ; + AMod Strong (GSg Neut) c => + caselist (bös+"es") (bös+"es") (bös+"em") (bös+"es") ! c ; + AMod Strong GPl c => + caselist (bös+"e") (bös+"e") (bös+"en") (bös+"er") ! c ; + AMod Weak (GSg g) c => case of { + <_,Nom> => bös+"e" ; + => bös+"en" ; + <_,Acc> => bös+"e" ; + _ => bös+"en" } ; + AMod Weak GPl c => bös+"en" + }} ; + +-- Here are some classes of adjectives: + + adjReg : Str -> Adjective = \gut -> mkAdjective gut gut ; + adjE : Str -> Adjective = \bös -> mkAdjective (bös+"e") bös ; + adjEr : Str -> Adjective = \teu -> mkAdjective (teu+"er") (teu+"r") ; + adjInvar : Str -> Adjective = \prima -> {s = table {_ => prima}} ; + +-- The first three classes can be recognized from the end of the word, depending +-- on if it is "e", "er", or something else. + + adjGen : Str -> Adjective = \gut -> let { + er = Predef.dp 2 gut ; + teu = Predef.tk 2 gut ; + e = Predef.dp 1 gut ; + bös = Predef.tk 1 gut + } in + ifTok Adjective er "er" (adjEr teu) ( + ifTok Adjective e "e" (adjE bös) ( + (adjReg gut))) ; + + +-- The comparison of adjectives needs three adjectives in the worst case. + + mkAdjComp : (_,_,_ : Adjective) -> AdjComp = \gut,besser,best -> + {s = table {Pos => gut.s ; Comp => besser.s ; Sup => best.s}} ; + +-- It can be done by just three strings, if each of the comparison +-- forms taken separately is a regular adjective. + + adjCompReg3 : (_,_,_ : Str) -> AdjComp = \gut,besser,best -> + mkAdjComp (adjReg gut) (adjReg besser) (adjReg best) ; + +-- If also the comparison forms are regular, one string is enough. + + adjCompReg : Str -> AdjComp = \billig -> + adjCompReg3 billig (billig+"er") (billig+"st") ; + + +--2 Verbs +-- +-- We limit ourselves to verbs in present tense infinitive, indicative, +-- and imperative, and past participle. Other forms will be introduced later. +-- +-- The worst-case macro needs three forms: the infinitive, the third person +-- singular indicative, and the second person singular imperative. +-- We take care of the special cases "ten", "sen", "ln", "rn". +-- +-- A famous law about Germanic languages says that plural first and third person +-- are similar. + + mkVerbum : (_,_,_,_ : Str) -> Verbum = \geben, gib, gb, gegeben -> + let { + en = Predef.dp 2 geben ; + geb = ifTok Tok (Predef.tk 1 en) "e" (Predef.tk 2 geben)(Predef.tk 1 geben) ; + gebt = ifTok Tok (Predef.dp 1 geb) "t" (geb + "et") (geb + "t") ; + gibst = ifTok Tok (Predef.dp 1 gib) "s" (gib + "t") (gib + "st") ; + gegebener = (adjReg gegeben).s + } in table { + VInf => geben ; + VInd Sg P1 => geb + "e" ; + VInd Sg P2 => gibst ; + VInd Sg P3 => gib + "t" ; + VInd Pl P2 => gebt ; + VInd Pl _ => geben ; -- the famous law + VImp Sg => gb ; + VImp Pl => gebt ; + VPart a => gegebener ! a + } ; + +-- Regular verbs: + + regVerb : Str -> Verbum = \legen -> + let {lege = ifTok Tok (Predef.dp 3 legen) "ten" (Predef.tk 1 legen) ( + ifTok Tok (Predef.dp 2 legen) "en" (Predef.tk 2 legen) ( + Predef.tk 1 legen))} in + mkVerbum legen lege lege ("ge" + (lege + "t")) ; + +-- Verbs ending with "t"; now recognized in $mkVerbum$. + + verbWarten : Str -> Verbum = regVerb ; + +-- Verbs with Umlaut in the second and third person singular and imperative: + + verbSehen : Str -> Str -> Str -> Verbum = \sehen, sieht, gesehen -> + let {sieh = Predef.tk 1 sieht} in mkVerbum sehen sieh sieh gesehen ; + +-- Verbs with Umlaut in the second and third person singular but not imperative: + + verbLaufen : Str -> Str -> Str -> Verbum = \laufen, läuft, gelaufen -> + let {läuf = Predef.tk 1 läuft ; laufe = Predef.tk 1 laufen} + in mkVerbum laufen läuf laufe gelaufen ; + +-- The verb "be": + + verbumSein : Verbum = let { + gewesen = (adjReg "gewesen").s + } in + table { + VInf => "sein" ; + VInd Sg P1 => "bin" ; + VInd Sg P2 => "bist" ; + VInd Sg P3 => "ist" ; + VInd Pl P2 => "seid" ; + VInd Pl _ => "sind" ; + VImp Sg => "sei" ; + VImp Pl => "seiet" ; + VPart a => gewesen ! a + } ; + +-- The verb "have": + + verbumHaben : Verbum = let { + haben = (regVerb "haben") + } in + table { + VInd Sg P2 => "hast" ; + VInd Sg P3 => "hat" ; + v => haben ! v + } ; + +-- The verb "become", used as the passive auxiliary: + + verbumWerden : Verbum = let { + werden = regVerb "werden" ; + geworden = (adjReg "geworden").s + } in + table { + VInd Sg P2 => "wirst" ; + VInd Sg P3 => "wird" ; + VPart a => geworden ! a ; + v => werden ! v + } ; + +-- A *full verb* ($Verb$) consists of the inflection forms ($Verbum$) and +-- a *particle* (e.g. "aus-sehen"). Simple verbs are the ones that have no +-- such particle. + + mkVerb : Verbum -> Particle -> Verb = \v,p -> {s = v ; s2 = p} ; + + mkVerbSimple : Verbum -> Verb = \v -> mkVerb v [] ; + + verbSein = mkVerbSimple verbumSein ; + verbHaben = mkVerbSimple verbumHaben ; + verbWerden = mkVerbSimple verbumWerden ; + verbGeben = mkVerbSimple (verbSehen "geben" "gibt" "gegeben") ; + +{- + -- tests for optimizer + verbumSein2 : Verbum = + table { + VInf => "sein" ; + VInd Sg P1 => "bin" ; + VInd Sg P2 => "bist" ; + VInd Sg P3 => "ist" ; + VInd Pl P2 => "seid" ; + VInd Pl _ => "sind" ; + VImp Sg => "sei" ; + VImp Pl => "seiet" ; + VPart a => (adjReg "gewesen").s ! a + } ; + + verbumHaben2 : Verbum = + table { + VInd Sg P2 => "hast" ; + VInd Sg P3 => "hat" ; + v => regVerb "haben" ! v + } ; +-} + +} ; diff --git a/lib/resource-0.6/german/ParadigmsGer.gf b/lib/resource-0.6/german/ParadigmsGer.gf new file mode 100644 index 000000000..1bfeb3fe6 --- /dev/null +++ b/lib/resource-0.6/german/ParadigmsGer.gf @@ -0,0 +1,310 @@ +--# -path=.:../abstract:../../prelude + +--1 German Lexical Paradigms +-- +-- Aarne Ranta 2003 +-- +-- This is an API to the user of the resource grammar +-- for adding lexical items. It give shortcuts for forming +-- expressions of basic categories: nouns, adjectives, verbs. +-- +-- Closed categories (determiners, pronouns, conjunctions) are +-- accessed through the resource syntax API, $resource.Abs.gf$. +-- +-- The main difference with $morpho.Deu.gf$ is that the types +-- referred to are compiled resource grammar types. We have moreover +-- had the design principle of always having existing forms as string +-- arguments of the paradigms, not stems. +-- +-- The following modules are presupposed: + +resource Paradigms = open (Predef=Predef), Prelude, (Morpho=Morpho), Syntax, Deutsch in { + + +--2 Parameters +-- +-- To abstract over gender names, we define the following identifiers. + +oper + masculine : Gender ; + feminine : Gender ; + neuter : Gender ; + +-- To abstract over case names, we define the following. + + nominative : Case ; + accusative : Case ; + dative : Case ; + genitive : Case ; + +-- To abstract over number names, we define the following. + + singular : Number ; + plural : Number ; + + +--2 Nouns + +-- Worst case: give all four singular forms, two plural forms (others + dative), +-- and the gender. + + mkN : (_,_,_,_,_,_ : Str) -> Gender -> N ; + -- mann, mann, manne, mannes, männer, männern + +-- Often it is enough with singular and plural nominatives, and singular +-- genitive. The plural dative +-- is computed by the heuristic that it is the same as the nominative this +-- ends with "n" or "s", otherwise "n" is added. + + nGen : Str -> Str -> Str -> Gender -> N ; -- punkt,punktes,punkt + +-- Here are some common patterns. Singular nominative or two nominatives are needed. +-- Two forms are needed in case of Umlaut, which would be complicated to define. +-- For the same reason, we have separate patterns for multisyllable stems. +-- +-- The weak masculine pattern $nSoldat$ avoids duplicating the final "e". + + nRaum : (_,_ : Str) -> N ; -- Raum, (Raumes,) Räume (masc) + nTisch : Str -> N ; -- Tisch, (Tisches, Tische) (masc) + nVater : (_,_ : Str) -> N ; -- Vater, (Vaters,) Väter (masc) + nFehler : Str -> N ; -- Fehler, (fehlers, Fehler) (masc) + nSoldat : Str -> N ; -- Soldat (, Soldaten) ; Kunde (, Kunden) (masc) + +-- Neuter patterns. + + nBuch : (_,_ : Str) -> N ; -- Buch, (Buches, Bücher) (neut) + nMesser : Str -> N ; -- Messer, (Messers, Messer) (neut) + nAuto : Str -> N ; -- Auto, (Autos, Autos) (neut) + +-- Feminine patterns. Duplicated "e" is avoided in $nFrau$. + + nHand : (_,_ : Str) -> N ; -- Hand, Hände; Mutter, Mütter (fem) + nFrau : Str -> N ; -- Frau (, Frauen) ; Wiese (, Wiesen) (fem) + + +-- Nouns used as functions need a preposition. The most common is "von". + + mkFun : N -> Preposition -> Case -> Fun ; + funVon : N -> Fun ; + +-- Proper names, with their possibly +-- irregular genitive. The regular genitive is "s", omitted after "s". + + mkPN : (karolus, karoli : Str) -> PN ; -- karolus, karoli + pnReg : (Johann : Str) -> PN ; -- Johann, Johanns ; Johannes, Johannes + +-- On the top level, it is maybe $CN$ that is used rather than $N$, and +-- $NP$ rather than $PN$. + + mkCN : N -> CN ; + mkNP : (karolus,karoli : Str) -> NP ; + + npReg : Str -> NP ; -- Johann, Johanns + +-- In some cases, you may want to make a complex $CN$ into a function. + + mkFunCN : CN -> Preposition -> Case -> Fun ; + funVonCN : CN -> Fun ; + + +--2 Adjectives + +-- Non-comparison one-place adjectives need two forms in the worst case: +-- the one in predication and the one before the ending "e". + + mkAdj1 : (teuer,teur : Str) -> Adj1 ; + +-- Invariable adjective are a special case. + + adjInvar : Str -> Adj1 ; -- prima + +-- The following heuristic recognizes the the end of the word, and builds +-- the second form depending on if it is "e", "er", or something else. +-- N.B. a contraction is made with "er", which works for "teuer" but not +-- for "bitter". + + adjGen : Str -> Adj1 ; -- gut; teuer; böse + +-- Two-place adjectives need a preposition and a case as extra arguments. + + mkAdj2 : Adj1 -> Str -> Case -> Adj2 ; -- teilbar, durch, acc + +-- Comparison adjectives may need three adjective, corresponding to the +-- three comparison forms. + + mkAdjDeg : (gut,besser,best : Adj1) -> AdjDeg ; + +-- In many cases, each of these adjectives is itself regular. Then we only +-- need three strings. Notice that contraction with "er" is not performed +-- ("bessere", not "bessre"). + + aDeg3 : (gut,besser,best : Str) -> AdjDeg ; + +-- In the completely regular case, the comparison forms are constructed by +-- the endings "er" and "st". + + aReg : Str -> AdjDeg ; -- billig, billiger, billigst + +-- The past participle of a verb can be used as an adjective. + + aPastPart : V -> Adj1 ; -- gefangen + +-- On top level, there are adjectival phrases. The most common case is +-- just to use a one-place adjective. The variation in $adjGen$ is taken +-- into account. + + apReg : Str -> AP ; + + +--2 Verbs +-- +-- The fragment only has present tense so far, but in all persons. +-- It also has the infinitive and the past participles. +-- The worst case macro needs four forms: : the infinitive and +-- the third person singular (where Umlaut may occur), the singular imperative, +-- and the past participle. +-- +-- The function recognizes if the stem ends with "s" or "t" and performs the +-- appropriate contractions. + + mkV : (_,_,_,_ : Str) -> V ; -- geben, gibt, gib, gegeben + +-- Regular verbs are those where no Umlaut occurs. + + vReg : Str -> V ; -- kommen + +-- The verbs 'be' and 'have' are special. + + vSein : V ; + vHaben : V ; + +-- Verbs with a detachable particle, with regular ones as a special case. + + vPart : (_,_,_,_,_ : Str) -> V ; -- sehen, sieht, sieh, gesehen, aus + vPartReg : (_,_ : Str) -> V ; -- bringen, um + +-- Two-place verbs, and the special case with direct object. Notice that +-- a particle can be included in a $V$. + + mkTV : V -> Str -> Case -> TV ; -- hören, zu, dative + + tvReg : Str -> Str -> Case -> TV ; -- hören, zu, dative + tvDir : V -> TV ; -- umbringen + tvDirReg : Str -> TV ; -- lieben + +-- Three-place verbs require two prepositions and cases. + + mkV3 : V -> Str -> Case -> Str -> Case -> V3 ; -- geben,[],dative,[],accusative + + +--2 Adverbials +-- +-- Adverbials for modifying verbs, adjectives, and sentences can be formed +-- from strings. + + mkAdV : Str -> AdV ; + mkAdA : Str -> AdA ; + mkAdS : Str -> AdS ; + +-- Prepositional phrases are another productive form of adverbials. + + mkPP : Case -> Str -> NP -> AdV ; + +-- The definitions should not bother the user of the API. So they are +-- hidden from the document. +--. + + + masculine = Masc ; + feminine = Fem ; + neuter = Neut ; + nominative = Nom ; + accusative = Acc ; + dative = Dat ; + genitive = Gen ; + -- singular defined in Types + -- plural defined in Types + + mkN a b c d e f g = mkNoun a b c d e f g ** {lock_N = <>} ; + + nGen = \punkt, punktes, punkte, g -> let { + e = Predef.dp 1 punkte ; + eqy = ifTok N e ; + noN = mkNoun4 punkt punktes punkte punkte g ** {lock_N = <>} + } in + eqy "n" noN ( + eqy "s" noN ( + mkNoun4 punkt punktes punkte (punkte+"n") g ** {lock_N = <>})) ; + + nRaum = \raum, räume -> nGen raum (raum + "es") räume masculine ; + nTisch = \tisch -> + mkNoun4 tisch (tisch + "es") (tisch + "e") (tisch +"en") masculine ** + {lock_N = <>}; + nVater = \vater, väter -> nGen vater (vater + "s") väter masculine ; + nFehler = \fehler -> nVater fehler fehler ; + + nSoldat = \soldat -> let { + e = Predef.dp 1 soldat ; + soldaten = ifTok Tok e "e" (soldat + "n") (soldat + "en") + } in + mkN soldat soldaten soldaten soldaten soldaten soldaten masculine ; + + nBuch = \buch, bücher -> nGen buch (buch + "es") bücher neuter ; + nMesser = \messer -> nGen messer (messer + "s") messer neuter ; + nAuto = \auto -> let {autos = auto + "s"} in + mkNoun4 auto autos autos autos neuter ** {lock_N = <>} ; + + nHand = \hand, hände -> nGen hand hand hände feminine ; + + nFrau = \frau -> let { + e = Predef.dp 1 frau ; + frauen = ifTok Tok e "e" (frau + "n") (frau + "en") + } in + mkN frau frau frau frau frauen frauen feminine ; + + mkFun n = mkFunCN (UseN n) ; + funVon n = funVonCN (UseN n) ; + + mkPN = \karolus, karoli -> + {s = table {Gen => karoli ; _ => karolus} ; lock_PN = <>} ; + pnReg = \horst -> + mkPN horst (ifTok Tok (Predef.dp 1 horst) "s" horst (horst + "s")) ; + + mkCN = UseN ; + mkNP = \x,y -> UsePN (mkPN x y) ; + npReg = \s -> UsePN (pnReg s) ; + + mkFunCN n p c = mkFunC n p c ** {lock_Fun = <>} ; + funVonCN n = funVonC n ** {lock_Fun = <>} ; + + mkAdj1 x y = mkAdjective x y ** {lock_Adj1 = <>} ; + adjInvar a = Morpho.adjInvar a ** {lock_Adj1 = <>} ; + adjGen a = Morpho.adjGen a ** {lock_Adj1 = <>} ; + mkAdj2 = \a,p,c -> a ** {s2 = p ; c = c ; lock_Adj2 = <>} ; + + mkAdjDeg a b c = mkAdjComp a b c ** {lock_AdjDeg = <>} ; + aDeg3 a b c = adjCompReg3 a b c ** {lock_AdjDeg = <>} ; + aReg a = adjCompReg a ** {lock_AdjDeg = <>} ; + aPastPart = \v -> {s = table AForm {a => v.s ! VPart a} ; lock_Adj1 = <>} ; + apReg = \s -> AdjP1 (adjGen s) ; + + mkV = \sehen, sieht, sieh, gesehen -> + mkVerbSimple (mkVerbum sehen (Predef.tk 1 sieht) sieh gesehen) ** {lock_V = <>} ; + vReg = \s -> mkVerbSimple (regVerb s) ** {lock_V = <>} ; + vSein = verbSein ** {lock_V = <>} ; + vHaben = verbHaben ** {lock_V = <>} ; + vPart = \sehen, sieht, sieh, gesehen, aus -> + mkVerb (mkVerbum sehen sieht sieh gesehen) aus ** {lock_V = <>} ; + vPartReg = \sehen, aus -> mkVerb (regVerb sehen) aus ** {lock_V = <>} ; + + mkTV v p c = mkTransVerb v p c ** {lock_TV = <>} ; + tvReg = \hören, zu, dat -> mkTV (vReg hören) zu dat ; + tvDir = \v -> mkTV v [] accusative ; + tvDirReg = \v -> tvReg v [] accusative ; + mkV3 v s c t d = mkDitransVerb v s c t d ** {lock_V3 = <>} ; + + mkAdV a = ss a ** {lock_AdV = <>} ; + mkPP x y z = prepPhrase x y z ** {lock_AdV = <>}; + mkAdA a = ss a ** {lock_AdA = <>} ; + mkAdS a = ss a ** {lock_AdS = <>} ; +} ; diff --git a/lib/resource-0.6/german/StructuralGer.gf b/lib/resource-0.6/german/StructuralGer.gf new file mode 100644 index 000000000..fbde504ba --- /dev/null +++ b/lib/resource-0.6/german/StructuralGer.gf @@ -0,0 +1,105 @@ +--1 The Top-Level German Resource Grammar +-- +-- Aarne Ranta 2002 -- 2003 +-- +-- This is the German concrete syntax of the multilingual resource +-- grammar. Most of the work is done in the file $syntax.Deu.gf$. +-- However, for the purpose of documentation, we make here explicit the +-- linearization types of each category, so that their structures and +-- dependencies can be seen. +-- Another substantial part are the linearization rules of some +-- structural words. +-- +-- The users of the resource grammar should not look at this file for the +-- linearization rules, which are in fact hidden in the document version. +-- They should use $resource.Abs.gf$ to access the syntactic rules. +-- This file can be consulted in those, hopefully rare, occasions in which +-- one has to know how the syntactic categories are +-- implemented. The parameter types are defined in $Types.gf$. + +concrete StructuralGer of Structural = CombinationsGer ** open Prelude, SyntaxGer in { + +lin + INP = pronNounPhrase pronIch ; + ThouNP = pronNounPhrase pronDu ; + HeNP = pronNounPhrase pronEr ; + SheNP = pronNounPhrase pronSie ; + WeNP n = pronNounPhrase (pronWithNum pronWir n) ; + YeNP n = pronNounPhrase (pronWithNum pronIhr n) ; + TheyNP = pronNounPhrase pronSiePl ; + + YouNP = pronNounPhrase pronSSie ; + + ItNP = pronNounPhrase pronEs ; + ThisNP = nameNounPhrase {s = dieserDet.s ! Neut} ; --- + ThatNP = nameNounPhrase {s = jenerDet.s ! Neut} ; --- + + EveryDet = jederDet ; + AllDet = allesDet ; + AllsDet = alleDet ; + WhichDet = welcherDet ; + WhichsDet = welcheDet ; + MostDet = meistDet ; + + HowIAdv = ss "wie" ; + WhenIAdv = ss "wann" ; + WhereIAdv = ss "war" ; + WhyIAdv = ss "warum" ; + + AndConj = ss "und" ** {n = Pl} ; + OrConj = ss "oder" ** {n = Sg} ; + BothAnd = sd2 "sowohl" ["als auch"] ** {n = Pl} ; + EitherOr = sd2 "entweder" "oder" ** {n = Sg} ; + NeitherNor = sd2 "weder" "noch" ** {n = Sg} ; + IfSubj = ss "wenn" ; + WhenSubj = ss "wenn" ; + + PhrYes = ss ["Ja ."] ; + PhrNo = ss ["Nein ."] ; + + VeryAdv = ss "sehr" ; + TooAdv = ss "zu" ; + OtherwiseAdv = ss "sonst" ; + ThereforeAdv = ss "deshalb" ; + + + + CanVV = + mkVerbSimple (verbSehen "können" "kann" "gekonnt") ** {isAux = True} ; --- + CanKnowVV = + mkVerbSimple (verbSehen "können" "kann" "gekonnt") ** {isAux = True} ; --- + MustVV = + mkVerbSimple (verbSehen "müssen" "muss" "gemusst") ** {isAux = True} ; --- + WantVV = + mkVerbSimple (verbSehen "wollen" "will" "gewollt") ** {isAux = True} ; --- + + + EverywhereNP = ss "überall" ; + SomewhereNP = ss "irgendwo" ; + NowhereNP = ss "nirgends" ; + + AlthoughSubj = ss "obwohl" ; + + AlmostAdv = ss "fast" ; + QuiteAdv = ss "ziemlich" ; + + InPrep = mkPrep "in" Dat ; + OnPrep = mkPrep "auf" Dat ; + ToPrep = mkPrep "nach" Dat ; + ThroughPrep = mkPrep "durch" Acc ; + AbovePrep = mkPrep "über" Dat ; + UnderPrep = mkPrep "unter" Dat ; + InFrontPrep = mkPrep "vor" Dat ; + BehindPrep = mkPrep "hinter" Dat ; + BetweenPrep = mkPrep "zwischen" Dat ; + FromPrep = mkPrep "aus" Dat ; + BeforePrep = mkPrep "vor" Dat ; + DuringPrep = mkPrep "während" Gen ; + AfterPrep = mkPrep "nach" Dat ; + WithPrep = mkPrep "mit" Dat ; + WithoutPrep = mkPrep "ohne" Acc ; + ByMeansPrep = mkPrep "mit" Dat ; + PartPrep = mkPrep "von" Dat ; + AgentPrep = mkPrep "durch" Acc ; + +} ; diff --git a/lib/resource-0.6/german/SyntaxGer.gf b/lib/resource-0.6/german/SyntaxGer.gf new file mode 100644 index 000000000..02c8f93d2 --- /dev/null +++ b/lib/resource-0.6/german/SyntaxGer.gf @@ -0,0 +1,1033 @@ +--1 A Small German Resource Syntax +-- +-- Aarne Ranta 2002 +-- +-- This resource grammar contains definitions needed to construct +-- indicative, interrogative, and imperative sentences in German. +-- +-- The following modules are presupposed: + +resource SyntaxGer = MorphoGer ** open Prelude, (CO = Coordination) in { + +--2 Common Nouns +-- +-- Simple common nouns are defined as the type $CommNoun$ in $morpho.Deu.gf$. + +--3 Common noun phrases + +-- The need for this more complex type comes from the variation in the way in +-- which a modifying adjective is inflected after different determiners. +-- We use the $Adjf$ parameter for this ($Strong$/$Weak$). + +oper + + CommNounPhrase : Type = {s : Adjf => Number => Case => Str ; g : Gender} ; + + noun2CommNounPhrase : CommNoun -> CommNounPhrase = \haus -> + {s = \\_ => haus.s ; g = haus.g} ; + + n2n = noun2CommNounPhrase ; + + +--2 Noun phrases +-- +-- The worst case is pronouns, which have inflection in the possessive +-- forms. Other noun phrases express all possessive forms with the genitive case. +-- The parameter $pro$ tells if the $NP$ is a pronoun, which is needed in e.g. +-- genitive constructions. + + NounPhrase : Type = { + s : NPForm => Str ; + n : Number ; + p : Person ; + pro : Bool + } ; + + pronNounPhrase : ProPN -> NounPhrase = \ich -> + ich ** {pro = True} ; + + caseNP : NPForm -> Case = \np -> case np of { + NPCase c => c ; + NPPoss _ _ => Gen + } ; + + normalNounPhrase : (Case => Str) -> Number -> NounPhrase = \cs,n -> + {s = \\c => cs ! caseNP c ; + n = n ; + p = P3 ; -- third person + pro = False -- not a pronoun + } ; + +-- Proper names are a simple kind of noun phrases. They can usually +-- be constructed from strings in a regular way. + + ProperName : Type = {s : Case => Str} ; + + nameNounPhrase : ProperName -> NounPhrase = \john -> + {s = \\np => john.s ! caseNP np ; n = Sg ; p = P3 ; pro = False} ; + + mkProperName : Str -> ProperName = \horst -> + {s = table {Gen => horst + "s" ; _ => horst}} ; + +-- Numerals can be used as determiners or, more generally, as modifiers +-- of ones. They are not inflected, since we only consider numerals above 1. + + Numeral : Type = {s : Str} ; + + pronWithNum : ProPN -> Numeral -> ProPN = \wir,acht -> + {s = \\c => wir.s ! c ++ acht.s ; + n = wir.n ; + p = wir.p + } ; + + noNum : Numeral = {s = []} ; + + +--2 Mass nouns +-- +-- Mass nouns are morphologically similar to nouns, but they have one special +-- rule of noun phrase formation, using the bare singular (in German). +-- Example: "Bier ist gut". +-- They can also be coerced to common nouns: "ein Mexikanisches Bier". + + MassNounPhrase : Type = CommNounPhrase ; + + massNounPhrase : MassNounPhrase -> NounPhrase = \bier -> { + s = \\c => let {nc = caseNP c} in + bier.s ! adjfCas Strong nc ! Sg ! nc ; + p = P3 ; + n = Sg ; + pro = False + } ; + + massCommNoun : MassNounPhrase -> CommNounPhrase = \x -> x ; + + +--2 Determiners +-- +-- Determiners are inflected according to the nouns they determine. +-- The determiner determines the number and adjectival form from the determiner. + + Determiner : Type = {s : Gender => Case => Str ; n : Number ; a : Adjf} ; + + detNounPhrase : Determiner -> CommNounPhrase -> NounPhrase = \ein, mann -> { + s = \\c => let {nc = caseNP c} in + ein.s ! mann.g ! nc ++ mann.s ! adjfCas ein.a nc ! ein.n ! nc ; + p = P3 ; + n = ein.n ; + pro = False + } ; + + +-- The adjectival form after a determiner depends both on the inferent form +-- and on the case ("ein alter Mann" but "einem alten Mann"). + + adjfCas : Adjf -> Case -> Adjf = \a,c -> case of { + => Strong ; + => Strong ; + _ => Weak + } ; + +-- The following macros are sufficient to define most determiners, +-- as shown by the examples that follow. + + DetSg = Gender => Case => Str ; + DetPl = Case => Str ; + + mkDeterminerSg : DetSg -> Adjf -> Determiner = \ein, a -> + {s = ein ; n = Sg ; a = a} ; + + mkDeterminerPl : DetPl -> Adjf -> Determiner = \x,y -> + mkDeterminerNum noNum x y ; + + mkDeterminerNum : Numeral -> DetPl -> Adjf -> Determiner = \nu,alle,a -> + {s = \\_,c => alle ! c ++ nu.s ; n = Pl ; a = a} ; + + detLikeAdj : Str -> Determiner = \jed -> mkDeterminerSg + (\\g,c => (adjReg jed).s ! AMod Strong (GSg g) c) Weak ; + + jederDet = detLikeAdj "jed" ; + dieserDet = detLikeAdj "dies" ; + jenerDet = detLikeAdj "jen" ; + allesDet = detLikeAdj "all" ; + alleDet : Numeral -> Determiner = \n -> + mkDeterminerNum n (caselist "alle" "alle" "allen" "aller") Weak ; + einDet = mkDeterminerSg artIndef Strong ; + derDet = mkDeterminerSg (table {g => artDef ! GSg g}) Weak ; + dieDet : Numeral -> Determiner = \nu -> + mkDeterminerNum nu (artDef ! GPl) Weak ; + + meistDet = mkDeterminerPl (table {c => artDef ! GPl ! c ++ "meisten"}) Weak ; + welcherDet = detLikeAdj "welch" ; + welcheDet : Numeral -> Determiner = \n -> + mkDeterminerNum n (caselist "welche" "welche" "welchen" "welcher") Weak ; + +-- Choose "welcher"/"welche" + + welchDet : Number -> Determiner = \n -> + case n of {Sg => welcherDet ; Pl => welcheDet noNum} ; + +-- Genitives of noun phrases can be used like determiners, to build noun phrases. +-- The number argument makes the difference between "mein Haus" - "meine Häuser". +-- +-- If the 'owner' is a pronoun, only one form is available "mein Haus". +-- In other cases, two variants are available: "Johanns Haus" / "das Haus Johanns". + + npGenDet : Number -> Numeral -> NounPhrase -> CommNounPhrase -> NounPhrase = + \n,nu,haus,Wein -> + let { + hauses : Case => Str = \\c => haus.s ! NPPoss (gNumber Wein.g n) c ; + wein : NPForm => Str = \\c => nu.s ++ Wein.s ! Strong ! n ! caseNP c ; + derwein : NPForm => Str = (defNounPhraseNum nu n Wein).s + } + in + {s = \\c => variants { + hauses ! caseNP c ++ wein ! c ; + if_then_else Str haus.pro + nonExist + (derwein ! c ++ hauses ! Nom) -- the case does not matter + } ; + p = P3 ; + n = n ; + pro = False + } ; + +-- *Bare plural noun phrases* like "Männer", "gute Häuser", are built without a +-- determiner word. + + plurDet : CommNounPhrase -> NounPhrase = \cn -> + normalNounPhrase (cn.s ! Strong ! Pl) Pl ; + + plurDetNum : Numeral -> CommNounPhrase -> NounPhrase = \nu,cn -> + normalNounPhrase (\\c => nu.s ++ cn.s ! Strong ! Pl ! c) Pl ; + +-- Macros for indef/def Sg/Pl noun phrases are needed in many places even +-- if they might not be constituents. + + indefNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n,haus -> case n of { + Sg => detNounPhrase einDet haus ; + Pl => plurDet haus + } ; + + defNounPhraseNum : Numeral -> Number -> CommNounPhrase -> NounPhrase = + \nu,n,haus -> case n of { + Sg => detNounPhrase derDet haus ; + Pl => detNounPhrase (dieDet nu) haus + } ; + + defNounPhrase : Number -> CommNounPhrase -> NounPhrase = + defNounPhraseNum noNum ; + + indefNoun : Number -> CommNounPhrase -> Str = \n, mann -> case n of { + Sg => (detNounPhrase einDet mann).s ! NPCase Nom ; + Pl => (plurDet mann).s ! NPCase Nom + } ; + +-- Constructions like "die Idee, dass zwei gerade ist" are formed at the +-- first place as common nouns, so that one can also have "ein Vorschlag, dass...". + + nounThatSentence : CommNounPhrase -> Sentence -> CommNounPhrase = \idee,x -> + {s = \\a,n,c => idee.s ! a! n ! c ++ [", dass"] ++ x.s ! Sub ; + g = idee.g + } ; + +--2 Adjectives +-- +-- Adjectival phrases have a parameter $p$ telling if postposition is +-- allowed (complex APs). + + AdjPhrase : Type = Adjective ** {p : Bool} ; + + adj2adjPhrase : Adjective -> AdjPhrase = \ny -> ny ** {p = False} ; + +--3 Comparison adjectives +-- +-- The type is defined in $types.Deu.gf$. + + AdjDegr : Type = AdjComp ; + +-- Each of the comparison forms has a characteristic use: +-- +-- Positive forms are used alone, as adjectival phrases ("jung"). + + positAdjPhrase : AdjDegr -> AdjPhrase = \jung -> + {s = jung.s ! Pos ; p = False} ; + +-- Comparative forms are used with an object of comparison, as +-- adjectival phrases ("besser als Rolf"). + + comparAdjPhrase : AdjDegr -> NounPhrase -> AdjPhrase = \besser,rolf -> + {s = \\a => besser.s ! Comp ! a ++ "als" ++ rolf.s ! NPCase Nom ; + p = True + } ; + +-- Superlative forms are used with a common noun, picking out the +-- maximal representative of a domain ("der Jüngste Mann"). + + superlNounPhrase : AdjDegr -> CommNounPhrase -> NounPhrase = \best,mann -> + let {gen = mann.g} in + {s = \\c => let {nc = caseNP c} in + artDef ! gNumber gen Sg ! nc ++ + best.s ! Sup ! aMod Weak gen Sg nc ++ + mann.s ! Weak ! Sg ! nc ; + p = P3 ; + n = Sg ; + pro = False + } ; + +--3 Two-place adjectives +-- +-- A two-place adjective is an adjective with a preposition used before +-- the complement, and the complement case. + + AdjCompl = Adjective ** {s2 : Preposition ; c : Case} ; + + complAdj : AdjCompl -> NounPhrase -> AdjPhrase = \verwandt,dich -> + {s = \\a => + bothWays (verwandt.s ! a) (verwandt.s2 ++ dich.s ! NPCase verwandt.c) ; + p = True + } ; + +--3 Modification of common nouns +-- +-- The two main functions of adjective are in predication ("Johann ist jung") +-- and in modification ("ein junger Mann"). Predication will be defined +-- later, in the chapter on verbs. +-- +-- Modification must pay attention to pre- and post-noun +-- adjectives: "gutes Haus"; "besseres als X haus" / "haus besseres als X" + + modCommNounPhrase : AdjPhrase -> CommNounPhrase -> CommNounPhrase = \gut,haus -> + {s = \\a,n,c => let { + gutes = gut.s ! aMod a haus.g n c ; + Haus = haus.s ! a ! n ! c + } in + if_then_else Str gut.p (bothWays gutes Haus) (gutes ++ Haus) ; + g = haus.g} ; + +--2 Function expressions + +-- A function expression is a common noun together with the +-- preposition prefixed to its argument ("Mutter von x"). +-- The type is analogous to two-place adjectives and transitive verbs. + + Function = CommNounPhrase ** {s2 : Preposition ; c : Case} ; + +-- The application of a function gives, in the first place, a common noun: +-- "Mutter/Mütter von Johann". From this, other rules of the resource grammar +-- give noun phrases, such as "die Mutter von Johann", "die Mütter von Johann", +-- "die Mütter von Johann und Maria", and "die Mutter von Johann und Maria" (the +-- latter two corresponding to distributive and collective functions, +-- respectively). Semantics will eventually tell when each +-- of the readings is meaningful. + + appFunComm : Function -> NounPhrase -> CommNounPhrase = \mutter,uwe -> + {s = \\a,n,c => mutter.s ! a ! n ! c ++ mutter.s2 ++ uwe.s ! NPCase mutter.c ; + g = mutter.g + } ; + +-- It is possible to use a function word as a common noun; the semantics is +-- often existential or indexical. + + funAsCommNounPhrase : Function -> CommNounPhrase = \x -> x ; + +-- The following is an aggregate corresponding to the original function application +-- producing "Johanns Mutter" and "die Mutter von Johann". It does not appear in the +-- resource grammar API any longer. + + appFun : Bool -> Function -> NounPhrase -> NounPhrase = \coll, mutter, uwe -> + let {n = uwe.n ; g = mutter.g ; nf = if_then_else Number coll Sg n} in + variants { + defNounPhrase nf (appFunComm mutter uwe) ; + npGenDet nf noNum uwe mutter + } ; + +-- The commonest cases are functions with "von" and functions with Genitive. + + mkFunC : CommNounPhrase -> Preposition -> Case -> Function = \f,p,c -> + f ** {s2 = p ; c = c} ; + + funVonC : CommNounPhrase -> Function = \wert -> + mkFunC wert "von" Dat ; + + funGenC : CommNounPhrase -> Function = \wert -> + mkFunC wert [] Gen ; + +-- Two-place functions add one argument place. + + Function2 = Function ** {s3 : Preposition ; c2 : Case} ; + +-- There application starts by filling the first place. + + appFun2 : Function2 -> NounPhrase -> Function = \flug, paris -> + {s = \\a,n,c => flug.s ! a ! n ! c ++ flug.s2 ++ paris.s ! NPCase flug.c ; + g = flug.g ; + s2 = flug.s3 ; + c = flug.c2 + } ; + + +--2 Verbs +-- +--3 Verb phrases +-- +-- Verb phrases are discontinuous: the parts of a verb phrase are +-- (s) an inflected verb, +-- (s3) negation+complement+particle, and (s4) sentential adverbial. +-- This discontinuity is needed in sentence formation +-- to account for word order variations. + + VerbPhrase = Verb ** {s3 : Number => Str ; s4 : Str} ; + VerbGroup = + {s : VForm => Str ; s2 : Str ; s3 : Bool => Number => Str ; s4 : Str} ; + + predVerbGroup : Bool -> VerbGroup -> VerbPhrase = \b,vg -> { + s = vg.s ; + s2 = vg.s2 ; + s3 = vg.s3 ! b ; + s4 = vg.s4 + } ; + +-- A simple verb can be made into a verb phrase with an empty complement. +-- There are two versions, depending on if we want to negate the verb. +-- N.B. negation is *not* a function applicable to a verb phrase, since +-- double negations with "nicht" are not grammatical. + + predVerb : Verb -> VerbGroup = \aussehen -> + aussehen ** { + s3 = \\b,_ => negation b ; + s4 = [] + } ; + + negation : Bool -> Str = \b -> if_then_else Str b [] "nicht" ; + +-- Verb phrases can also be formed from adjectives ("ist gut"), +-- common nouns ("ist ein Mann"), and noun phrases ("ist der jüngste Mann"). +-- The third rule is overgenerating: "ist jeder Mann" has to be ruled out +-- on semantic grounds. + + predAdjective : Adjective -> VerbGroup = \gut -> + verbSein ** { + s3 = \\b,_ => negation b ++ gut.s ! APred ; + s4 = [] + } ; + + predCommNoun : CommNounPhrase -> VerbGroup = \man -> + verbSein ** { + s3 = \\b,n => negation b ++ indefNoun n man ; + s4 = [] + } ; + + predNounPhrase : NounPhrase -> VerbGroup = \dermann -> + verbSein ** { + s3 = \\b,n => negation b ++ dermann.s ! NPCase Nom ; + s4 = [] + } ; + + predAdverb : Adverb -> VerbGroup = \hier -> + verbSein ** { + s3 = \\b,_ => negation b ++ hier.s ; + s4 = [] + } ; + +--3 Transitive verbs +-- +-- Transitive verbs are verbs with a preposition for the complement, +-- in analogy with two-place adjectives and functions. +-- One might prefer to use the term "2-place verb", since +-- "transitive" traditionally means that the inherent preposition is empty. +-- Such a verb is one with a *direct object* - which may still be accusative, +-- dative, or genitive. + + TransVerb = Verb ** {s3 : Preposition ; c : Case} ; + + mkTransVerb : Verb -> Preposition -> Case -> TransVerb = + \v,p,c -> v ** {s3 = p ; c = c} ; + + transDir : Verb -> TransVerb = \v -> + mkTransVerb v [] Acc ; + +-- The rule for using transitive verbs is the complementization rule: + + complTransVerb : TransVerb -> NounPhrase -> VerbGroup = \warten,dich -> + let { + aufdich = warten.s3 ++ dich.s ! NPCase warten.c + } in + {s = warten.s ; + s2 = warten.s2 ; + s3 = \\b,_ => bothWays aufdich (negation b) ; + s4 = [] + } ; + +-- Transitive verbs with accusative objects can be used passively. +-- The function does not check that the verb is transitive. +-- Therefore, the function can also be used for "es wird gelaufen", etc. + + passVerb : Verb -> VerbGroup = \lieben -> + {s = verbumWerden ; + s2 = [] ; + s3 = \\b,_ => negation b ++ lieben.s2 ++ lieben.s ! VPart APred ; + s4 = [] + } ; + +-- Transitive verb can be used elliptically as a verb. The semantics +-- is left to applications. The definition is trivial, due to record +-- subtyping. + + transAsVerb : TransVerb -> Verb = \lieben -> + lieben ; + +-- *Ditransitive verbs* are verbs with three argument places. +-- We treat so far only the rule in which the ditransitive +-- verb takes both complements to form a verb phrase. + + DitransVerb = TransVerb ** {s4 : Preposition ; c2 : Case} ; + + mkDitransVerb : + Verb -> Preposition -> Case -> Preposition -> Case -> DitransVerb = + \v,p1,c1,p2,c2 -> v ** {s3 = p1 ; c = c1 ; s4 = p2 ; c2 = c2} ; + + complDitransVerb : + DitransVerb -> NounPhrase -> NounPhrase -> VerbGroup = \geben,dir,bier -> + let { + zudir = geben.s3 ++ dir.s ! NPCase geben.c ; + dasbier = geben.s4 ++ bier.s ! NPCase geben.c2 + } in + {s = geben.s ; + s2 = geben.s2 ; + s3 = \\b,_ => let nicht = negation b in + variants { + nicht ++ zudir ++ dasbier ; + zudir ++ nicht ++ dasbier ; + zudir ++ dasbier ++ nicht + } ; + s4 = [] + } ; + + +--2 Adverbials +-- +-- Adverbials are not inflected (we ignore comparison, and treat +-- compared adverbials as separate expressions; this could be done another way). + + Adverb : Type = SS ; + + mkAdverb : Str -> Adverb = ss ; + +-- This rule is the one that shows that we cannot glue the particle in the +-- $s3$ field. + + adVerbPhrase : VerbPhrase -> Adverb -> VerbPhrase = \spielt, gut -> + {s = spielt.s ; + s2 = spielt.s2 ; + s3 = \\n => spielt.s3 ! n ++ gut.s ; + s4 = spielt.s4 + } ; + + advAdjPhrase : Adverb -> AdjPhrase -> AdjPhrase = \sehr, gut -> + {s = \\a => sehr.s ++ gut.s ! a ; + p = gut.p + } ; + +-- Adverbials are typically generated by prefixing prepositions, of which +-- the case has to be specified. + + Prepos = {s : Str ; c : Case} ; + + prepPhrase : Prepos -> NounPhrase -> Adverb = \auf,ihm -> + ss (auf.s ++ ihm.s ! NPCase auf.c) ; + + mkPrep : Str -> Case -> Prepos = \s,c -> + {s = s ; c = c} ; + +-- This is a source of the "Mann mit einem Teleskop" ambiguity, and may produce +-- strange things, like "Autos immer" (while "Autos heute" is OK). +-- Semantics will have to make finer distinctions among adverbials. + + advCommNounPhrase : CommNounPhrase -> Adverb -> CommNounPhrase = \haus,heute -> + {s = \\a, n, c => haus.s ! a ! n ! c ++ heute.s ; + g = haus.g} ; + + + +--2 Sentences +-- +-- Sentences depend on a *word order parameter* selecting between main clause, +-- inverted, and subordinate clause. + + Sentence : Type = SS1 Order ; + +-- This is the traditional $S -> NP VP$ rule. It takes care of both +-- word order and agreement. + + predVerbPhrase : NounPhrase -> VerbPhrase -> Sentence = + \Ich,LiebeDichNichtAus -> + let { + ich = Ich.s ! NPCase Nom ; + liebe = LiebeDichNichtAus.s ! VInd Ich.n Ich.p ; + aus = LiebeDichNichtAus.s2 ; + dichnichtgut = LiebeDichNichtAus.s3 ! Ich.n ; + wennesregnet = LiebeDichNichtAus.s4 + } in + {s = table { + Main => ich ++ liebe ++ dichnichtgut ++ aus ++ wennesregnet ; + Inv => liebe ++ ich ++ dichnichtgut ++ aus ++ wennesregnet ; + Sub => ich ++ dichnichtgut ++ aus ++ liebe ++ wennesregnet + } + } ; + +--3 Sentence-complement verbs +-- +-- Sentence-complement verbs take sentences as complements. + + SentenceVerb : Type = Verb ; + + complSentVerb : SentenceVerb -> Sentence -> VerbGroup = \sage,duisst -> + sage ** { + s3 = \\b,_ => negation b ; + s4 = "," ++ "dass" ++ duisst.s ! Sub + } ; + +--3 Verb-complement verbs +-- +-- Verb-complement verbs take verb phrases as complements. +-- They can be auxiliaries ("können", "müssen") or ordinary verbs +-- ("versuchen"); this distinction cannot be done in the multilingual +-- API. The distinction shows in whether the infinitive particle "zu" is needed. + + VerbVerb : Type = Verb ** {isAux : Bool} ; + + complVerbVerb : VerbVerb -> VerbGroup -> VerbGroup = \will, essen -> + will ** { + s3 = \\b,_ => negation b ++ + essen.s2 ++ zuInfinitive will.isAux ++ essen.s ! VInf ; + s4 = essen.s4 + } ; + + zuInfinitive : Bool -> Str = \isAux -> + if_then_Str isAux [] "zu" ; + +--2 Sentences missing noun phrases +-- +-- This is one instance of Gazdar's *slash categories*, corresponding to his +-- $S/NP$. +-- We cannot have - nor would we want to have - a productive slash-category former. +-- Perhaps a handful more will be needed. +-- +-- Notice that the slash category has the same relation to sentences as +-- transitive verbs have to verbs: it's like a *sentence taking a complement*. + + SentenceSlashNounPhrase : Type = Sentence ** {s2 : Preposition ; c : Case} ; + + slashTransVerb : Bool -> NounPhrase -> TransVerb -> SentenceSlashNounPhrase = + \b, Ich, sehen -> + let { + ich = Ich.s ! NPCase Nom ; + sehe = sehen.s ! VInd Ich.n P3 ; + aus = sehen.s2 ; + nicht = negation b + } in + {s = table { + Main => ich ++ sehe ++ nicht ++ aus ; + Inv => sehe ++ ich ++ nicht ++ aus ; + Sub => ich ++ nicht ++ aus ++ sehe + } ; + s2 = sehen.s3 ; + c = sehen.c + } ; + +--2 Relative pronouns and relative clauses +-- +-- Relative pronouns are inflected in +-- gender, number, and case just like adjectives. + +oper + identRelPron : RelPron = relPron ; + + funRelPron : Function -> RelPron -> RelPron = \wert, der -> + {s = \\gn,c => let {nu = numGenNum gn} in + artDef ! gNumber wert.g nu ! c ++ wert.s ! Weak ! nu ! c ++ + wert.s2 ++ der.s ! gn ! wert.c + } ; + +-- Relative clauses can be formed from both verb phrases ("der schläft") and +-- slash expressions ("den ich sehe", "auf dem ich sitze"). + + RelClause : Type = {s : GenNum => Str} ; + + relVerbPhrase : RelPron -> VerbPhrase -> RelClause = \der, geht -> + {s = \\gn => (predVerbPhrase (normalNounPhrase (der.s ! gn) (numGenNum gn)) + geht + ).s ! Sub + } ; + + relSlash : RelPron -> SentenceSlashNounPhrase -> RelClause = \den, ichSehe -> + {s = \\gn => ichSehe.s2 ++ den.s ! gn ! ichSehe.c ++ ichSehe.s ! Sub + } ; + +-- A 'degenerate' relative clause is the one often used in mathematics, e.g. +-- "Zahl x derart, dass x gerade ist". + + relSuch : Sentence -> RelClause = \A -> + {s = \\_ => "derart" ++ "dass" ++ A.s ! Sub} ; + +-- The main use of relative clauses is to modify common nouns. +-- The result is a common noun, out of which noun phrases can be formed +-- by determiners. A comma is used before the relative clause. + + modRelClause : CommNounPhrase -> RelClause -> CommNounPhrase = \mann,dergeht -> + {s = \\a,n,c => mann.s ! a ! n ! c ++ "," ++ dergeht.s ! gNumber mann.g n ; + g = mann.g + } ; + + +--2 Interrogative pronouns +-- +-- If relative pronouns are adjective-like, interrogative pronouns are +-- noun-phrase-like. We use a simplified type, since we don't need the possessive +-- forms. + + IntPron : Type = ProperName ** {n : Number} ; + +-- In analogy with relative pronouns, we have a rule for applying a function +-- to a relative pronoun to create a new one. + + funIntPron : Function -> IntPron -> IntPron = \wert, wer -> + let {n = wer.n} in + {s = \\c => + artDef ! gNumber wert.g n ! c ++ wert.s ! Weak ! n ! c ++ + wert.s2 ++ wer.s ! wert.c ; + n = n + } ; + +-- There is a variety of simple interrogative pronouns: +-- "welches Haus", "wer", "was". + + nounIntPron : Number -> CommNounPhrase -> IntPron = \n,cn -> + let {np = detNounPhrase (welchDet n) cn} in + {s = \\c => np.s ! NPCase c ; + n = np.n} ; + + intPronWho : Number -> IntPron = \num -> { + s = caselist "wer" "wen" "wem" "weren" ; + n = num + } ; + + intPronWhat : Number -> IntPron = \num -> { + s = caselist "was" "was" nonExist nonExist ; --- + n = num + } ; + + + +--2 Utterances + +-- By utterances we mean whole phrases, such as +-- 'can be used as moves in a language game': indicatives, questions, imperative, +-- and one-word utterances. The rules are far from complete. +-- +-- N.B. we have not included rules for texts, which we find we cannot say much +-- about on this level. In semantically rich GF grammars, texts, dialogues, etc, +-- will of course play an important role as categories not reducible to utterances. +-- An example is proof texts, whose semantics show a dependence between premises +-- and conclusions. Another example is intersentential anaphora. + + Utterance = SS ; + + indicUtt : Sentence -> Utterance = \x -> ss (x.s ! Main ++ ".") ; + interrogUtt : Question -> Utterance = \x -> ss (x.s ! DirQ ++ "?") ; + + +--2 Questions +-- +-- Questions are either direct ("bist du müde") or indirect +-- ("ob du müde bist"). + +param + QuestForm = DirQ | IndirQ ; + +oper + Question = SS1 QuestForm ; + +--3 Yes-no questions +-- +-- Yes-no questions are used both independently ("bist du müde") +-- and after interrogative adverbials ("warum bist du müde"). +-- It is economical to handle with these two cases by the one +-- rule, $questVerbPhrase'$. The only difference is if "ob" appears +-- in the indirect form. + + questVerbPhrase : NounPhrase -> VerbPhrase -> Question = + questVerbPhrase' False ; + + questVerbPhrase' : Bool -> NounPhrase -> VerbPhrase -> Question = + \adv, du,gehst -> + let {dugehst = (predVerbPhrase du gehst).s} in + {s = table { + DirQ => dugehst ! Inv ; + IndirQ => (if_then_else Str adv [] "ob") ++ dugehst ! Sub + } + } ; + + +--3 Wh-questions +-- +-- Wh-questions are of two kinds: ones that are like $NP - VP$ sentences, +-- others that are line $S/NP - NP$ sentences. + + intVerbPhrase : IntPron -> VerbPhrase -> Question = \Wer,geht -> + let {wer : NounPhrase = normalNounPhrase Wer.s Wer.n ; + wergeht : Sentence = predVerbPhrase wer geht + } in + {s = table { + DirQ => wergeht.s ! Main ; + IndirQ => wergeht.s ! Sub + } + } ; + + intSlash : IntPron -> SentenceSlashNounPhrase -> Question = \wer, ichSehe -> + let {zuwen = ichSehe.s2 ++ wer.s ! ichSehe.c} in + {s = table { + DirQ => zuwen ++ ichSehe.s ! Inv ; + IndirQ => zuwen ++ ichSehe.s ! Sub + } + } ; + + +--3 Interrogative adverbials +-- +-- These adverbials will be defined in the lexicon: they include +-- "wann", "war", "wie", "warum", etc, which are all invariant one-word +-- expressions. In addition, they can be formed by adding prepositions +-- to interrogative pronouns, in the same way as adverbials are formed +-- from noun phrases. + + IntAdverb = SS ; + + prepIntAdverb : Case -> Preposition -> IntPron -> IntAdverb =\ c,auf,wem -> + ss (auf ++ wem.s ! c) ; + +-- A question adverbial can be applied to anything, and whether this makes +-- sense is a semantic question. + + questAdverbial : IntAdverb -> NounPhrase -> VerbPhrase -> Question = + \wie, du, tust -> + {s = \\q => wie.s ++ (questVerbPhrase du tust).s ! q} ; + + +--2 Imperatives +-- +-- We only consider second-person imperatives. No polite "Sie" form so far. + + Imperative = SS1 Number ; + + imperVerbPhrase : VerbPhrase -> Imperative = \komm -> + {s = \\n => komm.s ! VImp n ++ komm.s3 ! n ++ komm.s2 ++ komm.s4} ; + + imperUtterance : Number -> Imperative -> Utterance = \n,I -> + ss (I.s ! n ++ "!") ; + +--2 Sentence adverbials +-- +-- This class covers adverbials such as "sonst", "deshalb", which are prefixed +-- to a sentence to form a phrase; the sentence gets inverted word order. + + advSentence : Adverb -> Sentence -> Utterance = \sonst,ist1gerade -> + ss (sonst.s ++ ist1gerade.s ! Inv ++ ".") ; + +--2 Coordination +-- +-- Coordination is to some extent orthogonal to the rest of syntax, and +-- has been treated in a generic way in the module $CO$ in the file +-- $coordination.gf$. The overall structure is independent of category, +-- but there can be differences in parameter dependencies. +-- +--3 Conjunctions +-- +-- Coordinated phrases are built by using conjunctions, which are either +-- simple ("und", "oder") or distributed ("sowohl - als auch", "entweder - oder"). +-- +-- The conjunction has an inherent number, which is used when conjoining +-- noun phrases: "John und Mary sind..." vs. "John oder Mary ist..."; in the +-- case of "oder", the result is however plural if any of the disjuncts is. + + Conjunction = CO.Conjunction ** {n : Number} ; + ConjunctionDistr = CO.ConjunctionDistr ** {n : Number} ; + + +--3 Coordinating sentences +-- +-- We need a category of lists of sentences. It is a discontinuous +-- category, the parts corresponding to 'init' and 'last' segments +-- (rather than 'head' and 'tail', because we have to keep track of the slot between +-- the last two elements of the list). A list has at least two elements. + + ListSentence : Type = {s1,s2 : Order => Str} ; + + twoSentence : (_,_ : Sentence) -> ListSentence = + CO.twoTable Order ; + + consSentence : ListSentence -> Sentence -> ListSentence = + CO.consTable Order CO.comma ; + +-- To coordinate a list of sentences by a simple conjunction, we place +-- it between the last two elements; commas are put in the other slots, +-- e.g. "du rauchst, er trinkt und ich esse". + + conjunctSentence : Conjunction -> ListSentence -> Sentence = + CO.conjunctTable Order ; + +-- To coordinate a list of sentences by a distributed conjunction, we place +-- the first part (e.g. "entweder") in front of the first element, the second +-- part ("oder") between the last two elements, and commas in the other slots. +-- For sentences this is really not used. + + conjunctDistrSentence : ConjunctionDistr -> ListSentence -> Sentence = + CO.conjunctDistrTable Order ; + +--3 Coordinating adjective phrases +-- +-- The structure is the same as for sentences. The result is a prefix adjective +-- if and only if all elements are prefix. + + ListAdjPhrase : Type = + {s1,s2 : AForm => Str ; p : Bool} ; + + twoAdjPhrase : (_,_ : AdjPhrase) -> ListAdjPhrase = \x,y -> + CO.twoTable AForm x y ** {p = andB x.p y.p} ; + consAdjPhrase : ListAdjPhrase -> AdjPhrase -> ListAdjPhrase = \xs,x -> + CO.consTable AForm CO.comma xs x ** {p = andB xs.p x.p} ; + + conjunctAdjPhrase : Conjunction -> ListAdjPhrase -> AdjPhrase = \c,xs -> + CO.conjunctTable AForm c xs ** {p = xs.p} ; + + conjunctDistrAdjPhrase : ConjunctionDistr -> ListAdjPhrase -> AdjPhrase = \c,xs -> + CO.conjunctDistrTable AForm c xs ** {p = xs.p} ; + + + +--3 Coordinating noun phrases +-- +-- The structure is the same as for sentences. The result is either always plural +-- or plural if any of the components is, depending on the conjunction. +-- The result is a pronoun if all components are. + + ListNounPhrase : Type = + {s1,s2 : NPForm => Str ; n : Number ; p : Person ; pro : Bool} ; + + twoNounPhrase : (_,_ : NounPhrase) -> ListNounPhrase = \x,y -> + CO.twoTable NPForm x y ** + {n = conjNumber x.n y.n ; p = conjPerson x.p y.p ; pro = andB x.pro y.pro} ; + + consNounPhrase : ListNounPhrase -> NounPhrase -> ListNounPhrase = \xs,x -> + CO.consTable NPForm CO.comma xs x ** + {n = conjNumber xs.n x.n ; p = conjPerson xs.p x.p ; pro = andB xs.pro x.pro} ; + + conjunctNounPhrase : Conjunction -> ListNounPhrase -> NounPhrase = \c,xs -> + CO.conjunctTable NPForm c xs ** + {n = conjNumber c.n xs.n ; p = xs.p ; pro = xs.pro} ; + + conjunctDistrNounPhrase : ConjunctionDistr -> ListNounPhrase -> NounPhrase = + \c,xs -> + CO.conjunctDistrTable NPForm c xs ** + {n = conjNumber c.n xs.n ; p = xs.p ; pro = xs.pro} ; + +-- We have to define a calculus of numbers of persons. For numbers, +-- it is like the conjunction with $Pl$ corresponding to $False$. + + conjNumber : Number -> Number -> Number = \m,n -> case of { + => Sg ; + _ => Pl + } ; + +-- For persons, we go in the descending order: +-- "ich und dich sind stark", "er oder du bist stark". +-- This is not always quite clear. + + conjPerson : Person -> Person -> Person = \p,q -> case of { + => P3 ; + => P1 ; + <_,P1> => P1 ; + _ => P2 + } ; + + +--2 Subjunction +-- +-- Subjunctions ("wenn", "falls", etc) +-- are a different way to combine sentences than conjunctions. +-- The main clause can be a sentences, an imperatives, or a question, +-- but the subjoined clause must be a sentence. + + Subjunction = SS ; + + subjunctSentence : Subjunction -> Sentence -> Sentence -> Sentence = \if, A, B -> + let {As = A.s ! Sub} in + {s = table { + Main => variants {if.s ++ As ++ "," ++ B.s ! Inv ; + B.s ! Main ++ "," ++ if.s ++ As} ; + o => B.s ! o ++ "," ++ if.s ++ As + } + } ; + + subjunctImperative : Subjunction -> Sentence -> Imperative -> Imperative = + \if, A, B -> + {s = \\n => subjunctVariants if A (B.s ! n)} ; + + subjunctQuestion : Subjunction -> Sentence -> Question -> Question = \if, A, B -> + {s = \\q => subjunctVariants if A (B.s ! q)} ; + +-- There are uniformly two variant word orders, e.g. +-- "wenn du rauchst, werde ish böse" +-- and "ich werde böse, wenn du rauchst". + + subjunctVariants : Subjunction -> Sentence -> Str -> Str = \if,A,B -> + let {As = A.s ! Sub} in + variants {if.s ++ As ++ "," ++ B ; B ++ "," ++ if.s ++ As} ; + +-- Subjunctions can be used for building adverbials, which can modify verb phrases +-- ("ich lache wenn ich gehe und singe wenn ich laufe"). , noun phrases, etc. +-- For reasons of word order, we treat this separately from other adverbials, +-- but this could be remedied by an extra parameter in adverbials. + + subjunctVerbPhrase : VerbPhrase -> Subjunction -> Sentence -> VerbPhrase = + \ruft,wenn,ergeht -> + {s = ruft.s ; + s2 = ruft.s2 ; + s3 = ruft.s3 ; + s4 = ruft.s4 ++ "," ++ wenn.s ++ ergeht.s ! Sub + } ; + +--2 One-word utterances +-- +-- An utterance can consist of one phrase of almost any category, +-- the limiting case being one-word utterances. These +-- utterances are often (but not always) in what can be called the +-- default form of a category, e.g. the nominative. +-- This list is far from exhaustive. + + useNounPhrase : NounPhrase -> Utterance = \john -> + postfixSS "." (defaultNounPhrase john) ; + useCommonNounPhrase : Number -> CommNounPhrase -> Utterance = \n,car -> + useNounPhrase (indefNounPhrase n car) ; + +-- Here are some default forms. + + defaultNounPhrase : NounPhrase -> SS = \john -> + ss (john.s ! NPCase Nom) ; + + defaultQuestion : Question -> SS = \whoareyou -> + ss (whoareyou.s ! DirQ) ; + + defaultSentence : Sentence -> Utterance = \x -> ss (x.s ! Main) ; + +--3 Puzzle +-- +-- Adding some lexicon, we can generate the sentence +-- +-- "der grösste alte Mann ist nicht ein Auto auf die Mutter von dem Männer warten" +-- +-- which looks completely ungrammatical! What you should do to decipher it is +-- put parentheses around "auf die Mutter von dem". + +} ; diff --git a/lib/resource-0.6/german/TestResourceGer.gf b/lib/resource-0.6/german/TestResourceGer.gf new file mode 100644 index 000000000..2b202a550 --- /dev/null +++ b/lib/resource-0.6/german/TestResourceGer.gf @@ -0,0 +1,54 @@ +-- use this path to read the grammar from the same directory +--# -path=.:../abstract:../../prelude + +concrete TestResourceGer of TestResource = StructuralGer ** open SyntaxGer in { + +flags startcat=Phr ; lexer=text ; parser=chart ; unlexer=text ; + +-- a random sample from the lexicon + +lin + Big = adjCompReg3 "gross" "grösser" "grösst"; + Small = adjCompReg "klein" ; + Happy = adjCompReg "glücklich" ; + Old = adjCompReg3 "alt" "älter" "ältest"; + Young = adjCompReg3 "jung" "jünger" "jüngst"; + American = adjReg "Amerikanisch" ; + Finnish = adjReg "Finnisch" ; + Married = adjReg "verheiratet" ** {s2 = "mit" ; c = Dat} ; + Man = declN2u "Mann" "Männer" ; + Woman = declN1 "Frau" ; + Bottle = declN1e "Flasche" ; + Wine = declN2 "Wein" ; + Car = declNs "Auto" ; + House = declN3uS "Haus" "Häuser" ; + Light = declN3 "Licht" ; + Bar = declNs "Bar" ; + Walk = mkVerbSimple (verbLaufen "gehen" "geht" "gegangen") ; + Run = mkVerbSimple (verbLaufen "laufen" "läuft" "gelaufen") ; + Say = mkVerbSimple (regVerb "sagen") ; + Prove = mkVerbSimple (regVerb "beweisen") ; + Send = mkTransVerb (mkVerbSimple (verbLaufen "senden" "sendet" "gesandt")) [] Acc; + Drink = transDir (mkVerbSimple (verbLaufen "trinken" "trinkt" "getrunken")) ; + Love = mkTransVerb (mkVerbSimple (regVerb "lieben")) [] Acc ; + Wait = mkTransVerb (mkVerbSimple (verbWarten "warten")) "auf" Acc ; + Give = mkDitransVerb + (mkVerbSimple (verbLaufen "geben" "gibt" "gegeben")) [] Dat [] Acc ; + Prefer = mkDitransVerb + (mkVerb (verbLaufen "ziehen" "zieht" "gezogen") "vor") [] Acc "vor" Dat ; + Mother = mkFunC (n2n (declN2uF "Mutter" "Mütter")) "von" Dat ; + Uncle = mkFunC (n2n (declN2i "Onkel")) "von" Dat ; + Connection = mkFunC (n2n (declN1 "Verbindung")) "von" Dat ** + {s3 = "nach" ; c2 = Dat} ; + + Always = mkAdverb "immer" ; + Well = mkAdverb "gut" ; + + SwitchOn = mkTransVerb (mkVerb (verbWarten "schalten") "auf") [] Acc ; + SwitchOff = mkTransVerb (mkVerb (verbWarten "schalten") "aus") [] Acc ; + + John = mkProperName "Johann" ; + Mary = mkProperName "Maria" ; + +} ; + diff --git a/lib/resource-0.6/german/TypesGer.gf b/lib/resource-0.6/german/TypesGer.gf new file mode 100644 index 000000000..a3f90c713 --- /dev/null +++ b/lib/resource-0.6/german/TypesGer.gf @@ -0,0 +1,98 @@ +--1 German Word Classes and Morphological Parameters +-- +-- This is a resource module for German morphology, defining the +-- morphological parameters and word classes of German. It is so far only +-- complete w.r.t. the syntax part of the resource grammar. +-- It does not include those parameters that are not needed for +-- analysing individual words: such parameters are defined in syntax modules. +-- + +resource TypesGer = open Prelude in { + +--2 Enumerated parameter types +-- +-- These types are the ones found in school grammars. +-- Their parameter values are atomic. + +param + Number = Sg | Pl ; + Gender = Masc | Fem | Neut ; + Person = P1 | P2 | P3 ; + Case = Nom | Acc | Dat | Gen ; + Adjf = Strong | Weak ; -- the main division in adjective declension + Order = Main | Inv | Sub ; -- word order: direct, indirect, subordinate + +-- For abstraction and API compatibility, we define two synonyms: + +oper + singular = Sg ; + plural = Pl ; + +--2 Word classes and hierarchical parameter types +-- +-- Real parameter types (i.e. ones on which words and phrases depend) +-- are mostly hierarchical. The alternative is cross-products of +-- simple parameters, but this cannot be always used since it overgenerates. +-- + +--3 Common nouns +-- +-- Common nouns are inflected in number and case and they have an inherent gender. + + CommNoun : Type = {s : Number => Case => Str ; g : Gender} ; + +--3 Pronouns +-- +-- Pronouns are an example - the worst-case one of noun phrases, +-- which are properly defined in $syntax.Deu.gf$. +-- Their inflection tables has, in addition to the normal genitive, +-- the possessive forms, which are inflected like determiners. + +param + NPForm = NPCase Case | NPPoss GenNum Case ; + +--3 Adjectives +-- +-- Adjectives are a very complex class, and the full table has as many as +-- 99 different forms. The major division is between the comparison degrees. +-- There is no gender distinction in the plural, +-- and the predicative forms ("X ist Adj") are not inflected. + +param + GenNum = GSg Gender | GPl ; + AForm = APred | AMod Adjf GenNum Case ; + +oper + Adjective : Type = {s : AForm => Str} ; + AdjComp : Type = {s : Degree => AForm => Str} ; + +-- Comparison of adjectives: + +param Degree = Pos | Comp | Sup ; + +--3 Verbs +-- +-- We have a reduced conjugation with only the present tense infinitive, +-- indicative, and imperative forms, and past participles. + +param VForm = VInf | VInd Number Person | VImp Number | VPart AForm ; + +oper Verbum : Type = VForm => Str ; + +-- On the general level, we have to account for composite verbs as well, +-- such as "aus" + "sehen" etc. + + Particle = Str ; + + Verb = {s : Verbum ; s2 : Particle} ; + + +--2 Prepositions +-- +-- We define prepositions simply as strings. Thus we do not capture the +-- contractions "vom", "ins", etc. To define them in GF grammar we would need +-- to introduce a parameter system, which we postpone. + + Preposition = Str ; + +} ; diff --git a/src/GF/UseGrammar/Linear.hs b/src/GF/UseGrammar/Linear.hs index 0bd053803..9459264ea 100644 --- a/src/GF/UseGrammar/Linear.hs +++ b/src/GF/UseGrammar/Linear.hs @@ -19,6 +19,7 @@ import Operations import Zipper import Monad +import List (intersperse) -- Linearization for canonical GF. AR 7/6/2003 @@ -143,7 +144,7 @@ allLinsOfTree gr a e = err (singleton . str) id $ do -- the value is a list of structures arranged as records of tables of terms allLinsAsRec :: CanonGrammar -> Ident -> A.Tree -> Err [[(Label,[([Patt],Term)])]] -allLinsAsRec gr c t = linearizeNoMark gr c t >>= allLinValues +allLinsAsRec gr c t = linearizeNoMark gr c t >>= expandLinTables gr >>= allLinValues -- the value is a list of structures arranged as records of tables of strings -- only taking into account string fields @@ -153,7 +154,8 @@ allLinTables gr c t = do mapM (mapM getS) r' where getS (lab,pss) = liftM (curry id lab) $ mapM gets pss - gets (ps,t) = liftM (curry id ps . concat . map str2strings) $ strsFromTerm t + gets (ps,t) = liftM (curry id ps . cc . map str2strings) $ strsFromTerm t + cc = concat . intersperse ["/"] prLinTable :: [[(Label,[([Patt],[String])])]] -> [String] prLinTable = concatMap prOne . concat where diff --git a/src/Today.hs b/src/Today.hs index 23b09ec65..f636f81fc 100644 --- a/src/Today.hs +++ b/src/Today.hs @@ -1 +1 @@ -module Today where today = "Fri Dec 19 18:43:03 CET 2003" +module Today where today = "Mon Jan 5 11:31:04 CET 2004"