mirror of
https://github.com/GrammaticalFramework/gf-core.git
synced 2026-05-07 02:02:51 -06:00
Founding the newly structured GF2.0 cvs archive.
This commit is contained in:
aarne
52
grammars/resource/german/DatabaseDeu.gf
Normal file
52
grammars/resource/german/DatabaseDeu.gf
Normal file
@@ -0,0 +1,52 @@
|
||||
concrete DatabaseDeu of Database =
|
||||
open Prelude,Syntax,Deutsch,Predication,Paradigms,DatabaseRes in {
|
||||
|
||||
flags lexer=text ; unlexer=text ;
|
||||
|
||||
lincat
|
||||
Phras = SS1 Bool ; -- long or short form
|
||||
Subject = NP ;
|
||||
Noun = CN ;
|
||||
Property = AP ;
|
||||
Comparison = AdjDeg ;
|
||||
Relation = Adj2 ;
|
||||
Feature = Fun ;
|
||||
Value = NP ;
|
||||
Name = ProperName ;
|
||||
|
||||
lin
|
||||
LongForm sent = ss (sent.s ! True ++ "?") ;
|
||||
ShortForm sent = ss (sent.s ! False ++ "?") ;
|
||||
|
||||
WhichAre A B = mkSent (defaultQuestion (IntVP (NounIPMany A) (PosA B)))
|
||||
(defaultNounPhrase (IndefManyNP (ModAdj B A))) ;
|
||||
|
||||
IsIt Q A = mkSentSame (defaultQuestion (QuestVP Q (PosA A))) ;
|
||||
|
||||
MoreThan = ComparAdjP ;
|
||||
TheMost = SuperlNP ;
|
||||
Relatively C _ = PositAdjP C ;
|
||||
|
||||
RelatedTo = ComplAdj ;
|
||||
|
||||
FeatureOf = appFun1 ;
|
||||
ValueOf F V = appFun1 F (UsePN V) ;
|
||||
|
||||
WithProperty A B = ModAdj B A ;
|
||||
|
||||
Individual = nameNounPhrase ;
|
||||
|
||||
AllN = DetNP AllDet ;
|
||||
MostN = DetNP MostDet ;
|
||||
EveryN = DetNP EveryDet ;
|
||||
|
||||
-- only these are language-dependent
|
||||
|
||||
Any = detNounPhrase einDet ;
|
||||
|
||||
IsThere A = mkSentPrel ["gibt es"] (defaultNounPhrase (IndefOneNP A)) ;
|
||||
AreThere A = mkSentPrel ["gibt es"] (defaultNounPhrase (IndefManyNP A)) ;
|
||||
|
||||
WhatIs V = mkSentPrel ["was ist"] (defaultNounPhrase V) ;
|
||||
|
||||
} ;
|
||||
11
grammars/resource/german/DatabaseRes.gf
Normal file
11
grammars/resource/german/DatabaseRes.gf
Normal file
@@ -0,0 +1,11 @@
|
||||
resource DatabaseRes = open Prelude in {
|
||||
oper
|
||||
mkSent : SS -> SS -> SS1 Bool = \long, short ->
|
||||
{s = table {b => if_then_else Str b long.s short.s}} ;
|
||||
|
||||
mkSentPrel : Str -> SS -> SS1 Bool = \prel, matter ->
|
||||
mkSent (ss (prel ++ matter.s)) matter ;
|
||||
|
||||
mkSentSame : SS -> SS1 Bool = \s ->
|
||||
mkSent s s ;
|
||||
} ;
|
||||
1
grammars/resource/german/Deutsch.gf
Normal file
1
grammars/resource/german/Deutsch.gf
Normal file
@@ -0,0 +1 @@
|
||||
resource Deutsch = reuse ResDeu ;
|
||||
23
grammars/resource/german/Logical.gf
Normal file
23
grammars/resource/german/Logical.gf
Normal file
@@ -0,0 +1,23 @@
|
||||
-- Slightly ad hoc and formal negation and connectives.
|
||||
|
||||
resource Logical = Predication ** open Deutsch, Paradigms in {
|
||||
|
||||
oper
|
||||
negS : S -> S ; -- es ist nicht der Fall, dass S
|
||||
univS : CN -> S -> S ; -- für alle CNs gilt es, dass S
|
||||
existS : CN -> S -> S ; -- es gibt ein CN derart, dass S
|
||||
existManyS : CN -> S -> S ; -- es gibt CNs derart, dass S
|
||||
--.
|
||||
|
||||
negS = \A ->
|
||||
PredVP ItNP (NegNP (DefOneNP (CNthatS (UseN (nRaum "Fall" "Fälle")) A))) ;
|
||||
univS = \A,B ->
|
||||
PredVP ItNP (AdvVP (PosVS (mkV "gelten" "gilt" "gelte" "gegolten") B)
|
||||
(mkPP accusative "für" (DetNP AllDet A))) ;
|
||||
existS = \A,B ->
|
||||
PredVP ItNP (PosTV (tvDir (mkV "geben" "gibt" "gib" "gegeben"))
|
||||
(IndefOneNP (ModRC A (RelSuch B)))) ;
|
||||
existManyS = \A,B ->
|
||||
PredVP ItNP (PosTV (tvDir (mkV "geben" "gibt" "gib" "gegeben"))
|
||||
(IndefManyNP (ModRC A (RelSuch B)))) ;
|
||||
} ;
|
||||
399
grammars/resource/german/Morpho.gf
Normal file
399
grammars/resource/german/Morpho.gf
Normal file
@@ -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 Morpho = Types ** 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 <gn,c> of {
|
||||
<GSg Fem,Gen> => "deren" ;
|
||||
<GSg g,Gen> => "dessen" ;
|
||||
<GPl,Dat> => "denen" ;
|
||||
<GPl,Gen> => "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 <g,c> of {
|
||||
<_,Nom> => bös+"e" ;
|
||||
<Masc,Acc> => 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 ;
|
||||
|
||||
{-
|
||||
-- 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
|
||||
} ;
|
||||
-}
|
||||
|
||||
} ;
|
||||
|
||||
300
grammars/resource/german/Paradigms.gf
Normal file
300
grammars/resource/german/Paradigms.gf
Normal file
@@ -0,0 +1,300 @@
|
||||
--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
|
||||
|
||||
--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 = mkNoun ;
|
||||
|
||||
nGen = \punkt, punktes, punkte, g -> let {
|
||||
e = Predef.dp 1 punkte ;
|
||||
eqy = ifTok (Gender -> N) e ;
|
||||
noN = mkNoun4 punkt punktes punkte punkte
|
||||
} in
|
||||
eqy "n" noN (
|
||||
eqy "s" noN (
|
||||
mkNoun4 punkt punktes punkte (punkte+"n"))) g ;
|
||||
|
||||
nRaum = \raum, räume -> nGen raum (raum + "es") räume masculine ;
|
||||
nTisch = \tisch ->
|
||||
mkNoun4 tisch (tisch + "es") (tisch + "e") (tisch +"en") masculine ;
|
||||
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 ;
|
||||
|
||||
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 (n2n n) ;
|
||||
funVon = \n -> funVonCN (n2n n) ;
|
||||
|
||||
mkPN = \karolus, karoli -> {s = table {Gen => karoli ; _ => karolus}} ;
|
||||
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 = mkFunC ;
|
||||
funVonCN = funVonC ;
|
||||
|
||||
mkAdj1 = mkAdjective ;
|
||||
adjInvar = Morpho.adjInvar ;
|
||||
adjGen = Morpho.adjGen ;
|
||||
mkAdj2 = \a,p,c -> a ** {s2 = p ; c = c} ;
|
||||
|
||||
mkAdjDeg = mkAdjComp ;
|
||||
aDeg3 = adjCompReg3 ;
|
||||
aReg = adjCompReg ;
|
||||
aPastPart = \v -> {s = table AForm {a => v.s ! VPart a}} ;
|
||||
apReg = \s -> AdjP1 (adjGen s) ;
|
||||
|
||||
mkV = \sehen, sieht, sieh, gesehen ->
|
||||
mkVerbSimple (mkVerbum sehen sieht sieh gesehen) ;
|
||||
vReg = \s -> mkVerbSimple (regVerb s) ;
|
||||
vSein = verbSein ;
|
||||
vHaben = verbHaben ;
|
||||
vPart = \sehen, sieht, sieh, gesehen, aus ->
|
||||
mkVerb (mkVerbum sehen sieht sieh gesehen) aus ;
|
||||
vPartReg = \sehen, aus -> mkVerb (regVerb sehen) aus ;
|
||||
|
||||
mkTV = mkTransVerb ;
|
||||
tvReg = \hören, zu, dat -> mkTV (vReg hören) zu dat ;
|
||||
tvDir = \v -> mkTV v [] accusative ;
|
||||
tvDirReg = \v -> tvReg v [] accusative ;
|
||||
|
||||
mkAdV = ss ;
|
||||
mkPP = prepPhrase ;
|
||||
mkAdA = ss ;
|
||||
mkAdS = ss ;
|
||||
} ;
|
||||
87
grammars/resource/german/Predication.gf
Normal file
87
grammars/resource/german/Predication.gf
Normal file
@@ -0,0 +1,87 @@
|
||||
|
||||
--1 A Small Predication Library
|
||||
--
|
||||
-- (c) Aarne Ranta 2003 under Gnu GPL.
|
||||
--
|
||||
-- This library is built on a language-independent API of
|
||||
-- resource grammars. It has a common part, the type signatures
|
||||
-- (defined here), and language-dependent parts. The user of
|
||||
-- the library should only have to look at the type signatures.
|
||||
|
||||
resource Predication = open Deutsch in {
|
||||
|
||||
-- We first define a set of predication patterns.
|
||||
|
||||
oper
|
||||
predV1 : V -> NP -> S ; -- one-place verb: "John walks"
|
||||
predV2 : TV -> NP -> NP -> S ; -- two-place verb: "John loves Mary"
|
||||
predVColl : V -> NP -> NP -> S ; -- collective verb: "John and Mary fight"
|
||||
predA1 : Adj1 -> NP -> S ; -- one-place adjective: "John is old"
|
||||
predA2 : Adj2 -> NP -> NP -> S ; -- two-place adj: "John is married to Mary"
|
||||
predAComp : AdjDeg -> NP -> NP -> S ; -- compar adj: "John is older than Mary"
|
||||
predAColl : Adj1 -> NP -> NP -> S ; -- collective adj: "John and Mary are married"
|
||||
predN1 : N -> NP -> S ; -- one-place noun: "John is a man"
|
||||
predN2 : Fun -> NP -> NP -> S ; -- two-place noun: "John is a lover of Mary"
|
||||
predNColl : N -> NP -> NP -> S ; -- collective noun: "John and Mary are lovers"
|
||||
|
||||
-- Individual-valued function applications.
|
||||
|
||||
appFun1 : Fun -> NP -> NP ; -- one-place function: "the successor of x"
|
||||
appFun2 : Fun -> NP -> NP -> NP ; -- two-place function: "the line from x to y"
|
||||
appFunColl : Fun -> NP -> NP -> NP ; -- collective function: "the sum of x and y"
|
||||
|
||||
-- Families of types, expressed by common nouns depending on arguments.
|
||||
|
||||
appFam1 : Fun -> NP -> CN ; -- one-place family: "divisor of x"
|
||||
appFam2 : Fun -> NP -> NP -> CN ; -- two-place family: "line from x to y"
|
||||
appFamColl : Fun -> NP -> NP -> CN ; -- collective family: "path between x and y"
|
||||
|
||||
-- Type constructor, similar to a family except that the argument is a type.
|
||||
|
||||
constrTyp1 : Fun -> CN -> CN ;
|
||||
|
||||
-- Logical connectives on two sentences.
|
||||
|
||||
conjS : S -> S -> S ;
|
||||
disjS : S -> S -> S ;
|
||||
implS : S -> S -> S ;
|
||||
|
||||
-- As an auxiliary, we need two-place conjunction of names ("John and Mary"),
|
||||
-- used in collective predication.
|
||||
|
||||
conjNP : NP -> NP -> NP ;
|
||||
|
||||
|
||||
-----------------------------
|
||||
|
||||
---- what follows should be an implementation of the preceding
|
||||
|
||||
oper
|
||||
predV1 = \F, x -> PredVP x (PosV F) ;
|
||||
predV2 = \F, x, y -> PredVP x (PosTV F y) ;
|
||||
predVColl = \F, x, y -> PredVP (conjNP x y) (PosV F) ;
|
||||
predA1 = \F, x -> PredVP x (PosA F) ;
|
||||
predA2 = \F, x, y -> PredVP x (PosA (ComplAdj F y)) ;
|
||||
predAComp = \F, x, y -> PredVP x (PosA (ComparAdjP F y)) ;
|
||||
predAColl = \F, x, y -> PredVP (conjNP x y) (PosA F) ;
|
||||
predN1 = \F, x -> PredVP x (PosCN (UseN F)) ;
|
||||
predN2 = \F, x, y -> PredVP x (PosCN (AppFun F y)) ;
|
||||
predNColl = \F, x, y -> PredVP (conjNP x y) (PosCN (UseN F)) ;
|
||||
|
||||
appFun1 = \f, x -> DefOneNP (AppFun f x) ;
|
||||
appFun2 = \f, x, y -> DefOneNP (AppFun (AppFun2 f x) y) ;
|
||||
appFunColl = \f, x, y -> DefOneNP (AppFun f (conjNP x y)) ;
|
||||
|
||||
appFam1 = \F, x -> AppFun F x ;
|
||||
appFam2 = \F, x, y -> AppFun (AppFun2 F x) y ;
|
||||
appFamColl = \F, x, y -> AppFun F (conjNP x y) ;
|
||||
|
||||
conjS = \A, B -> ConjS AndConj (TwoS A B) ;
|
||||
disjS = \A, B -> ConjS OrConj (TwoS A B) ;
|
||||
implS = \A, B -> SubjS IfSubj A B ;
|
||||
|
||||
constrTyp1 = \F, A -> AppFun F (IndefManyNP A) ;
|
||||
|
||||
conjNP = \x, y -> ConjNP AndConj (TwoNP x y) ;
|
||||
|
||||
} ;
|
||||
217
grammars/resource/german/ResDeu.gf
Normal file
217
grammars/resource/german/ResDeu.gf
Normal file
@@ -0,0 +1,217 @@
|
||||
--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 ResDeu of ResAbs = open Prelude, Syntax 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} ;
|
||||
|
||||
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} ;
|
||||
VP = Verb ** {s3 : Number => Str} ;
|
||||
TV = Verb ** {s3 : Preposition ; c : Case} ;
|
||||
VS = Verb ;
|
||||
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 ;
|
||||
ModGenMany = npGenDet plural ;
|
||||
UsePN = nameNounPhrase ;
|
||||
UseFun = funAsCommNounPhrase ;
|
||||
AppFun = appFunComm ;
|
||||
AppFun2 = appFun2 ;
|
||||
AdjP1 = adj2adjPhrase ;
|
||||
ComplAdj = complAdj ;
|
||||
PositAdjP = positAdjPhrase ;
|
||||
ComparAdjP = comparAdjPhrase ;
|
||||
SuperlNP = superlNounPhrase ;
|
||||
|
||||
DetNP = detNounPhrase ;
|
||||
IndefOneNP = indefNounPhrase singular ;
|
||||
IndefManyNP = indefNounPhrase plural ;
|
||||
DefOneNP = defNounPhrase singular ;
|
||||
DefManyNP = defNounPhrase plural ;
|
||||
|
||||
CNthatS = nounThatSentence ;
|
||||
|
||||
PredVP = predVerbPhrase ;
|
||||
PosV = predVerb True ;
|
||||
NegV = predVerb False ;
|
||||
PosA = predAdjective True ;
|
||||
NegA = predAdjective False ;
|
||||
PosCN = predCommNoun True ;
|
||||
NegCN = predCommNoun False ;
|
||||
PosTV = complTransVerb True ;
|
||||
NegTV = complTransVerb False ;
|
||||
PosPassV = passVerb True ;
|
||||
NegPassV = passVerb False ;
|
||||
PosNP = predNounPhrase True ;
|
||||
NegNP = predNounPhrase False ;
|
||||
PosVS = complSentVerb True ;
|
||||
NegVS = complSentVerb False ;
|
||||
|
||||
AdvVP = adVerbPhrase ;
|
||||
LocNP = locativeNounPhrase ;
|
||||
AdvCN = advCommNounPhrase ;
|
||||
AdvAP = advAdjPhrase ;
|
||||
|
||||
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 ;
|
||||
|
||||
PhrNP = useNounPhrase ;
|
||||
PhrOneCN = useCommonNounPhrase singular ;
|
||||
PhrManyCN = useCommonNounPhrase plural ;
|
||||
PhrIP ip = ip ;
|
||||
PhrIAdv ia = ia ;
|
||||
|
||||
OnePhr p = p ;
|
||||
ConsPhr = cc2 ;
|
||||
|
||||
INP = pronNounPhrase pronIch ;
|
||||
ThouNP = pronNounPhrase pronDu ;
|
||||
HeNP = pronNounPhrase pronEr ;
|
||||
SheNP = pronNounPhrase pronSie ;
|
||||
ItNP = pronNounPhrase pronEs ;
|
||||
WeNP = pronNounPhrase pronWir ;
|
||||
YeNP = pronNounPhrase pronIhr ;
|
||||
TheyNP = pronNounPhrase pronSiePl ;
|
||||
|
||||
YouNP = pronNounPhrase pronSSie ;
|
||||
|
||||
EveryDet = jederDet ;
|
||||
AllDet = alleDet ;
|
||||
WhichDet = welcherDet ;
|
||||
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" ;
|
||||
} ;
|
||||
24
grammars/resource/german/RestaurantDeu.gf
Normal file
24
grammars/resource/german/RestaurantDeu.gf
Normal file
@@ -0,0 +1,24 @@
|
||||
concrete RestaurantDeu of Restaurant =
|
||||
DatabaseDeu ** open Prelude,Paradigms,Deutsch,DatabaseRes in {
|
||||
|
||||
lin
|
||||
Restaurant = UseN (nAuto "Restaurant") ;
|
||||
Bar = UseN (nAuto "Bar") ; --- ??
|
||||
French = apReg "Französisch" ;
|
||||
Italian = apReg "Italienisch" ;
|
||||
Indian = apReg "Indisch" ;
|
||||
Japanese = apReg "Japanisch" ;
|
||||
|
||||
address = funVon (nFrau "Adresse") ;
|
||||
phone = funVon (nFrau "Rufnummer") ; ----
|
||||
priceLevel = funVon (nFrau "Preisstufe") ;
|
||||
|
||||
Cheap = aReg "billig" ;
|
||||
Expensive = aDeg3 "teuer" "teurer" "teurest" ;
|
||||
|
||||
WhoRecommend rest = mkSentSame (ss2 ["wer empfiehlt"] (rest.s ! accusative)) ;
|
||||
WhoHellRecommend rest =
|
||||
mkSentSame (ss2 ["wer zum Teufel empfiehlt"] (rest.s ! accusative)) ;
|
||||
|
||||
LucasCarton = mkPN ["Lucas Carton"] ["Lucas Cartons"] ;
|
||||
} ;
|
||||
891
grammars/resource/german/Syntax.gf
Normal file
891
grammars/resource/german/Syntax.gf
Normal file
@@ -0,0 +1,891 @@
|
||||
--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 Syntax = Morpho ** 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}} ;
|
||||
|
||||
--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 <a,c> of {
|
||||
<Strong,Nom> => Strong ;
|
||||
<Strong,Acc> => 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 = \alle, a ->
|
||||
{s = \\_ => alle ; n = Pl ; a = a} ;
|
||||
|
||||
detLikeAdj : Str -> Determiner = \jed -> mkDeterminerSg
|
||||
(\\g,c => (adjReg jed).s ! AMod Strong (GSg g) c) Weak ;
|
||||
|
||||
jederDet = detLikeAdj "jed" ;
|
||||
alleDet = mkDeterminerPl (caselist "alle" "alle" "allen" "aller") Weak ;
|
||||
einDet = mkDeterminerSg artIndef Strong ;
|
||||
derDet = mkDeterminerSg (table {g => artDef ! GSg g}) Weak ;
|
||||
dieDet = mkDeterminerPl (artDef ! GPl) Weak ;
|
||||
|
||||
meistDet = mkDeterminerPl (table {c => artDef ! GPl ! c ++ "meisten"}) Weak ;
|
||||
welcherDet = detLikeAdj "welch" ;
|
||||
welcheDet = mkDeterminerPl (caselist "welche" "welche" "welchen" "welcher") Weak ;
|
||||
|
||||
-- Choose "welcher"/"welche"
|
||||
|
||||
welchDet : Number -> Determiner = \n ->
|
||||
case n of {Sg => welcherDet ; Pl => welcheDet} ;
|
||||
|
||||
-- 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 -> NounPhrase -> CommNounPhrase -> NounPhrase = \n,haus,Wein ->
|
||||
let {
|
||||
hauses : Case => Str = \\c => haus.s ! NPPoss (gNumber Wein.g n) c ;
|
||||
wein : NPForm => Str = \\c => Wein.s ! Strong ! n ! caseNP c ;
|
||||
derwein : NPForm => Str = (defNounPhrase 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 ;
|
||||
|
||||
-- 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
|
||||
} ;
|
||||
|
||||
defNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n,haus -> case n of {
|
||||
Sg => detNounPhrase derDet haus ;
|
||||
Pl => detNounPhrase dieDet haus
|
||||
} ;
|
||||
|
||||
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 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, (s2) particle, and
|
||||
-- (s3) negation and complement. This discontinuity is needed in sentence formation
|
||||
-- to account for word order variations.
|
||||
|
||||
VerbPhrase = Verb ** {s3 : Number => Str} ;
|
||||
|
||||
-- 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 : Bool -> Verb -> VerbPhrase = \b,aussehen ->
|
||||
aussehen ** {
|
||||
s3 = \\_ => negation b
|
||||
} ;
|
||||
|
||||
negation : Bool -> Str = \b -> if_then_else Str b [] "nicht" ;
|
||||
|
||||
-- Sometimes we want to extract the verb part of a verb phrase.
|
||||
|
||||
verbOfPhrase : VerbPhrase -> Verb = \v -> {s = v.s ; s2 = v.s2} ;
|
||||
|
||||
-- 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 : Bool -> Adjective -> VerbPhrase = \b,gut ->
|
||||
verbSein ** {
|
||||
s3 = \\_ => negation b ++ gut.s ! APred
|
||||
} ;
|
||||
|
||||
predCommNoun : Bool -> CommNounPhrase -> VerbPhrase = \b,man ->
|
||||
verbSein ** {
|
||||
s3 = \\n => negation b ++ indefNoun n man
|
||||
} ;
|
||||
|
||||
predNounPhrase : Bool -> NounPhrase -> VerbPhrase = \b,dermann ->
|
||||
verbSein ** {
|
||||
s3 = \\n => negation b ++ dermann.s ! NPCase Nom
|
||||
} ;
|
||||
|
||||
--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} ;
|
||||
|
||||
-- The rule for using transitive verbs is the complementization rule:
|
||||
|
||||
complTransVerb : Bool -> TransVerb -> NounPhrase -> VerbPhrase =
|
||||
\b,warten,dich ->
|
||||
let {
|
||||
aufdich = warten.s3 ++ dich.s ! NPCase warten.c ;
|
||||
nicht = negation b
|
||||
} in
|
||||
{s = warten.s ;
|
||||
s2 = warten.s2 ;
|
||||
s3 = \\_ => bothWays aufdich nicht
|
||||
} ;
|
||||
|
||||
-- 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 : Bool -> Verb -> VerbPhrase = \b,lieben ->
|
||||
{s = verbumWerden ;
|
||||
s2 = [] ;
|
||||
s3 = \\_ => negation b ++ lieben.s ! VPart APred
|
||||
} ;
|
||||
|
||||
|
||||
--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 ;
|
||||
|
||||
adVerbPhrase : VerbPhrase -> Adverb -> VerbPhrase = \spielt, gut ->
|
||||
{s = spielt.s ;
|
||||
s2 = spielt.s2 ;
|
||||
s3 = \\n => spielt.s3 ! n ++ gut.s
|
||||
} ;
|
||||
|
||||
advAdjPhrase : Adverb -> AdjPhrase -> AdjPhrase = \sehr, gut ->
|
||||
{s = \\a => sehr.s ++ gut.s ! a ;
|
||||
p = gut.p
|
||||
} ;
|
||||
|
||||
-- Adverbials are typically generated by prefixing prepositions.
|
||||
-- The rule for creating locative noun phrases by the preposition "in"
|
||||
-- is a little shaky, since other prepositions may be preferred ("an", "auf").
|
||||
|
||||
prepPhrase : Case -> Preposition -> NounPhrase -> Adverb = \c,auf,ihm ->
|
||||
ss (auf ++ ihm.s ! NPCase c) ;
|
||||
|
||||
locativeNounPhrase : NounPhrase -> Adverb =
|
||||
prepPhrase Dat "in" ;
|
||||
|
||||
-- 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
|
||||
} in
|
||||
{s = table {
|
||||
Main => ich ++ liebe ++ dichnichtgut ++ aus ;
|
||||
Inv => liebe ++ ich ++ dichnichtgut ++ aus ;
|
||||
Sub => ich ++ dichnichtgut ++ aus ++ liebe
|
||||
}
|
||||
} ;
|
||||
|
||||
--3 Sentence-complement verbs
|
||||
--
|
||||
-- Sentence-complement verbs take sentences as complements.
|
||||
|
||||
SentenceVerb : Type = Verb ;
|
||||
|
||||
complSentVerb : Bool -> SentenceVerb -> Sentence -> VerbPhrase = \b,sage,duisst ->
|
||||
sage **
|
||||
{s3 = \\_ => negation b ++ "," ++ "dass" ++ duisst.s ! Sub} ;
|
||||
|
||||
|
||||
--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} ;
|
||||
|
||||
imperUtterance : Number -> Imperative -> Utterance = \n,I ->
|
||||
ss (I.s ! n ++ "!") ;
|
||||
|
||||
--2 Sentence adverbials
|
||||
--
|
||||
-- This class covers adverbials such as "sonst", "folgelich", 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 <m,n> of {
|
||||
<Sg,Sg> => 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 <p,q> of {
|
||||
<P3,P3> => P3 ;
|
||||
<P1,_> => 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} ;
|
||||
|
||||
|
||||
--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".
|
||||
|
||||
} ;
|
||||
39
grammars/resource/german/TestDeu.gf
Normal file
39
grammars/resource/german/TestDeu.gf
Normal file
@@ -0,0 +1,39 @@
|
||||
concrete TestDeu of TestAbs = ResDeu ** open Syntax 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" ;
|
||||
Old = adjCompReg3 "alt" "älter" "ältest";
|
||||
Young = adjCompReg3 "jung" "jünger" "jüngst";
|
||||
Man = declN2u "Mann" "Männer" ;
|
||||
Woman = declN1 "Frau" ;
|
||||
Car = declNs "Auto" ;
|
||||
House = declN3uS "Haus" "Häuser" ;
|
||||
Light = declN3 "Licht" ;
|
||||
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;
|
||||
Love = mkTransVerb (mkVerbSimple (regVerb "lieben")) [] Acc ;
|
||||
Wait = mkTransVerb (mkVerbSimple (verbWarten "warten")) "auf" Acc ;
|
||||
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" ;
|
||||
|
||||
} ;
|
||||
|
||||
98
grammars/resource/german/Types.gf
Normal file
98
grammars/resource/german/Types.gf
Normal file
@@ -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 Types = 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 ;
|
||||
|
||||
} ;
|
||||
Reference in New Issue
Block a user