msyds/gf-core
1
0
Fork 0
forked from GitHub/gf-core
Code Pull Requests Activity

resource = resource-1.0

Browse Source
This commit is contained in:
aarne
2006-06-22 22:25:55 +00:00
parent 7e5584b1ab
commit 251bc4c738
881 changed files with 31130 additions and 31130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
lib/resource/abstract/Adjective.gf Normal file
View File

@@ -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].
}

33
lib/resource/abstract/Adverb.gf Normal file
View File

@@ -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)
}

123
lib/resource/abstract/Cat.gf Normal file
View File

@@ -0,0 +1,123 @@
--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"
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"
--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"
QuantSg;-- quantifier ('nucleus' of sing. Det) e.g. "every"
QuantPl;-- quantifier ('nucleus' of plur. Det) e.g. "many"
Quant ; -- quantifier with both sg and pl 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, e.g. "five/fifth"
--2 Structural words
-- Constructed in [Structural Structural.html].
Conj ; -- conjunction, e.g. "and"
DConj ; -- distributed conj. 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. "ask"
VA ; -- adjective-complement verb e.g. "look"
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"
}

190
lib/resource/abstract/Categories.gf
View File

@@ -1,190 +0,0 @@
--1 Abstract Syntax Categories for Multilingual Resource Grammar
--
-- Aarne Ranta 2002 -- 2004
--
-- Although concrete syntax differs a lot between different languages,
-- many structures can be treated as common, on the level
-- of abstraction that GF provides.
-- What we will present in the following is a linguistically oriented abstract
-- syntax that has been successfully defined for the following languages:
--
--* $Eng$lish
--* $Fin$nish
--* $Fre$nch
--* $Ger$man
--* $Ita$lian
--* $Rus$sian
--* $Swe$dish
--
-- The three-letter prefixes are used in file names all over the resource
-- grammar library; we refer to them commonly as $X$ below.
--!
-- The grammar has been applied to define language
-- fragments on technical or near-to-technical domains: database queries,
-- video recorder dialogue systems, software specifications, and a
-- health-related phrase book. Each new application helped to identify some
-- missing structures in the resource and suggested some additions, but the
-- number of required additions was usually small.
--
-- To use the resource in applications, you need the following
-- $cat$ and $fun$ rules in $oper$ form, completed by taking the
-- $lincat$ and $lin$ judgements of a particular language. This is done
-- by using, instead of this module, the $reuse$ module which has the name
-- $ResourceX$. It is located in the subdirectory
-- $lib/resource/lang$ where $lang$ is the full name of the language.
abstract Categories = PredefAbs ** {
--!
--2 Categories
--
-- The categories of this resource grammar are mostly 'standard' categories
-- of linguistics. Their is no claim that they correspond to semantic categories
-- definable in type theory: to define such correspondences is the business
-- of applications grammars. In general, the correspondence between linguistic
-- and semantic categories is many-to-many.
--
-- Categories that may look special are $A2$, $N2$, and $V2$. They are all
-- instances of endowing another category with a complement, which can be either
-- a direct object (whose case may vary) or a prepositional phrase. Prepositional
-- phrases that are not complements belong to the category
-- $Adv$ of adverbs.
--
-- In each group below, some categories are *lexical* in the sense of only
-- containing atomic elements. These elements are not necessarily expressed by
-- one word in all languages; the essential thing is that they have no
-- constituents. Thus they have no productions in this part of the
-- resource grammar. The $ParadigmsX$ grammars provide ways of defining
-- lexical elements.
--
-- Lexical categories are listed before other categories
-- in each group and divided by an empty line.
--!
--3 Nouns and noun phrases
--
cat
N ; -- simple common noun, e.g. "car"
CN ; -- common noun phrase, e.g. "red car", "car that John owns"
N2 ; -- function word, e.g. "mother (of)"
N3 ; -- two-place function, e.g. "flight (from) (to)"
PN ; -- proper name, e.g. "John", "New York"
NP ; -- noun phrase, e.g. "John", "all cars", "you"
Det ; -- determiner, e.g. "every", "many"
NDet ; -- det that admits a num, e.g. "all (the 5)"
Num ; -- numeral, e.g. "three", "879"
--!
--3 Adjectives and adjectival phrases
--
A ; -- one-place adjective, e.g. "even"
A2 ; -- two-place adjective, e.g. "divisible (by)"
ADeg ; -- degree adjective, e.g. "big/bigger/biggest"
AP ; -- adjective phrase, e.g. "divisible by two", "bigger than John"
-- The difference between $A$ and $ADeg$ is that the former has no
-- comparison forms.
--!
--3 Verbs and verb phrases
--
V ; -- one-place verb, e.g. "walk"
V2 ; -- two-place verb, e.g. "love", "wait (for)", "switch on"
V3 ; -- three-place verb, e.g. "give", "prefer (stg) (to stg)"
VS ; -- sentence-compl. verb, e.g. "say", "prove"
VV ; -- verb-compl. verb, e.g. "can", "want"
VP ; -- verb phrase, e.g. "switch the light on"
VPI ; -- infinitive verb phrase e.g. "switch the light on", "not have run"
VCl ; -- same (variable ant.) e.g. "walk"/"have walked"
--!
--3 Adverbs and prepositions/cases
--
Adv ; -- sentence adverb e.g. "now", "in the house"
AdV ; -- verb adverb e.g. "always"
AdA ; -- ad-adjective e.g. "very"
AdC ; -- conjoining adverb e.g. "therefore", "otherwise"
PP ; -- prepositional phrase e.g. "in London"
Prep ; -- pre/postposition, case e.g. "after", Adessive
--!
--3 Sentences and relative clauses
--
-- This group has no lexical categories.
S ; -- sentence (fixed tense) e.g. "John walks", "John walked"
Cl ; -- clause (variable tense) e.g. "John walks"/"John walked"
Slash ; -- sentence without NP, e.g. "John waits for (...)"
RP ; -- relative pronoun, e.g. "which", "the mother of whom"
RCl ; -- relative clause, e.g. "who walks", "that I wait for"
--!
--3 Questions and imperatives
--
-- This group has no lexical categories.
IP ; -- interrogative pronoun, e.g. "who", "whose mother", "which car"
IDet ; -- interrog. determiner, e.g. "which", "how many"
IAdv ; -- interrogative adverb., e.g. "when", "why"
QCl ; -- question, e.g. "who walks"
QS ; -- question w. fixed tense
Imp ; -- imperative, e.g. "walk!"
--!
--3 Coordination and subordination
--
Conj ; -- conjunction, e.g. "and"
ConjD ; -- distributed conj. e.g. "both - and"
Subj ; -- subjunction, e.g. "if", "when"
ListS ; -- list of sentences
ListAP ; -- list of adjectival phrases
ListNP ; -- list of noun phrases
ListAdv ;-- list of adverbs
--!
--3 Complete utterances
--
-- This group has no lexical categories.
Phr ; -- full phrase, e.g. "John walks.","Who walks?", "Wait for me!"
Text ; -- sequence of phrases e.g. "One is odd. Therefore, two is even."
---- next
V2A ; -- paint the house red
V2V ; -- promise John to come / ask John to come
V2S ; -- tell John that it is raining
VQ ; -- ask who comes
V2Q ; -- ask John who comes
VA ; -- look yellow
V0 ; -- (it) rains
AS ; -- (it is) important that he comes
A2S ; -- (it is) important for me that he comes
AV ; -- difficult to play
A2V ; -- difficult for him to play
-- NB: it is difficult to play the sonata
-- vs. it (the sonata) is difficult to play
--- also: John is easy (for you) to please vs. John is eager to please
RS ; -- relative clause with fixed tense and polarity
TP ; -- tense x polarity selector
Tense ; -- (abstract) tense
Ant ; -- (abstract) anteriority
Pol ; -- polarity (positive or negative)
}

145
lib/resource/abstract/Clause.gf
View File

@@ -1,145 +0,0 @@
--!
--1 Rules for predication forming clauses
--
-- This module treats predications in a shallow way, without right-branching
-- $VP$ structures. This has the disadvantage of duplicating rules but the
-- advantage of fast parsing due to elimination of discontinuous
-- constituents. Also the canonical GF structures (in $.gfc$) files
-- get smaller, because much more pruning of case alternatives can
-- be performed at compile time.
--
-- Each of the rules below has the following structure:
--
-- "Subject -> Verb -> Complements -> Clause"
--
-- What complements are needed depends on the type of the verb.
-- For instance, $V$ takes no complement, $V2$ takes one $NP$
-- complement, $VS$ takes an $S$ complement, etc. There is an elegant
-- way of expressing this using dependent types:
--
-- (v : VType) -> Subj -> Verb v -> Compl v -> Clause
--
-- Since there are 12 verb types in our category system, using this
-- rule would be economical. The effect is amplified by another
-- distinction that the rules make: there are separate sets of
-- rules just differing in what type the subject and
-- the resulting clause have. There are four different types:
--
--* $SPred$ (declarative clause, from $NP$ to $Cl$),
--* $QPred$ (interrogative clause, from $IP$ to $QCl$),
--* $RPred$ (relative clause, from $RP$ to $RCl$),
--* $IPred$ (infinitive clause, from no subject to $VCl$).
--
-- The ultimate dependent type formalization of all the 4x12 rules is
--
-- (n : NType) -> (v : VType) -> Subj n -> Verb v -> Compl v -> Clause n
--
-- In the following, however, an expanded set of rules with no
-- dependent types is shown.
abstract Clause = Categories ** {
fun
SPredV : NP -> V -> Cl ; -- "John walks"
SPredPassV : NP -> V -> Cl ; -- "John is seen"
SPredV2 : NP -> V2 -> NP -> Cl ; -- "John sees Mary"
SPredV3 : NP -> V3 -> NP -> NP -> Cl ; -- "John tells Mary everything"
SPredReflV2 : NP -> V2 -> Cl ; -- "John loves himself"
SPredVS : NP -> VS -> S -> Cl ; -- "John says that Mary runs"
SPredVV : NP -> VV -> VPI -> Cl ; -- "John must walk"
SPredVQ : NP -> VQ -> QS -> Cl ; -- "John asks who will come"
SPredVA : NP -> VA -> AP -> Cl ; -- "John looks ill"
SPredV2A : NP -> V2A -> NP -> AP -> Cl ; -- "John paints the house red"
SPredSubjV2V : NP -> V2V -> NP -> VPI -> Cl ; -- "John promises Mary to leave"
SPredObjV2V : NP -> V2V -> NP -> VPI -> Cl ; -- "John asks me to come"
SPredV2S : NP -> V2S -> NP -> S -> Cl ; -- "John told me that it is good"
SPredV2Q : NP -> V2Q -> NP -> QS -> Cl ; -- "John asked me if it is good"
SPredAP : NP -> AP -> Cl ; -- "John is old"
SPredCN : NP -> CN -> Cl ; -- "John is a man"
SPredNP : NP -> NP -> Cl ; -- "John is Bill"
SPredAdv : NP -> Adv -> Cl ; -- "John is in France"
SPredProgVP : NP -> VPI -> Cl ; -- "he is eating"
QPredV : IP -> V -> QCl ; -- "who walks"
QPredPassV : IP -> V -> QCl ; -- "who is seen"
QPredV2 : IP -> V2 -> NP -> QCl ; -- "who sees Mary"
QPredV3 : IP -> V3 -> NP -> NP -> QCl ; -- "who gives Mary food"
QPredReflV2 : IP -> V2 -> QCl ; -- "who loves himself"
QPredVS : IP -> VS -> S -> QCl ; -- "who says that Mary runs"
QPredVV : IP -> VV -> VPI -> QCl ; -- "who must walk"
QPredVQ : IP -> VQ -> QS -> QCl ; -- "who asks who will come"
QPredVA : IP -> VA -> AP -> QCl ; -- "who looks ill"
QPredV2A : IP -> V2A -> NP ->AP ->QCl ; -- "who paints the house red"
QPredSubjV2V : IP -> V2V -> NP ->VPI ->QCl ; -- "who promises Mary to leave"
QPredObjV2V : IP -> V2V -> NP -> VPI -> QCl ; -- "who asks me to come"
QPredV2S : IP -> V2S -> NP -> S -> QCl ; -- "who told me that it is good"
QPredV2Q : IP -> V2Q -> NP -> QS -> QCl ; -- "who asked me if it is good"
QPredAP : IP -> AP -> QCl ; -- "who is old"
QPredCN : IP -> CN -> QCl ; -- "who is a man"
QPredNP : IP -> NP -> QCl ; -- "who is Bill"
QPredAdv : IP -> Adv -> QCl ; -- "who is in France"
QPredProgVP : IP -> VPI -> QCl ; -- "who is eating"
RPredV : RP -> V -> RCl ; -- "who walks"
RPredPassV : RP -> V -> RCl ; -- "who is seen"
RPredV2 : RP -> V2 -> NP -> RCl ; -- "who sees Mary"
RPredV3 : RP -> V3 -> NP -> NP -> RCl ; -- "who gives Mary food"
RPredReflV2 : RP -> V2 -> RCl ; -- "who loves himself"
RPredVS : RP -> VS -> S -> RCl ; -- "who says that Mary runs"
RPredVV : RP -> VV -> VPI -> RCl ; -- "who must walk"
RPredVQ : RP -> VQ -> QS -> RCl ; -- "who asks who will come"
RPredVA : RP -> VA -> AP -> RCl ; -- "who looks ill"
RPredV2A : RP -> V2A -> NP -> AP -> RCl ; -- "who paints the house red"
RPredSubjV2V : RP -> V2V -> NP -> VPI -> RCl ; -- "who promises Mary to leave"
RPredObjV2V : RP -> V2V -> NP -> VPI -> RCl ; -- "who asks me to come"
RPredV2S : RP -> V2S -> NP -> S -> RCl ; -- "who told me that it is good"
RPredV2Q : RP -> V2Q -> NP -> QS -> RCl ; -- "who asked me if it is good"
RPredAP : RP -> AP -> RCl ; -- "who is old"
RPredCN : RP -> CN -> RCl ; -- "who is a man"
RPredNP : RP -> NP -> RCl ; -- "who is Bill"
RPredAdv : RP -> Adv -> RCl ; -- "who is in France"
RPredProgVP : RP -> VPI -> RCl ; -- "who is eating"
IPredV : V -> VCl ; -- "walk"
IPredPassV : V -> VCl ; -- "be seen"
IPredV2 : V2 -> NP -> VCl ; -- "see Mary"
IPredV3 : V3 -> NP -> NP -> VCl ; -- "give Mary food"
IPredReflV2 : V2 -> VCl ; -- "love himself"
IPredVS : VS -> S -> VCl ; -- "say that Mary runs"
IPredVV : VV -> VPI -> VCl ; -- "want to walk"
IPredVQ : VQ -> QS -> VCl ; -- "ask who will come"
IPredVA : VA -> AP -> VCl ; -- "look ill"
IPredV2A : V2A -> NP -> AP -> VCl ; -- "paint the house red"
IPredSubjV2V : V2V -> NP -> VPI -> VCl ; -- "promise Mary to leave"
IPredObjV2V : V2V -> NP -> VPI -> VCl ; -- "ask me to come"
IPredV2S : V2S -> NP -> S -> VCl ; -- "tell me that it is good"
IPredV2Q : V2Q -> NP -> QS -> VCl ; -- "ask me if it is good"
IPredAP : AP -> VCl ; -- "be old"
IPredCN : CN -> VCl ; -- "be a man"
IPredNP : NP -> VCl ; -- "be Bill"
IPredAdv : Adv -> VCl ; -- "be in France"
IPredProgVP : VPI -> VCl ; -- "be eating"
{-
-- These rules *use* verb phrases.
PredVP : NP -> VP -> Cl ; -- "John walks"
RelVP : RP -> VP -> RCl ; -- "who walks", "who doesn't walk"
IntVP : IP -> VP -> QCl ; -- "who walks"
PosVP, NegVP : Ant -> VP -> VPI ; -- to eat, not to eat
AdvVP : VP -> AdV -> VP ; -- "always walks"
SubjVP : VP -> Subj -> S -> VP ; -- "(a man who) sings when he runs"
-}
} ;

111
lib/resource/abstract/ClauseI.gf
View File

@@ -1,111 +0,0 @@
--# -path=.:../abstract:../../prelude
incomplete concrete ClauseI of Clause = open Rules, Verbphrase in {
flags optimize=all_subs ;
lin
SPredV np v = PredVP np (UseV v) ;
SPredPassV np v = PredVP np (UsePassV v) ;
SPredV2 np v x = PredVP np (ComplV2 v x) ;
SPredV3 np v x y = PredVP np (ComplV3 v x y) ;
SPredReflV2 np v = PredVP np (ComplReflV2 v) ;
SPredVS np v x = PredVP np (ComplVS v x) ;
SPredVV np v x = PredVP np (ComplVV v x) ;
SPredVQ np v x = PredVP np (ComplVQ v x) ;
SPredVA np v x = PredVP np (ComplVA v x) ;
SPredV2A np v x y = PredVP np (ComplV2A v x y) ;
SPredSubjV2V np v x y = PredVP np (ComplSubjV2V v x y) ;
SPredObjV2V np v x y = PredVP np (ComplObjV2V v x y) ;
SPredV2S np v x y = PredVP np (ComplV2S v x y) ;
SPredV2Q np v x y = PredVP np (ComplV2Q v x y) ;
SPredAP np v = PredVP np (PredAP v) ;
SPredCN np v = PredVP np (PredCN v) ;
SPredNP np v = PredVP np (PredNP v) ;
SPredAdv np v = PredVP np (PredAdv v) ;
SPredProgVP np vp = PredVP np (PredProgVP vp) ;
QPredV np v = IntVP np (UseV v) ;
QPredPassV np v = IntVP np (UsePassV v) ;
QPredV2 np v x = IntVP np (ComplV2 v x) ;
QPredV3 np v x y = IntVP np (ComplV3 v x y) ;
QPredReflV2 np v = IntVP np (ComplReflV2 v) ;
QPredVS np v x = IntVP np (ComplVS v x) ;
QPredVV np v x = IntVP np (ComplVV v x) ;
QPredVQ np v x = IntVP np (ComplVQ v x) ;
QPredVA np v x = IntVP np (ComplVA v x) ;
QPredV2A np v x y = IntVP np (ComplV2A v x y) ;
QPredSubjV2V np v x y = IntVP np (ComplSubjV2V v x y) ;
QPredObjV2V np v x y = IntVP np (ComplObjV2V v x y) ;
QPredV2S np v x y = IntVP np (ComplV2S v x y) ;
QPredV2Q np v x y = IntVP np (ComplV2Q v x y) ;
QPredAP np v = IntVP np (PredAP v) ;
QPredCN np v = IntVP np (PredCN v) ;
QPredNP np v = IntVP np (PredNP v) ;
QPredAdv np v = IntVP np (PredAdv v) ;
QPredProgVP np vp = IntVP np (PredProgVP vp) ;
RPredV np v = RelVP np (UseV v) ;
RPredPassV np v = RelVP np (UsePassV v) ;
RPredV2 np v x = RelVP np (ComplV2 v x) ;
RPredV3 np v x y = RelVP np (ComplV3 v x y) ;
RPredReflV2 np v = RelVP np (ComplReflV2 v) ;
RPredVS np v x = RelVP np (ComplVS v x) ;
RPredVV np v x = RelVP np (ComplVV v x) ;
RPredVQ np v x = RelVP np (ComplVQ v x) ;
RPredVA np v x = RelVP np (ComplVA v x) ;
RPredV2A np v x y = RelVP np (ComplV2A v x y) ;
RPredSubjV2V np v x y = RelVP np (ComplSubjV2V v x y) ;
RPredObjV2V np v x y = RelVP np (ComplObjV2V v x y) ;
RPredV2S np v x y = RelVP np (ComplV2S v x y) ;
RPredV2Q np v x y = RelVP np (ComplV2Q v x y) ;
RPredAP np v = RelVP np (PredAP v) ;
RPredCN np v = RelVP np (PredCN v) ;
RPredNP np v = RelVP np (PredNP v) ;
RPredAdv np v = RelVP np (PredAdv v) ;
RPredProgVP np vp = RelVP np (PredProgVP vp) ;
IPredV v = UseVP (UseV v) ;
IPredV2 v x = UseVP (ComplV2 v x) ;
IPredPassV v = UseVP (UsePassV v) ;
IPredV3 v x y = UseVP (ComplV3 v x y) ;
IPredReflV2 v = UseVP (ComplReflV2 v) ;
IPredVS v x = UseVP (ComplVS v x) ;
IPredVV v x = UseVP (ComplVV v x) ;
IPredVQ v x = UseVP (ComplVQ v x) ;
IPredVA v x = UseVP (ComplVA v x) ;
IPredV2A v x y = UseVP (ComplV2A v x y) ;
IPredSubjV2V v x y = UseVP (ComplSubjV2V v x y) ;
IPredObjV2V v x y = UseVP (ComplObjV2V v x y) ;
IPredV2S v x y = UseVP (ComplV2S v x y) ;
IPredV2Q v x y = UseVP (ComplV2Q v x y) ;
IPredAP v = UseVP (PredAP v) ;
IPredCN v = UseVP (PredCN v) ;
IPredNP v = UseVP (PredNP v) ;
IPredAdv v = UseVP (PredAdv v) ;
IPredProgVP vp = UseVP (PredProgVP vp) ;
{-
-- Use VPs
IntVP = intVerbPhrase ;
RelVP = relVerbPhrase ;
PosVP tp = predVerbGroup True tp.a ;
NegVP tp = predVerbGroup False tp.a ;
AdvVP = adVerbPhrase ;
SubjVP = subjunctVerbPhrase ;
-}
}

113
lib/resource/abstract/ClausePredI.gf
View File

@@ -1,113 +0,0 @@
--# -path=.:../abstract:../../prelude
incomplete concrete ClausePredI of Clause = open Predic in {
flags optimize=all ;
lin
SPredV np v = SPredVerb Vt_ np (UseV1 v) ComplNil ;
SPredV2 np v x = SPredVerb (Vt CtN) np (UseV2 v) (ComplNP x) ;
---- SPredV3 np v x y = SPredVerb (VtN CtN) np (UseV3 v) (ComplAdd (Vt CtN) x (ComplNP y)) ;
---- SPredVS np v x = SPredVerb (Vt CtS) np (UseVS v) (ComplS x) ;
-- SPredPassV np v = PredVP np (UsePassV v) ;
-- SPredReflV2 np v = PredVP np (ComplReflV2 v) ;
{-
SPredVV np v x = PredVP np (ComplVV v x) ;
SPredVQ np v x = PredVP np (ComplVQ v x) ;
SPredVA np v x = PredVP np (ComplVA v x) ;
SPredV2A np v x y = PredVP np (ComplV2A v x y) ;
SPredSubjV2V np v x y = PredVP np (ComplSubjV2V v x y) ;
SPredObjV2V np v x y = PredVP np (ComplObjV2V v x y) ;
SPredV2S np v x y = PredVP np (ComplV2S v x y) ;
SPredV2Q np v x y = PredVP np (ComplV2Q v x y) ;
SPredAP np v = PredVP np (PredAP v) ;
SPredCN np v = PredVP np (PredCN v) ;
SPredNP np v = PredVP np (PredNP v) ;
SPredAdv np v = PredVP np (PredAdv v) ;
SPredProgVP np vp = PredVP np (PredProgVP vp) ;
QPredV np v = IntVP np (UseV v) ;
QPredPassV np v = IntVP np (UsePassV v) ;
QPredV2 np v x = IntVP np (ComplV2 v x) ;
QPredV3 np v x y = IntVP np (ComplV3 v x y) ;
QPredReflV2 np v = IntVP np (ComplReflV2 v) ;
QPredVS np v x = IntVP np (ComplVS v x) ;
QPredVV np v x = IntVP np (ComplVV v x) ;
QPredVQ np v x = IntVP np (ComplVQ v x) ;
QPredVA np v x = IntVP np (ComplVA v x) ;
QPredV2A np v x y = IntVP np (ComplV2A v x y) ;
QPredSubjV2V np v x y = IntVP np (ComplSubjV2V v x y) ;
QPredObjV2V np v x y = IntVP np (ComplObjV2V v x y) ;
QPredV2S np v x y = IntVP np (ComplV2S v x y) ;
QPredV2Q np v x y = IntVP np (ComplV2Q v x y) ;
QPredAP np v = IntVP np (PredAP v) ;
QPredCN np v = IntVP np (PredCN v) ;
QPredNP np v = IntVP np (PredNP v) ;
QPredAdv np v = IntVP np (PredAdv v) ;
QPredProgVP np vp = IntVP np (PredProgVP vp) ;
RPredV np v = RelVP np (UseV v) ;
RPredPassV np v = RelVP np (UsePassV v) ;
RPredV2 np v x = RelVP np (ComplV2 v x) ;
RPredV3 np v x y = RelVP np (ComplV3 v x y) ;
RPredReflV2 np v = RelVP np (ComplReflV2 v) ;
RPredVS np v x = RelVP np (ComplVS v x) ;
RPredVV np v x = RelVP np (ComplVV v x) ;
RPredVQ np v x = RelVP np (ComplVQ v x) ;
RPredVA np v x = RelVP np (ComplVA v x) ;
RPredV2A np v x y = RelVP np (ComplV2A v x y) ;
RPredSubjV2V np v x y = RelVP np (ComplSubjV2V v x y) ;
RPredObjV2V np v x y = RelVP np (ComplObjV2V v x y) ;
RPredV2S np v x y = RelVP np (ComplV2S v x y) ;
RPredV2Q np v x y = RelVP np (ComplV2Q v x y) ;
RPredAP np v = RelVP np (PredAP v) ;
RPredCN np v = RelVP np (PredCN v) ;
RPredNP np v = RelVP np (PredNP v) ;
RPredAdv np v = RelVP np (PredAdv v) ;
RPredProgVP np vp = RelVP np (PredProgVP vp) ;
IPredV v = UseVP (UseV v) ;
IPredV2 v x = UseVP (ComplV2 v x) ;
IPredPassV v = UseVP (UsePassV v) ;
IPredV3 v x y = UseVP (ComplV3 v x y) ;
IPredReflV2 v = UseVP (ComplReflV2 v) ;
IPredVS v x = UseVP (ComplVS v x) ;
IPredVV v x = UseVP (ComplVV v x) ;
IPredVQ v x = UseVP (ComplVQ v x) ;
IPredVA v x = UseVP (ComplVA v x) ;
IPredV2A v x y = UseVP (ComplV2A v x y) ;
IPredSubjV2V v x y = UseVP (ComplSubjV2V v x y) ;
IPredObjV2V v x y = UseVP (ComplObjV2V v x y) ;
IPredV2S v x y = UseVP (ComplV2S v x y) ;
IPredV2Q v x y = UseVP (ComplV2Q v x y) ;
IPredAP v = UseVP (PredAP v) ;
IPredCN v = UseVP (PredCN v) ;
IPredNP v = UseVP (PredNP v) ;
IPredAdv v = UseVP (PredAdv v) ;
IPredProgVP vp = UseVP (PredProgVP vp) ;
-}
{-
-- Use VPs
IntVP = intVerbPhrase ;
RelVP = relVerbPhrase ;
PosVP tp = predVerbGroup True tp.a ;
NegVP tp = predVerbGroup False tp.a ;
AdvVP = adVerbPhrase ;
SubjVP = subjunctVerbPhrase ;
-}
}

114
lib/resource/abstract/ClauseVP.gf
View File

@@ -1,114 +0,0 @@
--# -path=.:../abstract:../../prelude
abstract ClauseVP = Rules, Clause, Verbphrase ** {
fun
trCl : Cl -> Cl ;
trQCl : QCl -> QCl ;
trRCl : RCl -> RCl ;
trVCl : VCl -> VCl ;
def
trCl (SPredV np v) = PredVP np (UseV v) ;
trCl (SPredPassV np v) = PredVP np (UsePassV v) ;
trCl (SPredV2 np v x) = PredVP np (ComplV2 v x) ;
trCl (SPredV3 np v x y) = PredVP np (ComplV3 v x y) ;
trCl (SPredReflV2 np v) = PredVP np (ComplReflV2 v) ;
trCl (SPredVS np v x) = PredVP np (ComplVS v x) ;
trCl (SPredVV np v x) = PredVP np (ComplVV v x) ;
trCl (SPredVQ np v x) = PredVP np (ComplVQ v x) ;
trCl (SPredVA np v x) = PredVP np (ComplVA v x) ;
trCl (SPredV2A np v x y) = PredVP np (ComplV2A v x y) ;
trCl (SPredSubjV2V np v x y) = PredVP np (ComplSubjV2V v x y) ;
trCl (SPredObjV2V np v x y) = PredVP np (ComplObjV2V v x y) ;
trCl (SPredV2S np v x y) = PredVP np (ComplV2S v x y) ;
trCl (SPredV2Q np v x y) = PredVP np (ComplV2Q v x y) ;
trCl (SPredAP np v) = PredVP np (PredAP v) ;
trCl (SPredCN np v) = PredVP np (PredCN v) ;
trCl (SPredNP np v) = PredVP np (PredNP v) ;
trCl (SPredAdv np v) = PredVP np (PredAdv v) ;
trCl (SPredProgVP np vp) = PredVP np (PredProgVP vp) ;
trQCl (QPredV np v) = IntVP np (UseV v) ;
trQCl (QPredPassV np v) = IntVP np (UsePassV v) ;
trQCl (QPredV2 np v x) = IntVP np (ComplV2 v x) ;
trQCl (QPredV3 np v x y) = IntVP np (ComplV3 v x y) ;
trQCl (QPredReflV2 np v) = IntVP np (ComplReflV2 v) ;
trQCl (QPredVS np v x) = IntVP np (ComplVS v x) ;
trQCl (QPredVV np v x) = IntVP np (ComplVV v x) ;
trQCl (QPredVQ np v x) = IntVP np (ComplVQ v x) ;
trQCl (QPredVA np v x) = IntVP np (ComplVA v x) ;
trQCl (QPredV2A np v x y) = IntVP np (ComplV2A v x y) ;
trQCl (QPredSubjV2V np v x y) = IntVP np (ComplSubjV2V v x y) ;
trQCl (QPredObjV2V np v x y) = IntVP np (ComplObjV2V v x y) ;
trQCl (QPredV2S np v x y) = IntVP np (ComplV2S v x y) ;
trQCl (QPredV2Q np v x y) = IntVP np (ComplV2Q v x y) ;
trQCl (QPredAP np v) = IntVP np (PredAP v) ;
trQCl (QPredCN np v) = IntVP np (PredCN v) ;
trQCl (QPredNP np v) = IntVP np (PredNP v) ;
trQCl (QPredAdv np v) = IntVP np (PredAdv v) ;
trQCl (QPredProgVP np vp) = IntVP np (PredProgVP vp) ;
trRCl (RPredV np v) = RelVP np (UseV v) ;
trRCl (RPredPassV np v) = RelVP np (UsePassV v) ;
trRCl (RPredV2 np v x) = RelVP np (ComplV2 v x) ;
trRCl (RPredV3 np v x y) = RelVP np (ComplV3 v x y) ;
trRCl (RPredReflV2 np v) = RelVP np (ComplReflV2 v) ;
trRCl (RPredVS np v x) = RelVP np (ComplVS v x) ;
trRCl (RPredVV np v x) = RelVP np (ComplVV v x) ;
trRCl (RPredVQ np v x) = RelVP np (ComplVQ v x) ;
trRCl (RPredVA np v x) = RelVP np (ComplVA v x) ;
trRCl (RPredV2A np v x y) = RelVP np (ComplV2A v x y) ;
trRCl (RPredSubjV2V np v x y) = RelVP np (ComplSubjV2V v x y) ;
trRCl (RPredObjV2V np v x y) = RelVP np (ComplObjV2V v x y) ;
trRCl (RPredV2S np v x y) = RelVP np (ComplV2S v x y) ;
trRCl (RPredV2Q np v x y) = RelVP np (ComplV2Q v x y) ;
trRCl (RPredAP np v) = RelVP np (PredAP v) ;
trRCl (RPredCN np v) = RelVP np (PredCN v) ;
trRCl (RPredNP np v) = RelVP np (PredNP v) ;
trRCl (RPredAdv np v) = RelVP np (PredAdv v) ;
trRCl (RPredProgVP np vp) = RelVP np (PredProgVP vp) ;
trVCl (IPredV v) = UseVP (UseV v) ;
trVCl (IPredV2 v x) = UseVP (ComplV2 v x) ;
trVCl (IPredPassV v) = UseVP (UsePassV v) ;
trVCl (IPredV3 v x y) = UseVP (ComplV3 v x y) ;
trVCl (IPredReflV2 v) = UseVP (ComplReflV2 v) ;
trVCl (IPredVS v x) = UseVP (ComplVS v x) ;
trVCl (IPredVV v x) = UseVP (ComplVV v x) ;
trVCl (IPredVQ v x) = UseVP (ComplVQ v x) ;
trVCl (IPredVA v x) = UseVP (ComplVA v x) ;
trVCl (IPredV2A v x y) = UseVP (ComplV2A v x y) ;
trVCl (IPredSubjV2V v x y) = UseVP (ComplSubjV2V v x y) ;
trVCl (IPredObjV2V v x y) = UseVP (ComplObjV2V v x y) ;
trVCl (IPredV2S v x y) = UseVP (ComplV2S v x y) ;
trVCl (IPredV2Q v x y) = UseVP (ComplV2Q v x y) ;
trVCl (IPredAP v) = UseVP (PredAP v) ;
trVCl (IPredCN v) = UseVP (PredCN v) ;
trVCl (IPredNP v) = UseVP (PredNP v) ;
trVCl (IPredAdv v) = UseVP (PredAdv v) ;
trVCl (IPredProgVP vp) = UseVP (PredProgVP vp) ;
{-
-- Use VPs
trRCl (IntVP) = intVerbPhrase ;
trRCl (RelVP) = relVerbPhrase ;
trRCl (PosVP tp) = predVerbGroup True tp.a ;
trRCl (NegVP tp) = predVerbGroup False tp.a ;
trRCl (AdvVP) = adVerbPhrase ;
trRCl (SubjVP) = subjunctVerbPhrase ;
-}
}

61
lib/resource/abstract/Common.gf Normal file
View File

@@ -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 conj. 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: present, past, future, conditional
Pol ; -- polarity: positive, negative
Ant ; -- anteriority: 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
}

52
lib/resource/abstract/Conjunction.gf Normal file
View File

@@ -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].

23
lib/resource/abstract/Country.gf
View File

@@ -1,23 +0,0 @@
abstract Country = {
cat
Country ; Nationality ; Language ;
fun
Denmark,
England,
Finland,
France,
Germany,
Italy,
Norway,
Russia,
Spain,
Sweden
: Country ;
Danish,
English
: Nationality ;
DanishLang,
EnglishLang
: Language ;
} ;

56
lib/resource/abstract/DemRes.gf
View File

@@ -1,56 +0,0 @@
interface DemRes = open Prelude, Resource in {
oper
Pointing = {s5 : Str} ;
noPointing : Pointing = {s5 = []} ;
mkDemS : Cl -> DemAdverb -> Pointing -> MultiSentence = \cl,adv,p ->
{s = table {
MInd b => msS (UseCl (polar b) (AdvCl cl adv)) ;
MQuest b => msQS (UseQCl (polar b) (QuestCl (AdvCl cl adv)))
} ;
s5 = p.s5 ++ adv.s5
} ;
polar : Bool -> TP = \b -> case b of {
True => PosTP TPresent ASimul ;
False => NegTP TPresent ASimul
} ;
mkDemQ : QCl -> DemAdverb -> Pointing -> MultiQuestion = \cl,adv,p ->
{s = \\b => msQS (UseQCl (polar b) cl) ++ adv.s ; --- (AdvQCl cl adv)) ;
s5 = p.s5 ++ adv.s5
} ;
mkDemImp : VCl -> DemAdverb -> Pointing -> MultiImperative = \cl,adv,p ->
{s = table {
True => msImp (PosImpVP cl) ++ adv.s ;
False => msImp (NegImpVP cl) ++ adv.s
} ;
s5 = p.s5 ++ adv.s5
} ;
msS : S -> Str ;
msQS : QS -> Str ;
msImp : Imp -> Str ;
concatDem : (x,y : Pointing) -> Pointing = \x,y -> {
s5 = x.s5 ++ y.s5
} ;
mkDemType : Type -> Type = \t -> t ** Pointing ;
MultiSentence : Type = mkDemType {s : MSForm => Str} ;
MultiQuestion : Type = mkDemType {s : Bool => Str} ;
MultiImperative : Type = mkDemType {s : Bool => Str} ;
Demonstrative : Type = mkDemType NP ;
DemAdverb : Type = mkDemType Adv ;
mkDAdv : Adv -> Pointing -> DemAdverb = \a,p ->
a ** p ** {lock_Adv = a.lock_Adv} ;
param
MSForm = MInd Bool | MQuest Bool ;
}

44
lib/resource/abstract/Demonstrative.gf
View File

@@ -1,44 +0,0 @@
abstract Demonstrative = Categories ** {
cat
MS ; -- multimodal sentence or question
MQS ; -- multimodal wh question
MImp ; -- multimodal imperative
DNP ; -- demonstrative noun phrase
DAdv ; -- demonstrative adverbial
[DAdv] ; -- list of demonstrative adverbials
Point ; -- pointing gesture
fun
MkPoint : String -> Point ;
DemV : V -> DNP -> [DAdv] -> MS ; -- this flies (here)
DemV2 : V2 -> DNP -> DNP -> [DAdv] -> MS ; -- this takes that
ModDemV : VV -> V -> DNP -> [DAdv] -> MS ; -- this wants to fly
ModDemV2 : VV -> V2 -> DNP -> DNP -> [DAdv] -> MS ; -- this wants to take that
ImpDemV : V -> [DAdv] -> MImp ; -- fly (here)
ImpDemV2 : V2 -> DNP -> [DAdv] -> MImp ; -- take that
QDemV : V -> IP -> [DAdv] -> MQS ; -- who flies (here)
QDemV2 : V2 -> IP -> DNP -> [DAdv] -> MQS ; -- who takes that
QDemSlashV2 : V2 -> DNP -> IP -> [DAdv] -> MQS ; -- whom does that take
QModDemV : VV -> V -> IP -> [DAdv] -> MQS ; -- who wants to fly (here)
QModDemV2 : VV -> V2 -> IP -> DNP -> [DAdv] -> MQS ; -- who wants to take that
QModDemSlashV2 : VV -> V2 -> DNP -> IP -> [DAdv] -> MQS ; -- whom does that want to take
this_DNP : Point -> DNP ; -- this
that_DNP : Point -> DNP ; -- that
thisDet_DNP : Point -> CN -> DNP ; -- this car
thatDet_DNP : Point -> CN -> DNP ; -- that car
here_DAdv : Point -> DAdv ; -- here
here7from_DAdv : Point -> DAdv ; -- from here
here7to_DAdv : Point -> DAdv ; -- to here
PrepDNP : Prep -> DNP -> DAdv ;
-- to test
point1, point2 : Point ;
}

62
lib/resource/abstract/DemonstrativeI.gf
View File

@@ -1,62 +0,0 @@
--# -path=.:../abstract:../../prelude
incomplete concrete DemonstrativeI of Demonstrative =
open Prelude, Resource, Basic, DemRes in {
lincat
MS = MultiSentence ;
MQS = MultiQuestion ;
MImp = MultiImperative ;
DNP = Demonstrative ;
DAdv = DemAdverb ;
[DAdv] = DemAdverb ;
Point = Pointing ;
lin
MkPoint s = {s5 = s.s} ;
DemV verb dem adv =
mkDemS (SPredV dem verb) adv dem ;
DemV2 verb su ob adv =
mkDemS (SPredV2 su verb ob) adv (concatDem su ob) ;
ModDemV vv verb dem adv =
mkDemS (SPredVV dem vv (UseVCl PPos ASimul (IPredV verb))) adv dem ;
ModDemV2 vv verb su ob adv =
mkDemS (SPredVV su vv (UseVCl PPos ASimul (IPredV2 verb ob))) adv (concatDem su ob) ;
ImpDemV verb adv =
mkDemImp (IPredV verb) adv noPointing ;
ImpDemV2 verb ob adv =
mkDemImp (IPredV2 verb ob) adv ob ;
QDemV verb ip adv =
mkDemQ (QPredV ip verb) adv noPointing ;
QDemV2 verb ip ob adv =
mkDemQ (QPredV2 ip verb ob) adv ob ;
QDemSlashV2 verb su ip adv =
mkDemQ (IntSlash ip (SlashV2 su verb)) adv su ;
QModDemV vv verb ip adv =
mkDemQ (QPredVV ip vv (UseVCl PPos ASimul (IPredV verb))) adv noPointing ;
QModDemV2 vv verb ip ob adv =
mkDemQ (QPredVV ip vv (UseVCl PPos ASimul (IPredV2 verb ob))) adv ob ;
QModDemSlashV2 vv verb su ip adv =
mkDemQ (IntSlash ip (SlashVV2 su vv verb)) adv su ;
this_DNP p = this_NP ** p ;
that_DNP p = that_NP ** p ;
thisDet_DNP p cn = DetNP this_Det cn ** p ;
thatDet_DNP p cn = DetNP that_Det cn ** p ;
here_DAdv p = mkDAdv here_Adv p ;
here7from_DAdv p = mkDAdv here7from_Adv p ;
here7to_DAdv p = mkDAdv here7to_Adv p ;
BaseDAdv = {s,s5 = [] ; lock_Adv = <>} ;
ConsDAdv a as = {s = a.s ++ as.s ; s5 = a.s5 ++ as.s5 ; lock_Adv = <>} ;
PrepDNP p np = mkDAdv (AdvPP (PrepNP p np)) np ;
point1 = {s5 = "p1"} ;
point2 = {s5 = "p2"} ;
}

30
lib/resource/abstract/Extra.gf Normal file
View File

@@ -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 ;
}

21
lib/resource/abstract/Grammar.gf Normal file
View File

@@ -0,0 +1,21 @@
--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
** {} ;

22
lib/resource/abstract/Idiom.gf Normal file
View File

@@ -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
}

38
lib/resource/abstract/Lang.gf
View File

@@ -1,31 +1,11 @@
--# -path=.:../../prelude
--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 =
Rules,
Clause,
Structural,
Basic,
Time,
Country,
Math
** {
flags startcat=Phr ;
fun
-- Mount $Time$.
AdvDate : Date -> Adv ;
AdvTime : Time -> Adv ;
NWeekday : Weekday -> N ;
PNWeekday : Weekday -> PN ;
-- Mount $Country$.
PNCountry : Country -> PN ;
ANationality : Nationality -> A ;
NLanguage : Language -> N ;
}
Grammar,
Lexicon
** {} ;

13
lib/resource/abstract/LangVP.gf
View File

@@ -1,13 +0,0 @@
--# -path=.:../abstract:../../prelude
-- alternative API that is able to return VP's by parsing with Cl
-- constructors and then computing. AR 14/11/2005
--
-- to import: 'i -noparse=vp.gfnoparse LangVPEng'
-- to use: 'p -cat=Cl "I see her" | wt -c trCl'
abstract LangVP =
Lang,
Verbphrase,
ClauseVP ** {
} ;

241
lib/resource/abstract/Basic.gf → lib/resource/abstract/Lexicon.gf
View File

@@ -1,33 +1,47 @@
abstract Basic = Categories ** {
fun
abstract Lexicon = Cat ** {
fun
add_V3 : V3 ;
airplane_N : N ;
answer_V2S : V2S ;
already_Adv : Adv ;
animal_N : N ;
answer_V2S : V2 ;
apartment_N : N ;
apple_N : N ;
art_N : N ;
ask_V2Q : V2Q ;
ashes_N : N ;
ask_V2Q : V2 ;
baby_N : N ;
bad_ADeg : ADeg ;
back_N : N ;
bad_A : A ;
bank_N : N ;
beautiful_ADeg : ADeg ;
bark_N : N ;
beautiful_A : A ;
become_VA : VA ;
beer_N : N ;
beg_V2V : V2V ;
big_ADeg : ADeg ;
beg_V2V : V2 ;
belly_N : N ;
big_A : A ;
bike_N : N ;
bird_N : N ;
black_ADeg : ADeg ;
blue_ADeg : ADeg ;
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 ;
broad_ADeg : ADeg ;
breast_N : N ;
breathe_V : V ;
broad_A : A ;
brother_N2 : N2 ;
brown_ADeg : ADeg ;
brown_A : A ;
burn_V : V ;
butter_N : N ;
buy_V2 : V2 ;
camera_N : N ;
@@ -41,183 +55,298 @@ abstract Basic = Categories ** {
child_N : N ;
church_N : N ;
city_N : N ;
clean_ADeg : ADeg ;
clever_ADeg : ADeg ;
clean_A : A ;
clever_A : A ;
close_V2 : V2 ;
cloud_N : N ;
coat_N : N ;
cold_ADeg : ADeg ;
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 ;
dirty_ADeg : ADeg ;
dig_V : V ;
dirty_A : A ;
distance_N3 : N3 ;
doctor_N : N ;
dog_N : N ;
door_N : N ;
do_V2 : V2 ;
drink_V2 : V2 ;
easy_A2V : A2V ;
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 ;
empty_ADeg : ADeg ;
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 ;
fun_AV : AV ;
full_A : A ;
fun
fun_AV : A ;
garden_N : N ;
girl_N : N ;
give_V3 : V3 ;
glove_N : N ;
gold_N : N ;
good_ADeg : ADeg ;
good_A : A ;
go_V : V ;
green_ADeg : ADeg ;
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_ADeg : ADeg ;
hot_A : A ;
house_N : N ;
important_ADeg : ADeg ;
hunt_V2 : V2 ;
husband_N : N ;
ice_N : N ;
important_A : A ;
industry_N : N ;
iron_N : N ;
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_ADeg : ADeg ;
long_A : A ;
lose_V2 : V2 ;
louse_N : N ;
love_N : N ;
love_V2 : V2 ;
man_N : N ;
married_A2 : A2 ;
meat_N : N ;
meat_N : N ;
milk_N : N ;
moon_N : N ;
mother_N2 : N2 ;
mountain_N : N ;
mouth_N : N ;
music_N : N ;
narrow_ADeg : ADeg ;
new_ADeg : ADeg ;
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_ADeg : ADeg ;
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 : AS ;
probable_AS : A ;
pull_V2 : V2 ;
push_V2 : V2 ;
put_V2 : V2 ;
queen_N : N ;
radio_N : N ;
rain_V0 : V0 ;
rain_N : N ;
rain_V0 : V ;
read_V2 : V2 ;
red_ADeg : ADeg ;
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_ADeg : ADeg ;
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_ADeg : ADeg ;
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_ADeg : ADeg ;
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_ADeg : ADeg ;
thin_ADeg : ADeg ;
thick_A : A ;
thin_A : A ;
think_V : V ;
throw_V2 : V2 ;
tie_V2 : V2 ;
tongue_N : N ;
tooth_N : N ;
train_N : N ;
travel_V : V ;
tree_N : N ;
---- trousers_N : N ;
ugly_ADeg : ADeg ;
turn_V : V ;
ugly_A : A ;
understand_V2 : V2 ;
university_N : N ;
village_N : N ;
vomit_V : V ;
wait_V2 : V2 ;
walk_V : V ;
warm_ADeg : ADeg ;
warm_A : A ;
war_N : N ;
wash_V2 : V2 ;
watch_V2 : V2 ;
water_N : N ;
white_ADeg : ADeg ;
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 ;
yellow_ADeg : ADeg ;
young_ADeg : ADeg ;
year_N : N ;
yellow_A : A ;
young_A : A ;
do_V2 : V2 ;
now_Adv : Adv ;
already_Adv : Adv ;
song_N : N ;
add_V3 : V3 ;
number_N : N ;
put_V2 : V2 ;
stop_V : V ;
jump_V : V ;
here_Adv : Adv ;
here7to_Adv : Adv ;
here7from_Adv : Adv ;
there_Adv : Adv ;
there7to_Adv : Adv ;
there7from_Adv : Adv ;
}

53
lib/resource/abstract/Math.gf
View File

@@ -1,53 +0,0 @@
abstract Math = Categories ** {
--3 Noun phrases with symbols
fun
SymbPN : String -> PN ; -- "x"
IntPN : Int -> PN ; -- "27"
IntNP : CN -> Int -> NP ; -- "level 53"
IndefSymbNumNP : Num -> CN -> SymbList -> NP ; -- "(2) numbers x and y"
DefSymbNumNP : Num -> CN -> SymbList -> NP ; -- "the (2) numbers x and y"
NDetSymbNP : NDet -> Num -> CN -> SymbList -> NP ; -- "some (3) points x, y and z"
--3 Symbol lists
-- A symbol list has at least two elements. The last two are separated
-- by a conjunction ("and" in English), the others by commas.
-- This produces "x, y and z", in English.
cat
SymbList ;
fun
SymbTwo : String -> String -> SymbList ;
SymbMore : String -> SymbList -> SymbList ;
--3 Special forms of expression
-- This expression form is typical of mathematical texts.
-- It is realized with different constructs in different languages, typically
-- some kind of 3rd person imperative of the verb "be".
LetImp : NP -> NP -> Imp ; -- let x be a number
-- This rule is slightly overgenerating: "there exists every number x".
-- The problem seems to be of semantic nature. By this we avoid having many rules.
ExistNP : NP -> Cl ; -- there exist (2) number(s) x and y
--3 Rules moved from $Rules$.
-- This rule is powerful but overgenerating.
SymbCN : CN -> String -> CN ; -- "number x"
-- This rule is simply wrong, and will be deprecated: the correct
-- value type is $NP$.
IntCN : CN -> Int -> CN ; -- "level 53"
}

43
lib/resource/abstract/Minimal.gf
View File

@@ -1,43 +0,0 @@
--# -path=.:../../prelude
abstract Minimal = Categories ** {
-- a minimum sample of lexicon to test resource grammar with
fun
-- nouns: count and mass, relational
man_N : N ;
wine_N : N ;
mother_N2 : N2 ;
distance_N3 : N3 ;
-- proper names
john_PN : PN ;
-- adjectives: with and without degree
blue_ADeg : ADeg ;
american_A : A ;
-- adjectives: noun phase, sentence, and verb complements
married_A2 : A2 ;
probable_AS : AS ;
important_A2S : A2S ;
easy_A2V : A2V ;
-- adverbs
now_Adv : Adv ;
-- verbs
walk_V : V ;
love_V2 : V2 ;
give_V3 : V3 ;
believe_VS : VS ;
try_VV : VV ;
wonder_VQ : VQ ;
become_VA : VA ;
paint_V2A : V2A ;
promise_V2V : V2V ;
ask_V2Q : V2Q ;
tell_V2S : V2S ;
rain_V0 : V0 ;
} ;

30
lib/resource/abstract/Multimodal.gf
View File

@@ -1,30 +0,0 @@
--# -path=.:../../prelude
abstract Multimodal =
Rules,
Structural,
Basic,
Time,
Demonstrative
** {
flags startcat=Phr ;
fun
-- Interface to $Demonstrative$.
DemNP : NP -> DNP ;
DemAdv : Adv -> DAdv ;
SentMS : Pol -> MS -> Phr ;
QuestMS : Pol -> MS -> Phr ;
QuestMQS : Pol -> MQS -> Phr ;
ImpMImp : Pol -> MImp -> Phr ;
-- Mount $Time$.
AdvDate : Date -> Adv ;
AdvTime : Time -> Adv ;
}

16
lib/resource/abstract/MultimodalI.gf
View File

@@ -1,16 +0,0 @@
incomplete concrete MultimodalI of Multimodal =
open Prelude, Resource, Basic, Lang, DemRes in {
lin
DemNP np = np ** {s5 = [] ; lock_NP = <>} ;
DemAdv adv = mkDAdv (adv ** {lock_Adv = <>}) {s5 = []} ;
SentMS p ms = {s = p.s ++ ms.s ! MInd (p.p) ++ ";" ++ ms.s5} ;
QuestMS p ms = {s = p.s ++ ms.s ! MQuest (p.p) ++ ";" ++ ms.s5} ;
QuestMQS p ms = {s = p.s ++ ms.s ! p.p ++ ";" ++ ms.s5} ;
ImpMImp p ms = {s = p.s ++ ms.s ! p.p ++ ";" ++ ms.s5} ;
AdvDate = AdvDate ;
AdvTime = AdvTime ;
}

134
lib/resource/abstract/Noun.gf Normal file
View File

@@ -0,0 +1,134 @@
--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 : QuantSg -> Ord -> Det ; -- this best man
DetPl : QuantPl -> Num -> Ord -> Det ; -- these five best men
-- Quantifiers that have both forms can be used in both ways.
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
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
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 : QuantSg ; -- (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
} ;

23
lib/resource/abstract/Numerals.gf → lib/resource/abstract/Numeral.gf
View File

@@ -1,11 +1,25 @@
-- numerals from 1 to 999999 in decimal notation
--1 Numerals
abstract 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.
flags startcat=Numeral ;
abstract Numeral = Cat ** {
cat
Numeral ; -- 0..
Digit ; -- 2..9
Sub10 ; -- 1..9
Sub100 ; -- 1..99
@@ -31,4 +45,5 @@ fun
pot2as3 : Sub1000 -> Sub1000000 ; -- coercion of 1..999
pot3 : Sub1000 -> Sub1000000 ; -- m * 1000
pot3plus : Sub1000 -> Sub1000 -> Sub1000000 ; -- m * 1000 + n
}

43
lib/resource/abstract/Phrase.gf Normal file
View File

@@ -0,0 +1,43 @@
--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
-- 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
}

44
lib/resource/abstract/Predic.gf
View File

@@ -1,44 +0,0 @@
abstract Predic = Categories ** {
cat
VType ;
CType ;
Verb VType ;
Compl VType ;
fun
Vt_ : VType ;
Vt : CType -> VType ;
VtN : CType -> VType ;
CtN, CtS, CtV, CtQ, CtA : CType ;
SPredVerb : (v : VType) -> NP -> Verb v -> Compl v -> Cl ;
QPredVerb : (v : VType) -> IP -> Verb v -> Compl v -> QCl ;
RPredVerb : (v : VType) -> RP -> Verb v -> Compl v -> RCl ;
IPredVerb : (v : VType) -> Verb v -> Compl v -> VCl ;
Compl_ : Compl Vt_ ;
ComplN : NP -> Compl (Vt CtN) ;
ComplS : S -> Compl (Vt CtS) ;
ComplQ : QS -> Compl (Vt CtQ) ;
ComplA : AP -> Compl (Vt CtQ) ;
ComplAdd : (c : CType) -> NP -> Compl (Vt c) -> Compl (VtN c) ;
VeV1 : V -> Verb Vt_ ;
VeV2 : V2 -> Verb (Vt CtN) ;
VeVS : VS -> Verb (Vt CtS) ;
VeV3 : V3 -> Verb (VtN CtN) ;
VeV2S : V2S -> Verb (VtN CtS) ;
VeV2Q : V2Q -> Verb (VtN CtQ) ;
---- etc
}
{-
MkSlash3 : NG NtS -> VG (VtN CtN) -> CG (Vt CtN) -> Slash ;
MkSlash2 : (c : CType) -> NG NtS -> VG (VtN c) -> CG (Vt c) -> Slash ;
MkSlash1 : NG NtS -> VG (Vt CtN) -> Slash ;
SlashQ : NG NtQ -> Slash -> SG NtQ ;
-}

29
lib/resource/abstract/Question.gf Normal file
View File

@@ -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].
}

26
lib/resource/abstract/Relative.gf Normal file
View File

@@ -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
}

3
lib/resource/abstract/Resource.gf
View File

@@ -1,3 +0,0 @@
--# -path=.:../../prelude
abstract Resource = Rules, Clause, Structural ** {} ;

243
lib/resource/abstract/Rules.gf
View File

@@ -1,243 +0,0 @@
--!
--2 Rules
--
-- This set of rules is minimal, in the sense of defining the simplest combinations
-- of categories and not having redundant rules.
-- When the resource grammar is used as a library, it will often be useful to
-- access it through an intermediate library that defines more rules as
-- 'macros' for combinations of the ones below.
abstract Rules = Categories ** {
--!
--3 Nouns and noun phrases
--
fun
UseN : N -> CN ; -- "car"
UsePN : PN -> NP ; -- "John"
-- These three rules have been moved to the module $Math$.
{-
SymbPN : String -> PN ; -- "x"
SymbCN : CN -> String -> CN ; -- "number x"
IntCN : CN -> Int -> CN ; -- "number 53"
-}
IndefOneNP : CN -> NP ; -- "a car", "cars"
IndefNumNP : Num -> CN -> NP ; -- "houses", "86 houses"
DefOneNP : CN -> NP ; -- "the car"
DefNumNP : Num -> CN -> NP ; -- "the cars", "the 86 cars"
DetNP : Det -> CN -> NP ; -- "every car"
NDetNP : NDet -> Num -> CN -> NP ; -- "these (5) cars"
NDetNum : NDet -> Num -> NP ; -- "these (5)"
MassNP : CN -> NP ; -- "wine"
AppN2 : N2 -> NP -> CN ; -- "successor of zero"
AppN3 : N3 -> NP -> N2 ; -- "flight from Paris"
UseN2 : N2 -> CN ; -- "successor"
ModAP : AP -> CN -> CN ; -- "red car"
CNthatS : CN -> S -> CN ; -- "idea that the Earth is flat"
ModGenOne : NP -> CN -> NP ; -- "John's car"
ModGenNum : Num -> NP -> CN -> NP ; -- "John's cars", "John's 86 cars"
UseInt : Int -> Num ; -- "32" --- assumes i > 1
NoNum : Num ; -- no numeral modifier
--!
--3 Adjectives and adjectival phrases
--
UseA : A -> AP ; -- "red"
ComplA2 : A2 -> NP -> AP ; -- "divisible by two"
PositADeg : ADeg -> AP ; -- "old"
ComparADeg : ADeg -> NP -> AP ; -- "older than John"
SuperlADeg : ADeg -> AP ; -- "the oldest"
ComplAV : AV -> VPI -> AP ; -- "eager to leave"
ComplObjA2V : A2V -> NP -> VPI -> AP ; -- "easy for us to convince"
--!
--3 Verbs and verb phrases
--
-- The main uses of verbs and verb phrases have been moved to the
-- module $Verbphrase$ (deep $VP$ nesting) and its alternative,
-- $Clause$ (shallow many-place predication structure).
PredAS : AS -> S -> Cl ; -- "it is good that he comes"
PredV0 : V0 -> Cl ; -- "it is raining"
-- Partial saturation.
UseV2 : V2 -> V ; -- "loves"
ComplA2S : A2S -> NP -> AS ; -- "good for John"
UseV2V : V2V -> VV ;
UseV2S : V2S -> VS ;
UseV2Q : V2Q -> VQ ;
UseA2S : A2S -> AS ;
UseA2V : A2V -> AV ;
-- Formation of tensed phrases.
AdjPart : V -> A ; -- past participle, e.g. "forgotten"
UseCl : TP -> Cl -> S ;
UseRCl : TP -> RCl -> RS ;
UseQCl : TP -> QCl -> QS ;
UseVCl : Pol -> Ant -> VCl -> VPI ;
PosTP : Tense -> Ant -> TP ;
NegTP : Tense -> Ant -> TP ;
TPresent : Tense ;
TPast : Tense ;
TFuture : Tense ;
TConditional : Tense ;
ASimul : Ant ;
AAnter : Ant ;
PPos : Pol ;
PNeg : Pol ;
--!
--3 Adverbs
--
-- Here is how complex adverbs can be formed and used.
AdjAdv : A -> Adv ; -- "freely"
AdvPP : PP -> Adv ; -- "in London", "after the war"
PrepNP : Prep -> NP -> PP ; -- "in London", "after the war"
AdvCN : CN -> Adv -> CN ; -- "house in London"
AdvNP : NP -> Adv -> NP ; -- "the house in London"
AdvAP : AdA -> AP -> AP ; -- "very good"
AdvAdv : AdA -> Adv -> Adv ; -- "very well"
--!
--3 Sentences and relative clauses
--
SlashV2 : NP -> V2 -> Slash ; -- "(whom) John doesn't love"
SlashVV2 : NP -> VV -> V2 -> Slash ; -- "(which song do you) want to play"
SlashAdv : Cl -> Prep -> Slash ; -- "(whom) John walks with"
IdRP : RP ; -- "which"
FunRP : N2 -> RP -> RP ; -- "the successor of which"
RelSlash : RP -> Slash -> RCl ; -- "that I wait for"/"for which I wait"
ModRS : CN -> RS -> CN ; -- "man who walks"
RelCl : Cl -> RCl ; -- "such that it is even"
--!
--3 Questions and imperatives
--
FunIP : N2 -> IP -> IP ; -- "the mother of whom"
IDetCN : IDet -> CN -> IP ; -- "which car", "which cars"
QuestCl : Cl -> QCl ; -- "does John walk"; "doesn't John walk"
IntSlash : IP -> Slash -> QCl ; -- "whom does John see"
QuestAdv : IAdv -> Cl -> QCl ; -- "why do you walk"
PosImpVP, NegImpVP : VCl -> Imp ; -- "(don't) be a man"
----rename these ??
IndicPhrase : S -> Phr ; -- "I walk."
QuestPhrase : QS -> Phr ; -- "Do I walk?"
ImperOne, ImperMany : Imp -> Phr ; -- "Be a man!", "Be men!"
AdvCl : Cl -> Adv -> Cl ; -- "John walks in the park"
AdvVPI : VPI -> Adv -> VPI ; -- "walk in the park"
AdCPhr : AdC -> S -> Phr ; -- "Therefore, 2 is prime."
AdvPhr : Adv -> S -> Phr ; -- "In India, there are tigers."
--!
--3 Coordination
--
-- We consider "n"-ary coordination, with "n" > 1. To this end, we have introduced
-- a *list category* $ListX$ for each category $X$ whose expressions we want to
-- conjoin. Each list category has two constructors, the base case being $TwoX$.
-- We have not defined coordination of all possible categories here,
-- since it can be tricky in many languages. For instance, $VP$ coordination
-- is linguistically problematic in German because $VP$ is a discontinuous
-- category.
ConjS : Conj -> ListS -> S ; -- "John walks and Mary runs"
ConjAP : Conj -> ListAP -> AP ; -- "even and prime"
ConjNP : Conj -> ListNP -> NP ; -- "John or Mary"
ConjAdv : Conj -> ListAdv -> Adv ; -- "quickly or slowly"
ConjDS : ConjD -> ListS -> S ; -- "either John walks or Mary runs"
ConjDAP : ConjD -> ListAP -> AP ; -- "both even and prime"
ConjDNP : ConjD -> ListNP -> NP ; -- "either John or Mary"
ConjDAdv : ConjD -> ListAdv -> Adv ; -- "both badly and slowly"
TwoS : S -> S -> ListS ;
ConsS : ListS -> S -> ListS ;
TwoAP : AP -> AP -> ListAP ;
ConsAP : ListAP -> AP -> ListAP ;
TwoNP : NP -> NP -> ListNP ;
ConsNP : ListNP -> NP -> ListNP ;
TwoAdv : Adv -> Adv -> ListAdv ;
ConsAdv : ListAdv -> Adv -> ListAdv ;
--!
--3 Subordination
--
-- Subjunctions are different from conjunctions, but form
-- a uniform category among themselves.
SubjS : Subj -> S -> S -> S ; -- "if 2 is odd, 3 is even"
SubjImper : Subj -> S -> Imp -> Imp ; -- "if it is hot, use a glove!"
SubjQS : Subj -> S -> QS -> QS ; -- "if you are new, who are you?"
-- This rule makes a subordinate clause into a sentence adverb, which
-- can be attached to e.g. noun phrases. It might even replace the
-- previous subjunction rules.
AdvSubj : Subj -> S -> Adv ; -- "when he arrives"
--!
--2 One-word utterances
--
-- These are, more generally, *one-phrase utterances*. The list below
-- is very incomplete.
PhrNP : NP -> Phr ; -- "Some man.", "John."
PhrOneCN, PhrManyCN : CN -> Phr ; -- "A car.", "Cars."
PhrIP : IAdv -> Phr ; -- "Who?"
PhrIAdv : IAdv -> Phr ; -- "Why?"
PhrVPI : VPI -> Phr ; -- "Tända ljus."
--!
--2 Text formation
--
-- A text is a sequence of phrases. It is defined like a non-empty list.
OnePhr : Phr -> Text ;
ConsPhr : Phr -> Text -> Text ;
--2 Special constructs.
--
-- These constructs tend to have language-specific syntactic realizations.
ExistCN : CN -> Cl ; -- "there is a bar"
ExistNumCN : Num -> CN -> Cl ; -- "there are (86) bars"
OneNP : NP ; -- "one (walks)"
} ;

49
lib/resource/abstract/Sats.gf
View File

@@ -1,49 +0,0 @@
--1 Topological structure of Scandinavian sentences.
--
-- This is an alternative, more 'native' analysis than $Clause$ and
-- $Verbphrase$, due to Diderichsen.
--
-- Sources:
-- N. Jörgensen & J. Svensson, "Nusvensk grammatik" (Gleerups, 2001);
-- R. Zola Christensen, "Dansk grammatik for svenskere"
-- (Studentlitteratur 1999).
abstract Sats = Categories ** {
-- Idea: form primarily a $Sats$, which can then be lifted to a $Cl$
-- and used elsewhere in grammar.
cat Sats ;
fun
ClSats : Sats -> Cl ;
-- There will be $Sats$-forming functions for all subcategorization
-- patterns of verbs.
SatsV : NP -> V -> Sats ;
SatsV2 : NP -> V2 -> NP -> Sats ;
SatsV3 : NP -> V3 -> NP -> NP -> Sats ;
SatsReflV2 : NP -> V2 -> Sats ;
SatsVS : NP -> VS -> S -> Sats ;
SatsVQ : NP -> VQ -> QS -> Sats ;
SatsV2S : NP -> V2S -> NP -> S -> Sats ;
SatsV2Q : NP -> V2Q -> NP -> QS -> Sats ;
SatsAP : NP -> AP -> Sats ;
SatsCN : NP -> CN -> Sats ;
SatsNP : NP -> NP -> Sats ;
SatsAdv : NP -> Adv -> Sats ;
-- To a $Sats$, you can insert a sentence adverbial ($AdV$, e.g. "ändå") or
-- 'TSR' adverbial ($Adv$, e.g. "nu"; the name TSR is from Jörgensen
-- and Svensson).
AdVSats : Sats -> AdV -> Sats ;
AdvSats : Sats -> Adv -> Sats ;
-- We can also insert a verb-complement verb.
VVSats : Sats -> VV -> Sats ;
}

85
lib/resource/abstract/Sentence.gf Normal file
View File

@@ -0,0 +1,85 @@
--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.
SlashV2 : NP -> V2 -> Slash ; -- (whom) he sees
SlashVVV2 : NP -> VV -> V2 -> Slash; -- (whom) he wants to see
AdvSlash : Slash -> Adv -> Slash ; -- (whom) he sees tomorrow
SlashPrep : Cl -> Prep -> Slash ; -- (with whom) he walks
--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 ;
}
--.
-- 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
-}

41
lib/resource/abstract/Simple.gf
View File

@@ -1,41 +0,0 @@
abstract Simple = Categories ** {
cat
Sentence ;
fun
PAffirm : Sentence -> Phr ;
PNegate : Sentence -> Phr ;
PQuestion : Sentence -> Phr ;
PCommand : Imp -> Phr ;
SVerb : NP -> V -> Sentence ;
STransVerb : NP -> V2 -> NP -> Sentence ;
SAdjective : NP -> AP -> Sentence ;
SAdverb : NP -> Adv -> Sentence ;
SModified : Sentence -> Adv -> Sentence ;
PIntV : IP -> V -> Phr ;
PIntSubjV2 : IP -> V2 -> NP -> Phr ;
PIntObjV2 : IP -> NP -> V2 -> Phr ;
PIntAP : IP -> AP -> Phr ;
PIntAdv : IP -> Adv -> Phr ;
NPDef : CN -> NP ;
NPIndef : CN -> NP ;
NPGroup : CN -> NP ;
NPMass : CN -> NP ;
NPName : PN -> NP ;
NSimple : N -> CN ;
NModified : AP -> CN -> CN ;
ASimple : ADeg -> AP ;
AVery : ADeg -> AP ;
AdvPrep : Prep -> NP -> Adv ;
}

6
lib/resource/abstract/SimpleAux.gf
View File

@@ -1,6 +0,0 @@
resource SimpleAux = {
param
SentenceForm = SAffirm | SNegate | SQuestion ;
}

73
lib/resource/abstract/SimpleI.gf
View File

@@ -1,73 +0,0 @@
incomplete concrete SimpleI of Simple =
open Predef, Prelude, SimpleAux, Categories, Rules, Structural, Verbphrase in {
lincat
Sentence = {s : SentenceForm => Str} ;
lin
PAffirm sent = ss (sent.s ! SAffirm) ** {lock_Phr = <>} ;
PNegate sent = ss (sent.s ! SNegate) ** {lock_Phr = <>} ;
PQuestion sent = ss (sent.s ! SQuestion) ** {lock_Phr = <>} ;
PCommand = ImperOne ;
SVerb np v = {s = table {
SAffirm => toStr S (UseCl (PosTP TPresent ASimul) (PredVP np (UseV v))) ;
SNegate => toStr S (UseCl (NegTP TPresent ASimul) (PredVP np (UseV v))) ;
SQuestion => toStr QS (UseQCl (PosTP TPresent ASimul) (QuestCl (PredVP np
(UseV v))))
}
} ;
STransVerb np tv obj = {s = table {
SAffirm => toStr S (UseCl (PosTP TPresent ASimul) (PredVP np (ComplV2 tv obj))) ;
SNegate => toStr S (UseCl (PosTP TPresent ASimul) (PredVP np (ComplV2 tv obj))) ;
SQuestion =>
toStr QS (UseQCl (PosTP TPresent ASimul) (QuestCl (PredVP np (ComplV2 tv obj))))
}
} ;
SAdjective np ap = {s = table {
SAffirm => toStr S (UseCl (PosTP TPresent ASimul) (PredVP np (PredAP ap))) ;
SNegate => toStr S (UseCl (NegTP TPresent ASimul) (PredVP np (PredAP ap))) ;
SQuestion => toStr QS (UseQCl (PosTP TPresent ASimul) (QuestCl (PredVP np
(PredAP ap))))
}
} ;
SAdverb np ap = {s = table {
SAffirm => toStr S (UseCl (PosTP TPresent ASimul) (PredVP np (PredAdv ap))) ;
SNegate => toStr S (UseCl (NegTP TPresent ASimul) (PredVP np (PredAdv ap))) ;
SQuestion => toStr QS (UseQCl (PosTP TPresent ASimul) (QuestCl (PredVP np
(PredAdv ap))))
}
} ;
SModified s a = {s = \\f => s.s ! f ++ a.s ; lock_S = <>} ; ---
PIntV ip v =
QuestPhrase (UseQCl (PosTP TPresent ASimul) (IntVP ip (UseV v))) ;
PIntSubjV2 ip v np =
QuestPhrase (UseQCl (PosTP TPresent ASimul) (IntVP ip (ComplV2 v np))) ;
PIntObjV2 ip np v =
QuestPhrase (UseQCl (PosTP TPresent ASimul) (IntSlash ip (SlashV2 np v))) ;
PIntAP ip v =
QuestPhrase (UseQCl (PosTP TPresent ASimul) (IntVP ip (PredAP v))) ;
PIntAdv ip v =
QuestPhrase (UseQCl (PosTP TPresent ASimul) (IntVP ip (PredAdv v))) ;
NPDef = DefOneNP ;
NPIndef = IndefOneNP ;
NPGroup = IndefNumNP NoNum ;
NPMass = MassNP ;
NPName = UsePN ;
NSimple = UseN ;
NModified = ModAP ;
ASimple = PositADeg ;
AVery a = AdvAP very_Adv (PositADeg a) ;
AdvPrep p np = AdvPP (PrepNP p np) ;
}

26
lib/resource/abstract/SimpleLang.gf
View File

@@ -1,26 +0,0 @@
--# -path=.:../../prelude
abstract SimpleLang =
Simple,
Structural,
Basic,
Time,
Country
** {
fun
-- Mount $Time$.
AdvDate : Date -> Adv ;
AdvTime : Time -> Adv ;
NWeekday : Weekday -> N ;
PNWeekday : Weekday -> PN ;
-- Mount $Country$.
PNCountry : Country -> PN ;
ANationality : Nationality -> A ;
NLanguage : Language -> N ;
}

100
lib/resource/abstract/Structural.gf
View File

@@ -1,103 +1,111 @@
--1 GF Resource Grammar API for Structural Words
--1 Structural: Structural Words
--
-- AR 21/11/2003
--
-- Here we have some words belonging to closed classes and appearing
-- in all languages we have considered.
-- Sometimes they are not really meaningful, e.g. $we_NP$ in Spanish
-- should be replaced by masculine and feminine variants.
-- 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 = Categories, Numerals ** {
abstract Structural = Cat ** {
fun
-- First mount the numerals.
UseNumeral : Numeral-> Num ;
-- Then an alphabetical list of structural words
-- This is an alphabetical list of structural words
above_Prep : Prep ;
after_Prep : Prep ;
all8mass_Det : Det ;
all_NDet : NDet ;
almost_Adv : AdA ;
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 ;
both_AndConjD : ConjD ;
both7and_DConj : DConj ;
but_PConj : PConj ;
by8agent_Prep : Prep ;
by8means_Prep : Prep ;
can8know_VV : VV ;
can_VV : VV ;
during_Prep : Prep ;
either8or_ConjD : ConjD ;
either7or_DConj : DConj ;
every_Det : Det ;
everybody_NP : NP ;
everything_NP : NP ;
everywhere_Adv : Adv ;
first_Ord : Ord ;
few_Det : Det ;
from_Prep : Prep ;
he_NP : NP ;
he_Pron : Pron ;
here_Adv : Adv ;
here7to_Adv : Adv ;
here7from_Adv : Adv ;
how_IAdv : IAdv ;
how8many_IDet : IDet ;
i_NP : NP ;
i_Pron : Pron ;
if_Subj : Subj ;
in8front_Prep : Prep ;
in_Prep : Prep ;
it_NP : NP ;
it_Pron : Pron ;
less_CAdv : CAdv ;
many_Det : Det ;
most_Det : Det ;
most8many_Det : Det ;
more_CAdv : CAdv ;
most_Predet : Predet ;
much_Det : Det ;
must_VV : VV ;
no_Phr : Phr ;
on_Prep : Prep ;
one_Quant : QuantSg ;
only_Predet : Predet ;
or_Conj : Conj ;
otherwise_Adv : AdC ;
otherwise_PConj : PConj ;
part_Prep : Prep ;
please_Voc : Voc ;
possess_Prep : Prep ;
quite_Adv : AdA ;
she_NP : NP ;
so_Adv : AdA ;
some_Det : Det ;
some_NDet : NDet ;
she_Pron : Pron ;
so_AdA : AdA ;
someSg_Det : Det ;
somePl_Det : Det ;
somebody_NP : NP ;
something_NP : NP ;
somewhere_Adv : Adv ;
that_Det : Det ;
that_Quant : Quant ;
that_NP : NP ;
therefore_Adv : AdC ;
these_NDet : NDet ;
they8fem_NP : NP ;
they_NP : NP ;
this_Det : Det ;
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_NDet : NDet ;
thou_NP : NP ;
those_NP : NP ;
through_Prep : Prep ;
to_Prep : Prep ;
too_Adv : AdA ;
too_AdA : AdA ;
under_Prep : Prep ;
very_Adv : AdA ;
very_AdA : AdA ;
want_VV : VV ;
we_NP : NP ;
what8many_IP : IP ;
what8one_IP : IP ;
we_Pron : Pron ;
whatPl_IP : IP ;
whatSg_IP : IP ;
when_IAdv : IAdv ;
when_Subj : Subj ;
where_IAdv : IAdv ;
which8many_IDet : IDet ;
which8one_IDet : IDet ;
who8many_IP : IP ;
who8one_IP : IP ;
whichPl_IDet : IDet ;
whichSg_IDet : IDet ;
whoPl_IP : IP ;
whoSg_IP : IP ;
why_IAdv : IAdv ;
with_Prep : Prep ;
without_Prep : Prep ;
ye_NP : NP ;
yes_Phr : Phr ;
you_NP : NP ;
youSg_Pron : Pron ;
youPl_Pron : Pron ;
youPol_Pron : Pron ;
}
}

243
lib/resource/abstract/SwadeshLex.gf
View File

@@ -1,243 +0,0 @@
-- Swadesh 207
abstract SwadeshLex = Categories ** {
fun
-- Pronouns
i_NP : NP ;
thou_NP : NP ;
he_NP : NP ;
we_NP : NP ;
you_NP : NP ;
they_NP : NP ;
who8many_IP : IP ; -- only one who in Swadesh 207
who8one_IP : IP ;
what8many_IP : IP ; -- only one what in Swadesh 207
what8one_IP : IP ;
-- Determiners
that_Det : Det ;
this_Det : Det ;
all_NDet : NDet ;
many_Det : Det ;
some_Det : Det ;
few_Det : Det ;
other_Det : Det ;
-- Adverbs
here_Adv : Adv ;
there_Adv : Adv ;
where_IAdv : IAdv ;
when_IAdv : IAdv ;
how_IAdv : IAdv ;
-- Conjunctions
and_Conj : Conj ;
-- Prepositions
at_Prep : Prep ;
in_Prep : Prep ;
with_Prep : Prep ;
-- not -- ?
-- if -- ?
-- because -- ?
-- Numerals
one_Num : Num ;
two_Num : Num ;
three_Num : Num ;
four_Num : Num ;
five_Num : Num ;
-- Adjectives
bad_ADeg : ADeg ;
big_ADeg : ADeg ;
black_ADeg : ADeg ;
cold_ADeg : ADeg ;
correct_ADeg : ADeg ;
dirty_ADeg : ADeg ;
dry_ADeg : ADeg ;
dull_ADeg : ADeg ;
far_ADeg : ADeg ;
full_ADeg : ADeg ;
good_ADeg : ADeg ;
green_ADeg : ADeg ;
heavy_ADeg : ADeg ;
long_ADeg : ADeg ;
narrow_ADeg : ADeg ;
near_ADeg : ADeg ;
new_ADeg : ADeg ;
old_ADeg : ADeg ;
red_ADeg : ADeg ;
rotten_ADeg : ADeg ;
round_ADeg : ADeg ;
sharp_ADeg : ADeg ;
short_ADeg : ADeg ;
small_ADeg : ADeg ;
smooth_ADeg : ADeg ;
straight_ADeg : ADeg ;
thick_ADeg : ADeg ;
thin_ADeg : ADeg ;
warm_ADeg : ADeg ;
wet_ADeg : ADeg ;
white_ADeg : ADeg ;
wide_ADeg : ADeg ;
yellow_ADeg : ADeg ;
left_A : A ;
right_A : A ;
-- Nouns
animal_N : N ;
ashes_N : N ;
back_N : N ;
bark_N : N ;
belly_N : N ;
bird_N : N ;
blood_N : N ;
bone_N : N ;
breast_N : N ;
child_N : N ;
cloud_N : N ;
day_N : N ;
dog_N : N ;
dust_N : N ;
ear_N : N ;
earth_N : N ;
egg_N : N ;
eye_N : N ;
fat_N : N ;
father_N : N ;
feather_N : N ;
fingernail_N : N ;
fire_N : N ;
fish_N : N ;
flower_N : N ;
fog_N : N ;
foot_N : N ;
forest_N : N ;
fruit_N : N ;
grass_N : N ;
guts_N : N ;
hair_N : N ;
hand_N : N ;
head_N : N ;
heart_N : N ;
horn_N : N ;
husband_N : N ;
ice_N : N ;
knee_N : N ;
lake_N : N ;
leaf_N : N ;
leg_N : N ;
liver_N : N ;
louse_N : N ;
man_N : N ;
meat_N : N ;
moon_N : N ;
mother_N : N ;
mountain_N : N ;
mouth_N : N ;
name_N : N ;
neck_N : N ;
night_N : N ;
nose_N : N ;
person_N : N ;
rain_N : N ;
river_N : N ;
road_N : N ;
root_N : N ;
rope_N : N ;
salt_N : N ;
sand_N : N ;
sea_N : N ;
seed_N : N ;
skin_N : N ;
sky_N : N ;
smoke_N : N ;
snake_N : N ;
snow_N : N ;
star_N : N ;
stick_N : N ;
stone_N : N ;
sun_N : N ;
tail_N : N ;
tongue_N : N ;
tooth_N : N ;
tree_N : N ;
water_N : N ;
wife_N : N ;
wind_N : N ;
wing_N : N ;
woman_N : N ;
worm_N : N ;
year_N : N ;
-- Verbs
bite_V : V ;
blow_V : V ;
breathe_V : V ;
burn_V : V ;
come_V : V ;
count_V : V ;
cut_V : V ;
die_V : V ;
dig_V : V ;
drink_V : V ;
eat_V : V ;
fall_V : V ;
fear_V : V ;
fight_V : V ;
float_V : V ;
flow_V : V ;
fly_V : V ;
freeze_V : V ;
give_V : V ;
hear_V : V ;
hit_V : V ;
hold_V : V ;
hunt_V : V ;
kill_V : V ;
know_V : V ;
laugh_V : V ;
lie_V : V ;
live_V : V ;
play_V : V ;
pull_V : V ;
push_V : V ;
rub_V : V ;
say_V : V ;
scratch_V : V ;
see_V : V ;
sew_V : V ;
sing_V : V ;
sit_V : V ;
sleep_V : V ;
smell_V : V ;
spit_V : V ;
split_V : V ;
squeeze_V : V ;
stab_V : V ;
stand_V : V ;
suck_V : V ;
swell_V : V ;
swim_V : V ;
think_V : V ;
throw_V : V ;
tie_V : V ;
turn_V : V ;
vomit_V : V ;
walk_V : V ;
wash_V : V ;
wipe_V : V ;
}

15
lib/resource/abstract/Text.gf Normal file
View File

@@ -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! ...
}

55
lib/resource/abstract/Time.gf
View File

@@ -1,55 +0,0 @@
abstract Time = Numerals ** {
-- Time grammar Abstract syntax. Modified by AR from Karin Cavallin.
cat
Date ;
Time ;
Hour ;
Minute ;
Weekday ;
fun
-- The variants: "two twenty", "twenty past two", "twenty to two"
DayDate : Weekday -> Date ;
DayTimeDate : Weekday -> Time -> Date ;
FormalTime : Hour -> Minute -> Time ;
PastTime : Hour -> Minute -> Time ;
ToTime : Hour -> Minute -> Time ;
ExactTime : Hour -> Time ;
-- These range from 1 to 99 and are thus overgenerating.
NumHour : Sub100 -> Hour ;
NumMinute : Sub100 -> Minute ;
fun
monday : Weekday ;
tuesday : Weekday ;
wednesday : Weekday ;
thursday : Weekday ;
friday : Weekday ;
saturday : Weekday ;
sunday : Weekday ;
{-
Add:
years
dates: the x:th of y
relative weeks: next week, last week, in x weeks, x weeks ago
relative days: today, tomorrow, yesterday, the day before yesterday,
the day after tomorrow, in x days, x days ago
relative time: in x minutes, in x hours
-}
} ;

70
lib/resource/abstract/Verb.gf Normal file
View File

@@ -0,0 +1,70 @@
--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
ComplV2 : V2 -> NP -> VP ; -- use it
ComplV3 : V3 -> NP -> NP -> VP ; -- send a message to her
ComplVV : VV -> VP -> VP ; -- want to run
ComplVS : VS -> S -> VP ; -- know that she runs
ComplVQ : VQ -> QS -> VP ; -- ask if she runs
ComplVA : VA -> AP -> VP ; -- look red
ComplV2A : V2A -> NP -> AP -> VP ; -- paint the house red
--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)
}

54
lib/resource/abstract/Verbphrase.gf
View File

@@ -1,54 +0,0 @@
--!
--1 Rules for verbs and verb phrases
--
-- This module treats predications by means of deep right-branching
-- $VP$ structures, which have the advantage of conciseness but the
-- disadvantage of slow parsing due to discontinuous constituents.
--
-- The principal way of forming sentences ($S$) is by combining a noun phrase
-- with a verb phrase (the $PredVP$ rule below). In addition to this, verb
-- phrases have uses in relative clauses and questions. Verb phrases already
-- have (or have not) a negation, but they are formed from verbal groups
-- ($VG$), which have both positive and negative forms.
abstract Verbphrase = Categories ** {
flags optimize=all ;
-- These rules produce verb phrases.
fun
UseV : V -> VP ; -- "walks"
UsePassV : V -> VP ; -- "is seen"
ComplV2 : V2 -> NP -> VP ; -- "sees Mary"
ComplV3 : V3 -> NP -> NP -> VP ; -- "tells Mary everything"
ComplReflV2 : V2 -> VP ; -- "loves himself"
ComplVS : VS -> S -> VP ; -- "says that Mary runs"
ComplVV : VV -> VPI -> VP ; -- "must walk"
ComplVQ : VQ -> QS -> VP ; -- "asks who will come"
ComplVA : VA -> AP -> VP ; -- "looks ill"
ComplV2A : V2A -> NP -> AP -> VP ; -- "paints the house red"
ComplSubjV2V : V2V -> NP -> VPI -> VP ; -- "promises Mary to leave"
ComplObjV2V : V2V -> NP -> VPI -> VP ; -- "asked him to go"
ComplV2S : V2S -> NP -> S -> VP ; -- "told me that you came"
ComplV2Q : V2Q -> NP -> QS -> VP ; -- "asks me if you come"
PredAP : AP -> VP ; -- "is old"
PredCN : CN -> VP ; -- "is a man"
PredNP : NP -> VP ; -- "is Bill"
PredAdv : Adv -> VP ; -- "is in France", "is here"
PredProgVP : VPI -> VP ; -- "is eating fish"
-- These rules *use* verb phrases.
PredVP : NP -> VP -> Cl ; -- "John walks"
RelVP : RP -> VP -> RCl ; -- "who walks", "who doesn't walk"
IntVP : IP -> VP -> QCl ; -- "who walks"
UseVP : VP -> VCl ; -- to eat, not to eat
AdvVP : VP -> AdV -> VP ; -- "always walks"
SubjVP : VP -> Subj -> S -> VP ; -- "(a man who) sings when he runs"
}