mirror of
https://github.com/GrammaticalFramework/gf-core.git
synced 2026-04-23 03:32:51 -06:00
Founding the newly structured GF2.0 cvs archive.
This commit is contained in:
aarne
36
grammars/resource/abstract/Database.gf
Normal file
36
grammars/resource/abstract/Database.gf
Normal file
@@ -0,0 +1,36 @@
|
||||
abstract Database = {
|
||||
|
||||
flags startcat=Query ;
|
||||
|
||||
cat
|
||||
Query ; Phras ; Statement ; Question ;
|
||||
Noun ; Subject ; Value ; Property ; Relation ; Comparison ; Name ;
|
||||
Feature ;
|
||||
|
||||
fun
|
||||
LongForm : Phras -> Query ;
|
||||
ShortForm : Phras -> Query ;
|
||||
|
||||
WhichAre : Noun -> Property -> Phras ;
|
||||
IsThere : Noun -> Phras ;
|
||||
AreThere : Noun -> Phras ;
|
||||
IsIt : Subject -> Property -> Phras ;
|
||||
WhatIs : Value -> Phras ;
|
||||
|
||||
MoreThan : Comparison -> Subject -> Property ;
|
||||
TheMost : Comparison -> Noun -> Value ;
|
||||
Relatively : Comparison -> Noun -> Property ;
|
||||
|
||||
RelatedTo : Relation -> Subject -> Property ;
|
||||
|
||||
Individual : Name -> Subject ;
|
||||
AllN : Noun -> Subject ;
|
||||
Any : Noun -> Subject ;
|
||||
MostN : Noun -> Subject ;
|
||||
EveryN : Noun -> Subject ;
|
||||
|
||||
FeatureOf : Feature -> Subject -> Subject ;
|
||||
ValueOf : Feature -> Name -> Value ;
|
||||
|
||||
WithProperty : Noun -> Property -> Noun ;
|
||||
} ;
|
||||
4
grammars/resource/abstract/PredefAbs.gf
Normal file
4
grammars/resource/abstract/PredefAbs.gf
Normal file
@@ -0,0 +1,4 @@
|
||||
abstract PredefAbs = {
|
||||
cat String ; Int ;
|
||||
} ;
|
||||
|
||||
266
grammars/resource/abstract/ResAbs.gf
Normal file
266
grammars/resource/abstract/ResAbs.gf
Normal file
@@ -0,0 +1,266 @@
|
||||
--1 Abstract Syntax for Multilingual Resource Grammar
|
||||
--
|
||||
-- Aarne Ranta 2002 -- 2003
|
||||
--
|
||||
-- Although concrete syntax differs a lot between different languages,
|
||||
-- many structures can be found that are common, on a certain level
|
||||
-- of abstraction. What we will present in the following is an abstract
|
||||
-- syntax that has been successfully defined for English, French, German,
|
||||
-- Italian, Russian, and Swedish. It has been applied to define language
|
||||
-- fragments on technical or near-to-technical domains: database queries,
|
||||
-- video recorder dialogue systems, software specifications, and a
|
||||
-- health-related phrase book.
|
||||
--
|
||||
-- To use the resource in applications, you need the following
|
||||
-- $cat$ and $fun$ rules in $oper$ form, completed by taking the
|
||||
-- $lincat$ and $lin$ judgements of a particular language. There is
|
||||
-- a GF command for making this translation automatically.
|
||||
|
||||
--2 Categories
|
||||
--
|
||||
-- The categories of this resource grammar are mostly 'standard' categories
|
||||
-- of linguistics. Their is no claim that they correspond to semantic categories
|
||||
-- definable in type theory: to define such correspondences it the business
|
||||
-- of applications grammars.
|
||||
--
|
||||
-- Categories that may look special are $Adj2$, $Fun$, and $TV$. They are all
|
||||
-- instances of endowing another category with a complement, which can be either
|
||||
-- a direct object (whose case may vary) or a prepositional phrase. This, together
|
||||
-- with the category $Adv$, removes the need of a category of
|
||||
-- 'prepositional phrases', which is too language-dependent to make sense
|
||||
-- on this level of abstraction.
|
||||
--
|
||||
|
||||
abstract ResAbs = {
|
||||
|
||||
--3 Nouns and noun phrases
|
||||
--
|
||||
|
||||
cat
|
||||
N ; -- simple common noun, e.g. "car"
|
||||
CN ; -- common noun phrase, e.g. "red car", "car that John owns"
|
||||
NP ; -- noun phrase, e.g. "John", "all cars", "you"
|
||||
PN ; -- proper name, e.g. "John", "New York"
|
||||
Det ; -- determiner, e.g. "every", "all"
|
||||
Fun ; -- function word, e.g. "mother (of)"
|
||||
Fun2 ; -- two-place function, e.g. "flight (from) (to)"
|
||||
|
||||
--3 Adjectives and adjectival phrases
|
||||
--
|
||||
|
||||
Adj1 ; -- one-place adjective, e.g. "even"
|
||||
Adj2 ; -- two-place adjective, e.g. "divisible (by)"
|
||||
AdjDeg ; -- degree adjective, e.g. "big/bigger/biggest"
|
||||
AP ; -- adjective phrase, e.g. "divisible by two", "bigger than John"
|
||||
|
||||
--3 Verbs and verb phrases
|
||||
--
|
||||
|
||||
V ; -- one-place verb, e.g. "walk"
|
||||
TV ; -- two-place verb, e.g. "love", "wait (for)", "switch on"
|
||||
VS ; -- sentence-compl. verb e.g. "say", "prove"
|
||||
VP ; -- verb phrase, e.g. "switch the light on"
|
||||
|
||||
--3 Adverbials
|
||||
--
|
||||
|
||||
AdV ; -- adverbial e.g. "now", "in the house"
|
||||
AdA ; -- ad-adjective e.g. "very"
|
||||
AdS ; -- sentence adverbial e.g. "therefore", "otherwise"
|
||||
|
||||
--3 Sentences and relative clauses
|
||||
--
|
||||
|
||||
S ; -- sentence, e.g. "John walks"
|
||||
Slash ; -- sentence without NP, e.g. "John waits for (...)"
|
||||
RP ; -- relative pronoun, e.g. "which", "the mother of whom"
|
||||
RC ; -- relative clause, e.g. "who walks", "that I wait for"
|
||||
|
||||
--3 Questions and imperatives
|
||||
--
|
||||
|
||||
IP ; -- interrogative pronoun, e.g. "who", "whose mother", "which yellow car"
|
||||
IAdv ; -- interrogative adverb., e.g. "when", "why"
|
||||
Qu ; -- question, e.g. "who walks"
|
||||
Imp ; -- imperative, e.g. "walk!"
|
||||
|
||||
--3 Coordination and subordination
|
||||
--
|
||||
|
||||
Conj ; -- conjunction, e.g. "and"
|
||||
ConjD ; -- distributed conj. e.g. "both - and"
|
||||
Subj ; -- subjunction, e.g. "if", "when"
|
||||
|
||||
ListS ; -- list of sentences
|
||||
ListAP ; -- list of adjectival phrases
|
||||
ListNP ; -- list of noun phrases
|
||||
|
||||
--3 Complete utterances
|
||||
--
|
||||
|
||||
Phr ; -- full phrase, e.g. "John walks.","Who walks?", "Wait for me!"
|
||||
Text ; -- sequence of phrases e.g. "One is odd. Therefore, two is even."
|
||||
|
||||
--2 Rules
|
||||
--
|
||||
-- This set of rules is minimal, in the sense defining the simplest combinations
|
||||
-- of categories and of not having redundant rules.
|
||||
-- When the resource grammar is used as a library, it will often be useful to
|
||||
-- access it through an intermediate library that defines more rules as
|
||||
-- combinations of the ones below.
|
||||
|
||||
--3 Nouns and noun phrases
|
||||
--
|
||||
|
||||
fun
|
||||
UseN : N -> CN ; -- "car"
|
||||
ModAdj : AP -> CN -> CN ; -- "red car"
|
||||
DetNP : Det -> CN -> NP ; -- "every car"
|
||||
IndefOneNP, IndefManyNP : CN -> NP ; -- "a car", "cars"
|
||||
DefOneNP, DefManyNP : CN -> NP ; -- "the car", "the cars"
|
||||
ModGenOne, ModGenMany : NP -> CN -> NP ; -- "John's car", "John's cars"
|
||||
UsePN : PN -> NP ; -- "John"
|
||||
UseFun : Fun -> CN ; -- "successor"
|
||||
AppFun : Fun -> NP -> CN ; -- "successor of zero"
|
||||
AppFun2 : Fun2 -> NP -> Fun ; -- "flight from Paris"
|
||||
CNthatS : CN -> S -> CN ; -- "idea that the Earth is flat"
|
||||
|
||||
--3 Adjectives and adjectival phrases
|
||||
--
|
||||
|
||||
AdjP1 : Adj1 -> AP ; -- "red"
|
||||
ComplAdj : Adj2 -> NP -> AP ; -- "divisible by two"
|
||||
PositAdjP : AdjDeg -> AP ; -- "old"
|
||||
ComparAdjP : AdjDeg -> NP -> AP ; -- "older than John"
|
||||
SuperlNP : AdjDeg -> CN -> NP ; -- "the oldest man"
|
||||
|
||||
--3 Verbs and verb phrases
|
||||
--
|
||||
|
||||
PosV, NegV : V -> VP ; -- "walk", "doesn't walk"
|
||||
PosA, NegA : AP -> VP ; -- "is old", "isn't old"
|
||||
PosCN, NegCN : CN -> VP ; -- "is a man", "isn't a man"
|
||||
PosTV, NegTV : TV -> NP -> VP ; -- "sees John", "doesn't see John"
|
||||
PosPassV, NegPassV : V -> VP ; -- "is seen", "is not seen"
|
||||
PosNP, NegNP : NP -> VP ; -- "is John", "is not John"
|
||||
PosVS, NegVS : VS -> S -> VP ; -- "says that I run", "doesn't say..."
|
||||
|
||||
--3 Adverbials
|
||||
--
|
||||
|
||||
AdvVP : VP -> AdV -> VP ; -- "always walks", "walks in the park"
|
||||
LocNP : NP -> AdV ; -- "in London"
|
||||
AdvCN : CN -> AdV -> CN ; -- "house in London", "house today"
|
||||
|
||||
AdvAP : AdA -> AP -> AP ; -- "very good"
|
||||
|
||||
|
||||
--3 Sentences and relative clauses
|
||||
--
|
||||
|
||||
PredVP : NP -> VP -> S ; -- "John walks"
|
||||
PosSlashTV, NegSlashTV : NP -> TV -> Slash ; -- "John sees", "John doesn's see"
|
||||
OneVP : VP -> S ; -- "one walks"
|
||||
|
||||
IdRP : RP ; -- "which"
|
||||
FunRP : Fun -> RP -> RP ; -- "the successor of which"
|
||||
RelVP : RP -> VP -> RC ; -- "who walks"
|
||||
RelSlash : RP -> Slash -> RC ; -- "that I wait for"/"for which I wait"
|
||||
ModRC : CN -> RC -> CN ; -- "man who walks"
|
||||
RelSuch : S -> RC ; -- "such that it is even"
|
||||
|
||||
--3 Questions and imperatives
|
||||
--
|
||||
|
||||
WhoOne, WhoMany : IP ; -- "who (is)", "who (are)"
|
||||
WhatOne, WhatMany : IP ; -- "what (is)", "what (are)"
|
||||
FunIP : Fun -> IP -> IP ; -- "the mother of whom"
|
||||
NounIPOne, NounIPMany : CN -> IP ; -- "which car", "which cars"
|
||||
|
||||
QuestVP : NP -> VP -> Qu ; -- "does John walk"
|
||||
IntVP : IP -> VP -> Qu ; -- "who walks"
|
||||
IntSlash : IP -> Slash -> Qu ; -- "whom does John see"
|
||||
QuestAdv : IAdv -> NP -> VP -> Qu ; -- "why do you walk"
|
||||
|
||||
ImperVP : VP -> Imp ; -- "be a man"
|
||||
|
||||
IndicPhrase : S -> Phr ; -- "I walk."
|
||||
QuestPhrase : Qu -> Phr ; -- "Do I walk?"
|
||||
ImperOne, ImperMany : Imp -> Phr ; -- "Be a man!", "Be men!"
|
||||
|
||||
AdvS : AdS -> S -> Phr ; -- "Therefore, 2 is prime."
|
||||
|
||||
--3 Coordination
|
||||
--
|
||||
-- We consider "n"-ary coordination, with "n" > 1. To this end, we have introduced
|
||||
-- a *list category* $ListX$ for each category $X$ whose expressions we want to
|
||||
-- conjoin. Each list category has two constructors, the base case being $TwoX$.
|
||||
|
||||
-- We have not defined coordination of all possible categories here,
|
||||
-- since it can be tricky in many languages. For instance, $VP$ coordination
|
||||
-- is linguistically problematic in German because $VP$ is a discontinuous
|
||||
-- category.
|
||||
|
||||
ConjS : Conj -> ListS -> S ; -- "John walks and Mary runs"
|
||||
ConjAP : Conj -> ListAP -> AP ; -- "even and prime"
|
||||
ConjNP : Conj -> ListNP -> NP ; -- "John or Mary"
|
||||
|
||||
ConjDS : ConjD -> ListS -> S ; -- "either John walks or Mary runs"
|
||||
ConjDAP : ConjD -> ListAP -> AP ; -- "both even and prime"
|
||||
ConjDNP : ConjD -> ListNP -> NP ; -- "either John or Mary"
|
||||
|
||||
TwoS : S -> S -> ListS ;
|
||||
ConsS : ListS -> S -> ListS ;
|
||||
|
||||
TwoAP : AP -> AP -> ListAP ;
|
||||
ConsAP : ListAP -> AP -> ListAP ;
|
||||
|
||||
TwoNP : NP -> NP -> ListNP ;
|
||||
ConsNP : ListNP -> NP -> ListNP ;
|
||||
|
||||
--3 Subordination
|
||||
--
|
||||
-- Subjunctions are different from conjunctions, but form
|
||||
-- a uniform category among themselves.
|
||||
|
||||
SubjS : Subj -> S -> S -> S ; -- "if 2 is odd, 3 is even"
|
||||
SubjImper : Subj -> S -> Imp -> Imp ; -- "if it is hot, use a glove!"
|
||||
SubjQu : Subj -> S -> Qu -> Qu ; -- "if you are new, who are you?"
|
||||
|
||||
--2 One-word utterances
|
||||
--
|
||||
-- These are, more generally, *one-phrase utterances*. The list below
|
||||
-- is very incomplete.
|
||||
|
||||
PhrNP : NP -> Phr ; -- "Some man.", "John."
|
||||
PhrOneCN, PhrManyCN : CN -> Phr ; -- "A car.", "Cars."
|
||||
PhrIP : IAdv -> Phr ; -- "Who?"
|
||||
PhrIAdv : IAdv -> Phr ; -- "Why?"
|
||||
|
||||
--2 Text formation
|
||||
--
|
||||
-- A text is a sequence of phrases. It is defined like a non-empty list.
|
||||
|
||||
OnePhr : Phr -> Text ;
|
||||
ConsPhr : Phr -> Text -> Text ;
|
||||
|
||||
--2 Examples of structural words
|
||||
--
|
||||
-- Here we have some words belonging to closed classes and appearing
|
||||
-- in all languages we have considered.
|
||||
-- Sometimes they are not really meaningful, e.g. $TheyNP$ in French
|
||||
-- should really be replaced by masculine and feminine variants.
|
||||
|
||||
EveryDet, AllDet, WhichDet, MostDet : Det ; -- every, all, which, most
|
||||
INP, ThouNP, HeNP, SheNP, ItNP : NP ; -- personal pronouns in singular
|
||||
WeNP, YeNP, TheyNP : NP ; -- personal pronouns in plural
|
||||
YouNP : NP ; -- the polite you
|
||||
WhenIAdv,WhereIAdv,WhyIAdv,HowIAdv : IAdv ; -- when, where, why, how
|
||||
AndConj, OrConj : Conj ; -- and, or
|
||||
BothAnd, EitherOr, NeitherNor : ConjD ; -- both-and, either-or, neither-nor
|
||||
IfSubj, WhenSubj : Subj ; -- if, when
|
||||
PhrYes, PhrNo : Phr ; -- yes, no
|
||||
VeryAdv, TooAdv : AdA ; -- very, too
|
||||
OtherwiseAdv, ThereforeAdv : AdS ; -- therefore, otherwise
|
||||
} ;
|
||||
|
||||
15
grammars/resource/abstract/Restaurant.gf
Normal file
15
grammars/resource/abstract/Restaurant.gf
Normal file
@@ -0,0 +1,15 @@
|
||||
abstract Restaurant = Database ** {
|
||||
|
||||
fun
|
||||
Restaurant, Bar : Noun ;
|
||||
French, Italian, Indian, Japanese : Property ;
|
||||
address, phone, priceLevel : Feature ;
|
||||
Cheap, Expensive : Comparison ;
|
||||
|
||||
WhoRecommend : Name -> Phras ;
|
||||
WhoHellRecommend : Name -> Phras ;
|
||||
|
||||
|
||||
-- examples of restaurant names
|
||||
LucasCarton : Name ;
|
||||
} ;
|
||||
15
grammars/resource/abstract/TestAbs.gf
Normal file
15
grammars/resource/abstract/TestAbs.gf
Normal file
@@ -0,0 +1,15 @@
|
||||
abstract TestAbs = ResAbs ** {
|
||||
|
||||
-- a random sample of lexicon to test resource grammar with
|
||||
|
||||
fun
|
||||
Big, Small, Old, Young : AdjDeg ;
|
||||
Man, Woman, Car, House, Light : N ;
|
||||
Walk, Run : V ;
|
||||
Send, Wait, Love, SwitchOn, SwitchOff : TV ;
|
||||
Say, Prove : VS ;
|
||||
Mother, Uncle : Fun ;
|
||||
Connection : Fun2 ;
|
||||
Well, Always : AdV ;
|
||||
John, Mary : PN ;
|
||||
} ;
|
||||
51
grammars/resource/english/DatabaseEng.gf
Normal file
51
grammars/resource/english/DatabaseEng.gf
Normal file
@@ -0,0 +1,51 @@
|
||||
concrete DatabaseEng of Database = open Prelude,Syntax,English,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 = UsePN ;
|
||||
|
||||
AllN = DetNP AllDet ;
|
||||
MostN = DetNP MostDet ;
|
||||
EveryN = DetNP EveryDet ;
|
||||
|
||||
-- only these are language-dependent
|
||||
|
||||
Any = detNounPhrase anyPlDet ; ---
|
||||
|
||||
IsThere A = mkSentPrel ["is there"] (defaultNounPhrase (IndefOneNP A)) ;
|
||||
AreThere A = mkSentPrel ["are there"] (defaultNounPhrase (IndefManyNP A)) ;
|
||||
|
||||
WhatIs V = mkSentPrel ["what is"] (defaultNounPhrase V) ;
|
||||
|
||||
} ;
|
||||
11
grammars/resource/english/DatabaseEngRes.gf
Normal file
11
grammars/resource/english/DatabaseEngRes.gf
Normal file
@@ -0,0 +1,11 @@
|
||||
resource DatabaseEngRes = 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/english/English.gf
Normal file
1
grammars/resource/english/English.gf
Normal file
@@ -0,0 +1 @@
|
||||
resource English = reuse ResEng ;
|
||||
150
grammars/resource/english/Morpho.gf
Normal file
150
grammars/resource/english/Morpho.gf
Normal file
@@ -0,0 +1,150 @@
|
||||
--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.Eng.gf$.
|
||||
|
||||
resource Morpho = Types ** open Prelude 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'") ;
|
||||
|
||||
--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 ;
|
||||
|
||||
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
|
||||
--
|
||||
-- For the comparison of adjectives, three forms are needed in the worst case.
|
||||
|
||||
mkAdjDegr : (_,_,_ : Str) -> AdjDegr = \good,better,best ->
|
||||
{s = table {Pos => good ; Comp => better ; Sup => best}} ;
|
||||
|
||||
adjDegrReg : Str -> AdjDegr = \long ->
|
||||
mkAdjDegr long (long + "er") (long + "est") ;
|
||||
|
||||
adjDegrY : Str -> AdjDegr = \lovel ->
|
||||
mkAdjDegr (lovel + "y") (lovel + "ier") (lovel + "iest") ;
|
||||
|
||||
-- Many adjectives are 'inflected' by adding a comparison word.
|
||||
|
||||
adjDegrLong : Str -> AdjDegr = \ridiculous ->
|
||||
mkAdjDegr ridiculous ("more" ++ ridiculous) ("most" ++ ridiculous) ;
|
||||
|
||||
-- simple adjectives are just strings
|
||||
|
||||
simpleAdj : Str -> Adjective = ss ;
|
||||
|
||||
--3 Verbs
|
||||
--
|
||||
-- Except for "be", the worst case needs two forms.
|
||||
|
||||
mkVerbP3 : (_,_: Str) -> VerbP3 = \goes,go ->
|
||||
{s = table {InfImp => go ; Indic P3 => goes ; Indic _ => go}} ;
|
||||
|
||||
regVerbP3 : Str -> VerbP3 = \walk ->
|
||||
mkVerbP3 (walk + "s") walk ;
|
||||
|
||||
verbP3s : Str -> VerbP3 = \kiss ->
|
||||
mkVerbP3 (kiss + "es") kiss ;
|
||||
|
||||
verbP3y : Str -> VerbP3 = \fl ->
|
||||
mkVerbP3 (fl + "ies") (fl + "y") ;
|
||||
|
||||
verbP3Have = mkVerbP3 "has" "have" ;
|
||||
|
||||
verbP3Do = verbP3s "do" ;
|
||||
|
||||
verbBe : VerbP3 = {s = table {
|
||||
InfImp => "be" ;
|
||||
Indic P1 => "am" ;
|
||||
Indic P2 => "are" ;
|
||||
Indic P3 => "is"
|
||||
}} ;
|
||||
|
||||
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) ;
|
||||
} ;
|
||||
|
||||
229
grammars/resource/english/Paradigms.gf
Normal file
229
grammars/resource/english/Paradigms.gf
Normal file
@@ -0,0 +1,229 @@
|
||||
--1 English 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.Eng.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, Syntax, English in {
|
||||
|
||||
--2 Parameters
|
||||
--
|
||||
-- To abstract over gender names, we define the following identifiers.
|
||||
|
||||
oper
|
||||
human : Gender ;
|
||||
nonhuman : Gender ;
|
||||
|
||||
-- To abstract over number names, we define the following.
|
||||
|
||||
singular : Number ;
|
||||
plural : Number ;
|
||||
|
||||
|
||||
--2 Nouns
|
||||
|
||||
-- Worst case: give all four forms and the semantic gender.
|
||||
-- In practice the worst case is just: give singular and plural nominative.
|
||||
|
||||
oper
|
||||
mkN : (man,men,man's,men's : Str) -> Gender -> N ;
|
||||
nMan : (man,men : Str) -> Gender -> N ;
|
||||
|
||||
-- Regular nouns, nouns ending with "s", "y", or "o", and nouns with the same
|
||||
-- plural form as the singular.
|
||||
|
||||
nReg : Str -> Gender -> N ; -- dog, dogs
|
||||
nKiss : Str -> Gender -> N ; -- kiss, kisses
|
||||
nFly : Str -> Gender -> N ; -- fly, flies
|
||||
nHero : Str -> Gender -> N ; -- hero, heroes (= nKiss !)
|
||||
nSheep : Str -> Gender -> N ; -- sheep, sheep
|
||||
|
||||
-- These use general heuristics, that recognizes the last letter. *N.B* it
|
||||
-- does not get right with "boy", "rush", since it only looks at one letter.
|
||||
|
||||
nHuman : Str -> N ; -- gambler/actress/nanny
|
||||
nNonhuman : Str -> N ; -- dog/kiss/fly
|
||||
|
||||
-- Nouns used as functions need a preposition. The most common is "of".
|
||||
|
||||
mkFun : N -> Preposition -> Fun ;
|
||||
|
||||
funHuman : Str -> Fun ; -- the father/mistress/daddy of
|
||||
funNonhuman : Str -> Fun ; -- the successor/address/copy of
|
||||
|
||||
-- Proper names, with their regular genitive.
|
||||
|
||||
pnReg : (John : Str) -> PN ; -- John, John's
|
||||
|
||||
-- The most common cases on the top level havee shortcuts.
|
||||
-- The regular "y"/"s" variation is taken into account in $CN$.
|
||||
|
||||
cnNonhuman : Str -> CN ;
|
||||
cnHuman : Str -> CN ;
|
||||
npReg : Str -> NP ;
|
||||
|
||||
|
||||
--2 Adjectives
|
||||
|
||||
-- Non-comparison one-place adjectives just have one form.
|
||||
|
||||
mkAdj1 : (even : Str) -> Adj1 ;
|
||||
|
||||
-- Two-place adjectives need a preposition as second argument.
|
||||
|
||||
mkAdj2 : (divisible, by : Str) -> Adj2 ;
|
||||
|
||||
-- Comparison adjectives have three forms. The common irregular
|
||||
-- cases are ones ending with "y" and a consonant that is duplicated.
|
||||
|
||||
mkAdjDeg : (good,better,best : Str) -> AdjDeg ;
|
||||
|
||||
aReg : (long : Str) -> AdjDeg ; -- long, longer, longest
|
||||
aHappy : (happy : Str) -> AdjDeg ; -- happy, happier, happiest
|
||||
aFat : (fat : Str) -> AdjDeg ; -- fat, fatter, fattest
|
||||
aRidiculous : (ridiculous : Str) -> AdjDeg ; -- -/more/most ridiculous
|
||||
|
||||
-- On top level, there are adjectival phrases. The most common case is
|
||||
-- just to use a one-place adjective.
|
||||
|
||||
apReg : Str -> AP ;
|
||||
|
||||
|
||||
--2 Verbs
|
||||
--
|
||||
-- The fragment only has present tense so far, but in all persons.
|
||||
-- Except for "be", the worst case needs two forms: the infinitive and
|
||||
-- the third person singular.
|
||||
|
||||
mkV : (go, goes : Str) -> V ;
|
||||
|
||||
vReg : (walk : Str) -> V ; -- walk, walks
|
||||
vKiss : (kiss : Str) -> V ; -- kiss, kisses
|
||||
vFly : (fly : Str) -> V ; -- fly, flies
|
||||
vGo : (go : Str) -> V ; -- go, goes (= vKiss !)
|
||||
|
||||
-- This generic function recognizes the special cases where the last
|
||||
-- character is "y", "s", or "z". It is not right for "finish" and "convey".
|
||||
|
||||
vGen : Str -> V ; -- walk/kiss/fly
|
||||
|
||||
-- The verbs "be" and "have" are special.
|
||||
|
||||
vBe : V ;
|
||||
vHave : V ;
|
||||
|
||||
-- Verbs with a particle.
|
||||
|
||||
vPart : (go, goes, up : Str) -> V ;
|
||||
vPartReg : (get, up : Str) -> V ;
|
||||
|
||||
-- Two-place verbs, and the special case with direct object.
|
||||
-- Notice that a particle can already be included in $V$.
|
||||
|
||||
mkTV : V -> Str -> TV ; -- look for, kill
|
||||
|
||||
tvGen : (look, for : Str) -> TV ; -- look for, talk about
|
||||
tvDir : V -> TV ; -- switch off
|
||||
tvGenDir : (kill : Str) -> TV ; -- kill
|
||||
|
||||
-- Regular two-place verbs with a particle.
|
||||
|
||||
tvPartReg : Str -> Str -> Str -> TV ; -- get, along, with
|
||||
|
||||
-- The definitions should not bother the user of the API. So they are
|
||||
-- hidden from the document.
|
||||
--.
|
||||
|
||||
human = Hum ;
|
||||
nonhuman = NoHum ;
|
||||
-- singular defined in types.Eng
|
||||
-- plural defined in types.Eng
|
||||
|
||||
nominative = Nom ;
|
||||
|
||||
mkN = \man,men,man's,men's,g -> mkNoun man men man's men's ** {g = g} ;
|
||||
nReg = addGenN nounReg ;
|
||||
nKiss = addGenN nounS ;
|
||||
nFly = \fly -> addGenN nounY (Predef.tk 1 fly) ;
|
||||
nMan = \man,men -> mkN man men (man + "'s") (men + "'s") ;
|
||||
nHero = nKiss ;
|
||||
nSheep = \sheep -> nMan sheep sheep ;
|
||||
|
||||
nHuman = \s -> nGen s Hum ;
|
||||
nNonhuman = \s -> nGen s NoHum ;
|
||||
|
||||
nGen : Str -> Gender -> N = \fly,g -> let {
|
||||
fl = Predef.tk 1 fly ;
|
||||
y = Predef.dp 1 fly ;
|
||||
eqy = ifTok (Str -> Gender -> N) y
|
||||
} in
|
||||
eqy "y" nFly (
|
||||
eqy "s" nKiss (
|
||||
eqy "z" nKiss (
|
||||
nReg))) fly g ;
|
||||
|
||||
mkFun = \n,p -> n ** {s2 = p} ;
|
||||
funNonhuman = \s -> mkFun (nNonhuman s) "of" ;
|
||||
funHuman = \s -> mkFun (nHuman s) "of" ;
|
||||
|
||||
pnReg = nameReg ;
|
||||
|
||||
cnNonhuman = \s -> UseN (nGen s nonhuman) ;
|
||||
cnHuman = \s -> UseN (nGen s human) ;
|
||||
npReg = \s -> UsePN (pnReg s) ;
|
||||
|
||||
addGenN : (Str -> CommonNoun) -> Str -> Gender -> N = \f ->
|
||||
\s,g -> f s ** {g = g} ;
|
||||
|
||||
mkAdj1 = simpleAdj ;
|
||||
mkAdj2 = \s,p -> simpleAdj s ** {s2 = p} ;
|
||||
mkAdjDeg = mkAdjDegr ;
|
||||
aReg = adjDegrReg ;
|
||||
aHappy = \happy -> adjDegrY (Predef.tk 1 happy) ;
|
||||
aFat = \fat -> let {fatt = fat + Predef.dp 1 fat} in
|
||||
mkAdjDeg fat (fatt + "er") (fatt + "est") ;
|
||||
aRidiculous = adjDegrLong ;
|
||||
apReg = \s -> AdjP1 (mkAdj1 s) ;
|
||||
|
||||
mkV = \go,goes -> verbNoPart (mkVerbP3 goes go) ;
|
||||
vReg = \run -> mkV run (run + "s") ;
|
||||
vKiss = \kiss -> mkV kiss (kiss + "es") ;
|
||||
vFly = \fly -> mkV fly (Predef.tk 1 fly + "ies") ;
|
||||
vGo = vKiss ;
|
||||
|
||||
vGen = \fly -> let {
|
||||
fl = Predef.tk 1 fly ;
|
||||
y = Predef.dp 1 fly ;
|
||||
eqy = ifTok (Str -> V) y
|
||||
} in
|
||||
eqy "y" vFly (
|
||||
eqy "s" vKiss (
|
||||
eqy "z" vKiss (
|
||||
vReg))) fly ;
|
||||
|
||||
vPart = \go, goes, up -> verbPart (mkVerbP3 goes go) up ;
|
||||
vPartReg = \get, up -> verbPart (regVerbP3 get) up ;
|
||||
|
||||
mkTV = \v,p -> v ** {s3 = p} ;
|
||||
tvPartReg = \get, along, with -> mkTV (vPartReg get along) with ;
|
||||
|
||||
vBe = verbBe ;
|
||||
vHave = mkV "have" "has" ;
|
||||
|
||||
tvGen = \s,p -> mkTV (vGen s) p ;
|
||||
tvDir = \v -> mkTV v [] ;
|
||||
tvGenDir = \s -> tvDir (vGen s) ;
|
||||
|
||||
} ;
|
||||
83
grammars/resource/english/Predication.gf
Normal file
83
grammars/resource/english/Predication.gf
Normal file
@@ -0,0 +1,83 @@
|
||||
|
||||
--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 English 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"
|
||||
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"
|
||||
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) ;
|
||||
appFunColl = \f, x, y -> DefOneNP (AppFun f (conjNP x y)) ;
|
||||
|
||||
appFam1 = \F, x -> AppFun F x ;
|
||||
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) ;
|
||||
|
||||
} ;
|
||||
195
grammars/resource/english/ResEng.gf
Normal file
195
grammars/resource/english/ResEng.gf
Normal file
@@ -0,0 +1,195 @@
|
||||
--1 The Top-Level English Resource Grammar
|
||||
--
|
||||
-- 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 $types.Eng.gf$.
|
||||
|
||||
concrete ResEng of ResAbs = open Prelude, Syntax in {
|
||||
|
||||
flags
|
||||
startcat=Phr ;
|
||||
parser=chart ;
|
||||
|
||||
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 = CommNounPhrase ** {s2 : Preposition} ;
|
||||
|
||||
Adj1 = Adjective ;
|
||||
-- = {s : Str}
|
||||
Adj2 = Adjective ** {s2 : Preposition} ;
|
||||
AdjDeg = {s : Degree => Str} ;
|
||||
AP = Adjective ** {p : Bool} ;
|
||||
|
||||
V = Verb ;
|
||||
-- = {s : VForm => Str ; s1 : Particle}
|
||||
VP = {s : VForm => Str ; s2 : Number => Str ; isAux : Bool} ;
|
||||
TV = Verb ** {s3 : Preposition} ;
|
||||
VS = Verb ;
|
||||
|
||||
AdV = {s : Str ; isPost : 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} ;
|
||||
|
||||
Conj = {s : Str ; n : Number} ;
|
||||
ConjD = {s1 : Str ; s2 : Str ; n : Number} ;
|
||||
|
||||
ListS = {s1 : Str ; s2 : Str} ;
|
||||
ListAP = {s1 : Str ; s2 : Str ; p : Bool} ;
|
||||
ListNP = {s1,s2 : NPForm => Str ; n : Number ; p : Person} ;
|
||||
|
||||
--.
|
||||
|
||||
lin
|
||||
UseN = noun2CommNounPhrase ;
|
||||
ModAdj = modCommNounPhrase ;
|
||||
ModGenOne = npGenDet singular ;
|
||||
ModGenMany = npGenDet plural ;
|
||||
UsePN = nameNounPhrase ;
|
||||
UseFun = funAsCommNounPhrase ;
|
||||
AppFun = appFunComm ;
|
||||
AdjP1 = adj2adjPhrase ;
|
||||
ComplAdj = complAdj ;
|
||||
PositAdjP = positAdjPhrase ;
|
||||
ComparAdjP = comparAdjPhrase ;
|
||||
SuperlNP = superlNounPhrase ;
|
||||
|
||||
DetNP = detNounPhrase ;
|
||||
IndefOneNP = indefNounPhrase singular ;
|
||||
IndefManyNP = indefNounPhrase plural ;
|
||||
DefOneNP = defNounPhrase singular ;
|
||||
DefManyNP = defNounPhrase plural ;
|
||||
|
||||
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 ;
|
||||
PosNP = predNounPhrase True ;
|
||||
NegNP = predNounPhrase False ;
|
||||
PosVS = complSentVerb True ;
|
||||
NegVS = complSentVerb False ;
|
||||
|
||||
|
||||
AdvVP = adVerbPhrase ;
|
||||
LocNP = locativeNounPhrase ;
|
||||
AdvCN = advCommNounPhrase ;
|
||||
|
||||
PosSlashTV = slashTransVerb True ;
|
||||
NegSlashTV = slashTransVerb False ;
|
||||
|
||||
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 ;
|
||||
|
||||
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 ;
|
||||
|
||||
|
||||
lin
|
||||
INP = pronI ;
|
||||
ThouNP = pronYouSg ;
|
||||
HeNP = pronHe ;
|
||||
SheNP = pronShe ;
|
||||
WeNP = pronWe ;
|
||||
YeNP = pronYouPl ;
|
||||
YouNP = pronYouSg ;
|
||||
TheyNP = pronThey ;
|
||||
|
||||
EveryDet = everyDet ;
|
||||
AllDet = allDet ;
|
||||
WhichDet = whichDet ;
|
||||
MostDet = mostDet ;
|
||||
|
||||
HowIAdv = ss "how" ;
|
||||
WhenIAdv = ss "when" ;
|
||||
WhereIAdv = ss "where" ;
|
||||
WhyIAdv = ss "why" ;
|
||||
|
||||
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" ;
|
||||
|
||||
PhrYes = ss "Yes." ;
|
||||
PhrNo = ss "No." ;
|
||||
} ;
|
||||
25
grammars/resource/english/RestaurantEng.gf
Normal file
25
grammars/resource/english/RestaurantEng.gf
Normal file
@@ -0,0 +1,25 @@
|
||||
concrete RestaurantEng of Restaurant =
|
||||
DatabaseEng ** open Prelude,Paradigms,DatabaseRes in {
|
||||
|
||||
lin
|
||||
Restaurant = cnNonhuman "restaurant" ;
|
||||
Bar = cnNonhuman "bar" ;
|
||||
French = apReg "French" ;
|
||||
Italian = apReg "Italian" ;
|
||||
Indian = apReg "Indian" ;
|
||||
Japanese = apReg "Japanese" ;
|
||||
|
||||
address = funNonhuman "address" ;
|
||||
phone = funNonhuman ["number"] ; --- phone
|
||||
priceLevel = funNonhuman ["level"] ; --- price
|
||||
|
||||
Cheap = aReg "cheap" ;
|
||||
Expensive = aRidiculous "expensive" ;
|
||||
|
||||
WhoRecommend rest = mkSentSame (ss (["who recommended"] ++ rest.s ! nominative)) ;
|
||||
WhoHellRecommend rest =
|
||||
mkSentSame (ss (["who the hell recommended"] ++ rest.s ! nominative)) ;
|
||||
|
||||
LucasCarton = pnReg ["Lucas Carton"] ;
|
||||
|
||||
} ;
|
||||
848
grammars/resource/english/Syntax.gf
Normal file
848
grammars/resource/english/Syntax.gf
Normal file
@@ -0,0 +1,848 @@
|
||||
--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 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
|
||||
|
||||
-- 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} ;
|
||||
|
||||
--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,det ->
|
||||
{s = det ;
|
||||
n = n
|
||||
} ;
|
||||
|
||||
everyDet = mkDeterminer Sg "every" ;
|
||||
allDet = mkDeterminer Pl "all" ;
|
||||
mostDet = mkDeterminer Pl "most" ;
|
||||
aDet = mkDeterminer Sg artIndef ;
|
||||
plDet = mkDeterminer Pl [] ;
|
||||
theSgDet = mkDeterminer Sg "the" ;
|
||||
thePlDet = mkDeterminer Pl "the" ;
|
||||
anySgDet = mkDeterminer Sg "any" ;
|
||||
anyPlDet = mkDeterminer Pl "any" ;
|
||||
|
||||
whichSgDet = mkDeterminer Sg "which" ;
|
||||
whichPlDet = mkDeterminer Pl "which" ;
|
||||
|
||||
whichDet = whichSgDet ; --- API
|
||||
|
||||
indefNoun : Number -> CommNoun -> Str = \n,man ->
|
||||
(indefNounPhrase n man).s ! NomP ;
|
||||
|
||||
indefNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n,man ->
|
||||
{s = \\c => case n of {
|
||||
Sg => artIndef ++ man.s ! n ! toCase c ;
|
||||
Pl => man.s ! n ! toCase c
|
||||
} ;
|
||||
n = n ; p = P3
|
||||
} ;
|
||||
|
||||
defNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n,car ->
|
||||
{s = \\c => artDef ++ 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 -> NounPhrase -> CommNounPhrase -> NounPhrase =
|
||||
\n,john,car ->
|
||||
{s = \\c => variants {
|
||||
artDef ++ car.s ! n ! Nom ++ "of" ++ john.s ! GenSP ;
|
||||
john.s ! GenP ++ 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
|
||||
} ;
|
||||
|
||||
|
||||
--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 (simpleAdj 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 (ss (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 = big.s ! Comp ++ "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 ++ 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 = related.s ++ 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 ++ car.s ! n ! c)
|
||||
(table {Nom => car.s ! n ! Nom ++ big.s ; 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 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}) ;
|
||||
|
||||
|
||||
|
||||
--2 Verbs
|
||||
--
|
||||
--3 Verb phrases
|
||||
--
|
||||
-- Verb phrases are discontinuous: the two parts of a verb phrase are
|
||||
-- (s) an inflected verb, (s2) infinitive and complement.
|
||||
-- For instance: "doesn't" - "walk" ; "isn't" - "old" ; "is" - "a man"
|
||||
-- There's also a parameter telling if the verb is an auxiliary:
|
||||
-- this is needed in question.
|
||||
|
||||
VerbPhrase = VerbP3 ** {s2 : Number => Str ; isAux : Bool} ;
|
||||
|
||||
-- From the inflection table, we selecting the finite form as function
|
||||
-- of person and number:
|
||||
|
||||
indicVerb : VerbP3 -> Person -> Number -> Str = \v,p,n -> case n of {
|
||||
Sg => v.s ! Indic p ;
|
||||
Pl => v.s ! Indic P2
|
||||
} ;
|
||||
|
||||
-- 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 : Bool -> Verb -> VerbPhrase = \b,walk ->
|
||||
if_then_else VerbPhrase b
|
||||
{s = \\v => walk.s ! v ++ walk.s1 ;
|
||||
s2 = \\_ => [] ;
|
||||
isAux = False
|
||||
}
|
||||
{s = \\v => contractNot (verbP3Do.s ! v) ;
|
||||
s2 = \\_ => walk.s ! InfImp ++ walk.s1 ;
|
||||
isAux = True
|
||||
} ;
|
||||
|
||||
-- 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 : Bool -> Adjective -> VerbPhrase = \b,old ->
|
||||
{s = beOrNotBe b ;
|
||||
s2 = \\_ => old.s ;
|
||||
isAux = True
|
||||
} ;
|
||||
|
||||
predCommNoun : Bool -> CommNoun -> VerbPhrase = \b,man ->
|
||||
{s = beOrNotBe b ;
|
||||
s2 = \\n => indefNoun n man ;
|
||||
isAux = True
|
||||
} ;
|
||||
|
||||
predNounPhrase : Bool -> NounPhrase -> VerbPhrase = \b,john ->
|
||||
{s = beOrNotBe b ;
|
||||
s2 = \\_ => john.s ! NomP ;
|
||||
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 : Bool -> TransVerb -> NounPhrase -> VerbPhrase =
|
||||
\b,lookat,john ->
|
||||
let {lookatjohn = bothWays lookat.s1 (lookat.s3 ++ john.s ! AccP)} in
|
||||
if_then_else VerbPhrase b
|
||||
{s = lookat.s ;
|
||||
s2 = \\_ => lookatjohn ;
|
||||
isAux = False}
|
||||
{s = \\v => contractNot (verbP3Do.s ! v) ;
|
||||
s2 = \\_ => lookat.s ! InfImp ++ lookatjohn ;
|
||||
isAux = True} ;
|
||||
|
||||
|
||||
-- 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 [] ;
|
||||
|
||||
|
||||
--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 ** {isPost : Bool} ;
|
||||
|
||||
advPre : Str -> Adverb = \seldom -> ss seldom ** {isPost = False} ;
|
||||
advPost : Str -> Adverb = \well -> ss well ** {isPost = 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.isPost 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
|
||||
} ;
|
||||
|
||||
-- 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) ;
|
||||
|
||||
|
||||
-- This is a macro for simultaneous predication and complementization.
|
||||
|
||||
predTransVerb : Bool -> NounPhrase -> TransVerb -> NounPhrase -> Sentence =
|
||||
\b,you,see,john ->
|
||||
predVerbPhrase you (complTransVerb b see john) ;
|
||||
|
||||
|
||||
--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 : Bool -> SentenceVerb -> Sentence -> VerbPhrase =
|
||||
\b,say,johnruns ->
|
||||
let {thatjohnruns = optStr "that" ++ johnruns.s} in
|
||||
if_then_else VerbPhrase b
|
||||
{s = say.s ;
|
||||
s2 = \\_ => thatjohnruns ;
|
||||
isAux = False}
|
||||
{s = \\v => contractNot (verbP3Do.s ! v) ;
|
||||
s2 = \\_ => say.s ! InfImp ++ thatjohnruns ;
|
||||
isAux = True} ;
|
||||
|
||||
|
||||
--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
|
||||
} ;
|
||||
|
||||
|
||||
--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
|
||||
}
|
||||
} ;
|
||||
|
||||
|
||||
|
||||
--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 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 = SD2 ** {p : Bool} ;
|
||||
|
||||
twoAdjPhrase : (_,_ : AdjPhrase) -> ListAdjPhrase = \x,y ->
|
||||
CO.twoStr x.s y.s ** {p = andB x.p y.p} ;
|
||||
|
||||
consAdjPhrase : ListAdjPhrase -> AdjPhrase -> ListAdjPhrase = \xs,x ->
|
||||
CO.consStr CO.comma xs x.s ** {p = andB xs.p x.p} ;
|
||||
|
||||
conjunctAdjPhrase : Conjunction -> ListAdjPhrase -> AdjPhrase = \c,xs ->
|
||||
ss (CO.conjunctX c xs) ** {p = xs.p} ;
|
||||
|
||||
conjunctDistrAdjPhrase : ConjunctionDistr -> ListAdjPhrase -> AdjPhrase =
|
||||
\c,xs ->
|
||||
ss (CO.conjunctDistrX 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 <m,n> of {
|
||||
<Sg,Sg> => 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} ;
|
||||
|
||||
|
||||
--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 ;
|
||||
|
||||
} ;
|
||||
36
grammars/resource/english/TestEng.gf
Normal file
36
grammars/resource/english/TestEng.gf
Normal file
@@ -0,0 +1,36 @@
|
||||
concrete TestEng of TestAbs = ResEng ** open Syntax in {
|
||||
|
||||
flags startcat=Phr ; lexer=text ; parser=chart ; unlexer=text ;
|
||||
|
||||
-- a random sample from the lexicon
|
||||
|
||||
lin
|
||||
Big = mkAdjDegr "big" "bigger" "biggest";
|
||||
Small = adjDegrReg "small" ;
|
||||
Old = adjDegrReg "old" ;
|
||||
Young = adjDegrReg "young" ;
|
||||
Man = cnHum (mkNoun "man" "men" "man's" "men's") ;
|
||||
Woman = cnHum (mkNoun "woman" "women" "woman's" "women's") ;
|
||||
Car = cnNoHum (nounReg "car") ;
|
||||
House = cnNoHum (nounReg "house") ;
|
||||
Light = cnNoHum (nounReg "light") ;
|
||||
Walk = verbNoPart (regVerbP3 "walk") ;
|
||||
Run = verbNoPart (regVerbP3 "run") ;
|
||||
Say = verbNoPart (regVerbP3 "say") ;
|
||||
Prove = verbNoPart (regVerbP3 "prove") ;
|
||||
Send = mkTransVerbDir (regVerbP3 "send") ;
|
||||
Love = mkTransVerbDir (regVerbP3 "love") ;
|
||||
Wait = mkTransVerb (regVerbP3 "wait") "for" ;
|
||||
Mother = funOfReg "mother" Hum ;
|
||||
Uncle = funOfReg "uncle" Hum ;
|
||||
|
||||
Always = advPre "always" ;
|
||||
Well = advPost "well" ;
|
||||
|
||||
SwitchOn = mkTransVerbPart (verbP3s "switch") "on" ;
|
||||
SwitchOff = mkTransVerbPart (verbP3s "switch") "off" ;
|
||||
|
||||
John = nameReg "John" ;
|
||||
Mary = nameReg "Mary" ;
|
||||
|
||||
} ;
|
||||
101
grammars/resource/english/Types.gf
Normal file
101
grammars/resource/english/Types.gf
Normal file
@@ -0,0 +1,101 @@
|
||||
--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 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 = 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.
|
||||
-- Such adjectives are simply strings.
|
||||
|
||||
Adjective : Type = SS ;
|
||||
AdjDegr = SS1 Degree ;
|
||||
|
||||
--3 Verbs
|
||||
--
|
||||
-- We limit the grammar so far to verbs in infinitive-imperative or present tense.
|
||||
-- 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 ;
|
||||
|
||||
oper
|
||||
VerbP3 : Type = SS1 VForm ;
|
||||
|
||||
-- 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} ;
|
||||
} ;
|
||||
|
||||
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 ;
|
||||
|
||||
} ;
|
||||
1039
grammars/resource/swedish/Morpho.gf
Normal file
1039
grammars/resource/swedish/Morpho.gf
Normal file
File diff suppressed because it is too large
Load Diff
196
grammars/resource/swedish/ResSwe.gf
Normal file
196
grammars/resource/swedish/ResSwe.gf
Normal file
@@ -0,0 +1,196 @@
|
||||
--1 The Top-Level Swedish Resource Grammar
|
||||
--
|
||||
-- Aarne Ranta 2002 -- 2003
|
||||
--
|
||||
-- This is the Swedish concrete syntax of the multilingual resource
|
||||
-- grammar. Most of the work is done in the file $syntax.Swe.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 ResSwe of ResAbs = open Prelude, Syntax in {
|
||||
|
||||
flags
|
||||
startcat=Phr ;
|
||||
parser=chart ;
|
||||
|
||||
lincat
|
||||
CN = {s : Number => SpeciesP => Case => Str ; g : Gender ; x : Sex ;
|
||||
p : IsComplexCN} ;
|
||||
N = CommNoun ;
|
||||
-- = {s : Number => Species => Case => Str ; g : Gender ; x : Sex} ;
|
||||
NP = NounPhrase ;
|
||||
-- = {s : NPForm => Str ; g : Gender ; n : Number} ;
|
||||
PN = {s : Case => Str ; g : Gender ; x : Sex} ;
|
||||
Det = {s : Gender => Sex => Str ; n : Number ; b : SpeciesP} ;
|
||||
Fun = CommNoun ** {s2 : Preposition} ;
|
||||
|
||||
Adj1 = Adjective ;
|
||||
-- = {s : AdjFormPos => Case => Str} ;
|
||||
Adj2 = Adjective ** {s2 : Preposition} ;
|
||||
AdjDeg = {s : AdjForm => Str} ;
|
||||
AP = Adjective ** {p : IsPostfixAdj} ;
|
||||
|
||||
V = Verb ;
|
||||
-- = {s : VForm => Str} ;
|
||||
VP = Verb ** {s2 : Str ; s3 : Gender => Number => Str} ;
|
||||
TV = Verb ** {s2 : Preposition} ;
|
||||
VS = Verb ;
|
||||
|
||||
AdV = {s : Str ; isPost : Bool} ;
|
||||
|
||||
S = Sentence ;
|
||||
-- = {s : Order => Str} ;
|
||||
Slash = Sentence ** {s2 : Preposition} ;
|
||||
RP = {s : RelCase => GenNum => Str ; g : RelGender} ;
|
||||
RC = {s : GenNum => Str} ;
|
||||
IP = NounPhrase ;
|
||||
Qu = {s : QuestForm => Str} ;
|
||||
Imp = {s : Number => Str} ;
|
||||
|
||||
Phr = {s : Str} ;
|
||||
|
||||
Conj = {s : Str ; n : Number} ;
|
||||
ConjD = {s1 : Str ; s2 : Str ; n : Number} ;
|
||||
|
||||
ListS = {s1,s2 : Order => Str} ;
|
||||
ListAP = {s1,s2 : AdjFormPos => Case => Str ; p : Bool} ;
|
||||
ListNP = {s1,s2 : NPForm => Str ; g : Gender ; n : Number} ;
|
||||
|
||||
--.
|
||||
|
||||
lin
|
||||
UseN = noun2CommNounPhrase ;
|
||||
ModAdj = modCommNounPhrase ;
|
||||
ModGenOne = npGenDet singular ;
|
||||
ModGenMany = npGenDet plural ;
|
||||
UsePN = nameNounPhrase ;
|
||||
UseFun = funAsCommNounPhrase ;
|
||||
AppFun = appFunComm ;
|
||||
AdjP1 = adj2adjPhrase ;
|
||||
ComplAdj = complAdj ;
|
||||
PositAdjP = positAdjPhrase ;
|
||||
ComparAdjP = comparAdjPhrase ;
|
||||
SuperlNP = superlNounPhrase ;
|
||||
|
||||
DetNP = detNounPhrase ;
|
||||
IndefOneNP = indefNounPhrase singular ;
|
||||
IndefManyNP = indefNounPhrase plural ;
|
||||
DefOneNP = defNounPhrase singular ;
|
||||
DefManyNP = defNounPhrase plural ;
|
||||
|
||||
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 ;
|
||||
PosNP = predNounPhrase True ;
|
||||
NegNP = predNounPhrase False ;
|
||||
PosVS = complSentVerb True ;
|
||||
NegVS = complSentVerb False ;
|
||||
|
||||
|
||||
AdvVP = adVerbPhrase ;
|
||||
LocNP = locativeNounPhrase ;
|
||||
AdvCN = advCommNounPhrase ;
|
||||
|
||||
PosSlashTV = slashTransVerb True ;
|
||||
NegSlashTV = slashTransVerb False ;
|
||||
|
||||
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 ;
|
||||
|
||||
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 ;
|
||||
|
||||
INP = pronNounPhrase jag_32 ;
|
||||
ThouNP = pronNounPhrase du_33 ;
|
||||
HeNP = pronNounPhrase han_34 ;
|
||||
SheNP = pronNounPhrase hon_35 ;
|
||||
WeNP = pronNounPhrase vi_36 ;
|
||||
YeNP = pronNounPhrase ni_37 ;
|
||||
TheyNP = pronNounPhrase de_38 ;
|
||||
|
||||
YouNP = let {ni = pronNounPhrase ni_37 } in {s = ni.s ; g = ni.g ; n = Sg} ;
|
||||
|
||||
EveryDet = varjeDet ;
|
||||
AllDet = allaDet ;
|
||||
WhichDet = vilkenDet ;
|
||||
MostDet = flestaDet ;
|
||||
|
||||
HowIAdv = ss "hur" ;
|
||||
WhenIAdv = ss "när" ;
|
||||
WhereIAdv = ss "var" ;
|
||||
WhyIAdv = ss "varför" ;
|
||||
|
||||
AndConj = ss "och" ** {n = Pl} ;
|
||||
OrConj = ss "eller" ** {n = Sg} ;
|
||||
BothAnd = sd2 "både" "och" ** {n = Pl} ;
|
||||
EitherOr = sd2 "antingen" "eller" ** {n = Sg} ;
|
||||
NeitherNor = sd2 "varken" "eller" ** {n = Sg} ;
|
||||
IfSubj = ss "om" ;
|
||||
WhenSubj = ss "när" ;
|
||||
|
||||
PhrYes = ss ["Ja ."] ;
|
||||
PhrNo = ss ["Nej ."] ;
|
||||
} ;
|
||||
1
grammars/resource/swedish/Svenska.gf
Normal file
1
grammars/resource/swedish/Svenska.gf
Normal file
@@ -0,0 +1 @@
|
||||
resource Svenska = reuse ResSwe ;
|
||||
1000
grammars/resource/swedish/Syntax.gf
Normal file
1000
grammars/resource/swedish/Syntax.gf
Normal file
File diff suppressed because it is too large
Load Diff
35
grammars/resource/swedish/TestSwe.gf
Normal file
35
grammars/resource/swedish/TestSwe.gf
Normal file
@@ -0,0 +1,35 @@
|
||||
concrete TestSwe of TestAbs = ResSwe ** open Syntax in {
|
||||
|
||||
flags startcat=Phr ; lexer=text ; parser=chart ; unlexer=text ;
|
||||
|
||||
-- a random sample from the lexicon
|
||||
|
||||
lin
|
||||
Big = stor_25 ;
|
||||
Small = liten_1146 ;
|
||||
Old = gammal_16 ;
|
||||
Young = ung_29 ;
|
||||
Man = extCommNoun Masc man_1144 ;
|
||||
Woman = extCommNoun NoMasc (sApa "kvinn") ;
|
||||
Car = extCommNoun NoMasc (sBil "bil") ;
|
||||
House = extCommNoun NoMasc (sHus "hus") ;
|
||||
Light = extCommNoun NoMasc (sHus "ljus") ;
|
||||
Walk = extVerb Act gå_1174 ;
|
||||
Run = extVerb Act (vFinna "spring" "sprang" "sprung") ;
|
||||
Love = extTransVerb (vTala "älsk") [] ;
|
||||
Send = extTransVerb (vTala "skick") [] ;
|
||||
Wait = extTransVerb (vTala "vänt") "på" ;
|
||||
Say = extVerb Act (vLeka "säg") ; --- works in present tense...
|
||||
Prove = extVerb Act (vTala "bevis") ;
|
||||
SwitchOn = extTransVerb (vVända "tän") [] ;
|
||||
SwitchOff = extTransVerb (vLeka "släck") [] ;
|
||||
|
||||
Mother = mkFun (extCommNoun NoMasc mor_1) "till" ;
|
||||
Uncle = mkFun (extCommNoun Masc farbror_8) "till" ;
|
||||
|
||||
Always = advPre "alltid" ;
|
||||
Well = advPost "bra" ;
|
||||
|
||||
John = mkProperName "Johan" Utr Masc ;
|
||||
Mary = mkProperName "Maria" Utr NoMasc ;
|
||||
} ;
|
||||
150
grammars/resource/swedish/Types.gf
Normal file
150
grammars/resource/swedish/Types.gf
Normal file
@@ -0,0 +1,150 @@
|
||||
--1 Swedish Word Classes and Morphological Parameters
|
||||
--
|
||||
-- This is a resource module for Swedish morphology, defining the
|
||||
-- morphological parameters and word classes of Swedish. It is aimed
|
||||
-- to be complete w.r.t. the description of word forms.
|
||||
-- However, it does not include those parameters that are not needed for
|
||||
-- analysing individual words: such parameters are defined in syntax modules.
|
||||
--
|
||||
-- This GF grammar was obtained from the functional morphology file TypesSw.hs
|
||||
-- semi-automatically. The GF inflection engine obtained was obtained automatically.
|
||||
|
||||
resource Types = open Prelude in {
|
||||
|
||||
--
|
||||
|
||||
--2 Enumerated parameter types
|
||||
--
|
||||
-- These types are the ones found in school grammars.
|
||||
-- Their parameter values are atomic.
|
||||
|
||||
param
|
||||
Gender = Utr | Neutr ;
|
||||
Number = Sg | Pl ;
|
||||
Species = Indef | Def ;
|
||||
Case = Nom | Gen ;
|
||||
Sex = NoMasc | Masc ;
|
||||
Mode = Ind | Cnj ;
|
||||
Voice = Act | Pass ;
|
||||
Degree = Pos | Comp | Sup ;
|
||||
Person = P1 | P2 | P3 ;
|
||||
|
||||
--2 Word classes and hierarchical parameter types
|
||||
--
|
||||
-- Real parameter types (i.e. ones on which words and phrases depend)
|
||||
-- are mostly hierarchical. The alternative would be cross-products of
|
||||
-- simple parameters, but this would usually overgenerate.
|
||||
--
|
||||
|
||||
--3 Substantives
|
||||
--
|
||||
-- Substantives (= common nouns) have a parameter of type SubstForm.
|
||||
|
||||
param SubstForm = SF Number Species Case ;
|
||||
|
||||
-- Substantives moreover have an inherent gender.
|
||||
|
||||
oper Subst : Type = {s : SubstForm => Str ; h1 : Gender} ;
|
||||
|
||||
--3 Adjectives
|
||||
--
|
||||
-- Adjectives are a very complex class, and the full table has as many as
|
||||
-- 18 different forms. The major division is between the comparison degrees;
|
||||
-- the comparative has only the 2 case forms, whereas the positive has 12 forms.
|
||||
|
||||
param
|
||||
AdjForm = AF AdjFormGrad Case ;
|
||||
|
||||
-- The positive strong forms depend on gender: "en stor bil" - "ett stort hus".
|
||||
-- But the weak forms depend on sex: "den stora bilen" - "den store mannen".
|
||||
-- The plural never makes a gender-sex distinction.
|
||||
|
||||
GenNum = ASg Gender | APl ;
|
||||
SexNum = AxSg Sex | AxPl ;
|
||||
|
||||
AdjFormPos = Strong GenNum | Weak SexNum ;
|
||||
AdjFormSup = SupStrong | SupWeak ;
|
||||
|
||||
AdjFormGrad =
|
||||
Posit AdjFormPos
|
||||
| Compar
|
||||
| Super AdjFormSup ;
|
||||
|
||||
oper
|
||||
Adj : Type = {s : AdjForm => Str} ;
|
||||
|
||||
--3 Verbs
|
||||
--
|
||||
-- Verbs have 9 finite forms and as many as 18 infinite forms; the large number
|
||||
-- of the latter comes from adjectives.
|
||||
|
||||
oper Verbum : Type = {s : VerbForm => Str} ;
|
||||
|
||||
param
|
||||
VFin =
|
||||
Pres Mode Voice
|
||||
| Pret Mode Voice
|
||||
| Imper ; --- no passive
|
||||
|
||||
VInf =
|
||||
Inf Voice
|
||||
| Supin Voice
|
||||
| PtPres Case
|
||||
| PtPret AdjFormPos Case ;
|
||||
|
||||
VerbForm =
|
||||
VF VFin
|
||||
| VI VInf ;
|
||||
|
||||
-- However, the syntax only needs a simplified verb category, with
|
||||
-- present tense only. Such a verb can be extracted from the full verb,
|
||||
-- and a choice can be made between an active and a passive (deponent) verb.
|
||||
|
||||
param
|
||||
VForm = Infinit | Indicat | Imperat ;
|
||||
|
||||
oper
|
||||
Verb : Type = SS1 VForm ;
|
||||
|
||||
extVerb : Voice -> Verbum -> Verb = \v,verb -> {s = table {
|
||||
Infinit => verb.s ! VI (Inf v) ;
|
||||
Indicat => verb.s ! VF (Pres Ind v) ;
|
||||
Imperat => verb.s ! VF Imper --- no passive in Verbum
|
||||
}} ;
|
||||
|
||||
--3 Other open classes
|
||||
--
|
||||
-- Proper names, adverbs (Adv having comparison forms and AdvIn not having them),
|
||||
-- and interjections are the remaining open classes.
|
||||
|
||||
oper
|
||||
PNm : Type = {s : Case => Str ; h1 : Gender} ;
|
||||
Adv : Type = {s : Degree => Str} ;
|
||||
AdvInv : Type = {s : Str} ;
|
||||
Interj : Type = {s : Str} ;
|
||||
|
||||
--3 Closed classes
|
||||
--
|
||||
-- The rest of the Swedish word classes are closed, i.e. not extensible by new
|
||||
-- lexical entries. Thus we don't have to know how to build them, but only
|
||||
-- how to use them, i.e. which parameters they have.
|
||||
--
|
||||
-- The most important distinction is between proper-name-like pronouns and
|
||||
-- adjective-like pronouns, which are inflected in completely different parameters.
|
||||
|
||||
param
|
||||
NPForm = PNom | PAcc | PGen GenNum ;
|
||||
AdjPronForm = APron GenNum Case ;
|
||||
AuxVerbForm = AuxInf | AuxPres | AuxPret | AuxSup ;
|
||||
|
||||
oper
|
||||
ProPN : Type = {s : NPForm => Str ; h1 : Gender ; h2 : Number ; h3 : Person} ;
|
||||
ProAdj : Type = {s : AdjPronForm => Str} ;
|
||||
Prep : Type = {s : Str} ;
|
||||
Conjunct : Type = {s : Str} ;
|
||||
Subjunct : Type = {s : Str} ;
|
||||
Art : Type = {s : GenNum => Str} ;
|
||||
Part : Type = {s : Str} ;
|
||||
Infin : Type = {s : Str} ;
|
||||
VAux : Type = {s : AuxVerbForm => Str} ;
|
||||
}
|
||||
Reference in New Issue
Block a user