From a41f4407d2f224421a287c166df1efa7fab0e995 Mon Sep 17 00:00:00 2001 From: aarne Date: Fri, 18 Apr 2008 14:11:36 +0000 Subject: [PATCH] richer extraction syntax --- lib/resource/english/VerbEng.gf | 7 +- lib/resource/exper/abstract/Adjective.gf | 30 + lib/resource/exper/abstract/Adverb.gf | 33 ++ lib/resource/exper/abstract/Cat.gf | 131 +++++ lib/resource/exper/abstract/Common.gf | 61 ++ lib/resource/exper/abstract/Conjunction.gf | 52 ++ lib/resource/exper/abstract/Extra.gf | 30 + lib/resource/exper/abstract/Grammar.gf | 22 + lib/resource/exper/abstract/Idiom.gf | 22 + lib/resource/exper/abstract/Lang.gf | 13 + lib/resource/exper/abstract/Lexicon.gf | 356 ++++++++++++ lib/resource/exper/abstract/Noun.gf | 140 +++++ lib/resource/exper/abstract/Numeral.gf | 60 ++ lib/resource/exper/abstract/Phrase.gf | 44 ++ lib/resource/exper/abstract/Question.gf | 29 + lib/resource/exper/abstract/Relative.gf | 26 + lib/resource/exper/abstract/Sentence.gf | 99 ++++ lib/resource/exper/abstract/Structural.gf | 112 ++++ lib/resource/exper/abstract/Text.gf | 15 + lib/resource/exper/abstract/Verb.gf | 89 +++ lib/resource/exper/english/AdjectiveEng.gf | 38 ++ lib/resource/exper/english/AdverbEng.gf | 21 + lib/resource/exper/english/CatEng.gf | 82 +++ lib/resource/exper/english/ConjunctionEng.gf | 45 ++ lib/resource/exper/english/English.gf | 9 + lib/resource/exper/english/EnglishAbs.gf | 9 + lib/resource/exper/english/ExtraEng.gf | 52 ++ lib/resource/exper/english/ExtraEngAbs.gf | 16 + lib/resource/exper/english/GrammarEng.gf | 21 + lib/resource/exper/english/IdiomEng.gf | 30 + lib/resource/exper/english/IrregEng.gf | 181 ++++++ lib/resource/exper/english/IrregEngAbs.gf | 176 ++++++ lib/resource/exper/english/LangEng.gf | 10 + lib/resource/exper/english/LexiconEng.gf | 375 ++++++++++++ lib/resource/exper/english/MorphoEng.gf | 198 +++++++ lib/resource/exper/english/NounEng.gf | 94 +++ lib/resource/exper/english/NumeralEng.gf | 95 +++ lib/resource/exper/english/OverloadEng.gf | 1 + lib/resource/exper/english/ParadigmsEng.gf | 572 +++++++++++++++++++ lib/resource/exper/english/PhraseEng.gf | 24 + lib/resource/exper/english/QuestionEng.gf | 44 ++ lib/resource/exper/english/RelativeEng.gf | 48 ++ lib/resource/exper/english/ResEng.gf | 455 +++++++++++++++ lib/resource/exper/english/SentenceEng.gf | 88 +++ lib/resource/exper/english/StructuralEng.gf | 131 +++++ lib/resource/exper/english/VerbEng.gf | 67 +++ lib/resource/scandinavian/CatScand.gf | 2 +- 47 files changed, 4251 insertions(+), 4 deletions(-) create mode 100644 lib/resource/exper/abstract/Adjective.gf create mode 100644 lib/resource/exper/abstract/Adverb.gf create mode 100644 lib/resource/exper/abstract/Cat.gf create mode 100644 lib/resource/exper/abstract/Common.gf create mode 100644 lib/resource/exper/abstract/Conjunction.gf create mode 100644 lib/resource/exper/abstract/Extra.gf create mode 100644 lib/resource/exper/abstract/Grammar.gf create mode 100644 lib/resource/exper/abstract/Idiom.gf create mode 100644 lib/resource/exper/abstract/Lang.gf create mode 100644 lib/resource/exper/abstract/Lexicon.gf create mode 100644 lib/resource/exper/abstract/Noun.gf create mode 100644 lib/resource/exper/abstract/Numeral.gf create mode 100644 lib/resource/exper/abstract/Phrase.gf create mode 100644 lib/resource/exper/abstract/Question.gf create mode 100644 lib/resource/exper/abstract/Relative.gf create mode 100644 lib/resource/exper/abstract/Sentence.gf create mode 100644 lib/resource/exper/abstract/Structural.gf create mode 100644 lib/resource/exper/abstract/Text.gf create mode 100644 lib/resource/exper/abstract/Verb.gf create mode 100644 lib/resource/exper/english/AdjectiveEng.gf create mode 100644 lib/resource/exper/english/AdverbEng.gf create mode 100644 lib/resource/exper/english/CatEng.gf create mode 100644 lib/resource/exper/english/ConjunctionEng.gf create mode 100644 lib/resource/exper/english/English.gf create mode 100644 lib/resource/exper/english/EnglishAbs.gf create mode 100644 lib/resource/exper/english/ExtraEng.gf create mode 100644 lib/resource/exper/english/ExtraEngAbs.gf create mode 100644 lib/resource/exper/english/GrammarEng.gf create mode 100644 lib/resource/exper/english/IdiomEng.gf create mode 100644 lib/resource/exper/english/IrregEng.gf create mode 100644 lib/resource/exper/english/IrregEngAbs.gf create mode 100644 lib/resource/exper/english/LangEng.gf create mode 100644 lib/resource/exper/english/LexiconEng.gf create mode 100644 lib/resource/exper/english/MorphoEng.gf create mode 100644 lib/resource/exper/english/NounEng.gf create mode 100644 lib/resource/exper/english/NumeralEng.gf create mode 100644 lib/resource/exper/english/OverloadEng.gf create mode 100644 lib/resource/exper/english/ParadigmsEng.gf create mode 100644 lib/resource/exper/english/PhraseEng.gf create mode 100644 lib/resource/exper/english/QuestionEng.gf create mode 100644 lib/resource/exper/english/RelativeEng.gf create mode 100644 lib/resource/exper/english/ResEng.gf create mode 100644 lib/resource/exper/english/SentenceEng.gf create mode 100644 lib/resource/exper/english/StructuralEng.gf create mode 100644 lib/resource/exper/english/VerbEng.gf diff --git a/lib/resource/english/VerbEng.gf b/lib/resource/english/VerbEng.gf index d10e665b8..c8812b7f7 100644 --- a/lib/resource/english/VerbEng.gf +++ b/lib/resource/english/VerbEng.gf @@ -4,15 +4,16 @@ concrete VerbEng of Verb = CatEng ** open ResEng in { lin UseV = predV ; - ComplV2 v np = insertObj (\\_ => v.c2 ++ np.s ! Acc) (predV v) ; - ComplV3 v np np2 = - insertObj (\\_ => v.c2 ++ np.s ! Acc ++ v.c3 ++ np2.s ! Acc) (predV v) ; ComplVV v vp = insertObj (\\a => infVP v.isAux vp a) (predVV v) ; ComplVS v s = insertObj (\\_ => conjThat ++ s.s) (predV v) ; ComplVQ v q = insertObj (\\_ => q.s ! QIndir) (predV v) ; ComplVA v ap = insertObj (ap.s) (predV v) ; + ComplV2 v np = insertObj (\\_ => v.c2 ++ np.s ! Acc) (predV v) ; + ComplV3 v np np2 = + insertObj (\\_ => v.c2 ++ np.s ! Acc ++ v.c3 ++ np2.s ! Acc) (predV v) ; + ComplV2V v np vp = insertObj (\\a => infVP v.isAux vp a) (insertObj (\\_ => v.c2 ++ np.s ! Acc) (predV v)) ; diff --git a/lib/resource/exper/abstract/Adjective.gf b/lib/resource/exper/abstract/Adjective.gf new file mode 100644 index 000000000..ad4d6801d --- /dev/null +++ b/lib/resource/exper/abstract/Adjective.gf @@ -0,0 +1,30 @@ +--1 Adjective: Adjectives and Adjectival Phrases + +abstract Adjective = Cat ** { + + fun + +-- The principal ways of forming an adjectival phrase are +-- positive, comparative, relational, reflexive-relational, and +-- elliptic-relational. +-- (The superlative use is covered in [Noun Noun.html].$SuperlA$.) + + PositA : A -> AP ; -- warm + ComparA : A -> NP -> AP ; -- warmer than Spain + ComplA2 : A2 -> NP -> AP ; -- divisible by 2 + ReflA2 : A2 -> AP ; -- divisible by itself + UseA2 : A2 -> A ; -- divisible + +-- Sentence and question complements defined for all adjectival +-- phrases, although the semantics is only clear for some adjectives. + + SentAP : AP -> SC -> AP ; -- great that she won, uncertain if she did + +-- An adjectival phrase can be modified by an *adadjective*, such as "very". + + AdAP : AdA -> AP -> AP ; -- very uncertain + +-- The formation of adverbs from adjective (e.g. "quickly") is covered +-- by [Adverb Adverb.html]. + +} diff --git a/lib/resource/exper/abstract/Adverb.gf b/lib/resource/exper/abstract/Adverb.gf new file mode 100644 index 000000000..1266cda22 --- /dev/null +++ b/lib/resource/exper/abstract/Adverb.gf @@ -0,0 +1,33 @@ +--1 Adverb: Adverbs and Adverbial Phrases + +abstract Adverb = Cat ** { + + fun + +-- The two main ways of forming adverbs are from adjectives and by +-- prepositions from noun phrases. + + PositAdvAdj : A -> Adv ; -- quickly + PrepNP : Prep -> NP -> Adv ; -- in the house + +-- Comparative adverbs have a noun phrase or a sentence as object of +-- comparison. + + ComparAdvAdj : CAdv -> A -> NP -> Adv ; -- more quickly than John + ComparAdvAdjS : CAdv -> A -> S -> Adv ; -- more quickly than he runs + +-- Adverbs can be modified by 'adadjectives', just like adjectives. + + AdAdv : AdA -> Adv -> Adv ; -- very quickly + +-- Subordinate clauses can function as adverbs. + + SubjS : Subj -> S -> Adv ; -- when he arrives + AdvSC : SC -> Adv ; -- that he arrives ---- REMOVE? + +-- Comparison adverbs also work as numeral adverbs. + + AdnCAdv : CAdv -> AdN ; -- more (than five) + + +} diff --git a/lib/resource/exper/abstract/Cat.gf b/lib/resource/exper/abstract/Cat.gf new file mode 100644 index 000000000..35e59d78a --- /dev/null +++ b/lib/resource/exper/abstract/Cat.gf @@ -0,0 +1,131 @@ +--1 Cat: the Category System + +-- The category system is central to the library in the sense +-- that the other modules ($Adjective$, $Adverb$, $Noun$, $Verb$ etc) +-- communicate through it. This means that a e.g. a function using +-- $NP$s in $Verb$ need not know how $NP$s are constructed in $Noun$: +-- it is enough that both $Verb$ and $Noun$ use the same type $NP$, +-- which is given here in $Cat$. +-- +-- Some categories are inherited from [``Common`` Common.html]. +-- The reason they are defined there is that they have the same +-- implementation in all languages in the resource (typically, +-- just a string). These categories are +-- $AdA, AdN, AdV, Adv, Ant, CAdv, IAdv, PConj, Phr$, +-- $Pol, SC, Tense, Text, Utt, Voc$. +-- +-- Moreover, the list categories $ListAdv, ListAP, ListNP, ListS$ +-- are defined on $Conjunction$ and only used locally there. + + +abstract Cat = Common ** { + + cat + +--2 Sentences and clauses + +-- Constructed in [Sentence Sentence.html], and also in +-- [Idiom Idiom.html]. + + S ; -- declarative sentence e.g. "she lived here" + QS ; -- question e.g. "where did she live" + RS ; -- relative e.g. "in which she lived" + Cl ; -- declarative clause, with all tenses e.g. "she looks at this" + Slash ; -- clause missing NP (S/NP in GPSG) e.g. "she looks at" + SSlash ;-- sentence missing NP e.g. "she has looked at" + Imp ; -- imperative e.g. "look at this" + +--2 Questions and interrogatives + +-- Constructed in [Question Question.html]. + + QCl ; -- question clause, with all tenses e.g. "why does she walk" + IP ; -- interrogative pronoun e.g. "who" + IComp ; -- interrogative complement of copula e.g. "where" + IDet ; -- interrogative determiner e.g. "which" + +--2 Relative clauses and pronouns + +-- Constructed in [Relative Relative.html]. + + RCl ; -- relative clause, with all tenses e.g. "in which she lives" + RP ; -- relative pronoun e.g. "in which" + +--2 Verb phrases + +-- Constructed in [Verb Verb.html]. + + VP ; -- verb phrase e.g. "is very warm" + Comp ; -- complement of copula, such as AP e.g. "very warm" + VPSlash ; -- verb phrase missing complement e.g. "give to John" + +--2 Adjectival phrases + +-- Constructed in [Adjective Adjective.html]. + + AP ; -- adjectival phrase e.g. "very warm" + +--2 Nouns and noun phrases + +-- Constructed in [Noun Noun.html]. +-- Many atomic noun phrases e.g. "everybody" +-- are constructed in [Structural Structural.html]. +-- The determiner structure is +-- ``` Predet (QuantSg | QuantPl Num) Ord +-- as defined in [Noun Noun.html]. + + CN ; -- common noun (without determiner) e.g. "red house" + NP ; -- noun phrase (subject or object) e.g. "the red house" + Pron ; -- personal pronoun e.g. "she" + Det ; -- determiner phrase e.g. "those seven" + Predet ; -- predeterminer (prefixed Quant) e.g. "all" + Quant ; -- quantifier ('nucleus' of Det) e.g. "this/these" + Num ; -- cardinal number (used with QuantPl) e.g. "seven" + Ord ; -- ordinal number (used in Det) e.g. "seventh" + +--2 Numerals + +-- Constructed in [Numeral Numeral.html]. + + Numeral ; -- cardinal or ordinal in words e.g. "five/fifth" + Digits ; -- cardinal or ordinal in digits e.g. "1,000/1,000th" + +--2 Structural words + +-- Constructed in [Structural Structural.html]. + + Conj ; -- conjunction e.g. "and" + DConj ; -- distributed conjunction e.g. "both - and" + Subj ; -- subjunction e.g. "if" + Prep ; -- preposition, or just case e.g. "in" + +--2 Words of open classes + +-- These are constructed in [Lexicon Lexicon.html] and in +-- additional lexicon modules. + + V ; -- one-place verb e.g. "sleep" + V2 ; -- two-place verb e.g. "love" + V3 ; -- three-place verb e.g. "show" + VV ; -- verb-phrase-complement verb e.g. "want" + VS ; -- sentence-complement verb e.g. "claim" + VQ ; -- question-complement verb e.g. "wonder" + VA ; -- adjective-complement verb e.g. "look" + V2V ; -- verb with NP and V complement e.g. "cause" + V2S ; -- verb with NP and S complement e.g. "tell" + V2Q ; -- verb with NP and Q complement e.g. "ask" + V2A ; -- verb with NP and AP complement e.g. "paint" + + A ; -- one-place adjective e.g. "warm" + A2 ; -- two-place adjective e.g. "divisible" + + N ; -- common noun e.g. "house" + N2 ; -- relational noun e.g. "son" + N3 ; -- three-place relational noun e.g. "connection" + PN ; -- proper name e.g. "Paris" + +-- DEPRECATED: QuantSg, QuantPl +--- QuantSg ;-- quantifier ('nucleus' of sing. Det) e.g. "every" +--- QuantPl ;-- quantifier ('nucleus' of plur. Det) e.g. "many" + +} diff --git a/lib/resource/exper/abstract/Common.gf b/lib/resource/exper/abstract/Common.gf new file mode 100644 index 000000000..76bfd9cf4 --- /dev/null +++ b/lib/resource/exper/abstract/Common.gf @@ -0,0 +1,61 @@ +--1 Common: Structures with Common Implementations. + +-- This module defines the categories that uniformly have the linearization +-- ${s : Str}$ in all languages. + +-- Moreover, this module defines the abstract parameters of tense, polarity, and +-- anteriority, which are used in [``Phrase`` Phrase.html] to generate different +-- forms of sentences. Together they give 4 x 2 x 2 = 16 sentence forms. + +-- These tenses are defined for all languages in the library. More tenses +-- can be defined in the language extensions, e.g. the "passé simple" of +-- Romance languages in [``ExtraRomance`` ../romance/ExtraRomance.gf]. + +abstract Common = { + + cat + +--2 Top-level units + +-- Constructed in [``Text`` Text.html]: $Text$. + + Text ; -- text consisting of several phrases e.g. "He is here. Why?" + +-- Constructed in [``Phrase`` Phrase.html]: + + Phr ; -- phrase in a text e.g. "but be quiet please" + Utt ; -- sentence, question, word... e.g. "be quiet" + Voc ; -- vocative or "please" e.g. "my darling" + PConj ; -- phrase-beginning conjunction e.g. "therefore" + +-- Constructed in [``Sentence`` Sentence.html]: + + SC ; -- embedded sentence or question e.g. "that it rains" + +--2 Adverbs + +-- Constructed in [``Adverb`` Adverb.html]. +-- Many adverbs are constructed in [``Structural`` Structural.html]. + + Adv ; -- verb-phrase-modifying adverb e.g. "in the house" + AdV ; -- adverb directly attached to verb e.g. "always" + AdA ; -- adjective-modifying adverb e.g. "very" + AdN ; -- numeral-modifying adverb e.g. "more than" + IAdv ; -- interrogative adverb e.g. "why" + CAdv ; -- comparative adverb e.g. "more" + +--2 Tense, polarity, and anteriority + + Tense ; -- tense e.g. present, past, future + Pol ; -- polarity e.g. positive, negative + Ant ; -- anteriority e.g. simultaneous, anterior + + fun + PPos, PNeg : Pol ; -- I sleep/don't sleep + + TPres : Tense ; + ASimul : Ant ; + TPast, TFut, TCond : Tense ; -- I slept/will sleep/would sleep --# notpresent + AAnter : Ant ; -- I have slept --# notpresent + +} diff --git a/lib/resource/exper/abstract/Conjunction.gf b/lib/resource/exper/abstract/Conjunction.gf new file mode 100644 index 000000000..c08a520ed --- /dev/null +++ b/lib/resource/exper/abstract/Conjunction.gf @@ -0,0 +1,52 @@ +--1 Conjunction: Coordination + +-- Coordination is defined for many different categories; here is +-- a sample. The rules apply to *lists* of two or more elements, +-- and define two general patterns: +-- - ordinary conjunction: X,...X and X +-- - distributed conjunction: both X,...,X and X +-- +-- +-- $VP$ conjunctions are not covered here, because their applicability +-- depends on language. Some special cases are defined in +-- [``Extra`` ../abstract/Extra.gf]. + + +abstract Conjunction = Cat ** { + +--2 Rules + + fun + ConjS : Conj -> [S] -> S ; -- "John walks and Mary runs" + ConjAP : Conj -> [AP] -> AP ; -- "even and prime" + ConjNP : Conj -> [NP] -> NP ; -- "John or Mary" + ConjAdv : Conj -> [Adv] -> Adv ; -- "quickly or slowly" + + DConjS : DConj -> [S] -> S ; -- "either John walks or Mary runs" + DConjAP : DConj -> [AP] -> AP ; -- "both even and prime" + DConjNP : DConj -> [NP] -> NP ; -- "either John or Mary" + DConjAdv : DConj -> [Adv] -> Adv; -- "both badly and slowly" + +--2 Categories + +-- These categories are only used in this module. + + cat + [S]{2} ; + [Adv]{2} ; + [NP]{2} ; + [AP]{2} ; + +--2 List constructors + +-- The list constructors are derived from the list notation and therefore +-- not given explicitly. But here are their type signatures: + + -- BaseC : C -> C -> [C] ; -- for C = S, AP, NP, Adv + -- ConsC : C -> [C] -> [C] ; +} + +--. +-- *Note*. This module uses right-recursive lists. If backward +-- compatibility with API 0.9 is needed, use +-- [SeqConjunction SeqConjunction.html]. diff --git a/lib/resource/exper/abstract/Extra.gf b/lib/resource/exper/abstract/Extra.gf new file mode 100644 index 000000000..08a39ea78 --- /dev/null +++ b/lib/resource/exper/abstract/Extra.gf @@ -0,0 +1,30 @@ +--1 More syntax rules + +-- This module defines syntax rules that are not implemented in all +-- languages, but in more than one, so that it makes sense to offer a +-- common API. + +abstract Extra = Cat ** { + + fun + GenNP : NP -> Quant ; -- this man's + ComplBareVS : VS -> S -> VP ; -- know you go + + StrandRelSlash : RP -> Slash -> RCl ; -- that he lives in + EmptyRelSlash : RP -> Slash -> RCl ; -- he lives in + StrandQuestSlash : IP -> Slash -> QCl ; -- whom does John live with + +-- $VP$ conjunction, which has different fragments implemented in +-- different languages - never a full $VP$, though. + + cat + VPI ; + [VPI] {2} ; + + fun + MkVPI : VP -> VPI ; + ConjVPI : Conj -> [VPI] -> VPI ; + ComplVPIVV : VV -> VPI -> VP ; + + +} diff --git a/lib/resource/exper/abstract/Grammar.gf b/lib/resource/exper/abstract/Grammar.gf new file mode 100644 index 000000000..a1edd59df --- /dev/null +++ b/lib/resource/exper/abstract/Grammar.gf @@ -0,0 +1,22 @@ +--1 Grammar: the Main Module of the Resource Grammar + +-- This grammar is a collection of the different grammar modules, +-- To test the resource, import [``Lang`` Lang.html], which also contains +-- a lexicon. + +abstract Grammar = + Noun, + Verb, + Adjective, + Adverb, + Numeral, + Sentence, + Question, + Relative, + Conjunction, + Phrase, + Text, + Structural, + Idiom ; + + diff --git a/lib/resource/exper/abstract/Idiom.gf b/lib/resource/exper/abstract/Idiom.gf new file mode 100644 index 000000000..8a8168b5a --- /dev/null +++ b/lib/resource/exper/abstract/Idiom.gf @@ -0,0 +1,22 @@ +--1 Idiom: Idiomatic Expressions + +abstract Idiom = Cat ** { + +-- This module defines constructions that are formed in fixed ways, +-- often different even in closely related languages. + + fun + ImpersCl : VP -> Cl ; -- it rains + GenericCl : VP -> Cl ; -- one sleeps + + CleftNP : NP -> RS -> Cl ; -- it is you who did it + CleftAdv : Adv -> S -> Cl ; -- it is yesterday she arrived + + ExistNP : NP -> Cl ; -- there is a house + ExistIP : IP -> QCl ; -- which houses are there + + ProgrVP : VP -> VP ; -- be sleeping + + ImpPl1 : VP -> Utt ; -- let's go + +} diff --git a/lib/resource/exper/abstract/Lang.gf b/lib/resource/exper/abstract/Lang.gf new file mode 100644 index 000000000..978d970ad --- /dev/null +++ b/lib/resource/exper/abstract/Lang.gf @@ -0,0 +1,13 @@ +--1 Lang: a Test Module for the Resource Grammar + +-- This grammar is for testing the resource as included in the +-- language-independent API, consisting of a grammar and a lexicon. +-- The grammar without a lexicon is [``Grammar`` Grammar.html], +-- which may be more suitable to open in applications. + +abstract Lang = + Grammar, + Lexicon + ** { + flags startcat=Phr ; + } ; diff --git a/lib/resource/exper/abstract/Lexicon.gf b/lib/resource/exper/abstract/Lexicon.gf new file mode 100644 index 000000000..59b844ec9 --- /dev/null +++ b/lib/resource/exper/abstract/Lexicon.gf @@ -0,0 +1,356 @@ +abstract Lexicon = Cat ** { +fun + add_V3 : V3 ; + airplane_N : N ; + already_Adv : Adv ; + animal_N : N ; + answer_V2S : V2S ; + apartment_N : N ; + apple_N : N ; + art_N : N ; + ashes_N : N ; + ask_V2Q : V2Q ; + baby_N : N ; + back_N : N ; + bad_A : A ; + bank_N : N ; + bark_N : N ; + beautiful_A : A ; + become_VA : VA ; + beer_N : N ; + beg_V2V : V2V ; + belly_N : N ; + big_A : A ; + bike_N : N ; + bird_N : N ; + bite_V2 : V2 ; + black_A : A ; + blood_N : N ; + blow_V : V ; + blue_A : A ; + boat_N : N ; + bone_N : N ; + book_N : N ; + boot_N : N ; + boss_N : N ; + boy_N : N ; + bread_N : N ; + break_V2 : V2 ; + breast_N : N ; + breathe_V : V ; + broad_A : A ; + brother_N2 : N2 ; + brown_A : A ; + burn_V : V ; + butter_N : N ; + buy_V2 : V2 ; + camera_N : N ; + cap_N : N ; + car_N : N ; + carpet_N : N ; + cat_N : N ; + ceiling_N : N ; + chair_N : N ; + cheese_N : N ; + child_N : N ; + church_N : N ; + city_N : N ; + clean_A : A ; + clever_A : A ; + close_V2 : V2 ; + cloud_N : N ; + coat_N : N ; + cold_A : A ; + come_V : V ; + computer_N : N ; + correct_A : A ; + country_N : N ; + count_V2 : V2 ; + cousin_N : N ; + cow_N : N ; + cut_V2 : V2 ; + day_N : N ; + die_V : V ; + dig_V : V ; + dirty_A : A ; + distance_N3 : N3 ; + doctor_N : N ; + dog_N : N ; + door_N : N ; + do_V2 : V2 ; + drink_V2 : V2 ; + drink_V2 : V2 ; + dry_A : A ; + dull_A : A ; + dust_N : N ; + ear_N : N ; + earth_N : N ; + easy_A2V : A2 ; + eat_V2 : V2 ; + eat_V2 : V2 ; + egg_N : N ; + empty_A : A ; + enemy_N : N ; + eye_N : N ; + factory_N : N ; + fall_V : V ; + far_Adv : Adv ; + father_N2 : N2 ; + fat_N : N ; + fear_VS : VS ; + fear_V2 : V2 ; + feather_N : N ; + fight_V2 : V2 ; + find_V2 : V2 ; + fingernail_N : N ; + fire_N : N ; + fish_N : N ; + float_V : V ; + floor_N : N ; + flower_N : N ; + flow_V : V ; + fly_V : V ; + fog_N : N ; + foot_N : N ; + forest_N : N ; + forget_V2 : V2 ; + freeze_V : V ; + fridge_N : N ; + friend_N : N ; + fruit_N : N ; + full_A : A ; + fun + fun_AV : A ; + garden_N : N ; + girl_N : N ; + give_V3 : V3 ; + glove_N : N ; + gold_N : N ; + good_A : A ; + go_V : V ; + grammar_N : N ; + grass_N : N ; + green_A : A ; + guts_N : N ; + hair_N : N ; + hand_N : N ; + harbour_N : N ; + hate_V2 : V2 ; + hat_N : N ; + have_V2 : V2 ; + head_N : N ; + heart_N : N ; + hear_V2 : V2 ; + hear_V2 : V2 ; + heavy_A : A ; + hill_N : N ; + hit_V2 : V2 ; + hold_V2 : V2 ; + hope_VS : VS ; + horn_N : N ; + horse_N : N ; + hot_A : A ; + house_N : N ; + hunt_V2 : V2 ; + husband_N : N ; + ice_N : N ; + important_A : A ; + industry_N : N ; + iron_N : N ; + john_PN : PN ; + jump_V : V ; + kill_V2 : V2 ; + king_N : N ; + knee_N : N ; + know_V2 : V2 ; + know_V2 : V2 ; + lake_N : N ; + lamp_N : N ; + language_N : N ; + laugh_V : V ; + leaf_N : N ; + learn_V2 : V2 ; + leather_N : N ; + leave_V2 : V2 ; + left_Ord : Ord ; + leg_N : N ; + lie_V : V ; + like_V2 : V2 ; + listen_V2 : V2 ; + liver_N : N ; + live_V : V ; + long_A : A ; + lose_V2 : V2 ; + louse_N : N ; + love_N : N ; + love_V2 : V2 ; + man_N : N ; + married_A2 : A2 ; + meat_N : N ; + milk_N : N ; + moon_N : N ; + mother_N2 : N2 ; + mountain_N : N ; + mouth_N : N ; + music_N : N ; + name_N : N ; + narrow_A : A ; + near_A : A ; + neck_N : N ; + new_A : A ; + newspaper_N : N ; + night_N : N ; + nose_N : N ; + now_Adv : Adv ; + number_N : N ; + oil_N : N ; + old_A : A ; + open_V2 : V2 ; + paint_V2A : V2A ; + paper_N : N ; + paris_PN : PN ; + peace_N : N ; + pen_N : N ; + person_N : N ; + planet_N : N ; + plastic_N : N ; + play_V2 : V2 ; + play_V : V ; + policeman_N : N ; + priest_N : N ; + probable_AS : A ; + pull_V2 : V2 ; + push_V2 : V2 ; + put_V2 : V2 ; + queen_N : N ; + question_N : N ; + radio_N : N ; + rain_N : N ; + rain_V0 : V ; + read_V2 : V2 ; + ready_A : A ; + reason_N : N ; + red_A : A ; + religion_N : N ; + restaurant_N : N ; + right_Ord : Ord ; + river_N : N ; + road_N : N ; + rock_N : N ; + roof_N : N ; + root_N : N ; + rope_N : N ; + rotten_A : A ; + round_A : A ; + rubber_N : N ; + rub_V2 : V2 ; + rule_N : N ; + run_V : V ; + salt_N : N ; + sand_N : N ; + say_VS : VS ; + school_N : N ; + science_N : N ; + scratch_V2 : V2 ; + sea_N : N ; + seed_N : N ; + seek_V2 : V2 ; + see_V2 : V2 ; + see_V2 : V2 ; + sell_V3 : V3 ; + send_V3 : V3 ; + sew_V : V ; + sharp_A : A ; + sheep_N : N ; + ship_N : N ; + shirt_N : N ; + shoe_N : N ; + shop_N : N ; + short_A : A ; + silver_N : N ; + sing_V : V ; + sister_N : N ; + sit_V : V ; + skin_N : N ; + sky_N : N ; + sleep_V : V ; + small_A : A ; + smell_V : V ; + smoke_N : N ; + smooth_A : A ; + snake_N : N ; + snow_N : N ; + sock_N : N ; + song_N : N ; + speak_V2 : V2 ; + spit_V : V ; + split_V2 : V2 ; + squeeze_V2 : V2 ; + stab_V2 : V2 ; + stand_V : V ; + star_N : N ; + steel_N : N ; + stick_N : N ; + stone_N : N ; + stop_V : V ; + stove_N : N ; + straight_A : A ; + student_N : N ; + stupid_A : A ; + suck_V2 : V2 ; + sun_N : N ; + swell_V : V ; + swim_V : V ; + switch8off_V2 : V2 ; + switch8on_V2 : V2 ; + table_N : N ; + tail_N : N ; + talk_V3 : V3 ; + teacher_N : N ; + teach_V2 : V2 ; + television_N : N ; + thick_A : A ; + thin_A : A ; + think_V : V ; + throw_V2 : V2 ; + tie_V2 : V2 ; + today_Adv : Adv ; + tongue_N : N ; + tooth_N : N ; + train_N : N ; + travel_V : V ; + tree_N : N ; + turn_V : V ; + ugly_A : A ; + uncertain_A : A ; + understand_V2 : V2 ; + university_N : N ; + village_N : N ; + vomit_V : V ; + wait_V2 : V2 ; + walk_V : V ; + warm_A : A ; + war_N : N ; + wash_V2 : V2 ; + watch_V2 : V2 ; + water_N : N ; + wet_A : A ; + white_A : A ; + wide_A : A ; + wife_N : N ; + wind_N : N ; + window_N : N ; + wine_N : N ; + wing_N : N ; + win_V2 : V2 ; + wipe_V2 : V2 ; + woman_N : N ; + wonder_VQ : VQ ; + wood_N : N ; + worm_N : N ; + write_V2 : V2 ; + year_N : N ; + yellow_A : A ; + young_A : A ; + +} diff --git a/lib/resource/exper/abstract/Noun.gf b/lib/resource/exper/abstract/Noun.gf new file mode 100644 index 000000000..a97799647 --- /dev/null +++ b/lib/resource/exper/abstract/Noun.gf @@ -0,0 +1,140 @@ +--1 Noun: Nouns, noun phrases, and determiners + +abstract Noun = Cat ** { + +--2 Noun phrases + +-- The three main types of noun phrases are +-- - common nouns with determiners +-- - proper names +-- - pronouns +-- +-- + fun + DetCN : Det -> CN -> NP ; -- the man + UsePN : PN -> NP ; -- John + UsePron : Pron -> NP ; -- he + +-- Pronouns are defined in the module [``Structural`` Structural.html]. + +-- A noun phrase already formed can be modified by a $Predet$erminer. + + PredetNP : Predet -> NP -> NP; -- only the man + +-- A noun phrase can also be postmodified by the past participle of a +-- verb or by an adverb. + + PPartNP : NP -> V2 -> NP ; -- the number squared + AdvNP : NP -> Adv -> NP ; -- Paris at midnight + +--2 Determiners + +-- The determiner has a fine-grained structure, in which a 'nucleus' +-- quantifier and two optional parts can be discerned. +-- The cardinal numeral is only available for plural determiners. +-- (This is modified from CLE by further dividing their $Num$ into +-- cardinal and ordinal.) + + DetSg : Quant -> Ord -> Det ; -- this best man + DetPl : Quant -> Num -> Ord -> Det ; -- these five best men + +-- Notice that $DetPl$ can still result in a singular determiner, because +-- "one" is a numeral: "this one man". + +-- Quantifiers that have both forms can be used in both ways. + +--- DEPRECATED: no longer needed +--- SgQuant : Quant -> QuantSg ; -- this +--- PlQuant : Quant -> QuantPl ; -- these + +-- Pronouns have possessive forms. Genitives of other kinds +-- of noun phrases are not given here, since they are not possible +-- in e.g. Romance languages. They can be found in +-- [``Extra`` ../abstract/Extra.gf]. + + PossPron : Pron -> Quant ; -- my (house) + +-- All parts of the determiner can be empty, except $Quant$, which is +-- the "kernel" of a determiner. + + NoNum : Num ; + NoOrd : Ord ; + +-- $Num$ consists of either digits or numeral words. + + NumInt : Int -> Num ; -- 51 (DEPRECATED) + NumDigits : Digits -> Num ; -- 51 + NumNumeral : Numeral -> Num ; -- fifty-one + +-- The construction of numerals is defined in [Numeral Numeral.html]. + +-- $Num$ can be modified by certain adverbs. + + AdNum : AdN -> Num -> Num ; -- almost 51 + +-- $Ord$ consists of either digits or numeral words. + + OrdInt : Int -> Ord ; -- 51st (DEPRECATED) + OrdDigits : Digits -> Ord ; -- 51st + OrdNumeral : Numeral -> Ord ; -- fifty-first + +-- Superlative forms of adjectives behave syntactically in the same way as +-- ordinals. + + OrdSuperl : A -> Ord ; -- largest + +-- Definite and indefinite constructions are sometimes realized as +-- neatly distinct words (Spanish "un, unos ; el, los") but also without +-- any particular word (Finnish; Swedish definites). + + DefArt : Quant ; -- the (house), the (houses) + IndefArt : Quant ; -- a (house), (houses) + +-- Nouns can be used without an article as mass nouns. The resource does +-- not distinguish mass nouns from other common nouns, which can result +-- in semantically odd expressions. + + MassDet : Quant ; -- (beer) + +-- Other determiners are defined in [Structural Structural.html]. + + + +--2 Common nouns + +-- Simple nouns can be used as nouns outright. + + UseN : N -> CN ; -- house + +-- Relational nouns take one or two arguments. + + ComplN2 : N2 -> NP -> CN ; -- son of the king + ComplN3 : N3 -> NP -> N2 ; -- flight from Moscow (to Paris) + +-- Relational nouns can also be used without their arguments. +-- The semantics is typically derivative of the relational meaning. + + UseN2 : N2 -> CN ; -- son + UseN3 : N3 -> CN ; -- flight + +-- Nouns can be modified by adjectives, relative clauses, and adverbs +-- (the last rule will give rise to many 'PP attachment' ambiguities +-- when used in connection with verb phrases). + + AdjCN : AP -> CN -> CN ; -- big house + RelCN : CN -> RS -> CN ; -- house that John owns + AdvCN : CN -> Adv -> CN ; -- house on the hill + +-- Nouns can also be modified by embedded sentences and questions. +-- For some nouns this makes little sense, but we leave this for applications +-- to decide. Sentential complements are defined in [Verb Verb.html]. + + SentCN : CN -> SC -> CN ; -- fact that John smokes, question if he does + +--2 Apposition + +-- This is certainly overgenerating. + + ApposCN : CN -> NP -> CN ; -- number x, numbers x and y + +} ; diff --git a/lib/resource/exper/abstract/Numeral.gf b/lib/resource/exper/abstract/Numeral.gf new file mode 100644 index 000000000..68fcb90d0 --- /dev/null +++ b/lib/resource/exper/abstract/Numeral.gf @@ -0,0 +1,60 @@ +--1 Numerals + +-- This grammar defines numerals from 1 to 999999. +-- The implementations are adapted from the +-- [numerals library http://www.cs.chalmers.se/~aarne/GF/examples/numerals/] +-- which defines numerals for 88 languages. +-- The resource grammar implementations add to this inflection (if needed) +-- and ordinal numbers. +-- +-- *Note* 1. Number 1 as defined +-- in the category $Numeral$ here should not be used in the formation of +-- noun phrases, and should therefore be removed. Instead, one should use +-- [Structural Structural.html]$.one_Quant$. This makes the grammar simpler +-- because we can assume that numbers form plural noun phrases. +-- +-- *Note* 2. The implementations introduce spaces between +-- parts of a numeral, which is often incorrect - more work on +-- (un)lexing is needed to solve this problem. + +abstract Numeral = Cat ** { + +cat + Digit ; -- 2..9 + Sub10 ; -- 1..9 + Sub100 ; -- 1..99 + Sub1000 ; -- 1..999 + Sub1000000 ; -- 1..999999 + +fun + num : Sub1000000 -> Numeral ; + + n2, n3, n4, n5, n6, n7, n8, n9 : Digit ; + + pot01 : Sub10 ; -- 1 + pot0 : Digit -> Sub10 ; -- d * 1 + pot110 : Sub100 ; -- 10 + pot111 : Sub100 ; -- 11 + pot1to19 : Digit -> Sub100 ; -- 10 + d + pot0as1 : Sub10 -> Sub100 ; -- coercion of 1..9 + pot1 : Digit -> Sub100 ; -- d * 10 + pot1plus : Digit -> Sub10 -> Sub100 ; -- d * 10 + n + pot1as2 : Sub100 -> Sub1000 ; -- coercion of 1..99 + pot2 : Sub10 -> Sub1000 ; -- m * 100 + pot2plus : Sub10 -> Sub100 -> Sub1000 ; -- m * 100 + n + pot2as3 : Sub1000 -> Sub1000000 ; -- coercion of 1..999 + pot3 : Sub1000 -> Sub1000000 ; -- m * 1000 + pot3plus : Sub1000 -> Sub1000 -> Sub1000000 ; -- m * 1000 + n + +-- Numerals as sequences of digits have a separate, simpler grammar + + cat + Dig ; + + fun + IDig : Dig -> Digits ; + IIDig : Dig -> Digits -> Digits ; + + D_0, D_1, D_2, D_3, D_4, D_5, D_6, D_7, D_8, D_9 : Dig ; + +} diff --git a/lib/resource/exper/abstract/Phrase.gf b/lib/resource/exper/abstract/Phrase.gf new file mode 100644 index 000000000..d080e78bf --- /dev/null +++ b/lib/resource/exper/abstract/Phrase.gf @@ -0,0 +1,44 @@ +--1 Phrase: Phrases and Utterances + +abstract Phrase = Cat ** { + +-- When a phrase is built from an utterance it can be prefixed +-- with a phrasal conjunction (such as "but", "therefore") +-- and suffixing with a vocative (typically a noun phrase). + + fun + PhrUtt : PConj -> Utt -> Voc -> Phr ; -- But go home my friend. + +-- Utterances are formed from sentences, questions, and imperatives. + + UttS : S -> Utt ; -- John walks + UttQS : QS -> Utt ; -- is it good + UttImpSg : Pol -> Imp -> Utt; -- (don't) help yourself + UttImpPl : Pol -> Imp -> Utt; -- (don't) help yourselves + UttImpPol : Pol -> Imp -> Utt ; -- (don't) help (polite) + +-- There are also 'one-word utterances'. A typical use of them is +-- as answers to questions. +-- *Note*. This list is incomplete. More categories could be covered. +-- Moreover, in many languages e.g. noun phrases in different cases +-- can be used. + + UttIP : IP -> Utt ; -- who + UttIAdv : IAdv -> Utt ; -- why + UttNP : NP -> Utt ; -- this man + UttAdv : Adv -> Utt ; -- here + UttVP : VP -> Utt ; -- to sleep + +-- The phrasal conjunction is optional. A sentence conjunction +-- can also used to prefix an utterance. + + NoPConj : PConj ; + PConjConj : Conj -> PConj ; -- and + +-- The vocative is optional. Any noun phrase can be made into vocative, +-- which may be overgenerating (e.g. "I"). + + NoVoc : Voc ; + VocNP : NP -> Voc ; -- my friend + +} diff --git a/lib/resource/exper/abstract/Question.gf b/lib/resource/exper/abstract/Question.gf new file mode 100644 index 000000000..1898c46f2 --- /dev/null +++ b/lib/resource/exper/abstract/Question.gf @@ -0,0 +1,29 @@ +--1 Question: Questions and Interrogative Pronouns + +abstract Question = Cat ** { + +-- A question can be formed from a clause ('yes-no question') or +-- with an interrogative. + + fun + QuestCl : Cl -> QCl ; -- does John walk + QuestVP : IP -> VP -> QCl ; -- who walks + QuestSlash : IP -> Slash -> QCl ; -- who does John love + QuestIAdv : IAdv -> Cl -> QCl ; -- why does John walk + QuestIComp : IComp -> NP -> QCl ; -- where is John + +-- Interrogative pronouns can be formed with interrogative +-- determiners. + + IDetCN : IDet -> Num -> Ord -> CN -> IP; -- which five best songs + AdvIP : IP -> Adv -> IP ; -- who in Europe + + PrepIP : Prep -> IP -> IAdv ; -- with whom + + CompIAdv : IAdv -> IComp ; -- where + + +-- More $IP$, $IDet$, and $IAdv$ are defined in +-- [``Structural`` Structural.html]. + +} diff --git a/lib/resource/exper/abstract/Relative.gf b/lib/resource/exper/abstract/Relative.gf new file mode 100644 index 000000000..6a55f67e0 --- /dev/null +++ b/lib/resource/exper/abstract/Relative.gf @@ -0,0 +1,26 @@ +--1 Relative clauses and pronouns + +abstract Relative = Cat ** { + + fun + +-- The simplest way to form a relative clause is from a clause by +-- a pronoun similar to "such that". + + RelCl : Cl -> RCl ; -- such that John loves her + +-- The more proper ways are from a verb phrase +-- (formed in [``Verb`` Verb.html]) or a sentence +-- with a missing noun phrase (formed in [``Sentence`` Sentence.html]). + + RelVP : RP -> VP -> RCl ; -- who loves John + RelSlash : RP -> Slash -> RCl ; -- whom John loves + +-- Relative pronouns are formed from an 'identity element' by prefixing +-- or suffixing (depending on language) prepositional phrases. + + IdRP : RP ; -- which + FunRP : Prep -> NP -> RP -> RP ; -- all the roots of which + +} + diff --git a/lib/resource/exper/abstract/Sentence.gf b/lib/resource/exper/abstract/Sentence.gf new file mode 100644 index 000000000..a9b13408b --- /dev/null +++ b/lib/resource/exper/abstract/Sentence.gf @@ -0,0 +1,99 @@ +--1 Sentence: Sentences, Clauses, and Imperatives + +abstract Sentence = Cat ** { + +--2 Clauses + +-- The $NP VP$ predication rule form a clause whose linearization +-- gives a table of all tense variants, positive and negative. +-- Clauses are converted to $S$ (with fixed tense) with the +-- $UseCl$ function below. + + fun + PredVP : NP -> VP -> Cl ; -- John walks + +-- Using an embedded sentence as a subject is treated separately. +-- This can be overgenerating. E.g. "whether you go" as subject +-- is only meaningful for some verb phrases. + + PredSCVP : SC -> VP -> Cl ; -- that you go makes me happy + +--2 Clauses missing object noun phrases + +-- This category is a variant of the 'slash category' $S/NP$ of +-- GPSG and categorial grammars, which in turn replaces +-- movement transformations in the formation of questions +-- and relative clauses. Except $SlashV2$, the construction +-- rules can be seen as special cases of function composition, in +-- the style of CCG. +-- *Note* the set is not complete and lacks e.g. verbs with more than 2 places. + + SlashVP : NP -> VPSlash -> Slash ; -- (whom) he sees + AdvSlash : Slash -> Adv -> Slash ; -- (whom) he sees tomorrow + SlashPrep : Cl -> Prep -> Slash ; -- (with whom) he walks + SlashVS : NP -> VS -> SSlash -> Slash ; -- (whom) he says that she loves + +--2 Imperatives + +-- An imperative is straightforwardly formed from a verb phrase. +-- It has variation over positive and negative, singular and plural. +-- To fix these parameters, see [Phrase Phrase.html]. + + ImpVP : VP -> Imp ; -- go + +--2 Embedded sentences + +-- Sentences, questions, and infinitival phrases can be used as +-- subjects and (adverbial) complements. + + EmbedS : S -> SC ; -- that you go + EmbedQS : QS -> SC ; -- whether you go + EmbedVP : VP -> SC ; -- to go + +--2 Sentences + +-- These are the 2 x 4 x 4 = 16 forms generated by different +-- combinations of tense, polarity, and +-- anteriority, which are defined in [``Common`` Common.html]. + + fun + UseCl : Tense -> Ant -> Pol -> Cl -> S ; + UseQCl : Tense -> Ant -> Pol -> QCl -> QS ; + UseRCl : Tense -> Ant -> Pol -> RCl -> RS ; + UseSlash : Tense -> Ant -> Pol -> Slash -> SSlash ; + +-- An adverb can be added to the beginning of a sentence. + + AdvS : Adv -> S -> S ; -- today, I will go home + +--- Obsolete + + SlashV2 : NP -> V2 -> Slash ; -- (whom) he sees + SlashVVV2 : NP -> VV -> V2 -> Slash; -- (whom) he wants to see + +} + +--. + +--- todo: tense of embedded Slash +-- SlashVSS : NP -> VS -> Slash -> Slash; -- (whom) I think he sees + +-- Examples for English $S$/$Cl$: +{- + Pres Simul Pos ODir : he sleeps + Pres Simul Neg ODir : he doesn't sleep + Pres Anter Pos ODir : he has slept + Pres Anter Neg ODir : he hasn't slept + Past Simul Pos ODir : he slept + Past Simul Neg ODir : he didn't sleep + Past Anter Pos ODir : he had slept + Past Anter Neg ODir : he hadn't slept + Fut Simul Pos ODir : he will sleep + Fut Simul Neg ODir : he won't sleep + Fut Anter Pos ODir : he will have slept + Fut Anter Neg ODir : he won't have slept + Cond Simul Pos ODir : he would sleep + Cond Simul Neg ODir : he wouldn't sleep + Cond Anter Pos ODir : he would have slept + Cond Anter Neg ODir : he wouldn't have slept +-} diff --git a/lib/resource/exper/abstract/Structural.gf b/lib/resource/exper/abstract/Structural.gf new file mode 100644 index 000000000..511416346 --- /dev/null +++ b/lib/resource/exper/abstract/Structural.gf @@ -0,0 +1,112 @@ +--1 Structural: Structural Words +-- +-- Here we have some words belonging to closed classes and appearing +-- in all languages we have considered. +-- Sometimes more distinctions are needed, e.g. $we_Pron$ in Spanish +-- should be replaced by masculine and feminine variants, found in +-- [``ExtraSpa`` ../spanish/ExtraSpa.gf]. + +abstract Structural = Cat ** { + + fun + +-- This is an alphabetical list of structural words + + above_Prep : Prep ; + after_Prep : Prep ; + all_Predet : Predet ; + almost_AdA : AdA ; + almost_AdN : AdN ; + although_Subj : Subj ; + always_AdV : AdV ; + and_Conj : Conj ; + because_Subj : Subj ; + before_Prep : Prep ; + behind_Prep : Prep ; + between_Prep : Prep ; + both7and_DConj : DConj ; + but_PConj : PConj ; + by8agent_Prep : Prep ; + by8means_Prep : Prep ; + can8know_VV : VV ; + can_VV : VV ; + during_Prep : Prep ; + either7or_DConj : DConj ; + every_Det : Det ; + everybody_NP : NP ; + everything_NP : NP ; + everywhere_Adv : Adv ; +--- first_Ord : Ord ; DEPRECATED + few_Det : Det ; + for_Prep : Prep ; + from_Prep : Prep ; + he_Pron : Pron ; + here_Adv : Adv ; + here7to_Adv : Adv ; + here7from_Adv : Adv ; + how_IAdv : IAdv ; + how8many_IDet : IDet ; + i_Pron : Pron ; + if_Subj : Subj ; + in8front_Prep : Prep ; + in_Prep : Prep ; + it_Pron : Pron ; + less_CAdv : CAdv ; + many_Det : Det ; + more_CAdv : CAdv ; + most_Predet : Predet ; + much_Det : Det ; + must_VV : VV ; + no_Phr : Phr ; + on_Prep : Prep ; +--- one_Quant : QuantSg ; DEPRECATED + only_Predet : Predet ; + or_Conj : Conj ; + otherwise_PConj : PConj ; + part_Prep : Prep ; + please_Voc : Voc ; + possess_Prep : Prep ; + quite_Adv : AdA ; + she_Pron : Pron ; + so_AdA : AdA ; + someSg_Det : Det ; + somePl_Det : Det ; + somebody_NP : NP ; + something_NP : NP ; + somewhere_Adv : Adv ; + that_Quant : Quant ; + that_NP : NP ; + there_Adv : Adv ; + there7to_Adv : Adv ; + there7from_Adv : Adv ; + therefore_PConj : PConj ; + these_NP : NP ; + they_Pron : Pron ; + this_Quant : Quant ; + this_NP : NP ; + those_NP : NP ; + through_Prep : Prep ; + to_Prep : Prep ; + too_AdA : AdA ; + under_Prep : Prep ; + very_AdA : AdA ; + want_VV : VV ; + we_Pron : Pron ; + whatPl_IP : IP ; + whatSg_IP : IP ; + when_IAdv : IAdv ; + when_Subj : Subj ; + where_IAdv : IAdv ; + whichPl_IDet : IDet ; + whichSg_IDet : IDet ; + whoPl_IP : IP ; + whoSg_IP : IP ; + why_IAdv : IAdv ; + with_Prep : Prep ; + without_Prep : Prep ; + yes_Phr : Phr ; + youSg_Pron : Pron ; + youPl_Pron : Pron ; + youPol_Pron : Pron ; + +} diff --git a/lib/resource/exper/abstract/Text.gf b/lib/resource/exper/abstract/Text.gf new file mode 100644 index 000000000..ee4056a42 --- /dev/null +++ b/lib/resource/exper/abstract/Text.gf @@ -0,0 +1,15 @@ +--1 Text: Texts + +-- Texts are built from an empty text by adding $Phr$ases, +-- using as constructors the punctuation marks ".", "?", and "!". +-- Any punctuation mark can be attached to any kind of phrase. + +abstract Text = Common ** { + + fun + TEmpty : Text ; -- + TFullStop : Phr -> Text -> Text ; -- John walks. ... + TQuestMark : Phr -> Text -> Text ; -- Are you OK? ... + TExclMark : Phr -> Text -> Text ; -- John walks! ... + +} diff --git a/lib/resource/exper/abstract/Verb.gf b/lib/resource/exper/abstract/Verb.gf new file mode 100644 index 000000000..6ba7ae089 --- /dev/null +++ b/lib/resource/exper/abstract/Verb.gf @@ -0,0 +1,89 @@ +--1 The construction of verb phrases + +abstract Verb = Cat ** { + +--2 Complementization rules + +-- Verb phrases are constructed from verbs by providing their +-- complements. There is one rule for each verb category. + + fun + UseV : V -> VP ; -- sleep + + ComplVV : VV -> VP -> VP ; -- want to run + ComplVS : VS -> S -> VP ; -- know that she runs + ComplVQ : VQ -> QS -> VP ; -- wonder if she runs + ComplVA : VA -> AP -> VP ; -- look red + + SlashV2a : V2 -> VPSlash ; -- use (it) + Slash2V3 : V3 -> NP -> VPSlash ; -- send it (to her) + Slash3V3 : V3 -> NP -> VPSlash ; -- send (it) to her + + SlashV2V : V2V -> VP -> VPSlash ; -- cause (it) to burn + SlashV2S : V2S -> S -> VPSlash ; -- tell (me) that it rains + SlashV2Q : V2Q -> QS -> VPSlash ; -- ask (me) who came + SlashV2A : V2A -> AP -> VPSlash ; -- paint (it) red + + ComplSlash : VPSlash -> NP -> VP ; -- use it + + SlashVV : VV -> VPSlash -> VPSlash ; -- want to give her + SlashV2VNP : V2V -> NP -> VPSlash -> VPSlash ; -- want me to give her + +--2 Other ways of forming verb phrases + +-- Verb phrases can also be constructed reflexively and from +-- copula-preceded complements. + + ReflV2 : V2 -> VP ; -- use itself + UseComp : Comp -> VP ; -- be warm + +-- Passivization of two-place verbs is another way to use +-- them. In many languages, the result is a participle that +-- is used as complement to a copula ("is used"), but other +-- auxiliary verbs are possible (Ger. "wird angewendet", It. +-- "viene usato"), as well as special verb forms (Fin. "käytetään", +-- Swe. "används"). +-- +-- *Note*. the rule can be overgenerating, since the $V2$ need not +-- take a direct object. + + PassV2 : V2 -> VP ; -- be used + +-- Adverbs can be added to verb phrases. Many languages make +-- a distinction between adverbs that are attached in the end +-- vs. next to (or before) the verb. + + AdvVP : VP -> Adv -> VP ; -- sleep here + AdVVP : AdV -> VP -> VP ; -- always sleep + +-- *Agents of passives* are constructed as adverbs with the +-- preposition [Structural Structural.html]$.8agent_Prep$. + + +--2 Complements to copula + +-- Adjectival phrases, noun phrases, and adverbs can be used. + + CompAP : AP -> Comp ; -- (be) small + CompNP : NP -> Comp ; -- (be) a soldier + CompAdv : Adv -> Comp ; -- (be) here + +--2 Coercions + +-- Verbs can change subcategorization patterns in systematic ways, +-- but this is very much language-dependent. The following two +-- work in all the languages we cover. + + UseVQ : VQ -> V2 ; -- ask (a question) + UseVS : VS -> V2 ; -- know (a secret) + +--- Obsolete + + ComplV2 : V2 -> NP -> VP ; -- use it + ComplV3 : V3 -> NP -> NP -> VP ; -- send a message to her + ComplV2V : V2V -> NP -> VP -> VP ; -- cause it to burn + ComplV2S : V2S -> NP -> S -> VP ; -- tell me that it rains + ComplV2Q : V2Q -> NP -> QS -> VP ; -- ask me who came + ComplV2A : V2A -> NP -> AP -> VP ; -- paint it red + +} diff --git a/lib/resource/exper/english/AdjectiveEng.gf b/lib/resource/exper/english/AdjectiveEng.gf new file mode 100644 index 000000000..19dd5dddc --- /dev/null +++ b/lib/resource/exper/english/AdjectiveEng.gf @@ -0,0 +1,38 @@ +concrete AdjectiveEng of Adjective = CatEng ** open ResEng, Prelude in { + + lin + + PositA a = { + s = \\_ => a.s ! AAdj Posit ; + isPre = True + } ; + ComparA a np = { + s = \\_ => a.s ! AAdj Compar ++ "than" ++ np.s ! Nom ; + isPre = False + } ; + +-- $SuperlA$ belongs to determiner syntax in $Noun$. + + ComplA2 a np = { + s = \\_ => a.s ! AAdj Posit ++ a.c2 ++ np.s ! Acc ; + isPre = False + } ; + + ReflA2 a = { + s = \\ag => a.s ! AAdj Posit ++ a.c2 ++ reflPron ! ag ; + isPre = False + } ; + + SentAP ap sc = { + s = \\a => ap.s ! a ++ sc.s ; + isPre = False + } ; + + AdAP ada ap = { + s = \\a => ada.s ++ ap.s ! a ; + isPre = ap.isPre + } ; + + UseA2 a = a ; + +} diff --git a/lib/resource/exper/english/AdverbEng.gf b/lib/resource/exper/english/AdverbEng.gf new file mode 100644 index 000000000..5f6d01940 --- /dev/null +++ b/lib/resource/exper/english/AdverbEng.gf @@ -0,0 +1,21 @@ +concrete AdverbEng of Adverb = CatEng ** open ResEng, Prelude in { + + lin + PositAdvAdj a = {s = a.s ! AAdv} ; + ComparAdvAdj cadv a np = { + s = cadv.s ++ a.s ! AAdv ++ "than" ++ np.s ! Nom + } ; + ComparAdvAdjS cadv a s = { + s = cadv.s ++ a.s ! AAdv ++ "than" ++ s.s + } ; + + PrepNP prep np = {s = prep.s ++ np.s ! Acc} ; + + AdAdv = cc2 ; + + SubjS = cc2 ; + AdvSC s = s ; --- this rule give stack overflow in ordinary parsing + + AdnCAdv cadv = {s = cadv.s ++ "than"} ; + +} diff --git a/lib/resource/exper/english/CatEng.gf b/lib/resource/exper/english/CatEng.gf new file mode 100644 index 000000000..afceff993 --- /dev/null +++ b/lib/resource/exper/english/CatEng.gf @@ -0,0 +1,82 @@ +concrete CatEng of Cat = CommonX ** open ResEng, Prelude in { + + flags optimize=all_subs ; + + lincat + +-- Tensed/Untensed + + S = {s : Str} ; + QS = {s : QForm => Str} ; + RS = {s : Agr => Str ; c : Case} ; -- c for it clefts + SSlash = {s : Str ; c2 : Str} ; + +-- Sentence + + Cl = {s : ResEng.Tense => Anteriority => CPolarity => Order => Str} ; + Slash = { + s : ResEng.Tense => Anteriority => CPolarity => Order => Str ; + c2 : Str + } ; + Imp = {s : CPolarity => ImpForm => Str} ; + +-- Question + + QCl = {s : ResEng.Tense => Anteriority => CPolarity => QForm => Str} ; + IP = {s : Case => Str ; n : Number} ; + IComp = {s : Str} ; + IDet = {s : Str ; n : Number} ; + +-- Relative + + RCl = {s : ResEng.Tense => Anteriority => CPolarity => Agr => Str ; c : Case} ; + RP = {s : RCase => Str ; a : RAgr} ; + +-- Verb + + VP = ResEng.VP ; + VPSlash = ResEng.VP ** {c2 : Str} ; + Comp = {s : Agr => Str} ; + +-- Adjective + + AP = {s : Agr => Str ; isPre : Bool} ; + +-- Noun + + CN = {s : Number => Case => Str} ; + NP, Pron = {s : Case => Str ; a : Agr} ; + Det = {s : Str ; n : Number} ; + Predet, Ord = {s : Str} ; + Num = {s : Str; n : Number } ; + Quant = {s : Number => Str} ; + +-- Numeral + + Numeral = {s : CardOrd => Str ; n : Number} ; + Digits = {s : CardOrd => Str ; n : Number ; tail : DTail} ; + +-- Structural + + Conj = {s : Str ; n : Number} ; + DConj = {s1,s2 : Str ; n : Number} ; + Subj = {s : Str} ; + Prep = {s : Str} ; + +-- Open lexical classes, e.g. Lexicon + + V, VS, VQ, VA = Verb ; -- = {s : VForm => Str} ; + V2, V2A, V2Q, V2S = Verb ** {c2 : Str} ; + V3 = Verb ** {c2, c3 : Str} ; + VV = {s : VVForm => Str ; isAux : Bool} ; + V2V = Verb ** {c2 : Str ; isAux : Bool} ; + + A = {s : AForm => Str} ; + A2 = {s : AForm => Str ; c2 : Str} ; + + N = {s : Number => Case => Str} ; + N2 = {s : Number => Case => Str} ** {c2 : Str} ; + N3 = {s : Number => Case => Str} ** {c2,c3 : Str} ; + PN = {s : Case => Str} ; + +} diff --git a/lib/resource/exper/english/ConjunctionEng.gf b/lib/resource/exper/english/ConjunctionEng.gf new file mode 100644 index 000000000..0723b5abd --- /dev/null +++ b/lib/resource/exper/english/ConjunctionEng.gf @@ -0,0 +1,45 @@ +concrete ConjunctionEng of Conjunction = + CatEng ** open ResEng, Coordination, Prelude in { + + flags optimize=all_subs ; + + lin + + ConjS = conjunctSS ; + DConjS = conjunctDistrSS ; + + ConjAdv = conjunctSS ; + DConjAdv = conjunctDistrSS ; + + ConjNP conj ss = conjunctTable Case conj ss ** { + a = {n = conjNumber conj.n ss.a.n ; p = ss.a.p} + } ; + DConjNP conj ss = conjunctDistrTable Case conj ss ** { + a = {n = conjNumber conj.n ss.a.n ; p = ss.a.p} + } ; + + ConjAP conj ss = conjunctTable Agr conj ss ** { + isPre = ss.isPre + } ; + DConjAP conj ss = conjunctDistrTable Agr conj ss ** { + isPre = ss.isPre + } ; + +-- These fun's are generated from the list cat's. + + BaseS = twoSS ; + ConsS = consrSS comma ; + BaseAdv = twoSS ; + ConsAdv = consrSS comma ; + BaseNP x y = twoTable Case x y ** {a = conjAgr x.a y.a} ; + ConsNP xs x = consrTable Case comma xs x ** {a = conjAgr xs.a x.a} ; + BaseAP x y = twoTable Agr x y ** {isPre = andB x.isPre y.isPre} ; + ConsAP xs x = consrTable Agr comma xs x ** {isPre = andB xs.isPre x.isPre} ; + + lincat + [S] = {s1,s2 : Str} ; + [Adv] = {s1,s2 : Str} ; + [NP] = {s1,s2 : Case => Str ; a : Agr} ; + [AP] = {s1,s2 : Agr => Str ; isPre : Bool} ; + +} diff --git a/lib/resource/exper/english/English.gf b/lib/resource/exper/english/English.gf new file mode 100644 index 000000000..a117f34d3 --- /dev/null +++ b/lib/resource/exper/english/English.gf @@ -0,0 +1,9 @@ +--# -path=.:../abstract:../common:prelude + +concrete English of EnglishAbs = + LangEng, + IrregEng-[ + blow_V,burn_V,come_V,dig_V,fall_V,fly_V,freeze_V,go_V,lie_V,run_V, + sew_V,sing_V,sit_V,sleep_V,spit_V,stand_V,swell_V,swim_V,think_V], + ExtraEng + ** {} ; diff --git a/lib/resource/exper/english/EnglishAbs.gf b/lib/resource/exper/english/EnglishAbs.gf new file mode 100644 index 000000000..9498db96a --- /dev/null +++ b/lib/resource/exper/english/EnglishAbs.gf @@ -0,0 +1,9 @@ +--# -path=.:../abstract:../common:prelude + +abstract EnglishAbs = + Lang, + IrregEngAbs-[ + blow_V,burn_V,come_V,dig_V,fall_V,fly_V,freeze_V,go_V,lie_V,run_V, + sew_V,sing_V,sit_V,sleep_V,spit_V,stand_V,swell_V,swim_V,think_V], + ExtraEngAbs + ** {} ; diff --git a/lib/resource/exper/english/ExtraEng.gf b/lib/resource/exper/english/ExtraEng.gf new file mode 100644 index 000000000..a8904ec8e --- /dev/null +++ b/lib/resource/exper/english/ExtraEng.gf @@ -0,0 +1,52 @@ +concrete ExtraEng of ExtraEngAbs = CatEng ** + open ResEng, Coordination, Prelude in { + + lin + GenNP np = {s = \\_ => np.s ! Gen} ; + ComplBareVS v s = insertObj (\\_ => s.s) (predV v) ; + + StrandRelSlash rp slash = { + s = \\t,a,p,_ => rp.s ! RC Acc ++ slash.s ! t ! a ! p ! ODir ++ slash.c2 ; + c = Acc + } ; + EmptyRelSlash rp slash = { + s = \\t,a,p,_ => slash.s ! t ! a ! p ! ODir ++ slash.c2 ; + c = Acc + } ; + + StrandQuestSlash ip slash = + {s = \\t,a,b,q => + (mkQuestion (ss (ip.s ! Acc)) slash).s ! t ! a ! b ! q ++ slash.c2 + }; + + lincat + VPI = {s : VPIForm => Agr => Str} ; + [VPI] = {s1,s2 : VPIForm => Agr => Str} ; + + lin + BaseVPI = twoTable2 VPIForm Agr ; + ConsVPI = consrTable2 VPIForm Agr comma ; + + MkVPI vp = { + s = \\v,a => vp.ad ++ vp.inf ++ vp.s2 ! a + } ; + ConjVPI = conjunctTable2 VPIForm Agr ; + ComplVPIVV vv vpi = + insertObj (\\a => (if_then_Str vv.isAux [] "to") ++ vpi.s ! VPIInf ! a) (predVV vv) ; + + UncNegCl t a cl = {s = t.s ++ a.s ++ cl.s ! t.t ! a.a ! neg ! ODir} ; + UncNegQCl t a cl = {s = \\q => t.s ++ a.s ++ cl.s ! t.t ! a.a ! neg !q} ; + UncNegRCl t a cl = { + s = \\r => t.s ++ a.s ++ cl.s ! t.t ! a.a ! neg ! r ; + c = cl.c + } ; + UncNegImpSg imp = {s = imp.s ! neg ! ImpF Sg False} ; + UncNegImpPl imp = {s = imp.s ! neg ! ImpF Pl False} ; + + CompoundCN a b = {s = \\n,c => a.s ! Sg ! Nom ++ b.s ! n ! c} ; + + + oper + neg = CNeg False ; + +} diff --git a/lib/resource/exper/english/ExtraEngAbs.gf b/lib/resource/exper/english/ExtraEngAbs.gf new file mode 100644 index 000000000..9ee849627 --- /dev/null +++ b/lib/resource/exper/english/ExtraEngAbs.gf @@ -0,0 +1,16 @@ +abstract ExtraEngAbs = Extra ** { + +-- uncontracted negations; contracted are the default + fun + UncNegCl : Tense -> Ant -> Cl -> S ; + UncNegQCl : Tense -> Ant -> QCl -> QS ; + UncNegRCl : Tense -> Ant -> RCl -> RS ; + + UncNegImpSg : Imp -> Utt; -- do not help yourself + UncNegImpPl : Imp -> Utt; -- do not help yourselves + +-- freely compounded nouns + + CompoundCN : CN -> CN -> CN ; -- rock album + +} diff --git a/lib/resource/exper/english/GrammarEng.gf b/lib/resource/exper/english/GrammarEng.gf new file mode 100644 index 000000000..932dd9821 --- /dev/null +++ b/lib/resource/exper/english/GrammarEng.gf @@ -0,0 +1,21 @@ +--# -path=.:../abstract:../common:prelude + +concrete GrammarEng of Grammar = + NounEng, + VerbEng, + AdjectiveEng, + AdverbEng, + NumeralEng, + SentenceEng, + QuestionEng, + RelativeEng, + ConjunctionEng, + PhraseEng, + TextX, + StructuralEng, + IdiomEng + ** { + +flags startcat = Phr ; unlexer = text ; lexer = text ; + +} ; diff --git a/lib/resource/exper/english/IdiomEng.gf b/lib/resource/exper/english/IdiomEng.gf new file mode 100644 index 000000000..35ef4ba46 --- /dev/null +++ b/lib/resource/exper/english/IdiomEng.gf @@ -0,0 +1,30 @@ +concrete IdiomEng of Idiom = CatEng ** open Prelude, ResEng in { + + flags optimize=all_subs ; + + lin + ImpersCl vp = mkClause "it" (agrP3 Sg) vp ; + GenericCl vp = mkClause "one" (agrP3 Sg) vp ; + + CleftNP np rs = mkClause "it" (agrP3 Sg) + (insertObj (\\_ => rs.s ! np.a) + (insertObj (\\_ => np.s ! rs.c) (predAux auxBe))) ; + + CleftAdv ad s = mkClause "it" (agrP3 Sg) + (insertObj (\\_ => conjThat ++ s.s) + (insertObj (\\_ => ad.s) (predAux auxBe))) ; + + ExistNP np = + mkClause "there" (agrP3 np.a.n) + (insertObj (\\_ => np.s ! Acc) (predAux auxBe)) ; + + ExistIP ip = + mkQuestion (ss (ip.s ! Nom)) + (mkClause "there" (agrP3 ip.n) (predAux auxBe)) ; + + ProgrVP vp = insertObj (\\a => vp.ad ++ vp.prp ++ vp.s2 ! a) (predAux auxBe) ; + + ImpPl1 vp = {s = "let's" ++ infVP True vp {n = Pl ; p = P1}} ; + +} + diff --git a/lib/resource/exper/english/IrregEng.gf b/lib/resource/exper/english/IrregEng.gf new file mode 100644 index 000000000..2b90da1c4 --- /dev/null +++ b/lib/resource/exper/english/IrregEng.gf @@ -0,0 +1,181 @@ +--# -path=.:prelude:../abstract:../common + +concrete IrregEng of IrregEngAbs = CatEng ** open ParadigmsEng in { + +flags optimize=values ; + + lin + awake_V = irregV "awake" "awoke" "awoken" ; + bear_V = irregV "bear" "bore" "born" ; + beat_V = irregV "beat" "beat" "beat" ; + become_V = irregV "become" "became" "become" ; + begin_V = irregV "begin" "began" "begun" ; + bend_V = irregV "bend" "bent" "bent" ; + beset_V = irregV "beset" "beset" "beset" ; + bet_V = irregDuplV "bet" "bet" "bet" ; + bid_V = irregDuplV "bid" (variants {"bid" ; "bade"}) (variants {"bid" ; "bidden"}) ; + bind_V = irregV "bind" "bound" "bound" ; + bite_V = irregV "bite" "bit" "bitten" ; + bleed_V = irregV "bleed" "bled" "bled" ; + blow_V = irregV "blow" "blew" "blown" ; + break_V = irregV "break" "broke" "broken" ; + breed_V = irregV "breed" "bred" "bred" ; + bring_V = irregV "bring" "brought" "brought" ; + broadcast_V = irregV "broadcast" "broadcast" "broadcast" ; + build_V = irregV "build" "built" "built" ; + burn_V = irregV "burn" (variants {"burned" ; "burnt"}) (variants {"burned" ; "burnt"}) ; + burst_V = irregV "burst" "burst" "burst" ; + buy_V = irregV "buy" "bought" "bought" ; + cast_V = irregV "cast" "cast" "cast" ; + catch_V = irregV "catch" "caught" "caught" ; + choose_V = irregV "choose" "chose" "chosen" ; + cling_V = irregV "cling" "clung" "clung" ; + come_V = irregV "come" "came" "come" ; + cost_V = irregV "cost" "cost" "cost" ; + creep_V = irregV "creep" "crept" "crept" ; + cut_V = irregDuplV "cut" "cut" "cut" ; + deal_V = irregV "deal" "dealt" "dealt" ; + dig_V = irregDuplV "dig" "dug" "dug" ; + dive_V = irregV "dive" (variants {"dived" ; "dove"}) "dived" ; + do_V = mk5V "do" "does" "did" "done" "doing" ; + draw_V = irregV "draw" "drew" "drawn" ; + dream_V = irregV "dream" (variants {"dreamed" ; "dreamt"}) (variants {"dreamed" ; "dreamt"}) ; + drive_V = irregV "drive" "drove" "driven" ; + drink_V = irregV "drink" "drank" "drunk" ; + eat_V = irregV "eat" "ate" "eaten" ; + fall_V = irregV "fall" "fell" "fallen" ; + feed_V = irregV "feed" "fed" "fed" ; + feel_V = irregV "feel" "felt" "felt" ; + fight_V = irregV "fight" "fought" "fought" ; + find_V = irregV "find" "found" "found" ; + fit_V = irregDuplV "fit" "fit" "fit" ; + flee_V = irregV "flee" "fled" "fled" ; + fling_V = irregV "fling" "flung" "flung" ; + fly_V = irregV "fly" "flew" "flown" ; + forbid_V = irregDuplV "forbid" "forbade" "forbidden" ; + forget_V = irregDuplV "forget" "forgot" "forgotten" ; + forgive_V = irregV "forgive" "forgave" "forgiven" ; + forsake_V = irregV "forsake" "forsook" "forsaken" ; + freeze_V = irregV "freeze" "froze" "frozen" ; + get_V = irregDuplV "get" "got" "gotten" ; + give_V = irregV "give" "gave" "given" ; + go_V = mk5V "go" "goes" "went" "gone" "going" ; + grind_V = irregV "grind" "ground" "ground" ; + grow_V = irregV "grow" "grew" "grown" ; + hang_V = irregV "hang" "hung" "hung" ; + have_V = mk5V "have" "has" "had" "had" "having" ; + hear_V = irregV "hear" "heard" "heard" ; + hide_V = irregV "hide" "hid" "hidden" ; + hit_V = irregDuplV "hit" "hit" "hit" ; + hold_V = irregV "hold" "held" "held" ; + hurt_V = irregV "hurt" "hurt" "hurt" ; + keep_V = irregV "keep" "kept" "kept" ; + kneel_V = irregV "kneel" "knelt" "knelt" ; + knit_V = irregDuplV "knit" "knit" "knit" ; + know_V = irregV "know" "knew" "know" ; + lay_V = irregV "lay" "laid" "laid" ; + lead_V = irregV "lead" "led" "led" ; + leap_V = irregV "leap" (variants {"leaped" ; "lept"}) (variants {"leaped" ; "lept"}) ; + learn_V = irregV "learn" (variants {"learned" ; "learnt"}) (variants {"learned" ; "learnt"}) ; + leave_V = irregV "leave" "left" "left" ; + lend_V = irregV "lend" "lent" "lent" ; + let_V = irregDuplV "let" "let" "let" ; + lie_V = irregV "lie" "lay" "lain" ; + light_V = irregV "light" (variants {"lighted" ; "lit"}) "lighted" ; + lose_V = irregV "lose" "lost" "lost" ; + make_V = irregV "make" "made" "made" ; + mean_V = irregV "mean" "meant" "meant" ; + meet_V = irregV "meet" "met" "met" ; + misspell_V = irregV "misspell" (variants {"misspelled" ; "misspelt"}) (variants {"misspelled" ; "misspelt"}) ; + mistake_V = irregV "mistake" "mistook" "mistaken" ; + mow_V = irregV "mow" "mowed" (variants {"mowed" ; "mown"}) ; + overcome_V = irregV "overcome" "overcame" "overcome" ; + overdo_V = mk5V "overdo" "overdoes" "overdid" "overdone" "overdoing" ; + overtake_V = irregV "overtake" "overtook" "overtaken" ; + overthrow_V = irregV "overthrow" "overthrew" "overthrown" ; + pay_V = irregV "pay" "paid" "paid" ; + plead_V = irregV "plead" "pled" "pled" ; + prove_V = irregV "prove" "proved" (variants {"proved" ; "proven"}) ; + put_V = irregDuplV "put" "put" "put" ; + quit_V = irregDuplV "quit" "quit" "quit" ; + read_V = irregV "read" "read" "read" ; + rid_V = irregDuplV "rid" "rid" "rid" ; + ride_V = irregV "ride" "rode" "ridden" ; + ring_V = irregV "ring" "rang" "rung" ; + rise_V = irregV "rise" "rose" "risen" ; + run_V = irregDuplV "run" "ran" "run" ; + saw_V = irregV "saw" "sawed" (variants {"sawed" ; "sawn"}) ; + say_V = irregV "say" "said" "said" ; + see_V = irregV "see" "saw" "seen" ; + seek_V = irregV "seek" "sought" "sought" ; + sell_V = irregV "sell" "sold" "sold" ; + send_V = irregV "send" "sent" "sent" ; + set_V = irregDuplV "set" "set" "set" ; + sew_V = irregV "sew" "sewed" (variants {"sewed" ; "sewn"}) ; + shake_V = irregV "shake" "shook" "shaken" ; + shave_V = irregV "shave" "shaved" (variants {"shaved" ; "shaven"}) ; + shear_V = irregV "shear" "shore" "shorn" ; + shed_V = irregDuplV "shed" "shed" "shed" ; + shine_V = irregV "shine" "shone" "shone" ; + shoe_V = irregV "shoe" "shoed" (variants {"shoed" ; "shod"}) ; + shoot_V = irregV "shoot" "shot" "shot" ; + show_V = irregV "show" "showed" (variants {"showed" ; "shown"}) ; + shrink_V = irregV "shrink" "shrank" "shrunk" ; + shut_V = irregDuplV "shut" "shut" "shut" ; + sing_V = irregV "sing" "sang" "sung" ; + sink_V = irregV "sink" "sank" "sunk" ; + sit_V = irregDuplV "sit" "sat" "sat" ; + sleep_V = irregV "sleep" "slept" "slept" ; + slay_V = irregV "slay" "slew" "slain" ; + slide_V = irregV "slide" "slid" "slid" ; + sling_V = irregV "sling" "slung" "slung" ; + slit_V = irregDuplV "slit" "slit" "slit" ; + smite_V = irregV "smite" "smote" "smitten" ; + sow_V = irregV "sow" "sowed" (variants {"sowed" ; "sown"}) ; + speak_V = irregV "speak" "spoke" "spoken" ; + speed_V = irregV "speed" "sped" "sped" ; + spend_V = irregV "spend" "spent" "spent" ; + spill_V = irregV "spill" (variants {"spilled" ; "spilt"}) (variants {"spilled" ; "spilt"}) ; + spin_V = irregDuplV "spin" "spun" "spun" ; + spit_V = irregDuplV "spit" (variants {"spit" ; "spat"}) "spit" ; + split_V = irregDuplV "split" "split" "split" ; + spread_V = irregV "spread" "spread" "spread" ; + spring_V = irregV "spring" (variants {"sprang" ; "sprung"}) "sprung" ; + stand_V = irregV "stand" "stood" "stood" ; + steal_V = irregV "steal" "stole" "stolen" ; + stick_V = irregV "stick" "stuck" "stuck" ; + sting_V = irregV "sting" "stung" "stung" ; + stink_V = irregV "stink" "stank" "stunk" ; + stride_V = irregV "stride" "strod" "stridden" ; + strike_V = irregV "strike" "struck" "struck" ; + string_V = irregV "string" "strung" "strung" ; + strive_V = irregV "strive" "strove" "striven" ; + swear_V = irregV "swear" "swore" "sworn" ; + sweep_V = irregV "sweep" "swept" "swept" ; + swell_V = irregV "swell" "swelled" (variants {"swelled" ; "swollen"}) ; + swim_V = irregDuplV "swim" "swam" "swum" ; + swing_V = irregV "swing" "swung" "swung" ; + take_V = irregV "take" "took" "taken" ; + teach_V = irregV "teach" "taught" "taught" ; + tear_V = irregV "tear" "tore" "torn" ; + tell_V = irregV "tell" "told" "told" ; + think_V = irregV "think" "thought" "thought" ; + thrive_V = irregV "thrive" (variants {"thrived" ; "throve"}) "thrived" ; + throw_V = irregV "throw" "threw" "thrown" ; + thrust_V = irregV "thrust" "thrust" "thrust" ; + tread_V = irregV "tread" "trod" "trodden" ; + understand_V = irregV "understand" "understood" "understood" ; + uphold_V = irregV "uphold" "upheld" "upheld" ; + upset_V = irregDuplV "upset" "upset" "upset" ; + wake_V = irregV "wake" "woke" "woken" ; + wear_V = irregV "wear" "wore" "worn" ; + weave_V = irregV "weave" (variants {"weaved" ; "wove"}) (variants {"weaved" ; "woven"}) ; + wed_V = irregDuplV "wed" "wed" "wed" ; + weep_V = irregV "weep" "wept" "wept" ; + wind_V = irregV "wind" "wound" "wound" ; + win_V = irregDuplV "win" "won" "won" ; + withhold_V = irregV "withhold" "withheld" "withheld" ; + withstand_V = irregV "withstand" "withstood" "withstood" ; + wring_V = irregV "wring" "wrung" "wrung" ; + write_V = irregV "write" "wrote" "written" ; +} diff --git a/lib/resource/exper/english/IrregEngAbs.gf b/lib/resource/exper/english/IrregEngAbs.gf new file mode 100644 index 000000000..103fe3278 --- /dev/null +++ b/lib/resource/exper/english/IrregEngAbs.gf @@ -0,0 +1,176 @@ +abstract IrregEngAbs = Cat ** { +fun + awake_V : V ; + bear_V : V ; + beat_V : V ; + become_V : V ; + begin_V : V ; + bend_V : V ; + beset_V : V ; + bet_V : V ; + bid_V : V ; + bind_V : V ; + bite_V : V ; + bleed_V : V ; + blow_V : V ; + break_V : V ; + breed_V : V ; + bring_V : V ; + broadcast_V : V ; + build_V : V ; + burn_V : V ; + burst_V : V ; + buy_V : V ; + cast_V : V ; + catch_V : V ; + choose_V : V ; + cling_V : V ; + come_V : V ; + cost_V : V ; + creep_V : V ; + cut_V : V ; + deal_V : V ; + dig_V : V ; + dive_V : V ; + do_V : V ; + draw_V : V ; + dream_V : V ; + drive_V : V ; + drink_V : V ; + eat_V : V ; + fall_V : V ; + feed_V : V ; + feel_V : V ; + fight_V : V ; + find_V : V ; + fit_V : V ; + flee_V : V ; + fling_V : V ; + fly_V : V ; + forbid_V : V ; + forget_V : V ; + forgive_V : V ; + forsake_V : V ; + freeze_V : V ; + get_V : V ; + give_V : V ; + go_V : V ; + grind_V : V ; + grow_V : V ; + hang_V : V ; + have_V : V ; + hear_V : V ; + hide_V : V ; + hit_V : V ; + hold_V : V ; + hurt_V : V ; + keep_V : V ; + kneel_V : V ; + knit_V : V ; + know_V : V ; + lay_V : V ; + lead_V : V ; + leap_V : V ; + learn_V : V ; + leave_V : V ; + lend_V : V ; + let_V : V ; + lie_V : V ; + light_V : V ; + lose_V : V ; + make_V : V ; + mean_V : V ; + meet_V : V ; + misspell_V : V ; + mistake_V : V ; + mow_V : V ; + overcome_V : V ; + overdo_V : V ; + overtake_V : V ; + overthrow_V : V ; + pay_V : V ; + plead_V : V ; + prove_V : V ; + put_V : V ; + quit_V : V ; + read_V : V ; + rid_V : V ; + ride_V : V ; + ring_V : V ; + rise_V : V ; + run_V : V ; + saw_V : V ; + say_V : V ; + see_V : V ; + seek_V : V ; + sell_V : V ; + send_V : V ; + set_V : V ; + sew_V : V ; + shake_V : V ; + shave_V : V ; + shear_V : V ; + shed_V : V ; + shine_V : V ; + shoe_V : V ; + shoot_V : V ; + show_V : V ; + shrink_V : V ; + shut_V : V ; + sing_V : V ; + sink_V : V ; + sit_V : V ; + sleep_V : V ; + slay_V : V ; + slide_V : V ; + sling_V : V ; + slit_V : V ; + smite_V : V ; + sow_V : V ; + speak_V : V ; + speed_V : V ; + spend_V : V ; + spill_V : V ; + spin_V : V ; + spit_V : V ; + split_V : V ; + spread_V : V ; + spring_V : V ; + stand_V : V ; + steal_V : V ; + stick_V : V ; + sting_V : V ; + stink_V : V ; + stride_V : V ; + strike_V : V ; + string_V : V ; + strive_V : V ; + swear_V : V ; + sweep_V : V ; + swell_V : V ; + swim_V : V ; + swing_V : V ; + take_V : V ; + teach_V : V ; + tear_V : V ; + tell_V : V ; + think_V : V ; + thrive_V : V ; + throw_V : V ; + thrust_V : V ; + tread_V : V ; + understand_V : V ; + uphold_V : V ; + upset_V : V ; + wake_V : V ; + wear_V : V ; + weave_V : V ; + wed_V : V ; + weep_V : V ; + wind_V : V ; + win_V : V ; + withhold_V : V ; + withstand_V : V ; + wring_V : V ; + write_V : V ; +} diff --git a/lib/resource/exper/english/LangEng.gf b/lib/resource/exper/english/LangEng.gf new file mode 100644 index 000000000..a38cd12ac --- /dev/null +++ b/lib/resource/exper/english/LangEng.gf @@ -0,0 +1,10 @@ +--# -path=.:abstract:../common:prelude + +concrete LangEng of Lang = + GrammarEng, + LexiconEng + ** { + +flags startcat = Phr ; unlexer = text ; lexer = text ; + +} ; diff --git a/lib/resource/exper/english/LexiconEng.gf b/lib/resource/exper/english/LexiconEng.gf new file mode 100644 index 000000000..eee1f4eee --- /dev/null +++ b/lib/resource/exper/english/LexiconEng.gf @@ -0,0 +1,375 @@ +--# -path=.:prelude + +concrete LexiconEng of Lexicon = CatEng ** + open ParadigmsEng, IrregEng, Prelude in { + +flags + optimize=values ; + +lin + airplane_N = regN "airplane" ; + answer_V2S = mkV2S (regV "answer") toP ; + apartment_N = regN "apartment" ; + apple_N = regN "apple" ; + art_N = regN "art" ; + ask_V2Q = mkV2Q (regV "ask") noPrep ; + baby_N = regN "baby" ; + bad_A = mkADeg "bad" "worse" "worst" "badly" ; + bank_N = regN "bank" ; + beautiful_A = compoundADeg (regA "beautiful") ; + become_VA = mkVA (irregV "become" "became" "become") ; + beer_N = regN "beer" ; + beg_V2V = mkV2V (regDuplV "beg") noPrep toP ; + big_A = duplADeg "big" ; + bike_N = regN "bike" ; + bird_N = regN "bird" ; + black_A = regADeg "black" ; + blue_A = regADeg "blue" ; + boat_N = regN "boat" ; + book_N = regN "book" ; + boot_N = regN "boot" ; + boss_N = regN "boss" ; + boy_N = regN "boy" ; + bread_N = regN "bread" ; + break_V2 = dirV2 (irregV "break" "broke" "broken") ; + broad_A = regADeg "broad" ; + brother_N2 = regN2 "brother" ; + brown_A = regADeg "brown" ; + butter_N = regN "butter" ; + buy_V2 = dirV2 (irregV "buy" "bought" "bought") ; + camera_N = regN "camera" ; + cap_N = regN "cap" ; + car_N = regN "car" ; + carpet_N = regN "carpet" ; + cat_N = regN "cat" ; + ceiling_N = regN "ceiling" ; + chair_N = regN "chair" ; + cheese_N = regN "cheese" ; + child_N = mk2N "child" "children" ; + church_N = regN "church" ; + city_N = regN "city" ; + clean_A = regADeg "clean" ; + clever_A = regADeg "clever" ; + close_V2 = dirV2 (regV "close") ; + coat_N = regN "coat" ; + cold_A = regADeg "cold" ; + come_V = (irregV "come" "came" "come") ; + computer_N = regN "computer" ; + country_N = regN "country" ; + cousin_N = regN "cousin" ; + cow_N = regN "cow" ; + die_V = (regV "die") ; + dirty_A = regADeg "dirty" ; + distance_N3 = mkN3 (regN "distance") fromP toP ; + doctor_N = regN "doctor" ; + dog_N = regN "dog" ; + door_N = regN "door" ; + drink_V2 = dirV2 (irregV "drink" "drank" "drunk") ; + easy_A2V = mkA2V (regA "easy") forP ; + eat_V2 = dirV2 (irregV "eat" "ate" "eaten") ; + empty_A = regADeg "empty" ; + enemy_N = regN "enemy" ; + factory_N = regN "factory" ; + father_N2 = regN2 "father" ; + fear_VS = mkVS (regV "fear") ; + find_V2 = dirV2 (irregV "find" "found" "found") ; + fish_N = mk2N "fish" "fish" ; + floor_N = regN "floor" ; + forget_V2 = dirV2 (irregDuplV "forget" "forgot" "forgotten") ; + fridge_N = regN "fridge" ; + friend_N = regN "friend" ; + fruit_N = regN "fruit" ; + fun_AV = mkAV (regA "fun") ; + garden_N = regN "garden" ; + girl_N = regN "girl" ; + glove_N = regN "glove" ; + gold_N = regN "gold" ; + good_A = mkADeg "good" "better" "best" "well" ; + go_V = mk5V "go" "goes" "went" "gone" "going" ; + green_A = regADeg "green" ; + harbour_N = regN "harbour" ; + hate_V2 = dirV2 (regV "hate") ; + hat_N = regN "hat" ; + have_V2 = dirV2 (mk5V "have" "has" "had" "had" "having") ; + hear_V2 = dirV2 (irregV "hear" "heard" "heard") ; + hill_N = regN "hill" ; + hope_VS = mkVS (regV "hope") ; + horse_N = regN "horse" ; + hot_A = duplADeg "hot" ; + house_N = regN "house" ; + important_A = compoundADeg (regA "important") ; + industry_N = regN "industry" ; + iron_N = regN "iron" ; + king_N = regN "king" ; + know_V2 = dirV2 (irregV "know" "knew" "known") ; + lake_N = regN "lake" ; + lamp_N = regN "lamp" ; + learn_V2 = dirV2 (regV "learn") ; + leather_N = regN "leather" ; + leave_V2 = dirV2 (irregV "leave" "left" "left") ; + like_V2 = dirV2 (regV "like") ; + listen_V2 = prepV2 (regV "listen") toP ; + live_V = (regV "live") ; + long_A = regADeg "long" ; + lose_V2 = dirV2 (irregV "lose" "lost" "lost") ; + love_N = regN "love" ; + love_V2 = dirV2 (regV "love") ; + man_N = mk2N "man" "men" ; + married_A2 = mkA2 (regA "married") toP ; + meat_N = regN "meat" ; + milk_N = regN "milk" ; + moon_N = regN "moon" ; + mother_N2 = regN2 "mother" ; + mountain_N = regN "mountain" ; + music_N = regN "music" ; + narrow_A = regADeg "narrow" ; + new_A = regADeg "new" ; + newspaper_N = regN "newspaper" ; + oil_N = regN "oil" ; + old_A = regADeg "old" ; + open_V2 = dirV2 (regV "open") ; + paint_V2A = mkV2A (regV "paint") noPrep ; + paper_N = regN "paper" ; + paris_PN = regPN "Paris" ; + peace_N = regN "peace" ; + pen_N = regN "pen" ; + planet_N = regN "planet" ; + plastic_N = regN "plastic" ; + play_V2 = dirV2 (regV "play") ; + policeman_N = regN "policeman" ; + priest_N = regN "priest" ; + probable_AS = mkAS (regA "probable") ; + queen_N = regN "queen" ; + radio_N = regN "radio" ; + rain_V0 = mkV0 (regV "rain") ; + read_V2 = dirV2 (irregV "read" "read" "read") ; + red_A = duplADeg "red" ; + religion_N = regN "religion" ; + restaurant_N = regN "restaurant" ; + river_N = regN "river" ; + rock_N = regN "rock" ; + roof_N = regN "roof" ; + rubber_N = regN "rubber" ; + run_V = (irregDuplV "run" "ran" "run") ; + say_VS = mkVS (irregV "say" "said" "said") ; + school_N = regN "school" ; + science_N = regN "science" ; + sea_N = regN "sea" ; + seek_V2 = dirV2 (irregV "seek" "sought" "sought") ; + see_V2 = dirV2 (irregV "see" "saw" "seen") ; + sell_V3 = dirV3 (irregV "sell" "sold" "sold") toP ; + send_V3 = dirV3 (irregV "send" "sent" "sent") toP ; + sheep_N = mk2N "sheep" "sheep" ; + ship_N = regN "ship" ; + shirt_N = regN "shirt" ; + shoe_N = regN "shoe" ; + shop_N = regN "shop" ; + short_A = regADeg "short" ; + silver_N = regN "silver" ; + sister_N = regN "sister" ; + sleep_V = (irregV "sleep" "slept" "slept") ; + small_A = regADeg "small" ; + snake_N = regN "snake" ; + sock_N = regN "sock" ; + speak_V2 = dirV2 (irregV "speak" "spoke" "spoken") ; + star_N = regN "star" ; + steel_N = regN "steel" ; + stone_N = regN "stone" ; + stove_N = regN "stove" ; + student_N = regN "student" ; + stupid_A = regADeg "stupid" ; + sun_N = regN "sun" ; + switch8off_V2 = dirV2 (partV (regV "switch") "off") ; + switch8on_V2 = dirV2 (partV (regV "switch") "on") ; + table_N = regN "table" ; + talk_V3 = mkV3 (regV "talk") toP aboutP ; + teacher_N = regN "teacher" ; + teach_V2 = dirV2 (irregV "teach" "taught" "taught") ; + television_N = regN "television" ; + thick_A = regADeg "thick" ; + thin_A = duplADeg "thin" ; + train_N = regN "train" ; + travel_V = (regDuplV "travel") ; + tree_N = regN "tree" ; + ---- trousers_N = regN "trousers" ; + ugly_A = regADeg "ugly" ; + understand_V2 = dirV2 (irregV "understand" "understood" "understood") ; + university_N = regN "university" ; + village_N = regN "village" ; + wait_V2 = prepV2 (regV "wait") forP ; + walk_V = (regV "walk") ; + warm_A = regADeg "warm" ; + war_N = regN "war" ; + watch_V2 = dirV2 (regV "watch") ; + water_N = regN "water" ; + white_A = regADeg "white" ; + window_N = regN "window" ; + wine_N = regN "wine" ; + win_V2 = dirV2 (irregDuplV "win" "won" "won") ; + woman_N = mk2N "woman" "women" ; + wonder_VQ = mkVQ (regV "wonder") ; + wood_N = regN "wood" ; + write_V2 = dirV2 (irregV "write" "wrote" "written") ; + yellow_A = regADeg "yellow" ; + young_A = regADeg "young" ; + + do_V2 = dirV2 (mk5V "do" "does" "did" "done" "doing") ; + now_Adv = mkAdv "now" ; + already_Adv = mkAdv "already" ; + song_N = regN "song" ; + add_V3 = dirV3 (regV "add") toP ; + number_N = regN "number" ; + put_V2 = prepV2 (irregDuplV "put" "put" "put") noPrep ; + stop_V = regDuplV "stop" ; + jump_V = regV "jump" ; + + left_Ord = ss "left" ; + right_Ord = ss "right" ; + far_Adv = mkAdv "far" ; + correct_A = (regA "correct") ; + dry_A = regA "dry" ; + dull_A = regA "dull" ; + full_A = regA "full" ; + heavy_A = regA "heavy" ; + near_A = regA "near" ; + rotten_A = (regA "rotten") ; + round_A = regA "round" ; + sharp_A = regA "sharp" ; + smooth_A = regA "smooth" ; + straight_A = regA "straight" ; + wet_A = regA "wet" ; ---- + wide_A = regA "wide" ; + animal_N = regN "animal" ; + ashes_N = regN "ash" ; -- FIXME: plural only? + back_N = regN "back" ; + bark_N = regN "bark" ; + belly_N = regN "belly" ; + blood_N = regN "blood" ; + bone_N = regN "bone" ; + breast_N = regN "breast" ; + cloud_N = regN "cloud" ; + day_N = regN "day" ; + dust_N = regN "dust" ; + ear_N = regN "ear" ; + earth_N = regN "earth" ; + egg_N = regN "egg" ; + eye_N = regN "eye" ; + fat_N = regN "fat" ; + feather_N = regN "feather" ; + fingernail_N = regN "fingernail" ; + fire_N = regN "fire" ; + flower_N = regN "flower" ; + fog_N = regN "fog" ; + foot_N = mk2N "foot" "feet" ; + forest_N = regN "forest" ; + grass_N = regN "grass" ; + guts_N = regN "gut" ; -- FIXME: no singular + hair_N = regN "hair" ; + hand_N = regN "hand" ; + head_N = regN "head" ; + heart_N = regN "heart" ; + horn_N = regN "horn" ; + husband_N = genderN masculine (regN "husband") ; + ice_N = regN "ice" ; + knee_N = regN "knee" ; + leaf_N = mk2N "leaf" "leaves" ; + leg_N = regN "leg" ; + liver_N = regN "liver" ; + louse_N = mk2N "louse" "lice" ; + mouth_N = regN "mouth" ; + name_N = regN "name" ; + neck_N = regN "neck" ; + night_N = regN "night" ; + nose_N = regN "nose" ; + person_N = genderN human (regN "person") ; + rain_N = regN "rain" ; + road_N = regN "road" ; + root_N = regN "root" ; + rope_N = regN "rope" ; + salt_N = regN "salt" ; + sand_N = regN "sand" ; + seed_N = regN "seed" ; + skin_N = regN "skin" ; + sky_N = regN "sky" ; + smoke_N = regN "smoke" ; + snow_N = regN "snow" ; + stick_N = regN "stick" ; + tail_N = regN "tail" ; + tongue_N = regN "tongue" ; + tooth_N = mk2N "tooth" "teeth" ; + wife_N = genderN feminine (mk2N "wife" "wives") ; + wind_N = regN "wind" ; + wing_N = regN "wing" ; + worm_N = regN "worm" ; + year_N = regN "year" ; + blow_V = IrregEng.blow_V ; + breathe_V = dirV2 (regV "breathe") ; + burn_V = IrregEng.burn_V ; + dig_V = IrregEng.dig_V ; + fall_V = IrregEng.fall_V ; + float_V = regV "float" ; + flow_V = regV "flow" ; + fly_V = IrregEng.fly_V ; + freeze_V = IrregEng.freeze_V ; + give_V3 = dirV3 give_V toP ; + laugh_V = regV "laugh" ; + lie_V = IrregEng.lie_V ; + play_V = regV "play" ; + sew_V = IrregEng.sew_V ; + sing_V = IrregEng.sing_V ; + sit_V = IrregEng.sit_V ; + smell_V = regV "smell" ; + spit_V = IrregEng.spit_V ; + stand_V = IrregEng.stand_V ; + swell_V = IrregEng.swell_V ; + swim_V = IrregEng.swim_V ; + think_V = IrregEng.think_V ; + turn_V = regV "turn" ; + vomit_V = regV "vomit" ; + + bite_V2 = dirV2 IrregEng.bite_V ; + count_V2 = dirV2 (regV "count") ; + cut_V2 = dirV2 IrregEng.cut_V ; + fear_V2 = dirV2 (regV "fear") ; + fight_V2 = dirV2 fight_V ; + hit_V2 = dirV2 hit_V ; + hold_V2 = dirV2 hold_V ; + hunt_V2 = dirV2 (regV "hunt") ; + kill_V2 = dirV2 (regV "kill") ; + pull_V2 = dirV2 (regV "pull") ; + push_V2 = dirV2 (regV "push") ; + rub_V2 = dirV2 (regDuplV "rub") ; + scratch_V2 = dirV2 (regV "scratch") ; + split_V2 = dirV2 split_V ; + squeeze_V2 = dirV2 (regV "squeeze") ; + stab_V2 = dirV2 (regDuplV "stab") ; + suck_V2 = dirV2 (regV "suck") ; + throw_V2 = dirV2 throw_V ; + tie_V2 = dirV2 (regV "tie") ; + wash_V2 = dirV2 (regV "wash") ; + wipe_V2 = dirV2 (regV "wipe") ; + +-- other_A = regA "other" ; + + grammar_N = regN "grammar" ; + language_N = regN "language" ; + rule_N = regN "rule" ; + +-- added 4/6/2007 + john_PN = regPN "John" ; + question_N = regN "question" ; + ready_A = regA "ready" ; + reason_N = regN "reason" ; + today_Adv = mkAdv "today" ; + uncertain_A = regA "uncertain" ; + +oper + aboutP = mkPrep "about" ; + atP = mkPrep "at" ; + forP = mkPrep "for" ; + fromP = mkPrep "from" ; + inP = mkPrep "in" ; + onP = mkPrep "on" ; + toP = mkPrep "to" ; + +} ; diff --git a/lib/resource/exper/english/MorphoEng.gf b/lib/resource/exper/english/MorphoEng.gf new file mode 100644 index 000000000..a45a2b82c --- /dev/null +++ b/lib/resource/exper/english/MorphoEng.gf @@ -0,0 +1,198 @@ +--# -path=.:../../prelude + +--1 A Simple English Resource Morphology +-- +-- Aarne Ranta 2002 -- 2005 +-- +-- This resource morphology contains definitions needed in the resource +-- syntax. To build a lexicon, it is better to use $ParadigmsEng$, which +-- gives a higher-level access to this module. + +resource MorphoEng = ResEng ** open Prelude, (Predef=Predef) in { + + flags optimize=all ; + +--2 Phonology +-- +-- To regulate the use of endings for both nouns, adjectives, and verbs: + +oper + y2ie : Str -> Str -> Str = \fly,s -> + let y = last (init fly) in + case y of { + "a" => fly + s ; + "e" => fly + s ; + "o" => fly + s ; + "u" => fly + s ; + _ => init fly + "ie" + s + } ; + + +--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 + CommonNoun : Type = {s : Number => Case => Str} ; + + nounGen : Str -> CommonNoun = \dog -> case last dog of { + "y" => nounY "dog" ; + "s" => nounS (init "dog") ; + _ => nounReg "dog" + } ; + +-- These are auxiliaries to $nounGen$. + + 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 -> Gender -> {s : Case => Str} = \john,g -> + {s = table {Gen => john + "'s" ; _ => john} ; g = g} ; + +--2 Determiners + + mkDeterminer : Number -> Str -> {s : Str ; n : Number} = \n,s -> + {s = s ; n = n} ; + +--2 Pronouns +-- +-- Here we define personal pronouns. +-- +-- We record the form "mine" and the gender for later use. + + Pronoun : Type = + {s : Case => Str ; a : Agr ; g : Gender} ; + + mkPronoun : (_,_,_,_ : Str) -> Number -> Person -> Gender -> Pronoun = + \I,me,my,mine,n,p,g -> + {s = table {Nom => I ; Acc => me ; Gen => my} ; + a = {n = n ; p = p} ; + g = g + } ; + + human : Gender = Masc ; --- doesn't matter + + pronI = mkPronoun "I" "me" "my" "mine" Sg P1 human ; + pronYouSg = mkPronoun "you" "you" "your" "yours" Sg P2 human ; -- verb agr OK + pronHe = mkPronoun "he" "him" "his" "his" Sg P3 Masc ; + pronShe = mkPronoun "she" "her" "her" "hers" Sg P3 Fem ; + pronIt = mkPronoun "it" "it" "its" "it" Sg P3 Neutr ; + + pronWe = mkPronoun "we" "us" "our" "ours" Pl P1 human ; + pronYouPl = mkPronoun "you" "you" "your" "yours" Pl P2 human ; + pronThey = mkPronoun "they" "them" "their" "theirs" Pl P3 human ; --- + + +--2 Adjectives +-- +-- To form the adjectival and the adverbial forms, two strings are needed +-- in the worst case. (First without degrees.) + + Adjective = {s : AForm => Str} ; + +-- However, most adjectives can be inflected using the final character. +-- N.B. this is not correct for "shy", but $mkAdjective$ has to be used. + + regAdjective : Str -> Adjective = \free -> + let + e = last free ; + fre = init free ; + freely = case e of { + "y" => fre + "ily" ; + _ => free + "ly" + } ; + fre = case e of { + "e" => fre ; + "y" => fre + "i" ; + _ => free + } + in + mkAdjective free (fre + "er") (fre + "est") freely ; + +-- Many adjectives are 'inflected' by adding a comparison word. + + adjDegrLong : Str -> Adjective = \ridiculous -> + mkAdjective + ridiculous + ("more" ++ ridiculous) + ("most" ++ ridiculous) + ((regAdjective ridiculous).s ! AAdv) ; + + +--3 Verbs +-- +-- The worst case needs five forms. (The verb "be" is treated separately.) + + mkVerb4 : (_,_,_,_: Str) -> Verb = \go,goes,went,gone -> + let going = case last go of { + "e" => init go + "ing" ; + _ => go + "ing" + } + in + mkVerb go goes went gone going ; + +-- This is what we use to derive the irregular forms in almost all cases + + mkVerbIrreg : (_,_,_ : Str) -> Verb = \bite,bit,bitten -> + let bites = case last bite of { + "y" => y2ie bite "s" ; + "s" => init bite + "es" ; + _ => bite + "s" + } + in mkVerb4 bite bites bit bitten ; + +-- This is used to derive regular forms. + + mkVerbReg : Str -> Verb = \soak -> + let + soaks = case last soak of { + "y" => y2ie soak "s" ; + "s" => init soak + "es" ; + _ => soak + "s" + } ; + soaked = case last soak of { + "e" => init soak + "s" ; + _ => soak + "ed" + } + in + mkVerb4 soak soaks soaked soaked ; + + verbGen : Str -> Verb = \kill -> case last kill of { + "y" => verbP3y (init kill) ; + "e" => verbP3e (init kill) ; + "s" => verbP3s (init kill) ; + _ => regVerbP3 kill + } ; + +-- These are just auxiliary to $verbGen$. + + regVerbP3 : Str -> Verb = \walk -> + mkVerbIrreg walk (walk + "ed") (walk + "ed") ; + verbP3s : Str -> Verb = \kiss -> + mkVerb4 kiss (kiss + "es") (kiss + "ed") (kiss + "ed") ; + verbP3e : Str -> Verb = \love -> + mkVerb4 love (love + "s") (love + "d") (love + "d") ; + verbP3y : Str -> Verb = \cr -> + mkVerb4 (cr + "y") (cr + "ies") (cr + "ied") (cr + "ied") ; + +--- The particle always appears right after the verb. + + verbPart : Verb -> Str -> Verb = \v,p -> + {s = \\f => v.s ! f ++ p ; isRefl = v.isRefl} ; + + verbNoPart : Verb -> Verb = \v -> verbPart v [] ; + + +} ; + diff --git a/lib/resource/exper/english/NounEng.gf b/lib/resource/exper/english/NounEng.gf new file mode 100644 index 000000000..c282c16b0 --- /dev/null +++ b/lib/resource/exper/english/NounEng.gf @@ -0,0 +1,94 @@ +concrete NounEng of Noun = CatEng ** open ResEng, Prelude in { + + flags optimize=all_subs ; + + lin + DetCN det cn = { + s = \\c => det.s ++ cn.s ! det.n ! c ; + a = agrP3 det.n + } ; + UsePN pn = pn ** {a = agrP3 Sg} ; + UsePron p = p ; + + PredetNP pred np = { + s = \\c => pred.s ++ np.s ! c ; + a = np.a + } ; + + PPartNP np v2 = { + s = \\c => np.s ! c ++ v2.s ! VPPart ; + a = np.a + } ; + + AdvNP np adv = { + s = \\c => np.s ! c ++ adv.s ; + a = np.a + } ; + + DetSg quant ord = { + s = quant.s ! Sg ++ ord.s ; + n = Sg + } ; + + DetPl quant num ord = { + s = quant.s ! num.n ++ num.s ++ ord.s ; + n = num.n + } ; + +--- SgQuant quant = {s = quant.s ! Sg} ; DEPRECATED +--- PlQuant quant = {s = quant.s ! Pl} ; + + PossPron p = {s = \\_ => p.s ! Gen} ; + + NoNum = {s = []; n = Pl } ; + NoOrd = {s = []} ; + + NumDigits n = {s = n.s ! NCard ; n = n.n} ; + + NumInt n = {s = n.s ; n = Pl} ; + --table (Predef.Ints 1 * Predef.Ints 9) { + -- <0,1> => Sg ; + -- _ => Pl -- DEPRECATED + -- } ! <1,2> ---- parser bug (AR 2/6/2007) + -- ---- + -- } ; + + OrdInt n = {s = n.s ++ "th"} ; --- DEPRECATED + OrdDigits n = {s = n.s ! NOrd} ; + + NumNumeral numeral = {s = numeral.s ! NCard; n = numeral.n} ; + OrdNumeral numeral = {s = numeral.s ! NOrd} ; + + AdNum adn num = {s = adn.s ++ num.s; n = num.n } ; + + OrdSuperl a = {s = a.s ! AAdj Superl} ; + + DefArt = {s = \\_ => artDef} ; + + IndefArt = { + s = table { + Sg => artIndef ; + Pl => [] + } + } ; + + MassDet = {s = \\_ => []} ; + + UseN n = n ; + UseN2 n = n ; + UseN3 n = n ; + + ComplN2 f x = {s = \\n,c => f.s ! n ! Nom ++ f.c2 ++ x.s ! c} ; + ComplN3 f x = {s = \\n,c => f.s ! n ! Nom ++ f.c2 ++ x.s ! c ; c2 = f.c3} ; + + AdjCN ap cn = { + s = \\n,c => preOrPost ap.isPre (ap.s ! agrP3 n) (cn.s ! n ! c) + } ; + RelCN cn rs = {s = \\n,c => cn.s ! n ! c ++ rs.s ! {n = n ; p = P3}} ; + AdvCN cn ad = {s = \\n,c => cn.s ! n ! c ++ ad.s} ; + + SentCN cn sc = {s = \\n,c => cn.s ! n ! c ++ sc.s} ; + + ApposCN cn np = {s = \\n,c => cn.s ! n ! Nom ++ np.s ! c} ; + +} diff --git a/lib/resource/exper/english/NumeralEng.gf b/lib/resource/exper/english/NumeralEng.gf new file mode 100644 index 000000000..2f7c8e553 --- /dev/null +++ b/lib/resource/exper/english/NumeralEng.gf @@ -0,0 +1,95 @@ +concrete NumeralEng of Numeral = CatEng ** open ResEng in { + +lincat + Digit = {s : DForm => CardOrd => Str} ; + Sub10 = {s : DForm => CardOrd => Str ; n : Number} ; + Sub100 = {s : CardOrd => Str ; n : Number} ; + Sub1000 = {s : CardOrd => Str ; n : Number} ; + Sub1000000 = {s : CardOrd => Str ; n : Number} ; + +lin num x = x ; +lin n2 = let two = mkNum "two" "twelve" "twenty" "second" in + {s = \\f,c => case of { + => "twelfth" ; + _ => two.s ! f ! c + } + } ; + +lin n3 = mkNum "three" "thirteen" "thirty" "third" ; +lin n4 = mkNum "four" "fourteen" "forty" "fourth" ; +lin n5 = mkNum "five" "fifteen" "fifty" "fifth" ; +lin n6 = regNum "six" ; +lin n7 = regNum "seven" ; +lin n8 = mkNum "eight" "eighteen" "eighty" "eighth" ; +lin n9 = mkNum "nine" "nineteen" "ninety" "ninth" ; + +lin pot01 = mkNum "one" "eleven" "ten" "first" ** {n = Sg} ; +lin pot0 d = d ** {n = Pl} ; +lin pot110 = regCardOrd "ten" ** {n = Pl} ; +lin pot111 = regCardOrd "eleven" ** {n = Pl} ; +lin pot1to19 d = {s = d.s ! teen} ** {n = Pl} ; +lin pot0as1 n = {s = n.s ! unit} ** {n = n.n} ; +lin pot1 d = {s = d.s ! ten} ** {n = Pl} ; +lin pot1plus d e = { + s = \\c => d.s ! ten ! NCard ++ "-" ++ e.s ! unit ! c ; n = Pl} ; +lin pot1as2 n = n ; +lin pot2 d = {s = \\c => d.s ! unit ! NCard ++ mkCard c "hundred"} ** {n = Pl} ; +lin pot2plus d e = { + s = \\c => d.s ! unit ! NCard ++ "hundred" ++ "and" ++ e.s ! c ; n = Pl} ; +lin pot2as3 n = n ; +lin pot3 n = { + s = \\c => n.s ! NCard ++ mkCard c "thousand" ; n = Pl} ; +lin pot3plus n m = { + s = \\c => n.s ! NCard ++ "thousand" ++ m.s ! c ; n = Pl} ; + +-- numerals as sequences of digits + + lincat + Dig = TDigit ; + + lin + IDig d = d ** {tail = T1} ; + + IIDig d i = { + s = \\o => d.s ! NCard ++ commaIf i.tail ++ i.s ! o ; + n = Pl ; + tail = inc i.tail + } ; + + D_0 = mkDig "0" ; + D_1 = mk3Dig "1" "1st" Sg ; + D_2 = mk2Dig "2" "2nd" ; + D_3 = mk2Dig "3" "3rd" ; + D_4 = mkDig "4" ; + D_5 = mkDig "5" ; + D_6 = mkDig "6" ; + D_7 = mkDig "7" ; + D_8 = mkDig "8" ; + D_9 = mkDig "9" ; + + oper + commaIf : DTail -> Str = \t -> case t of { + T3 => "," ; + _ => [] + } ; + + inc : DTail -> DTail = \t -> case t of { + T1 => T2 ; + T2 => T3 ; + T3 => T1 + } ; + + mk2Dig : Str -> Str -> TDigit = \c,o -> mk3Dig c o Pl ; + mkDig : Str -> TDigit = \c -> mk2Dig c (c + "th") ; + + mk3Dig : Str -> Str -> Number -> TDigit = \c,o,n -> { + s = table {NCard => c ; NOrd => o} ; + n = n + } ; + + TDigit = { + n : Number ; + s : CardOrd => Str + } ; + +} diff --git a/lib/resource/exper/english/OverloadEng.gf b/lib/resource/exper/english/OverloadEng.gf new file mode 100644 index 000000000..90d365c7b --- /dev/null +++ b/lib/resource/exper/english/OverloadEng.gf @@ -0,0 +1 @@ +resource OverloadEng = Overload with (Grammar = GrammarEng) ; diff --git a/lib/resource/exper/english/ParadigmsEng.gf b/lib/resource/exper/english/ParadigmsEng.gf new file mode 100644 index 000000000..b1ed21b66 --- /dev/null +++ b/lib/resource/exper/english/ParadigmsEng.gf @@ -0,0 +1,572 @@ +--# -path=.:../abstract:../../prelude:../common + +--1 English Lexical Paradigms +-- +-- Aarne Ranta 2003--2005 +-- +-- This is an API for the user of the resource grammar +-- for adding lexical items. It gives functions for forming +-- expressions of open categories: nouns, adjectives, verbs. +-- +-- Closed categories (determiners, pronouns, conjunctions) are +-- accessed through the resource syntax API, $Structural.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, rather +-- than stems, as string arguments of the paradigms. +-- +-- The structure of functions for each word class $C$ is the following: +-- first we give a handful of patterns that aim to cover all +-- regular cases. Then we give a worst-case function $mkC$, which serves as an +-- escape to construct the most irregular words of type $C$. +-- However, this function should only seldom be needed: we have a +-- separate module [``IrregEng`` ../../english/IrregEng.gf], +-- which covers irregular verbss. + +resource ParadigmsEng = open + (Predef=Predef), + Prelude, + MorphoEng, + CatEng + in { +--2 Parameters +-- +-- To abstract over gender names, we define the following identifiers. + +oper + Gender : Type ; + + human : Gender ; + nonhuman : Gender ; + masculine : Gender ; + +-- To abstract over number names, we define the following. + + Number : Type ; + + singular : Number ; + plural : Number ; + +-- To abstract over case names, we define the following. + + Case : Type ; + + nominative : Case ; + genitive : Case ; + +-- Prepositions are used in many-argument functions for rection. +-- The resource category $Prep$ is used. + + + +--2 Nouns + +-- Nouns are constructed by the function $mkN$, which takes a varying +-- number of arguments. + + mkN : overload { + +-- The regular function captures the variants for nouns ending with +-- "s","sh","x","z" or "y": "kiss - kisses", "flash - flashes"; +-- "fly - flies" (but "toy - toys"), + + mkN : (flash : Str) -> N ; + +-- In practice the worst case is to give singular and plural nominative. + + mkN : (man,men : Str) -> N ; + +-- The theoretical worst case: give all four forms. + + mkN : (man,men,man's,men's : Str) -> N ; + +--3 Compound nouns +-- +-- A compound noun is an uninflected string attached to an inflected noun, +-- such as "baby boom", "chief executive officer". + + mkN : Str -> N -> N + } ; + + +--3 Relational nouns +-- +-- Relational nouns ("daughter of x") need a preposition. + + mkN2 : N -> Prep -> N2 ; + +-- The most common preposition is "of", and the following is a +-- shortcut for regular relational nouns with "of". + + regN2 : Str -> N2 ; + +-- Use the function $mkPrep$ or see the section on prepositions below to +-- form other prepositions. +-- +-- Three-place relational nouns ("the connection from x to y") need two prepositions. + + mkN3 : N -> Prep -> Prep -> N3 ; + + + +--3 Proper names and noun phrases +-- +-- Proper names, with a regular genitive, are formed from strings. + + mkPN : overload { + + mkPN : Str -> PN ; + +-- Sometimes a common noun can be reused as a proper name, e.g. "Bank" + + mkPN : N -> PN + } ; + + +--2 Adjectives + + mkA : overload { + +-- For regular adjectives, the adverbial and comparison forms are derived. This holds +-- even for cases with the variations "happy - happily - happier - happiest", +-- "free - freely - freer - freest", and "rude - rudest". + + mkA : (happy : Str) -> A ; + +-- However, the duplication of the final consonant cannot be predicted, +-- but a separate case is used to give the comparative + + mkA : (fat,fatter : Str) -> A ; + +-- As many as four forms may be needed. + + mkA : (good,better,best,well : Str) -> A + } ; + +-- To force comparison to be formed by "more - most", +-- the following function is used: + + compoundA : A -> A ; -- -/more/most ridiculous + + + +--3 Two-place adjectives +-- +-- Two-place adjectives need a preposition for their second argument. + + mkA2 : A -> Prep -> A2 ; + + + +--2 Adverbs + +-- Adverbs are not inflected. Most lexical ones have position +-- after the verb. Some can be preverbal (e.g. "always"). + + mkAdv : Str -> Adv ; + mkAdV : Str -> AdV ; + +-- Adverbs modifying adjectives and sentences can also be formed. + + mkAdA : Str -> AdA ; + +--2 Prepositions +-- +-- A preposition as used for rection in the lexicon, as well as to +-- build $PP$s in the resource API, just requires a string. + + mkPrep : Str -> Prep ; + noPrep : Prep ; + +-- (These two functions are synonyms.) + +--2 Verbs +-- + +-- Verbs are constructed by the function $mkV$, which takes a varying +-- number of arguments. + + mkV : overload { + +-- The regular verb function recognizes the special cases where the last +-- character is "y" ("cry-cries" but "buy-buys") or a sibilant +-- ("kiss-"kisses", "jazz-jazzes", "rush-rushes", "munch - munches", +-- "fix - fixes"). + + mkV : (cry : Str) -> V ; + +-- Give the present and past forms for regular verbs where +-- the last letter is duplicated in some forms, +-- e.g. "rip - ripped - ripping". + + mkV : (stop, stopped : Str) -> V ; + +-- There is an extensive list of irregular verbs in the module $IrregularEng$. +-- In practice, it is enough to give three forms, +-- e.g. "drink - drank - drunk". + + mkV : (drink, drank, drunk : Str) -> V ; + +-- Irregular verbs with duplicated consonant in the present participle. + + mkV : (run, ran, run, running : Str) -> V ; + +-- Except for "be", the worst case needs five forms: the infinitive and +-- the third person singular present, the past indicative, and the +-- past and present participles. + + mkV : (go, goes, went, gone, going : Str) -> V + }; + +-- Verbs with a particle. +-- The particle, such as in "switch on", is given as a string. + + partV : V -> Str -> V ; + +-- Reflexive verbs. +-- By default, verbs are not reflexive; this function makes them that. + + reflV : V -> V ; + +--3 Two-place verbs +-- +-- Two-place verbs need a preposition, except the special case with direct object. +-- (transitive verbs). Notice that a particle comes from the $V$. + + mkV2 : overload { + mkV2 : V -> Prep -> V2 ; -- believe in + mkV2 : V -> V2 -- kill + }; + +--3 Three-place verbs +-- +-- Three-place (ditransitive) verbs need two prepositions, of which +-- the first one or both can be absent. + + mkV3 : V -> Prep -> Prep -> V3 ; -- speak, with, about + dirV3 : V -> Prep -> V3 ; -- give,_,to + dirdirV3 : V -> V3 ; -- give,_,_ + +--3 Other complement patterns +-- +-- Verbs and adjectives can take complements such as sentences, +-- questions, verb phrases, and adjectives. + + mkV0 : V -> V0 ; + mkVS : V -> VS ; + mkV2S : V -> Prep -> V2S ; + mkVV : V -> VV ; + mkV2V : V -> Prep -> Prep -> V2V ; + mkVA : V -> VA ; + mkV2A : V -> Prep -> V2A ; + mkVQ : V -> VQ ; + mkV2Q : V -> Prep -> V2Q ; + + mkAS : A -> AS ; + mkA2S : A -> Prep -> A2S ; + mkAV : A -> AV ; + mkA2V : A -> Prep -> A2V ; + +-- Notice: Categories $V0, AS, A2S, AV, A2V$ are just $A$. +-- $V0$ is just $V$; the second argument is treated as adverb. + + V0 : Type ; + AS, A2S, AV, A2V : Type ; + +--. +--2 Definitions of paradigms +-- +-- The definitions should not bother the user of the API. So they are +-- hidden from the document. + + Gender = MorphoEng.Gender ; + Number = MorphoEng.Number ; + Case = MorphoEng.Case ; + human = Masc ; + nonhuman = Neutr ; + masculine = Masc ; + feminine = Fem ; + singular = Sg ; + plural = Pl ; + nominative = Nom ; + genitive = Gen ; + + Preposition : Type = Str ; -- obsolete + + regN = \ray -> + let rays = add_s ray + in + mk2N ray rays ; + + + add_s : Str -> Str = \w -> case w of { + _ + ("io" | "oo") => w + "s" ; -- radio, bamboo + _ + ("s" | "z" | "x" | "sh" | "ch" | "o") => w + "es" ; -- bus, hero + _ + ("a" | "o" | "u" | "e") + "y" => w + "s" ; -- boy + x + "y" => x + "ies" ; -- fly + _ => w + "s" -- car + } ; + + mk2N = \man,men -> + let mens = case last men of { + "s" => men + "'" ; + _ => men + "'s" + } + in + mk4N man men (man + "'s") mens ; + + mk4N = \man,men,man's,men's -> + mkNoun man man's men men's ** {g = Neutr ; lock_N = <>} ; + + genderN g man = {s = man.s ; g = g ; lock_N = <>} ; + + compoundN s n = {s = \\x,y => s ++ n.s ! x ! y ; g=n.g ; lock_N = <>} ; + + mkPN = overload { + mkPN : Str -> PN = regPN ; + mkPN : N -> PN = nounPN + } ; + + + mkN2 = \n,p -> n ** {lock_N2 = <> ; c2 = p.s} ; + regN2 n = mkN2 (regN n) (mkPrep "of") ; + mkN3 = \n,p,q -> n ** {lock_N3 = <> ; c2 = p.s ; c3 = q.s} ; + +--3 Relational common noun phrases +-- +-- In some cases, you may want to make a complex $CN$ into a +-- relational noun (e.g. "the old town hall of"). + + cnN2 : CN -> Prep -> N2 ; + cnN3 : CN -> Prep -> Prep -> N3 ; + +-- This is obsolete. + cnN2 = \n,p -> n ** {lock_N2 = <> ; c2 = p.s} ; + cnN3 = \n,p,q -> n ** {lock_N3 = <> ; c2 = p.s ; c3 = q.s} ; + + regPN n = regGenPN n human ; + regGenPN n g = nameReg n g ** {lock_PN = <>} ; + nounPN n = {s = n.s ! singular ; g = n.g ; lock_PN = <>} ; + + mk2A a b = mkAdjective a a a b ** {lock_A = <>} ; + regA a = regADeg a ** {lock_A = <>} ; + + mkA2 a p = a ** {c2 = p.s ; lock_A2 = <>} ; + + ADeg = A ; ---- + + mkADeg a b c d = mkAdjective a b c d ** {lock_A = <>} ; + + regADeg happy = + let + happ = init happy ; + y = last happy ; + happie = case y of { + "y" => happ + "ie" ; + "e" => happy ; + _ => happy + "e" + } ; + happily : Str = case happy of { + _ + "y" => happ + "ily" ; + _ + "ll" => happy + "y" ; + _ => happy + "ly" + } ; + in mkADeg happy (happie + "r") (happie + "st") happily ; + + duplADeg fat = + mkADeg fat + (fat + last fat + "er") (fat + last fat + "est") (fat + "ly") ; + + compoundADeg a = + let ad = (a.s ! AAdj Posit) + in mkADeg ad ("more" ++ ad) ("most" ++ ad) (a.s ! AAdv) ; + + adegA a = a ; + + mkAdv x = ss x ** {lock_Adv = <>} ; + mkAdV x = ss x ** {lock_AdV = <>} ; + mkAdA x = ss x ** {lock_AdA = <>} ; + + mkPrep p = ss p ** {lock_Prep = <>} ; + noPrep = mkPrep [] ; + + mk5V a b c d e = mkVerb a b c d e ** {s1 = [] ; lock_V = <>} ; + + regV cry = + let + cr = init cry ; + y = last cry ; + cries = (regN cry).s ! Pl ! Nom ; -- ! + crie = init cries ; + cried = case last crie of { + "e" => crie + "d" ; + _ => crie + "ed" + } ; + crying = case y of { + "e" => case last cr of { + "e" => cry + "ing" ; + _ => cr + "ing" + } ; + _ => cry + "ing" + } + in mk5V cry cries cried cried crying ; + + reg2V fit fitted = + let fitt = Predef.tk 2 fitted ; + in mk5V fit (fit + "s") (fitt + "ed") (fitt + "ed") (fitt + "ing") ; + + regDuplV fit = + case last fit of { + ("a" | "e" | "i" | "o" | "u" | "y") => + Predef.error (["final duplication makes no sense for"] ++ fit) ; + t => + let fitt = fit + t in + mk5V fit (fit + "s") (fitt + "ed") (fitt + "ed") (fitt + "ing") + } ; + + irregV x y z = let reg = (regV x).s in + mk5V x (reg ! VPres) y z (reg ! VPresPart) ** {s1 = [] ; lock_V = <>} ; + + irreg4V x y z w = let reg = (regV x).s in + mk5V x (reg ! VPres) y z w ** {s1 = [] ; lock_V = <>} ; + + irregDuplV fit y z = + let + fitting = (regDuplV fit).s ! VPresPart + in + mk5V fit (fit + "s") y z fitting ; + + partV v p = verbPart v p ** {lock_V = <>} ; + reflV v = {s = v.s ; part = v.part ; lock_V = v.lock_V ; isRefl = True} ; + + prepV2 v p = v ** {s = v.s ; s1 = v.s1 ; c2 = p.s ; lock_V2 = <>} ; + dirV2 v = prepV2 v noPrep ; + + mkV3 v p q = v ** {s = v.s ; s1 = v.s1 ; c2 = p.s ; c3 = q.s ; lock_V3 = <>} ; + dirV3 v p = mkV3 v noPrep p ; + dirdirV3 v = dirV3 v noPrep ; + + mkVS v = v ** {lock_VS = <>} ; + mkVV v = { + s = table {VVF vf => v.s ! vf ; _ => variants {}} ; + isAux = False ; lock_VV = <> + } ; + mkVQ v = v ** {lock_VQ = <>} ; + + V0 : Type = V ; +-- V2S, V2V, V2Q : Type = V2 ; + AS, A2S, AV : Type = A ; + A2V : Type = A2 ; + + mkV0 v = v ** {lock_V = <>} ; + mkV2S v p = prepV2 v p ** {lock_V2S = <>} ; + mkV2V v p t = prepV2 v p ** {isAux = False ; lock_V2V = <>} ; + mkVA v = v ** {lock_VA = <>} ; + mkV2A v p = prepV2 v p ** {lock_V2A = <>} ; + mkV2Q v p = prepV2 v p ** {lock_V2Q = <>} ; + + mkAS v = v ** {lock_A = <>} ; + mkA2S v p = mkA2 v p ** {lock_A = <>} ; + mkAV v = v ** {lock_A = <>} ; + mkA2V v p = mkA2 v p ** {lock_A2 = <>} ; + + +-- pre-overload API and overload definitions + + mk4N : (man,men,man's,men's : Str) -> N ; + regN : Str -> N ; + mk2N : (man,men : Str) -> N ; + genderN : Gender -> N -> N ; + compoundN : Str -> N -> N ; + + mkN = overload { + mkN : (man,men,man's,men's : Str) -> N = mk4N ; + mkN : Str -> N = regN ; + mkN : (man,men : Str) -> N = mk2N ; + mkN : Gender -> N -> N = genderN ; + mkN : Str -> N -> N = compoundN + } ; + + + mk2A : (free,freely : Str) -> A ; + regA : Str -> A ; + + mkA = overload { + mkA : Str -> A = regA ; + mkA : (fat,fatter : Str) -> A = \fat,fatter -> + mkAdjective fat fatter (init fatter + "st") (fat + "ly") ** {lock_A = <>} ; + mkA : (good,better,best,well : Str) -> A = \a,b,c,d -> + mkAdjective a b c d ** {lock_A = <>} + } ; + + compoundA = compoundADeg ; + + + mk5V : (go, goes, went, gone, going : Str) -> V ; + regV : (cry : Str) -> V ; + reg2V : (stop, stopped : Str) -> V; + irregV : (drink, drank, drunk : Str) -> V ; + irreg4V : (run, ran, run, running : Str) -> V ; + + -- Use reg2V instead + regDuplV : Str -> V ; + -- Use irreg4V instead + irregDuplV : (get, got, gotten : Str) -> V ; + + mkV = overload { + mkV : (cry : Str) -> V = regV ; + mkV : (stop, stopped : Str) -> V = reg2V ; + mkV : (drink, drank, drunk : Str) -> V = irregV ; + mkV : (run, ran, run, running : Str) -> V = irreg4V ; + mkV : (go, goes, went, gone, going : Str) -> V = mk5V + }; + + prepV2 : V -> Prep -> V2 ; + dirV2 : V -> V2 ; + + mkV2 = overload { + mkV2 : V -> Prep -> V2 = prepV2; + mkV2 : V -> V2 = dirV2 + }; + + +---- obsolete + +-- Comparison adjectives may two more forms. + + ADeg : Type ; + + mkADeg : (good,better,best,well : Str) -> ADeg ; + +-- The regular pattern recognizes two common variations: +-- "-e" ("rude" - "ruder" - "rudest") and +-- "-y" ("happy - happier - happiest - happily") + + regADeg : Str -> ADeg ; -- long, longer, longest + +-- However, the duplication of the final consonant is nor predicted, +-- but a separate pattern is used: + + duplADeg : Str -> ADeg ; -- fat, fatter, fattest + +-- If comparison is formed by "more", "most", as in general for +-- long adjective, the following pattern is used: + + compoundADeg : A -> ADeg ; -- -/more/most ridiculous + +-- From a given $ADeg$, it is possible to get back to $A$. + + adegA : ADeg -> A ; + + + regPN : Str -> PN ; + regGenPN : Str -> Gender -> PN ; -- John, John's + +-- Sometimes you can reuse a common noun as a proper name, e.g. "Bank". + + nounPN : N -> PN ; + + + +} ; diff --git a/lib/resource/exper/english/PhraseEng.gf b/lib/resource/exper/english/PhraseEng.gf new file mode 100644 index 000000000..ec31aeb83 --- /dev/null +++ b/lib/resource/exper/english/PhraseEng.gf @@ -0,0 +1,24 @@ +concrete PhraseEng of Phrase = CatEng ** open Prelude, ResEng in { + + lin + PhrUtt pconj utt voc = {s = pconj.s ++ utt.s ++ voc.s} ; + + UttS s = s ; + UttQS qs = {s = qs.s ! QDir} ; + UttImpSg pol imp = {s = pol.s ++ imp.s ! contrNeg True pol.p ! ImpF Sg False} ; + UttImpPl pol imp = {s = pol.s ++ imp.s ! contrNeg True pol.p ! ImpF Pl False} ; + UttImpPol pol imp = {s = pol.s ++ imp.s ! contrNeg True pol.p ! ImpF Sg True} ; + + UttIP ip = {s = ip.s ! Nom} ; --- Acc also + UttIAdv iadv = iadv ; + UttNP np = {s = np.s ! Nom} ; + UttVP vp = {s = infVP False vp (agrP3 Sg)} ; + UttAdv adv = adv ; + + NoPConj = {s = []} ; + PConjConj conj = conj ; + + NoVoc = {s = []} ; + VocNP np = {s = "," ++ np.s ! Nom} ; + +} diff --git a/lib/resource/exper/english/QuestionEng.gf b/lib/resource/exper/english/QuestionEng.gf new file mode 100644 index 000000000..c58f631fc --- /dev/null +++ b/lib/resource/exper/english/QuestionEng.gf @@ -0,0 +1,44 @@ +concrete QuestionEng of Question = CatEng ** open ResEng, Prelude in { + + flags optimize=all_subs ; + + lin + + QuestCl cl = { + s = \\t,a,p => + let cls = cl.s ! t ! a ! p + in table { + QDir => cls ! OQuest ; + QIndir => "if" ++ cls ! ODir + } ---- "whether" in ExtEng + } ; + + QuestVP qp vp = + let cl = mkClause (qp.s ! Nom) {n = qp.n ; p = P3} vp + in {s = \\t,a,b,_ => cl.s ! t ! a ! b ! ODir} ; + + QuestSlash ip slash = + mkQuestion (ss (slash.c2 ++ ip.s ! Acc)) slash ; + --- stranding in ExratEng + + QuestIAdv iadv cl = mkQuestion iadv cl ; + + QuestIComp icomp np = + mkQuestion icomp (mkClause (np.s ! Nom) np.a (predAux auxBe)) ; + + + PrepIP p ip = {s = p.s ++ ip.s ! Nom} ; + + AdvIP ip adv = { + s = \\c => ip.s ! c ++ adv.s ; + n = ip.n + } ; + + IDetCN idet num ord cn = { + s = \\c => idet.s ++ num.s ++ ord.s ++ cn.s ! idet.n ! c ; + n = idet.n + } ; + + CompIAdv a = a ; + +} diff --git a/lib/resource/exper/english/RelativeEng.gf b/lib/resource/exper/english/RelativeEng.gf new file mode 100644 index 000000000..87c78c96a --- /dev/null +++ b/lib/resource/exper/english/RelativeEng.gf @@ -0,0 +1,48 @@ +concrete RelativeEng of Relative = CatEng ** open ResEng in { + + flags optimize=all_subs ; + + lin + + RelCl cl = { + s = \\t,a,p,_ => "such" ++ "that" ++ cl.s ! t ! a ! p ! ODir ; + c = Nom + } ; + + RelVP rp vp = { + s = \\t,ant,b,ag => + let + agr = case rp.a of { + RNoAg => ag ; + RAg a => a + } ; + cl = mkClause (rp.s ! RC Nom) agr vp + in + cl.s ! t ! ant ! b ! ODir ; + c = Nom + } ; + +-- Pied piping: "at which we are looking". Stranding and empty +-- relative are defined in $ExtraEng.gf$ ("that we are looking at", +-- "we are looking at"). + + RelSlash rp slash = { + s = \\t,a,p,_ => slash.c2 ++ rp.s ! RPrep ++ slash.s ! t ! a ! p ! ODir ; + c = Acc + } ; + + FunRP p np rp = { + s = \\c => np.s ! Acc ++ p.s ++ rp.s ! RPrep ; + a = RAg np.a + } ; + + IdRP = { + s = table { + RC Gen => "whose" ; + RC _ => "that" ; + RPrep => "which" + } ; + a = RNoAg + } ; + +} diff --git a/lib/resource/exper/english/ResEng.gf b/lib/resource/exper/english/ResEng.gf new file mode 100644 index 000000000..650acfd34 --- /dev/null +++ b/lib/resource/exper/english/ResEng.gf @@ -0,0 +1,455 @@ +--# -path=.:../abstract:../common:../../prelude + +--1 English auxiliary operations. + +-- This module contains operations that are needed to make the +-- resource syntax work. To define everything that is needed to +-- implement $Test$, it moreover contains regular lexical +-- patterns needed for $Lex$. + +resource ResEng = ParamX ** open Prelude in { + + flags optimize=all ; + + +-- Some parameters, such as $Number$, are inherited from $ParamX$. + +--2 For $Noun$ + +-- This is the worst-case $Case$ needed for pronouns. + + param + Case = Nom | Acc | Gen ; + +-- Agreement of $NP$ is a record. We'll add $Gender$ later. + + oper + Agr = {n : Number ; p : Person} ; + + param + Gender = Neutr | Masc | Fem ; + +--2 For $Verb$ + +-- Only these five forms are needed for open-lexicon verbs. + + param + VForm = + VInf + | VPres + | VPPart + | VPresPart + | VPast --# notpresent + ; + +-- Auxiliary verbs have special negative forms. + + VVForm = + VVF VForm + | VVPresNeg + | VVPastNeg --# notpresent + ; + +-- The order of sentence is needed already in $VP$. + + Order = ODir | OQuest ; + + +--2 For $Adjective$ + + AForm = AAdj Degree | AAdv ; + +--2 For $Relative$ + + RAgr = RNoAg | RAg {n : Number ; p : Person} ; + RCase = RPrep | RC Case ; + +--2 For $Numeral$ + + CardOrd = NCard | NOrd ; + DForm = unit | teen | ten ; + +--2 Transformations between parameter types + + oper + agrP3 : Number -> Agr = \n -> + {n = n ; p = P3} ; + + conjAgr : Agr -> Agr -> Agr = \a,b -> { + n = conjNumber a.n b.n ; + p = conjPerson a.p b.p + } ; + +-- For $Lex$. + +-- For each lexical category, here are the worst-case constructors. + + mkNoun : (_,_,_,_ : Str) -> {s : Number => Case => Str} = + \man,mans,men,mens -> { + s = table { + Sg => table { + Gen => mans ; + _ => man + } ; + Pl => table { + Gen => mens ; + _ => men + } + } + } ; + + mkAdjective : (_,_,_,_ : Str) -> {s : AForm => Str} = + \good,better,best,well -> { + s = table { + AAdj Posit => good ; + AAdj Compar => better ; + AAdj Superl => best ; + AAdv => well + } + } ; + + mkVerb : (_,_,_,_,_ : Str) -> Verb = + \go,goes,went,gone,going -> { + s = table { + VInf => go ; + VPres => goes ; + VPast => went ; --# notpresent + VPPart => gone ; + VPresPart => going + } ; + isRefl = False + } ; + + mkIP : (i,me,my : Str) -> Number -> {s : Case => Str ; n : Number} = + \i,me,my,n -> let who = mkNP i me my n P3 in {s = who.s ; n = n} ; + + mkNP : (i,me,my : Str) -> Number -> Person -> {s : Case => Str ; a : Agr} = + \i,me,my,n,p -> { + s = table { + Nom => i ; + Acc => me ; + Gen => my + } ; + a = { + n = n ; + p = p + } + } ; + +-- These functions cover many cases; full coverage inflectional patterns are +-- in $MorphoEng$. + + regN : Str -> {s : Number => Case => Str} = \car -> + mkNoun car (car + "'s") (car + "s") (car + "s'") ; + + regA : Str -> {s : AForm => Str} = \warm -> + mkAdjective warm (warm + "er") (warm + "est") (warm + "ly") ; + + regV : Str -> Verb = \walk -> + mkVerb walk (walk + "s") (walk + "ed") (walk + "ed") (walk + "ing") ; + + regNP : Str -> Number -> {s : Case => Str ; a : Agr} = \that,n -> + mkNP that that (that + "'s") n P3 ; + +-- 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" ; + +-- For $Verb$. + + Verb : Type = { + s : VForm => Str ; + isRefl : Bool + } ; + + param + CPolarity = + CPos + | CNeg Bool ; -- contracted or not + + oper + contrNeg : Bool -> Polarity -> CPolarity = \b,p -> case p of { + Pos => CPos ; + Neg => CNeg b + } ; + + VerbForms : Type = + Tense => Anteriority => CPolarity => Order => Agr => + {aux, adv, fin, inf : Str} ; -- would, not, sleeps, slept + + VP : Type = { + s : VerbForms ; + prp : Str ; -- present participle + inf : Str ; -- the infinitive form ; VerbForms would be the logical place + ad : Str ; -- sentence adverb + s2 : Agr => Str -- complement + } ; + + + SlashVP = VP ** {c2 : Str} ; + + predVc : (Verb ** {c2 : Str}) -> SlashVP = \verb -> + predV verb ** {c2 = verb.c2} ; + + predV : Verb -> VP = \verb -> { + s = \\t,ant,b,ord,agr => + let + inf = verb.s ! VInf ; + fin = presVerb verb agr ; + part = verb.s ! VPPart ; + in + case of { + => vff fin [] ; + => vf (does agr) inf ; + => vf (have agr) part ; --# notpresent + => vfn c (have agr) (havent agr) part ; --# notpresent + => vff (verb.s ! VPast) [] ; --# notpresent + => vf "did" inf ; --# notpresent + => vfn c "did" "didn't" inf ; --# notpresent + => vf "had" part ; --# notpresent + => vfn c "had" "hadn't" part ; --# notpresent + => vf "will" inf ; --# notpresent + => vfn c "will" "won't" inf ; --# notpresent + => vf "will" ("have" ++ part) ; --# notpresent + => vfn c "will" "won't"("have" ++ part) ; --# notpresent + => vf "would" inf ; --# notpresent + => vfn c "would" "wouldn't" inf ; --# notpresent + => vf "would" ("have" ++ part) ; --# notpresent + => vfn c "would" "wouldn't" ("have" ++ part) ; --# notpresent + => vfn c (does agr) (doesnt agr) inf + } ; + prp = verb.s ! VPresPart ; + inf = verb.s ! VInf ; + ad = [] ; + s2 = \\a => if_then_Str verb.isRefl (reflPron ! a) [] + } ; + + predAux : Aux -> VP = \verb -> { + s = \\t,ant,cb,ord,agr => + let + b = case cb of { + CPos => Pos ; + _ => Neg + } ; + inf = verb.inf ; + fin = verb.pres ! b ! agr ; + finp = verb.pres ! Pos ! agr ; + part = verb.ppart ; + in + case of { + => vf (have agr) part ; --# notpresent + => vfn c (have agr) (havent agr) part ; --# notpresent + => vf (verb.past ! b ! agr) [] ; --# notpresent + => vfn c (verb.past!Pos!agr)(verb.past!Neg!agr) [] ; --# notpresent + => vf "had" part ; --# notpresent + => vfn c "had" "hadn't" part ; --# notpresent + => vf "will" inf ; --# notpresent + => vfn c "will" "won't" inf ; --# notpresent + => vf "will" ("have" ++ part) ; --# notpresent + => vfn c "will" "won't"("have" ++ part) ; --# notpresent + => vf "would" inf ; --# notpresent + => vfn c "would" "wouldn't" inf ; --# notpresent + => vf "would" ("have" ++ part) ; --# notpresent + => vfn c "would" "wouldn't" ("have" ++ part) ; --# notpresent + => vf fin [] ; + => vfn c finp fin [] + } ; + prp = verb.prpart ; + inf = verb.inf ; + ad = [] ; + s2 = \\_ => [] + } ; + + vff : Str -> Str -> {aux, adv, fin, inf : Str} = \x,y -> + {aux = [] ; adv = [] ; fin = x ; inf = y} ; + + vf : Str -> Str -> {aux, adv, fin, inf : Str} = \x,y -> vfn True x x y ; + + vfn : Bool -> Str -> Str -> Str -> {aux, fin, adv, inf : Str} = + \contr,x,y,z -> + case contr of { + True => {aux = y ; adv = [] ; fin = [] ; inf = z} ; + False => {aux = x ; adv = "not" ; fin = [] ; inf = z} + } ; + + insertObj : (Agr => Str) -> VP -> VP = \obj,vp -> { + s = vp.s ; + prp = vp.prp ; + inf = vp.inf ; + ad = vp.ad ; + s2 = \\a => vp.s2 ! a ++ obj ! a + } ; + + insertObjPre : (Agr => Str) -> VP -> VP = \obj,vp -> { + s = vp.s ; + prp = vp.prp ; + inf = vp.inf ; + ad = vp.ad ; + s2 = \\a => obj ! a ++ vp.s2 ! a + } ; + + insertObjc : (Agr => Str) -> SlashVP -> SlashVP = \obj,vp -> + insertObj obj vp ** {c2 = vp.c2} ; + +--- The adverb should be before the finite verb. + + insertAdV : Str -> VP -> VP = \ad,vp -> { + s = vp.s ; + prp = vp.prp ; + inf = vp.inf ; + ad = vp.ad ++ ad ; + s2 = \\a => vp.s2 ! a + } ; + +-- + + predVV : {s : VVForm => Str ; isAux : Bool} -> VP = \verb -> + let verbs = verb.s + in + case verb.isAux of { + True => predAux { + pres = table { + Pos => \\_ => verbs ! VVF VPres ; + Neg => \\_ => verbs ! VVPresNeg + } ; + past = table { --# notpresent + Pos => \\_ => verbs ! VVF VPast ; --# notpresent + Neg => \\_ => verbs ! VVPastNeg --# notpresent + } ; --# notpresent + inf = verbs ! VVF VInf ; + ppart = verbs ! VVF VPPart ; + prpart = verbs ! VVF VPresPart ; + } ; + _ => predV {s = \\vf => verbs ! VVF vf ; isRefl = False} + } ; + + presVerb : {s : VForm => Str} -> Agr -> Str = \verb -> + agrVerb (verb.s ! VPres) (verb.s ! VInf) ; + + infVP : Bool -> VP -> Agr -> Str = \isAux,vp,a -> + vp.ad ++ + case isAux of {True => [] ; False => "to"} ++ + vp.inf ++ vp.s2 ! a ; + + agrVerb : Str -> Str -> Agr -> Str = \has,have,agr -> + case agr of { + {n = Sg ; p = P3} => has ; + _ => have + } ; + + have = agrVerb "has" "have" ; + havent = agrVerb "hasn't" "haven't" ; + does = agrVerb "does" "do" ; + doesnt = agrVerb "doesn't" "don't" ; + + Aux = { + pres : Polarity => Agr => Str ; + past : Polarity => Agr => Str ; --# notpresent + inf,ppart,prpart : Str + } ; + + auxBe : Aux = { + pres = \\b,a => case of { + => "am" ; + => ["am not"] ; --- am not I + _ => agrVerb (posneg b "is") (posneg b "are") a + } ; + past = \\b,a => case a of { --# notpresent + {n = Sg ; p = P1|P3} => (posneg b "was") ; --# notpresent + _ => (posneg b "were") --# notpresent + } ; --# notpresent + inf = "be" ; + ppart = "been" ; + prpart = "being" + } ; + + posneg : Polarity -> Str -> Str = \p,s -> case p of { + Pos => s ; + Neg => s + "n't" + } ; + + conjThat : Str = "that" ; + + reflPron : Agr => Str = table { + {n = Sg ; p = P1} => "myself" ; + {n = Sg ; p = P2} => "yourself" ; + {n = Sg ; p = P3} => "itself" ; ---- + {n = Pl ; p = P1} => "ourselves" ; + {n = Pl ; p = P2} => "yourselves" ; + {n = Pl ; p = P3} => "themselves" + } ; + +-- For $Sentence$. + + Clause : Type = { + s : Tense => Anteriority => CPolarity => Order => Str + } ; + + mkClause : Str -> Agr -> VP -> Clause = + \subj,agr,vp -> { + s = \\t,a,b,o => + let + verb = vp.s ! t ! a ! b ! o ! agr ; + compl = vp.s2 ! agr + in + case o of { + ODir => subj ++ verb.aux ++ verb.adv ++ vp.ad ++ verb.fin ++ verb.inf ++ compl ; + OQuest => verb.aux ++ subj ++ verb.adv ++ vp.ad ++ verb.fin ++ verb.inf ++ compl + } + } ; + + +-- For $Numeral$. + + mkNum : Str -> Str -> Str -> Str -> {s : DForm => CardOrd => Str} = + \two, twelve, twenty, second -> + {s = table { + unit => table {NCard => two ; NOrd => second} ; + teen => \\c => mkCard c twelve ; + ten => \\c => mkCard c twenty + } + } ; + + regNum : Str -> {s : DForm => CardOrd => Str} = + \six -> mkNum six (six + "teen") (six + "ty") (regOrd six) ; + + regCardOrd : Str -> {s : CardOrd => Str} = \ten -> + {s = table {NCard => ten ; NOrd => regOrd ten}} ; + + mkCard : CardOrd -> Str -> Str = \c,ten -> + (regCardOrd ten).s ! c ; + + regOrd : Str -> Str = \ten -> + case last ten of { + "y" => init ten + "ieth" ; + _ => ten + "th" + } ; + + mkQuestion : + {s : Str} -> Clause -> + {s : Tense => Anteriority => CPolarity => QForm => Str} = \wh,cl -> + { + s = \\t,a,p => + let + cls = cl.s ! t ! a ! p ; + why = wh.s + in table { + QDir => why ++ cls ! OQuest ; + QIndir => why ++ cls ! ODir + } + } ; + +-- for VP conjunction + + param + VPIForm = VPIInf | VPIPPart ; + + +} diff --git a/lib/resource/exper/english/SentenceEng.gf b/lib/resource/exper/english/SentenceEng.gf new file mode 100644 index 000000000..6089cd74b --- /dev/null +++ b/lib/resource/exper/english/SentenceEng.gf @@ -0,0 +1,88 @@ +concrete SentenceEng of Sentence = CatEng ** open Prelude, ResEng in { + + flags optimize=all_subs ; + + lin + + PredVP np vp = mkClause (np.s ! Nom) np.a vp ; + + PredSCVP sc vp = mkClause sc.s (agrP3 Sg) vp ; + + ImpVP vp = { + s = \\pol,n => + let + agr = {n = numImp n ; p = P2} ; + verb = infVP True vp agr ; + dont = case pol of { + CNeg True => "don't" ; + CNeg False => "do" ++ "not" ; + _ => [] + } + in + dont ++ verb + } ; + + SlashVP np vp = + mkClause (np.s ! Nom) np.a vp ** {c2 = vp.c2} ; + + SlashVVV2 np vv v2 = + mkClause (np.s ! Nom) np.a + (insertObj (\\a => infVP vv.isAux (predV v2) a) (predVV vv)) ** + {c2 = v2.c2} ; + + AdvSlash slash adv = { + s = \\t,a,b,o => slash.s ! t ! a ! b ! o ++ adv.s ; + c2 = slash.c2 + } ; + + SlashPrep cl prep = cl ** {c2 = prep.s} ; + + SlashVS np vs slash = + mkClause (np.s ! Nom) np.a + (insertObj (\\_ => conjThat ++ slash.s) (predV vs)) ** + {c2 = slash.c2} ; + + EmbedS s = {s = conjThat ++ s.s} ; + EmbedQS qs = {s = qs.s ! QIndir} ; + EmbedVP vp = {s = infVP False vp (agrP3 Sg)} ; --- agr + + UseCl t a p cl = { + s = t.s ++ a.s ++ p.s ++ cl.s ! t.t ! a.a ! ctr p.p ! ODir + } ; + UseQCl t a p cl = { + s = \\q => t.s ++ a.s ++ p.s ++ cl.s ! t.t ! a.a ! ctr p.p ! q + } ; + UseRCl t a p cl = { + s = \\r => t.s ++ a.s ++ p.s ++ cl.s ! t.t ! a.a ! ctr p.p ! r ; + c = cl.c + } ; + UseSlash t a p cl = { + s = t.s ++ a.s ++ p.s ++ cl.s ! t.t ! a.a ! ctr p.p ! ODir ; + c2 = cl.c2 + } ; + + AdvS a s = {s = a.s ++ "," ++ s.s} ; + + oper + ctr = contrNeg True ; -- contracted negations + +-- obsolete + lin + SlashV2 np v2 = + mkClause (np.s ! Nom) np.a (predV v2) ** {c2 = v2.c2} ; + + SlashVVV2 np vv v2 = + mkClause (np.s ! Nom) np.a + (insertObj (\\a => infVP vv.isAux (predV v2) a) (predVV vv)) ** + {c2 = v2.c2} ; + +} + +{- +--- todo: tense of embedded Slash + + SlashVSS np vs s = + mkClause (np.s ! Nom) np.a + (insertObj (\\_ => conjThat ++ s.s) (predV vs)) ** + {c2 = s.c2} ; +-} diff --git a/lib/resource/exper/english/StructuralEng.gf b/lib/resource/exper/english/StructuralEng.gf new file mode 100644 index 000000000..0b19685c5 --- /dev/null +++ b/lib/resource/exper/english/StructuralEng.gf @@ -0,0 +1,131 @@ +concrete StructuralEng of Structural = CatEng ** + open MorphoEng, (P = ParadigmsEng), Prelude in { + + flags optimize=all ; + + lin + above_Prep = ss "above" ; + after_Prep = ss "after" ; + all_Predet = ss "all" ; + almost_AdA, almost_AdN = ss "almost" ; + although_Subj = ss "although" ; + always_AdV = ss "always" ; + and_Conj = ss "and" ** {n = Pl} ; + because_Subj = ss "because" ; + before_Prep = ss "before" ; + behind_Prep = ss "behind" ; + between_Prep = ss "between" ; + both7and_DConj = sd2 "both" "and" ** {n = Pl} ; + but_PConj = ss "but" ; + by8agent_Prep = ss "by" ; + by8means_Prep = ss "by" ; + can8know_VV, can_VV = { + s = table { + VVF VInf => ["be able to"] ; + VVF VPres => "can" ; + VVF VPPart => ["been able to"] ; + VVF VPresPart => ["being able to"] ; + VVF VPast => "could" ; --# notpresent + VVPastNeg => "couldn't" ; --# notpresent + VVPresNeg => "can't" + } ; + isAux = True + } ; + during_Prep = ss "during" ; + either7or_DConj = sd2 "either" "or" ** {n = Sg} ; + everybody_NP = regNP "everybody" Sg ; + every_Det = mkDeterminer Sg "every" ; + everything_NP = regNP "everything" Sg ; + everywhere_Adv = ss "everywhere" ; + few_Det = mkDeterminer Pl "few" ; +--- first_Ord = ss "first" ; DEPRECATED + for_Prep = ss "for" ; + from_Prep = ss "from" ; + he_Pron = mkNP "he" "him" "his" Sg P3 ; + here_Adv = ss "here" ; + here7to_Adv = ss ["to here"] ; + here7from_Adv = ss ["from here"] ; + how_IAdv = ss "how" ; + how8many_IDet = mkDeterminer Pl ["how many"] ; + if_Subj = ss "if" ; + in8front_Prep = ss ["in front of"] ; + i_Pron = mkNP "I" "me" "my" Sg P1 ; + in_Prep = ss "in" ; + it_Pron = mkNP "it" "it" "its" Sg P3 ; + less_CAdv = ss "less" ; + many_Det = mkDeterminer Pl "many" ; + more_CAdv = ss "more" ; + most_Predet = ss "most" ; + much_Det = mkDeterminer Sg "much" ; + must_VV = { + s = table { + VVF VInf => ["have to"] ; + VVF VPres => "must" ; + VVF VPPart => ["had to"] ; + VVF VPresPart => ["having to"] ; + VVF VPast => ["had to"] ; --# notpresent + VVPastNeg => ["hadn't to"] ; --# notpresent + VVPresNeg => "mustn't" + } ; + isAux = True + } ; + no_Phr = ss "no" ; + on_Prep = ss "on" ; +---- one_Quant = mkDeterminer Sg "one" ; -- DEPRECATED + only_Predet = ss "only" ; + or_Conj = ss "or" ** {n = Sg} ; + otherwise_PConj = ss "otherwise" ; + part_Prep = ss "of" ; + please_Voc = ss "please" ; + possess_Prep = ss "of" ; + quite_Adv = ss "quite" ; + she_Pron = mkNP "she" "her" "her" Sg P3 ; + so_AdA = ss "so" ; + somebody_NP = regNP "somebody" Sg ; + someSg_Det = mkDeterminer Sg "some" ; + somePl_Det = mkDeterminer Pl "some" ; + something_NP = regNP "something" Sg ; + somewhere_Adv = ss "somewhere" ; + that_Quant = mkQuant "that" "those" ; + that_NP = regNP "that" Sg ; + there_Adv = ss "there" ; + there7to_Adv = ss "there" ; + there7from_Adv = ss ["from there"] ; + therefore_PConj = ss "therefore" ; + these_NP = regNP "these" Pl ; + they_Pron = mkNP "they" "them" "their" Pl P3 ; + this_Quant = mkQuant "this" "these" ; + this_NP = regNP "this" Sg ; + those_NP = regNP "those" Pl ; + through_Prep = ss "through" ; + too_AdA = ss "too" ; + to_Prep = ss "to" ; + under_Prep = ss "under" ; + very_AdA = ss "very" ; + want_VV = P.mkVV (P.regV "want") ; + we_Pron = mkNP "we" "us" "our" Pl P1 ; + whatPl_IP = mkIP "what" "what" "what's" Sg ; + whatSg_IP = mkIP "what" "what" "what's" Sg ; + when_IAdv = ss "when" ; + when_Subj = ss "when" ; + where_IAdv = ss "where" ; + whichPl_IDet = mkDeterminer Pl ["which"] ; + whichSg_IDet = mkDeterminer Sg ["which"] ; + whoSg_IP = mkIP "who" "whom" "whose" Sg ; + whoPl_IP = mkIP "who" "whom" "whose" Pl ; + why_IAdv = ss "why" ; + without_Prep = ss "without" ; + with_Prep = ss "with" ; + yes_Phr = ss "yes" ; + youSg_Pron = mkNP "you" "you" "your" Sg P2 ; + youPl_Pron = mkNP "you" "you" "your" Pl P2 ; + youPol_Pron = mkNP "you" "you" "your" Sg P2 ; + + +oper + mkQuant : Str -> Str -> {s : Number => Str} = \x,y -> { + s = table Number [x ; y] + } ; + +} + diff --git a/lib/resource/exper/english/VerbEng.gf b/lib/resource/exper/english/VerbEng.gf new file mode 100644 index 000000000..3ab2ec29f --- /dev/null +++ b/lib/resource/exper/english/VerbEng.gf @@ -0,0 +1,67 @@ +concrete VerbEng of Verb = CatEng ** open ResEng in { + + flags optimize=all_subs ; + + lin + UseV = predV ; + + SlashV2a v = predVc v ; + Slash2V3 v np = + insertObjc (\\_ => v.c2 ++ np.s ! Acc) (predV v ** {c2 = v.c3}) ; + Slash3V3 v np = + insertObjc (\\_ => v.c3 ++ np.s ! Acc) (predVc v) ; ---- + + ComplVV v vp = insertObj (\\a => infVP v.isAux vp a) (predVV v) ; + ComplVS v s = insertObj (\\_ => conjThat ++ s.s) (predV v) ; + ComplVQ v q = insertObj (\\_ => q.s ! QIndir) (predV v) ; + ComplVA v ap = insertObj (ap.s) (predV v) ; + + SlashV2V v vp = insertObjc (\\a => infVP v.isAux vp a) (predVc v) ; + SlashV2S v s = insertObjc (\\_ => conjThat ++ s.s) (predVc v) ; + SlashV2Q v q = insertObjc (\\_ => q.s ! QIndir) (predVc v) ; + SlashV2A v ap = insertObjc (\\a => ap.s ! a) (predVc v) ; ---- + + ComplSlash vp np = insertObjPre (\\_ => vp.c2 ++ np.s ! Acc) vp ; + + SlashVV vv vp = + insertObj (\\a => infVP vv.isAux vp a) (predVV vv) ** + {c2 = vp.c2} ; + SlashV2VNP vv np vp = + insertObjPre (\\_ => vp.c2 ++ np.s ! Acc) + (insertObjc (\\a => infVP vv.isAux vp a) (predVc vv)) ** + {c2 = vp.c2} ; + + UseComp comp = insertObj comp.s (predAux auxBe) ; + + AdvVP vp adv = insertObj (\\_ => adv.s) vp ; + + AdVVP adv vp = insertAdV adv.s vp ; + + ReflV2 v = insertObj (\\a => v.c2 ++ reflPron ! a) (predV v) ; + + PassV2 v = insertObj (\\_ => v.s ! VPPart) (predAux auxBe) ; + + UseVS, UseVQ = \vv -> {s = vv.s ; c2 = [] ; isRefl = vv.isRefl} ; -- no "to" + + CompAP ap = ap ; + CompNP np = {s = \\_ => np.s ! Acc} ; + CompAdv a = {s = \\_ => a.s} ; + +-- obsolete, just creating spurious ambiguity now + + ComplV2 v np = insertObj (\\_ => v.c2 ++ np.s ! Acc) (predV v) ; + ComplV3 v np np2 = + insertObj (\\_ => v.c2 ++ np.s ! Acc ++ v.c3 ++ np2.s ! Acc) (predV v) ; + ComplV2V v np vp = + insertObj (\\a => infVP v.isAux vp a) + (insertObj (\\_ => v.c2 ++ np.s ! Acc) (predV v)) ; + ComplV2S v np s = + insertObj (\\_ => conjThat ++ s.s) + (insertObj (\\_ => v.c2 ++ np.s ! Acc) (predV v)) ; + ComplV2Q v np q = + insertObj (\\_ => q.s ! QIndir) + (insertObj (\\_ => v.c2 ++ np.s ! Acc) (predV v)) ; + ComplV2A v np ap = + insertObj (\\_ => v.c2 ++ np.s ! Acc ++ ap.s ! np.a) (predV v) ; + +} diff --git a/lib/resource/scandinavian/CatScand.gf b/lib/resource/scandinavian/CatScand.gf index 4c1295ede..cd81382ca 100644 --- a/lib/resource/scandinavian/CatScand.gf +++ b/lib/resource/scandinavian/CatScand.gf @@ -10,7 +10,7 @@ incomplete concrete CatScand of Cat = S = {s : Order => Str} ; QS = {s : QForm => Str} ; RS = {s : Agr => Str ; c : NPForm} ; - SlashS = {s : Order => Str} ** {c2 : Str} ; + SSlash = {s : Order => Str} ** {c2 : Str} ; -- Sentence