diff --git a/grammars/database/DatabaseEng.gf b/grammars/database/DatabaseEng.gf index 29ae87fec..971ab96a5 100644 --- a/grammars/database/DatabaseEng.gf +++ b/grammars/database/DatabaseEng.gf @@ -1,6 +1,6 @@ --# -path=.:../resource/nabstract:../resource/nenglish:../prelude -concrete DatabaseEng of Database = open Prelude, ResEng in { +concrete DatabaseEng of Database = open Prelude, ResourceEng in { flags lexer=text ; unlexer=text ; @@ -17,8 +17,8 @@ lincat lin WhichAre A B = QuestPhrase (IntVP (NounIPMany A) (PosVG (PredAP B))) ; - IsThere A = QuestPhrase (IsThereCN A) ; - AreThere A = QuestPhrase (AreThereCN NoNum A) ; + IsThere A = QuestPhrase (IsThereNP (IndefOneNP A)) ; + AreThere A = QuestPhrase (IsThereNP (IndefManyNP NoNum A)) ; WhatIs val = QuestPhrase (IntVP WhatOne (PosVG (PredNP val))) ; IsIt Q A = QuestPhrase (QuestVP Q (PosVG (PredAP A))) ; diff --git a/grammars/database/RestaurantEng.gf b/grammars/database/RestaurantEng.gf index 04e89a5b6..9b0b208a3 100644 --- a/grammars/database/RestaurantEng.gf +++ b/grammars/database/RestaurantEng.gf @@ -1,7 +1,7 @@ --# -path=.:../resource/nabstract:../resource/nenglish:../prelude concrete RestaurantEng of Restaurant = - DatabaseEng ** open Prelude,ParadigmsEng in { + DatabaseEng ** open Prelude, ParadigmsEng in { lin Restaurant = cnNonhuman "restaurant" ; diff --git a/lib/resource-0.6/abstract/Combinations.gf b/lib/resource-0.6/abstract/Combinations.gf new file mode 100644 index 000000000..16a951503 --- /dev/null +++ b/lib/resource-0.6/abstract/Combinations.gf @@ -0,0 +1,331 @@ +--1 Abstract Syntax for Multilingual Resource Grammar +-- +-- Aarne Ranta 2002 -- 2003 +-- +-- Although concrete syntax differs a lot between different languages, +-- many structures can be treated as common, on the level +-- of abstraction that GF provides. +-- What we will present in the following is a linguistically oriented abstract +-- syntax that has been successfully defined for the following languages: +-- +--* $Eng$lish +--* $Fin$nish +--* $Fre$nch +--* $Ger$man +--* $Ita$lian +--* $Rus$sian +--* $Swe$dish +-- +-- The three-letter prefixes are used in file names all over the resource +-- grammar library; we refer to them commonly as $X$ below. +--! +-- The grammar 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. Each new application helped to identify some +-- missing structures in the resource and suggested some additions, but the +-- number of them was usually small. +-- +-- 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. This is done +-- by using, instead of this module, the $reuse$ module which has the name +-- $ResourceX$ + +abstract Combinations = PredefAbs ** { +--! +--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 is the business +-- of applications grammars. In general, the correspondence between linguistic +-- and semantic categories is many-to-many. +-- +-- 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. Prepositional +-- phrases that are not complements belong to the category +-- $AdV$ of adverbials. +-- +-- In each group below, some categories are *lexical* in the sense of only +-- containing atomic elements. These elements are not necessarily expressed by +-- one word in all languages; the essential thing is that they have no +-- constituents. Thus they have no productions in this part of the +-- resource grammar. The $ParadigmsX$ grammars provide ways of defining +-- lexical elements. +-- +-- Lexical categories are listed before other categories +-- in each group and divided by an empty line. + +--! +--3 Nouns and noun phrases +-- + +cat + N ; -- simple common noun, e.g. "car" + PN ; -- proper name, e.g. "John", "New York" + Fun ; -- function word, e.g. "mother (of)" + Fun2 ; -- two-place function, e.g. "flight (from) (to)" + + CN ; -- common noun phrase, e.g. "red car", "car that John owns" + NP ; -- noun phrase, e.g. "John", "all cars", "you" + Det ; -- determiner, e.g. "every", "all" + Num ; -- numeral, e.g. "three", "879" + +--! +--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" + +-- The difference between $Adj1$ and $AdjDeg$ is that the former has no +-- comparison forms. + +--! +--3 Verbs and verb phrases +-- + + V ; -- one-place verb, e.g. "walk" + TV ; -- two-place verb, e.g. "love", "wait (for)", "switch on" + V3 ; -- three-place verb, e.g. "give", "prefer (stg) (to stg)" + VS ; -- sentence-compl. verb, e.g. "say", "prove" + VV ; -- verb-compl. verb, e.g. "can", "want" + + VG ; -- verbal group, e.g. "switch the light on" + VP ; -- verb phrase, e.g. "switch the light on", "don't run" + +--! +--3 Adverbials +-- +-- This group has no lexical categories. + + AdV ; -- adverbial e.g. "now", "in the house" + AdA ; -- ad-adjective e.g. "very" + AdS ; -- sentence adverbial e.g. "therefore", "otherwise" + Prep ; -- pre/postposition, case e.g. "after", Adessive + +--! +--3 Sentences and relative clauses +-- +-- This group has no lexical categories. + + 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 +-- +-- This group has no lexical categories. + + 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 +-- +-- This group has no lexical categories. + + 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 of defining the simplest combinations +-- of categories and 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 +-- 'macros' for combinations of the ones below. + +--! +--3 Nouns and noun phrases +-- + +fun + UseN : N -> CN ; -- "car" + UsePN : PN -> NP ; -- "John" + UseFun : Fun -> CN ; -- "successor" + UseInt : Int -> Num ; -- "32" --- assumes i > 1 + + ModAdj : AP -> CN -> CN ; -- "red car" + DetNP : Det -> CN -> NP ; -- "every car" + MassNP : CN -> NP ; -- "wine" + IndefOneNP : CN -> NP ; -- "a car", "cars" + IndefManyNP : Num -> CN -> NP ; -- "houses", "86 houses" + DefOneNP : CN -> NP ; -- "the car" + DefManyNP : Num -> CN -> NP ; -- "the cars", "the 86 cars" + ModGenOne : NP -> CN -> NP ; -- "John's car" + ModGenMany : Num -> NP -> CN -> NP ; -- "John's cars", "John's 86 cars" + AppFun : Fun -> NP -> CN ; -- "successor of zero" + AppFun2 : Fun2 -> NP -> Fun ; -- "flight from Paris" + CNthatS : CN -> S -> CN ; -- "idea that the Earth is flat" + NoNum : Num ; -- no numeral modifier + +--! +--3 Adjectives and adjectival phrases +-- + + AdjP1 : Adj1 -> AP ; -- "red" + PositAdjP : AdjDeg -> AP ; -- "old" + + ComplAdj : Adj2 -> NP -> AP ; -- "divisible by two" + ComparAdjP : AdjDeg -> NP -> AP ; -- "older than John" + SuperlNP : AdjDeg -> CN -> NP ; -- "the oldest man" + +--! +--3 Verbs and verb phrases +-- +-- The principal way of forming sentences ($S$) is by combining a noun phrase +-- with a verb phrase (the $PredVP$ rule below). In addition to this, verb +-- phrases have uses in relative clauses and questions. Verb phrases already +-- have (or have not) a negation, but they are formed from verbal groups +-- ($VG$), which have both positive and negative forms. + + PredV : V -> VG ; -- "walk", "doesn't walk" + PredPassV : V -> VG ; -- "is seen", "is not seen" + PredTV : TV -> NP -> VG ; -- "sees John", "doesn't see John" + PredVS : VS -> S -> VG ; -- "says that I run", "doesn't say..." + PredVV : VV -> VG -> VG ; -- "can run", "can't run", "tries to run" + PredV3 : V3 -> NP -> NP -> VG ; -- "prefers wine to beer" + + PredNP : NP -> VG ; -- "is John", "is not John" + PredAdV : AdV -> VG ; -- "is everywhere", "is not in France" + PredAP : AP -> VG ; -- "is old", "isn't old" + PredCN : CN -> VG ; -- "is a man", "isn't a man" + VTrans : TV -> V ; -- "loves" + + PosVG,NegVG : VG -> VP ; -- + +--! +--3 Adverbials +-- +-- Here is how complex adverbials can be formed and used. + + AdjAdv : AP -> AdV ; -- "freely", "more consciously than you" + PrepNP : Prep -> NP -> AdV ; -- "in London", "after the war" + + AdvVP : VP -> AdV -> VP ; -- "always walks", "walks in the park" + 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" + ThereNP : NP -> S ; -- "there is a bar","there are 86 bars" + + IdRP : RP ; -- "which" + FunRP : Fun -> RP -> RP ; -- "the successor of which" + RelVP : RP -> VP -> RC ; -- "who walks", "who doesn't walk" + 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"; "doesn't 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" + IsThereNP : NP -> Qu ; -- "is there a bar", "are there (86) bars" + + 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?" + SubjVP : VP -> Subj -> S -> VP ; -- "(a man who) sings when he runs" + +--! +--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 ; + +} ; + diff --git a/lib/resource-0.6/abstract/Structural.gf b/lib/resource-0.6/abstract/Structural.gf new file mode 100644 index 000000000..e651afb5e --- /dev/null +++ b/lib/resource-0.6/abstract/Structural.gf @@ -0,0 +1,90 @@ +--1 GF Resource Grammar API for Structural Words +-- +-- AR 21/11/2003 +-- +-- 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. + +abstract Structural = Combinations ** { + +fun + +--! +--2 Determiners and noun phrases +-- +-- Many plural determiners can take a numeral modifier. So can the plural +-- pronouns "we" and "you". + + EveryDet, WhichDet, AllDet, -- every, sg which, sg all + SomeDet, AnyDet, NoDet, -- sg some, any, no + MostDet, MostsDet, ManyDet, MuchDet : Det ; -- sg most, pl most, many, much + ThisDet, ThatDet : Det ; -- this, that + + AllsDet, WhichsDet, -- pl all, which (86) + SomesDet, AnysDet, NosDet, -- pl some, any, no + TheseDet, ThoseDet : Num -> Det ; -- these, those (86) + + ThisNP, ThatNP : NP ; -- this, that + TheseNP, ThoseNP : Num -> NP ; -- these, those (86) + INP, ThouNP, HeNP, SheNP, ItNP : NP ; -- personal pronouns in singular + WeNP, YeNP : Num -> NP ; -- these pronouns can take numeral + TheyNP : NP ; YouNP : NP ; -- they, the polite you + + EverybodyNP, SomebodyNP, NobodyNP, -- everybody, somebody, nobody + EverythingNP, SomethingNP, NothingNP : NP ; -- everything, something, nothing + +--! +--2 Auxiliary verbs +-- +-- Depending on language, all, some, or none of there verbs belong to +-- a separate class of *auxiliary* verbs. The list is incomplete. + + CanVV, CanKnowVV, MustVV : VV ; -- can (pouvoir/savoir), must + WantVV : VV ; -- want (to do) + +--! +--2 Adverbials +-- + + WhenIAdv,WhereIAdv,WhyIAdv,HowIAdv : IAdv ; -- when, where, why, how + EverywhereNP, SomewhereNP,NowhereNP : AdV ; -- everywhere, somewhere, nowhere + VeryAdv, TooAdv : AdA ; -- very, too + AlmostAdv, QuiteAdv : AdA ; -- almost, quite + OtherwiseAdv, ThereforeAdv : AdS ; -- therefore, otherwise + +--! +--2 Conjunctions and subjunctions +-- + + AndConj, OrConj : Conj ; -- and, or + BothAnd, EitherOr, NeitherNor : ConjD ; -- both-and, either-or, neither-nor + IfSubj, WhenSubj, AlthoughSubj : Subj ; -- if, when, although + +--! +--2 Prepositions +-- +-- We have carefully chosen a set of semantic relations expressible +-- by prepositions in some languages, by cases or postpositions in +-- others. Complement uses of prepositions are not included, and +-- should be treated by the use of many-place verbs, adjectives, and +-- functions. + + InPrep, OnPrep, ToPrep, FromPrep, -- spatial relations + ThroughPrep, AbovePrep, UnderPrep, + InFrontPrep, BehindPrep, BetweenPrep : Prep ; + BeforePrep, DuringPrep, AfterPrep : Prep ; -- temporal relations + WithPrep, WithoutPrep, ByMeansPrep : Prep ; -- some other relations + PartPrep : Prep ; -- partitive "of" ("bottle of wine") + AgentPrep : Prep ; -- agent "by" in passive constructions + + +--! +--2 Affirmation and negation +-- +-- The negative-positive (French "si", German "doch") is missing. + + PhrYes, PhrNo : Phr ; -- yes, no + +} diff --git a/lib/resource-0.6/abstract/TestResource.gf b/lib/resource-0.6/abstract/TestResource.gf new file mode 100644 index 000000000..adafdcfbc --- /dev/null +++ b/lib/resource-0.6/abstract/TestResource.gf @@ -0,0 +1,18 @@ +abstract TestResource = Structural ** { + +-- a random sample of lexicon to test resource grammar with + +fun + Big, Happy, Small, Old, Young : AdjDeg ; + American, Finnish : Adj1 ; + Married : Adj2 ; + Man, Woman, Car, House, Light, Bar, Bottle, Wine : N ; + Walk, Run : V ; + Send, Wait, Love, Drink, SwitchOn, SwitchOff : TV ; + Give, Prefer : V3 ; + Say, Prove : VS ; + Mother, Uncle : Fun ; + Connection : Fun2 ; + Well, Always : AdV ; + John, Mary : PN ; +} ; diff --git a/lib/resource-0.6/english/CombinationsEng.gf b/lib/resource-0.6/english/CombinationsEng.gf new file mode 100644 index 000000000..48ca2203a --- /dev/null +++ b/lib/resource-0.6/english/CombinationsEng.gf @@ -0,0 +1,193 @@ +--# -path=.:../abstract:../../prelude + +--1 The Top-Level English Resource Grammar: Combination Rules +-- +-- Aarne Ranta 2002 -- 2003 +-- +-- This is the English concrete syntax of the multilingual resource +-- grammar. Most of the work is done in the file $syntax.Eng.gf$. +-- However, for the purpose of documentation, we make here explicit the +-- linearization types of each category, so that their structures and +-- dependencies can be seen. +-- Another substantial part are the linearization rules of some +-- structural words. +-- +-- The users of the resource grammar should not look at this file for the +-- linearization rules, which are in fact hidden in the document version. +-- They should use $resource.Abs.gf$ to access the syntactic rules. +-- This file can be consulted in those, hopefully rare, occasions in which +-- one has to know how the syntactic categories are +-- implemented. The parameter types are defined in $TypesEng.gf$. + +concrete CombinationsEng of Combinations = open Prelude, SyntaxEng in { + +flags + startcat=Phr ; + lexer=text ; + unlexer=text ; + +lincat + N = CommNoun ; + -- = {s : Number => Case => Str} + CN = CommNounPhrase ; + -- = CommNoun ** {g : Gender} + NP = {s : NPForm => Str ; n : Number ; p : Person} ; + PN = {s : Case => Str} ; + Det = {s : Str ; n : Number} ; + Fun = Function ; + -- = CommNounPhrase ** {s2 : Preposition} ; + Fun2 = Function ** {s3 : Preposition} ; + Num = {s : Case => Str} ; + + Adj1 = Adjective ; + -- = {s : AForm => Str} + Adj2 = Adjective ** {s2 : Preposition} ; + AdjDeg = {s : Degree => AForm => Str} ; + AP = Adjective ** {p : Bool} ; + + V = Verb ; + -- = {s : VForm => Str ; s1 : Particle} + VG = {s : Bool => VForm => Str ; s2 : Bool => Number => Str ; + isAuxT, isAuxF : Bool} ; + VP = {s : VForm => Str ; s2 : Number => Str ; isAux : Bool} ; + TV = TransVerb ; + -- = Verb ** {s3 : Preposition} ; + V3 = TransVerb ** {s4 : Preposition} ; + VS = Verb ; + VV = Verb ** {isAux : Bool} ; + + AdV = {s : Str ; p : Bool} ; + + S = {s : Str} ; + Slash = {s : Bool => Str ; s2 : Preposition} ; + RP = {s : Gender => Number => NPForm => Str} ; + RC = {s : Gender => Number => Str} ; + + IP = {s : NPForm => Str ; n : Number} ; + Qu = {s : QuestForm => Str} ; + Imp = {s : Number => Str} ; + Phr = {s : Str} ; + Text = {s : Str} ; + + Conj = {s : Str ; n : Number} ; + ConjD = {s1 : Str ; s2 : Str ; n : Number} ; + + ListS = {s1 : Str ; s2 : Str} ; + ListAP = {s1,s2 : AForm => Str ; p : Bool} ; + ListNP = {s1,s2 : NPForm => Str ; n : Number ; p : Person} ; + +--. + +lin + UseN = noun2CommNounPhrase ; + ModAdj = modCommNounPhrase ; + ModGenOne = npGenDet singular noNum ; + 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 = indefNounPhraseNum plural ; + DefOneNP = defNounPhrase singular ; + DefManyNP = defNounPhraseNum plural ; + MassNP = detNounPhrase (mkDeterminer Sg []) ; + + CNthatS = nounThatSentence ; + UseInt i = {s = table {Nom => i.s ; Gen => i.s ++ "'s"}} ; --- + NoNum = noNum ; + + PredVP = predVerbPhrase ; + PosVG = predVerbGroup True ; + NegVG = predVerbGroup False ; + + PredV = predVerb ; + PredAP = predAdjective ; + PredCN = predCommNoun ; + PredTV = complTransVerb ; + PredV3 = complDitransVerb ; + PredPassV = passVerb ; + PredNP = predNounPhrase ; + PredAdV = predAdverb ; + PredVS = complSentVerb ; + PredVV = complVerbVerb ; + VTrans = transAsVerb ; + + AdjAdv a = advPost (a.s ! AAdv) ; + PrepNP p = prepPhrase p.s ; --- + AdvVP = adVerbPhrase ; + AdvCN = advCommNounPhrase ; + AdvAP = advAdjPhrase ; + + PosSlashTV = slashTransVerb True ; + NegSlashTV = slashTransVerb False ; + OneVP = predVerbPhrase (nameNounPhrase (nameReg "one")) ; + ThereNP = thereIs ; + + IdRP = identRelPron ; + FunRP = funRelPron ; + RelVP = relVerbPhrase ; + RelSlash = relSlash ; + ModRC = modRelClause ; + RelSuch = relSuch ; + + WhoOne = intPronWho singular ; + WhoMany = intPronWho plural ; + WhatOne = intPronWhat singular ; + WhatMany = intPronWhat plural ; + FunIP = funIntPron ; + NounIPOne = nounIntPron singular ; + NounIPMany = nounIntPron plural ; + + QuestVP = questVerbPhrase ; + IntVP = intVerbPhrase ; + IntSlash = intSlash ; + QuestAdv = questAdverbial ; + IsThereNP = isThere ; + + ImperVP = imperVerbPhrase ; + + IndicPhrase = indicUtt ; + QuestPhrase = interrogUtt ; + ImperOne = imperUtterance singular ; + ImperMany = imperUtterance plural ; + + AdvS = advSentence ; + + TwoS = twoSentence ; + ConsS = consSentence ; + ConjS = conjunctSentence ; + ConjDS = conjunctDistrSentence ; + + TwoAP = twoAdjPhrase ; + ConsAP = consAdjPhrase ; + ConjAP = conjunctAdjPhrase ; + ConjDAP = conjunctDistrAdjPhrase ; + + TwoNP = twoNounPhrase ; + ConsNP = consNounPhrase ; + ConjNP = conjunctNounPhrase ; + ConjDNP = conjunctDistrNounPhrase ; + + SubjS = subjunctSentence ; + SubjImper = subjunctImperative ; + SubjQu = subjunctQuestion ; + SubjVP = subjunctVerbPhrase ; + + PhrNP = useNounPhrase ; + PhrOneCN = useCommonNounPhrase singular ; + PhrManyCN = useCommonNounPhrase plural ; + PhrIP ip = ip ; + PhrIAdv ia = ia ; + + OnePhr p = p ; + ConsPhr = cc2 ; + +} ; diff --git a/lib/resource-0.6/english/MorphoEng.gf b/lib/resource-0.6/english/MorphoEng.gf new file mode 100644 index 000000000..54dbdeb2a --- /dev/null +++ b/lib/resource-0.6/english/MorphoEng.gf @@ -0,0 +1,202 @@ +--# -path=.:../../prelude + +--1 A Simple English Resource Morphology +-- +-- Aarne Ranta 2002 +-- +-- This resource morphology contains definitions needed in the resource +-- syntax. It moreover contains the most usual inflectional patterns. +-- +-- We use the parameter types and word classes defined in $Types.gf$. + +resource MorphoEng = TypesEng ** open Prelude, (Predef=Predef) in { + +--2 Nouns +-- +-- For conciseness and abstraction, we define a worst-case macro for +-- noun inflection. It is used for defining special case that +-- only need one string as argument. + +oper + mkNoun : (_,_,_,_ : Str) -> CommonNoun = + \man,men, mans, mens -> {s = table { + Sg => table {Nom => man ; Gen => mans} ; + Pl => table {Nom => men ; Gen => mens} + }} ; + + nounReg : Str -> CommonNoun = \dog -> + mkNoun dog (dog + "s") (dog + "'s") (dog + "s'"); + + nounS : Str -> CommonNoun = \kiss -> + mkNoun kiss (kiss + "es") (kiss + "'s") (kiss + "es'") ; + + nounY : Str -> CommonNoun = \fl -> + mkNoun (fl + "y") (fl + "ies") (fl + "y's") (fl + "ies'") ; + +--3 Proper names +-- +-- Regular proper names are inflected with "'s" in the genitive. + + nameReg : Str -> ProperName = \john -> + {s = table {Nom => john ; Gen => john + "'s"}} ; + + +--2 Pronouns +-- +-- Here we define personal and relative pronouns. + + mkPronoun : (_,_,_,_ : Str) -> Number -> Person -> Pronoun = \I,me,my,mine,n,p -> + {s = table {NomP => I ; AccP => me ; GenP => my ; GenSP => mine} ; + n = n ; p = p} ; + + pronI = mkPronoun "I" "me" "my" "mine" Sg P1 ; + pronYouSg = mkPronoun "you" "you" "your" "yours" Sg P2 ; -- verb form still OK + pronHe = mkPronoun "he" "him" "his" "his" Sg P3 ; + pronShe = mkPronoun "she" "her" "her" "hers" Sg P3 ; + pronIt = mkPronoun "it" "it" "its" "it" Sg P3 ; + + pronWe = mkPronoun "we" "us" "our" "ours" Pl P1 ; + pronYouPl = mkPronoun "you" "you" "your" "yours" Pl P2 ; + pronThey = mkPronoun "they" "them" "their" "theirs" Pl P3 ; + +-- Relative pronouns in the accusative have the 'no pronoun' variant. +-- The simple pronouns do not really depend on number. + + relPron : RelPron = {s = table { + NoHum => \\_ => table { + NomP => variants {"that" ; "which"} ; + AccP => variants {"that" ; "which" ; []} ; + GenP => variants {"whose"} ; + GenSP => variants {"which"} + } ; + Hum => \\_ => table { + NomP => variants {"that" ; "who"} ; + AccP => variants {"that" ; "who" ; "whom" ; []} ; + GenP => variants {"whose"} ; + GenSP => variants {"whom"} + } + } + } ; + + +--3 Determiners +-- +-- We have just a heuristic definition of the indefinite article. +-- There are lots of exceptions: consonantic "e" ("euphemism"), consonantic +-- "o" ("one-sided"), vocalic "u" ("umbrella"). + + artIndef = pre {"a" ; + "an" / strs {"a" ; "e" ; "i" ; "o" ; "A" ; "E" ; "I" ; "O" }} ; + + artDef = "the" ; + +--2 Adjectives +-- +-- To form the adjectival and the adverbial forms, two strings are needed +-- in the worst case. + + mkAdjective : Str -> Str -> Adjective = \free,freely -> { + s = table { + AAdj => free ; + AAdv => freely + } + } ; + +-- However, the ending "iy" is sufficient for most cases. This function +-- automatically changes the word-final "y" to "i" ("happy" - "happily"). +-- N.B. this is not correct for "shy", but $mkAdjective$ has to be used. + + regAdjective : Str -> Adjective = \free -> + let + y = Predef.dp 1 free + in mkAdjective + free + (ifTok Str y "y" (Predef.tk 1 free + ("ily")) (free + "ly")) ; + +-- For the comparison of adjectives, six forms are needed to cover all cases. +-- But there is no adjective that actually needs all these. + + mkAdjDegrWorst : (_,_,_,_,_,_ : Str) -> AdjDegr = + \good,well,better,betterly,best,bestly -> + {s = table { + Pos => (mkAdjective good well).s ; + Comp => (mkAdjective better betterly).s ; + Sup => (mkAdjective best bestly).s + } + } ; + +-- What is usually needed for irregular comparisons are just three forms, +-- since the adverbial form is the same (in comparative or superlative) +-- or formed in the regular way (positive). + + adjDegrIrreg : (_,_,_ : Str) -> AdjDegr = \bad,worse,worst -> + let badly = (regAdjective bad).s ! AAdv + in mkAdjDegrWorst bad badly worse worse worst worst ; + +-- Like above, the regular formation takes account of final "y". + + adjDegrReg : Str -> AdjDegr = \happy -> + let happi = ifTok Str (Predef.dp 1 happy) "y" (Predef.tk 1 happy + "i") happy + in adjDegrIrreg happy (happi + "er") (happi + "est") ; + +-- Many adjectives are 'inflected' by adding a comparison word. + + adjDegrLong : Str -> AdjDegr = \ridiculous -> + adjDegrIrreg ridiculous ("more" ++ ridiculous) ("most" ++ ridiculous) ; + + +--3 Verbs +-- +-- Except for "be", the worst case needs four forms. + + mkVerbP3 : (_,_,_,_: Str) -> VerbP3 = \go,goes,went,gone -> + {s = table { + InfImp => go ; + Indic P3 => goes ; + Indic _ => go ; + Past _ => went ; + PPart => gone + } + } ; + + mkVerb : (_,_,_ : Str) -> VerbP3 = \ring,rang,rung -> + mkVerbP3 ring (ring + "s") rang rung ; + + regVerbP3 : Str -> VerbP3 = \walk -> + mkVerb walk (walk + "ed") (walk + "ed") ; + + verbP3s : Str -> VerbP3 = \kiss -> + mkVerbP3 kiss (kiss + "es") (kiss + "ed") (kiss + "ed") ; + + verbP3e : Str -> VerbP3 = \love -> + mkVerbP3 love (love + "s") (love + "d") (love + "d") ; + + verbP3y : Str -> VerbP3 = \cr -> + mkVerbP3 (cr + "y") (cr + "ies") (cr + "ied") (cr + "ied") ; + + verbP3Have = mkVerbP3 "have" "has" "had" "had" ; + + verbP3Do = mkVerbP3 "do" "does" "did" "done" ; + + verbBe : VerbP3 = {s = table { + InfImp => "be" ; + Indic P1 => "am" ; + Indic P2 => "are" ; + Indic P3 => "is" ; + Past Sg => "was" ; + Past Pl => "were" ; + PPart => "been" + }} ; + + verbPart : VerbP3 -> Particle -> Verb = \v,p -> + v ** {s1 = p} ; + + verbNoPart : VerbP3 -> Verb = \v -> verbPart v [] ; + +-- The optional negation contraction is a useful macro e.g. for "do". + + contractNot : Str -> Str = \is -> variants {is ++ "not" ; is + "n't"} ; + + dont = contractNot (verbP3Do.s ! InfImp) ; +} ; + diff --git a/lib/resource-0.6/english/ParadigmsEng.gf b/lib/resource-0.6/english/ParadigmsEng.gf new file mode 100644 index 000000000..332c5439e --- /dev/null +++ b/lib/resource-0.6/english/ParadigmsEng.gf @@ -0,0 +1,242 @@ +--# -path=.:../abstract:../../prelude + +--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 $MorphoEng.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 ParadigmsEng = open (Predef=Predef), Prelude, SyntaxEng, ResEng 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 ; + +-- In some cases, you may want to make a complex $CN$ into a function. + + mkFunCN : CN -> Preposition -> Fun ; + funOfCN : CN -> Fun ; + +--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; +-- the "y" ending is recognized by the function $aReg$. + + mkAdjDeg : (good,better,best : Str) -> AdjDeg ; + + aReg : (long : Str) -> AdjDeg ; -- long, longer, longest + 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 now has all verb forms, except the gerund/present participle. +-- Except for "be", the worst case needs four forms: the infinitive and +-- the third person singular present, the past indicative, and the past participle. + + mkV : (go, goes, went, gone : 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, went, gone, 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 ; lock_N = <>} ; + nReg a g = addGenN nounReg a g ; + nKiss n g = addGenN nounS n g ; + 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 ** {lock_Fun = <> ; s2 = p} ; + funNonhuman = \s -> mkFun (nNonhuman s) "of" ; + funHuman = \s -> mkFun (nHuman s) "of" ; + + pnReg n = nameReg n ** {lock_PN = <>} ; + + cnNonhuman = \s -> UseN (nGen s nonhuman) ; + cnHuman = \s -> UseN (nGen s human) ; + npReg = \s -> UsePN (pnReg s) ; + + mkFunCN = \n,p -> n ** {lock_Fun = <> ; s2 = p} ; + funOfCN = \n -> mkFunCN n "of" ; + + addGenN : (Str -> CommonNoun) -> Str -> Gender -> N = \f -> + \s,g -> f s ** {g = g ; lock_N = <>} ; + + mkAdj1 a = regAdjective a ** {lock_Adj1 = <>} ; + mkAdj2 = \s,p -> regAdjective s ** {s2 = p} ** {lock_Adj2 = <>} ; + mkAdjDeg a b c = adjDegrIrreg a b c ** {lock_AdjDeg = <>} ; + aReg a = adjDegrReg a ** {lock_AdjDeg = <>} ; + aFat = \fat -> let {fatt = fat + Predef.dp 1 fat} in + mkAdjDeg fat (fatt + "er") (fatt + "est") ; + aRidiculous a = adjDegrLong a ** {lock_AdjDeg = <>} ; + apReg = \s -> AdjP1 (mkAdj1 s) ; + + mkV = \go,goes,went,gone -> verbNoPart (mkVerbP3 go goes went gone) ** + {lock_V = <>} ; + vReg = \walk -> mkV walk (walk + "s") (walk + "ed") (walk + "ed") ; + vKiss = \kiss -> mkV kiss (kiss + "es") (kiss + "ed") (kiss + "ed") ; + vFly = \cry -> let {cr = Predef.tk 1 cry} in + mkV cry (cr + "ies") (cr + "ied") (cr + "ied") ; + 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, went, gone, up -> + verbPart (mkVerbP3 go goes went gone) up ** {lock_V = <>} ; + vPartReg = \get, up -> + verbPart (regVerbP3 get) up ** {lock_V = <>} ; + + mkTV = \v,p -> v ** {lock_TV = <> ; s3 = p} ; + tvPartReg = \get, along, to -> mkTV (vPartReg get along) to ; + + vBe = verbBe ** {s1 = [] ; lock_V = <>} ; + vHave = verbP3Have ** {s1 = [] ; lock_V = <>} ; + + tvGen = \s,p -> mkTV (vGen s) p ; + tvDir = \v -> mkTV v [] ; + tvGenDir = \s -> tvDir (vGen s) ; + +} ; diff --git a/lib/resource-0.6/english/Predication.gf b/lib/resource-0.6/english/Predication.gf new file mode 100644 index 000000000..4285a8e24 --- /dev/null +++ b/lib/resource-0.6/english/Predication.gf @@ -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 (AdjP1 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 (AdjP1 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) ; + +} ; diff --git a/lib/resource-0.6/english/ResourceEng.gf b/lib/resource-0.6/english/ResourceEng.gf new file mode 100644 index 000000000..452b36780 --- /dev/null +++ b/lib/resource-0.6/english/ResourceEng.gf @@ -0,0 +1,3 @@ +--# -path=.:../abstract:../../prelude + +resource ResourceEng = reuse StructuralEng ; diff --git a/lib/resource-0.6/english/StructuralEng.gf b/lib/resource-0.6/english/StructuralEng.gf new file mode 100644 index 000000000..98771c1c0 --- /dev/null +++ b/lib/resource-0.6/english/StructuralEng.gf @@ -0,0 +1,103 @@ +--# -path=.:../abstract:../../prelude + +--1 The Top-Level English Resource Grammar: Structural Words +-- +-- Aarne Ranta 2002 -- 2003 +-- +concrete StructuralEng of Structural = + CombinationsEng ** open Prelude, SyntaxEng in { + lin + INP = pronI ; + ThouNP = pronYouSg ; + HeNP = pronHe ; + SheNP = pronShe ; + ItNP = pronIt ; + WeNP = pronWithNum pronWe ; + YeNP = pronWithNum pronYouPl ; + YouNP = pronYouSg ; + TheyNP = pronThey ; + + EveryDet = everyDet ; + AllDet = mkDeterminer Sg "all" ; --- all the missing + AllsDet = mkDeterminerNum Pl "all" ; + WhichDet = whichDet ; + WhichsDet = mkDeterminerNum Pl "which" ; + MostsDet = mostDet ; + MostDet = mkDeterminer Sg "most" ; + SomeDet = mkDeterminer Sg "some" ; + SomesDet = mkDeterminerNum Pl "some" ; + AnyDet = mkDeterminer Sg "any" ; + AnysDet = mkDeterminerNum Pl "any" ; + NoDet = mkDeterminer Sg "no" ; + NosDet = mkDeterminerNum Pl "no" ; + ManyDet = mkDeterminer Pl "many" ; + MuchDet = mkDeterminer Sg ["a lot of"] ; --- + ThisDet = mkDeterminer Sg "this" ; + TheseDet = mkDeterminerNum Pl "these" ; + ThatDet = mkDeterminer Sg "that" ; + ThoseDet = mkDeterminerNum Pl "those" ; + + ThisNP = nameNounPhrase (nameReg "this") ; + ThatNP = nameNounPhrase (nameReg "that") ; + TheseNP n = nameNounPhrase {s = \\c => "these" ++ n.s ! c} ; --- Pl; Gen! + ThoseNP n = nameNounPhrase {s = \\c => "those" ++ n.s ! c} ; --- Pl; Gen! + + EverybodyNP = nameNounPhrase (nameReg "everybody") ; + SomebodyNP = nameNounPhrase (nameReg "somebody") ; + NobodyNP = nameNounPhrase (nameReg "nobody") ; + EverythingNP = nameNounPhrase (nameReg "everything") ; + SomethingNP = nameNounPhrase (nameReg "something") ; + NothingNP = nameNounPhrase (nameReg "nothing") ; + + CanVV = vvCan ; + CanKnowVV = vvCan ; + MustVV = vvMust ; + WantVV = verbNoPart (regVerbP3 "want") ** {isAux = False} ; + + HowIAdv = ss "how" ; + WhenIAdv = ss "when" ; + WhereIAdv = ss "where" ; + WhyIAdv = ss "why" ; + EverywhereNP = advPost "everywhere" ; + SomewhereNP = advPost "somewhere" ; + NowhereNP = advPost "nowhere" ; + + AndConj = ss "and" ** {n = Pl} ; + OrConj = ss "or" ** {n = Sg} ; + BothAnd = sd2 "both" "and" ** {n = Pl} ; + EitherOr = sd2 "either" "or" ** {n = Sg} ; + NeitherNor = sd2 "neither" "nor" ** {n = Sg} ; + IfSubj = ss "if" ; + WhenSubj = ss "when" ; + AlthoughSubj = ss "although" ; + + PhrYes = ss "Yes." ; + PhrNo = ss "No." ; + + VeryAdv = ss "very" ; + TooAdv = ss "too" ; + AlmostAdv = ss "almost" ; + QuiteAdv = ss "quite" ; + OtherwiseAdv = ss "otherwise" ; + ThereforeAdv = ss "therefore" ; + + InPrep = ss "in" ; + OnPrep = ss "on" ; + ToPrep = ss "to" ; + ThroughPrep = ss "through" ; + AbovePrep = ss "above" ; + UnderPrep = ss "under" ; + InFrontPrep = ss ["in front of"] ; + BehindPrep = ss "behind" ; + BetweenPrep = ss "between" ; + FromPrep = ss "from" ; + BeforePrep = ss "before" ; + DuringPrep = ss "during" ; + AfterPrep = ss "after" ; + WithPrep = ss "with" ; + WithoutPrep = ss "without" ; + ByMeansPrep = ss "by" ; + PartPrep = ss "of" ; + AgentPrep = ss "by" ; + +} diff --git a/lib/resource-0.6/english/SyntaxEng.gf b/lib/resource-0.6/english/SyntaxEng.gf new file mode 100644 index 000000000..6bd0ddb82 --- /dev/null +++ b/lib/resource-0.6/english/SyntaxEng.gf @@ -0,0 +1,1027 @@ +--# -path=.:../../prelude + +--1 A Small English Resource Syntax +-- +-- Aarne Ranta 2002 +-- +-- This resource grammar contains definitions needed to construct +-- indicative, interrogative, and imperative sentences in English. +-- +-- The following files are presupposed: + +resource SyntaxEng = MorphoEng ** open Prelude, (CO = Coordination) in { + +--2 Common Nouns +-- +-- Simple common nouns are defined as the type $CommNoun$ in $morpho.Deu.gf$. + +--3 Common noun phrases + +-- To the common nouns of morphology, +-- we add natural gender (human/nonhuman) which is needed in syntactic +-- combinations (e.g. "man who runs" - "program which runs"). + +oper + CommNoun = CommonNoun ** {g : Gender} ; + + CommNounPhrase = CommNoun ; + + noun2CommNounPhrase : CommNoun -> CommNounPhrase = \man -> + man ; + + cnGen : CommonNoun -> Gender -> CommNoun = \cn,g -> + cn ** {g = g} ; + + cnHum : CommonNoun -> CommNoun = \cn -> + cnGen cn Hum ; + cnNoHum : CommonNoun -> CommNoun = \cn -> + cnGen cn NoHum ; + +--2 Noun phrases +-- +-- The worst case is pronouns, which have inflection in the possessive forms. +-- Proper names are a special case. + + NounPhrase : Type = Pronoun ; + + nameNounPhrase : ProperName -> NounPhrase = \john -> + {s = \\c => john.s ! toCase c ; n = Sg ; p = P3} ; + +-- The following construction has to be refined for genitive forms: +-- "we two", "us two" are OK, but "our two" is not. + + Numeral : Type = {s : Case => Str} ; + + pronWithNum : Pronoun -> Numeral -> Pronoun = \we,two -> + {s = \\c => we.s ! c ++ two.s ! toCase c ; n = we.n ; p = we.p} ; + + noNum : Numeral = {s = \\_ => []} ; + +--2 Determiners +-- +-- Determiners are inflected according to the nouns they determine. +-- The determiner is not inflected. + + Determiner : Type = {s : Str ; n : Number} ; + + detNounPhrase : Determiner -> CommNounPhrase -> NounPhrase = \every, man -> + {s = \\c => every.s ++ man.s ! every.n ! toCase c ; + n = every.n ; + p = P3 + } ; + + mkDeterminer : Number -> Str -> Determiner = \n,the -> + mkDeterminerNum n the noNum ; + + mkDeterminerNum : Number -> Str -> Numeral -> Determiner = \n,det,two -> + {s = det ++ two.s ! Nom ; + n = n + } ; + + everyDet = mkDeterminer Sg "every" ; + allDet = mkDeterminerNum Pl "all" ; + mostDet = mkDeterminer Pl "most" ; + aDet = mkDeterminer Sg artIndef ; + plDet = mkDeterminerNum Pl [] ; + theSgDet = mkDeterminer Sg "the" ; + thePlDet = mkDeterminerNum Pl "the" ; + anySgDet = mkDeterminer Sg "any" ; + anyPlDet = mkDeterminerNum Pl "any" ; + + whichSgDet = mkDeterminer Sg "which" ; + whichPlDet = mkDeterminerNum Pl "which" ; + + whichDet = whichSgDet ; --- API + + indefNoun : Number -> CommNoun -> Str = \n,man -> + (indefNounPhrase n man).s ! NomP ; + + indefNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n -> + indefNounPhraseNum n noNum ; + + indefNounPhraseNum : Number -> Numeral ->CommNounPhrase -> NounPhrase = + \n,two,man -> + {s = \\c => case n of { + Sg => artIndef ++ two.s ! Nom ++ man.s ! n ! toCase c ; + Pl => two.s ! Nom ++ man.s ! n ! toCase c + } ; + n = n ; p = P3 + } ; + + defNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n -> + defNounPhraseNum n noNum ; + defNounPhraseNum : Number -> Numeral -> CommNounPhrase -> NounPhrase = + \n,two,car -> + {s = \\c => artDef ++ two.s ! Nom ++ car.s ! n ! toCase c ; + n = n ; + p = P3 + } ; + +-- Genitives of noun phrases can be used like determiners, to build noun phrases. +-- The number argument makes the difference between "my house" - "my houses". +-- +-- We have the variation "the car of John / the car of John's / John's car" + + npGenDet : Number -> Numeral -> NounPhrase -> CommNounPhrase -> NounPhrase = + \n,two,john,car -> + {s = \\c => variants { + artDef ++ two.s ! Nom ++ car.s ! n ! Nom ++ "of" ++ john.s ! GenSP ; + john.s ! GenP ++ two.s ! Nom ++ car.s ! n ! toCase c + } ; + n = n ; + p = P3 + } ; + +-- *Bare plural noun phrases* like "men", "good cars", are built without a +-- determiner word. + + plurDet : CommNounPhrase -> NounPhrase = \cn -> + {s = \\c => cn.s ! plural ! toCase c ; + p = P3 ; + n = Pl + } ; + +-- Constructions like "the idea that two is even" are formed at the +-- first place as common nouns, so that one can also have "a suggestion that...". + + nounThatSentence : CommNounPhrase -> Sentence -> CommNounPhrase = \idea,x -> + {s = \\n,c => idea.s ! n ! c ++ "that" ++ x.s ; + g = idea.g + } ; + + +--2 Adjectives +-- +-- Adjectival phrases have a parameter $p$ telling if they are prefixed ($True$) or +-- postfixed (complex APs). + + AdjPhrase : Type = Adjective ** {p : Bool} ; + + adj2adjPhrase : Adjective -> AdjPhrase = \new -> new ** {p = True} ; + + simpleAdjPhrase : Str -> AdjPhrase = \French -> + adj2adjPhrase (regAdjective French) ; + + +--3 Comparison adjectives +-- +-- Each of the comparison forms has a characteristic use: +-- +-- Positive forms are used alone, as adjectival phrases ("big"). + + positAdjPhrase : AdjDegr -> AdjPhrase = \big -> + adj2adjPhrase {s = big.s ! Pos} ; + +-- Comparative forms are used with an object of comparison, as +-- adjectival phrases ("bigger then you"). + + comparAdjPhrase : AdjDegr -> NounPhrase -> AdjPhrase = \big, you -> + {s = \\a => big.s ! Comp ! a ++ "than" ++ you.s ! NomP ; + p = False + } ; + +-- Superlative forms are used with a modified noun, picking out the +-- maximal representative of a domain ("the biggest house"). + + superlNounPhrase : AdjDegr -> CommNoun -> NounPhrase = \big, house -> + {s = \\c => "the" ++ big.s ! Sup ! AAdj ++ house.s ! Sg ! toCase c ; + n = Sg ; + p = P3 + } ; + + +--3 Two-place adjectives +-- +-- A two-place adjective is an adjective with a preposition used before +-- the complement. + + Preposition = Str ; + + AdjCompl = Adjective ** {s2 : Preposition} ; + + complAdj : AdjCompl -> NounPhrase -> AdjPhrase = \related,john -> + {s = \\a => related.s ! a ++ related.s2 ++ john.s ! AccP ; + p = False + } ; + + +--3 Modification of common nouns +-- +-- The two main functions of adjective are in predication ("John is old") +-- and in modification ("an old man"). Predication will be defined +-- later, in the chapter on verbs. +-- +-- Modification must pay attention to pre- and post-noun +-- adjectives: "big car"/"car bigger than X" + + modCommNounPhrase : AdjPhrase -> CommNounPhrase -> CommNounPhrase = \big, car -> + {s = \\n => if_then_else (Case => Str) big.p + (\\c => big.s ! AAdj ++ car.s ! n ! c) + (table {Nom => car.s ! n ! Nom ++ big.s ! AAdj ; Gen => variants {}}) ; + g = car.g + } ; + + +--2 Function expressions + +-- A function expression is a common noun together with the +-- preposition prefixed to its argument ("mother of x"). +-- The type is analogous to two-place adjectives and transitive verbs. + + Function = CommNounPhrase ** {s2 : Preposition} ; + +-- The application of a function gives, in the first place, a common noun: +-- "mother/mothers of John". From this, other rules of the resource grammar +-- give noun phrases, such as "the mother of John", "the mothers of John", +-- "the mothers of John and Mary", and "the mother of John and Mary" (the +-- latter two corresponding to distributive and collective functions, +-- respectively). Semantics will eventually tell when each +-- of the readings is meaningful. + + appFunComm : Function -> NounPhrase -> CommNounPhrase = \mother,john -> + {s = \\n => table { + Gen => nonExist ; --- ? + _ => mother.s ! n ! Nom ++ mother.s2 ++ john.s ! GenSP + } ; + g = mother.g + } ; + +-- It is possible to use a function word as a common noun; the semantics is +-- often existential or indexical. + + funAsCommNounPhrase : Function -> CommNounPhrase = + noun2CommNounPhrase ; + +-- The following is an aggregate corresponding to the original function application +-- producing "John's mother" and "the mother of John". It does not appear in the +-- resource grammar API any longer. + + appFun : Bool -> Function -> NounPhrase -> NounPhrase = \coll, mother,john -> + let {n = john.n ; nf = if_then_else Number coll Sg n} in + variants { + defNounPhrase nf (appFunComm mother john) ; + npGenDet nf noNum john mother + } ; + +-- The commonest case is functions with the preposition "of". + + funOf : CommNoun -> Function = \mother -> + mother ** {s2 = "of"} ; + + funOfReg : Str -> Gender -> Function = \mother,g -> + funOf (nounReg mother ** {g = g}) ; + +-- Two-place functions add one argument place. + + Function2 = Function ** {s3 : Preposition} ; + +-- There application starts by filling the first place. + + appFun2 : Function2 -> NounPhrase -> Function = \train, paris -> + {s = \\n,c => train.s ! n ! c ++ train.s2 ++ paris.s ! AccP ; + g = train.g ; + s2 = train.s3 + } ; + + +--2 Verbs +-- +--3 Verb phrases +-- +-- 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. + + VerbGroup = { + s : Bool => VForm => Str ; + s2 : Bool => Number => Str ; + isAuxT : Bool ; + isAuxF : Bool + } ; + + VerbPhrase = VerbP3 ** {s2 : Number => Str ; isAux : Bool} ; + + predVerbGroup : Bool -> VerbGroup -> VerbPhrase = \b,vg -> { + s = vg.s ! b ; + s2 = vg.s2 ! b ; + isAux = if_then_else Bool b vg.isAuxT vg.isAuxF + } ; + +-- 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 : Verb -> VerbGroup = \walk -> + {s = \\b,v => if_then_Str b + (walk.s ! v ++ walk.s1) + (contractNot (verbP3Do.s ! v)) ; + s2 = \\b,_ => if_then_Str b + [] + (walk.s ! InfImp ++ walk.s1) ; + isAuxT = False ; + isAuxF = 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 : Adjective -> VerbGroup = \old -> + {s = beOrNotBe ; + s2 = \\_,_ => old.s ! AAdj ; + isAuxT, isAuxF = True + } ; + + predCommNoun : CommNoun -> VerbGroup = \man -> + {s = beOrNotBe ; + s2 = \\_,n => indefNoun n man ; + isAuxT, isAuxF = True + } ; + + predNounPhrase : NounPhrase -> VerbGroup = \john -> + {s = beOrNotBe ; + s2 = \\_,_ => john.s ! NomP ; + isAuxT, isAuxF = True + } ; + + predAdverb : Adverb -> VerbGroup = \elsewhere -> + {s = beOrNotBe ; + s2 = \\_,_ => elsewhere.s ; + isAuxT, isAuxF = True + } ; + +-- We use an auxiliary giving all forms of "be". + + beOrNotBe : Bool => VForm => Str = \\b => + if_then_else (VForm => Str) b + verbBe.s + (table { + InfImp => contractNot "do" ++ "be" ; + Indic P1 => "am" ++ "not" ; + v => contractNot (verbBe.s ! v) + }) ; + +--3 Transitive verbs +-- +-- Transitive verbs are verbs with a preposition for the complement, +-- in analogy with two-place adjectives and functions. +-- One might prefer to use the term "2-place verb", since +-- "transitive" traditionally means that the inherent preposition is empty. +-- Such a verb is one with a *direct object*. + + TransVerb : Type = Verb ** {s3 : Preposition} ; + +-- The rule for using transitive verbs is the complementization rule. +-- Particles produce free variation: before or after the complement +-- ("I switch on the TV" / "I switch the TV on"). + + complTransVerb : TransVerb -> NounPhrase -> VerbGroup = \lookat,john -> + let lookatjohn = bothWays lookat.s1 (lookat.s3 ++ john.s ! AccP) + in {s = \\b,v => if_then_Str b (lookat.s ! v) (contractNot (verbP3Do.s ! v)) ; + s2 = \\b,_ => if_then_Str b lookatjohn (lookat.s ! InfImp ++ lookatjohn) ; + isAuxT = False ; + isAuxF = 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 [] ; + +-- Transitive verbs with accusative objects can be used passively. +-- The function does not check that the verb is transitive. +-- Therefore, the function can also be used for "he is swum", etc. +-- The syntax is the same as for adjectival predication. + + passVerb : Verb -> VerbGroup = \love -> + predAdjective (adj2adjPhrase (regAdjective (love.s ! PPart))) ; + +-- Transitive verbs can also be used reflexively. +-- But to formalize this we must make verb phrases depend on a person parameter. + +--- reflTransVerb : TransVerb -> VerbGroup = \love -> + + +-- Transitive verbs can be used elliptically as verbs. The semantics +-- is left to applications. The definition is trivial, due to record +-- subtyping. + + transAsVerb : TransVerb -> Verb = \love -> + love ; + +-- *Ditransitive verbs* are verbs with three argument places. +-- We treat so far only the rule in which the ditransitive +-- verb takes both complements to form a verb phrase. + + DitransVerb = TransVerb ** {s4 : Preposition} ; + + mkDitransVerb : Verb -> Preposition -> Preposition -> DitransVerb = \v,p1,p2 -> + v ** {s3 = p1 ; s4 = p2} ; + + complDitransVerb : DitransVerb -> NounPhrase -> NounPhrase -> VerbGroup = + \give,you,beer -> + let + youbeer = give.s1 ++ give.s3 ++ you.s ! AccP ++ give.s4 ++ beer.s ! AccP + in + {s = \\b,v => if_then_Str b (give.s ! v) (contractNot (verbP3Do.s ! v)) ; + s2 = \\b,_ => if_then_Str b youbeer (give.s ! InfImp ++ youbeer) ; + isAuxT = False ; + isAuxF = True + } ; + + +--2 Adverbials +-- +-- Adverbials are not inflected (we ignore comparison, and treat +-- compared adverbials as separate expressions; this could be done another way). +-- We distinguish between post- and pre-verbal adverbs. + + Adverb : Type = SS ** {p : Bool} ; + + advPre : Str -> Adverb = \seldom -> ss seldom ** {p = False} ; + advPost : Str -> Adverb = \well -> ss well ** {p = True} ; + +-- N.B. this rule generates the cyclic parsing rule $VP#2 ::= VP#2$ +-- and cannot thus be parsed. + + adVerbPhrase : VerbPhrase -> Adverb -> VerbPhrase = \sings, well -> + let {postp = orB well.p sings.isAux} in + { + s = \\v => (if_then_else Str postp [] well.s) ++ sings.s ! v ; + s2 = \\n => sings.s2 ! n ++ (if_then_else Str postp well.s []) ; + isAux = sings.isAux + } ; + + advAdjPhrase : SS -> AdjPhrase -> AdjPhrase = \very, good -> + {s = \\a => very.s ++ good.s ! a ; + p = good.p + } ; + +-- Adverbials are typically generated by prefixing prepositions. +-- The rule for creating locative noun phrases by the preposition "in" +-- is a little shaky, since other prepositions may be preferred ("on", "at"). + + prepPhrase : Preposition -> NounPhrase -> Adverb = \on, it -> + advPost (on ++ it.s ! AccP) ; + + locativeNounPhrase : NounPhrase -> Adverb = + prepPhrase "in" ; + +-- This is a source of the "mann with a telescope" ambiguity, and may produce +-- strange things, like "cars always" (while "cars today" is OK). +-- Semantics will have to make finer distinctions among adverbials. +-- +-- N.B. the genitive case created in this way would not make sense. + + advCommNounPhrase : CommNounPhrase -> Adverb -> CommNounPhrase = \car,today -> + {s = \\n => table { + Nom => car.s ! n ! Nom ++ today.s ; + Gen => nonExist + } ; + g = car.g + } ; + + +--2 Sentences +-- +-- Sentences are not inflected in this fragment of English without tense. + + Sentence : Type = SS ; + +-- This is the traditional $S -> NP VP$ rule. It takes care of +-- agreement between subject and verb. Recall that the VP may already +-- contain negation. + + predVerbPhrase : NounPhrase -> VerbPhrase -> Sentence = \john,walks -> + ss (john.s ! NomP ++ indicVerb (verbOfPhrase walks) john.p john.n ++ + walks.s2 ! john.n) ; + + + +--3 Sentence-complement verbs +-- +-- Sentence-complement verbs take sentences as complements. + + SentenceVerb : Type = Verb ; + +-- To generate "says that John walks" / "doesn't say that John walks": + + complSentVerb : SentenceVerb -> Sentence -> VerbGroup = \say,johnruns -> + let {thatjohnruns = optStr "that" ++ johnruns.s} in + {s = \\b,v => if_then_Str b (say.s ! v) (contractNot (verbP3Do.s ! v)) ; + s2 = \\b,_ => if_then_Str b thatjohnruns (say.s ! InfImp ++ thatjohnruns) ; + isAuxT = False ; + isAuxF = True + } ; + +--3 Verb-complement verbs +-- +-- Sentence-complement verbs take verb phrases as complements. +-- They can be auxiliaries ("can", "must") or ordinary verbs +-- ("try"); this distinction cannot be done in the multilingual +-- API and leads to some anomalies in English, such as the necessity +-- to create the infinitive form "to be able to" for "can" so that +-- the construction can be iterated, and the corresponding complication +-- in the parameter structure. + + VerbVerb : Type = Verb ** {isAux : Bool} ; + +-- To generate "can walk"/"can't walk"; "tries to walk"/"does not try to walk": +-- The contraction of "not" is not provided, since it would require changing +-- the verb parameter type. + + complVerbVerb : VerbVerb -> VerbGroup -> VerbGroup = \try,run -> + let + taux = try.isAux ; + to = if_then_Str taux [] "to" ; + dont = table VForm {v => if_then_Str taux + (try.s ! v ++ "not") -- can not + (contractNot (verbP3Do.s ! v)) -- doesn't ... + } ; + trnot = if_then_Str taux + [] -- + (try.s ! InfImp ++ try.s1) ; -- ... try + in + {s = \\b,v => if_then_Str b + (try.s ! v ++ try.s1 ++ to ++ run.s ! True ! InfImp) + (dont ! v) ; + s2 = \\b,v => if_then_Str b + (run.s2 ! True ! v) + (trnot ++ run.s ! True ! InfImp ++ run.s2 ! True ! v) ; + isAuxT = taux ; + isAuxF = True + } ; + +-- The three most important example auxiliaries. + + mkVerbAux : (_,_,_,_: Str) -> VerbVerb = \beable, can, could, beenable -> + {s = table { + InfImp => beable ; + Indic _ => can ; + Past _ => could ; + PPart => beenable + } ; + s1 = [] ; + isAux = True + } ; + + vvCan : VerbVerb = mkVerbAux ["be able to"] "can" "could" ["been able to"] ; + vvMust : VerbVerb = mkVerbAux ["have to"] "must" ["had to"] ["had to"] ; + +--2 Sentences missing noun phrases +-- +-- This is one instance of Gazdar's *slash categories*, corresponding to his +-- $S/NP$. +-- We cannot have - nor would we want to have - a productive slash-category former. +-- Perhaps a handful more will be needed. +-- +-- Notice that the slash category has a similar relation to sentences as +-- transitive verbs have to verbs: it's like a *sentence taking a complement*. +-- However, we need something more to distinguish its use in direct questions: +-- not just "you see" but ("whom") "do you see". +-- +-- The particle always follows the verb, but the preposition can fly: +-- "whom you make it up with" / "with whom you make it up". + + SentenceSlashNounPhrase = {s : Bool => Str ; s2 : Preposition} ; + + slashTransVerb : Bool -> NounPhrase -> TransVerb -> SentenceSlashNounPhrase = + \b,You,lookat -> + let {you = You.s ! NomP ; + looks = indicVerb {s = lookat.s} You.p You.n ; + look = lookat.s ! InfImp ; + do = indicVerb verbP3Do You.p You.n ; + dont = contractNot do ; + up = lookat.s1 + } in + {s = table { + True => if_then_else Str b do dont ++ you ++ look ++ up ; + False => you ++ if_then_else Str b looks (dont ++ look) ++ up + } ; + s2 = lookat.s3 + } ; + + + thereIs : NounPhrase -> Sentence = \abar -> + predVerbPhrase + (case abar.n of { + Sg => nameNounPhrase (nameReg "there") ; + Pl => {s = \\_ => "there" ; n = Pl ; p = P3} + }) + (predVerbGroup True (predNounPhrase abar)) ; + + +--2 Relative pronouns and relative clauses +-- +-- As described in $types.Eng.gf$, relative pronouns are inflected in +-- gender (human/nonhuman), number, and case. +-- +-- We get the simple relative pronoun ("who"/"which"/"whom"/"whose"/"that"/$""$) +-- from $morpho.Eng.gf$. + + identRelPron : RelPron = relPron ; + + funRelPron : Function -> RelPron -> RelPron = \mother,which -> + {s = \\g,n,c => "the" ++ mother.s ! n ! Nom ++ + mother.s2 ++ which.s ! g ! n ! GenSP + } ; + +-- Relative clauses can be formed from both verb phrases ("who walks") and +-- slash expressions ("whom you see", "on which you sit" / "that you sit on"). + + RelClause : Type = {s : Gender => Number => Str} ; + + relVerbPhrase : RelPron -> VerbPhrase -> RelClause = \who,walks -> + {s = \\g, n => who.s ! g ! n ! NomP ++ + indicVerb (verbOfPhrase walks) P3 n ++ walks.s2 ! n + } ; + + relSlash : RelPron -> SentenceSlashNounPhrase -> RelClause = \who,yousee -> + {s = \\g,n => + let {youSee = yousee.s ! False} in + variants { + who.s ! g ! n ! AccP ++ youSee ++ yousee.s2 ; + yousee.s2 ++ who.s ! g ! n ! GenSP ++ youSee + } + } ; + +-- A 'degenerate' relative clause is the one often used in mathematics, e.g. +-- "number x such that x is even". + + relSuch : Sentence -> RelClause = \A -> + {s = \\_,_ => "such" ++ "that" ++ A.s} ; + +-- The main use of relative clauses is to modify common nouns. +-- The result is a common noun, out of which noun phrases can be formed +-- by determiners. No comma is used before these relative clause. + + modRelClause : CommNounPhrase -> RelClause -> CommNounPhrase = \man,whoruns -> + {s = \\n,c => man.s ! n ! c ++ whoruns.s ! man.g ! n ; + g = man.g + } ; + + +--2 Interrogative pronouns +-- +-- If relative pronouns are adjective-like, interrogative pronouns are +-- noun-phrase-like. + + IntPron : Type = {s : NPForm => Str ; n : Number} ; + +-- In analogy with relative pronouns, we have a rule for applying a function +-- to a relative pronoun to create a new one. + + funIntPron : Function -> IntPron -> IntPron = \mother,which -> + {s = \\c => "the" ++ mother.s ! which.n ! Nom ++ mother.s2 ++ which.s ! GenSP ; + n = which.n + } ; + +-- There is a variety of simple interrogative pronouns: +-- "which house", "who", "what". + + nounIntPron : Number -> CommNounPhrase -> IntPron = \n, car -> + {s = \\c => "which" ++ car.s ! n ! toCase c ; + n = n + } ; + + intPronWho : Number -> IntPron = \num -> { + s = table { + NomP => "who" ; + AccP => variants {"who" ; "whom"} ; + GenP => "whose" ; + GenSP => "whom" + } ; + n = num + } ; + + intPronWhat : Number -> IntPron = \num -> { + s = table { + GenP => "what's" ; + _ => "what" + } ; + n = num + } ; + + +--2 Utterances + +-- By utterances we mean whole phrases, such as +-- 'can be used as moves in a language game': indicatives, questions, imperative, +-- and one-word utterances. The rules are far from complete. +-- +-- N.B. we have not included rules for texts, which we find we cannot say much +-- about on this level. In semantically rich GF grammars, texts, dialogues, etc, +-- will of course play an important role as categories not reducible to utterances. +-- An example is proof texts, whose semantics show a dependence between premises +-- and conclusions. Another example is intersentential anaphora. + + Utterance = SS ; + + indicUtt : Sentence -> Utterance = \x -> ss (x.s ++ ".") ; + interrogUtt : Question -> Utterance = \x -> ss (x.s ! DirQ ++ "?") ; + + +--2 Questions +-- +-- Questions are either direct ("are you happy") or indirect +-- ("if/whether you are happy"). + +param + QuestForm = DirQ | IndirQ ; + +oper + Question = SS1 QuestForm ; + +--3 Yes-no questions +-- +-- Yes-no questions are used both independently +-- ("does John walk" / "if John walks") +-- and after interrogative adverbials +-- ("why does John walk" / "why John walks"). +-- +-- It is economical to handle with all these cases by the one +-- rule, $questVerbPhrase'$. The word ("ob" / "whether") never appears +-- if there is an adverbial. + + questVerbPhrase : NounPhrase -> VerbPhrase -> Question = + questVerbPhrase' False ; + + questVerbPhrase' : Bool -> NounPhrase -> VerbPhrase -> Question = + \adv,john,walk -> + {s = table { + DirQ => if_then_else Str walk.isAux + (indicVerb (verbOfPhrase walk) john.p john.n ++ + john.s ! NomP ++ walk.s2 ! john.n) + (indicVerb verbP3Do john.p john.n ++ + john.s ! NomP ++ walk.s ! InfImp ++ walk.s2 ! john.n) ; + IndirQ => if_then_else Str adv [] (variants {"if" ; "whether"}) ++ + (predVerbPhrase john walk).s + } + } ; + + isThere : NounPhrase -> Question = \abar -> + questVerbPhrase + (case abar.n of { + Sg => nameNounPhrase (nameReg "there") ; + Pl => {s = \\_ => "there" ; n = Pl ; p = P3} + }) + (predVerbGroup True (predNounPhrase abar)) ; + + +--3 Wh-questions +-- +-- Wh-questions are of two kinds: ones that are like $NP - VP$ sentences, +-- others that are line $S/NP - NP$ sentences. + + intVerbPhrase : IntPron -> VerbPhrase -> Question = \who,walk -> + {s = \\_ => who.s ! NomP ++ indicVerb (verbOfPhrase walk) P3 who.n ++ + walk.s2 ! who.n + } ; + + intSlash : IntPron -> SentenceSlashNounPhrase -> Question = \who,yousee -> + {s = \\q => + let {youSee = case q of { + DirQ => yousee.s ! True ; + IndirQ => yousee.s ! False + } + } in + variants { + who.s ! AccP ++ youSee ++ yousee.s2 ; + yousee.s2 ++ who.s ! GenSP ++ youSee + } + } ; + +--3 Interrogative adverbials +-- +-- These adverbials will be defined in the lexicon: they include +-- "when", "where", "how", "why", etc, which are all invariant one-word +-- expressions. In addition, they can be formed by adding prepositions +-- to interrogative pronouns, in the same way as adverbials are formed +-- from noun phrases. + + IntAdverb = SS ; + + prepIntAdverb : Preposition -> IntPron -> IntAdverb = \at, whom -> + ss (at ++ whom.s ! AccP) ; + +-- A question adverbial can be applied to anything, and whether this makes +-- sense is a semantic question. + + questAdverbial : IntAdverb -> NounPhrase -> VerbPhrase -> Question = + \why, you, walk -> + {s = \\q => why.s ++ (questVerbPhrase' True you walk).s ! q} ; + + +--2 Imperatives +-- +-- We only consider second-person imperatives. + + Imperative = SS1 Number ; + + imperVerbPhrase : VerbPhrase -> Imperative = \walk -> + {s = \\n => walk.s ! InfImp ++ walk.s2 ! n} ; + + imperUtterance : Number -> Imperative -> Utterance = \n,I -> + ss (I.s ! n ++ "!") ; + +--2 Sentence adverbials +-- +-- This class covers adverbials such as "otherwise", "therefore", which are prefixed +-- to a sentence to form a phrase. + + advSentence : SS -> Sentence -> Utterance = \hence,itiseven -> + ss (hence.s ++ itiseven.s ++ ".") ; + + +--2 Coordination +-- +-- Coordination is to some extent orthogonal to the rest of syntax, and +-- has been treated in a generic way in the module $CO$ in the file +-- $coordination.gf$. The overall structure is independent of category, +-- but there can be differences in parameter dependencies. +-- +--3 Conjunctions +-- +-- Coordinated phrases are built by using conjunctions, which are either +-- simple ("and", "or") or distributed ("both - and", "either - or"). +-- +-- The conjunction has an inherent number, which is used when conjoining +-- noun phrases: "John and Mary are..." vs. "John or Mary is..."; in the +-- case of "or", the result is however plural if any of the disjuncts is. + + Conjunction = CO.Conjunction ** {n : Number} ; + ConjunctionDistr = CO.ConjunctionDistr ** {n : Number} ; + +--3 Coordinating sentences +-- +-- We need a category of lists of sentences. It is a discontinuous +-- category, the parts corresponding to 'init' and 'last' segments +-- (rather than 'head' and 'tail', because we have to keep track of the slot between +-- the last two elements of the list). A list has at least two elements. + + ListSentence : Type = SD2 ; + + twoSentence : (_,_ : Sentence) -> ListSentence = CO.twoSS ; + + consSentence : ListSentence -> Sentence -> ListSentence = + CO.consSS CO.comma ; + +-- To coordinate a list of sentences by a simple conjunction, we place +-- it between the last two elements; commas are put in the other slots, +-- e.g. "du rauchst, er trinkt und ich esse". + + conjunctSentence : Conjunction -> ListSentence -> Sentence = \c,xs -> + ss (CO.conjunctX c xs) ; + +-- To coordinate a list of sentences by a distributed conjunction, we place +-- the first part (e.g. "either") in front of the first element, the second +-- part ("or") between the last two elements, and commas in the other slots. +-- For sentences this is really not used. + + conjunctDistrSentence : ConjunctionDistr -> ListSentence -> Sentence = + \c,xs -> + ss (CO.conjunctDistrX c xs) ; + +--3 Coordinating adjective phrases +-- +-- The structure is the same as for sentences. The result is a prefix adjective +-- if and only if all elements are prefix. + + ListAdjPhrase : Type = {s1,s2 : AForm => Str ; p : Bool} ; + + twoAdjPhrase : (_,_ : AdjPhrase) -> ListAdjPhrase = \x,y -> + CO.twoTable AForm x y ** {p = andB x.p y.p} ; + + consAdjPhrase : ListAdjPhrase -> AdjPhrase -> ListAdjPhrase = \xs,x -> + CO.consTable AForm CO.comma xs x ** {p = andB xs.p x.p} ; + + conjunctAdjPhrase : Conjunction -> ListAdjPhrase -> AdjPhrase = \c,xs -> + CO.conjunctTable AForm c xs ** {p = xs.p} ; + + conjunctDistrAdjPhrase : ConjunctionDistr -> ListAdjPhrase -> AdjPhrase = + \c,xs -> + CO.conjunctDistrTable AForm c xs ** {p = xs.p} ; + + +--3 Coordinating noun phrases +-- +-- The structure is the same as for sentences. The result is either always plural +-- or plural if any of the components is, depending on the conjunction. + + ListNounPhrase : Type = {s1,s2 : NPForm => Str ; n : Number ; p : Person} ; + + twoNounPhrase : (_,_ : NounPhrase) -> ListNounPhrase = \x,y -> + CO.twoTable NPForm x y ** {n = conjNumber x.n y.n ; p = conjPerson x.p y.p} ; + + consNounPhrase : ListNounPhrase -> NounPhrase -> ListNounPhrase = \xs,x -> + CO.consTable NPForm CO.comma xs x ** + {n = conjNumber xs.n x.n ; p = conjPerson xs.p x.p} ; + + conjunctNounPhrase : Conjunction -> ListNounPhrase -> NounPhrase = \c,xs -> + CO.conjunctTable NPForm c xs ** {n = conjNumber c.n xs.n ; p = xs.p} ; + + conjunctDistrNounPhrase : ConjunctionDistr -> ListNounPhrase -> NounPhrase = + \c,xs -> + CO.conjunctDistrTable NPForm c xs ** {n = conjNumber c.n xs.n ; p = xs.p} ; + +-- We have to define a calculus of numbers of persons. For numbers, +-- it is like the conjunction with $Pl$ corresponding to $False$. + + conjNumber : Number -> Number -> Number = \m,n -> case of { + => Sg ; + _ => Pl + } ; + +-- For persons, we let the latter argument win ("either you or I am absent" +-- but "either I or you are absent"). This is not quite clear. + + conjPerson : Person -> Person -> Person = \_,p -> + p ; + + + +--2 Subjunction +-- +-- Subjunctions ("when", "if", etc) +-- are a different way to combine sentences than conjunctions. +-- The main clause can be a sentences, an imperatives, or a question, +-- but the subjoined clause must be a sentence. +-- +-- There are uniformly two variant word orders, e.g. +-- "if you smoke I get angry" +-- and "I get angry if you smoke". + + Subjunction = SS ; + + subjunctSentence : Subjunction -> Sentence -> Sentence -> Sentence = + \if, A, B -> + ss (subjunctVariants if A.s B.s) ; + + subjunctImperative : Subjunction -> Sentence -> Imperative -> Imperative = + \if, A, B -> + {s = \\n => subjunctVariants if A.s (B.s ! n)} ; + + subjunctQuestion : Subjunction -> Sentence -> Question -> Question = + \if, A, B -> + {s = \\q => subjunctVariants if A.s (B.s ! q)} ; + + subjunctVariants : Subjunction -> Str -> Str -> Str = \if,A,B -> + variants {if.s ++ A ++ "," ++ B ; B ++ "," ++ if.s ++ A} ; + + subjunctVerbPhrase : VerbPhrase -> Subjunction -> Sentence -> VerbPhrase = + \V, if, A -> + adVerbPhrase V (advPost (if.s ++ A.s)) ; + +--2 One-word utterances +-- +-- An utterance can consist of one phrase of almost any category, +-- the limiting case being one-word utterances. These +-- utterances are often (but not always) in what can be called the +-- default form of a category, e.g. the nominative. +-- This list is far from exhaustive. + + useNounPhrase : NounPhrase -> Utterance = \john -> + postfixSS "." (defaultNounPhrase john) ; + + useCommonNounPhrase : Number -> CommNounPhrase -> Utterance = \n,car -> + useNounPhrase (indefNounPhrase n car) ; + + useRegularName : SS -> NounPhrase = \john -> + nameNounPhrase (nameReg john.s) ; + +-- Here are some default forms. + + defaultNounPhrase : NounPhrase -> SS = \john -> + ss (john.s ! NomP) ; + + defaultQuestion : Question -> SS = \whoareyou -> + ss (whoareyou.s ! DirQ) ; + + defaultSentence : Sentence -> Utterance = \x -> + x ; + +} ; diff --git a/lib/resource-0.6/english/TestResourceEng.gf b/lib/resource-0.6/english/TestResourceEng.gf new file mode 100644 index 000000000..d1f3c13a2 --- /dev/null +++ b/lib/resource-0.6/english/TestResourceEng.gf @@ -0,0 +1,50 @@ +--# -path=.:../abstract:../../prelude + +concrete TestResourceEng of TestResource = StructuralEng ** open SyntaxEng in { + +flags startcat=Phr ; lexer=literals ; parser=chart ; unlexer=text ; + +-- a random sample from the lexicon + +lin + Big = adjDegrIrreg "big" "bigger" "biggest"; + Happy = adjDegrReg "happy" ; + Small = adjDegrReg "small" ; + Old = adjDegrReg "old" ; + Young = adjDegrReg "young" ; + American = regAdjective "American" ; + Finnish = regAdjective "Finnish" ; + Married = regAdjective "married" ** {s2 = "to"} ; + 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") ; + Bar = cnNoHum (nounReg "bar") ; + Bottle = cnNoHum (nounReg "bottle") ; + Wine = cnNoHum (nounReg "wine") ; + Walk = verbNoPart (regVerbP3 "walk") ; + Run = verbNoPart (mkVerb "run" "ran" "run") ; + Say = verbNoPart (mkVerb "say" "said" "said") ; + Prove = verbNoPart (regVerbP3 "prove") ; + Send = mkTransVerbDir (verbNoPart (mkVerb "send" "sent" "sent")) ; + Love = mkTransVerbDir (verbNoPart (verbP3e "love")) ; + Wait = mkTransVerb (verbNoPart (regVerbP3 "wait")) "for" ; + Drink = mkTransVerbDir (verbNoPart (mkVerb "drink" "drank" "drunk")) ; + Give = mkDitransVerb (verbNoPart (mkVerb "give" "gave" "given")) [] [] ; + Prefer = mkDitransVerb + (verbNoPart (mkVerb "prefer" "preferred" "preferred")) [] "to" ; + Mother = funOfReg "mother" Hum ; + Uncle = funOfReg "uncle" Hum ; + Connection = cnNoHum (nounReg "connection") ** {s2 = "from" ; s3 = "to"} ; + + Always = advPre "always" ; + Well = advPost "well" ; + + SwitchOn = mkTransVerbPart (verbP3s "switch") "on" ; + SwitchOff = mkTransVerbPart (verbP3s "switch") "off" ; + + John = nameReg "John" ; + Mary = nameReg "Mary" ; + +} ; diff --git a/lib/resource-0.6/english/TypesEng.gf b/lib/resource-0.6/english/TypesEng.gf new file mode 100644 index 000000000..61682c14f --- /dev/null +++ b/lib/resource-0.6/english/TypesEng.gf @@ -0,0 +1,104 @@ +--1 English Word Classes and Morphological Parameters +-- +-- This is a resource module for English morphology, defining the +-- morphological parameters and word classes of English. It is aimed +-- to be complete w.r.t. the description of word forms. +-- However, it only includes those parameters that are needed for +-- analysing individual words: such parameters are defined in syntax modules. +-- +-- We use the language-independent prelude. + +resource TypesEng = open Prelude in { + +-- +--2 Enumerated parameter types +-- +-- These types are the ones found in school grammars. +-- Their parameter values are atomic. + +param + Number = Sg | Pl ; + Gender = NoHum | Hum ; + Case = Nom | Gen ; + Person = P1 | P2 | P3 ; + Degree = Pos | Comp | Sup ; + +-- For data abstraction, we define + +oper + singular = Sg ; + plural = Pl ; + +--2 Word classes and hierarchical parameter types +-- +-- Real parameter types (i.e. ones on which words and phrases depend) +-- are often hierarchical. The alternative would be cross-products of +-- simple parameters, but this would usually overgenerate. +-- + +--3 Common nouns +-- +-- Common nouns are inflected in number and case. + + CommonNoun : Type = {s : Number => Case => Str} ; + + +-- +--3 Adjectives +-- +-- The major division is between the comparison degrees, but it +-- is also good to leave room for adjectives that cannon be compared. +-- It is, however, productive to form an adverbial from any adjective. + +param AForm = AAdj | AAdv ; + +oper + Adjective : Type = SS1 AForm ; + AdjDegr = {s : Degree => AForm => Str} ; + +--3 Verbs +-- +-- We treat the full conjugation now. +-- The present tense is made to depend on person, which correspond to forms +-- in the singular; plural forms are uniformly equal to the 2nd person singular. + +param + VForm = InfImp | Indic Person | Past Number | PPart ; + +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} ; +} ; + diff --git a/lib/resource-0.6/swedish/CombinationsSwe.gf b/lib/resource-0.6/swedish/CombinationsSwe.gf new file mode 100644 index 000000000..dfc7115d9 --- /dev/null +++ b/lib/resource-0.6/swedish/CombinationsSwe.gf @@ -0,0 +1,199 @@ +--# -path=.:../abstract:../../prelude + +--1 The Top-Level Swedish Resource Grammar: Combination Rules +-- +-- Aarne Ranta 2002 -- 2003 +-- +-- This is the Swedish concrete syntax of the multilingual resource +-- grammar. Most of the work is done in the file $SyntaxSwe.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 $TypesSwe.gf$. + +concrete CombinationsSwe of Combinations = open Prelude, SyntaxSwe in { + +flags + startcat=Phr ; + lexer=text ; + unlexer=text ; + +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 = Function ; + -- = CommNoun ** {s2 : Preposition} ; + Fun2 = Function ** {s3 : Preposition} ; + Num = {s : Case => Str} ; + Prep = {s : Str} ; + + Adj1 = Adjective ; + -- = {s : AdjFormPos => Case => Str} ; + Adj2 = Adjective ** {s2 : Preposition} ; + AdjDeg = {s : AdjForm => Str} ; + AP = Adjective ** {p : IsPostfixAdj} ; + + V = Verb ; + -- = {s : VForm => Str ; s1 : Str} ; + VG = {s : VForm => Str ; s2 : Bool => Str ; s3 : Gender => Number => Str} ; + VP = {s : VForm => Str ; s2 : Str ; s3 : Gender => Number => Str} ; + TV = TransVerb ; + -- = Verb ** {s2 : Preposition} ; + V3 = TransVerb ** {s3 : Preposition} ; + VS = Verb ; + VV = Verb ** {isAux : Bool} ; + + 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 noNum ; + ModGenMany = npGenDet plural ; + UsePN = nameNounPhrase ; + UseFun = funAsCommNounPhrase ; + AppFun = appFunComm ; + AppFun2 = appFun2 ; + AdjP1 = adj2adjPhrase ; + ComplAdj = complAdj ; + PositAdjP = positAdjPhrase ; + ComparAdjP = comparAdjPhrase ; + SuperlNP = superlNounPhrase ; + + DetNP = detNounPhrase ; + IndefOneNP = indefNounPhrase singular ; + IndefManyNP = indefNounPhraseNum plural ; + DefOneNP = defNounPhrase singular ; + DefManyNP = defNounPhraseNum plural ; + MassNP = detNounPhrase (mkDeterminerSg (detSgInvar []) IndefP) ; + UseInt i = {s = table {Nom => i.s ; Gen => i.s ++ "s"}} ; --- + NoNum = noNum ; + + CNthatS = nounThatSentence ; + + PredVP = predVerbPhrase ; + PosVG = predVerbGroup True ; + NegVG = predVerbGroup False ; + + PredV = predVerb ; + PredAP = predAdjective ; + PredCN = predCommNoun ; + PredTV = complTransVerb ; + PredV3 = complDitransVerb ; + PredPassV = passVerb ; + PredNP = predNounPhrase ; + PredAdV = predAdverb ; + PredVS = complSentVerb ; + PredVV = complVerbVerb ; + VTrans = transAsVerb ; + + AdjAdv a = advPost (a.s ! adverbForm ! Nom) ; + PrepNP p = prepPhrase p.s ; --- + AdvVP = adVerbPhrase ; + AdvCN = advCommNounPhrase ; + AdvAP = advAdjPhrase ; + + ThereNP A = predVerbPhrase npDet + (predVerbGroup True + (complTransVerb (mkDirectVerb verbFinnas) A)) ; + + PosSlashTV = slashTransVerb True ; + NegSlashTV = slashTransVerb False ; + OneVP = predVerbPhrase npMan ; + + IdRP = identRelPron ; + FunRP = funRelPron ; + RelVP = relVerbPhrase ; + RelSlash = relSlash ; + ModRC = modRelClause ; + RelSuch = relSuch ; + + WhoOne = intPronWho singular ; + WhoMany = intPronWho plural ; + WhatOne = intPronWhat singular ; + WhatMany = intPronWhat plural ; + FunIP = funIntPron ; + NounIPOne = nounIntPron singular ; + NounIPMany = nounIntPron plural ; + + QuestVP = questVerbPhrase ; + IntVP = intVerbPhrase ; + IntSlash = intSlash ; + QuestAdv = questAdverbial ; + IsThereNP A = questVerbPhrase npDet + (predVerbGroup True + (complTransVerb (mkDirectVerb verbFinnas) A)) ; + + ImperVP = imperVerbPhrase ; + + IndicPhrase = indicUtt ; + QuestPhrase = interrogUtt ; + ImperOne = imperUtterance singular ; + ImperMany = imperUtterance plural ; + + AdvS = advSentence ; + + TwoS = twoSentence ; + ConsS = consSentence ; + ConjS = conjunctSentence ; + ConjDS = conjunctDistrSentence ; + + TwoAP = twoAdjPhrase ; + ConsAP = consAdjPhrase ; + ConjAP = conjunctAdjPhrase ; + ConjDAP = conjunctDistrAdjPhrase ; + + TwoNP = twoNounPhrase ; + ConsNP = consNounPhrase ; + ConjNP = conjunctNounPhrase ; + ConjDNP = conjunctDistrNounPhrase ; + + SubjS = subjunctSentence ; + SubjImper = subjunctImperative ; + SubjQu = subjunctQuestion ; + SubjVP = subjunctVerbPhrase ; + + PhrNP = useNounPhrase ; + PhrOneCN = useCommonNounPhrase singular ; + PhrManyCN = useCommonNounPhrase plural ; + PhrIP ip = ip ; + PhrIAdv ia = ia ; + + OnePhr p = p ; + ConsPhr = cc2 ; + +} ; diff --git a/lib/resource-0.6/swedish/MorphoSwe.gf b/lib/resource-0.6/swedish/MorphoSwe.gf new file mode 100644 index 000000000..ab55497e3 --- /dev/null +++ b/lib/resource-0.6/swedish/MorphoSwe.gf @@ -0,0 +1,1168 @@ +--1 A Simple Swedish Resource Morphology +-- +-- Aarne Ranta 2002 +-- +-- This resource morphology contains definitions needed in the resource +-- syntax. It moreover contains copies of the most usual inflectional patterns +-- as defined in functional morphology (in the Haskell file $RulesSw.hs$). +-- +-- We use the parameter types and word classes defined for morphology. + +resource MorphoSwe = TypesSwe ** open Prelude in { + +-- The indefinite and definite article +oper + artIndef = table {Utr => "en" ; Neutr => "ett"} ; + + artDef : Bool => GenNum => Str = table { + True => table { + ASg Utr => "den" ; + ASg Neutr => "det" ; -- det gamla huset + APl => variants {"de" ; "dom"} + } ; + False => table {_ => []} -- huset + } ; + +-- A simplified verb category: present tense only. +oper + verbVara = extVerb Act vara_1200 ; + verbHava = extVerb Act hava_1198 ; + verbFinnas = mkVerb "finnas" "finns" "finns" ; + +-- A simplified conjugation takes three forms in the worst case, plus a particle. + + mkVerbPart : (supa,super,sup,upp : Str) -> Verb = \supa,super,sup,upp -> + {s = table { + VPres Infinit Act => supa ; + VPres Infinit Pass => supa + "s" ; + VPres Indicat Act => super ; + VPres Indicat Pass => sup + "s" ; + VPres Imperat Act => sup ; + VPres Imparat Pass => sup + "s" + } ; + s1 = upp + } ; + +-- The most common is a verb without a particle. + + mkVerb : (supa,super,sup : Str) -> Verb = \supa,super,sup -> + mkVerbPart supa super sup [] ; + +-- Prepositions are just strings. + Preposition = Str ; + +-- Relative pronouns have a special case system. $RPrep$ is the form used +-- after a preposition (e.g. "det hus i vilket jag bor"). +param + RelCase = RNom | RAcc | RGen | RPrep ; + +oper + relPronForms : RelCase => GenNum => Str = table { + RNom => \\_ => "som" ; + RAcc => \\_ => variants {"som" ; []} ; + RGen => \\_ => "vars" ; + RPrep => pronVilken + } ; + + pronVilken = table { + ASg Utr => "vilken" ; + ASg Neutr => "vilket" ; + APl => "vilka" + } ; + + pronSådan = table { + ASg Utr => "sådan" ; + ASg Neutr => "sådant" ; + APl => "sådana" + } ; + +-- What follows are machine-generated inflection paradigms from functional +-- morphology. Hence they are low-level paradigms, without any +-- abstractions or generalizations: the Haskell code is better in these respects. +-- +-- The variable names are selected in such a way that the paradigms can be read +-- as inflection tables of certain words. + +oper sApa : Str -> Subst = \ap -> + {s = table { + SF Sg Indef Nom => ap + "a" ; + SF Sg Indef Gen => ap + "as" ; + SF Sg Def Nom => ap + "an" ; + SF Sg Def Gen => ap + "ans" ; + SF Pl Indef Nom => ap + "or" ; + SF Pl Indef Gen => ap + "ors" ; + SF Pl Def Nom => ap + "orna" ; + SF Pl Def Gen => ap + "ornas" + } ; + h1 = Utr + } ; + +oper sBil : Str -> Subst = \bil -> + {s = table { + SF Sg Indef Nom => bil ; + SF Sg Indef Gen => bil + "s" ; + SF Sg Def Nom => bil + "en" ; + SF Sg Def Gen => bil + "ens" ; + SF Pl Indef Nom => bil + "ar" ; + SF Pl Indef Gen => bil + "ars" ; + SF Pl Def Nom => bil + "arna" ; + SF Pl Def Gen => bil + "arnas" + } ; + h1 = Utr + } ; + +oper sPojke : Str -> Subst = \pojk -> + {s = table { + SF Sg Indef Nom => pojk + "e" ; + SF Sg Indef Gen => pojk + "es" ; + SF Sg Def Nom => pojk + "en" ; + SF Sg Def Gen => pojk + "ens" ; + SF Pl Indef Nom => pojk + "ar" ; + SF Pl Indef Gen => pojk + "ars" ; + SF Pl Def Nom => pojk + "arna" ; + SF Pl Def Gen => pojk + "arnas" + } ; + h1 = Utr + } ; + +oper sNyckel : Str -> Subst = \nyck -> + {s = table { + SF Sg Indef Nom => nyck + "el" ; + SF Sg Indef Gen => nyck + "els" ; + SF Sg Def Nom => nyck + "eln" ; + SF Sg Def Gen => nyck + "elns" ; + SF Pl Indef Nom => nyck + "lar" ; + SF Pl Indef Gen => nyck + "lars" ; + SF Pl Def Nom => nyck + "larna" ; + SF Pl Def Gen => nyck + "larnas" + } ; + h1 = Utr + } ; + +oper sKam : Str -> Subst = \kam -> + {s = table { + SF Sg Indef Nom => kam ; + SF Sg Indef Gen => kam + "s" ; + SF Sg Def Nom => kam + "men" ; + SF Sg Def Gen => kam + "mens" ; + SF Pl Indef Nom => kam + "mar" ; + SF Pl Indef Gen => kam + "mars" ; + SF Pl Def Nom => kam + "marna" ; + SF Pl Def Gen => kam + "marnas" + } ; + h1 = Utr + } ; + +oper sSak : Str -> Subst = \sak -> + {s = table { + SF Sg Indef Nom => sak ; + SF Sg Indef Gen => sak + "s" ; + SF Sg Def Nom => sak + "en" ; + SF Sg Def Gen => sak + "ens" ; + SF Pl Indef Nom => sak + "er" ; + SF Pl Indef Gen => sak + "ers" ; + SF Pl Def Nom => sak + "erna" ; + SF Pl Def Gen => sak + "ernas" + } ; + h1 = Utr + } ; + +oper sVarelse : Str -> Subst = \varelse -> + {s = table { + SF Sg Indef Nom => varelse ; + SF Sg Indef Gen => varelse + "s" ; + SF Sg Def Nom => varelse + "n" ; + SF Sg Def Gen => varelse + "ns" ; + SF Pl Indef Nom => varelse + "r" ; + SF Pl Indef Gen => varelse + "rs" ; + SF Pl Def Nom => varelse + "rna" ; + SF Pl Def Gen => varelse + "rnas" + } ; + h1 = Utr + } ; + +oper sNivå : Str -> Subst = \nivå -> + {s = table { + SF Sg Indef Nom => nivå ; + SF Sg Indef Gen => nivå + "s" ; + SF Sg Def Nom => nivå + "n" ; + SF Sg Def Gen => nivå + "ns" ; + SF Pl Indef Nom => nivå + "er" ; + SF Pl Indef Gen => nivå + "ers" ; + SF Pl Def Nom => nivå + "erna" ; + SF Pl Def Gen => nivå + "ernas" + } ; + h1 = Utr + } ; + +oper sParti : Str -> Subst = \parti -> + {s = table { + SF Sg Indef Nom => parti ; + SF Sg Indef Gen => parti + "s" ; + SF Sg Def Nom => parti + "et" ; + SF Sg Def Gen => parti + "ets" ; + SF Pl Indef Nom => parti + "er" ; + SF Pl Indef Gen => parti + "ers" ; + SF Pl Def Nom => parti + "erna" ; + SF Pl Def Gen => parti + "ernas" + } ; + h1 = Neutr + } ; + +oper sMuseum : Str -> Subst = \muse -> + {s = table { + SF Sg Indef Nom => muse + "um" ; + SF Sg Indef Gen => muse + "ums" ; + SF Sg Def Nom => muse + "et" ; + SF Sg Def Gen => muse + "ets" ; + SF Pl Indef Nom => muse + "er" ; + SF Pl Indef Gen => muse + "ers" ; + SF Pl Def Nom => muse + "erna" ; + SF Pl Def Gen => muse + "ernas" + } ; + h1 = Neutr + } ; + +oper sRike : Str -> Subst = \rike -> + {s = table { + SF Sg Indef Nom => rike ; + SF Sg Indef Gen => rike + "s" ; + SF Sg Def Nom => rike + "t" ; + SF Sg Def Gen => rike + "ts" ; + SF Pl Indef Nom => rike + "n" ; + SF Pl Indef Gen => rike + "ns" ; + SF Pl Def Nom => rike + "na" ; + SF Pl Def Gen => rike + "nas" + } ; + h1 = Neutr + } ; + +oper sLik : Str -> Subst = \lik -> + {s = table { + SF Sg Indef Nom => lik ; + SF Sg Indef Gen => lik + "s" ; + SF Sg Def Nom => lik + "et" ; + SF Sg Def Gen => lik + "ets" ; + SF Pl Indef Nom => lik ; + SF Pl Indef Gen => lik + "s" ; + SF Pl Def Nom => lik + "en" ; + SF Pl Def Gen => lik + "ens" + } ; + h1 = Neutr + } ; + +oper sRum : Str -> Subst = \rum -> + {s = table { + SF Sg Indef Nom => rum ; + SF Sg Indef Gen => rum + "s" ; + SF Sg Def Nom => rum + "met" ; + SF Sg Def Gen => rum + "mets" ; + SF Pl Indef Nom => rum ; + SF Pl Indef Gen => rum + "s" ; + SF Pl Def Nom => rum + "men" ; + SF Pl Def Gen => rum + "mens" + } ; + h1 = Neutr + } ; + +oper sHus : Str -> Subst = \hus -> + {s = table { + SF Sg Indef Nom => hus ; + SF Sg Indef Gen => hus ; + SF Sg Def Nom => hus + "et" ; + SF Sg Def Gen => hus + "ets" ; + SF Pl Indef Nom => hus ; + SF Pl Indef Gen => hus ; + SF Pl Def Nom => hus + "en" ; + SF Pl Def Gen => hus + "ens" + } ; + h1 = Neutr + } ; + +oper sPapper : Str -> Subst = \papp -> + {s = table { + SF Sg Indef Nom => papp + "er" ; + SF Sg Indef Gen => papp + "ers" ; + SF Sg Def Nom => papp + "ret" ; + SF Sg Def Gen => papp + "rets" ; + SF Pl Indef Nom => papp + "er" ; + SF Pl Indef Gen => papp + "ers" ; + SF Pl Def Nom => papp + "ren" ; + SF Pl Def Gen => papp + "rens" + } ; + h1 = Neutr + } ; + +oper sNummer : Str -> Subst = \num -> + {s = table { + SF Sg Indef Nom => num + "mer" ; + SF Sg Indef Gen => num + "mers" ; + SF Sg Def Nom => num + "ret" ; + SF Sg Def Gen => num + "rets" ; + SF Pl Indef Nom => num + "mer" ; + SF Pl Indef Gen => num + "mers" ; + SF Pl Def Nom => num + "ren" ; + SF Pl Def Gen => num + "rens" + } ; + h1 = Neutr + } ; + +oper sKikare : Str -> Subst = \kikar -> + {s = table { + SF Sg Indef Nom => kikar + "e" ; + SF Sg Indef Gen => kikar + "es" ; + SF Sg Def Nom => kikar + "en" ; + SF Sg Def Gen => kikar + "ens" ; + SF Pl Indef Nom => kikar + "e" ; + SF Pl Indef Gen => kikar + "es" ; + SF Pl Def Nom => kikar + "na" ; + SF Pl Def Gen => kikar + "nas" + } ; + h1 = Utr + } ; + +oper sProgram : Str -> Subst = \program -> + {s = table { + SF Sg Indef Nom => program ; + SF Sg Indef Gen => program + "s" ; + SF Sg Def Nom => program + "met" ; + SF Sg Def Gen => program + "mets" ; + SF Pl Indef Nom => program ; + SF Pl Indef Gen => program + "s" ; + SF Pl Def Nom => program + "men" ; + SF Pl Def Gen => program + "mens" + } ; + h1 = Neutr + } ; + +oper aFin : Str -> Adj = \fin -> + {s = table { + AF (Posit (Strong (ASg Utr))) Nom => fin ; + AF (Posit (Strong (ASg Utr))) Gen => fin + "s" ; + AF (Posit (Strong (ASg Neutr))) Nom => fin + "t" ; + AF (Posit (Strong (ASg Neutr))) Gen => fin + "ts" ; + AF (Posit (Strong APl)) Nom => fin + "a" ; + AF (Posit (Strong APl)) Gen => fin + "as" ; + AF (Posit (Weak (AxSg NoMasc))) Nom => fin + "a" ; + AF (Posit (Weak (AxSg NoMasc))) Gen => fin + "as" ; + AF (Posit (Weak (AxSg Masc))) Nom => fin + "e" ; + AF (Posit (Weak (AxSg Masc))) Gen => fin + "es" ; + AF (Posit (Weak AxPl)) Nom => fin + "a" ; + AF (Posit (Weak AxPl)) Gen => fin + "as" ; + AF Compar Nom => fin + "are" ; + AF Compar Gen => fin + "ares" ; + AF (Super SupStrong) Nom => fin + "ast" ; + AF (Super SupStrong) Gen => fin + "asts" ; + AF (Super SupWeak) Nom => fin + "aste" ; + AF (Super SupWeak) Gen => fin + "astes" + } + } ; + +oper aFager : Str -> Adj = \fag -> + {s = table { + AF (Posit (Strong (ASg Utr))) Nom => fag + "er" ; + AF (Posit (Strong (ASg Utr))) Gen => fag + "ers" ; + AF (Posit (Strong (ASg Neutr))) Nom => fag + "ert" ; + AF (Posit (Strong (ASg Neutr))) Gen => fag + "erts" ; + AF (Posit (Strong APl)) Nom => fag + "era" ; + AF (Posit (Strong APl)) Gen => fag + "eras" ; + AF (Posit (Weak (AxSg NoMasc))) Nom => fag + "era" ; + AF (Posit (Weak (AxSg NoMasc))) Gen => fag + "eras" ; + AF (Posit (Weak (AxSg Masc))) Nom => fag + "ere" ; + AF (Posit (Weak (AxSg Masc))) Gen => fag + "eres" ; + AF (Posit (Weak AxPl)) Nom => fag + "era" ; + AF (Posit (Weak AxPl)) Gen => fag + "eras" ; + AF Compar Nom => fag + "erare" ; + AF Compar Gen => fag + "erares" ; + AF (Super SupStrong) Nom => fag + "erast" ; + AF (Super SupStrong) Gen => fag + "erasts" ; + AF (Super SupWeak) Nom => fag + "eraste" ; + AF (Super SupWeak) Gen => fag + "erastes" + } + } ; + +oper aGrund : Str -> Adj = \grun -> + {s = table { + AF (Posit (Strong (ASg Utr))) Nom => grun + "d" ; + AF (Posit (Strong (ASg Utr))) Gen => grun + "ds" ; + AF (Posit (Strong (ASg Neutr))) Nom => grun + "t" ; + AF (Posit (Strong (ASg Neutr))) Gen => grun + "ts" ; + AF (Posit (Strong APl)) Nom => grun + "da" ; + AF (Posit (Strong APl)) Gen => grun + "das" ; + AF (Posit (Weak (AxSg NoMasc))) Nom => grun + "da" ; + AF (Posit (Weak (AxSg NoMasc))) Gen => grun + "das" ; + AF (Posit (Weak (AxSg Masc))) Nom => grun + "de" ; + AF (Posit (Weak (AxSg Masc))) Gen => grun + "des" ; + AF (Posit (Weak AxPl)) Nom => grun + "da" ; + AF (Posit (Weak AxPl)) Gen => grun + "das" ; + AF Compar Nom => grun + "dare" ; + AF Compar Gen => grun + "dares" ; + AF (Super SupStrong) Nom => grun + "dast" ; + AF (Super SupStrong) Gen => grun + "dasts" ; + AF (Super SupWeak) Nom => grun + "daste" ; + AF (Super SupWeak) Gen => grun + "dastes" + } + } ; + +oper aVid : Str -> Adj = \vi -> + {s = table { + AF (Posit (Strong (ASg Utr))) Nom => vi + "d" ; + AF (Posit (Strong (ASg Utr))) Gen => vi + "ds" ; + AF (Posit (Strong (ASg Neutr))) Nom => vi + "tt" ; + AF (Posit (Strong (ASg Neutr))) Gen => vi + "tts" ; + AF (Posit (Strong APl)) Nom => vi + "da" ; + AF (Posit (Strong APl)) Gen => vi + "das" ; + AF (Posit (Weak (AxSg NoMasc))) Nom => vi + "da" ; + AF (Posit (Weak (AxSg NoMasc))) Gen => vi + "das" ; + AF (Posit (Weak (AxSg Masc))) Nom => vi + "de" ; + AF (Posit (Weak (AxSg Masc))) Gen => vi + "des" ; + AF (Posit (Weak AxPl)) Nom => vi + "da" ; + AF (Posit (Weak AxPl)) Gen => vi + "das" ; + AF Compar Nom => vi + "dare" ; + AF Compar Gen => vi + "dares" ; + AF (Super SupStrong) Nom => vi + "dast" ; + AF (Super SupStrong) Gen => vi + "dasts" ; + AF (Super SupWeak) Nom => vi + "daste" ; + AF (Super SupWeak) Gen => vi + "dastes" + } + } ; + +oper aVaken : Str -> Adj = \vak -> + {s = table { + AF (Posit (Strong (ASg Utr))) Nom => vak + "en" ; + AF (Posit (Strong (ASg Utr))) Gen => vak + "ens" ; + AF (Posit (Strong (ASg Neutr))) Nom => vak + "et" ; + AF (Posit (Strong (ASg Neutr))) Gen => vak + "ets" ; + AF (Posit (Strong APl)) Nom => vak + "na" ; + AF (Posit (Strong APl)) Gen => vak + "nas" ; + AF (Posit (Weak (AxSg NoMasc))) Nom => vak + "na" ; + AF (Posit (Weak (AxSg NoMasc))) Gen => vak + "nas" ; + AF (Posit (Weak (AxSg Masc))) Nom => vak + "ne" ; + AF (Posit (Weak (AxSg Masc))) Gen => vak + "nes" ; + AF (Posit (Weak AxPl)) Nom => vak + "na" ; + AF (Posit (Weak AxPl)) Gen => vak + "nas" ; + AF Compar Nom => vak + "nare" ; + AF Compar Gen => vak + "nares" ; + AF (Super SupStrong) Nom => vak + "nast" ; + AF (Super SupStrong) Gen => vak + "nasts" ; + AF (Super SupWeak) Nom => vak + "naste" ; + AF (Super SupWeak) Gen => vak + "nastes" + } + } ; + +oper aKorkad : Str -> Adj = \korka -> + {s = table { + AF (Posit (Strong (ASg Utr))) Nom => korka + "d" ; + AF (Posit (Strong (ASg Utr))) Gen => korka + "ds" ; + AF (Posit (Strong (ASg Neutr))) Nom => korka + "t" ; + AF (Posit (Strong (ASg Neutr))) Gen => korka + "ts" ; + AF (Posit (Strong APl)) Nom => korka + "de" ; + AF (Posit (Strong APl)) Gen => korka + "des" ; + AF (Posit (Weak (AxSg NoMasc))) Nom => korka + "de" ; + AF (Posit (Weak (AxSg NoMasc))) Gen => korka + "des" ; + AF (Posit (Weak (AxSg Masc))) Nom => korka + "de" ; + AF (Posit (Weak (AxSg Masc))) Gen => korka + "des" ; + AF (Posit (Weak AxPl)) Nom => korka + "de" ; + AF (Posit (Weak AxPl)) Gen => korka + "des" ; + AF Compar Nom => variants {} ; + AF Compar Gen => variants {} ; + AF (Super SupStrong) Nom => variants {} ; + AF (Super SupStrong) Gen => variants {} ; + AF (Super SupWeak) Nom => variants {} ; + AF (Super SupWeak) Gen => variants {} + } + } ; + +oper aAbstrakt : Str -> Adj = \abstrakt -> + {s = table { + AF (Posit (Strong (ASg Utr))) Nom => abstrakt ; + AF (Posit (Strong (ASg Utr))) Gen => abstrakt + "s" ; + AF (Posit (Strong (ASg Neutr))) Nom => abstrakt ; + AF (Posit (Strong (ASg Neutr))) Gen => abstrakt + "s" ; + AF (Posit (Strong APl)) Nom => abstrakt + "a" ; + AF (Posit (Strong APl)) Gen => abstrakt + "as" ; + AF (Posit (Weak (AxSg NoMasc))) Nom => abstrakt + "a" ; + AF (Posit (Weak (AxSg NoMasc))) Gen => abstrakt + "as" ; + AF (Posit (Weak (AxSg Masc))) Nom => abstrakt + "e" ; + AF (Posit (Weak (AxSg Masc))) Gen => abstrakt + "es" ; + AF (Posit (Weak AxPl)) Nom => abstrakt + "a" ; + AF (Posit (Weak AxPl)) Gen => abstrakt + "as" ; + AF Compar Nom => abstrakt + "are" ; + AF Compar Gen => abstrakt + "ares" ; + AF (Super SupStrong) Nom => abstrakt + "ast" ; + AF (Super SupStrong) Gen => abstrakt + "asts" ; + AF (Super SupWeak) Nom => abstrakt + "aste" ; + AF (Super SupWeak) Gen => abstrakt + "astes" + } + } ; + +oper vTala : Str -> Verbum = \tal -> + {s = table { + VF (Pres Ind Act) => tal + "ar" ; + VF (Pres Ind Pass) => tal + "as" ; + VF (Pres Cnj Act) => tal + "e" ; + VF (Pres Cnj Pass) => tal + "es" ; + VF (Pret Ind Act) => tal + "ade" ; + VF (Pret Ind Pass) => tal + "ades" ; + VF (Pret Cnj Act) => tal + "ade" ; + VF (Pret Cnj Pass) => tal + "ades" ; + VF Imper => tal + "a" ; + VI (Inf Act) => tal + "a" ; + VI (Inf Pass) => tal + "as" ; + VI (Supin Act) => tal + "at" ; + VI (Supin Pass) => tal + "ats" ; + VI (PtPres Nom) => tal + "ande" ; + VI (PtPres Gen) => tal + "andes" ; + VI (PtPret (Strong (ASg Utr)) Nom) => tal + "ad" ; + VI (PtPret (Strong (ASg Utr)) Gen) => tal + "ads" ; + VI (PtPret (Strong (ASg Neutr)) Nom) => tal + "at" ; + VI (PtPret (Strong (ASg Neutr)) Gen) => tal + "ats" ; + VI (PtPret (Strong APl) Nom) => tal + "ade" ; + VI (PtPret (Strong APl) Gen) => tal + "ades" ; + VI (PtPret (Weak (AxSg NoMasc)) Nom) => tal + "ade" ; + VI (PtPret (Weak (AxSg NoMasc)) Gen) => tal + "ades" ; + VI (PtPret (Weak (AxSg Masc)) Nom) => tal + "ade" ; + VI (PtPret (Weak (AxSg Masc)) Gen) => tal + "ades" ; + VI (PtPret (Weak AxPl) Nom) => tal + "ade" ; + VI (PtPret (Weak AxPl) Gen) => tal + "ades" + } + } ; + +oper vLeka : Str -> Verbum = \lek -> + {s = table { + VF (Pres Ind Act) => lek + "er" ; + VF (Pres Ind Pass) => variants {lek + "s" ; lek + "es"} ; + VF (Pres Cnj Act) => lek + "e" ; + VF (Pres Cnj Pass) => lek + "es" ; + VF (Pret Ind Act) => lek + "te" ; + VF (Pret Ind Pass) => lek + "tes" ; + VF (Pret Cnj Act) => lek + "te" ; + VF (Pret Cnj Pass) => lek + "tes" ; + VF Imper => lek ; + VI (Inf Act) => lek + "a" ; + VI (Inf Pass) => lek + "as" ; + VI (Supin Act) => lek + "t" ; + VI (Supin Pass) => lek + "ts" ; + VI (PtPres Nom) => lek + "ande" ; + VI (PtPres Gen) => lek + "andes" ; + VI (PtPret (Strong (ASg Utr)) Nom) => lek + "t" ; + VI (PtPret (Strong (ASg Utr)) Gen) => lek + "ts" ; + VI (PtPret (Strong (ASg Neutr)) Nom) => lek + "t" ; + VI (PtPret (Strong (ASg Neutr)) Gen) => lek + "ts" ; + VI (PtPret (Strong APl) Nom) => lek + "ta" ; + VI (PtPret (Strong APl) Gen) => lek + "tas" ; + VI (PtPret (Weak (AxSg NoMasc)) Nom) => lek + "ta" ; + VI (PtPret (Weak (AxSg NoMasc)) Gen) => lek + "tas" ; + VI (PtPret (Weak (AxSg Masc)) Nom) => lek + "te" ; + VI (PtPret (Weak (AxSg Masc)) Gen) => lek + "tes" ; + VI (PtPret (Weak AxPl) Nom) => lek + "ta" ; + VI (PtPret (Weak AxPl) Gen) => lek + "tas" + } + } ; + +oper vTyda : Str -> Verbum = \ty -> + {s = table { + VF (Pres Ind Act) => ty + "der" ; + VF (Pres Ind Pass) => variants {ty + "ds" ; ty + "des"} ; + VF (Pres Cnj Act) => ty + "de" ; + VF (Pres Cnj Pass) => ty + "des" ; + VF (Pret Ind Act) => ty + "dde" ; + VF (Pret Ind Pass) => ty + "ddes" ; + VF (Pret Cnj Act) => ty + "dde" ; + VF (Pret Cnj Pass) => ty + "ddes" ; + VF Imper => ty + "d" ; + VI (Inf Act) => ty + "da" ; + VI (Inf Pass) => ty + "das" ; + VI (Supin Act) => ty + "tt" ; + VI (Supin Pass) => ty + "tts" ; + VI (PtPres Nom) => ty + "dande" ; + VI (PtPres Gen) => ty + "dandes" ; + VI (PtPret (Strong (ASg Utr)) Nom) => ty + "dd" ; + VI (PtPret (Strong (ASg Utr)) Gen) => ty + "dds" ; + VI (PtPret (Strong (ASg Neutr)) Nom) => ty + "tt" ; + VI (PtPret (Strong (ASg Neutr)) Gen) => ty + "tts" ; + VI (PtPret (Strong APl) Nom) => ty + "dda" ; + VI (PtPret (Strong APl) Gen) => ty + "ddas" ; + VI (PtPret (Weak (AxSg NoMasc)) Nom) => ty + "dda" ; + VI (PtPret (Weak (AxSg NoMasc)) Gen) => ty + "ddas" ; + VI (PtPret (Weak (AxSg Masc)) Nom) => ty + "dde" ; + VI (PtPret (Weak (AxSg Masc)) Gen) => ty + "ddes" ; + VI (PtPret (Weak AxPl) Nom) => ty + "dda" ; + VI (PtPret (Weak AxPl) Gen) => ty + "ddas" + } + } ; + +oper vVända : Str -> Verbum = \vän -> + {s = table { + VF (Pres Ind Act) => vän + "der" ; + VF (Pres Ind Pass) => variants {vän + "ds" ; vän + "des"} ; + VF (Pres Cnj Act) => vän + "de" ; + VF (Pres Cnj Pass) => vän + "des" ; + VF (Pret Ind Act) => vän + "de" ; + VF (Pret Ind Pass) => vän + "des" ; + VF (Pret Cnj Act) => vän + "de" ; + VF (Pret Cnj Pass) => vän + "des" ; + VF Imper => vän + "d" ; + VI (Inf Act) => vän + "da" ; + VI (Inf Pass) => vän + "das" ; + VI (Supin Act) => vän + "t" ; + VI (Supin Pass) => vän + "ts" ; + VI (PtPres Nom) => vän + "dande" ; + VI (PtPres Gen) => vän + "dandes" ; + VI (PtPret (Strong (ASg Utr)) Nom) => vän + "d" ; + VI (PtPret (Strong (ASg Utr)) Gen) => vän + "ds" ; + VI (PtPret (Strong (ASg Neutr)) Nom) => vän + "t" ; + VI (PtPret (Strong (ASg Neutr)) Gen) => vän + "ts" ; + VI (PtPret (Strong APl) Nom) => vän + "da" ; + VI (PtPret (Strong APl) Gen) => vän + "das" ; + VI (PtPret (Weak (AxSg NoMasc)) Nom) => vän + "da" ; + VI (PtPret (Weak (AxSg NoMasc)) Gen) => vän + "das" ; + VI (PtPret (Weak (AxSg Masc)) Nom) => vän + "de" ; + VI (PtPret (Weak (AxSg Masc)) Gen) => vän + "des" ; + VI (PtPret (Weak AxPl) Nom) => vän + "da" ; + VI (PtPret (Weak AxPl) Gen) => vän + "das" + } + } ; + +oper vByta : Str -> Verbum = \by -> + {s = table { + VF (Pres Ind Act) => by + "ter" ; + VF (Pres Ind Pass) => variants {by + "ts" ; by + "tes"} ; + VF (Pres Cnj Act) => by + "te" ; + VF (Pres Cnj Pass) => by + "tes" ; + VF (Pret Ind Act) => by + "tte" ; + VF (Pret Ind Pass) => by + "ttes" ; + VF (Pret Cnj Act) => by + "tte" ; + VF (Pret Cnj Pass) => by + "ttes" ; + VF Imper => by + "t" ; + VI (Inf Act) => by + "ta" ; + VI (Inf Pass) => by + "tas" ; + VI (Supin Act) => by + "tt" ; + VI (Supin Pass) => by + "tts" ; + VI (PtPres Nom) => by + "tande" ; + VI (PtPres Gen) => by + "tandes" ; + VI (PtPret (Strong (ASg Utr)) Nom) => by + "tt" ; + VI (PtPret (Strong (ASg Utr)) Gen) => by + "tts" ; + VI (PtPret (Strong (ASg Neutr)) Nom) => by + "tt" ; + VI (PtPret (Strong (ASg Neutr)) Gen) => by + "tts" ; + VI (PtPret (Strong APl) Nom) => by + "tta" ; + VI (PtPret (Strong APl) Gen) => by + "ttas" ; + VI (PtPret (Weak (AxSg NoMasc)) Nom) => by + "tta" ; + VI (PtPret (Weak (AxSg NoMasc)) Gen) => by + "ttas" ; + VI (PtPret (Weak (AxSg Masc)) Nom) => by + "tte" ; + VI (PtPret (Weak (AxSg Masc)) Gen) => by + "ttes" ; + VI (PtPret (Weak AxPl) Nom) => by + "tta" ; + VI (PtPret (Weak AxPl) Gen) => by + "ttas" + } + } ; + +oper vGömma : Str -> Verbum = \göm -> + {s = table { + VF (Pres Ind Act) => göm + "mer" ; + VF (Pres Ind Pass) => variants {göm + "s" ; göm + "mes"} ; + VF (Pres Cnj Act) => göm + "me" ; + VF (Pres Cnj Pass) => göm + "mes" ; + VF (Pret Ind Act) => göm + "de" ; + VF (Pret Ind Pass) => göm + "des" ; + VF (Pret Cnj Act) => göm + "de" ; + VF (Pret Cnj Pass) => göm + "des" ; + VF Imper => göm ; + VI (Inf Act) => göm + "ma" ; + VI (Inf Pass) => göm + "mas" ; + VI (Supin Act) => göm + "t" ; + VI (Supin Pass) => göm + "ts" ; + VI (PtPres Nom) => göm + "mande" ; + VI (PtPres Gen) => göm + "mandes" ; + VI (PtPret (Strong (ASg Utr)) Nom) => göm + "d" ; + VI (PtPret (Strong (ASg Utr)) Gen) => göm + "ds" ; + VI (PtPret (Strong (ASg Neutr)) Nom) => göm + "t" ; + VI (PtPret (Strong (ASg Neutr)) Gen) => göm + "ts" ; + VI (PtPret (Strong APl) Nom) => göm + "da" ; + VI (PtPret (Strong APl) Gen) => göm + "das" ; + VI (PtPret (Weak (AxSg NoMasc)) Nom) => göm + "da" ; + VI (PtPret (Weak (AxSg NoMasc)) Gen) => göm + "das" ; + VI (PtPret (Weak (AxSg Masc)) Nom) => göm + "de" ; + VI (PtPret (Weak (AxSg Masc)) Gen) => göm + "des" ; + VI (PtPret (Weak AxPl) Nom) => göm + "da" ; + VI (PtPret (Weak AxPl) Gen) => göm + "das" + } + } ; + +oper vHyra : Str -> Verbum = \hyr -> + {s = table { + VF (Pres Ind Act) => hyr ; + VF (Pres Ind Pass) => variants {hyr + "s" ; hyr + "es"} ; + VF (Pres Cnj Act) => hyr + "e" ; + VF (Pres Cnj Pass) => hyr + "es" ; + VF (Pret Ind Act) => hyr + "de" ; + VF (Pret Ind Pass) => hyr + "des" ; + VF (Pret Cnj Act) => hyr + "de" ; + VF (Pret Cnj Pass) => hyr + "des" ; + VF Imper => hyr ; + VI (Inf Act) => hyr + "a" ; + VI (Inf Pass) => hyr + "as" ; + VI (Supin Act) => hyr + "t" ; + VI (Supin Pass) => hyr + "ts" ; + VI (PtPres Nom) => hyr + "ande" ; + VI (PtPres Gen) => hyr + "andes" ; + VI (PtPret (Strong (ASg Utr)) Nom) => hyr + "d" ; + VI (PtPret (Strong (ASg Utr)) Gen) => hyr + "ds" ; + VI (PtPret (Strong (ASg Neutr)) Nom) => hyr + "t" ; + VI (PtPret (Strong (ASg Neutr)) Gen) => hyr + "ts" ; + VI (PtPret (Strong APl) Nom) => hyr + "da" ; + VI (PtPret (Strong APl) Gen) => hyr + "das" ; + VI (PtPret (Weak (AxSg NoMasc)) Nom) => hyr + "da" ; + VI (PtPret (Weak (AxSg NoMasc)) Gen) => hyr + "das" ; + VI (PtPret (Weak (AxSg Masc)) Nom) => hyr + "de" ; + VI (PtPret (Weak (AxSg Masc)) Gen) => hyr + "des" ; + VI (PtPret (Weak AxPl) Nom) => hyr + "da" ; + VI (PtPret (Weak AxPl) Gen) => hyr + "das" + } + } ; + +oper vTåla : Str -> Verbum = \tål -> + {s = table { + VF (Pres Ind Act) => tål ; + VF (Pres Ind Pass) => variants {tål + "s" ; tål + "es"} ; + VF (Pres Cnj Act) => tål + "e" ; + VF (Pres Cnj Pass) => tål + "es" ; + VF (Pret Ind Act) => tål + "de" ; + VF (Pret Ind Pass) => tål + "des" ; + VF (Pret Cnj Act) => tål + "de" ; + VF (Pret Cnj Pass) => tål + "des" ; + VF Imper => tål ; + VI (Inf Act) => tål + "a" ; + VI (Inf Pass) => tål + "as" ; + VI (Supin Act) => tål + "t" ; + VI (Supin Pass) => tål + "ts" ; + VI (PtPres Nom) => tål + "ande" ; + VI (PtPres Gen) => tål + "andes" ; + VI (PtPret (Strong (ASg Utr)) Nom) => tål + "d" ; + VI (PtPret (Strong (ASg Utr)) Gen) => tål + "ds" ; + VI (PtPret (Strong (ASg Neutr)) Nom) => tål + "t" ; + VI (PtPret (Strong (ASg Neutr)) Gen) => tål + "ts" ; + VI (PtPret (Strong APl) Nom) => tål + "da" ; + VI (PtPret (Strong APl) Gen) => tål + "das" ; + VI (PtPret (Weak (AxSg NoMasc)) Nom) => tål + "da" ; + VI (PtPret (Weak (AxSg NoMasc)) Gen) => tål + "das" ; + VI (PtPret (Weak (AxSg Masc)) Nom) => tål + "de" ; + VI (PtPret (Weak (AxSg Masc)) Gen) => tål + "des" ; + VI (PtPret (Weak AxPl) Nom) => tål + "da" ; + VI (PtPret (Weak AxPl) Gen) => tål + "das" + } + } ; + +oper vFinna : (_,_,_ : Str) -> Verbum = \finn, fann, funn -> + {s = table { + VF (Pres Ind Act) => finn + "er" ; + VF (Pres Ind Pass) => variants {finn + "s" ; finn + "es"} ; + VF (Pres Cnj Act) => finn + "e" ; + VF (Pres Cnj Pass) => finn + "es" ; + VF (Pret Ind Act) => fann ; + VF (Pret Ind Pass) => fann + "s" ; + VF (Pret Cnj Act) => funn + "e" ; + VF (Pret Cnj Pass) => funn + "es" ; + VF Imper => finn ; + VI (Inf Act) => finn + "a" ; + VI (Inf Pass) => finn + "as" ; + VI (Supin Act) => funn + "it" ; + VI (Supin Pass) => funn + "its" ; + VI (PtPres Nom) => finn + "ande" ; + VI (PtPres Gen) => finn + "andes" ; + VI (PtPret (Strong (ASg Utr)) Nom) => funn + "en" ; + VI (PtPret (Strong (ASg Utr)) Gen) => funn + "ens" ; + VI (PtPret (Strong (ASg Neutr)) Nom) => funn + "et" ; + VI (PtPret (Strong (ASg Neutr)) Gen) => funn + "ets" ; + VI (PtPret (Strong APl) Nom) => funn + "a" ; + VI (PtPret (Strong APl) Gen) => funn + "as" ; + VI (PtPret (Weak (AxSg NoMasc)) Nom) => funn + "a" ; + VI (PtPret (Weak (AxSg NoMasc)) Gen) => funn + "as" ; + VI (PtPret (Weak (AxSg Masc)) Nom) => funn + "e" ; + VI (PtPret (Weak (AxSg Masc)) Gen) => funn + "es" ; + VI (PtPret (Weak AxPl) Nom) => funn + "a" ; + VI (PtPret (Weak AxPl) Gen) => funn + "as" + } + } ; + +-- machine-generated exceptional inflection tables from rules.Swe.gf + +oper mor_1 : Subst = + {s = table { + SF Sg Indef Nom => variants {"mor" ; "moder"} ; + SF Sg Indef Gen => variants {"mors" ; "moders"} ; + SF Sg Def Nom => "modern" ; + SF Sg Def Gen => "moderns" ; + SF Pl Indef Nom => "mödrar" ; + SF Pl Indef Gen => "mödrars" ; + SF Pl Def Nom => "mödrarna" ; + SF Pl Def Gen => "mödrarnas" + } ; + h1 = Utr + } ; + +oper farbror_8 : Subst = + {s = table { + SF Sg Indef Nom => variants {"farbror" ; "farbroder"} ; + SF Sg Indef Gen => variants {"farbrors" ; "farbroders"} ; + SF Sg Def Nom => "farbrodern" ; + SF Sg Def Gen => "farbroderns" ; + SF Pl Indef Nom => "farbröder" ; + SF Pl Indef Gen => "farbröders" ; + SF Pl Def Nom => "farbröderna" ; + SF Pl Def Gen => "farbrödernas" + } ; + h1 = Utr + } ; + +oper gammal_16 : Adj = + {s = table { + AF (Posit (Strong (ASg Utr))) Nom => "gammal" ; + AF (Posit (Strong (ASg Utr))) Gen => "gammals" ; + AF (Posit (Strong (ASg Neutr))) Nom => "gammalt" ; + AF (Posit (Strong (ASg Neutr))) Gen => "gammalts" ; + AF (Posit (Strong APl)) Nom => "gamla" ; + AF (Posit (Strong APl)) Gen => "gamlas" ; + AF (Posit (Weak (AxSg NoMasc))) Nom => "gamla" ; + AF (Posit (Weak (AxSg NoMasc))) Gen => "gamlas" ; + AF (Posit (Weak (AxSg Masc))) Nom => "gamle" ; + AF (Posit (Weak (AxSg Masc))) Gen => "gamles" ; + AF (Posit (Weak AxPl)) Nom => "gamla" ; + AF (Posit (Weak AxPl)) Gen => "gamlas" ; + AF Compar Nom => "äldre" ; + AF Compar Gen => "äldres" ; + AF (Super SupStrong) Nom => "äldst" ; + AF (Super SupStrong) Gen => "äldsts" ; + AF (Super SupWeak) Nom => "äldsta" ; + AF (Super SupWeak) Gen => "äldstas" + } + } ; + + +oper stor_25 : Adj = + {s = table { + AF (Posit (Strong (ASg Utr))) Nom => "stor" ; + AF (Posit (Strong (ASg Utr))) Gen => "stors" ; + AF (Posit (Strong (ASg Neutr))) Nom => "stort" ; + AF (Posit (Strong (ASg Neutr))) Gen => "storts" ; + AF (Posit (Strong APl)) Nom => "stora" ; + AF (Posit (Strong APl)) Gen => "storas" ; + AF (Posit (Weak (AxSg NoMasc))) Nom => "stora" ; + AF (Posit (Weak (AxSg NoMasc))) Gen => "storas" ; + AF (Posit (Weak (AxSg Masc))) Nom => "store" ; + AF (Posit (Weak (AxSg Masc))) Gen => "stores" ; + AF (Posit (Weak AxPl)) Nom => "stora" ; + AF (Posit (Weak AxPl)) Gen => "storas" ; + AF Compar Nom => "större" ; + AF Compar Gen => "störres" ; + AF (Super SupStrong) Nom => "störst" ; + AF (Super SupStrong) Gen => "störsts" ; + AF (Super SupWeak) Nom => "största" ; + AF (Super SupWeak) Gen => "störstas" + } + } ; + +oper ung_29 : Adj = + {s = table { + AF (Posit (Strong (ASg Utr))) Nom => "ung" ; + AF (Posit (Strong (ASg Utr))) Gen => "ungs" ; + AF (Posit (Strong (ASg Neutr))) Nom => "ungt" ; + AF (Posit (Strong (ASg Neutr))) Gen => "ungts" ; + AF (Posit (Strong APl)) Nom => "unga" ; + AF (Posit (Strong APl)) Gen => "ungas" ; + AF (Posit (Weak (AxSg NoMasc))) Nom => "unga" ; + AF (Posit (Weak (AxSg NoMasc))) Gen => "ungas" ; + AF (Posit (Weak (AxSg Masc))) Nom => "unge" ; + AF (Posit (Weak (AxSg Masc))) Gen => "unges" ; + AF (Posit (Weak AxPl)) Nom => "unga" ; + AF (Posit (Weak AxPl)) Gen => "ungas" ; + AF Compar Nom => "yngre" ; + AF Compar Gen => "yngres" ; + AF (Super SupStrong) Nom => "yngst" ; + AF (Super SupStrong) Gen => "yngsts" ; + AF (Super SupWeak) Nom => "yngsta" ; + AF (Super SupWeak) Gen => "yngstas" + } + } ; + + +oper jag_32 : ProPN = + {s = table { + PNom => "jag" ; + PAcc => "mig" ; + PGen (ASg Utr) => "min" ; + PGen (ASg Neutr) => "mitt" ; + PGen APl => "mina" + } ; + h1 = Utr ; + h2 = Sg ; + h3 = P1 + } ; + +oper du_33 : ProPN = + {s = table { + PNom => "du" ; + PAcc => "dig" ; + PGen (ASg Utr) => "din" ; + PGen (ASg Neutr) => "ditt" ; + PGen APl => "dina" + } ; + h1 = Utr ; + h2 = Sg ; + h3 = P2 + } ; + +oper han_34 : ProPN = + {s = table { + PNom => "han" ; + PAcc => "honom" ; + PGen (ASg Utr) => "hans" ; + PGen (ASg Neutr) => "hans" ; + PGen APl => "hans" + } ; + h1 = Utr ; + h2 = Sg ; + h3 = P3 + } ; + +oper hon_35 : ProPN = + {s = table { + PNom => "hon" ; + PAcc => "henne" ; + PGen (ASg Utr) => "hennes" ; + PGen (ASg Neutr) => "hennes" ; + PGen APl => "hennes" + } ; + h1 = Utr ; + h2 = Sg ; + h3 = P3 + } ; + +oper vi_36 : ProPN = + {s = table { + PNom => "vi" ; + PAcc => "oss" ; + PGen (ASg Utr) => "vår" ; + PGen (ASg Neutr) => "vårt" ; + PGen APl => "våra" + } ; + h1 = Utr ; + h2 = Pl ; + h3 = P1 + } ; + +oper ni_37 : ProPN = + {s = table { + PNom => "ni" ; + PAcc => "er" ; + PGen (ASg Utr) => "er" ; + PGen (ASg Neutr) => "ert" ; + PGen APl => "era" + } ; + h1 = Utr ; + h2 = Pl ; + h3 = P2 + } ; + +oper de_38 : ProPN = + {s = table { + PNom => "de" ; + PAcc => "dem" ; + PGen (ASg Utr) => "deras" ; + PGen (ASg Neutr) => "deras" ; + PGen APl => "deras" + } ; + h1 = Utr ; + h2 = Pl ; + h3 = P3 + } ; + +oper den_39 : ProPN = + {s = table { + PNom => "den" ; + PAcc => "den" ; + PGen (ASg Utr) => "dess" ; + PGen (ASg Neutr) => "dess" ; + PGen APl => "dess" + } ; + h1 = Utr ; + h2 = Sg ; + h3 = P3 + } ; + +oper det_40 : ProPN = + {s = table { + PNom => "det" ; + PAcc => "det" ; + PGen (ASg Utr) => "dess" ; + PGen (ASg Neutr) => "dess" ; + PGen APl => "dess" + } ; + h1 = Neutr ; + h2 = Sg ; + h3 = P3 + } ; + +oper man_1144 : Subst = + {s = table { + SF Sg Indef Nom => "man" ; + SF Sg Indef Gen => "mans" ; + SF Sg Def Nom => "mannen" ; + SF Sg Def Gen => "mannens" ; + SF Pl Indef Nom => "män" ; + SF Pl Indef Gen => "mäns" ; + SF Pl Def Nom => "männen" ; + SF Pl Def Gen => "männens" + } ; + h1 = Utr + } ; + +oper liten_1146 : Adj = + {s = table { + AF (Posit (Strong (ASg Utr))) Nom => "liten" ; + AF (Posit (Strong (ASg Utr))) Gen => "litens" ; + AF (Posit (Strong (ASg Neutr))) Nom => "litet" ; + AF (Posit (Strong (ASg Neutr))) Gen => "litets" ; + AF (Posit (Strong APl)) Nom => "små" ; + AF (Posit (Strong APl)) Gen => "smås" ; + AF (Posit (Weak (AxSg NoMasc))) Nom => "lilla" ; + AF (Posit (Weak (AxSg NoMasc))) Gen => "lillas" ; + AF (Posit (Weak (AxSg Masc))) Nom => "lille" ; + AF (Posit (Weak (AxSg Masc))) Gen => "lilles" ; + AF (Posit (Weak AxPl)) Nom => "små" ; + AF (Posit (Weak AxPl)) Gen => "smås" ; + AF Compar Nom => "mindre" ; + AF Compar Gen => "mindres" ; + AF (Super SupStrong) Nom => "minst" ; + AF (Super SupStrong) Gen => "minsts" ; + AF (Super SupWeak) Nom => "minsta" ; + AF (Super SupWeak) Gen => "minstas" + } + } ; + +oper giva_1147 : Verbum = + {s = table { + VF (Pres Ind Act) => variants {"giver" ; "ger"} ; + VF (Pres Ind Pass) => variants {"gives" ; "givs" ; "ges"} ; + VF (Pres Conj Act) => "give" ; + VF (Pres Conj Pass) => "gives" ; + VF (Pret Ind Act) => "gav" ; + VF (Pret Ind Pass) => "gavs" ; + VF (Pret Conj Act) => "give" ; + VF (Pret Conj Pass) => "gives" ; + VF Imper => variants {"giv" ; "ge"} ; + VI (Inf Act) => variants {"giva" ; "ge"} ; + VI (Inf Pass) => variants {"givas" ; "ges"} ; + VI (Supin Act) => "givit" ; + VI (Supin Pass) => "givits" ; + VI (PtPres Nom) => "givande" ; + VI (PtPres Gen) => "givandes" ; + VI (PtPret (Strong (ASg Utr)) Nom) => "given" ; + VI (PtPret (Strong (ASg Utr)) Gen) => "givens" ; + VI (PtPret (Strong (ASg Neutr)) Nom) => "givet" ; + VI (PtPret (Strong (ASg Neutr)) Gen) => "givets" ; + VI (PtPret (Strong APl) Nom) => "givna" ; + VI (PtPret (Strong APl) Gen) => "givnas" ; + VI (PtPret (Weak (AxSg NoMasc)) Nom) => "givna" ; + VI (PtPret (Weak (AxSg NoMasc)) Gen) => "givnas" ; + VI (PtPret (Weak (AxSg Masc)) Nom) => "givne" ; + VI (PtPret (Weak (AxSg Masc)) Gen) => "givnes" ; + VI (PtPret (Weak AxPl) Nom) => "givna" ; + VI (PtPret (Weak AxPl) Gen) => "givnas" + } + } ; + +oper gå_1174 : Verbum = + {s = table { + VF (Pres Ind Act) => "går" ; + VF (Pres Ind Pass) => "gås" ; + VF (Pres Cnj Act) => "gå" ; + VF (Pres Cnj Pass) => "gås" ; + VF (Pret Ind Act) => "gick" ; + VF (Pret Ind Pass) => "gicks" ; + VF (Pret Cnj Act) => "ginge" ; + VF (Pret Cnj Pass) => "ginges" ; + VF Imper => "gå" ; + VI (Inf Act) => "gå" ; + VI (Inf Pass) => "gås" ; + VI (Supin Act) => "gått" ; + VI (Supin Pass) => "gåtts" ; + VI (PtPres Nom) => "gående" ; + VI (PtPres Gen) => "gåendes" ; + VI (PtPret (Strong (ASg Utr)) Nom) => "gången" ; + VI (PtPret (Strong (ASg Utr)) Gen) => "gångens" ; + VI (PtPret (Strong (ASg Neutr)) Nom) => "gånget" ; + VI (PtPret (Strong (ASg Neutr)) Gen) => "gångets" ; + VI (PtPret (Strong APl) Nom) => "gångna" ; + VI (PtPret (Strong APl) Gen) => "gångnas" ; + VI (PtPret (Weak (AxSg NoMasc)) Nom) => "gångna" ; + VI (PtPret (Weak (AxSg NoMasc)) Gen) => "gångnas" ; + VI (PtPret (Weak (AxSg Masc)) Nom) => "gångne" ; + VI (PtPret (Weak (AxSg Masc)) Gen) => "gångnes" ; + VI (PtPret (Weak AxPl) Nom) => "gångna" ; + VI (PtPret (Weak AxPl) Gen) => "gångnas" + } + } ; +oper hava_1198 : Verbum = + {s = table { + VF (Pres Ind Act) => variants {"haver" ; "har"} ; + VF (Pres Ind Pass) => variants {"havs" ; "has"} ; + VF (Pres Conj Act) => "have" ; + VF (Pres Conj Pass) => "haves" ; + VF (Pret Ind Act) => "hade" ; + VF (Pret Ind Pass) => "hades" ; + VF (Pret Conj Act) => "hade" ; + VF (Pret Conj Pass) => "hades" ; + VF Imper => variants {"hav" ; "ha"} ; + VI (Inf Act) => variants {"hava" ; "ha"} ; + VI (Inf Pass) => variants {"havas" ; "has"} ; + VI (Supin Act) => "haft" ; + VI (Supin Pass) => "hafts" ; + VI (PtPres Nom) => "havande" ; + VI (PtPres Gen) => "havandes" ; + VI (PtPret (Strong (ASg Utr)) Nom) => variants {} ; + VI (PtPret (Strong (ASg Utr)) Gen) => variants {} ; + VI (PtPret (Strong (ASg Neutr)) Nom) => variants {} ; + VI (PtPret (Strong (ASg Neutr)) Gen) => variants {} ; + VI (PtPret (Strong APl) Nom) => variants {} ; + VI (PtPret (Strong APl) Gen) => variants {} ; + VI (PtPret (Weak (AxSg NoMasc)) Nom) => variants {} ; + VI (PtPret (Weak (AxSg NoMasc)) Gen) => variants {} ; + VI (PtPret (Weak (AxSg Masc)) Nom) => variants {} ; + VI (PtPret (Weak (AxSg Masc)) Gen) => variants {} ; + VI (PtPret (Weak AxPl) Nom) => variants {} ; + VI (PtPret (Weak AxPl) Gen) => variants {} + } + } ; + +oper vara_1200 : Verbum = + {s = table { + VF (Pres Ind Act) => "är" ; + VF (Pres Ind Pass) => variants {} ; + VF (Pres Conj Act) => "vare" ; + VF (Pres Conj Pass) => variants {} ; + VF (Pret Ind Act) => "var" ; + VF (Pret Ind Pass) => variants {} ; + VF (Pret Conj Act) => "vore" ; + VF (Pret Conj Pass) => variants {} ; + VF Imper => "var" ; + VI (Inf Act) => "vara" ; + VI (Inf Pass) => variants {} ; + VI (Supin Act) => "varit" ; + VI (Supin Pass) => variants {} ; + VI (PtPres Nom) => "varande" ; + VI (PtPres Gen) => "varandes" ; + VI (PtPret (Strong (ASg Utr)) Nom) => variants {} ; + VI (PtPret (Strong (ASg Utr)) Gen) => variants {} ; + VI (PtPret (Strong (ASg Neutr)) Nom) => variants {} ; + VI (PtPret (Strong (ASg Neutr)) Gen) => variants {} ; + VI (PtPret (Strong APl) Nom) => variants {} ; + VI (PtPret (Strong APl) Gen) => variants {} ; + VI (PtPret (Weak (AxSg NoMasc)) Nom) => variants {} ; + VI (PtPret (Weak (AxSg NoMasc)) Gen) => variants {} ; + VI (PtPret (Weak (AxSg Masc)) Nom) => variants {} ; + VI (PtPret (Weak (AxSg Masc)) Gen) => variants {} ; + VI (PtPret (Weak AxPl) Nom) => variants {} ; + VI (PtPret (Weak AxPl) Gen) => variants {} + } + } ; +} diff --git a/lib/resource-0.6/swedish/ParadigmsSwe.gf b/lib/resource-0.6/swedish/ParadigmsSwe.gf new file mode 100644 index 000000000..94c3cb1a9 --- /dev/null +++ b/lib/resource-0.6/swedish/ParadigmsSwe.gf @@ -0,0 +1,292 @@ +--# -path=.:../abstract:../../prelude + +--1 Swedish 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, $Structural.gf$. +-- +-- The main difference with $MorphoSwe.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 ParadigmsSwe = open (Predef=Predef), Prelude, SyntaxSwe, ResourceSwe in { + +--2 Parameters +-- +-- To abstract over gender names, we define the following identifiers. + +oper + utrum : Gender ; + neutrum : Gender ; + + masculine : Sex ; + nonmasculine : Sex ; + +-- To abstract over case names, we define the following. + + nominative : Case ; + genitive : Case ; + +-- To abstract over number names, we define the following. + + singular : Number ; + plural : Number ; + + +--2 Nouns + +-- Worst case: give all nominative forms and the gender. +-- The genitive is formed automatically, even when the nominative +-- ends with an "s". + + mkN : (_,_,_,_ : Str) -> Gender -> Sex -> N ; + -- man, mannen, män, männen + +-- Here are some common patterns, corresponding to school-gramamr declensions. +-- Except $nPojke$, $nKarl$, and $nMurare$, +-- they are defined to be $nonmasculine$, which means that they don't create +-- the definite adjective form with "e" but with "a". + + nApa : Str -> N ; -- apa (apan, apor, aporna) ; utrum + nBil : Str -> N ; -- bil (bilen, bilar, bilarna) ; utrum + nKarl : Str -> N ; -- karl (karlen, karlar, karlarna) ; utrum ; masculine + nPojke : Str -> N ; -- pojke (pojken, pojkar, pojkarna) ; utrum ; masculine + nNyckel : Str -> N ; -- nyckel (nyckeln, nycklar, nycklarna) ; utrum + nRisk : Str -> N ; -- risk (risken, risker, riskerna) ; utrum + nDike : Str -> N ; -- dike (diket, diken, dikena) ; neutrum + nRep : Str -> N ; -- rep (repet, rep, repen) ; neutrum + nPapper : Str -> N ; -- papper (pappret, papper, pappren) ; neutrum + nMurare : Str -> N ; -- murare (muraren, murare, murarna) ; utrum ; masculine + nKikare : Str -> N ; -- kikare (kikaren, kikare, kikarna) ; utrum + +-- Nouns used as functions need a preposition. The most common ones are "av", +-- "på", and "till". + + mkFun : N -> Preposition -> Fun ; + funAv : N -> Fun ; + funPaa : N -> Fun ; + funTill : N -> Fun ; + +-- Proper names, with their possibly +-- irregular genitive. The regular genitive is "s", omitted after "s". + + mkPN : (_,_ : Str) -> Gender -> Sex -> PN ; -- Karolus, Karoli + pnReg : Str -> Gender -> Sex -> PN ; -- Johan,Johans ; 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) -> Gender -> NP ; + + npReg : Str -> Gender -> NP ; -- Johann, Johanns + + +--2 Adjectives + +-- Non-comparison one-place adjectives need four forms in the worst case: +-- strong singular, weak singular, plural. + + mkAdj1 : (_,_,_,_ : Str) -> Adj1 ; -- liten, litet, lilla, små + +-- Special cases needing one form each are: regular adjectives, +-- adjectives with unstressed "e" in the last syllable, those +-- ending with "n" as a further special case, and invariable +-- adjectives. + + adjReg : Str -> Adj1 ; -- billig (billigt, billiga, billiga) + adjNykter : Str -> Adj1 ; -- nykter (nyktert, nyktra, nyktra) + adjGalen : Str -> Adj1 ; -- galen (galet, galna, galna) + adjInvar : Str -> Adj1 ; -- bra + +-- Two-place adjectives need a preposition and a case as extra arguments. + + mkAdj2 : Adj1 -> Str -> Adj2 ; -- delbar, med + mkAdj2Reg : Str -> Str -> Adj2 ; -- + +-- Comparison adjectives may need the three four forms for the positive case, plus +-- three more forms for the comparison cases. + + mkAdjDeg : (liten, litet, lilla, sma, mindre, minst, minsta : Str) -> AdjDeg ; + +-- Some comparison adjectives are completely regular. + + aReg : Str -> AdjDeg ; + +-- 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. +-- The worst case needs three forms: the infinitive, the indicative, and the +-- imperative. + + mkV : (_,_,_ : Str) -> V ; -- vara, är, var; trivas, trivs, trivs + +-- The main conjugations need one string each. + + vKoka : Str -> V ; -- tala (talar, tala) + vSteka : Str -> V ; -- leka (leker, lek) + vBo : Str -> V ; -- bo (bor, bo) + + vAndas : Str -> V ; -- andas [all forms the same: also "slåss"] + vTrivas : Str -> V ; -- trivas (trivs, trivs) + +-- The verbs 'be' and 'have' are special. + + vVara : V ; + vHa : V ; + +-- Particle verbs are formed by putting together a verb and a particle. +-- If the verb already has a particle, it is replaced by the new one. + + mkPartV : V -> Str -> V ; -- stänga av ; + +-- Two-place verbs, and the special case with direct object. + + mkTV : V -> Preposition -> TV ; -- tycka, om + tvDir : V -> TV ; -- gilla + +-- The definitions should not bother the user of the API. So they are +-- hidden from the document. +--. + + utrum = Utr ; + neutrum = Neutr ; + masculine = Masc ; + nonmasculine = NoMasc ; + nominative = Nom ; + genitive = Gen ; + -- singular defined in Types + -- plural defined in Types + + mkN = \apa, apan, apor, aporna, g, x -> let + {nom = table { + SF Sg Indef _ => apa ; + SF Sg Def _ => apan ; + SF Pl Indef _ => apor ; + SF Pl Def _ => aporna + } + } in + {s = \\n,d,c => mkCase c (nom ! SF n d Nom) ; + g = g ; x = x ; lock_N = <> + } ; + + -- auxiliaries + mkGenit : Tok -> Tok = \s -> ifTok Tok (Predef.dp 1 s) "s" s (s + "s") ; + mkCase : Case -> Tok -> Tok = \c,t -> case c of { + Nom => t ; + Gen => mkGenit t + } ; + + nApa = \apa -> + let {apor = Predef.tk 1 apa + "or"} in + mkN apa (apa + "n") apor (apor + "na") utrum nonmasculine ; + + nBil = \bil -> + mkN bil (bil + "en") (bil + "ar") (bil + "arna") utrum nonmasculine ; + nKarl = \bil -> + mkN bil (bil + "en") (bil + "ar") (bil + "arna") utrum masculine ; + nPojke = \pojke -> + let {bil = Predef.tk 1 pojke} in + mkN pojke (bil + "en") (bil + "ar") (bil + "arna") utrum masculine ; + nNyckel = \cykel -> + let {cykl = Predef.tk 2 cykel + Predef.dp 1 cykel} in + mkN cykel (cykel + "n") (cykl + "ar") (cykl + "arna") utrum nonmasculine ; + nRisk = \bil -> + mkN bil (bil + "en") (bil + "er") (bil + "erna") utrum nonmasculine ; + nDike = \dike -> + mkN dike (dike + "t") (dike + "n") (dike + "na") neutrum nonmasculine ; + nRep = \rep -> + mkN rep (rep + "et") rep (rep + "en") neutrum nonmasculine ; + nPapper = \cykel -> + let {cykl = Predef.tk 2 cykel + Predef.dp 1 cykel} in + mkN cykel (cykl + "et") cykel (cykl + "en") neutrum nonmasculine ; + nMurare = \murare -> + let {murar = Predef.tk 1 murare} in + mkN murare (murar + "en") murare (murar + "na") utrum masculine ; + nKikare = \murare -> + let {murar = Predef.tk 1 murare} in + mkN murare (murar + "en") murare (murar + "na") utrum nonmasculine ; + + + mkFun x y = SyntaxSwe.mkFun x y ** {lock_Fun = <>} ; + funAv = \f -> mkFun f "av" ; + funPaa = \f -> mkFun f "på" ; + funTill = \f -> mkFun f "till" ; + + mkPN = \karolus, karoli, g, x -> + {s = table {Gen => karoli ; _ => karolus} ; g = g ; x = x ; lock_PN = <>} ; + pnReg = \horst -> + mkPN horst (ifTok Tok (Predef.dp 1 horst) "s" horst (horst + "s")) ; + + mkCN = UseN ; + mkNP = \a,b,g -> UsePN (mkPN a b g nonmasculine) ; -- gender irrelevant in NP + npReg = \s,g -> UsePN (pnReg s g nonmasculine) ; + + mkAdj1 = \liten, litet, lilla, små -> + {s = table { + Strong (ASg Utr) => \\c => mkCase c liten ; + Strong (ASg Neutr) => \\c => mkCase c litet ; + Strong APl => \\c => mkCase c små ; + Weak (AxSg Masc) => \\c => mkCase c (Predef.tk 1 lilla + "e") ; + Weak _ => \\c => mkCase c lilla + } ; + lock_Adj1 = <> + } ; + + adjReg = \billig -> mkAdj1 billig (billig + "t") (billig + "a") (billig + "a") ; + adjNykter = \nykter -> + let {nyktr = Predef.tk 2 nykter + Predef.dp 1 nykter} in + mkAdj1 nykter (nykter + "t") (nyktr + "a") (nyktr + "a") ; + adjGalen = \galen -> + let {gal = Predef.tk 2 galen} in + mkAdj1 galen (gal + "et") (gal + "na") (gal + "na") ; + adjInvar = \bra -> {s = \\_,_ => bra ; lock_Adj1 = <>} ; + + mkAdj2 = \a,p -> a ** {s2 = p ; lock_Adj2 = <>} ; + mkAdj2Reg = \a -> mkAdj2 (adjReg a) ; + + mkAdjDeg = \liten, litet, lilla, sma, mindre, minst, minsta -> + let {lit = (mkAdj1 liten litet lilla sma).s} in + {s = table { + AF (Posit f) c => lit ! f ! c ; + AF Compar c => mkCase c mindre ; + AF (Super SupStrong) c => mkCase c minst ; + AF (Super SupWeak) c => mkCase c minsta --- masculine! + } ; + lock_AdjDeg = <> + } ; + + aReg = \fin -> mkAdjDeg fin + (fin + "t") (fin + "a") (fin + "a") (fin + "are") (fin + "ast") (fin + "aste") ; + + apReg = \s -> AdjP1 (adjReg s) ; + + mkV x y z = mkVerb x y z ** {lock_V = <>} ; + vKoka = \tala -> mkV tala (tala+"r") tala ; + vSteka = \leka -> let {lek = Predef.tk 1 leka} in mkV leka (lek + "er") lek ; + vBo = \bo -> mkV bo (bo+"r") bo ; + vAndas = \andas -> mkV andas andas andas ; + vTrivas = \trivas -> + let {trivs = Predef.tk 1 trivas + "s"} in mkV trivas trivs trivs ; + vVara = verbVara ** {lock_V = <>} ; + vHa = verbHava ** {lock_V = <>} ; + mkPartV v p = {s = v.s ; s1 = p ; lock_V = <>} ; + mkTV x y = mkTransVerb x y ** {lock_TV = <>} ; + tvDir = \v -> mkTV v [] ; + +} ; diff --git a/lib/resource-0.6/swedish/ResourceSwe.gf b/lib/resource-0.6/swedish/ResourceSwe.gf new file mode 100644 index 000000000..cc9446fcf --- /dev/null +++ b/lib/resource-0.6/swedish/ResourceSwe.gf @@ -0,0 +1,3 @@ +--# -path=.:../abstract:../../prelude + +resource ResourceSwe = reuse StructuralSwe ; diff --git a/lib/resource-0.6/swedish/StructuralSwe.gf b/lib/resource-0.6/swedish/StructuralSwe.gf new file mode 100644 index 000000000..87bf89c6b --- /dev/null +++ b/lib/resource-0.6/swedish/StructuralSwe.gf @@ -0,0 +1,137 @@ +--# -path=.:../abstract:../../prelude + +--1 The Top-Level English Resource Grammar: Structural Words +-- +-- Aarne Ranta 2002 -- 2003 +-- +concrete StructuralSwe of Structural = + CombinationsSwe ** open Prelude, SyntaxSwe in { + lin + + INP = pronNounPhrase jag_32 ; + ThouNP = pronNounPhrase du_33 ; + HeNP = pronNounPhrase han_34 ; + SheNP = pronNounPhrase hon_35 ; + WeNP n = pronNounPhrase (pronWithNum vi_36 n) ; + YeNP n = pronNounPhrase (pronWithNum ni_37 n) ; + TheyNP = pronNounPhrase de_38 ; + + YouNP = let {ni = pronNounPhrase ni_37 } in {s = ni.s ; g = ni.g ; n = Sg} ; + + ItNP = pronNounPhrase det_40 ; ---- + ThisNP = regNameNounPhrase ["det här"] Neutr NoMasc ; + ThatNP = regNameNounPhrase ["det där"] Neutr NoMasc ; + TheseNP n = {s = \\c => ["det här"] ++ n.s ! npCase c ; g = Neutr ; n = Pl} ; + ThoseNP n = {s = \\c => ["det där"] ++ n.s ! npCase c ; g = Neutr ; n = Pl} ; + + EveryDet = varjeDet ; + AllDet = mkDeterminerSgGender2 "all" "allt" IndefP ; + AllsDet = mkDeterminerPlNum "alla" IndefP ; + AnyDet = mkDeterminerSgGender2 "någon" "något" IndefP ; + AnysDet = mkDeterminerPlNum "några" IndefP ; + SomeDet = mkDeterminerSgGender2 "någon" "något" IndefP ; + SomesDet = mkDeterminerPlNum "några" IndefP ; + ManyDet = mkDeterminerPl "många" IndefP ; + NoDet = mkDeterminerSgGender2 "ingen" "inget" IndefP ; + NosDet = mkDeterminerPlNum "inga" IndefP ; + WhichsDet = mkDeterminerPlNum "vilka" IndefP ; + + WhichDet = vilkenDet ; + MostDet = mkDeterminerSgGender2 ["den mesta"] ["det mesta"] (DefP Def) ; + MostsDet = flestaDet ; + MuchDet = mkDeterminerSg (detSgInvar "mycket") IndefP ; + + ThisDet = mkDeterminerSgGender2 ["den här"] ["det här"] (DefP Def) ; + ThatDet = mkDeterminerSgGender2 ["den där"] ["det där"] (DefP Def) ; + TheseDet = mkDeterminerPlNum ["de här"] (DefP Def) ; + ThoseDet = mkDeterminerPlNum ["de där"] (DefP Def) ; + + 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 ."] ; + + VeryAdv = ss "mycket" ; + TooAdv = ss "för" ; + OtherwiseAdv = ss "annars" ; + ThereforeAdv = ss "därför" ; + +{- + EveryDet = everyDet ; + AllDet = mkDeterminer Sg "all" ; --- all the missing + AllsDet = mkDeterminerNum Pl "all" ; + WhichDet = whichDet ; + WhichsDet = mkDeterminerNum Pl "which" ; + MostsDet = mostDet ; + MostDet = mkDeterminer Sg "most" ; + SomeDet = mkDeterminer Sg "some" ; + SomesDet = mkDeterminerNum Pl "some" ; + AnyDet = mkDeterminer Sg "any" ; + AnysDet = mkDeterminerNum Pl "any" ; + NoDet = mkDeterminer Sg "no" ; + NosDet = mkDeterminerNum Pl "no" ; + ManyDet = mkDeterminer Sg "many" ; + MuchDet = mkDeterminer Sg ["a lot of"] ; --- + ThisDet = mkDeterminer Sg "this" ; + TheseDet = mkDeterminerNum Pl "these" ; + ThatDet = mkDeterminer Sg "that" ; + ThoseDet = mkDeterminerNum Pl "those" ; + + ThisNP = nameNounPhrase (nameReg "this") ; + ThatNP = nameNounPhrase (nameReg "that") ; + TheseNP n = nameNounPhrase {s = \\c => "these" ++ n.s ! c} ; + ThoseNP n = nameNounPhrase {s = \\c => "those" ++ n.s ! c} ; +-} + + EverybodyNP = nameNounPhrase (mkProperName "alleman" Utr Masc) ; + SomebodyNP = nameNounPhrase (mkProperName "någon" Utr Masc) ; + NobodyNP = nameNounPhrase (mkProperName "ingen" Utr Masc) ; + EverythingNP = nameNounPhrase (mkProperName "allting" Neutr NoMasc) ; + SomethingNP = nameNounPhrase (mkProperName "någonting" Neutr NoMasc) ; + NothingNP = nameNounPhrase (mkProperName "ingenting" Neutr NoMasc) ; + + CanVV = mkVerb "kunna" "kan" "kunn" ** {isAux = True} ; --- + CanKnowVV = mkVerb "kunna" "kan" "kunn" ** {isAux = True} ; --- + MustVV = mkVerb "få" "måste" "få" ** {isAux = True} ; --- + WantVV = mkVerb "vilja" "vill" "vilj" ** {isAux = True} ; --- + + EverywhereNP = advPost "varstans" ; + SomewhereNP = advPost "någonstans" ; + NowhereNP = advPost "ingenstans" ; + + AlthoughSubj = ss "fast" ; + + AlmostAdv = ss "nästan" ; + QuiteAdv = ss "ganska" ; + + InPrep = ss "i" ; + OnPrep = ss "på" ; + ToPrep = ss "till" ; + ThroughPrep = ss "genom" ; + AbovePrep = ss "ovanför" ; + UnderPrep = ss "under" ; + InFrontPrep = ss "framför" ; + BehindPrep = ss "bakom" ; + BetweenPrep = ss "mellan" ; + FromPrep = ss "från" ; + BeforePrep = ss "före" ; + DuringPrep = ss "under" ; + AfterPrep = ss "efter" ; + WithPrep = ss "med" ; + WithoutPrep = ss "utan" ; + ByMeansPrep = ss "med" ; + PartPrep = ss "av" ; + AgentPrep = ss "av" ; + +} diff --git a/lib/resource-0.6/swedish/SyntaxSwe.gf b/lib/resource-0.6/swedish/SyntaxSwe.gf new file mode 100644 index 000000000..991ddaa4a --- /dev/null +++ b/lib/resource-0.6/swedish/SyntaxSwe.gf @@ -0,0 +1,1148 @@ +--1 A Small Swedish Resource Syntax +-- +-- Aarne Ranta 2002 +-- +-- This resource grammar contains definitions needed to construct +-- indicative, interrogative, and imperative sentences in Swedish. +-- +-- The following modules are presupposed: + +resource SyntaxSwe = MorphoSwe ** open Prelude, (CO = Coordination) in { + +--2 Common Nouns +-- +--3 Simple common nouns + +oper + CommNoun : Type = {s : Number => Species => Case => Str ; g : Gender ; x : Sex} ; + +-- When common nouns are extracted from lexicon, the composite noun form is ignored. +-- But we have to indicate a sex. + extCommNoun : Sex -> Subst -> CommNoun = \x,sb -> + {s = \\n,b,c => sb.s ! SF n b c ; + g = sb.h1 ; + x = x} ; + +-- These constants are used for data abstraction over the parameter type $Num$. + singular = Sg ; + plural = Pl ; + +--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: +-- "(en) ful orm" / "(den) fula ormen" / "(min) fula orm". +param + SpeciesP = IndefP | DefP Species ; + +-- We also have to be able to decide if a $CommNounPhrase$ is complex +-- (to form the definite form: "bilen" / "den stora bilen"). + +oper + IsComplexCN : Type = Bool ; + +-- Coercions between simple $Species$ and $SpeciesP$: + unSpeciesP : SpeciesP -> Species = \b -> + case b of {IndefP => Indef ; DefP p => p} ; -- bil/bil/bilen + unSpeciesAdjP : SpeciesP -> Species = \b -> + case b of {IndefP => Indef ; DefP _ => Def} ; -- gammal/gamla/gamla + +-- Here's the type itself. + CommNounPhrase : Type = + {s : Number => SpeciesP => Case => Str ; + g : Gender ; x : Sex ; p : IsComplexCN} ; + +-- To use a $CommNoun$ as $CommNounPhrase$. + noun2CommNounPhrase : CommNoun -> CommNounPhrase = \hus -> + {s = \\n,b,c => hus.s ! n ! unSpeciesP b ! c ; + g = hus.g ; x = hus.x ; p = False} ; + + n2n = noun2CommNounPhrase ; + + +--2 Noun Phrases +-- +-- The worst case for noun phrases is pronouns, which have inflection +-- in (what is syntactically) their genitive. Most noun phrases can +-- ignore this variation. + +oper + npCase : NPForm -> Case = \c -> case c of {PGen _ => Gen ; _ => Nom} ; + mkNPForm : Case -> NPForm = \c -> case c of {Gen => PGen APl ; _ => PNom} ; + + NounPhrase : Type = {s : NPForm => Str ; g : Gender ; n : Number} ; + +-- Proper names are a simple kind of noun phrases. However, we want to +-- anticipate the rule that proper names can be modified by +-- adjectives, even though noun phrases in general cannot - hence the sex. + + ProperName : Type = {s : Case => Str ; g : Gender ; x : Sex} ; + + mkProperName : Str -> Gender -> Sex -> ProperName = \john,g,x -> + {s = table {Nom => john ; Gen => john + "s"} ; g = g ; x = x} ; + + nameNounPhrase : ProperName -> NounPhrase = + \john -> {s = table {c => john.s ! npCase c} ; g = john.g ; n = Sg} ; + + regNameNounPhrase : Str -> Gender -> Sex -> NounPhrase = \john,g,x -> + nameNounPhrase (mkProperName john g x) ; + + pronNounPhrase : ProPN -> NounPhrase = \jag -> + {s = jag.s ; g = jag.h1 ; n = jag.h2} ; + +-- The following construction has to be refined for genitive forms: +-- "vi tre", "oss tre" are OK, but "vår tres" is not. + + Numeral : Type = {s : Case => Str} ; + + pronWithNum : ProPN -> Numeral -> ProPN = \we,two -> + {s = \\c => we.s ! c ++ two.s ! npCase c ; + h1 = we.h1 ; + h2 = we.h2 ; + h3 = we.h3 + } ; + + noNum : Numeral = {s = \\_ => []} ; + +-- Formal subjects + + npMan = nameNounPhrase (mkProperName "man" Utr Masc) ; + npDet = nameNounPhrase (mkProperName "det" Neutr NoMasc) ; + +--2 Determiners +-- +-- Determiners are inflected according to noun in gender and sex. +-- The number and species of the noun are determined by the determiner. + + Determiner : Type = {s : Gender => Sex => Str ; n : Number ; b : SpeciesP} ; + +-- This is the rule for building noun phrases. + + detNounPhrase : Determiner -> CommNounPhrase -> NounPhrase = \en, man -> + {s = table {c => en.s ! man.g ! man.x ++ man.s ! en.n ! en.b ! npCase c} ; + g = man.g ; n = en.n} ; + +-- The following macros are sufficient to define most determiners. +-- All $SpeciesP$ values come into question: +-- "en god vän" - "min gode vän" - "den gode vännen". + + DetSg : Type = Gender => Sex => Str ; + DetPl : Type = Str ; + + mkDeterminerSg : DetSg -> SpeciesP -> Determiner = \en, b -> + {s = en ; n = Sg ; b = b} ; + + mkDeterminerPl : DetPl -> SpeciesP -> Determiner = \alla,b -> + mkDeterminerPlNum alla b noNum ; + + mkDeterminerPlNum : DetPl -> SpeciesP -> Numeral -> Determiner = \alla,b,n -> + {s = \\_,_ => alla ++ n.s ! Nom ; + n = Pl ; + b = b + } ; + + detSgInvar : Str -> DetSg = \varje -> table {_ => table {_ => varje}} ; + +-- A large class of determiners can be built from a gender-dependent table. + + mkDeterminerSgGender : (Gender => Str) -> SpeciesP -> Determiner = \en -> + mkDeterminerSg (table {g => table {_ => en ! g}}) ; + + mkDeterminerSgGender2 : Str -> Str -> SpeciesP -> Determiner = \en,ett -> + mkDeterminerSgGender (table {Utr => en ; Neutr => ett}) ; + +-- Here are some examples. We are in fact doing some ad hoc morphology here, +-- instead of importing the lexicon. + + varjeDet = mkDeterminerSg (detSgInvar "varje") IndefP ; + allaDet = mkDeterminerPl "alla" IndefP ; + enDet = mkDeterminerSgGender artIndef IndefP ; + + flestaDet = mkDeterminerPl ["de flesta"] IndefP ; + vilkenDet = mkDeterminerSgGender + (table {Utr => "vilken" ; Neutr => "vilket"}) IndefP ; + vilkaDet = mkDeterminerPl "vilka" IndefP ; + + vilkDet : Number -> Determiner = \n -> case n of { + Sg => vilkenDet ; + Pl => vilkaDet + } ; + + någDet : Number -> Determiner = \n -> case n of { + Sg => mkDeterminerSgGender + (table {Utr => "någon" ; Neutr => "något"}) IndefP ; + Pl => mkDeterminerPl "några" IndefP + } ; + + +-- Genitives of noun phrases can be used like determiners, to build noun phrases. +-- The number argument makes the difference between "min bil" - "mina bilar". + + npGenDet : Number -> Numeral -> NounPhrase -> CommNounPhrase -> NounPhrase = + \n,tre,huset,vin -> { + s = \\c => case n of { + Sg => huset.s ! PGen (ASg vin.g) ++ + vin.s ! Sg ! DefP Indef ! npCase c ; + Pl => huset.s ! PGen APl ++ tre.s ! Nom ++ + vin.s ! Pl ! DefP Indef ! npCase c + } ; + g = vin.g ; + n = n + } ; + +-- *Bare plural noun phrases* like "män", "goda vänner", are built without a +-- determiner word. But a $Numeral$ may occur. + + plurDet : CommNounPhrase -> NounPhrase = plurDetNum noNum ; + + plurDetNum : Numeral -> CommNounPhrase -> NounPhrase = \num,cn -> + {s = \\c => num.s ! Nom ++ cn.s ! Pl ! IndefP ! npCase c ; + g = cn.g ; + n = Pl + } ; + +-- Definite phrases in Swedish are special, since determiner may be absent +-- depending on if the noun is complex: "bilen" - "den nya bilen". + + denDet : CommNounPhrase -> NounPhrase = \cn -> + detNounPhrase + (mkDeterminerSgGender (table {g => artDef ! cn.p ! ASg g}) (DefP Def)) cn ; + deDet : Numeral -> CommNounPhrase -> NounPhrase = \n,cn -> + detNounPhrase (mkDeterminerPlNum (artDef ! cn.p ! APl) (DefP Def) n) cn ; + +-- It is useful to have macros for indefinite and definite, singular and plural +-- noun-phrase-like syncategorematic expressions. + + indefNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n -> + indefNounPhraseNum n noNum ; + + indefNounPhraseNum : Number -> Numeral -> CommNounPhrase -> NounPhrase = + \n,num,hus -> + case n of { + Sg => detNounPhrase enDet hus ; + Pl => plurDetNum num hus + } ; + + defNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n -> + defNounPhraseNum n noNum ; + + defNounPhraseNum : Number -> Numeral -> CommNounPhrase -> NounPhrase = + \n,num,hus -> case n of { + Sg => denDet hus ; + Pl => deDet num hus + } ; + + indefNoun : Number -> CommNounPhrase -> Str = \n,man -> case n of { + Sg => artIndef ! man.g ++ man.s ! Sg ! IndefP ! Nom ; + Pl => man.s ! Pl ! IndefP ! Nom + } ; + +-- Constructions like "tanken att två är jämnt" are formed at the +-- first place as common nouns, so that one can also have "ett förslag att...". + + nounThatSentence : CommNounPhrase -> Sentence -> CommNounPhrase = \tanke,x -> + {s = \\n,d,c => tanke.s ! n ! d ! c ++ "att" ++ x.s ! Sub ; + g = tanke.g ; + x = tanke.x ; + p = tanke.p + } ; + + +--2 Adjectives +--3 Simple adjectives +-- +-- A special type of adjectives just having positive forms (for semantic reasons) +-- is useful, e.g. "finsk", "trekantig". + + Adjective : Type = {s : AdjFormPos => Case => Str} ; + + extAdjective : Adj -> Adjective = \adj -> + {s = table {f => table {c => adj.s ! AF (Posit f) c}}} ; + +-- Coercions between the compound gen-num type and gender and number: + + gNum : Gender -> Number -> GenNum = \g,n -> + case n of {Sg => ASg g ; Pl => APl} ; + + genGN : GenNum -> Gender = \gn -> + case gn of {ASg g => g ; _ => Utr} ; + numGN : GenNum -> Number = \gn -> + case gn of {ASg _ => Sg ; APl => Pl} ; + +--3 Adjective phrases +-- +-- An adjective phrase may contain a complement, e.g. "yngre än Rolf". +-- Then it is used as postfix in modification, e.g. "en man yngre än Rolf". + + IsPostfixAdj = Bool ; + + AdjPhrase : Type = Adjective ** {p : IsPostfixAdj} ; + +-- Simple adjectives are not postfix: + + adj2adjPhrase : Adjective -> AdjPhrase = \ny -> ny ** {p = False} ; + +--3 Comparison adjectives + +-- We take comparison adjectives directly from +-- the lexicon, which has full adjectives: + + AdjDegr = Adj ; + +-- Each of the comparison forms has a characteristic use: +-- +-- Positive forms are used alone, as adjectival phrases ("ung"). + + positAdjPhrase : AdjDegr -> AdjPhrase = \ung -> + {s = table {a => \\c => ung.s ! AF (Posit a) c} ; + p = False + } ; + +-- Comparative forms are used with an object of comparison, as +-- adjectival phrases ("yngre än Rolf"). + + comparAdjPhrase : AdjDegr -> NounPhrase -> AdjPhrase = \yngre,rolf -> + {s = \\_, c => yngre.s ! AF Compar Nom ++ "än" ++ rolf.s ! mkNPForm c ; + p = True + } ; + +-- Superlative forms are used with a modified noun, picking out the +-- maximal representative of a domain ("den yngste mannen"). + + superlNounPhrase : AdjDegr -> CommNounPhrase -> NounPhrase = \yngst,man -> + {s = \\c => let {gn = gNum man.g Sg} in + artDef ! True ! gn ++ + yngst.s ! AF (Super SupWeak) Nom ++ + man.s ! Sg ! DefP Def ! npCase c ; + g = man.g ; + n = Sg + } ; + +-- Moreover, superlatives can be used alone as adjectival phrases +-- ("yngst", "den yngste" - in free variation). +-- N.B. the former is only permitted in predicative position. + + superlAdjPhrase : AdjDegr -> AdjPhrase = \ung -> + {s = \\a,c => variants { + --- artDef ! True ! gn ++ yngst.s ! AF (Super SupWeak) c + ung.s ! AF (Super SupStrong) c + } ; + p = False + } ; + +--3 Two-place adjectives +-- +-- A two-place adjective is an adjective with a preposition used before +-- the complement. (Rem. $Preposition = Str$). + + AdjCompl = Adjective ** {s2 : Preposition} ; + + complAdj : AdjCompl -> NounPhrase -> AdjPhrase = \förtjust,dig -> + {s = \\a,c => förtjust.s ! a ! c ++ förtjust.s2 ++ dig.s ! PAcc ; + p = True + } ; + + +--3 Modification of common nouns +-- +-- The two main functions of adjective are in predication ("Johan är ung") +-- and in modification ("en ung man"). Predication will be defined +-- later, in the chapter on verbs. + + modCommNounPhrase : AdjPhrase -> CommNounPhrase -> CommNounPhrase = \God,Nybil -> + {s = \\n, b, c => + let { + god = God.s ! mkAdjForm (unSpeciesAdjP b) n Nybil.g Nybil.x ! Nom ; + nybil = Nybil.s ! n ! b ! c + } in + preOrPost God.p nybil god ; + g = Nybil.g ; + x = Nybil.x ; + p = True} ; + +-- A special case is modification of a noun that has not yet been modified. +-- But it is simply a special case. + + modCommNoun : Adjective -> CommNoun -> CommNounPhrase = \god,bil -> + modCommNounPhrase (adj2adjPhrase god) (n2n bil) ; + +-- We have used a straightforward +-- method building adjective forms from simple parameters. + + mkAdjForm : Species -> Number -> Gender -> Sex -> AdjFormPos = \b,n,g,x -> + case of { + => Strong (ASg g) ; + => Strong APl ; + => Weak (AxSg x) ; ---- add masc! + => Weak AxPl + } ; + + +--2 Function expressions + +-- A function expression is a common noun together with the +-- preposition prefixed to its argument ("mor till x"). +-- The type is analogous to two-place adjectives and transitive verbs. + + Function = CommNoun ** {s2 : Preposition} ; + + mkFun : CommNoun -> Preposition -> Function = \f,p -> + f ** {s2 = p} ; + +-- The application of a function gives, in the first place, a common noun: +-- "mor/mödrar till Johan". From this, other rules of the resource grammar +-- give noun phrases, such as "modern till Johan", "mödrarna till Johan", +-- "mödrarna till Johan och Maria", and "modern till Johan och 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 = \värde,x -> + noun2CommNounPhrase + {s = \\n,b => table { + Gen => nonExist ; + _ => värde.s ! n ! b ! Nom ++ värde.s2 ++ x.s ! PAcc + } ; + g = värde.g ; + x = värde.x + } ; + +-- 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 "Johans mor" and "modern till Johan". It does not appear in the +-- resource grammar API any longer. + + appFun : Bool -> Function -> NounPhrase -> NounPhrase = \coll,värde,x -> + let {n = x.n ; nf = if_then_else Number coll Sg n} in + variants { + defNounPhrase nf (appFunComm värde x) ; + npGenDet nf noNum x (noun2CommNounPhrase värde) + } ; + +-- Two-place functions add one argument place. + + Function2 = Function ** {s3 : Preposition} ; + +-- There application starts by filling the first place. + + appFun2 : Function2 -> NounPhrase -> Function = \flyg, paris -> + {s = \\n,d,c => flyg.s ! n ! d ! c ++ flyg.s2 ++ paris.s ! PAcc ; + g = flyg.g ; + x = flyg.x ; + s2 = flyg.s3 + } ; + + +--2 Verbs + +-- Although the Swedish lexicon has full verb inflection, +-- we have limited this first version of the resource syntax to +-- verbs in present tense. Their mode can be infinitive, imperative, and indicative. + + +--3 Verb phrases +-- +-- Verb phrases are discontinuous: the parts of a verb phrase are +-- (s) an inflected verb, (s2) verb adverbials (such as negation), and +-- (s3) complement. This discontinuity is needed in sentence formation +-- to account for word order variations. No particle needs to be retained. + + VerbPhrase : Type = {s : VForm => Str} ** + {s2 : Str ; s3 : Gender => Number => Str} ; + VerbGroup : Type = {s : VForm => Str} ** + {s2 : Bool => Str ; s3 : Gender => Number => Str} ; + + predVerbGroup : Bool -> VerbGroup -> VerbPhrase = \b,vg -> { + s = vg.s ; + s2 = vg.s2 ! b ; + s3 = vg.s3 + } ; + +-- 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 "inte" are not grammatical. + + predVerb : Verb -> VerbGroup = \se -> + {s = se.s ; + s2 = negation ; + s3 = \\_,_ => se.s1 + } ; + + negation : Bool => Str = \\b => if_then_Str b [] "inte" ; + +-- Verb phrases can also be formed from adjectives ("är snäll"), +-- common nouns ("är en man"), and noun phrases ("är den yngste mannen"). +-- The third rule is overgenerating: "är varje man" has to be ruled out +-- on semantic grounds. + + predAdjective : Adjective -> VerbGroup = \arg -> + verbVara ** { + s2 = negation ; + s3 = \\g,n => arg.s ! mkAdjForm Indef n g NoMasc ! Nom + } ; + + predCommNoun : CommNounPhrase -> VerbGroup = \man -> + verbVara ** { + s2 = negation ; + s3 = \\_,n => indefNoun n man + } ; + + predNounPhrase : NounPhrase -> VerbGroup = \john -> + verbVara ** { + s2 = negation ; + s3 = \\_,_ => john.s ! PNom + } ; + + predAdverb : Adverb -> VerbGroup = \ute -> + verbVara ** { + s2 = negation ; + s3 = \\_,_ => ute.s + } ; + +--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 ** {s2 : Preposition} ; + + mkTransVerb : Verb -> Preposition -> TransVerb = \v,p -> + v ** {s2 = p} ; + + mkDirectVerb : Verb -> TransVerb = \v -> + mkTransVerb v nullPrep ; + + nullPrep : Preposition = [] ; + + extTransVerb : Verbum -> Preposition -> TransVerb = + \v -> mkTransVerb (extVerb Act v) ; + +-- The rule for using transitive verbs is the complementization rule: + + complTransVerb : TransVerb -> NounPhrase -> VerbGroup = \se,dig -> + {s = se.s ; + s2 = negation ; + s3 = \\_,_ => se.s1 ++ se.s2 ++ dig.s ! PAcc + } ; + +-- 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 "han löps", etc. +-- The syntax is the same as for active verbs, with the choice of the +-- "s" passive form. + + passVerb : Verb -> VerbGroup = \se -> ---- passive not yet + {s = table {VPres m _ => se.s ! VPres m Pass} ; + s2 = negation ; + s3 = \\_,_ => se.s1 + } ; + +-- Transitive verbs can be used elliptically as verbs. The semantics +-- is left to applications. The definition is trivial, due to record +-- subtyping. + + transAsVerb : TransVerb -> Verb = \love -> + love ; + +-- *Ditransitive verbs* are verbs with three argument places. +-- We treat so far only the rule in which the ditransitive +-- verb takes both complements to form a verb phrase. + + DitransVerb = TransVerb ** {s3 : Preposition} ; + + mkDitransVerb : Verb -> Preposition -> Preposition -> DitransVerb = \v,p1,p2 -> + v ** {s2 = p1 ; s3 = p2} ; + + complDitransVerb : + DitransVerb -> NounPhrase -> NounPhrase -> VerbGroup = \ge,dig,vin -> + {s = ge.s ; + s2 = negation ; + s3 = \\_,_ => ge.s1 ++ ge.s2 ++ dig.s ! PAcc ++ ge.s3 ++ vin.s ! PAcc + } ; + + +--2 Adverbials +-- +-- Adverbials that modify verb phrases are either post- or pre-verbal. +-- As a rule of thumb, simple adverbials ("bra","alltid") are pre-verbal, +-- but this is not always the case ("här" is post-verbal). + + Adverb : Type = SS ** {isPost : Bool} ; + + advPre : Str -> Adverb = \alltid -> ss alltid ** {isPost = False} ; + advPost : Str -> Adverb = \bra -> ss bra ** {isPost = True} ; + + adVerbPhrase : VerbPhrase -> Adverb -> VerbPhrase = \spelar, bra -> + let {postp = bra.isPost} in + { + --- this unfortunately generates VP#2 ::= VP#2 + s = spelar.s ; + s2 = (if_then_else Str postp [] bra.s) ++ spelar.s2 ; + s3 = \\g,n => spelar.s3 ! g ! n ++ (if_then_else Str postp bra.s []) + } ; + + advAdjPhrase : SS -> AdjPhrase -> AdjPhrase = \mycket, dyr -> + {s = \\a,c => mycket.s ++ dyr.s ! a ! c ; + p = dyr.p + } ; + +-- Adverbials are typically generated by prefixing prepositions. +-- The rule for creating locative noun phrases by the preposition "i" +-- is a little shaky: "i Sverige" but "på Island". + + prepPhrase : Preposition -> NounPhrase -> Adverb = \i,huset -> + advPost (i ++ huset.s ! PAcc) ; + + locativeNounPhrase : NounPhrase -> Adverb = + prepPhrase "i" ; + +-- This is a source of the "mannen med teleskopen" ambiguity, and may produce +-- strange things, like "bilar alltid" (while "bilar idag" is OK). +-- Semantics will have to make finer distinctions among adverbials. + + advCommNounPhrase : CommNounPhrase -> Adverb -> CommNounPhrase = \bil,idag -> + {s = \\n, b, c => bil.s ! n ! b ! c ++ idag.s ; + g = bil.g ; + x = bil.x ; + p = bil.p} ; + + +--2 Sentences +-- +-- Sentences depend on a *word order parameter* selecting between main clause, +-- inverted, and subordinate clause. + +param + Order = Main | Inv | Sub ; + +oper + 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 = + \Jag, serdiginte -> + let { + jag = Jag.s ! PNom ; + ser = serdiginte.s ! VPres Indicat Act ; + dig = serdiginte.s3 ! Jag.g ! Jag.n ; + inte = serdiginte.s2 + } in + {s = table { + Main => jag ++ ser ++ inte ++ dig ; + Inv => ser ++ jag ++ inte ++ dig ; + Sub => jag ++ inte ++ ser ++ dig + } + } ; + + +--3 Sentence-complement verbs +-- +-- Sentence-complement verbs take sentences as complements. + + SentenceVerb : Type = Verb ; + + complSentVerb : SentenceVerb -> Sentence -> VerbGroup = \se,duler -> + {s = se.s ; + s2 = negation ; + s3 = \\_,_ => se.s1 ++ optStr "att" ++ duler.s ! Main + } ; + +--3 Verb-complement verbs +-- +-- Sentence-complement verbs take verb phrases as complements. +-- They can be auxiliaries ("kan", "måste") or ordinary verbs +-- ("försöka"); this distinction cannot be done in the multilingual +-- API and leads to some anomalies in Swedish, but less so than in English. + + VerbVerb : Type = Verb ** {isAux : Bool} ; + + complVerbVerb : VerbVerb -> VerbGroup -> VerbGroup = \vilja, simma -> + {s = vilja.s ; + s2 = negation ; + s3 = \\g,n => + vilja.s1 ++ + if_then_Str vilja.isAux [] "att" ++ + simma.s ! VPres Infinit Act ++ simma.s2 ! True ++ simma.s3 ! g ! n + } ; + + +--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} ; + + slashTransVerb : Bool -> NounPhrase -> TransVerb -> SentenceSlashNounPhrase = + \b, Jag, se -> + let { + jag = Jag.s ! PNom ; + ser = se.s ! VPres Indicat Act ; + inte = negation ! b ++ se.s1 + } in + {s = table { + Main => jag ++ ser ++ inte ; + Inv => ser ++ jag ++ inte ; + Sub => jag ++ inte ++ ser + } ; + s2 = se.s2 + } ; + + +--2 Relative pronouns and relative clauses +-- +-- Relative pronouns can be nominative, accusative, or genitive, and +-- they depend on gender and number just like adjectives. +-- Moreover they may or may not carry their own genders: for instance, +-- "som" just transmits the gender of a noun ("tal som är primt"), whereas +-- "vars efterföljare" is $Utrum$ independently of the noun +-- ("tal vars efterföljare är prim"). +-- This variation is expressed by the $RelGender$ type. + + RelPron : Type = {s : RelCase => GenNum => Str ; g : RelGender} ; + +param + RelGender = RNoGen | RG Gender ; + +-- The following functions are selectors for relative-specific parameters. + +oper + -- this will be needed in "tal som är jämnt" / "tal vars efterföljare är jämn" + mkGenderRel : RelGender -> Gender -> Gender = \rg,g -> case rg of { + RG gen => gen ; + _ => g + } ; + + relCase : RelCase -> Case = \c -> case c of { + RGen => Gen ; + _ => Nom + } ; + +-- The simplest relative pronoun has no gender of its own. As accusative variant, +-- it has the omission of the pronoun ("mannen (som) jag ser"). + + identRelPron : RelPron = + {s = table { + RNom => \\_ => "som" ; + RAcc => \\_ => variants {"som" ; []} ; + RGen => \\_ => "vars" ; + RPrep => pronVilken + } ; + g = RNoGen + } ; + +-- Composite relative pronouns have the same variation as function +-- applications ("efterföljaren till vilket" - "vars efterföljare"). + + funRelPron : Function -> RelPron -> RelPron = \värde,vilken -> + {s = \\c,gn => + variants { + vilken.s ! RGen ! gn ++ värde.s ! numGN gn ! Indef ! relCase c ; + värde.s ! numGN gn ! Def ! Nom ++ värde.s2 ++ vilken.s ! RPrep ! gn + } ; + g = RG värde.g + } ; + +-- Relative clauses can be formed from both verb phrases ("som sover") and +-- slash expressions ("som jag ser"). The latter has moreover the variation +-- as for the place of the preposition ("som jag talar om" - "om vilken jag talar"). + + RelClause : Type = {s : GenNum => Str} ; + + relVerbPhrase : RelPron -> VerbPhrase -> RelClause = \som,sover -> + {s = \\gn => + som.s ! RNom ! gn ++ sover.s2 ++ sover.s ! VPres Indicat Act ++ + sover.s3 ! mkGenderRel som.g (genGN gn) ! numGN gn + } ; + + relSlash : RelPron -> SentenceSlashNounPhrase -> RelClause = \som,jagTalar -> + {s = \\gn => + let {jagtalar = jagTalar.s ! Sub ; om = jagTalar.s2} in + variants { + som.s ! RAcc ! gn ++ jagtalar ++ om ; + om ++ som.s ! RPrep ! gn ++ jagtalar + } + } ; + +-- A 'degenerate' relative clause is the one often used in mathematics, e.g. +-- "tal x sådant att x är primt". + + relSuch : Sentence -> RelClause = \A -> + {s = \\g => pronSådan ! g ++ "att" ++ 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. + + modRelClause : CommNounPhrase -> RelClause -> CommNounPhrase = \man,somsover -> + {s = \\n,b,c => man.s ! n ! b ! c ++ somsover.s ! gNum man.g n ; + g = man.g ; + x = man.x ; + p = False + } ; + +-- N.B. we do not get the determinative pronoun +-- construction "den man som sover" in this way, but only "mannen som sover". +-- Thus we need an extra rule: + + detRelClause : Number -> CommNounPhrase -> RelClause -> NounPhrase = + \n,man,somsover -> + {s = \\c => let {gn = gNum man.g n} in + artDef ! True ! gn ++ + man.s ! n ! DefP Indef ! npCase c ++ somsover.s ! gn ; + g = man.g ; + n = n + } ; + + +--2 Interrogative pronouns +-- +-- If relative pronouns are adjective-like, interrogative pronouns are +-- noun-phrase-like. Actually we can use the very same type! + + IntPron : Type = NounPhrase ; + +-- In analogy with relative pronouns, we have a rule for applying a function +-- to a relative pronoun to create a new one. We can reuse the rule applying +-- functions to noun phrases! + + funIntPron : Function -> IntPron -> IntPron = + appFun False ; + +-- There is a variety of simple interrogative pronouns: +-- "vilken bil", "vem", "vad". + + nounIntPron : Number -> CommNounPhrase -> IntPron = \n -> + detNounPhrase (vilkDet n) ; + + intPronWho : Number -> IntPron = \num -> { + s = table { + PGen _ => "vems" ; + _ => "vem" + } ; + g = Utr ; + n = num + } ; + + intPronWhat : Number -> IntPron = \num -> { + s = table { + PGen _ => nonExist ; --- + _ => "vad" + } ; + n = num ; + g = Neutr + } ; + +--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 -> postfixSS "." (defaultSentence x) ; + interrogUtt : Question -> Utterance = \x -> postfixSS "?" (defaultQuestion x) ; + + +--2 Questions +-- +-- Questions are either direct ("vem tog bollen") or indirect +-- ("vem som tog bollen"). + +param + QuestForm = DirQ | IndirQ ; + +oper + Question = SS1 QuestForm ; + +--3 Yes-no questions +-- +-- Yes-no questions are used both independently ("tog du bollen") +-- and after interrogative adverbials ("varför tog du bollen"). +-- It is economical to handle with these two cases by the one +-- rule, $questVerbPhrase'$. The only difference is if "om" appears +-- in the indirect form. + + questVerbPhrase : NounPhrase -> VerbPhrase -> Question = + questVerbPhrase' False ; + + questVerbPhrase' : Bool -> NounPhrase -> VerbPhrase -> Question = + \adv,du,sover -> + let {dusover = (predVerbPhrase du sover).s} in + {s = table { + DirQ => dusover ! Inv ; + IndirQ => (if_then_else Str adv [] "om") ++ dusover ! 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 = \vem,sover -> + let {vemsom : NounPhrase = + {s = \\c => vem.s ! c ++ "som" ; g = vem.g ; n = vem.n} + } in + {s = table { + DirQ => (predVerbPhrase vem sover).s ! Main ; + IndirQ => (predVerbPhrase vemsom sover).s ! Sub + } + } ; + + intSlash : IntPron -> SentenceSlashNounPhrase -> Question = \Vem, jagTalar -> + let { + vem = Vem.s ! PAcc ; + jagtalar = jagTalar.s ! Sub ; + talarjag = jagTalar.s ! Inv ; + om = jagTalar.s2 + } in + {s = table { + DirQ => variants { + vem ++ talarjag ++ om ; + om ++ vem ++ talarjag + } ; + IndirQ => variants { + vem ++ jagtalar ++ om ; + om ++ vem ++ jagtalar + } + } + } ; + +--3 Interrogative adverbials +-- +-- These adverbials will be defined in the lexicon: they include +-- "när", "var", "hur", "varför", 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. N.B. we rely on record subtyping when ignoring the +-- position component. + + IntAdverb = SS ; + + prepIntAdverb : Preposition -> IntPron -> IntAdverb = + prepPhrase ; + +-- A question adverbial can be applied to anything, and whether this makes +-- sense is a semantic question. + + questAdverbial : IntAdverb -> NounPhrase -> VerbPhrase -> Question = + \hur, du, mår -> + {s = \\q => hur.s ++ (questVerbPhrase' True du mår).s ! q} ; + + +--2 Imperatives +-- +-- We only consider second-person imperatives. + + Imperative = SS1 Number ; + + imperVerbPhrase : VerbPhrase -> Imperative = \titta -> + {s = \\n => titta.s ! VPres Imperat Act ++ titta.s2 ++ titta.s3 ! Utr ! n} ; + + imperUtterance : Number -> Imperative -> Utterance = \n,I -> + ss (I.s ! n ++ "!") ; + +--2 Sentence adverbials +-- +-- This class covers adverbials such as "annars", "därför", which are prefixed +-- to a sentence to form a phrase. + + advSentence : SS -> Sentence -> Utterance = \annars,soverhan -> + ss (annars.s ++ soverhan.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 ("och", "eller") or distributed ("både - och", "antingen - eller"). +-- +-- The conjunction has an inherent number, which is used when conjoining +-- noun phrases: "John och Mary är rika" vs. "John eller Mary är rik"; in the +-- case of "eller", 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. "månen lyser, solen skiner och stjärnorna blinkar". + + conjunctSentence : Conjunction -> ListSentence -> Sentence = + CO.conjunctTable Order ; + + conjunctOrd : Bool -> Conjunction -> CO.ListTable Order -> {s : Order => Str} = + \b,or,xs -> + {s = \\p => xs.s1 ! p ++ or.s ++ xs.s2 ! p} ; + + +-- To coordinate a list of sentences by a distributed conjunction, we place +-- the first part (e.g. "antingen") in front of the first element, the second +-- part ("eller") 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 : AdjFormPos => Case => Str ; p : Bool} ; + + twoAdjPhrase : (_,_ : AdjPhrase) -> ListAdjPhrase = \x,y -> + CO.twoTable2 AdjFormPos Case x y ** {p = andB x.p y.p} ; + consAdjPhrase : ListAdjPhrase -> AdjPhrase -> ListAdjPhrase = \xs,x -> + CO.consTable2 AdjFormPos Case CO.comma xs x ** {p = andB xs.p x.p} ; + + conjunctAdjPhrase : Conjunction -> ListAdjPhrase -> AdjPhrase = \c,xs -> + CO.conjunctTable2 AdjFormPos Case c xs ** {p = xs.p} ; + + conjunctDistrAdjPhrase : ConjunctionDistr -> ListAdjPhrase -> AdjPhrase = \c,xs -> + CO.conjunctDistrTable2 AdjFormPos Case 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 gender is neuter if any of the components is. + + ListNounPhrase : Type = {s1,s2 : NPForm => Str ; g : Gender ; n : Number} ; + + twoNounPhrase : (_,_ : NounPhrase) -> ListNounPhrase = \x,y -> + CO.twoTable NPForm x y ** {n = conjNumber x.n y.n ; g = conjGender x.g y.g} ; + + consNounPhrase : ListNounPhrase -> NounPhrase -> ListNounPhrase = \xs,x -> + CO.consTable NPForm CO.comma xs x ** + {n = conjNumber xs.n x.n ; g = conjGender xs.g x.g} ; + + conjunctNounPhrase : Conjunction -> ListNounPhrase -> NounPhrase = \c,xs -> + CO.conjunctTable NPForm c xs ** {n = conjNumber c.n xs.n ; g = xs.g} ; + + conjunctDistrNounPhrase : ConjunctionDistr -> ListNounPhrase -> NounPhrase = + \c,xs -> + CO.conjunctDistrTable NPForm c xs ** {n = conjNumber c.n xs.n ; g = xs.g} ; + +-- We hve to define a calculus of numbers of genders. For numbers, +-- it is like the conjunction with $Pl$ corresponding to $False$. For genders, +-- $Neutr$ corresponds to $False$. + + conjNumber : Number -> Number -> Number = \m,n -> case of { + => Sg ; + _ => Pl + } ; + + conjGender : Gender -> Gender -> Gender = \m,n -> case of { + => Utr ; + _ => Neutr + } ; + + +--2 Subjunction +-- +-- Subjunctions ("om", "när", 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. "om du sover kommer björnen" +-- and "björnen kommer om du sover". + + 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)} ; + + subjunctVariants : Subjunction -> Sentence -> Str -> Str = \if,A,B -> + let {As = A.s ! Sub} in + variants {if.s ++ As ++ "," ++ B ; B ++ "," ++ if.s ++ As} ; + + subjunctVerbPhrase : VerbPhrase -> Subjunction -> Sentence -> VerbPhrase = + \V, if, A -> + adVerbPhrase V (advPost (if.s ++ A.s ! Sub)) ; + +--2 One-word utterances +-- +-- An utterance can consist of one phrase of almost any category, +-- the limiting case being one-word utterances. These +-- utterances are often (but not always) in what can be called the +-- default form of a category, e.g. the nominative. +-- This list is far from exhaustive. + + useNounPhrase : NounPhrase -> Utterance = \john -> + postfixSS "." (defaultNounPhrase john) ; + useCommonNounPhrase : Number -> CommNounPhrase -> Utterance = \n,car -> + useNounPhrase (indefNounPhrase n car) ; + +-- Here are some default forms. + + defaultNounPhrase : NounPhrase -> SS = \john -> + ss (john.s ! PNom) ; + + defaultQuestion : Question -> SS = \whoareyou -> + ss (whoareyou.s ! DirQ) ; + + defaultSentence : Sentence -> Utterance = \x -> ss (x.s ! Main) ; +} ; diff --git a/lib/resource-0.6/swedish/TestResourceSwe.gf b/lib/resource-0.6/swedish/TestResourceSwe.gf new file mode 100644 index 000000000..fc8db3f34 --- /dev/null +++ b/lib/resource-0.6/swedish/TestResourceSwe.gf @@ -0,0 +1,51 @@ +--# -path=.:../abstract:../../prelude + +concrete TestResourceSwe of TestResource = StructuralSwe ** open SyntaxSwe in { + +flags startcat=Phr ; lexer=text ; unlexer=text ; + +-- a random sample from the lexicon + +lin + Big = stor_25 ; + Small = liten_1146 ; + Old = gammal_16 ; + Young = ung_29 ; + American = extAdjective (aFin "amerikansk") ; + Finnish = extAdjective (aFin "finsk") ; + Happy = aFin "lycklig" ; + Married = extAdjective (aAbstrakt "gift") ** {s2 = "med"} ; + Man = extCommNoun Masc man_1144 ; + Bar = extCommNoun NoMasc (sSak "bar") ; + Bottle = extCommNoun NoMasc (sApa "flask") ; + Woman = extCommNoun NoMasc (sApa "kvinn") ; + Car = extCommNoun NoMasc (sBil "bil") ; + House = extCommNoun NoMasc (sHus "hus") ; + Light = extCommNoun NoMasc (sHus "ljus") ; + Wine = extCommNoun NoMasc (sParti "vin") ; + Walk = extVerb Act gå_1174 ; + Run = extVerb Act (vFinna "spring" "sprang" "sprung") ; + Drink = extTransVerb (vFinna "drick" "drack" "druck") [] ; + Love = extTransVerb (vTala "älsk") [] ; + Send = extTransVerb (vTala "skick") [] ; + Wait = extTransVerb (vTala "vänt") "på" ; + Give = extTransVerb (vFinna "giv" "gav" "giv") [] ** {s3 = "till"} ; --- ge + Prefer = extTransVerb (vFinna "föredrag" "föredrog" "föredrag") [] ** + {s3 = "framför"} ; --- föredra + + Say = extVerb Act (vLeka "säg") ; --- works in present tense... + Prove = extVerb Act (vTala "bevis") ; + SwitchOn = mkDirectVerb (extVerbPart Act (vFinna "sätt" "satte" "satt") "på") ; + SwitchOff = mkDirectVerb (extVerbPart Act (vLeka "stäng") "av") ; + + Mother = mkFun (extCommNoun NoMasc mor_1) "till" ; + Uncle = mkFun (extCommNoun Masc farbror_8) "till" ; + Connection = mkFun (extCommNoun NoMasc (sVarelse "förbindelse")) "från" ** + {s3 = "till"} ; + + Always = advPre "alltid" ; + Well = advPost "bra" ; + + John = mkProperName "Johan" Utr Masc ; + Mary = mkProperName "Maria" Utr NoMasc ; +} ; diff --git a/lib/resource-0.6/swedish/TypesSwe.gf b/lib/resource-0.6/swedish/TypesSwe.gf new file mode 100644 index 000000000..60e0bb7fa --- /dev/null +++ b/lib/resource-0.6/swedish/TypesSwe.gf @@ -0,0 +1,161 @@ +--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 TypesSwe = 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} ; + + adverbForm : AdjFormPos = Strong (ASg Neutr) ; + +--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. +-- Active verbs continue to have passive forms. But we add an extra field $s1$ +-- for a verb particle, as e.g. in "se upp". + +param + VMode = Infinit | Indicat | Imperat ; + VForm = VPres VMode Voice ; + +oper + Verb : Type = {s : VForm => Str ; s1 : Str} ; + + extVerbPart : Voice -> Verbum -> Str -> Verb = \v,verb,upp -> {s = table { + VPres Infinit v => verb.s ! VI (Inf v) ; + VPres Indicat v => verb.s ! VF (Pres Ind v) ; + VPres Imperat Act => verb.s ! VF Imper ; + VPres Imperat Pass => verb.s ! VF (Pres Ind Pass) --- no passive in Verbum + } ; + s1 = upp + } ; + + extVerb : Voice -> Verbum -> Verb = \v,verb -> + extVerbPart v verb [] ; + +--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} ; +}