From 330e73f9aa1bb8e0cf80a198caae921b8e6904bf Mon Sep 17 00:00:00 2001 From: aarne Date: Mon, 17 Jan 2005 16:32:15 +0000 Subject: [PATCH] starting to add tense to English resource --- lib/resource/abstract/Categories.gf | 4 +- lib/resource/abstract/Rules.gf | 6 +- lib/resource/abstract/TestResource.gf | 2 +- lib/resource/english/CategoriesEng.gf | 82 ++ lib/resource/english/MorphoEng.gf | 215 ++++ lib/resource/english/Rules.gf | 198 ++++ lib/resource/english/StructuralEng.gf | 104 ++ lib/resource/english/SyntaxEng.gf | 1096 +++++++++++++++++++++ lib/resource/english/TypesEng.gf | 104 ++ lib/resource/romance/CategoriesRomance.gf | 2 +- lib/resource/romance/RulesRomance.gf | 4 +- lib/resource/russian/CategoriesRus.gf | 2 +- lib/resource/russian/RulesRus.gf | 4 +- lib/resource/swedish/CategoriesSwe.gf | 2 +- lib/resource/swedish/RulesSwe.gf | 4 +- 15 files changed, 1814 insertions(+), 15 deletions(-) create mode 100644 lib/resource/english/CategoriesEng.gf create mode 100644 lib/resource/english/MorphoEng.gf create mode 100644 lib/resource/english/Rules.gf create mode 100644 lib/resource/english/StructuralEng.gf create mode 100644 lib/resource/english/SyntaxEng.gf create mode 100644 lib/resource/english/TypesEng.gf diff --git a/lib/resource/abstract/Categories.gf b/lib/resource/abstract/Categories.gf index 7c1771aa3..13f91fbbe 100644 --- a/lib/resource/abstract/Categories.gf +++ b/lib/resource/abstract/Categories.gf @@ -79,13 +79,13 @@ cat --3 Adjectives and adjectival phrases -- - A1 ; -- one-place adjective, e.g. "even" + A ; -- one-place adjective, e.g. "even" A2 ; -- two-place adjective, e.g. "divisible (by)" ADeg ; -- degree adjective, e.g. "big/bigger/biggest" AP ; -- adjective phrase, e.g. "divisible by two", "bigger than John" --- The difference between $A1$ and $ADeg$ is that the former has no +-- The difference between $A$ and $ADeg$ is that the former has no -- comparison forms. --! diff --git a/lib/resource/abstract/Rules.gf b/lib/resource/abstract/Rules.gf index 553ffe2ce..09beb1ec9 100644 --- a/lib/resource/abstract/Rules.gf +++ b/lib/resource/abstract/Rules.gf @@ -33,7 +33,7 @@ fun AppN3 : N3 -> NP -> N2 ; -- "flight from Paris" UseN2 : N2 -> CN ; -- "successor" - ModAdj : AP -> CN -> CN ; -- "red car" + ModAP : AP -> CN -> CN ; -- "red car" CNthatS : CN -> S -> CN ; -- "idea that the Earth is flat" ModGenOne : NP -> CN -> NP ; -- "John's car" @@ -46,14 +46,14 @@ fun --3 Adjectives and adjectival phrases -- - UseA1 : A1 -> AP ; -- "red" + UseA : A -> AP ; -- "red" ComplA2 : A2 -> NP -> AP ; -- "divisible by two" PositADeg : ADeg -> AP ; -- "old" ComparADeg : ADeg -> NP -> AP ; -- "older than John" SuperlNP : ADeg -> CN -> NP ; -- "the oldest man" ----- AdjPart : V -> A1 ; -- "forgotten" +---- AdjPart : V -> A ; -- "forgotten" --! --3 Verbs and verb phrases diff --git a/lib/resource/abstract/TestResource.gf b/lib/resource/abstract/TestResource.gf index 0e454e78f..3a2aa4901 100644 --- a/lib/resource/abstract/TestResource.gf +++ b/lib/resource/abstract/TestResource.gf @@ -4,7 +4,7 @@ abstract TestResource = Rules, Structural ** { fun Big, Happy, Small, Old, Young : ADeg ; - American, Finnish : A1 ; + American, Finnish : A ; Married : A2 ; Man, Woman, Car, House, Light, Bar, Bottle, Wine, Level : N ; Walk, Run : V ; diff --git a/lib/resource/english/CategoriesEng.gf b/lib/resource/english/CategoriesEng.gf new file mode 100644 index 000000000..5a024a073 --- /dev/null +++ b/lib/resource/english/CategoriesEng.gf @@ -0,0 +1,82 @@ +--# -path=.:../abstract:../../prelude + +--1 The Top-Level English Resource Grammar: Combination Rules +-- +-- Aarne Ranta 2002 -- 2003 +-- +-- This is the English concrete syntax of the multilingual resource +-- grammar. Most of the work is done in the file $syntax.Eng.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 $TypesEng.gf$. + +concrete CategoriesEng of Categories = open Prelude, SyntaxEng in { + +flags + startcat=Phr ; + lexer=text ; + unlexer=text ; + +lincat + N = CommNoun ; + -- = {s : Number => Case => Str} + CN = CommNounPhrase ; + -- = CommNoun ** {g : Gender} + NP = {s : NPForm => Str ; n : Number ; p : Person} ; + PN = {s : Case => Str} ; + Det = {s : Str ; n : Number} ; + N2 = Function ; + -- = CommNounPhrase ** {s2 : Preposition} ; + N3 = Function ** {s3 : Preposition} ; + Num = {s : Case => Str} ; + Prep = {s : Str} ; + + A = Adjective ; + -- = {s : AForm => Str} + A2 = Adjective ** {s2 : Preposition} ; + ADeg = {s : Degree => AForm => Str} ; + AP = Adjective ** {p : Bool} ; + + V = Verb ; + -- = {s : VForm => Str ; s1 : Particle} + VG = {s : Bool => SForm => Str ; s2 : Bool => Number => Str ; + isAuxT, isAuxF : Bool} ; + VP = {s : SForm => Str ; s2 : Number => Str ; isAux : Bool} ; + TV = TransVerb ; + -- = Verb ** {s3 : Preposition} ; + V3 = TransVerb ** {s4 : Preposition} ; + VS = Verb ; + VV = Verb ** {isAux : Bool} ; + + AdV = {s : Str ; p : Bool} ; + + S = {s : Str} ; + Cl = Clause ; + -- = {s : Bool => SForm => Str} ; + Slash = {s : Bool => Str ; s2 : Preposition} ; + RP = {s : Gender => Number => NPForm => Str} ; + RC = {s : Gender => Number => Str} ; + + IP = {s : NPForm => Str ; n : Number} ; + Qu = {s : QuestForm => Str} ; + Imp = {s : Number => Str} ; + Phr = {s : Str} ; + Text = {s : Str} ; + + Conj = {s : Str ; n : Number} ; + ConjD = {s1 : Str ; s2 : Str ; n : Number} ; + + ListS = {s1 : Str ; s2 : Str} ; + ListAP = {s1,s2 : AForm => Str ; p : Bool} ; + ListNP = {s1,s2 : NPForm => Str ; n : Number ; p : Person} ; + +} ; diff --git a/lib/resource/english/MorphoEng.gf b/lib/resource/english/MorphoEng.gf new file mode 100644 index 000000000..33fe593ee --- /dev/null +++ b/lib/resource/english/MorphoEng.gf @@ -0,0 +1,215 @@ +--# -path=.:../../prelude + +--1 A Simple English 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.gf$. + +resource MorphoEng = TypesEng ** open Prelude, (Predef=Predef) in { + +--2 Nouns +-- +-- For conciseness and abstraction, we define a worst-case macro for +-- noun inflection. It is used for defining special case that +-- only need one string as argument. + +oper + mkNoun : (_,_,_,_ : Str) -> CommonNoun = + \man,men, mans, mens -> {s = table { + Sg => table {Nom => man ; Gen => mans} ; + Pl => table {Nom => men ; Gen => mens} + }} ; + + nounReg : Str -> CommonNoun = \dog -> + mkNoun dog (dog + "s") (dog + "'s") (dog + "s'"); + + nounS : Str -> CommonNoun = \kiss -> + mkNoun kiss (kiss + "es") (kiss + "'s") (kiss + "es'") ; + + nounY : Str -> CommonNoun = \fl -> + mkNoun (fl + "y") (fl + "ies") (fl + "y's") (fl + "ies'") ; + + nounGen : Str -> CommonNoun = \dog -> case last dog of { + "y" => nounY "dog" ; + "s" => nounS (init "dog") ; + _ => nounReg "dog" + } ; + +--3 Proper names +-- +-- Regular proper names are inflected with "'s" in the genitive. + + nameReg : Str -> ProperName = \john -> + {s = table {Nom => john ; Gen => john + "'s"}} ; + + +--2 Pronouns +-- +-- Here we define personal and relative pronouns. + + mkPronoun : (_,_,_,_ : Str) -> Number -> Person -> Pronoun = \I,me,my,mine,n,p -> + {s = table {NomP => I ; AccP => me ; GenP => my ; GenSP => mine} ; + n = n ; p = p} ; + + pronI = mkPronoun "I" "me" "my" "mine" Sg P1 ; + pronYouSg = mkPronoun "you" "you" "your" "yours" Sg P2 ; -- verb form still OK + pronHe = mkPronoun "he" "him" "his" "his" Sg P3 ; + pronShe = mkPronoun "she" "her" "her" "hers" Sg P3 ; + pronIt = mkPronoun "it" "it" "its" "it" Sg P3 ; + + pronWe = mkPronoun "we" "us" "our" "ours" Pl P1 ; + pronYouPl = mkPronoun "you" "you" "your" "yours" Pl P2 ; + pronThey = mkPronoun "they" "them" "their" "theirs" Pl P3 ; + +-- Relative pronouns in the accusative have the 'no pronoun' variant. +-- The simple pronouns do not really depend on number. + + relPron : RelPron = {s = table { + NoHum => \\_ => table { + NomP => variants {"that" ; "which"} ; + AccP => variants {"that" ; "which" ; []} ; + GenP => variants {"whose"} ; + GenSP => variants {"which"} + } ; + Hum => \\_ => table { + NomP => variants {"that" ; "who"} ; + AccP => variants {"that" ; "who" ; "whom" ; []} ; + GenP => variants {"whose"} ; + GenSP => variants {"whom"} + } + } + } ; + + +--3 Determiners +-- +-- We have just a heuristic definition of the indefinite article. +-- There are lots of exceptions: consonantic "e" ("euphemism"), consonantic +-- "o" ("one-sided"), vocalic "u" ("umbrella"). + + artIndef = pre {"a" ; + "an" / strs {"a" ; "e" ; "i" ; "o" ; "A" ; "E" ; "I" ; "O" }} ; + + artDef = "the" ; + +--2 Adjectives +-- +-- To form the adjectival and the adverbial forms, two strings are needed +-- in the worst case. + + mkAdjective : Str -> Str -> Adjective = \free,freely -> { + s = table { + AAdj => free ; + AAdv => freely + } + } ; + +-- However, the ending "iy" is sufficient for most cases. This function +-- automatically changes the word-final "y" to "i" ("happy" - "happily"). +-- N.B. this is not correct for "shy", but $mkAdjective$ has to be used. + + regAdjective : Str -> Adjective = \free -> + let + y = Predef.dp 1 free + in mkAdjective + free + (ifTok Str y "y" (Predef.tk 1 free + ("ily")) (free + "ly")) ; + +-- For the comparison of adjectives, six forms are needed to cover all cases. +-- But there is no adjective that actually needs all these. + + mkAdjDegrWorst : (_,_,_,_,_,_ : Str) -> AdjDegr = + \good,well,better,betterly,best,bestly -> + {s = table { + Pos => (mkAdjective good well).s ; + Comp => (mkAdjective better betterly).s ; + Sup => (mkAdjective best bestly).s + } + } ; + +-- What is usually needed for irregular comparisons are just three forms, +-- since the adverbial form is the same (in comparative or superlative) +-- or formed in the regular way (positive). + + adjDegrIrreg : (_,_,_ : Str) -> AdjDegr = \bad,worse,worst -> + let badly = (regAdjective bad).s ! AAdv + in mkAdjDegrWorst bad badly worse worse worst worst ; + +-- Like above, the regular formation takes account of final "y". + + adjDegrReg : Str -> AdjDegr = \happy -> + let happi = ifTok Str (Predef.dp 1 happy) "y" (Predef.tk 1 happy + "i") happy + in adjDegrIrreg happy (happi + "er") (happi + "est") ; + +-- Many adjectives are 'inflected' by adding a comparison word. + + adjDegrLong : Str -> AdjDegr = \ridiculous -> + adjDegrIrreg ridiculous ("more" ++ ridiculous) ("most" ++ ridiculous) ; + + +--3 Verbs +-- +-- Except for "be", the worst case needs four forms. + + mkVerbP3 : (_,_,_,_: Str) -> VerbP3 = \go,goes,went,gone -> + {s = table { + InfImp => go ; + Indic P3 => goes ; + Indic _ => go ; + Pastt _ => went ; + PPart => gone + } + } ; + + mkVerb : (_,_,_ : Str) -> VerbP3 = \ring,rang,rung -> + mkVerbP3 ring (ring + "s") rang rung ; + + regVerbP3 : Str -> VerbP3 = \walk -> + mkVerb walk (walk + "ed") (walk + "ed") ; + + verbP3s : Str -> VerbP3 = \kiss -> + mkVerbP3 kiss (kiss + "es") (kiss + "ed") (kiss + "ed") ; + + verbP3e : Str -> VerbP3 = \love -> + mkVerbP3 love (love + "s") (love + "d") (love + "d") ; + + verbP3y : Str -> VerbP3 = \cr -> + mkVerbP3 (cr + "y") (cr + "ies") (cr + "ied") (cr + "ied") ; + + verbGen : Str -> VerbP3 = \kill -> case last kill of { + "y" => verbP3y (init "kill") ; + "e" => verbP3y (init "kill") ; + "s" => verbP3s (init "kill") ; + _ => regVerbP3 "kill" + } ; + + verbP3Have = mkVerbP3 "have" "has" "had" "had" ; + + verbP3Do = mkVerbP3 "do" "does" "did" "done" ; + + verbBe : VerbP3 = {s = table { + InfImp => "be" ; + Indic P1 => "am" ; + Indic P2 => "are" ; + Indic P3 => "is" ; + Pastt Sg => "was" ; + Pastt Pl => "were" ; + PPart => "been" + }} ; + + verbPart : VerbP3 -> Particle -> Verb = \v,p -> + v ** {s1 = p} ; + + verbNoPart : VerbP3 -> Verb = \v -> verbPart v [] ; + +-- The optional negation contraction is a useful macro e.g. for "do". + + contractNot : Str -> Str = \is -> variants {is ++ "not" ; is + "n't"} ; + + dont = contractNot (verbP3Do.s ! InfImp) ; +} ; + diff --git a/lib/resource/english/Rules.gf b/lib/resource/english/Rules.gf new file mode 100644 index 000000000..15c78277a --- /dev/null +++ b/lib/resource/english/Rules.gf @@ -0,0 +1,198 @@ +--# -path=.:../abstract:../../prelude + +--1 The Top-Level English Resource Grammar: Combination Rules +-- +-- Aarne Ranta 2002 -- 2003 +-- +-- This is the English concrete syntax of the multilingual resource +-- grammar. Most of the work is done in the file $syntax.Eng.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 $TypesEng.gf$. + +concrete CombinationsEng of Combinations = open Prelude, SyntaxEng in { + +flags + startcat=Phr ; + lexer=text ; + unlexer=text ; + +lincat + N = CommNoun ; + -- = {s : Number => Case => Str} + CN = CommNounPhrase ; + -- = CommNoun ** {g : Gender} + NP = {s : NPForm => Str ; n : Number ; p : Person} ; + PN = {s : Case => Str} ; + Det = {s : Str ; n : Number} ; + Fun = Function ; + -- = CommNounPhrase ** {s2 : Preposition} ; + Fun2 = Function ** {s3 : Preposition} ; + Num = {s : Case => Str} ; + + Adj1 = Adjective ; + -- = {s : AForm => Str} + Adj2 = Adjective ** {s2 : Preposition} ; + AdjDeg = {s : Degree => AForm => Str} ; + AP = Adjective ** {p : Bool} ; + + V = Verb ; + -- = {s : VForm => Str ; s1 : Particle} + VG = {s : Bool => VForm => Str ; s2 : Bool => Number => Str ; + isAuxT, isAuxF : Bool} ; + VP = {s : VForm => Str ; s2 : Number => Str ; isAux : Bool} ; + TV = TransVerb ; + -- = Verb ** {s3 : Preposition} ; + V3 = TransVerb ** {s4 : Preposition} ; + VS = Verb ; + VV = Verb ** {isAux : Bool} ; + + AdV = {s : Str ; p : Bool} ; + + S = {s : Str} ; + Slash = {s : Bool => Str ; s2 : Preposition} ; + RP = {s : Gender => Number => NPForm => Str} ; + RC = {s : Gender => Number => Str} ; + + IP = {s : NPForm => Str ; n : Number} ; + Qu = {s : QuestForm => Str} ; + Imp = {s : Number => Str} ; + Phr = {s : Str} ; + Text = {s : Str} ; + + Conj = {s : Str ; n : Number} ; + ConjD = {s1 : Str ; s2 : Str ; n : Number} ; + + ListS = {s1 : Str ; s2 : Str} ; + ListAP = {s1,s2 : AForm => Str ; p : Bool} ; + ListNP = {s1,s2 : NPForm => Str ; n : Number ; p : Person} ; + +--. + +lin + UseN = noun2CommNounPhrase ; + ModAdj = modCommNounPhrase ; + ModGenOne = npGenDet singular noNum ; + ModGenNum = 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 ; + IndefNumNP = indefNounPhraseNum plural ; + DefOneNP = defNounPhrase singular ; + DefNumNP = defNounPhraseNum plural ; + MassNP = detNounPhrase (mkDeterminer Sg []) ; + + CNthatS = nounThatSentence ; + UseInt i = {s = table {Nom => i.s ; Gen => i.s ++ "'s"}} ; --- + NoNum = noNum ; + + SymbPN i = {s = table {Nom => i.s ; Gen => i.s ++ "'s"}} ; --- + SymbCN cn s = + {s = \\n,c => cn.s ! n ! c ++ s.s ; + g = cn.g} ; + + 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 = advPost (a.s ! AAdv) ; + PrepNP p = prepPhrase p.s ; --- + AdvVP = adVerbPhrase ; + AdvCN = advCommNounPhrase ; + AdvAP = advAdjPhrase ; + + PosSlashTV = slashTransVerb True ; + NegSlashTV = slashTransVerb False ; + OneVP = predVerbPhrase (nameNounPhrase (nameReg "one")) ; + ThereNP = thereIs ; + + 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 ; + IsThereNP = isThere ; + + ImperVP = imperVerbPhrase ; + + IndicPhrase = indicUtt ; + QuestPhrase = interrogUtt ; + ImperOne = imperUtterance singular ; + ImperMany = imperUtterance plural ; + + AdvS = advSentence ; + + 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/english/StructuralEng.gf b/lib/resource/english/StructuralEng.gf new file mode 100644 index 000000000..261d65fa0 --- /dev/null +++ b/lib/resource/english/StructuralEng.gf @@ -0,0 +1,104 @@ +--# -path=.:../abstract:../../prelude + +--1 The Top-Level English Resource Grammar: Structural Words +-- +-- Aarne Ranta 2002 -- 2003 +-- +concrete StructuralEng of Structural = + CombinationsEng ** open Prelude, SyntaxEng in { + lin + INP = pronI ; + ThouNP = pronYouSg ; + HeNP = pronHe ; + SheNP = pronShe ; + ItNP = pronIt ; + WeNumNP = pronWithNum pronWe ; + YeNumNP = pronWithNum pronYouPl ; + YouNP = pronYouSg ; + TheyNP = pronThey ; + + EveryDet = everyDet ; + AllMassDet = mkDeterminer Sg "all" ; --- all the missing + AllNumDet = mkDeterminerNum Pl "all" ; + WhichDet = whichDet ; + WhichNumDet = mkDeterminerNum Pl "which" ; + MostsDet = mostDet ; + MostDet = mkDeterminer Sg "most" ; + SomeDet = mkDeterminer Sg "some" ; + SomeNumDet = mkDeterminerNum Pl "some" ; + AnyDet = mkDeterminer Sg "any" ; + AnyNumDet = mkDeterminerNum Pl "any" ; + NoDet = mkDeterminer Sg "no" ; + NoNumDet = mkDeterminerNum Pl "no" ; + ManyDet = mkDeterminer Pl "many" ; + MuchDet = mkDeterminer Sg ["a lot of"] ; --- + ThisDet = mkDeterminer Sg "this" ; + TheseNumDet = mkDeterminerNum Pl "these" ; + ThatDet = mkDeterminer Sg "that" ; + ThoseNumDet = mkDeterminerNum Pl "those" ; + + ThisNP = nameNounPhrase (nameReg "this") ; + ThatNP = nameNounPhrase (nameReg "that") ; + TheseNumNP n = nameNounPhrasePl {s = \\c => "these" ++ n.s ! c} ; + ThoseNumNP n = nameNounPhrasePl {s = \\c => "those" ++ n.s ! c} ; + + EverybodyNP = nameNounPhrase (nameReg "everybody") ; + SomebodyNP = nameNounPhrase (nameReg "somebody") ; + NobodyNP = nameNounPhrase (nameReg "nobody") ; + EverythingNP = nameNounPhrase (nameReg "everything") ; + SomethingNP = nameNounPhrase (nameReg "something") ; + NothingNP = nameNounPhrase (nameReg "nothing") ; + + CanVV = vvCan ; + CanKnowVV = vvCan ; + MustVV = vvMust ; + WantVV = verbNoPart (regVerbP3 "want") ** {isAux = False} ; + + HowIAdv = ss "how" ; + WhenIAdv = ss "when" ; + WhereIAdv = ss "where" ; + WhyIAdv = ss "why" ; + EverywhereNP = advPost "everywhere" ; + SomewhereNP = advPost "somewhere" ; + NowhereNP = advPost "nowhere" ; + + AndConj = ss "and" ** {n = Pl} ; + OrConj = ss "or" ** {n = Sg} ; + BothAnd = sd2 "both" "and" ** {n = Pl} ; + EitherOr = sd2 "either" "or" ** {n = Sg} ; + NeitherNor = sd2 "neither" "nor" ** {n = Sg} ; + IfSubj = ss "if" ; + WhenSubj = ss "when" ; + AlthoughSubj = ss "although" ; + + PhrYes = ss "Yes." ; + PhrNo = ss "No." ; + + VeryAdv = ss "very" ; + TooAdv = ss "too" ; + AlmostAdv = ss "almost" ; + QuiteAdv = ss "quite" ; + OtherwiseAdv = ss "otherwise" ; + ThereforeAdv = ss "therefore" ; + + InPrep = ss "in" ; + OnPrep = ss "on" ; + ToPrep = ss "to" ; + ThroughPrep = ss "through" ; + AbovePrep = ss "above" ; + UnderPrep = ss "under" ; + InFrontPrep = ss ["in front of"] ; + BehindPrep = ss "behind" ; + BetweenPrep = ss "between" ; + FromPrep = ss "from" ; + BeforePrep = ss "before" ; + DuringPrep = ss "during" ; + AfterPrep = ss "after" ; + WithPrep = ss "with" ; + WithoutPrep = ss "without" ; + ByMeansPrep = ss "by" ; + PossessPrep = ss "of" ; + PartPrep = ss "of" ; + AgentPrep = ss "by" ; + +} diff --git a/lib/resource/english/SyntaxEng.gf b/lib/resource/english/SyntaxEng.gf new file mode 100644 index 000000000..6a2564642 --- /dev/null +++ b/lib/resource/english/SyntaxEng.gf @@ -0,0 +1,1096 @@ +--# -path=.:../../prelude + +--1 A Small English Resource Syntax +-- +-- Aarne Ranta 2002 +-- +-- This resource grammar contains definitions needed to construct +-- indicative, interrogative, and imperative sentences in English. +-- +-- The following files are presupposed: + +resource SyntaxEng = MorphoEng ** 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 + +-- To the common nouns of morphology, +-- we add natural gender (human/nonhuman) which is needed in syntactic +-- combinations (e.g. "man who runs" - "program which runs"). + +oper + CommNoun = CommonNoun ** {g : Gender} ; + + CommNounPhrase = CommNoun ; + + noun2CommNounPhrase : CommNoun -> CommNounPhrase = \man -> + man ; + + cnGen : CommonNoun -> Gender -> CommNoun = \cn,g -> + cn ** {g = g} ; + + cnHum : CommonNoun -> CommNoun = \cn -> + cnGen cn Hum ; + cnNoHum : CommonNoun -> CommNoun = \cn -> + cnGen cn NoHum ; + +--2 Noun phrases +-- +-- The worst case is pronouns, which have inflection in the possessive forms. +-- Proper names are a special case. + + NounPhrase : Type = Pronoun ; + + nameNounPhrase : ProperName -> NounPhrase = \john -> + {s = \\c => john.s ! toCase c ; n = Sg ; p = P3} ; + + nameNounPhrasePl : ProperName -> NounPhrase = \john -> + {s = \\c => john.s ! toCase c ; n = Pl ; p = P3} ; + +-- The following construction has to be refined for genitive forms: +-- "we two", "us two" are OK, but "our two" is not. + + Numeral : Type = {s : Case => Str} ; + + pronWithNum : Pronoun -> Numeral -> Pronoun = \we,two -> + {s = \\c => we.s ! c ++ two.s ! toCase c ; n = we.n ; p = we.p} ; + + noNum : Numeral = {s = \\_ => []} ; + +--2 Determiners +-- +-- Determiners are inflected according to the nouns they determine. +-- The determiner is not inflected. + + Determiner : Type = {s : Str ; n : Number} ; + + detNounPhrase : Determiner -> CommNounPhrase -> NounPhrase = \every, man -> + {s = \\c => every.s ++ man.s ! every.n ! toCase c ; + n = every.n ; + p = P3 + } ; + + mkDeterminer : Number -> Str -> Determiner = \n,the -> + mkDeterminerNum n the noNum ; + + mkDeterminerNum : Number -> Str -> Numeral -> Determiner = \n,det,two -> + {s = det ++ two.s ! Nom ; + n = n + } ; + + everyDet = mkDeterminer Sg "every" ; + allDet = mkDeterminerNum Pl "all" ; + mostDet = mkDeterminer Pl "most" ; + aDet = mkDeterminer Sg artIndef ; + plDet = mkDeterminerNum Pl [] ; + theSgDet = mkDeterminer Sg "the" ; + thePlDet = mkDeterminerNum Pl "the" ; + anySgDet = mkDeterminer Sg "any" ; + anyPlDet = mkDeterminerNum Pl "any" ; + + whichSgDet = mkDeterminer Sg "which" ; + whichPlDet = mkDeterminerNum Pl "which" ; + + whichDet = whichSgDet ; --- API + + indefNoun : Number -> CommNoun -> Str = \n,man -> + (indefNounPhrase n man).s ! NomP ; + + indefNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n -> + indefNounPhraseNum n noNum ; + + indefNounPhraseNum : Number -> Numeral ->CommNounPhrase -> NounPhrase = + \n,two,man -> + {s = \\c => case n of { + Sg => artIndef ++ two.s ! Nom ++ man.s ! n ! toCase c ; + Pl => two.s ! Nom ++ man.s ! n ! toCase c + } ; + n = n ; p = P3 + } ; + + defNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n -> + defNounPhraseNum n noNum ; + defNounPhraseNum : Number -> Numeral -> CommNounPhrase -> NounPhrase = + \n,two,car -> + {s = \\c => artDef ++ two.s ! Nom ++ car.s ! n ! toCase c ; + n = n ; + p = P3 + } ; + +-- Genitives of noun phrases can be used like determiners, to build noun phrases. +-- The number argument makes the difference between "my house" - "my houses". +-- +-- We have the variation "the car of John / the car of John's / John's car" + + npGenDet : Number -> Numeral -> NounPhrase -> CommNounPhrase -> NounPhrase = + \n,two,john,car -> + {s = \\c => variants { + artDef ++ two.s ! Nom ++ car.s ! n ! Nom ++ "of" ++ john.s ! GenSP ; + john.s ! GenP ++ two.s ! Nom ++ car.s ! n ! toCase c + } ; + n = n ; + p = P3 + } ; + +-- *Bare plural noun phrases* like "men", "good cars", are built without a +-- determiner word. + + plurDet : CommNounPhrase -> NounPhrase = \cn -> + {s = \\c => cn.s ! plural ! toCase c ; + p = P3 ; + n = Pl + } ; + +-- Constructions like "the idea that two is even" are formed at the +-- first place as common nouns, so that one can also have "a suggestion that...". + + nounThatSentence : CommNounPhrase -> SS -> CommNounPhrase = \idea,x -> + {s = \\n,c => idea.s ! n ! c ++ "that" ++ x.s ; + g = idea.g + } ; + + +--2 Adjectives +-- +-- Adjectival phrases have a parameter $p$ telling if they are prefixed ($True$) or +-- postfixed (complex APs). + + AdjPhrase : Type = Adjective ** {p : Bool} ; + + adj2adjPhrase : Adjective -> AdjPhrase = \new -> new ** {p = True} ; + + simpleAdjPhrase : Str -> AdjPhrase = \French -> + adj2adjPhrase (regAdjective French) ; + + +--3 Comparison adjectives +-- +-- Each of the comparison forms has a characteristic use: +-- +-- Positive forms are used alone, as adjectival phrases ("big"). + + positAdjPhrase : AdjDegr -> AdjPhrase = \big -> + adj2adjPhrase {s = big.s ! Pos} ; + +-- Comparative forms are used with an object of comparison, as +-- adjectival phrases ("bigger then you"). + + comparAdjPhrase : AdjDegr -> NounPhrase -> AdjPhrase = \big, you -> + {s = \\a => big.s ! Comp ! a ++ "than" ++ you.s ! NomP ; + p = False + } ; + +-- Superlative forms are used with a modified noun, picking out the +-- maximal representative of a domain ("the biggest house"). + + superlNounPhrase : AdjDegr -> CommNoun -> NounPhrase = \big, house -> + {s = \\c => "the" ++ big.s ! Sup ! AAdj ++ house.s ! Sg ! toCase c ; + n = Sg ; + p = P3 + } ; + + +--3 Two-place adjectives +-- +-- A two-place adjective is an adjective with a preposition used before +-- the complement. + + Preposition = Str ; + + AdjCompl = Adjective ** {s2 : Preposition} ; + + complAdj : AdjCompl -> NounPhrase -> AdjPhrase = \related,john -> + {s = \\a => related.s ! a ++ related.s2 ++ john.s ! AccP ; + p = False + } ; + + +--3 Modification of common nouns +-- +-- The two main functions of adjective are in predication ("John is old") +-- and in modification ("an old man"). Predication will be defined +-- later, in the chapter on verbs. +-- +-- Modification must pay attention to pre- and post-noun +-- adjectives: "big car"/"car bigger than X" + + modCommNounPhrase : AdjPhrase -> CommNounPhrase -> CommNounPhrase = \big, car -> + {s = \\n => if_then_else (Case => Str) big.p + (\\c => big.s ! AAdj ++ car.s ! n ! c) + (table {Nom => car.s ! n ! Nom ++ big.s ! AAdj ; Gen => variants {}}) ; + g = car.g + } ; + + +--2 Function expressions + +-- A function expression is a common noun together with the +-- preposition prefixed to its argument ("mother of x"). +-- The type is analogous to two-place adjectives and transitive verbs. + + Function = CommNounPhrase ** {s2 : Preposition} ; + +-- The application of a function gives, in the first place, a common noun: +-- "mother/mothers of John". From this, other rules of the resource grammar +-- give noun phrases, such as "the mother of John", "the mothers of John", +-- "the mothers of John and Mary", and "the mother of John and Mary" (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 = \mother,john -> + {s = \\n => table { + Gen => nonExist ; --- ? + _ => mother.s ! n ! Nom ++ mother.s2 ++ john.s ! GenSP + } ; + g = mother.g + } ; + +-- It is possible to use a function word as a common noun; the semantics is +-- often existential or indexical. + + funAsCommNounPhrase : Function -> CommNounPhrase = + noun2CommNounPhrase ; + +-- The following is an aggregate corresponding to the original function application +-- producing "John's mother" and "the mother of John". It does not appear in the +-- resource grammar API any longer. + + appFun : Bool -> Function -> NounPhrase -> NounPhrase = \coll, mother,john -> + let {n = john.n ; nf = if_then_else Number coll Sg n} in + variants { + defNounPhrase nf (appFunComm mother john) ; + npGenDet nf noNum john mother + } ; + +-- The commonest case is functions with the preposition "of". + + funOf : CommNoun -> Function = \mother -> + mother ** {s2 = "of"} ; + + funOfReg : Str -> Gender -> Function = \mother,g -> + funOf (nounReg mother ** {g = g}) ; + +-- Two-place functions add one argument place. + + Function2 = Function ** {s3 : Preposition} ; + +-- There application starts by filling the first place. + + appFun2 : Function2 -> NounPhrase -> Function = \train, paris -> + {s = \\n,c => train.s ! n ! c ++ train.s2 ++ paris.s ! AccP ; + g = train.g ; + s2 = train.s3 + } ; + + +--2 Verbs +-- +--3 Verb phrases +-- +-- The syntactic verb phrase form type, which includes compound tenses, +-- is defined as follows. + + param + + Tense = Present | Past ; + Anteriority = Simul | Anter ; + VPForm = + VIndic Tense Anteriority Number Person + | VFut Anteriority + | VCondit Anteriority + | VImperat + | VInfinit Anteriority + ; + +-- This is how the syntactic verb phrase forms are realized as +-- inflectional forms of verbs. + + oper + + verbVPForm : Verb -> VPForm -> {fin,inf : Str} = \goes,sf -> + let + tense : Tense -> Number -> Person -> VForm = \t,n,p -> case of { + => Indic p ; + => Indic P2 ; + => Pastt Pl ; + => Pastt n + } ; + have : Tense -> Number -> Person -> Str = \t,n,p -> case of { + => "has" ; + => "have" ; + => "had" + } ; + do : Tense -> Number -> Person -> Str = \t,n,p -> case of { + => "does" ; + => "do" ; + => "did" + } ; + simple : VForm -> {fin,inf : Str} = \v -> { + fin = goes.s ! v ; + inf = [] + } ; + compound : Str -> Str -> {fin,inf : Str} = \x,y -> { + fin = x ; + inf = y + } ; + go : Str = goes.s ! InfImp ; + gone : Str = goes.s ! PPart + in case sf of { + VIndic t Simul n p => simple (tense t n p) ; + VIndic t Anter n p => compound (have t n p) gone ; + VFut Simul => compound "will" go ; + VFut Anter => compound "will" ("have" ++ gone) ; + VCondit Simul => compound "would" go ; + VCondit Anter => compound "would" ("have" ++ gone) ; + VImperat => simple InfImp ; + VInfinit Simul => simple InfImp ; + VInfinit Anter => compound "have" gone + } ; + + + +} ; +{- + useVerb : Verb -> (Number => Str) -> VerbGroup = \verb,arg -> + let go = verbVPForm go + in { + s = \\b,vf => (go sf).fin ; + s2 = \\b,vf => (go sf).inf ; + s3 = arg + } ; + +-- Verb phrases are discontinuous: the three parts of a verb phrase are +-- (s) an inflected verb, (s2) infinitive or participle, and (s3) complement. +-- For instance: "doesn't" - "walk" - ""; "hasn't" - "been" - "old". +-- There's also a parameter telling if the verb is an auxiliary: +-- this is needed in question. + + VerbGroup = { + s : Bool => VPForm => Str ; + s2 : Bool => VPForm => Str ; + s3 : Number => Str ; + isAux : Bool + } ; + + VerbPhrase = { + s : VPForm => Str ; + s2 : VPForm => Str ; + s3 : Number => Str ; + isAux : Bool ; + } ; + + predVerbGroup : Bool -> VerbGroup -> VerbPhrase = \b,vg -> { + s = vg.s ! b ; + s2 = vg.s2 ! b ; + s3 = vg.s3 ; + isAux = vg.isAux + } ; + +-- 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 "don't" are not grammatical. + + predVerb : Verb -> VerbGroup = \walk -> + {s = \\b,v => if_then_Str b + (walk.s ! v ++ walk.s1) + (contractNot (verbP3Do.s ! v)) ; + s2 = \\b,_ => if_then_Str b + [] + (walk.s ! InfImp ++ walk.s1) ; + isAux = False + } ; + +-- Sometimes we want to extract the verb part of a verb phrase. + + verbOfPhrase : VerbPhrase -> VerbP3 = \v -> {s = v.s} ; + +-- Verb phrases can also be formed from adjectives ("is old"), +-- common nouns ("is a man"), and noun phrases ("ist John"). +-- The third rule is overgenerating: "is every man" has to be ruled out +-- on semantic grounds. + + predAdjective : Adjective -> VerbGroup = \old -> + {s = beOrNotBe ; + s2 = \\_,_ => old.s ! AAdj ; + isAux = True + } ; + + predCommNoun : CommNoun -> VerbGroup = \man -> + {s = beOrNotBe ; + s2 = \\_,n => indefNoun n man ; + isAux = True + } ; + + predNounPhrase : NounPhrase -> VerbGroup = \john -> + {s = beOrNotBe ; + s2 = \\_,_ => john.s ! NomP ; + isAux = True + } ; + + predAdverb : Adverb -> VerbGroup = \elsewhere -> + {s = beOrNotBe ; + s2 = \\_,_ => elsewhere.s ; + isAux = True + } ; + +-- We use an auxiliary giving all forms of "be". + + beOrNotBe : Bool => VForm => Str = \\b => + if_then_else (VForm => Str) b + verbBe.s + (table { + InfImp => contractNot "do" ++ "be" ; + Indic P1 => "am" ++ "not" ; + v => contractNot (verbBe.s ! v) + }) ; + +--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*. + + TransVerb : Type = Verb ** {s3 : Preposition} ; + +-- The rule for using transitive verbs is the complementization rule. +-- Particles produce free variation: before or after the complement +-- ("I switch on the TV" / "I switch the TV on"). + + complTransVerb : TransVerb -> NounPhrase -> VerbGroup = \lookat,john -> + let lookatjohn = bothWays lookat.s1 (lookat.s3 ++ john.s ! AccP) + in {s = \\b,v => if_then_Str b (lookat.s ! v) (contractNot (verbP3Do.s ! v)) ; + s2 = \\b,_ => if_then_Str b lookatjohn (lookat.s ! InfImp ++ lookatjohn) ; + isAux = False + } ; + + +-- Verbs that take direct object and a particle: + mkTransVerbPart : VerbP3 -> Str -> TransVerb = \turn,off -> + {s = turn.s ; s1 = off ; s3 = []} ; + +-- Verbs that take prepositional object, no particle: + mkTransVerb : VerbP3 -> Str -> TransVerb = \wait,for -> + {s = wait.s ; s1 = [] ; s3 = for} ; + +-- Verbs that take direct object, no particle: + mkTransVerbDir : VerbP3 -> TransVerb = \love -> + mkTransVerbPart love [] ; + +-- 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 "he is swum", etc. +-- The syntax is the same as for adjectival predication. + + passVerb : Verb -> VerbGroup = \love -> + predAdjective (adj2adjPhrase (regAdjective (love.s ! PPart))) ; + +-- Transitive verbs can also be used reflexively. +-- But to formalize this we must make verb phrases depend on a person parameter. + +--- reflTransVerb : TransVerb -> VerbGroup = \love -> + + +-- Transitive verbs can be used elliptically as verbs. The semantics +-- is left to applications. The definition is trivial, due to record +-- subtyping. + + transAsVerb : TransVerb -> Verb = \love -> + love ; + +-- *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} ; + + mkDitransVerb : Verb -> Preposition -> Preposition -> DitransVerb = \v,p1,p2 -> + v ** {s3 = p1 ; s4 = p2} ; + + complDitransVerb : DitransVerb -> NounPhrase -> NounPhrase -> VerbGroup = + \give,you,beer -> + let + youbeer = give.s1 ++ give.s3 ++ you.s ! AccP ++ give.s4 ++ beer.s ! AccP + in + {s = \\b,v => if_then_Str b (give.s ! v) (contractNot (verbP3Do.s ! v)) ; + s2 = \\b,_ => if_then_Str b youbeer (give.s ! InfImp ++ youbeer) ; + isAux = False + } ; + + +--2 Adverbials +-- +-- Adverbials are not inflected (we ignore comparison, and treat +-- compared adverbials as separate expressions; this could be done another way). +-- We distinguish between post- and pre-verbal adverbs. + + Adverb : Type = SS ** {p : Bool} ; + + advPre : Str -> Adverb = \seldom -> ss seldom ** {p = False} ; + advPost : Str -> Adverb = \well -> ss well ** {p = True} ; + +-- N.B. this rule generates the cyclic parsing rule $VP#2 ::= VP#2$ +-- and cannot thus be parsed. + + adVerbPhrase : VerbPhrase -> Adverb -> VerbPhrase = \sings, well -> + let {postp = orB well.p sings.isAux} in + { + s = \\v => (if_then_else Str postp [] well.s) ++ sings.s ! v ; + s2 = \\n => sings.s2 ! n ++ (if_then_else Str postp well.s []) ; + isAux = sings.isAux + } ; + + advAdjPhrase : SS -> AdjPhrase -> AdjPhrase = \very, good -> + {s = \\a => very.s ++ good.s ! a ; + p = good.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 ("on", "at"). + + prepPhrase : Preposition -> NounPhrase -> Adverb = \on, it -> + advPost (on ++ it.s ! AccP) ; + + locativeNounPhrase : NounPhrase -> Adverb = + prepPhrase "in" ; + +-- This is a source of the "mann with a telescope" ambiguity, and may produce +-- strange things, like "cars always" (while "cars today" is OK). +-- Semantics will have to make finer distinctions among adverbials. +-- +-- N.B. the genitive case created in this way would not make sense. + + advCommNounPhrase : CommNounPhrase -> Adverb -> CommNounPhrase = \car,today -> + {s = \\n => table { + Nom => car.s ! n ! Nom ++ today.s ; + Gen => nonExist + } ; + g = car.g + } ; + + +--2 Sentences +-- +-- Sentences are not inflected in this fragment of English without tense. + + Sentence : Type = SS ; + +-- This is the traditional $S -> NP VP$ rule. It takes care of +-- agreement between subject and verb. Recall that the VP may already +-- contain negation. + + predVerbPhrase : NounPhrase -> VerbPhrase -> Sentence = \john,walks -> + ss (john.s ! NomP ++ indicVerb (verbOfPhrase walks) john.p john.n ++ + walks.s2 ! john.n) ; + + + +--3 Sentence-complement verbs +-- +-- Sentence-complement verbs take sentences as complements. + + SentenceVerb : Type = Verb ; + +-- To generate "says that John walks" / "doesn't say that John walks": + + complSentVerb : SentenceVerb -> Sentence -> VerbGroup = \say,johnruns -> + let {thatjohnruns = optStr "that" ++ johnruns.s} in + {s = \\b,v => if_then_Str b (say.s ! v) (contractNot (verbP3Do.s ! v)) ; + s2 = \\b,_ => if_then_Str b thatjohnruns (say.s ! InfImp ++ thatjohnruns) ; + isAux = False + } ; + +--3 Verb-complement verbs +-- +-- Sentence-complement verbs take verb phrases as complements. +-- They can be auxiliaries ("can", "must") or ordinary verbs +-- ("try"); this distinction cannot be done in the multilingual +-- API and leads to some anomalies in English, such as the necessity +-- to create the infinitive form "to be able to" for "can" so that +-- the construction can be iterated, and the corresponding complication +-- in the parameter structure. + + VerbVerb : Type = Verb ** {isAux : Bool} ; + +-- To generate "can walk"/"can't walk"; "tries to walk"/"does not try to walk": +-- The contraction of "not" is not provided, since it would require changing +-- the verb parameter type. + + complVerbVerb : VerbVerb -> VerbGroup -> VerbGroup = \try,run -> + let + taux = try.isAux ; + to = if_then_Str taux [] "to" ; + dont = table VForm {v => if_then_Str taux + (try.s ! v ++ "not") -- can not + (contractNot (verbP3Do.s ! v)) -- doesn't ... + } ; + trnot = if_then_Str taux + [] -- + (try.s ! InfImp ++ try.s1) ; -- ... try + in + {s = \\b,v => if_then_Str b + (try.s ! v ++ try.s1 ++ to ++ run.s ! True ! InfImp) + (dont ! v) ; + s2 = \\b,v => if_then_Str b + (run.s2 ! True ! v) + (trnot ++ run.s ! True ! InfImp ++ run.s2 ! True ! v) ; + isAux = taux + } ; + +-- The three most important example auxiliaries. + + mkVerbAux : (_,_,_,_: Str) -> VerbVerb = \beable, can, could, beenable -> + {s = table { + InfImp => beable ; + Indic _ => can ; + Past _ => could ; + PPart => beenable + } ; + s1 = [] ; + isAux = True + } ; + + vvCan : VerbVerb = mkVerbAux ["be able to"] "can" "could" ["been able to"] ; + vvMust : VerbVerb = mkVerbAux ["have to"] "must" ["had to"] ["had to"] ; + +--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 a similar relation to sentences as +-- transitive verbs have to verbs: it's like a *sentence taking a complement*. +-- However, we need something more to distinguish its use in direct questions: +-- not just "you see" but ("whom") "do you see". +-- +-- The particle always follows the verb, but the preposition can fly: +-- "whom you make it up with" / "with whom you make it up". + + SentenceSlashNounPhrase = {s : Bool => Str ; s2 : Preposition} ; + + slashTransVerb : Bool -> NounPhrase -> TransVerb -> SentenceSlashNounPhrase = + \b,You,lookat -> + let {you = You.s ! NomP ; + looks = indicVerb {s = lookat.s} You.p You.n ; + look = lookat.s ! InfImp ; + do = indicVerb verbP3Do You.p You.n ; + dont = contractNot do ; + up = lookat.s1 + } in + {s = table { + True => if_then_else Str b do dont ++ you ++ look ++ up ; + False => you ++ if_then_else Str b looks (dont ++ look) ++ up + } ; + s2 = lookat.s3 + } ; + + + thereIs : NounPhrase -> Sentence = \abar -> + predVerbPhrase + (case abar.n of { + Sg => nameNounPhrase (nameReg "there") ; + Pl => {s = \\_ => "there" ; n = Pl ; p = P3} + }) + (predVerbGroup True (predNounPhrase abar)) ; + + +--2 Relative pronouns and relative clauses +-- +-- As described in $types.Eng.gf$, relative pronouns are inflected in +-- gender (human/nonhuman), number, and case. +-- +-- We get the simple relative pronoun ("who"/"which"/"whom"/"whose"/"that"/$""$) +-- from $morpho.Eng.gf$. + + identRelPron : RelPron = relPron ; + + funRelPron : Function -> RelPron -> RelPron = \mother,which -> + {s = \\g,n,c => "the" ++ mother.s ! n ! Nom ++ + mother.s2 ++ which.s ! g ! n ! GenSP + } ; + +-- Relative clauses can be formed from both verb phrases ("who walks") and +-- slash expressions ("whom you see", "on which you sit" / "that you sit on"). + + RelClause : Type = {s : Gender => Number => Str} ; + + relVerbPhrase : RelPron -> VerbPhrase -> RelClause = \who,walks -> + {s = \\g, n => who.s ! g ! n ! NomP ++ + indicVerb (verbOfPhrase walks) P3 n ++ walks.s2 ! n + } ; + + relSlash : RelPron -> SentenceSlashNounPhrase -> RelClause = \who,yousee -> + {s = \\g,n => + let {youSee = yousee.s ! False} in + variants { + who.s ! g ! n ! AccP ++ youSee ++ yousee.s2 ; + yousee.s2 ++ who.s ! g ! n ! GenSP ++ youSee + } + } ; + +-- A 'degenerate' relative clause is the one often used in mathematics, e.g. +-- "number x such that x is even". + + relSuch : Sentence -> RelClause = \A -> + {s = \\_,_ => "such" ++ "that" ++ A.s} ; + +-- 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. No comma is used before these relative clause. + + modRelClause : CommNounPhrase -> RelClause -> CommNounPhrase = \man,whoruns -> + {s = \\n,c => man.s ! n ! c ++ whoruns.s ! man.g ! n ; + g = man.g + } ; + + +--2 Interrogative pronouns +-- +-- If relative pronouns are adjective-like, interrogative pronouns are +-- noun-phrase-like. + + IntPron : Type = {s : NPForm => Str ; 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 = \mother,which -> + {s = \\c => "the" ++ mother.s ! which.n ! Nom ++ mother.s2 ++ which.s ! GenSP ; + n = which.n + } ; + +-- There is a variety of simple interrogative pronouns: +-- "which house", "who", "what". + + nounIntPron : Number -> CommNounPhrase -> IntPron = \n, car -> + {s = \\c => "which" ++ car.s ! n ! toCase c ; + n = n + } ; + + intPronWho : Number -> IntPron = \num -> { + s = table { + NomP => "who" ; + AccP => variants {"who" ; "whom"} ; + GenP => "whose" ; + GenSP => "whom" + } ; + n = num + } ; + + intPronWhat : Number -> IntPron = \num -> { + s = table { + GenP => "what's" ; + _ => "what" + } ; + 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 ++ ".") ; + interrogUtt : Question -> Utterance = \x -> ss (x.s ! DirQ ++ "?") ; + + +--2 Questions +-- +-- Questions are either direct ("are you happy") or indirect +-- ("if/whether you are happy"). + +param + QuestForm = DirQ | IndirQ ; + +oper + Question = SS1 QuestForm ; + +--3 Yes-no questions +-- +-- Yes-no questions are used both independently +-- ("does John walk" / "if John walks") +-- and after interrogative adverbials +-- ("why does John walk" / "why John walks"). +-- +-- It is economical to handle with all these cases by the one +-- rule, $questVerbPhrase'$. The word ("ob" / "whether") never appears +-- if there is an adverbial. + + questVerbPhrase : NounPhrase -> VerbPhrase -> Question = + questVerbPhrase' False ; + + questVerbPhrase' : Bool -> NounPhrase -> VerbPhrase -> Question = + \adv,john,walk -> + {s = table { + DirQ => if_then_else Str walk.isAux + (indicVerb (verbOfPhrase walk) john.p john.n ++ + john.s ! NomP ++ walk.s2 ! john.n) + (indicVerb verbP3Do john.p john.n ++ + john.s ! NomP ++ walk.s ! InfImp ++ walk.s2 ! john.n) ; + IndirQ => if_then_else Str adv [] (variants {"if" ; "whether"}) ++ + (predVerbPhrase john walk).s + } + } ; + + isThere : NounPhrase -> Question = \abar -> + questVerbPhrase + (case abar.n of { + Sg => nameNounPhrase (nameReg "there") ; + Pl => {s = \\_ => "there" ; n = Pl ; p = P3} + }) + (predVerbGroup True (predNounPhrase abar)) ; + + +--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 = \who,walk -> + {s = \\_ => who.s ! NomP ++ indicVerb (verbOfPhrase walk) P3 who.n ++ + walk.s2 ! who.n + } ; + + intSlash : IntPron -> SentenceSlashNounPhrase -> Question = \who,yousee -> + {s = \\q => + let {youSee = case q of { + DirQ => yousee.s ! True ; + IndirQ => yousee.s ! False + } + } in + variants { + who.s ! AccP ++ youSee ++ yousee.s2 ; + yousee.s2 ++ who.s ! GenSP ++ youSee + } + } ; + +--3 Interrogative adverbials +-- +-- These adverbials will be defined in the lexicon: they include +-- "when", "where", "how", "why", 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 : Preposition -> IntPron -> IntAdverb = \at, whom -> + ss (at ++ whom.s ! AccP) ; + +-- A question adverbial can be applied to anything, and whether this makes +-- sense is a semantic question. + + questAdverbial : IntAdverb -> NounPhrase -> VerbPhrase -> Question = + \why, you, walk -> + {s = \\q => why.s ++ (questVerbPhrase' True you walk).s ! q} ; + + +--2 Imperatives +-- +-- We only consider second-person imperatives. + + Imperative = SS1 Number ; + + imperVerbPhrase : VerbPhrase -> Imperative = \walk -> + {s = \\n => walk.s ! InfImp ++ walk.s2 ! n} ; + + imperUtterance : Number -> Imperative -> Utterance = \n,I -> + ss (I.s ! n ++ "!") ; + +--2 Sentence adverbials +-- +-- This class covers adverbials such as "otherwise", "therefore", which are prefixed +-- to a sentence to form a phrase. + + advSentence : SS -> Sentence -> Utterance = \hence,itiseven -> + ss (hence.s ++ itiseven.s ++ ".") ; + + +--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 ("and", "or") or distributed ("both - and", "either - or"). +-- +-- The conjunction has an inherent number, which is used when conjoining +-- noun phrases: "John and Mary are..." vs. "John or Mary is..."; in the +-- case of "or", 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 = SD2 ; + + twoSentence : (_,_ : Sentence) -> ListSentence = CO.twoSS ; + + consSentence : ListSentence -> Sentence -> ListSentence = + CO.consSS 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 = \c,xs -> + ss (CO.conjunctX c xs) ; + +-- To coordinate a list of sentences by a distributed conjunction, we place +-- the first part (e.g. "either") in front of the first element, the second +-- part ("or") between the last two elements, and commas in the other slots. +-- For sentences this is really not used. + + conjunctDistrSentence : ConjunctionDistr -> ListSentence -> Sentence = + \c,xs -> + ss (CO.conjunctDistrX c xs) ; + +--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. + + ListNounPhrase : Type = {s1,s2 : NPForm => Str ; n : Number ; p : Person} ; + + twoNounPhrase : (_,_ : NounPhrase) -> ListNounPhrase = \x,y -> + CO.twoTable NPForm x y ** {n = conjNumber x.n y.n ; p = conjPerson x.p y.p} ; + + 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} ; + + conjunctNounPhrase : Conjunction -> ListNounPhrase -> NounPhrase = \c,xs -> + CO.conjunctTable NPForm c xs ** {n = conjNumber c.n xs.n ; p = xs.p} ; + + conjunctDistrNounPhrase : ConjunctionDistr -> ListNounPhrase -> NounPhrase = + \c,xs -> + CO.conjunctDistrTable NPForm c xs ** {n = conjNumber c.n xs.n ; p = xs.p} ; + +-- 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 let the latter argument win ("either you or I am absent" +-- but "either I or you are absent"). This is not quite clear. + + conjPerson : Person -> Person -> Person = \_,p -> + p ; + + + +--2 Subjunction +-- +-- Subjunctions ("when", "if", 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. +-- +-- There are uniformly two variant word orders, e.g. +-- "if you smoke I get angry" +-- and "I get angry if you smoke". + + Subjunction = SS ; + + subjunctSentence : Subjunction -> Sentence -> Sentence -> Sentence = + \if, A, B -> + ss (subjunctVariants if A.s B.s) ; + + subjunctImperative : Subjunction -> Sentence -> Imperative -> Imperative = + \if, A, B -> + {s = \\n => subjunctVariants if A.s (B.s ! n)} ; + + subjunctQuestion : Subjunction -> Sentence -> Question -> Question = + \if, A, B -> + {s = \\q => subjunctVariants if A.s (B.s ! q)} ; + + subjunctVariants : Subjunction -> Str -> Str -> Str = \if,A,B -> + variants {if.s ++ A ++ "," ++ B ; B ++ "," ++ if.s ++ A} ; + + subjunctVerbPhrase : VerbPhrase -> Subjunction -> Sentence -> VerbPhrase = + \V, if, A -> + adVerbPhrase V (advPost (if.s ++ A.s)) ; + +--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) ; + + useRegularName : SS -> NounPhrase = \john -> + nameNounPhrase (nameReg john.s) ; + +-- Here are some default forms. + + defaultNounPhrase : NounPhrase -> SS = \john -> + ss (john.s ! NomP) ; + + defaultQuestion : Question -> SS = \whoareyou -> + ss (whoareyou.s ! DirQ) ; + + defaultSentence : Sentence -> Utterance = \x -> + x ; + +} ; +-} \ No newline at end of file diff --git a/lib/resource/english/TypesEng.gf b/lib/resource/english/TypesEng.gf new file mode 100644 index 000000000..c2c27d297 --- /dev/null +++ b/lib/resource/english/TypesEng.gf @@ -0,0 +1,104 @@ +--1 English Word Classes and Morphological Parameters +-- +-- This is a resource module for English morphology, defining the +-- morphological parameters and word classes of English. It is aimed +-- to be complete w.r.t. the description of word forms. +-- However, it only includes those parameters that are needed for +-- analysing individual words: such parameters are defined in syntax modules. +-- +-- We use the language-independent prelude. + +resource TypesEng = 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 = NoHum | Hum ; + Case = Nom | Gen ; + Person = P1 | P2 | P3 ; + Degree = Pos | Comp | Sup ; + +-- For data abstraction, we define + +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 often hierarchical. The alternative would be cross-products of +-- simple parameters, but this would usually overgenerate. +-- + +--3 Common nouns +-- +-- Common nouns are inflected in number and case. + + CommonNoun : Type = {s : Number => Case => Str} ; + + +-- +--3 Adjectives +-- +-- The major division is between the comparison degrees, but it +-- is also good to leave room for adjectives that cannon be compared. +-- It is, however, productive to form an adverbial from any adjective. + +param AForm = AAdj | AAdv ; + +oper + Adjective : Type = SS1 AForm ; + AdjDegr = {s : Degree => AForm => Str} ; + +--3 Verbs +-- +-- We treat the full conjugation now. +-- The present tense is made to depend on person, which correspond to forms +-- in the singular; plural forms are uniformly equal to the 2nd person singular. + +param + VForm = InfImp | Indic Person | Pastt Number | PPart ; + +oper + VerbP3 : Type = {s : VForm => Str} ; + +-- A full verb can moreover have a particle. + + Particle : Type = Str ; + Verb = VerbP3 ** {s1 : Particle} ; + +-- +--3 Pronouns +-- +-- For pronouns, we need four case forms: "I" - "me" - "my" - "mine". + +param + NPForm = NomP | AccP | GenP | GenSP ; + +oper + Pronoun : Type = {s : NPForm => Str ; n : Number ; p : Person} ; + +-- Coercions between pronoun cases and ordinaty cases. + + toCase : NPForm -> Case = \c -> case c of {GenP => Gen ; _ => Nom} ; + toNPForm : Case -> NPForm = \c -> case c of {Gen => GenP ; _ => NomP} ; --- + +--3 Proper names +-- +-- Proper names only need two cases. + + ProperName : Type = SS1 Case ; + +--3 Relative pronouns +-- +-- Relative pronouns are inflected in gender (human/nonhuman), number, and case. + + RelPron : Type = {s : Gender => Number => NPForm => Str} ; +} ; + diff --git a/lib/resource/romance/CategoriesRomance.gf b/lib/resource/romance/CategoriesRomance.gf index 563ae2000..6b1ebbf0a 100644 --- a/lib/resource/romance/CategoriesRomance.gf +++ b/lib/resource/romance/CategoriesRomance.gf @@ -35,7 +35,7 @@ lincat n : Number ; p : Person ; c : ClitType} ; PN = {s : Str ; g : Gender} ; Det = {s : Gender => Str ; n : Number} ; - A1 = Adjective ; + A = Adjective ; -- = {s : AForm => Str ; p : Bool} ; A2 = Adjective ** {s2 : Preposition ; c : CaseA} ; ADeg = {s : Degree => AForm => Str ; p : Bool} ; diff --git a/lib/resource/romance/RulesRomance.gf b/lib/resource/romance/RulesRomance.gf index b9dccf45f..21623c904 100644 --- a/lib/resource/romance/RulesRomance.gf +++ b/lib/resource/romance/RulesRomance.gf @@ -5,14 +5,14 @@ incomplete concrete RulesRomance of Rules = CategoriesRomance ** lin UseN = noun2CommNounPhrase ; - ModAdj = modCommNounPhrase ; + ModAP = modCommNounPhrase ; ModGenOne = npGenDet singular ; ModGenNum = npGenDetNum ; UsePN = nameNounPhrase ; UseN2 = funAsCommNounPhrase ; -- [SyntaxFra.noun2CommNounPhrase] AppN2 = appFunComm ; AppN3 = appFun2 ; - UseA1 = adj2adjPhrase ; + UseA = adj2adjPhrase ; ComplA2 = complAdj ; PositADeg = positAdjPhrase ; ComparADeg = comparAdjPhrase ; diff --git a/lib/resource/russian/CategoriesRus.gf b/lib/resource/russian/CategoriesRus.gf index bded5686e..723d412d7 100644 --- a/lib/resource/russian/CategoriesRus.gf +++ b/lib/resource/russian/CategoriesRus.gf @@ -36,7 +36,7 @@ lincat -- g: PronGen ; anim : Animacy ; pron: Bool} ; PN = ProperName ; -- = {s : Case => Str ; g : Gender ; anim : Animacy} ; - A1 = Adjective ; + A = Adjective ; -- = {s : AdjForm => Str} ; A2 = AdjCompl ; -- = Adjective ** Complement ; diff --git a/lib/resource/russian/RulesRus.gf b/lib/resource/russian/RulesRus.gf index 8d4b9e48b..1f1b5a42e 100644 --- a/lib/resource/russian/RulesRus.gf +++ b/lib/resource/russian/RulesRus.gf @@ -6,8 +6,8 @@ lin UsePN = nameNounPhrase ; ComplA2 = complAdj ; PredVP = predVerbPhrase ; - UseA1 = adj2adjPhrase ; - ModAdj = modCommNounPhrase ; + UseA = adj2adjPhrase ; + ModAP = modCommNounPhrase ; UseN = noun2CommNounPhrase ; ModGenOne = npGenDet Sg noNum ; ModGenNum = npGenDet Pl ; diff --git a/lib/resource/swedish/CategoriesSwe.gf b/lib/resource/swedish/CategoriesSwe.gf index 862832c32..254a23e36 100644 --- a/lib/resource/swedish/CategoriesSwe.gf +++ b/lib/resource/swedish/CategoriesSwe.gf @@ -41,7 +41,7 @@ lincat Num = {s : Case => Str} ; Prep = {s : Str} ; - A1 = Adjective ; + A = Adjective ; -- = {s : AdjFormPos => Case => Str} ; A2 = Adjective ** {s2 : Preposition} ; ADeg = {s : AdjForm => Str} ; diff --git a/lib/resource/swedish/RulesSwe.gf b/lib/resource/swedish/RulesSwe.gf index 7f2e801ce..adc85ffca 100644 --- a/lib/resource/swedish/RulesSwe.gf +++ b/lib/resource/swedish/RulesSwe.gf @@ -2,14 +2,14 @@ concrete RulesSwe of Rules = CategoriesSwe ** open Prelude, SyntaxSwe in { lin UseN = noun2CommNounPhrase ; - ModAdj = modCommNounPhrase ; + ModAP = modCommNounPhrase ; ModGenOne = npGenDet singular noNum ; ModGenNum = npGenDet plural ; UsePN = nameNounPhrase ; UseN2 = funAsCommNounPhrase ; AppN2 = appFunComm ; AppN3 = appFun2 ; - UseA1 = adj2adjPhrase ; + UseA = adj2adjPhrase ; ComplA2 = complAdj ; PositADeg = positAdjPhrase ; ComparADeg = comparAdjPhrase ;