GitHub/gf-core
1
0
Fork 1
mirror of https://github.com/GrammaticalFramework/gf-core.git synced 2026-04-22 11:19:32 -06:00
Code Issues Packages Projects Releases Wiki Activity

established resource-1.4 and moved contents of resource/exper there

Browse Source
This commit is contained in:
aarne
2008-04-28 07:18:02 +00:00
parent 95c8a5d4f1
commit 6c13446edd
94 changed files with 5 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
lib/resource/exper/abstract/Adjective.gf
View File

@@ -1,30 +0,0 @@
--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 I
ComplA2 : A2 -> NP -> AP ; -- married to her
ReflA2 : A2 -> AP ; -- married to itself
UseA2 : A2 -> A ; -- married
-- Sentence and question complements defined for all adjectival
-- phrases, although the semantics is only clear for some adjectives.
SentAP : AP -> SC -> AP ; -- good that she is here
-- An adjectival phrase can be modified by an *adadjective*, such as "very".
AdAP : AdA -> AP -> AP ; -- very warm
-- The formation of adverbs from adjective (e.g. "quickly") is covered
-- in [Adverb Adverb.html].
}

32
lib/resource/exper/abstract/Adverb.gf
View File

@@ -1,32 +0,0 @@
--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 ; -- warmly
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 warmly than John
ComparAdvAdjS : CAdv -> A -> S -> Adv ; -- more warmly 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 she sleeps
-- Comparison adverbs also work as numeral adverbs.
AdnCAdv : CAdv -> AdN ; -- less (than five)
}

63
lib/resource/exper/abstract/Backward.gf
View File

@@ -1,63 +0,0 @@
--1 Obsolete constructs included for backward-compatibility
abstract Backward = Cat ** {
-- from Cat
cat
Slash ;
fun
-- from Verb 19/4/2008
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
ReflV2 : V2 -> VP ; -- use itself
UseVQ : VQ -> V2 ; -- ask (a question)
UseVS : VS -> V2 ; -- know (a secret)
-- from Sentence 19/4/2008
SlashV2 : NP -> V2 -> Slash ; -- (whom) he sees
SlashVVV2 : NP -> VV -> V2 -> Slash; -- (whom) he wants to see
-- from Noun 19/4/2008
NumInt : Int -> Num ; -- 51
OrdInt : Int -> Ord ; -- 51st (DEPRECATED)
NoOrd : Ord ;
-- 20/4
DetSg : Quant -> Ord -> Det ; -- the best man
DetPl : Quant -> Num -> Ord -> Det ; -- the five best men
NoNum : Num ;
-- 22/4
DefArt : Quant ; -- the (house), the (houses)
IndefArt : Quant ; -- a (house), (houses)
MassDet : Quant ; -- (beer)
-- from Structural 19/4/2008
that_NP : NP ;
these_NP : NP ;
this_NP : NP ;
those_NP : NP ;
whichPl_IDet : IDet ;
whichSg_IDet : IDet ;
-- from Adverb
AdvSC : SC -> Adv ; -- that he arrives ---- REMOVE?
}

134
lib/resource/exper/abstract/Cat.gf
View File

@@ -1,134 +0,0 @@
--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"
ClSlash;-- 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. "how many"
IQuant; -- interrogative quantifier 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"
Art ; -- article e.g. "the"
Num ; -- number determining element e.g. "seven"
Card ; -- cardinal number 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"
---b 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"
}

61
lib/resource/exper/abstract/Common.gf
View File

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

52
lib/resource/exper/abstract/Conjunction.gf
View File

@@ -1,52 +0,0 @@
--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 ; -- "he walks and she runs"
ConjAP : Conj -> [AP] -> AP ; -- "cold and warm"
ConjNP : Conj -> [NP] -> NP ; -- "she or we"
ConjAdv : Conj -> [Adv] -> Adv ; -- "here or there"
---b DConjS : DConj -> [S] -> S ; -- "either he walks or she runs"
---b DConjAP : DConj -> [AP] -> AP ; -- "both warm and cold"
---b DConjNP : DConj -> [NP] -> NP ; -- "either he or she"
---b DConjAdv : DConj -> [Adv] -> Adv; -- "both here and there"
--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].

30
lib/resource/exper/abstract/Extra.gf
View File

@@ -1,30 +0,0 @@
--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 -> ClSlash -> RCl ; -- that he lives in
EmptyRelSlash : RP -> ClSlash -> RCl ; -- he lives in
StrandQuestSlash : IP -> ClSlash -> 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 ;
}

22
lib/resource/exper/abstract/Grammar.gf
View File

@@ -1,22 +0,0 @@
--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/exper/abstract/Idiom.gf
View File

@@ -1,22 +0,0 @@
--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 is hot
GenericCl : VP -> Cl ; -- one sleeps
CleftNP : NP -> RS -> Cl ; -- it is I who did it
CleftAdv : Adv -> S -> Cl ; -- it is here she slept
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
}

13
lib/resource/exper/abstract/Lang.gf
View File

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

356
lib/resource/exper/abstract/Lexicon.gf
View File

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

144
lib/resource/exper/abstract/Noun.gf
View File

@@ -1,144 +0,0 @@
--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, by an adverb, or by a relative clause
PPartNP : NP -> V2 -> NP ; -- the man seen
AdvNP : NP -> Adv -> NP ; -- Paris today
RelNP : NP -> RS -> NP ; -- Paris, which is here
-- Determiners can form noun phrases directly.
DetNP : Det -> NP ; -- these five
--2 Determiners
-- The determiner has a fine-grained structure, in which a 'nucleus'
-- quantifier and two optional parts can be discerned: a cardinal and
-- an ordinal numeral.
DetQuantOrd : Quant -> Num -> Ord -> Det ; -- these five best
DetQuant : Quant -> Num -> Det ; -- these five
-- Whether the resulting determiner is singular or plural depends on the
-- cardinal.
-- All parts of the determiner can be empty, except $Quant$, which is
-- the "kernel" of a determiner. It is, however, the $Num$ that determines
-- the inherent number.
NumSg : Num ;
NumPl : Num ;
NumCard : Card -> Num ;
-- $Card$ consists of either digits or numeral words.
NumDigits : Digits -> Card ; -- 51
NumNumeral : Numeral -> Card ; -- fifty-one
-- The construction of numerals is defined in [Numeral Numeral.html].
-- $Num$ can be modified by certain adverbs.
AdNum : AdN -> Card -> Card ; -- almost 51
-- $Ord$ consists of either digits or numeral words.
-- Also superlative forms of adjectives behave syntactically like ordinals.
OrdDigits : Digits -> Ord ; -- 51st
OrdNumeral : Numeral -> Ord ; -- fifty-first
OrdSuperl : A -> Ord ; -- warmest
-- Definite and indefinite noun phrases are sometimes realized as
-- neatly distinct words (Spanish "un, unos ; el, los") but also without
-- any particular word (Finnish; Swedish definites).
DetArtOrd : Art -> Num -> Ord -> Det ; -- the (five) best
DetArtCard : Art -> Card -> Det ; -- the five
IndefArt : Art ;
DefArt : Art ;
-- Articles cannot alone form noun phrases, but need a noun.
DetArtSg : Art -> CN -> NP ; -- the man
DetArtPl : Art -> CN -> NP ; -- the men
-- 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.
MassNP : CN -> NP ; -- (beer)
-- 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$ modules.
PossPron : Pron -> Quant ; -- my (house)
-- 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 ; -- mother of the king
ComplN3 : N3 -> NP -> N2 ; -- distance from this city (to Paris)
-- Relational nouns can also be used without their arguments.
-- The semantics is typically derivative of the relational meaning.
UseN2 : N2 -> CN ; -- mother
Use2N3 : N3 -> N2 ; -- distance (from this city)
Use3N3 : N3 -> N2 ; -- distance (to Paris)
-- 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 bought
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 ; -- question where she sleeps
--2 Apposition
-- This is certainly overgenerating.
ApposCN : CN -> NP -> CN ; -- city Paris (, numbers x and y)
} ;

60
lib/resource/exper/abstract/Numeral.gf
View File

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

44
lib/resource/exper/abstract/Phrase.gf
View File

@@ -1,44 +0,0 @@
--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 come here, 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) love yourself
UttImpPl : Pol -> Imp -> Utt; -- (don't) love yourselves
UttImpPol : Pol -> Imp -> Utt ; -- (don't) sleep (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
}

41
lib/resource/exper/abstract/Question.gf
View File

@@ -1,41 +0,0 @@
--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 -> ClSlash -> QCl ; -- whom 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, with or without a noun.
IdetCN : IDet -> CN -> IP ; -- which five songs
IdetIP : IDet -> IP ; -- which five
-- They can be modified with adverbs.
AdvIP : IP -> Adv -> IP ; -- who in Paris
-- Interrogative quantifiers have number forms and can take number modifiers.
IdetQuant : IQuant -> Num -> IDet ; -- which (five)
-- Interrogative adverbs can be formed prepositionally.
PrepIP : Prep -> IP -> IAdv ; -- with whom
-- Interrogative complements to copulas can be both adverbs and
-- pronouns.
CompIAdv : IAdv -> IComp ; -- where (is it)
CompIP : IP -> IComp ; -- who (is it)
-- More $IP$, $IDet$, and $IAdv$ are defined in $Structural$.
}

26
lib/resource/exper/abstract/Relative.gf
View File

@@ -1,26 +0,0 @@
--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 -> ClSlash -> 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 ; -- the mother of whom
}

95
lib/resource/exper/abstract/Sentence.gf
View File

@@ -1,95 +0,0 @@
--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 she goes is good
--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 -> ClSlash ; -- (whom) he sees
AdvSlash : ClSlash -> Adv -> ClSlash ; -- (whom) he sees today
SlashPrep : Cl -> Prep -> ClSlash ; -- (with whom) he walks
SlashVS : NP -> VS -> SSlash -> ClSlash ; -- (whom) she says that he 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 ; -- love yourselves
--2 Embedded sentences
-- Sentences, questions, and infinitival phrases can be used as
-- subjects and (adverbial) complements.
EmbedS : S -> SC ; -- that she goes
EmbedQS : QS -> SC ; -- who goes
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 -> ClSlash -> SSlash ;
-- An adverb can be added to the beginning of a sentence.
AdvS : Adv -> S -> S ; -- today, I will go home
-- A sentence can be modified by a relative clause referring to its contents.
RelS : S -> RS -> S ; -- she sleeps, which is good
}
--.
-- 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
-}

111
lib/resource/exper/abstract/Structural.gf
View File

@@ -1,111 +0,0 @@
--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 : Conj ;
---b both7and_DConj : DConj ;
but_PConj : PConj ;
by8agent_Prep : Prep ;
by8means_Prep : Prep ;
can8know_VV : VV ;
can_VV : VV ;
during_Prep : Prep ;
either7or_DConj : Conj ;
---b 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 ;
---b no_Phr : Phr ;
no_Utt : Utt ;
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 ;
there_Adv : Adv ;
there7to_Adv : Adv ;
there7from_Adv : Adv ;
therefore_PConj : PConj ;
they_Pron : Pron ;
this_Quant : Quant ;
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 ;
which_IQuant : IQuant ;
whoPl_IP : IP ;
whoSg_IP : IP ;
why_IAdv : IAdv ;
with_Prep : Prep ;
without_Prep : Prep ;
---b yes_Phr : Phr ;
yes_Utt : Utt ;
youSg_Pron : Pron ;
youPl_Pron : Pron ;
youPol_Pron : Pron ;
}

15
lib/resource/exper/abstract/Text.gf
View File

@@ -1,15 +0,0 @@
--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 they here? ...
TExclMark : Phr -> Text -> Text ; -- Let's go! ...
}

71
lib/resource/exper/abstract/Verb.gf
View File

@@ -1,71 +0,0 @@
--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 ; -- say that she runs
ComplVQ : VQ -> QS -> VP ; -- wonder who runs
ComplVA : VA -> AP -> VP ; -- they become red
SlashV2a : V2 -> VPSlash ; -- love (it)
Slash2V3 : V3 -> NP -> VPSlash ; -- give it (to her)
Slash3V3 : V3 -> NP -> VPSlash ; -- give (it) to her
SlashV2V : V2V -> VP -> VPSlash ; -- beg (her) to go
SlashV2S : V2S -> S -> VPSlash ; -- answer (to him) that it is good
SlashV2Q : V2Q -> QS -> VPSlash ; -- ask (him) who came
SlashV2A : V2A -> AP -> VPSlash ; -- paint (it) red
ComplSlash : VPSlash -> NP -> VP ; -- love it
SlashVV : VV -> VPSlash -> VPSlash ; -- want to buy
SlashV2VNP : V2V -> NP -> VPSlash -> VPSlash ; -- beg me to buy
--2 Other ways of forming verb phrases
-- Verb phrases can also be constructed reflexively and from
-- copula-preceded complements.
ReflVP : VPSlash -> VP ; -- love himself
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 loved
-- 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 man
CompAdv : Adv -> Comp ; -- (be) here
}

38
lib/resource/exper/english/AdjectiveEng.gf
View File

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

21
lib/resource/exper/english/AdverbEng.gf
View File

@@ -1,21 +0,0 @@
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 ;
---b AdvSC s = s ; --- this rule give stack overflow in ordinary parsing
AdnCAdv cadv = {s = cadv.s ++ "than"} ;
}

76
lib/resource/exper/english/BackwardEng.gf
View File

@@ -1,76 +0,0 @@
concrete BackwardEng of Backward = CatEng ** open ResEng in {
flags optimize=all_subs ;
lin
-- A repository of obsolete constructs, needed for backward compatibility.
-- They create spurious ambiguities if used in combination with Lang.
-- from Verb 19/4/2008
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) ;
ReflV2 v = insertObj (\\a => v.c2 ++ reflPron ! a) (predV v) ;
-- from Sentence 19/4/2008
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} ;
-- from Noun 19/4/2008
NumInt n = {s = n.s ; n = Pl} ;
OrdInt n = {s = n.s ++ "th"} ; --- DEPRECATED
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
} ;
NoNum = {s = []; n = Pl } ;
DefArt = {s = \\_ => artDef} ;
IndefArt = {
s = table {
Sg => artIndef ;
Pl => []
}
} ;
MassDet = {s = \\_ => []} ;
-- from Structural 19/4/2008
that_NP = regNP "that" Sg ;
these_NP = regNP "these" Pl ;
this_NP = regNP "this" Sg ;
those_NP = regNP "those" Pl ;
}

89
lib/resource/exper/english/CatEng.gf
View File

@@ -1,89 +0,0 @@
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} ;
ClSlash = {
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} ;
IQuant = {s : Number => Str} ;
-- 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 ; g : Gender} ;
NP, Pron = {s : Case => Str ; a : Agr} ;
Det = {s : Str ; n : Number} ;
Predet, Ord = {s : Str} ;
Num = {s : Str; n : Number ; hasCard : Bool} ;
Card = {s : Str; n : Number} ;
Quant = {s : Number => Str} ;
Art = {s : Bool => Number => Str} ;
-- Numeral
Numeral = {s : CardOrd => Str ; n : Number} ;
Digits = {s : CardOrd => Str ; n : Number ; tail : DTail} ;
-- Structural
Conj = {s1,s2 : Str ; n : Number} ;
---b Conj = {s : Str ; n : Number} ;
---b 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 ; g : Gender} ;
N2 = {s : Number => Case => Str ; g : Gender} ** {c2 : Str} ;
N3 = {s : Number => Case => Str ; g : Gender} ** {c2,c3 : Str} ;
PN = {s : Case => Str ; g : Gender} ;
}

60
lib/resource/exper/english/ConjunctionEng.gf
View File

@@ -1,60 +0,0 @@
concrete ConjunctionEng of Conjunction =
CatEng ** open ResEng, Coordination, Prelude in {
flags optimize=all_subs ;
lin
ConjS = conjunctDistrSS ;
ConjAdv = conjunctDistrSS ;
ConjNP conj ss = conjunctDistrTable Case conj ss ** {
a = conjAgr (agrP3 conj.n) ss.a
} ;
ConjAP conj ss = conjunctDistrTable Agr conj ss ** {
isPre = ss.isPre
} ;
{---b
ConjS = conjunctSS ;
DConjS = conjunctDistrSS ;
ConjAdv = conjunctSS ;
DConjAdv = conjunctDistrSS ;
ConjNP conj ss = conjunctTable Case conj ss ** {
a = conjAgr (agrP3 conj.n) ss.a
} ;
DConjNP conj ss = conjunctDistrTable Case conj ss ** {
a = conjAgr (agrP3 conj.n) ss.a
} ;
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} ;
}

9
lib/resource/exper/english/English.gf
View File

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

9
lib/resource/exper/english/EnglishAbs.gf
View File

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

53
lib/resource/exper/english/ExtraEng.gf
View File

@@ -1,53 +0,0 @@
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,ag =>
rp.s ! RC (fromAgr ag).g 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 ; g = b.g} ;
oper
neg = CNeg False ;
}

16
lib/resource/exper/english/ExtraEngAbs.gf
View File

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

21
lib/resource/exper/english/GrammarEng.gf
View File

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

30
lib/resource/exper/english/IdiomEng.gf
View File

@@ -1,30 +0,0 @@
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 (\\_ => optStr conjThat ++ s.s)
(insertObj (\\_ => ad.s) (predAux auxBe))) ;
ExistNP np =
mkClause "there" (agrP3 (fromAgr 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 (AgP1 Pl)} ;
}

181
lib/resource/exper/english/IrregEng.gf
View File

@@ -1,181 +0,0 @@
--# -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" ;
}

176
lib/resource/exper/english/IrregEngAbs.gf
View File

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

10
lib/resource/exper/english/LangEng.gf
View File

@@ -1,10 +0,0 @@
--# -path=.:abstract:../common:prelude
concrete LangEng of Lang =
GrammarEng,
LexiconEng
** {
flags startcat = Phr ; unlexer = text ; lexer = text ;
} ;

375
lib/resource/exper/english/LexiconEng.gf
View File

@@ -1,375 +0,0 @@
--# -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 = mkN human (regN "boss") ;
boy_N = mkN masculine (regN "boy") ;
bread_N = regN "bread" ;
break_V2 = dirV2 (irregV "break" "broke" "broken") ;
broad_A = regADeg "broad" ;
brother_N2 = mkN2 (mkN masculine (mkN "brother")) (mkPrep "of") ;
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 = mkN human (regN "cousin") ;
cow_N = regN "cow" ;
die_V = (regV "die") ;
dirty_A = regADeg "dirty" ;
distance_N3 = mkN3 (regN "distance") fromP toP ;
doctor_N = mkN human (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 = mkN2 (mkN masculine (mkN "father")) (mkPrep "of") ;
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 = mkN human (regN "friend") ;
fruit_N = regN "fruit" ;
fun_AV = mkAV (regA "fun") ;
garden_N = regN "garden" ;
girl_N = mkN feminine (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 = mkN masculine (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 = mkN masculine (mk2N "man" "men") ;
married_A2 = mkA2 (regA "married") toP ;
meat_N = regN "meat" ;
milk_N = regN "milk" ;
moon_N = regN "moon" ;
mother_N2 = mkN2 (mkN feminine (mkN "mother")) (mkPrep "of") ;
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 = mkPN (mkN nonhuman (mkN "Paris")) ;
peace_N = regN "peace" ;
pen_N = regN "pen" ;
planet_N = regN "planet" ;
plastic_N = regN "plastic" ;
play_V2 = dirV2 (regV "play") ;
policeman_N = mkN masculine (mkN "policeman" "policemen") ;
priest_N = mkN human (regN "priest") ;
probable_AS = mkAS (regA "probable") ;
queen_N = mkN feminine (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 = mkN2 (mkN feminine (mkN "sister")) (mkPrep "of") ;
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 = mkN human (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 = mkN human (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 = mkN feminine (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 = mkN 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 = mkN 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 = mkN 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 = mkPN (mkN masculine (mkN "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" ;
} ;

197
lib/resource/exper/english/MorphoEng.gf
View File

@@ -1,197 +0,0 @@
--# -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} ;
mkPronoun : (_,_,_,_ : Str) -> Number -> Person -> Gender -> Pronoun =
\I,me,my,mine,n,p,g ->
{s = table {Nom => I ; Acc => me ; Gen => my} ;
a = toAgr n p 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 [] ;
} ;

137
lib/resource/exper/english/NounEng.gf
View File

@@ -1,137 +0,0 @@
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 = agrgP3 det.n cn.g
} ;
UsePN pn = pn ** {a = agrgP3 Sg pn.g} ;
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
} ;
RelNP np rs = {
s = \\c => np.s ! c ++ "," ++ rs.s ! np.a ;
a = np.a
} ;
AdvNP np adv = {
s = \\c => np.s ! c ++ adv.s ;
a = np.a
} ;
DetQuantOrd quant num ord = {
s = quant.s ! num.n ++ num.s ++ ord.s ;
n = num.n
} ;
DetQuant quant num = {
s = quant.s ! num.n ++ num.s ;
n = num.n
} ;
DetNP det = {
s = \\c => det.s ; ---- case
a = agrP3 det.n
} ;
PossPron p = {s = \\_ => p.s ! Gen} ;
NumSg = {s = []; n = Sg ; hasCard = False} ;
NumPl = {s = []; n = Pl ; hasCard = False} ;
---b NoOrd = {s = []} ;
NumCard n = n ** {hasCard = True} ;
NumDigits n = {s = n.s ! NCard ; n = n.n} ;
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} ;
DetArtOrd art num ord = {
s = art.s ! num.hasCard ! num.n ++ num.s ++ ord.s ;
n = num.n
} ;
DetArtCard art card = {
s = art.s ! True ! card.n ++ card.s ;
n = card.n
} ;
DetArtSg art cn = {
s = \\c => art.s ! False ! Sg ++ cn.s ! Sg ! c ;
a = agrgP3 Sg cn.g
} ;
DetArtPl art cn = {
s = \\c => art.s ! False ! Pl ++ cn.s ! Pl ! c ;
a = agrgP3 Pl cn.g
} ;
DefArt = {s = \\c,n => artDef} ;
IndefArt = {s = \\c,n => case <n,c> of {
<Sg,False> => artIndef ;
_ => []
}
} ;
MassNP cn = {
s = cn.s ! Sg ;
a = agrP3 Sg
} ;
UseN n = n ;
UseN2 n = n ;
---b UseN3 n = n ;
Use2N3 f = {
s = \\n,c => f.s ! n ! Nom ;
g = f.g ;
c2 = f.c2
} ;
Use3N3 f = {
s = \\n,c => f.s ! n ! Nom ;
g = f.g ;
c2 = f.c3
} ;
ComplN2 f x = {s = \\n,c => f.s ! n ! Nom ++ f.c2 ++ x.s ! c ; g = f.g} ;
ComplN3 f x = {
s = \\n,c => f.s ! n ! Nom ++ f.c2 ++ x.s ! c ;
g = f.g ;
c2 = f.c3
} ;
AdjCN ap cn = {
s = \\n,c => preOrPost ap.isPre (ap.s ! agrgP3 n cn.g) (cn.s ! n ! c) ;
g = cn.g
} ;
RelCN cn rs = {
s = \\n,c => cn.s ! n ! c ++ rs.s ! agrgP3 n cn.g ;
g = cn.g
} ;
AdvCN cn ad = {s = \\n,c => cn.s ! n ! c ++ ad.s ; g = cn.g} ;
SentCN cn sc = {s = \\n,c => cn.s ! n ! c ++ sc.s ; g = cn.g} ;
ApposCN cn np = {s = \\n,c => cn.s ! n ! Nom ++ np.s ! c ; g = cn.g} ;
}

95
lib/resource/exper/english/NumeralEng.gf
View File

@@ -1,95 +0,0 @@
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 <f,c> of {
<teen,NOrd> => "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
} ;
}

1
lib/resource/exper/english/OverloadEng.gf
View File

@@ -1 +0,0 @@
resource OverloadEng = Overload with (Grammar = GrammarEng) ;

577
lib/resource/exper/english/ParadigmsEng.gf
View File

@@ -1,577 +0,0 @@
--# -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 ;
feminine : 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 ;
-- Change gender from the default $nonhuman$.
mkN : Gender -> N -> 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 ** {g = 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 ;
} ;

24
lib/resource/exper/english/PhraseEng.gf
View File

@@ -1,24 +0,0 @@
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 = {s = conj.s2} ; ---
NoVoc = {s = []} ;
VocNP np = {s = "," ++ np.s ! Nom} ;
}

55
lib/resource/exper/english/QuestionEng.gf
View File

@@ -1,55 +0,0 @@
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) (agrP3 qp.n) 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 ! Acc} ;
AdvIP ip adv = {
s = \\c => ip.s ! c ++ adv.s ;
n = ip.n
} ;
IdetCN idet cn = {
s = \\c => idet.s ++ cn.s ! idet.n ! c ;
n = idet.n
} ;
IdetIP idet = {
s = \\c => idet.s ;
n = idet.n
} ;
IdetQuant idet num = {
s = idet.s ! num.n ++ num.s ;
n = num.n
} ;
CompIAdv a = a ;
CompIP p = ss (p.s ! Nom) ;
}

54
lib/resource/exper/english/RelativeEng.gf
View File

@@ -1,54 +0,0 @@
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 (fromAgr agr).g 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,agr =>
slash.c2 ++ rp.s ! RPrep (fromAgr agr).g ++ slash.s ! t ! a ! p ! ODir ;
c = Acc
} ;
FunRP p np rp = {
s = \\c => np.s ! Acc ++ p.s ++ rp.s ! RPrep (fromAgr np.a).g ;
a = RAg np.a
} ;
IdRP =
let varr : Str -> Str = \x -> variants {x ; "that"} --- for bwc
in {
s = table {
RC _ Gen => "whose" ;
RC Neutr _ => varr "which" ;
RC _ Acc => varr "whom" ;
RC _ Nom => varr "who" ;
RPrep Neutr => "which" ;
RPrep _ => "whom"
} ;
a = RNoAg
} ;
}

479
lib/resource/exper/english/ResEng.gf
View File

@@ -1,479 +0,0 @@
--# -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$ has 8 values. $Gender$ is needed for "who"/"which" and
-- for "himself"/"herself"/"itself".
param
Agr = AgP1 Number | AgP2 Number | AgP3Sg Gender | AgP3Pl ;
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 Agr ;
RCase = RPrep Gender | RC Gender Case ;
--2 For $Numeral$
CardOrd = NCard | NOrd ;
DForm = unit | teen | ten ;
--2 Transformations between parameter types
oper
toAgr : Number -> Person -> Gender -> Agr = \n,p,g ->
case p of {
P1 => AgP1 n ;
P2 => AgP2 n ;
P3 => case n of {
Sg => AgP3Sg g ;
Pl => AgP3Pl
}
} ;
fromAgr : Agr -> {n : Number ; p : Person ; g : Gender} = \a -> case a of {
AgP1 n => {n = n ; p = P1 ; g = Masc} ;
AgP2 n => {n = n ; p = P2 ; g = Masc} ;
AgP3Pl => {n = Pl ; p = P3 ; g = Masc} ;
AgP3Sg g => {n = Sg ; p = P3 ; g = g}
} ;
agrP3 : Number -> Agr = \n -> agrgP3 n Neutr ;
agrgP3 : Number -> Gender -> Agr = \n,g -> toAgr n P3 g ;
conjAgr : Agr -> Agr -> Agr = \a0,b0 ->
let a = fromAgr a0 ; b = fromAgr b0
in
toAgr
(conjNumber a.n b.n)
(conjPerson a.p b.p) a.g ;
-- 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 Neutr in {
s = who.s ;
n = n
} ;
mkNP : (i,me,my : Str) -> Number -> Person -> Gender ->
{s : Case => Str ; a : Agr} =
\i,me,my,n,p,g -> {
s = table {
Nom => i ;
Acc => me ;
Gen => my
} ;
a = toAgr n p g ;
} ;
-- 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 Neutr ;
-- 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 <t,ant,b,ord> of {
<Pres,Simul,CPos,ODir> => vff fin [] ;
<Pres,Simul,CPos,OQuest> => vf (does agr) inf ;
<Pres,Anter,CPos,_> => vf (have agr) part ; --# notpresent
<Pres,Anter,CNeg c,_> => vfn c (have agr) (havent agr) part ; --# notpresent
<Past,Simul,CPos,ODir> => vff (verb.s ! VPast) [] ; --# notpresent
<Past,Simul,CPos,OQuest> => vf "did" inf ; --# notpresent
<Past,Simul,CNeg c,_> => vfn c "did" "didn't" inf ; --# notpresent
<Past,Anter,CPos,_> => vf "had" part ; --# notpresent
<Past,Anter,CNeg c,_> => vfn c "had" "hadn't" part ; --# notpresent
<Fut, Simul,CPos,_> => vf "will" inf ; --# notpresent
<Fut, Simul,CNeg c,_> => vfn c "will" "won't" inf ; --# notpresent
<Fut, Anter,CPos,_> => vf "will" ("have" ++ part) ; --# notpresent
<Fut, Anter,CNeg c,_> => vfn c "will" "won't"("have" ++ part) ; --# notpresent
<Cond,Simul,CPos,_> => vf "would" inf ; --# notpresent
<Cond,Simul,CNeg c,_> => vfn c "would" "wouldn't" inf ; --# notpresent
<Cond,Anter,CPos,_> => vf "would" ("have" ++ part) ; --# notpresent
<Cond,Anter,CNeg c,_> => vfn c "would" "wouldn't" ("have" ++ part) ; --# notpresent
<Pres,Simul,CNeg c,_> => 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 <t,ant,cb,ord> of {
<Pres,Anter,CPos,_> => vf (have agr) part ; --# notpresent
<Pres,Anter,CNeg c,_> => vfn c (have agr) (havent agr) part ; --# notpresent
<Past,Simul,CPos, _> => vf (verb.past ! b ! agr) [] ; --# notpresent
<Past,Simul,CNeg c, _> => vfn c (verb.past!Pos!agr)(verb.past!Neg!agr) [] ; --# notpresent
<Past,Anter,CPos,_> => vf "had" part ; --# notpresent
<Past,Anter,CNeg c,_> => vfn c "had" "hadn't" part ; --# notpresent
<Fut, Simul,CPos,_> => vf "will" inf ; --# notpresent
<Fut, Simul,CNeg c,_> => vfn c "will" "won't" inf ; --# notpresent
<Fut, Anter,CPos,_> => vf "will" ("have" ++ part) ; --# notpresent
<Fut, Anter,CNeg c,_> => vfn c "will" "won't"("have" ++ part) ; --# notpresent
<Cond,Simul,CPos,_> => vf "would" inf ; --# notpresent
<Cond,Simul,CNeg c,_> => vfn c "would" "wouldn't" inf ; --# notpresent
<Cond,Anter,CPos,_> => vf "would" ("have" ++ part) ; --# notpresent
<Cond,Anter,CNeg c,_> => vfn c "would" "wouldn't" ("have" ++ part) ; --# notpresent
<Pres,Simul,CPos, _> => vf fin [] ;
<Pres,Simul,CNeg c, _> => 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 {
AgP3Sg _ => 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 <b,a> of {
<Pos,AgP1 Sg> => "am" ;
<Neg,AgP1 Sg> => ["am not"] ; --- am not I
_ => agrVerb (posneg b "is") (posneg b "are") a
} ;
past = \\b,a => case a of { --# notpresent
AgP1 Sg | AgP3Sg _ => 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 {
AgP1 Sg => "myself" ;
AgP2 Sg => "yourself" ;
AgP3Sg Masc => "himself" ;
AgP3Sg Fem => "herself" ;
AgP3Sg Neutr => "itself" ;
AgP1 Pl => "ourselves" ;
AgP2 Pl => "yourselves" ;
AgP3Pl => "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 ;
}

75
lib/resource/exper/english/SentenceEng.gf
View File

@@ -1,75 +0,0 @@
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 = AgP2 (numImp n) ;
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} ;
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} ;
RelS s r = {s = s.s ++ "," ++ r.s ! agrP3 Sg} ;
oper
ctr = contrNeg True ; -- contracted negations
}
{-
--- todo: tense of embedded Slash
SlashVSS np vs s =
mkClause (np.s ! Nom) np.a
(insertObj (\\_ => conjThat ++ s.s) (predV vs)) **
{c2 = s.c2} ;
-}

131
lib/resource/exper/english/StructuralEng.gf
View File

@@ -1,131 +0,0 @@
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 = sd2 [] "and" ** {n = Pl} ;
---b 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 Masc ;
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 Masc ;
in_Prep = ss "in" ;
it_Pron = mkNP "it" "it" "its" Sg P3 Neutr ;
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
} ;
---b no_Phr = ss "no" ;
no_Utt = ss "no" ;
on_Prep = ss "on" ;
---- one_Quant = mkDeterminer Sg "one" ; -- DEPRECATED
only_Predet = ss "only" ;
or_Conj = sd2 [] "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 Fem ;
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" ;
there_Adv = ss "there" ;
there7to_Adv = ss "there" ;
there7from_Adv = ss ["from there"] ;
therefore_PConj = ss "therefore" ;
they_Pron = mkNP "they" "them" "their" Pl P3 Masc ; ----
this_Quant = mkQuant "this" "these" ;
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 Masc ;
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" ;
which_IQuant = {s = \\_ => "which"} ;
---b whichPl_IDet = mkDeterminer Pl ["which"] ;
---b 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" ;
---b yes_Phr = ss "yes" ;
yes_Utt = ss "yes" ;
youSg_Pron = mkNP "you" "you" "your" Sg P2 Masc ;
youPl_Pron = mkNP "you" "you" "your" Pl P2 Masc ;
youPol_Pron = mkNP "you" "you" "your" Sg P2 Masc ;
oper
mkQuant : Str -> Str -> {s : Number => Str} = \x,y -> {
s = table Number [x ; y]
} ;
}

50
lib/resource/exper/english/VerbEng.gf
View File

@@ -1,50 +0,0 @@
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 ;
ReflVP v = insertObjPre (\\a => v.c2 ++ reflPron ! a) v ;
PassV2 v = insertObj (\\_ => v.s ! VPPart) (predAux auxBe) ;
---b 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} ;
}

195
lib/resource/exper/exx-restest.gft
View File

@@ -1,195 +0,0 @@
-- Adjective
PositA warm_A
ComparA warm_A (UsePron i_Pron)
ComplA2 married_A2 (DetNP (DetQuant (PossPron she_Pron) NumPl))
ComplA2 married_A2 (DetNP (DetQuant (PossPron she_Pron) NumSg))
ComplA2 married_A2 (UsePron she_Pron)
ReflA2 married_A2
PositA (UseA2 married_A2)
SentAP (PositA good_A) (EmbedS (UseCl TPres ASimul PPos (PredVP (UsePron she_Pron) (UseComp (CompAdv here_Adv)))))
AdAP very_AdA (PositA warm_A)
-- Adverb
PositAdvAdj warm_A
PrepNP in_Prep (DetArtSg DefArt (UseN house_N))
ComparAdvAdj more_CAdv warm_A (UsePN john_PN)
ComparAdvAdjS more_CAdv warm_A (UseCl TPres ASimul PPos (PredVP (UsePron he_Pron) (UseV run_V)))
SubjS when_Subj (UseCl TPres ASimul PPos (PredVP (UsePron she_Pron) (UseV sleep_V)))
AdNum (AdnCAdv more_CAdv) (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n5))))))
-- Conjunction
ConjS and_Conj (BaseS (UseCl TPres ASimul PPos (PredVP (UsePron he_Pron) (UseV walk_V))) (UseCl TPres ASimul PPos (PredVP (UsePron she_Pron) (UseV run_V))))
ConjAP and_Conj (BaseAP (PositA cold_A) (PositA warm_A))
ConjNP or_Conj (BaseNP (UsePron she_Pron) (UsePron we_Pron))
ConjAdv or_Conj (BaseAdv here_Adv there_Adv)
DConjS either7or_DConj (BaseS (UseCl TPres ASimul PPos (PredVP (UsePron he_Pron) (UseV walk_V))) (UseCl TPres ASimul PPos (PredVP (UsePron she_Pron) (UseV run_V))))
DConjAP both7and_DConj (BaseAP (PositA warm_A) (PositA cold_A))
DConjNP either7or_DConj (BaseNP (UsePron he_Pron) (UsePron she_Pron))
DConjAdv both7and_DConj (BaseAdv here_Adv there_Adv)
-- Idiom
ImpersCl (UseComp (CompAP (PositA hot_A)))
GenericCl (UseV sleep_V)
CleftNP (UsePron i_Pron) (UseRCl TPast ASimul PPos (RelVP IdRP (ComplSlash (SlashV2a do_V2) (UsePron it_Pron))))
CleftAdv here_Adv (UseCl TPast ASimul PPos (PredVP (UsePron she_Pron) (UseV sleep_V)))
ExistNP (DetArtSg IndefArt (UseN house_N))
ExistIP (IdetCN (IdetQuant which_IQuant NumPl) (UseN house_N))
PredVP (UsePron i_Pron) (ProgrVP (UseV sleep_V))
ImpPl1 (UseV go_V)
-- Noun
DetArtSg DefArt (UseN man_N)
UsePN john_PN
UsePron he_Pron
PredetNP only_Predet (DetArtSg DefArt (UseN man_N))
PPartNP (DetArtSg DefArt (UseN man_N)) see_V2
AdvNP (UsePN paris_PN) today_Adv
RelNP (UsePN paris_PN) (UseRCl TPres ASimul PPos (RelVP IdRP (UseComp (CompAdv here_Adv))))
DetNP (DetQuant this_Quant (NumCard (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n5))))))))
DetCN (DetQuantOrd this_Quant (NumCard (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n5))))))) (OrdSuperl good_A)) (UseN man_N)
DetCN (DetQuant this_Quant (NumCard (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n5)))))))) (UseN man_N)
DetCN (DetQuant this_Quant NumPl) (UseN man_N)
DetCN (DetQuant this_Quant NumSg) (UseN man_N)
NumCard (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n5))))))
NumCard (NumDigits (IIDig D_5 (IDig D_1)))
NumCard (NumNumeral (num (pot2as3 (pot1as2 (pot1plus n5 pot01)))))
NumCard (AdNum almost_AdN (NumDigits (IIDig D_5 (IDig D_1))))
OrdDigits (IIDig D_5 (IDig D_1))
OrdNumeral (num (pot2as3 (pot1as2 (pot1plus n5 pot01))))
OrdSuperl warm_A
DetCN (DetArtOrd DefArt (NumCard (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n5))))))) (OrdSuperl good_A)) (UseN man_N)
DetCN (DetArtCard DefArt (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n5))))))) (UseN man_N)
DetCN (DetArtCard IndefArt (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 pot01)))))) (UseN man_N)
DetCN (DetArtCard DefArt (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 pot01)))))) (UseN man_N)
DetArtSg DefArt (UseN man_N)
DetArtPl DefArt (UseN man_N)
MassNP (UseN beer_N)
DetCN (DetQuant (PossPron i_Pron) NumSg) (UseN house_N)
UseN house_N
ComplN2 mother_N2 (DetArtSg DefArt (UseN king_N))
ComplN2 (ComplN3 distance_N3 (DetCN (DetQuant this_Quant NumSg) (UseN city_N))) (UsePN paris_PN)
UseN2 mother_N2
ComplN2 (Use2N3 distance_N3) (DetCN (DetQuant this_Quant NumSg) (UseN city_N))
ComplN2 (Use3N3 distance_N3) (UsePN paris_PN)
UseN2 (Use2N3 distance_N3)
AdjCN (PositA big_A) (UseN house_N)
RelCN (UseN house_N) (UseRCl TPast ASimul PPos (RelSlash IdRP (SlashVP (UsePN john_PN) (SlashV2a buy_V2))))
AdvCN (UseN house_N) (PrepNP on_Prep (DetArtSg DefArt (UseN hill_N)))
SentCN (UseN question_N) (EmbedQS (UseQCl TPres ASimul PPos (QuestIAdv where_IAdv (PredVP (UsePron she_Pron) (UseV sleep_V)))))
ApposCN (UseN city_N) (UsePN paris_PN)
-- Numeral
num (pot2as3 (pot1as2 (pot0as1 (pot0 n6))))
num (pot2as3 (pot1as2 (pot0as1 pot01)))
num (pot2as3 (pot1as2 (pot1 n6)))
num (pot2as3 (pot1as2 pot110))
num (pot2as3 (pot1as2 pot111))
num (pot2as3 (pot1as2 (pot1to19 n6)))
num (pot2as3 (pot1as2 (pot1 n6)))
num (pot2as3 (pot1as2 (pot1plus n6 (pot0 n5))))
num (pot2as3 (pot2 (pot0 n4)))
num (pot2as3 (pot2plus (pot0 n4) (pot1plus n6 (pot0 n7))))
num (pot3 (pot2plus (pot0 n4) (pot1plus n6 (pot0 n7))))
num (pot3plus (pot2plus (pot0 n4) (pot1plus n6 (pot0 n7))) (pot1as2 (pot1plus n8 (pot0 n9))))
IDig D_8
IIDig D_8 (IIDig D_0 (IIDig D_0 (IIDig D_1 (IIDig D_7 (IIDig D_8 (IDig D_9))))))
-- Phrase
PhrUtt but_PConj (UttImpSg PPos (ImpVP (AdvVP (UseV come_V) here_Adv))) (VocNP (DetCN (DetQuant (PossPron i_Pron) NumSg) (UseN friend_N)))
PhrUtt NoPConj (UttS (UseCl TPres ASimul PPos (PredVP (UsePN john_PN) (UseV walk_V)))) NoVoc
UttQS (UseQCl TPres ASimul PPos (QuestCl (PredVP (UsePron it_Pron) (UseComp (CompAP (PositA good_A))))))
UttImpSg PNeg (ImpVP (ReflVP (SlashV2a love_V2)))
UttImpPl PNeg (ImpVP (ReflVP (SlashV2a love_V2)))
UttImpPol PNeg (ImpVP (UseV sleep_V))
UttIP whoPl_IP
UttIP whoSg_IP
UttIAdv why_IAdv
UttNP (DetCN (DetQuant this_Quant NumSg) (UseN man_N))
UttAdv here_Adv
UttVP (UseV sleep_V)
VocNP (DetCN (DetQuant (PossPron i_Pron) NumSg) (UseN friend_N))
-- Question
QuestCl (PredVP (UsePN john_PN) (UseV walk_V))
QuestVP whoSg_IP (UseV walk_V)
QuestSlash whoSg_IP (SlashVP (UsePN john_PN) (SlashV2a love_V2))
QuestIAdv why_IAdv (PredVP (UsePN john_PN) (UseV walk_V))
QuestIComp (CompIAdv where_IAdv) (UsePN john_PN)
IdetCN (IdetQuant which_IQuant (NumCard (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n5)))))))) (UseN song_N)
IdetIP (IdetQuant which_IQuant (NumCard (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n5))))))))
AdvIP whoSg_IP (PrepNP in_Prep (UsePN paris_PN))
IdetIP (IdetQuant which_IQuant NumSg)
PrepIP with_Prep whoSg_IP
QuestIComp (CompIAdv where_IAdv) (UsePron it_Pron)
QuestIComp (CompIP whoSg_IP) (UsePron it_Pron)
-- Relative
ExistNP (DetArtSg IndefArt (RelCN (UseN woman_N) (UseRCl TPres ASimul PPos (RelCl (PredVP (UsePN john_PN) (ComplSlash (SlashV2a love_V2) (UsePron she_Pron)))))))
ExistNP (DetArtSg IndefArt (RelCN (UseN woman_N) (UseRCl TPres ASimul PPos (RelVP IdRP (ComplSlash (SlashV2a love_V2) (UsePN john_PN))))))
ExistNP (DetArtSg IndefArt (RelCN (UseN woman_N) (UseRCl TPres ASimul PPos (RelSlash IdRP (SlashVP (UsePN john_PN) (SlashV2a love_V2))))))
ExistNP (DetArtSg IndefArt (RelCN (UseN woman_N) (UseRCl TPres ASimul PPos (RelSlash (FunRP possess_Prep (DetArtSg DefArt (UseN2 mother_N2)) IdRP) (SlashVP (UsePN john_PN) (SlashV2a love_V2))))))
-- Sentence
PredVP (UsePN john_PN) (UseV walk_V)
PredSCVP (EmbedS (UseCl TPres ASimul PPos (PredVP (UsePron she_Pron) (UseV go_V)))) (UseComp (CompAP (PositA good_A)))
RelCN (UseN girl_N) (UseRCl TPres ASimul PPos (RelSlash IdRP (SlashVP (UsePron he_Pron) (SlashV2a see_V2))))
RelCN (UseN girl_N) (UseRCl TPres ASimul PPos (RelSlash IdRP (AdvSlash (SlashVP (UsePron he_Pron) (SlashV2a see_V2)) today_Adv)))
RelCN (UseN girl_N) (UseRCl TPres ASimul PPos (RelSlash IdRP (SlashPrep (PredVP (UsePron he_Pron) (UseV walk_V)) with_Prep)))
RelCN (UseN girl_N) (UseRCl TPres ASimul PPos (RelSlash IdRP (SlashVS (UsePron she_Pron) say_VS (UseSlash TPres ASimul PPos (SlashVP (UsePron he_Pron) (SlashV2a love_V2))))))
ImpVP (ReflVP (SlashV2a love_V2))
EmbedS (UseCl TPres ASimul PPos (PredVP (UsePron she_Pron) (UseV go_V)))
EmbedQS (UseQCl TPres ASimul PPos (QuestVP whoSg_IP (UseV go_V)))
EmbedVP (UseV go_V)
UseCl TCond AAnter PNeg (PredVP (UsePN john_PN) (UseV walk_V))
UseQCl TCond AAnter PNeg (QuestCl (PredVP (UsePN john_PN) (UseV walk_V)))
RelCN (UseN girl_N) (UseRCl TCond AAnter PNeg (RelVP IdRP (UseV walk_V)))
RelCN (UseN girl_N) (UseRCl TCond AAnter PNeg (RelSlash IdRP (SlashPrep (PredVP (UsePron i_Pron) (UseV walk_V)) with_Prep)))
RelS (UseCl TPres ASimul PPos (PredVP (UsePron she_Pron) (UseV sleep_V))) (UseRCl TPres ASimul PPos (RelVP IdRP (UseComp (CompAP (PositA good_A)))))
-- Text
TEmpty
TFullStop (PhrUtt NoPConj (UttS (UseCl TPres ASimul PPos (PredVP (UsePN john_PN) (UseV walk_V)))) NoVoc) TEmpty
TQuestMark (PhrUtt NoPConj (UttQS (UseQCl TPres ASimul PPos (QuestCl (PredVP (UsePron they_Pron) (UseComp (CompAdv here_Adv)))))) NoVoc) TEmpty
TExclMark (PhrUtt NoPConj (ImpPl1 (UseV go_V)) NoVoc) TEmpty
-- Verb
PredVP (UsePron i_Pron) (UseV sleep_V)
PredVP (UsePron i_Pron) (ComplVV want_VV (UseV run_V))
PredVP (UsePron i_Pron) (ComplVS say_VS (UseCl TPres ASimul PPos (PredVP (UsePron she_Pron) (UseV run_V))))
PredVP (UsePron i_Pron) (ComplVQ wonder_VQ (UseQCl TPres ASimul PPos (QuestVP whoSg_IP (UseV run_V))))
PredVP (UsePron they_Pron) (ComplVA become_VA (PositA red_A))
PredVP (UsePron i_Pron) (ComplSlash (Slash3V3 give_V3 (UsePron he_Pron)) (UsePron it_Pron))
PredVP (UsePron i_Pron) (ComplSlash (SlashV2V beg_V2V (UseV go_V)) (UsePron she_Pron))
PredVP (UsePron i_Pron) (ComplSlash (SlashV2S answer_V2S (UseCl TPres ASimul PPos (PredVP (UsePron it_Pron) (UseComp (CompAP (PositA good_A)))))) (UsePron he_Pron))
PredVP (UsePron i_Pron) (ComplSlash (SlashV2Q ask_V2Q (UseQCl TPast ASimul PPos (QuestVP whoSg_IP (UseV come_V)))) (UsePron he_Pron))
PredVP (UsePron i_Pron) (ComplSlash (SlashV2A paint_V2A (PositA red_A)) (UsePron it_Pron))
RelCN (UseN car_N) (UseRCl TPres ASimul PPos (RelSlash IdRP (SlashVP (UsePron i_Pron) (SlashVV want_VV (SlashV2a buy_V2)))))
RelCN (UseN car_N) (UseRCl TPres ASimul PPos (RelSlash IdRP (SlashVP (UsePron they_Pron) (SlashV2VNP beg_V2V (UsePron i_Pron) (SlashV2a buy_V2)))))
PredVP (UsePron he_Pron) (ReflVP (SlashV2a love_V2))
PredVP (DetNP (DetQuant this_Quant NumSg)) (UseComp (CompAP (PositA warm_A)))
PredVP (UsePron we_Pron) (PassV2 love_V2)
PredVP (UsePron we_Pron) (AdvVP (UseV sleep_V) here_Adv)
PredVP (UsePron we_Pron) (AdVVP always_AdV (UseV sleep_V))
PredVP (UsePron we_Pron) (UseComp (CompAP (PositA small_A)))
PredVP (UsePron i_Pron) (UseComp (CompNP (DetArtSg IndefArt (UseN man_N))))
PredVP (UsePron i_Pron) (UseComp (CompAdv here_Adv))

2
lib/resource/exper/french/AdjectiveFre.gf
View File

@@ -1,2 +0,0 @@
concrete AdjectiveFre of Adjective = CatFre ** AdjectiveRomance with
(ResRomance = ResFre) ;

2
lib/resource/exper/french/AdverbFre.gf
View File

@@ -1,2 +0,0 @@
concrete AdverbFre of Adverb = CatFre ** AdverbRomance with
(ResRomance = ResFre) ;

102
lib/resource/exper/french/BeschFre.gf
View File

@@ -1,102 +0,0 @@
resource BeschFre = open Prelude, MorphoFre in {
flags optimize=noexpand ; -- faster and smaller than =all
oper VerbeN = {s : VF => Str} ;
oper mkNV : Verbe -> VerbeN = \ve -> {s = vvf ve} ;
oper conj : Str -> Verbe = conj1aimer ; --- temp. default
oper v_nancy100inf : Str -> VerbeN = \ve -> {s = table {
VInfin _ => ve ;
_ => nonExist
}
} ;
oper v_besch1 : Str -> VerbeN = \s -> mkNV (conjAvoir s) ;
oper v_besch2 : Str -> VerbeN = \s -> mkNV (conjÊtre s) ;
-- 3-5 not used
oper v_besch6 : Str -> VerbeN = \s -> mkNV (conj1aimer s) ;
oper v_besch7 : Str -> VerbeN = \s -> mkNV (conj1placer s) ;
oper v_besch8 : Str -> VerbeN = \s -> mkNV (conj1manger s) ;
oper v_besch9 : Str -> VerbeN = \s -> mkNV (conj1peser s) ;
oper v_besch10 : Str -> VerbeN = \s -> mkNV (conj1céder s) ;
oper v_besch11 : Str -> VerbeN = \s -> mkNV (conj1jeter s) ;
oper v_besch12 : Str -> VerbeN = \s -> mkNV (conj1jeter s) ;
oper v_besch13 : Str -> VerbeN = \s -> mkNV (conj1aimer s) ;
oper v_besch14 : Str -> VerbeN = \s -> mkNV (conj1assiéger s) ;
oper v_besch15 : Str -> VerbeN = \s -> mkNV (conj1aimer s) ; --- ?
oper v_besch16 : Str -> VerbeN = \s -> mkNV (conj1payer s) ;
oper v_besch17 : Str -> VerbeN = \s -> mkNV (conj1payer s) ;
oper v_besch18 : Str -> VerbeN = \s -> mkNV (conj1envoyer s) ;
oper v_besch19 : Str -> VerbeN = \s -> mkNV (conj2finir s) ;
oper v_besch20 : Str -> VerbeN = \s -> mkNV (conj2haïr s) ;
-- oper v_besch21 : Str -> VerbeN = \s -> mkNV (conj s) ; -- not used
oper v_besch22 : Str -> VerbeN = \s -> mkNV (conj3aller s) ;
oper v_besch23 : Str -> VerbeN = \s -> mkNV (conj3tenir s) ;
oper v_besch24 : Str -> VerbeN = \s -> mkNV (conj3quérir s) ;
oper v_besch25 : Str -> VerbeN = \s -> mkNV (conj3sentir s) ;
oper v_besch26 : Str -> VerbeN = \s -> mkNV (conj3vêtir s) ;
oper v_besch27 : Str -> VerbeN = \s -> mkNV (conj3couvrir s) ;
oper v_besch28 : Str -> VerbeN = \s -> mkNV (conj3cueillir s) ;
oper v_besch29 : Str -> VerbeN = \s -> mkNV (conj3assaillir s) ;
oper v_besch30 : Str -> VerbeN = \s -> mkNV (conj3faillir s) ;
oper v_besch31 : Str -> VerbeN = \s -> mkNV (conj3bouillir s) ;
oper v_besch32 : Str -> VerbeN = \s -> mkNV (conj3dormir s) ;
oper v_besch33 : Str -> VerbeN = \s -> mkNV (conj3courir s) ;
oper v_besch34 : Str -> VerbeN = \s -> mkNV (conj3mourir s) ;
oper v_besch35 : Str -> VerbeN = \s -> mkNV (conj3sentir s) ;
oper v_besch36 : Str -> VerbeN = \s -> mkNV (conj3fuir s) ;
oper v_besch37 : Str -> VerbeN = \s -> mkNV (conj3ouïr s) ;
oper v_besch38 : Str -> VerbeN = \s -> mkNV (conj3cevoir s) ;
oper v_besch39 : Str -> VerbeN = \s -> mkNV (conj3voir s) ;
oper v_besch40 : Str -> VerbeN = \s -> mkNV (conj3pourvoir s) ;
oper v_besch41 : Str -> VerbeN = \s -> mkNV (conj3savoir s) ;
oper v_besch42 : Str -> VerbeN = \s -> mkNV (conj3devoir s) ;
oper v_besch43 : Str -> VerbeN = \s -> mkNV (conj3pouvoir s) ;
oper v_besch44 : Str -> VerbeN = \s -> mkNV (conj3mouvoir s) ;
oper v_besch45 : Str -> VerbeN = \s -> mkNV (conj3pleuvoir s) ;
oper v_besch46 : Str -> VerbeN = \s -> mkNV (conj3falloir s) ;
oper v_besch47 : Str -> VerbeN = \s -> mkNV (conj3valoir s) ;
oper v_besch48 : Str -> VerbeN = \s -> mkNV (conj3vouloir s) ;
oper v_besch49 : Str -> VerbeN = \s -> mkNV (conj3asseoir s) ;
oper v_besch50 : Str -> VerbeN = \s -> mkNV (conj3messeoir s) ; --- ?
oper v_besch51 : Str -> VerbeN = \s -> mkNV (conj3surseoir s) ;
oper v_besch52 : Str -> VerbeN = \s -> mkNV (conj3choir s) ;
oper v_besch53 : Str -> VerbeN = \s -> mkNV (conj3rendre s) ;
oper v_besch54 : Str -> VerbeN = \s -> mkNV (conj3prendre s) ;
oper v_besch55 : Str -> VerbeN = \s -> mkNV (conj3battre s) ;
oper v_besch56 : Str -> VerbeN = \s -> mkNV (conj3mettre s) ;
oper v_besch57 : Str -> VerbeN = \s -> mkNV (conj3peindre s) ;
oper v_besch58 : Str -> VerbeN = \s -> mkNV (conj3joindre s) ;
oper v_besch59 : Str -> VerbeN = \s -> mkNV (conj3craindre s) ;
oper v_besch60 : Str -> VerbeN = \s -> mkNV (conj3vaincre s) ;
oper v_besch61 : Str -> VerbeN = \s -> mkNV (conj3traire s) ;
oper v_besch62 : Str -> VerbeN = \s -> mkNV (conj3faire s) ;
oper v_besch63 : Str -> VerbeN = \s -> mkNV (conj3plaire s) ;
oper v_besch64 : Str -> VerbeN = \s -> mkNV (conj3connaître s) ;
oper v_besch65 : Str -> VerbeN = \s -> mkNV (conj3naître s) ;
oper v_besch66 : Str -> VerbeN = \s -> mkNV (conj3paître s) ;
oper v_besch67 : Str -> VerbeN = \s -> mkNV (conj3croître s) ;
oper v_besch68 : Str -> VerbeN = \s -> mkNV (conj3croire s) ;
oper v_besch69 : Str -> VerbeN = \s -> mkNV (conj3boire s) ;
oper v_besch70 : Str -> VerbeN = \s -> mkNV (conj3clore s) ;
oper v_besch71 : Str -> VerbeN = \s -> mkNV (conj3conclure s) ;
oper v_besch72 : Str -> VerbeN = \s -> mkNV (conj3absoudre s) ;
oper v_besch73 : Str -> VerbeN = \s -> mkNV (conj3coudre s) ;
oper v_besch74 : Str -> VerbeN = \s -> mkNV (conj3moudre s) ;
oper v_besch75 : Str -> VerbeN = \s -> mkNV (conj3suivre s) ;
oper v_besch76 : Str -> VerbeN = \s -> mkNV (conj3vivre s) ;
oper v_besch77 : Str -> VerbeN = \s -> mkNV (conj3lire s) ;
oper v_besch78 : Str -> VerbeN = \s -> mkNV (conj3dire s) ;
oper v_besch79 : Str -> VerbeN = \s -> mkNV (conj3rire s) ;
oper v_besch80 : Str -> VerbeN = \s -> mkNV (conj3écrire s) ;
oper v_besch81 : Str -> VerbeN = \s -> mkNV (conj3confire s) ;
oper v_besch82 : Str -> VerbeN = \s -> mkNV (conj3cuire s) ;
-- 83-99 not used
oper v_besch100 : Str -> VerbeN = \s -> mkNV (conj s) ; --- to do
oper v_besch101 : Str -> VerbeN = \s -> mkNV (conj s) ; --- to do
}

4
lib/resource/exper/french/CatFre.gf
View File

@@ -1,4 +0,0 @@
--# -path=.:../romance:../common:../abstract:../common:prelude
concrete CatFre of Cat = CommonX - [Tense,TPres,TPast,TFut,TCond] ** CatRomance with
(ResRomance = ResFre) ;

2
lib/resource/exper/french/ConjunctionFre.gf
View File

@@ -1,2 +0,0 @@
concrete ConjunctionFre of Conjunction = CatFre ** ConjunctionRomance with
(ResRomance = ResFre) ;

211
lib/resource/exper/french/DiffFre.gf
View File

@@ -1,211 +0,0 @@
--# -path=.:../romance:../abstract:../common:prelude
instance DiffFre of DiffRomance = open CommonRomance, PhonoFre, Prelude in {
flags optimize=noexpand ;
-- flags optimize=all ;
param
Prepos = P_de | P_a ;
VType = VHabere | VEsse | VRefl ;
oper
dative : Case = CPrep P_a ;
genitive : Case = CPrep P_de ;
prepCase : Case -> Str = \c -> case c of {
Nom => [] ;
Acc => [] ;
CPrep P_a => "à" ;
CPrep P_de => elisDe
} ;
artDef : Gender -> Number -> Case -> Str = \g,n,c ->
case <g,n,c> of {
<Masc,Sg, CPrep P_de> => pre {"du" ; ["de l'"] / voyelle} ;
<Masc,Sg, CPrep P_a> => pre {"au" ; ["à l'"] / voyelle} ;
<Masc,Sg, _> => elisLe ;
<Fem, Sg, _> => prepCase c ++ elisLa ;
<_, Pl, CPrep P_de> => "des" ;
<_, Pl, CPrep P_a> => "aux" ;
<_, Pl, _ > => "les"
} ;
-- In these two, "de de/du/des" becomes "de".
artIndef = \g,n,c -> case <n,c> of {
<Sg,_> => prepCase c ++ genForms "un" "une" ! g ;
<Pl,CPrep P_de> => elisDe ;
_ => prepCase c ++ "des"
} ;
possCase = \_,_,c -> prepCase c ;
partitive = \g,c -> case c of {
CPrep P_de => elisDe ;
_ => prepCase c ++ artDef g Sg (CPrep P_de)
} ;
conjunctCase : NPForm -> NPForm = \c -> case c of {
Aton k => Ton k ;
_ => c
} ;
auxVerb : VType -> (VF => Str) = \vtyp -> case vtyp of {
VHabere => avoir_V.s ;
_ => copula.s
} ;
partAgr : VType -> VPAgr = \vtyp -> case vtyp of {
VHabere => vpAgrNone ;
_ => VPAgrSubj
} ;
vpAgrClit : Agr -> VPAgr = \a ->
VPAgrClit (aagr a.g a.n) ; --- subty
---- pronArg = pronArgGen Neg ; --- takes more space and time
pronArg : Number -> Person -> CAgr -> CAgr -> Str * Str * Bool =
\n,p,acc,dat ->
let
pacc = case acc of {
CRefl => <case p of {
P3 => elision "s" ; --- use of reflPron incred. expensive
_ => argPron Fem n p Acc
},True> ;
CPron ag an ap => <argPron ag an ap Acc,True> ;
_ => <[],False>
} ;
in
case dat of {
CPron ag an ap => let pdat = argPron ag an ap dative in case ap of {
P3 => <pacc.p1 ++ pdat,[],True> ;
_ => <pdat ++ pacc.p1,[],True>
} ;
_ => <pacc.p1, [],pacc.p2>
} ;
-- Positive polarity is used in the imperative: stressed for 1st and
-- 2nd persons.
pronArgGen : Polarity -> Number -> Person -> CAgr -> CAgr -> Str * Str =
\b,n,p,acc,dat ->
let
cas : Person -> Case -> Case = \pr,c -> case <pr,b> of {
<P1 | P2, Pos> => CPrep P_de ; --- encoding in argPron
_ => c
} ;
pacc = case acc of {
CRefl => case p of {
P3 => elision "s" ; --- use of reflPron incred. expensive
_ => argPron Fem n p (cas p Acc)
} ;
CPron ag an ap => argPron ag an ap (cas ap Acc) ;
_ => []
} ;
pdat = case dat of {
CPron ag an ap => argPron ag an ap (cas ap dative) ;
_ => []
} ;
in
case dat of {
CPron _ _ P3 => <pacc ++ pdat,[]> ;
_ => <pdat ++ pacc, []>
} ;
mkImperative b p vp = {
s = \\pol,aag =>
let
num = if_then_else Number b Pl aag.n ;
agr = {g = aag.g ; n = num ; p = p} ;
verb = (vp.s ! VPImperat).fin ! agr ;
neg = vp.neg ! pol ;
hascl = (pronArg agr.n agr.p vp.clAcc vp.clDat).p3 ;
clpr = pronArgGen pol agr.n agr.p vp.clAcc vp.clDat ;
compl = neg.p2 ++ clpr.p2 ++ vp.comp ! agr ++ vp.ext ! pol
in
case pol of {
Pos => verb ++ if_then_Str hascl "-" [] ++ clpr.p1 ++ compl ;
Neg => neg.p1 ++ clpr.p1 ++ verb ++ compl
}
} ;
negation : Polarity => (Str * Str) = table {
Pos => <[],[]> ;
Neg => <elisNe,"pas">
} ;
conjThan = elisQue ;
conjThat = elisQue ;
subjIf = "si" ; --- s'
clitInf _ cli inf = cli ++ inf ;
relPron : Bool => AAgr => Case => Str = \\b,a,c =>
let
lequel = artDef a.g a.n c + quelPron ! a
in
case b of {
False => case c of {
Nom => "qui" ;
Acc => elisQue ;
CPrep P_de => "dont" ;
_ => lequel
} ;
_ => lequel
} ;
pronSuch : AAgr => Str = aagrForms "tel" "telle" "tels" "telles" ;
quelPron : AAgr => Str = aagrForms "quel" "quelle" "quels" "quelles" ;
partQIndir = [] ; --- only for qui,que: elision "c" ;
reflPron : Number -> Person -> Case -> Str = \n,p,c ->
let pron = argPron Fem n p c in
case <p,c> of {
<P3, Acc | CPrep P_a> => elision "s" ;
<P3, _> => prepCase c ++ "soi" ;
_ => pron
} ;
argPron : Gender -> Number -> Person -> Case -> Str =
let
cases : (x,y : Str) -> Case -> Str = \me,moi,c -> case c of {
Acc | CPrep P_a => me ;
_ => moi
} ;
cases3 : (x,y,z : Str) -> Case -> Str = \les,leur,eux,c -> case c of {
Acc => les ;
CPrep P_a => leur ;
_ => eux
} ;
in
\g,n,p -> case <g,n,p> of {
<_,Sg,P1> => cases (elision "m") "moi" ;
<_,Sg,P2> => cases (elision "t") "toi" ;
<_,Pl,P1> => \_ -> "nous" ;
<_,Pl,P2> => \_ -> "vous" ;
<Fem,Sg,P3> => cases3 elisLa "lui" "elle" ;
<_,Sg,P3> => cases3 (elision "l") "lui" "lui" ;
<Fem,Pl,P3> => cases3 "les" "leur" "elles" ;
<_,Pl,P3> => cases3 "les" "leur" "eux"
} ;
vRefl : VType = VRefl ;
isVRefl : VType -> Bool = \ty -> case ty of {
VRefl => True ;
_ => False
} ;
auxPassive : Verb = copula ;
copula : Verb = {s = table VF ["être";"être";"suis";"es";"est";"sommes";"êtes";"sont";"sois";"sois";"soit";"soyons";"soyez";"soient";"étais";"étais";"était";"étions";"étiez";"étaient";"fusse";"fusses";"fût";"fussions";"fussiez";"fussent";"fus";"fus";"fut";"fûmes";"fûtes";"furent";"serai";"seras";"sera";"serons";"serez";"seront";"serais";"serais";"serait";"serions";"seriez";"seraient";"sois";"soyons";"soyez";"été";"étés";"étée";"étées";"étant"]; vtyp=VHabere} ;
avoir_V : Verb = {s=table VF ["avoir";"avoir";"ai";"as";"a";"avons";"avez";"ont";"aie";"aies";"ait";"ayons";"ayez";"aient";"avais";"avais";"avait";"avions";"aviez";"avaient";"eusse";"eusses";"eût";"eussions";"eussiez";"eussent";"eus";"eus";"eut";"eûmes";"eûtes";"eurent";"aurai";"auras";"aura";"aurons";"aurez";"auront";"aurais";"aurais";"aurait";"aurions";"auriez";"auraient";"aie";"ayons";"ayez";"eu";"eus";"eue";"eues";"ayant"];vtyp=VHabere};
}

60
lib/resource/exper/french/ExtraFre.gf
View File

@@ -1,60 +0,0 @@
concrete ExtraFre of ExtraFreAbs = ExtraRomanceFre **
open CommonRomance, PhonoFre, MorphoFre, ParadigmsFre, ParamX, ResFre in {
lin
EstcequeS qs = {s = "est-ce" ++ elisQue ++ qs.s ! Indic} ;
EstcequeIAdvS idet qs = {s = idet.s ++ "est-ce" ++ elisQue ++ qs.s ! Indic} ;
QueestcequeIP = {
s = table {
c => prepQue c ++ "est-ce" ++ caseQue c
} ;
a = aagr Fem Pl
} ;
QuiestcequeIP = {
s = table {
c => prepQue c ++ "qui" ++ "est-ce" ++ caseQue c
} ;
a = aagr Fem Pl
} ;
i8fem_Pron = mkPronoun
(elision "j") (elision "m") (elision "m") "moi" "mon" (elisPoss "m") "mes"
Fem Sg P1 ;
these8fem_NP = makeNP ["celles-ci"] Fem Pl ;
they8fem_Pron = mkPronoun
"elles" "les" "leur" "eux" "leur" "leur" "leurs"
Fem Pl P3 ;
this8fem_NP = pn2np (mkPN ["celle-ci"] Fem) ;
those8fem_NP = makeNP ["celles-là"] Fem Pl ;
we8fem_Pron = mkPronoun "nous" "nous" "nous" "nous" "notre" "notre" "nos"
Fem Pl P1 ;
whoPl8fem_IP =
{s = \\c => artDef a.g a.n c + quelPron ! a ; a = a}
where {a = aagr Fem Sg} ;
whoSg8fem_IP =
{s = \\c => artDef a.g a.n c + quelPron ! a ; a = a}
where {a = aagr Fem Pl} ;
youSg8fem_Pron = mkPronoun
"tu" (elision "t") (elision "t") "toi" "ton" (elisPoss "t") "tes"
Fem Sg P2 ;
youPl8fem_Pron,
youPol8fem_Pron =
mkPronoun
"vous" "vous" "vous" "vous" "votre" "votre" "vos"
Fem Pl P2 ;
oper
prepQue : Case -> Str = \c -> case c of {
Nom | Acc => elisQue ;
_ => prepCase c ++ "qui" ---
} ;
caseQue : Case -> Str = \c -> case c of {
Nom => "qui" ;
_ => elisQue
} ;
}

34
lib/resource/exper/french/ExtraFreAbs.gf
View File

@@ -1,34 +0,0 @@
-- Structures special for French. These are not implemented in other
-- Romance languages.
abstract ExtraFreAbs = ExtraRomanceAbs ** {
-- Notice: only direct (main-clause) questions are generated, and needed.
fun
EstcequeS : S -> Utt ; -- est-ce qu'il pleut
EstcequeIAdvS : IAdv -> S -> Utt ; -- où est-ce qu'il pleut
-- These also generate indirect (subordinate) questions.
QueestcequeIP : IP ; -- qu'est-ce (que/qui)
QuiestcequeIP : IP ; -- qu'est-ce (que/qui)
-- Feminine variants of pronouns (those in $Structural$ are
-- masculine, which is the default when gender is unknown).
i8fem_Pron : Pron ;
these8fem_NP : NP ;
they8fem_Pron : Pron ;
this8fem_NP : NP ;
those8fem_NP : NP ;
we8fem_Pron : Pron ;
whoPl8fem_IP : IP ;
whoSg8fem_IP : IP ;
youSg8fem_Pron : Pron ;
youPl8fem_Pron : Pron ;
youPol8fem_Pron : Pron ;
}

2
lib/resource/exper/french/ExtraRomanceFre.gf
View File

@@ -1,2 +0,0 @@
concrete ExtraRomanceFre of ExtraRomanceAbs = CatFre ** ExtraRomance with
(ResRomance = ResFre) ;

7
lib/resource/exper/french/French.gf
View File

@@ -1,7 +0,0 @@
--# -path=.:../romance:../abstract:../common:prelude
concrete French of FrenchAbs =
LangFre,
IrregFre,
ExtraFre
** {} ;

5
lib/resource/exper/french/FrenchAbs.gf
View File

@@ -1,5 +0,0 @@
abstract FrenchAbs =
Lang,
IrregFreAbs,
ExtraFreAbs
** {} ;

21
lib/resource/exper/french/GrammarFre.gf
View File

@@ -1,21 +0,0 @@
--# -path=.:../romance:../abstract:../common:prelude
concrete GrammarFre of Grammar =
NounFre,
VerbFre,
AdjectiveFre,
AdverbFre,
NumeralFre,
SentenceFre,
QuestionFre,
RelativeFre,
ConjunctionFre,
PhraseFre,
TextX - [Tense,TPres,TPast,TFut,TCond],
IdiomFre,
StructuralFre
** {
flags startcat = Phr ; unlexer = text ; lexer = text ;
} ;

45
lib/resource/exper/french/IdiomFre.gf
View File

@@ -1,45 +0,0 @@
concrete IdiomFre of Idiom = CatFre **
open (P = ParamX), PhonoFre, MorphoFre, ParadigmsFre, Prelude in {
flags optimize=all_subs ;
lin
ImpersCl vp = mkClause "il" True (agrP3 Masc Sg) vp ;
GenericCl vp = mkClause "on" True (agrP3 Masc Sg) vp ;
ExistNP np =
mkClause "il" True (agrP3 Masc Sg)
(insertClit2 "y" (insertComplement (\\_ => np.s ! Ton Acc) (predV avoir_V))) ;
ExistIP ip = {
s = \\t,a,p,_ =>
ip.s ! Nom ++
(mkClause "il" True (agrP3 Masc Sg)
(insertClit2 "y" (predV avoir_V))).s
! DDir ! t ! a ! p ! Indic ---- DInv
} ;
CleftNP np rs = mkClause elisCe True (agrP3 Masc Sg)
(insertComplement (\\_ => rs.s ! Indic ! np.a)
(insertComplement (\\_ => np.s ! Ton rs.c) (predV copula))) ;
CleftAdv ad s = mkClause elisCe True (agrP3 Masc Sg)
(insertComplement (\\_ => conjThat ++ s.s ! Indic)
(insertComplement (\\_ => ad.s) (predV copula))) ;
ProgrVP vp =
insertComplement
(\\a => "en" ++ "train" ++ elisDe ++ infVP vp a)
(predV copula) ;
ImpPl1 vp = {s =
(mkImperative False P1 vp).s ! Pos ! {n = Pl ; g = Masc} --- fem
} ;
oper
elisCe = elision "c" ;
}

395
lib/resource/exper/french/IrregFre.gf
View File

@@ -1,395 +0,0 @@
--# -path=.:../romance:../common:../abstract:../../prelude
-- Irregular verbs from Nancy, based on a list from Sylvain Pogodalla, 25/11/2004
-- Translated to GF by Aarne Ranta
-- added extracted subcat information 29/11
concrete IrregFre of IrregFreAbs = CatFre **
open DiffFre, MorphoFre, BeschFre, Prelude in {
flags optimize=values ;
-- all verbs in classes with "er" and "finir" are omitted
lin
abattre_V2 = v_besch55 "abattre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
absoudre_V2 = v_besch72 "absoudre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
abstenir_V = v_besch23 "abstenir" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ;
abstraire_V2 = v_besch61 "abstraire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
accourir_V = v_besch33 "accourir" ** {vtyp = VHabere ; lock_V = <>} ;
accroître_V2 = v_besch73 "accroître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
accueillir_V2 = v_besch28 "accueillir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
acquérir_V2 = v_besch24 "acquérir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
adjoindre_V2 = v_besch58 "adjoindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
admettre_V2 = v_besch56 "admettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
advenir_V = v_besch23 "advenir" ** {vtyp = VEsse ; lock_V = <>} ;
aller_V = v_besch22 "aller" ** {vtyp = VEsse ; lock_V = <>} ;
apercevoir_V2 = v_besch38 "apercevoir" ** {vtyp = VRefl ; lock_V2 = <> ; c2 = complGen} ;
apparaître_V = v_besch64 "apparaître" ** {vtyp = VHabere ; lock_V = <>} ;
appartenir_V2 = v_besch23 "appartenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
appendre_V2 = v_besch53 "appendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
apprendre_V2 = v_besch54 "apprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
assaillir_V2 = v_besch29 "assaillir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
asseoir_V2 = v_besch49 "asseoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
astreindre_V2 = v_besch57 "astreindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
atteindre_V2 = v_besch57 "atteindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
attendre_V2 = v_besch53 "attendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
avoir_V2 = v_besch1 "avoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
battre_V2 = v_besch55 "battre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
boire_V2 = v_besch69 "boire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
bouillir_V2 = v_besch31 "bouillir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
braire_V = v_besch61 "braire" ** {vtyp = VHabere ; lock_V = <>} ;
ceindre_V2 = v_besch57 "ceindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
choir_V = v_besch52 "choir" ** {vtyp = VEsse ; lock_V = <>} ;
circonscrire_V2 = v_besch80 "circonscrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
circonvenir_V2 = v_besch23 "circonvenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
clore_V2 = v_besch70 "clore" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
combattre_V2 = v_besch55 "combattre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
commettre_V2 = v_besch56 "commettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
comparaître_V2 = v_besch64 "comparaître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
complaire_V2 = v_besch63 "complaire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
comprendre_V2 = v_besch54 "comprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
compromettre_V2 = v_besch56 "compromettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
concevoir_V2 = v_besch38 "concevoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
conclure_V2 = v_besch71 "conclure" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
concourir_V2 = v_besch33 "concourir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
condescendre_V2 = v_besch53 "condescendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
conduire_V2 = v_besch82 "conduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
confire_V2 = v_besch81 "confire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
confondre_V2 = v_besch53 "confondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
conjoindre_V2 = v_besch58 "conjoindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
connaître_V2 = v_besch64 "connaître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
conquérir_V2 = v_besch24 "conquérir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
consentir_V2 = v_besch25 "consentir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
construire_V2 = v_besch82 "construire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
contenir_V2 = v_besch23 "contenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
contraindre_V2 = v_besch59 "contraindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
contrebattre_V2 = v_besch55 "contrebattre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
contredire_V2 = v_besch78 "contredire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
contrefaire_V2 = v_besch62 "contrefaire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
contrevenir_V2 = v_besch23 "contrevenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
convaincre_V2 = v_besch60 "convaincre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ;
convenir_V2 = v_besch23 "convenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ;
correspondre_V2 = v_besch53 "correspondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
corrompre_V2 = v_besch53 "corrompre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
coudre_V2 = v_besch73 "coudre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
courir_V2 = v_besch33 "courir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
couvrir_V2 = v_besch27 "couvrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
craindre_V2 = v_besch59 "craindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
croire_V2 = v_besch68 "croire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
croître_V = v_besch67 "croître" ** {vtyp = VEsse ; lock_V = <>} ;
cueillir_V2 = v_besch28 "cueillir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
cuire_V2 = v_besch82 "cuire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
débattre_V2 = v_besch55 "débattre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
débouillir_V2 = v_besch31 "débouillir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
décevoir_V2 = v_besch38 "décevoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
déchoir_V2 = v_besch52 "déchoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
déclore_V2 = v_besch70 "déclore" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
décommettre_V2 = v_besch56 "décommettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
déconfire_V2 = v_besch81 "déconfire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
découdre_V2 = v_besch73 "découdre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
découvrir_V2 = v_besch27 "découvrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
décrire_V2 = v_besch80 "décrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
décroître_V2 = v_besch67 "décroître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
décuire_V2 = v_besch82 "décuire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
déduire_V2 = v_besch82 "déduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
défaillir_V = v_besch30 "défaillir" ** {vtyp = VHabere ; lock_V = <>} ;
défaire_V2 = v_besch62 "défaire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
défendre_V2 = v_besch53 "défendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
démentir_V2 = v_besch25 "démentir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
démettre_V2 = v_besch56 "démettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
démordre_V = v_besch53 "démordre" ** {vtyp = VHabere ; lock_V = <>} ;
départir_V2 = v_besch25 "départir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ;
dépeindre_V2 = v_besch57 "dépeindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
dépendre_V2 = v_besch53 "dépendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ;
déplaire_V = v_besch63 "déplaire" ** {vtyp = VHabere ; lock_V = <>} ;
dépourvoir_V2 = v_besch40 "dépourvoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
déprendre_V2 = v_besch54 "déprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ;
désapprendre_V2 = v_besch54 "désapprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
descendre_V2 = v_besch53 "descendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
desservir_V2 = v_besch35 "desservir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
déteindre_V2 = v_besch57 "déteindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
détendre_V2 = v_besch53 "détendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
détenir_V2 = v_besch23 "détenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
détordre_V2 = v_besch53 "détordre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
détruire_V2 = v_besch82 "détruire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
devenir_V = v_besch23 "devenir" ** {vtyp = VEsse ; lock_V = <>} ;
dévêtir_V2 = v_besch26 "dévêtir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
devoir_V2 = v_besch42 "devoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
dire_V2 = v_besch78 "dire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
disconvenir_V2 = v_besch23 "disconvenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ;
discourir_V2 = v_besch33 "discourir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ;
disjoindre_V2 = v_besch58 "disjoindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
disparaître_V2 = v_besch64 "disparaître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
dissoudre_V2 = v_besch72 "dissoudre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
distendre_V2 = v_besch53 "distendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
distordre_V2 = v_besch53 "distordre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
distraire_V2 = v_besch61 "distraire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
dormir_V2 = v_besch32 "dormir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
ébattre_V = v_besch55 "ébattre" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ;
échoir_V2 = v_besch52 "échoir" ** {vtyp = VEsse ; lock_V2 = <> ; c2 = complDat} ;
éclore_V2 = v_besch70 "éclore" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
éconduire_V2 = v_besch82 "éconduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
écrire_V2 = v_besch80 "écrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
élire_V2 = v_besch77 "élire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
embatre_V2 = v_besch55 "embatre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
embattre_V2 = v_besch55 "embattre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
emboire_V = v_besch69 "emboire" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ;
émettre_V2 = v_besch56 "émettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
émoudre_V2 = v_besch74 "émoudre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
émouvoir_V2 = v_besch44 "émouvoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
empreindre_V2 = v_besch57 "empreindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ;
enceindre_V2 = v_besch57 "enceindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
enclore_V2 = v_besch70 "enclore" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
encourir_V2 = v_besch33 "encourir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
endormir_V2 = v_besch32 "endormir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
enduire_V2 = v_besch82 "enduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
enfreindre_V2 = v_besch57 "enfreindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
enfuir_V = v_besch36 "enfuir" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ;
enjoindre_V2 = v_besch58 "enjoindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
enquérir_V = v_besch24 "enquérir" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ;
entendre_V2 = v_besch53 "entendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
entr'apercevoir_V = v_besch38 "entr'apercevoir" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ;
entrebattre_V = v_besch55 "entrebattre" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ;
entre_détruire_V = v_besch82 "entre-détruire" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ;
entre_haïr_V = v_besch20 "entre-haïr" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ;
entremettre_V = v_besch56 "entremettre" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ;
entre_nuire_V = v_besch82 "entre-nuire" ** {vtyp = VHabere ; lock_V = <>} ;
entreprendre_V2 = v_besch54 "entreprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
entretenir_V2 = v_besch23 "entretenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
entrevoir_V2 = v_besch39 "entrevoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
entrouvrir_V2 = v_besch27 "entrouvrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
envoyer_V2 = v_besch18 "envoyer" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
épandre_V2 = v_besch53 "épandre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
éperdre_V = v_besch53 "éperdre" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ;
éprendre_V = v_besch54 "éprendre" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ;
équivaloir_V2 = v_besch47 "équivaloir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
éteindre_V2 = v_besch57 "éteindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
étendre_V2 = v_besch53 "étendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
étreindre_V2 = v_besch57 "étreindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
être_V = v_besch2 "être" ** {vtyp = VHabere ; lock_V = <>} ;
exclure_V2 = v_besch71 "exclure" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
extraire_V2 = v_besch61 "extraire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
faillir_V2 = v_besch30 "faillir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
faire_V2 = v_besch62 "faire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
falloir_V = v_besch46 "falloir" ** {vtyp = VHabere ; lock_V = <>} ;
feindre_V2 = v_besch57 "feindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
fendre_V2 = v_besch53 "fendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
fondre_V2 = v_besch53 "fondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
forfaire_V2 = v_besch62 "forfaire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
foutre_V2 = v_besch53 "foutre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ;
frire_V2 = v_besch81 "frire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
fuir_V2 = v_besch36 "fuir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
geindre_V2 = v_besch57 "geindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
gésir_V2 = mkNV (conj3gésir "gésir") ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
haïr_V2 = v_besch20 "haïr" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
inclure_V2 = v_besch71 "inclure" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
induire_V2 = v_besch82 "induire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
inscrire_V2 = v_besch80 "inscrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
instruire_V2 = v_besch82 "instruire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
interdire_V2 = v_besch78 "interdire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
interrompre_V2 = v_besch53 "interrompre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
intervenir_V = v_besch23 "intervenir" ** {vtyp = VEsse ; lock_V = <>} ;
introduire_V2 = v_besch82 "introduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
joindre_V2 = v_besch58 "joindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
lire_V2 = v_besch77 "lire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
luire_V = v_besch82 "luire" ** {vtyp = VHabere ; lock_V = <>} ;
mainmettre_V2 = v_besch56 "mainmettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
maintenir_V2 = v_besch23 "maintenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
méconnaître_V2 = v_besch64 "méconnaître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
mécroire_V2 = v_besch68 "mécroire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
médire_V2 = v_besch78 "médire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ;
mentir_V2 = v_besch25 "mentir" ** {vtyp = VEsse ; lock_V2 = <> ; c2 = complDat} ;
méprendre_V2 = v_besch54 "méprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
messeoir_V2 = v_besch50 "messeoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
mettre_V2 = v_besch56 "mettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
mévendre_V2 = v_besch53 "mévendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
mordre_V2 = v_besch53 "mordre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
morfondre_V = v_besch53 "morfondre" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ;
moudre_V2 = v_besch74 "moudre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
mourir_V = v_besch34 "mourir" ** {vtyp = VEsse ; lock_V = <>} ;
mouvoir_V2 = v_besch44 "mouvoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ;
naître_V = v_besch65 "naître" ** {vtyp = VEsse ; lock_V = <>} ;
nuire_V2 = v_besch82 "nuire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
obtenir_V2 = v_besch23 "obtenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
obvenir_V = v_besch23 "obvenir" ** {vtyp = VEsse ; lock_V = <>} ;
occlure_V2 = v_besch71 "occlure" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
offrir_V2 = v_besch27 "offrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
oindre_V2 = v_besch58 "oindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
omettre_V2 = v_besch56 "omettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
ouïr_V2 = v_besch37 "ouïr" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
ouvrir_V2 = v_besch27 "ouvrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
paître_V2 = v_besch66 "paître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
paître_V = v_besch66 "paître" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ;
paraître_V = v_besch64 "paraître" ** {vtyp = VHabere ; lock_V = <>} ;
parcourir_V2 = v_besch33 "parcourir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
parfondre_V2 = v_besch53 "parfondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
partir_V = v_besch25 "partir" ** {vtyp = VEsse ; lock_V = <>} ;
parvenir_V = v_besch23 "parvenir" ** {vtyp = VEsse ; lock_V = <>} ;
peindre_V2 = v_besch57 "peindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
pendre_V2 = v_besch53 "pendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
percevoir_V2 = v_besch38 "percevoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
perdre_V2 = v_besch53 "perdre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
permettre_V2 = v_besch56 "permettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
plaindre_V2 = v_besch59 "plaindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
plaire_V2 = v_besch63 "plaire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
pleuvoir_V = v_besch45 "pleuvoir" ** {vtyp = VHabere ; lock_V = <>} ;
poindre_V2 = v_besch58 "poindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
pondre_V2 = v_besch53 "pondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
pourfendre_V2 = v_besch53 "pourfendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
poursuivre_V2 = v_besch75 "poursuivre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
pourvoir_V2 = v_besch40 "pourvoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
pouvoir_V = v_besch43 "pouvoir" ** {vtyp = VHabere ; lock_V = <>} ;
prédire_V2 = v_besch78 "prédire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
prendre_V2 = v_besch54 "prendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
prescrire_V2 = v_besch80 "prescrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
pressentir_V2 = v_besch25 "pressentir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
prétendre_V2 = v_besch53 "prétendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
prévaloir_V2 = v_besch47 "prévaloir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ;
prévenir_V2 = v_besch23 "prévenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
prévoir_V2 = v_besch39 "prévoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
produire_V2 = v_besch82 "produire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
promettre_V2 = v_besch56 "promettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
promouvoir_V2 = v_besch44 "promouvoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
proscrire_V2 = v_besch80 "proscrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
provenir_V = v_besch23 "provenir" ** {vtyp = VEsse ; lock_V = <>} ;
rabattre_V2 = v_besch55 "rabattre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
raire_V2 = v_besch61 "raire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
rapprendre_V2 = v_besch54 "rapprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
rasseoir_V2 = v_besch49 "rasseoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
réadmettre_V2 = v_besch56 "réadmettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
réapparaître_V = v_besch64 "réapparaître" ** {vtyp = VHabere ; lock_V = <>} ;
réapprendre_V2 = v_besch54 "réapprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
rebattre_V2 = v_besch55 "rebattre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
recevoir_V2 = v_besch38 "recevoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
recomparaître_V2 = v_besch64 "recomparaître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
reconduire_V2 = v_besch82 "reconduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
reconnaître_V2 = v_besch64 "reconnaître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
reconquérir_V2 = v_besch24 "reconquérir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
reconstruire_V2 = v_besch82 "reconstruire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
recoudre_V2 = v_besch73 "recoudre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
recourir_V2 = v_besch33 "recourir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
recouvrir_V2 = v_besch27 "recouvrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
récrire_V2 = v_besch80 "récrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
recroître_V2 = v_besch67 "recroître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
recueillir_V2 = v_besch28 "recueillir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
recuire_V2 = v_besch82 "recuire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
redécouvrir_V2 = v_besch27 "redécouvrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
redéfaire_V2 = v_besch62 "redéfaire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
redescendre_V2 = v_besch53 "redescendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
redevenir_V = v_besch23 "redevenir" ** {vtyp = VEsse ; lock_V = <>} ;
redevoir_V2 = v_besch42 "redevoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
redire_V2 = v_besch78 "redire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
réduire_V2 = v_besch82 "réduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
réécrire_V2 = v_besch80 "réécrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
réélire_V2 = v_besch77 "réélire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
réentendre_V2 = v_besch53 "réentendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
refaire_V2 = v_besch62 "refaire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
refendre_V2 = v_besch53 "refendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
refondre_V2 = v_besch53 "refondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
réinscrire_V2 = v_besch80 "réinscrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
réintroduire_V2 = v_besch82 "réintroduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
rejoindre_V2 = v_besch58 "rejoindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
relire_V2 = v_besch77 "relire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
reluire_V2 = v_besch82 "reluire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
remettre_V2 = v_besch56 "remettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
remordre_V2 = v_besch53 "remordre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
remoudre_V2 = v_besch74 "remoudre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
renaître_V2 = v_besch65 "renaître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
rendormir_V2 = v_besch32 "rendormir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
rendre_V2 = v_besch53 "rendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
rentraire_V2 = v_besch61 "rentraire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
rentrouvrir_V2 = v_besch27 "rentrouvrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
renvoyer_V2 = v_besch18 "renvoyer" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
repaître_V2 = v_besch66 "repaître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
répandre_V2 = v_besch53 "répandre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
reparaître_V = v_besch64 "reparaître" ** {vtyp = VEsse ; lock_V = <>} ;
repartir_V = v_besch25 "repartir" ** {vtyp = VEsse ; lock_V = <>} ;
repeindre_V2 = v_besch57 "repeindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
rependre_V2 = v_besch53 "rependre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
repentir_V = v_besch25 "repentir" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ;
reperdre_V2 = v_besch53 "reperdre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
repleuvoir_V = v_besch45 "repleuvoir" ** {vtyp = VHabere ; lock_V = <>} ;
répondre_V2 = v_besch53 "répondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
reprendre_V2 = v_besch54 "reprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
reproduire_V2 = v_besch82 "reproduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
requérir_V2 = v_besch24 "requérir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
résoudre_V2 = mkNV (conj3résoudre "résoudre") ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
ressentir_V2 = v_besch25 "ressentir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ;
resservir_V2 = v_besch35 "resservir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
ressortir_V = v_besch25 "ressortir" ** {vtyp = VEsse ; lock_V = <>} ;
ressouvenir_V = v_besch23 "ressouvenir" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ;
restreindre_V2 = v_besch57 "restreindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
reteindre_V2 = v_besch57 "reteindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
retendre_V2 = v_besch53 "retendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
retenir_V2 = v_besch23 "retenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
retondre_V2 = v_besch53 "retondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
retordre_V2 = v_besch53 "retordre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
retraduire_V2 = v_besch82 "retraduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
retraire_V2 = v_besch61 "retraire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
retranscrire_V2 = v_besch80 "retranscrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
retransmettre_V2 = v_besch56 "retransmettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
rétreindre_V2 = v_besch57 "rétreindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
revaloir_V2 = v_besch47 "revaloir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
revendre_V2 = v_besch53 "revendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
revenir_V = v_besch23 "revenir" ** {vtyp = VEsse ; lock_V = <>} ;
revêtir_V2 = v_besch26 "revêtir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
revivre_V2 = v_besch76 "revivre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
revoir_V2 = v_besch39 "revoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
revouloir_V2 = v_besch48 "revouloir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
rire_V2 = v_besch79 "rire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ;
rompre_V2 = v_besch53 "rompre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
rouvrir_V2 = v_besch27 "rouvrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
saillir_V2 = v_besch29 "saillir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
satisfaire_V2 = v_besch62 "satisfaire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
savoir_V2 = v_besch41 "savoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
secourir_V2 = v_besch33 "secourir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
séduire_V2 = v_besch82 "séduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
sentir_V2 = v_besch25 "sentir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
seoir_V = v_besch50 "seoir" ** {vtyp = VHabere ; lock_V = <>} ;
servir_V2 = v_besch35 "servir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
sortir_V = v_besch25 "sortir" ** {vtyp = VHabere ; lock_V = <>} ;
soubattre_V2 = v_besch55 "soubattre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
souffrir_V2 = v_besch27 "souffrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
soumettre_V2 = v_besch56 "soumettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
sourire_V2 = v_besch79 "sourire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
souscrire_V2 = v_besch80 "souscrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
sous_entendre_V2 = v_besch53 "sous-entendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
sous_tendre_V2 = v_besch53 "sous-tendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
soustraire_V2 = v_besch61 "soustraire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
soutenir_V2 = v_besch23 "soutenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
souvenir_V = v_besch23 "souvenir" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ;
subvenir_V2 = v_besch23 "subvenir" ** {vtyp = VEsse ; lock_V2 = <> ; c2 = complDat} ;
suffire_V2 = v_besch81 "suffire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
suivre_V2 = v_besch75 "suivre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
surfaire_V2 = v_besch62 "surfaire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
surprendre_V2 = v_besch54 "surprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
surproduire_V2 = v_besch82 "surproduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
surseoir_V2 = v_besch51 "surseoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
surtondre_V2 = v_besch53 "surtondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
survenir_V = v_besch23 "survenir" ** {vtyp = VEsse ; lock_V = <>} ;
survivre_V2 = v_besch76 "survivre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
suspendre_V2 = v_besch53 "suspendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
taire_V2 = v_besch63 "taire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
teindre_V2 = v_besch57 "teindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
tendre_V2 = v_besch53 "tendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
tenir_V2 = v_besch23 "tenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ;
tondre_V2 = v_besch53 "tondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
tordre_V2 = v_besch53 "tordre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
traduire_V2 = v_besch82 "traduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
traire_V2 = v_besch61 "traire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
transcrire_V2 = v_besch80 "transcrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
transmettre_V2 = v_besch56 "transmettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
transparaître_V = v_besch64 "transparaître" ** {vtyp = VHabere ; lock_V = <>} ;
tréfondre_V2 = v_besch53 "tréfondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
tressaillir_V = v_besch29 "tressaillir" ** {vtyp = VHabere ; lock_V = <>} ;
vaincre_V2 = v_besch60 "vaincre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
valoir_V2 = v_besch47 "valoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
vendre_V2 = v_besch53 "vendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
venir_V = v_besch23 "venir" ** {vtyp = VEsse ; lock_V = <>} ;
vêtir_V2 = v_besch26 "vêtir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
vivre_V2 = v_besch76 "vivre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
voir_V2 = v_besch39 "voir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
vouloir_V2 = v_besch48 "vouloir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ;
}

391
lib/resource/exper/french/IrregFreAbs.gf
View File

@@ -1,391 +0,0 @@
--# -path=.:../romance:../abstract:../../prelude
-- Irregular verbs from Nancy, based on a list from Sylvain Pogodalla, 25/11/2004
-- Translated to GF by Aarne Ranta
-- added extracted subcat information 29/11
abstract IrregFreAbs = Cat ** {
-- all verbs in classes with "er" and "ir" like "finir" are omitted
fun
abattre_V2 : V2 ;
absoudre_V2 : V2 ;
abstenir_V : V ;
abstraire_V2 : V2 ;
accourir_V : V ;
accroître_V2 : V2 ;
accueillir_V2 : V2 ;
acquérir_V2 : V2 ;
adjoindre_V2 : V2 ;
admettre_V2 : V2 ;
advenir_V : V ;
aller_V : V ;
apercevoir_V2 : V2 ;
apparaître_V : V ;
appartenir_V2 : V2 ;
appendre_V2 : V2 ;
apprendre_V2 : V2 ;
assaillir_V2 : V2 ;
asseoir_V2 : V2 ;
astreindre_V2 : V2 ;
atteindre_V2 : V2 ;
attendre_V2 : V2 ;
avoir_V2 : V2 ;
battre_V2 : V2 ;
boire_V2 : V2 ;
bouillir_V2 : V2 ;
braire_V : V ;
ceindre_V2 : V2 ;
choir_V : V ;
circonscrire_V2 : V2 ;
circonvenir_V2 : V2 ;
clore_V2 : V2 ;
combattre_V2 : V2 ;
commettre_V2 : V2 ;
comparaître_V2 : V2 ;
complaire_V2 : V2 ;
comprendre_V2 : V2 ;
compromettre_V2 : V2 ;
concevoir_V2 : V2 ;
conclure_V2 : V2 ;
concourir_V2 : V2 ;
condescendre_V2 : V2 ;
conduire_V2 : V2 ;
confire_V2 : V2 ;
confondre_V2 : V2 ;
conjoindre_V2 : V2 ;
connaître_V2 : V2 ;
conquérir_V2 : V2 ;
consentir_V2 : V2 ;
construire_V2 : V2 ;
contenir_V2 : V2 ;
contraindre_V2 : V2 ;
contrebattre_V2 : V2 ;
contredire_V2 : V2 ;
contrefaire_V2 : V2 ;
contrevenir_V2 : V2 ;
convaincre_V2 : V2 ;
convenir_V2 : V2 ;
correspondre_V2 : V2 ;
corrompre_V2 : V2 ;
coudre_V2 : V2 ;
courir_V2 : V2 ;
couvrir_V2 : V2 ;
craindre_V2 : V2 ;
croire_V2 : V2 ;
croître_V : V ;
cueillir_V2 : V2 ;
cuire_V2 : V2 ;
débattre_V2 : V2 ;
débouillir_V2 : V2 ;
décevoir_V2 : V2 ;
déchoir_V2 : V2 ;
déclore_V2 : V2 ;
décommettre_V2 : V2 ;
déconfire_V2 : V2 ;
découdre_V2 : V2 ;
découvrir_V2 : V2 ;
décrire_V2 : V2 ;
décroître_V2 : V2 ;
décuire_V2 : V2 ;
déduire_V2 : V2 ;
défaillir_V : V ;
défaire_V2 : V2 ;
défendre_V2 : V2 ;
démentir_V2 : V2 ;
démettre_V2 : V2 ;
démordre_V : V ;
départir_V2 : V2 ;
dépeindre_V2 : V2 ;
dépendre_V2 : V2 ;
déplaire_V : V ;
dépourvoir_V2 : V2 ;
déprendre_V2 : V2 ;
désapprendre_V2 : V2 ;
descendre_V2 : V2 ;
desservir_V2 : V2 ;
déteindre_V2 : V2 ;
détendre_V2 : V2 ;
détenir_V2 : V2 ;
détordre_V2 : V2 ;
détruire_V2 : V2 ;
devenir_V : V ;
dévętir_V2 : V2 ;
devoir_V2 : V2 ;
dire_V2 : V2 ;
disconvenir_V2 : V2 ;
discourir_V2 : V2 ;
disjoindre_V2 : V2 ;
disparaître_V2 : V2 ;
dissoudre_V2 : V2 ;
distendre_V2 : V2 ;
distordre_V2 : V2 ;
distraire_V2 : V2 ;
dormir_V2 : V2 ;
ébattre_V : V ;
échoir_V2 : V2 ;
éclore_V2 : V2 ;
éconduire_V2 : V2 ;
écrire_V2 : V2 ;
élire_V2 : V2 ;
embatre_V2 : V2 ;
embattre_V2 : V2 ;
emboire_V : V ;
émettre_V2 : V2 ;
émoudre_V2 : V2 ;
émouvoir_V2 : V2 ;
empreindre_V2 : V2 ;
enceindre_V2 : V2 ;
enclore_V2 : V2 ;
encourir_V2 : V2 ;
endormir_V2 : V2 ;
enduire_V2 : V2 ;
enfreindre_V2 : V2 ;
enfuir_V : V ;
enjoindre_V2 : V2 ;
enquérir_V : V ;
entendre_V2 : V2 ;
entr'apercevoir_V : V ;
entrebattre_V : V ;
entre_détruire_V : V ;
entre_haďr_V : V ;
entremettre_V : V ;
entre_nuire_V : V ;
entreprendre_V2 : V2 ;
entretenir_V2 : V2 ;
entrevoir_V2 : V2 ;
entrouvrir_V2 : V2 ;
envoyer_V2 : V2 ;
épandre_V2 : V2 ;
éperdre_V : V ;
éprendre_V : V ;
équivaloir_V2 : V2 ;
éteindre_V2 : V2 ;
étendre_V2 : V2 ;
étreindre_V2 : V2 ;
ętre_V : V ;
exclure_V2 : V2 ;
extraire_V2 : V2 ;
faillir_V2 : V2 ;
faire_V2 : V2 ;
falloir_V : V ;
feindre_V2 : V2 ;
fendre_V2 : V2 ;
fondre_V2 : V2 ;
forfaire_V2 : V2 ;
foutre_V2 : V2 ;
frire_V2 : V2 ;
fuir_V2 : V2 ;
geindre_V2 : V2 ;
gésir_V2 : V2 ;
haďr_V2 : V2 ;
inclure_V2 : V2 ;
induire_V2 : V2 ;
inscrire_V2 : V2 ;
instruire_V2 : V2 ;
interdire_V2 : V2 ;
interrompre_V2 : V2 ;
intervenir_V : V ;
introduire_V2 : V2 ;
joindre_V2 : V2 ;
lire_V2 : V2 ;
luire_V : V ;
mainmettre_V2 : V2 ;
maintenir_V2 : V2 ;
méconnaître_V2 : V2 ;
mécroire_V2 : V2 ;
médire_V2 : V2 ;
mentir_V2 : V2 ;
méprendre_V2 : V2 ;
messeoir_V2 : V2 ;
mettre_V2 : V2 ;
mévendre_V2 : V2 ;
mordre_V2 : V2 ;
morfondre_V : V ;
moudre_V2 : V2 ;
mourir_V : V ;
mouvoir_V2 : V2 ;
naître_V : V ;
nuire_V2 : V2 ;
obtenir_V2 : V2 ;
obvenir_V : V ;
occlure_V2 : V2 ;
offrir_V2 : V2 ;
oindre_V2 : V2 ;
omettre_V2 : V2 ;
ouďr_V2 : V2 ;
ouvrir_V2 : V2 ;
paître_V2 : V2 ;
paître_V : V ;
paraître_V : V ;
parcourir_V2 : V2 ;
parfondre_V2 : V2 ;
partir_V : V ;
parvenir_V : V ;
peindre_V2 : V2 ;
pendre_V2 : V2 ;
percevoir_V2 : V2 ;
perdre_V2 : V2 ;
permettre_V2 : V2 ;
plaindre_V2 : V2 ;
plaire_V2 : V2 ;
pleuvoir_V : V ;
poindre_V2 : V2 ;
pondre_V2 : V2 ;
pourfendre_V2 : V2 ;
poursuivre_V2 : V2 ;
pourvoir_V2 : V2 ;
pouvoir_V : V ;
prédire_V2 : V2 ;
prendre_V2 : V2 ;
prescrire_V2 : V2 ;
pressentir_V2 : V2 ;
prétendre_V2 : V2 ;
prévaloir_V2 : V2 ;
prévenir_V2 : V2 ;
prévoir_V2 : V2 ;
produire_V2 : V2 ;
promettre_V2 : V2 ;
promouvoir_V2 : V2 ;
proscrire_V2 : V2 ;
provenir_V : V ;
rabattre_V2 : V2 ;
raire_V2 : V2 ;
rapprendre_V2 : V2 ;
rasseoir_V2 : V2 ;
réadmettre_V2 : V2 ;
réapparaître_V : V ;
réapprendre_V2 : V2 ;
rebattre_V2 : V2 ;
recevoir_V2 : V2 ;
recomparaître_V2 : V2 ;
reconduire_V2 : V2 ;
reconnaître_V2 : V2 ;
reconquérir_V2 : V2 ;
reconstruire_V2 : V2 ;
recoudre_V2 : V2 ;
recourir_V2 : V2 ;
recouvrir_V2 : V2 ;
récrire_V2 : V2 ;
recroître_V2 : V2 ;
recueillir_V2 : V2 ;
recuire_V2 : V2 ;
redécouvrir_V2 : V2 ;
redéfaire_V2 : V2 ;
redescendre_V2 : V2 ;
redevenir_V : V ;
redevoir_V2 : V2 ;
redire_V2 : V2 ;
réduire_V2 : V2 ;
réécrire_V2 : V2 ;
réélire_V2 : V2 ;
réentendre_V2 : V2 ;
refaire_V2 : V2 ;
refendre_V2 : V2 ;
refondre_V2 : V2 ;
réinscrire_V2 : V2 ;
réintroduire_V2 : V2 ;
rejoindre_V2 : V2 ;
relire_V2 : V2 ;
reluire_V2 : V2 ;
remettre_V2 : V2 ;
remordre_V2 : V2 ;
remoudre_V2 : V2 ;
renaître_V2 : V2 ;
rendormir_V2 : V2 ;
rendre_V2 : V2 ;
rentraire_V2 : V2 ;
rentrouvrir_V2 : V2 ;
renvoyer_V2 : V2 ;
repaître_V2 : V2 ;
répandre_V2 : V2 ;
reparaître_V : V ;
repartir_V : V ;
repeindre_V2 : V2 ;
rependre_V2 : V2 ;
repentir_V : V ;
reperdre_V2 : V2 ;
repleuvoir_V : V ;
répondre_V2 : V2 ;
reprendre_V2 : V2 ;
reproduire_V2 : V2 ;
requérir_V2 : V2 ;
résoudre_V2 : V2 ;
ressentir_V2 : V2 ;
resservir_V2 : V2 ;
ressortir_V : V ;
ressouvenir_V : V ;
restreindre_V2 : V2 ;
reteindre_V2 : V2 ;
retendre_V2 : V2 ;
retenir_V2 : V2 ;
retondre_V2 : V2 ;
retordre_V2 : V2 ;
retraduire_V2 : V2 ;
retraire_V2 : V2 ;
retranscrire_V2 : V2 ;
retransmettre_V2 : V2 ;
rétreindre_V2 : V2 ;
revaloir_V2 : V2 ;
revendre_V2 : V2 ;
revenir_V : V ;
revętir_V2 : V2 ;
revivre_V2 : V2 ;
revoir_V2 : V2 ;
revouloir_V2 : V2 ;
rire_V2 : V2 ;
rompre_V2 : V2 ;
rouvrir_V2 : V2 ;
saillir_V2 : V2 ;
satisfaire_V2 : V2 ;
savoir_V2 : V2 ;
secourir_V2 : V2 ;
séduire_V2 : V2 ;
sentir_V2 : V2 ;
seoir_V : V ;
servir_V2 : V2 ;
sortir_V : V ;
soubattre_V2 : V2 ;
souffrir_V2 : V2 ;
soumettre_V2 : V2 ;
sourire_V2 : V2 ;
souscrire_V2 : V2 ;
sous_entendre_V2 : V2 ;
sous_tendre_V2 : V2 ;
soustraire_V2 : V2 ;
soutenir_V2 : V2 ;
souvenir_V : V ;
subvenir_V2 : V2 ;
suffire_V2 : V2 ;
suivre_V2 : V2 ;
surfaire_V2 : V2 ;
surprendre_V2 : V2 ;
surproduire_V2 : V2 ;
surseoir_V2 : V2 ;
surtondre_V2 : V2 ;
survenir_V : V ;
survivre_V2 : V2 ;
suspendre_V2 : V2 ;
taire_V2 : V2 ;
teindre_V2 : V2 ;
tendre_V2 : V2 ;
tenir_V2 : V2 ;
tondre_V2 : V2 ;
tordre_V2 : V2 ;
traduire_V2 : V2 ;
traire_V2 : V2 ;
transcrire_V2 : V2 ;
transmettre_V2 : V2 ;
transparaître_V : V ;
tréfondre_V2 : V2 ;
tressaillir_V : V ;
vaincre_V2 : V2 ;
valoir_V2 : V2 ;
vendre_V2 : V2 ;
venir_V : V ;
vętir_V2 : V2 ;
vivre_V2 : V2 ;
voir_V2 : V2 ;
vouloir_V2 : V2 ;
}

10
lib/resource/exper/french/LangFre.gf
View File

@@ -1,10 +0,0 @@
--# -path=.:romance:abstract:../common:prelude
concrete LangFre of Lang =
GrammarFre,
LexiconFre
** {
flags startcat = Phr ; unlexer = text ; lexer = text ;
} ;

367
lib/resource/exper/french/LexiconFre.gf
View File

@@ -1,367 +0,0 @@
--# -path=.:../romance:../common:../abstract:../../prelude
concrete LexiconFre of Lexicon = CatFre **
open (M = MorphoFre), ParadigmsFre, IrregFre in {
flags
optimize=values ;
lin
airplane_N = regGenN "avion" masculine ;
answer_V2S = mkV2S (v2V répondre_V2) dative ;
apartment_N = regGenN "apartement" masculine ;
apple_N = regGenN "pomme" feminine ;
art_N = regGenN "art" feminine ;
ask_V2Q = mkV2Q (regV "demander") dative ;
baby_N = regGenN "bébé" masculine ;
bad_A = prefA (mkADeg (regA "mauvais") (regA "pire")) ;
bank_N = regGenN "banque" feminine ;
beautiful_A = prefA (regA "joli") ; ---- beau
become_VA = mkVA devenir_V ;
beer_N = regGenN "bière" feminine ;
beg_V2V = mkV2V (regV "demander") accusative dative ;
big_A = prefA (regA "grand") ;
bike_N = regGenN "vélo" masculine ;
bird_N = regGenN "oiseau" masculine ;
black_A = regA "noir" ;
blue_A = regA "bleu" ;
boat_N = regGenN "bateau" masculine ;
book_N = regGenN "livre" masculine ;
boot_N = regGenN "botte" feminine ;
boss_N = regGenN "chef" masculine ;
boy_N = regGenN "garçon" masculine ;
bread_N = regGenN "pain" masculine ;
break_V2 = dirV2 (regV "casser") ;
broad_A = regA "large" ;
brother_N2 = deN2 (regGenN "frère" masculine) ;
brown_A = regA "brun" ;
butter_N = regGenN "beurre" masculine ;
buy_V2 = dirV2 (reg3V "acheter" "achète" "achètera") ;
camera_N = compN (regGenN "appareil" masculine) ["de photo"] ;
cap_N = regGenN "casquette" feminine ;
car_N = regGenN "voiture" feminine ;
carpet_N = regGenN "tapis" masculine ;
cat_N = regGenN "chat" masculine ;
ceiling_N = regGenN "plafond" masculine ;
chair_N = regGenN "chaise" feminine ;
cheese_N = regGenN "fromage" masculine ;
child_N = regGenN "enfant" masculine ;
church_N = regGenN "église" feminine ;
city_N = regGenN "ville" feminine ;
clean_A = regA "propre" ;
clever_A = regA "sage" ; ----
close_V2 = dirV2 (regV "fermer") ;
coat_N = regGenN "manteau" masculine ;
cold_A = regA "froid" ;
come_V = venir_V ;
computer_N = regGenN "ordinateur" masculine ;
country_N = regGenN "pays" masculine ;
cousin_N = regGenN "cousin" masculine ; ---- cousine
cow_N = regGenN "vache" feminine ;
die_V = mourir_V ;
dirty_A = regA "sale" ;
distance_N3 = mkN3 (regGenN "distance" feminine) genitive dative ;
doctor_N = regGenN "médecin" masculine ;
dog_N = regGenN "chien" masculine ;
door_N = regGenN "porte" feminine ;
drink_V2 = boire_V2 ;
easy_A2V = mkA2V (regA "facile") dative genitive ;
eat_V2 = dirV2 (regV "manger") ;
empty_A = regA "vide" ;
enemy_N = regGenN "ennemi" masculine ;
factory_N = regGenN "usine" feminine ;
father_N2 = deN2 (regGenN "père" masculine) ;
fear_VS = mkVS (v2V craindre_V2) ;
fear_V2 = dirV2 (v2V craindre_V2) ;
find_V2 = dirV2 (regV "trouver") ;
fish_N = regGenN "poisson" masculine ;
floor_N = regGenN "plancher" masculine ;
forget_V2 = dirV2 (regV "oublier") ;
fridge_N = regGenN "frigo" masculine ;
friend_N = regGenN "ami" masculine ;
fruit_N = regGenN "fruit" masculine ;
fun_AV = mkAV (regA "marrant") genitive ;
garden_N = regGenN "jardin" masculine ;
girl_N = regGenN "fille" feminine ;
glove_N = regGenN "gant" masculine ;
gold_N = regGenN "or" masculine ;
good_A = prefA (mkADeg (mkA "bon" "bonne" "bons" "bien")
(mkA "meilleur" "meilleure" "meilleurs" "mieux")) ;
go_V = aller_V ;
green_A = regA "vert" ;
harbour_N = regGenN "port" masculine ;
hate_V2 = haïr_V2 ;
hat_N = regGenN "chapeau" masculine ;
have_V2 = avoir_V2 ;
hear_V2 = entendre_V2 ;
hill_N = regGenN "colline" feminine ;
hope_VS = mkVS (reg3V "espérer" "espère" "espérera") ;
horse_N = regGenN "cheval" masculine ;
hot_A = regA "chaud" ;
house_N = regGenN "maison" feminine ;
important_A = regA "important" ;
industry_N = regGenN "industrie" feminine ;
iron_N = regGenN "fer" masculine ;
king_N = regGenN "roi" masculine ;
know_V2 = connaître_V2 ; ---- savoir_V2 : VS
lake_N = regGenN "lac" masculine ;
lamp_N = regGenN "lampe" feminine ;
learn_V2 = apprendre_V2 ;
leather_N = regGenN "cuir" masculine ;
leave_V2 = dirV2 (regV "quitter") ;
like_V2 = dirV2 (regV "aimer") ;
listen_V2 = dirV2 (regV "écouter") ;
live_V = v2V vivre_V2 ;
long_A = compADeg (mkA "long" "longue" "longs" "longuement") ;
lose_V2 = perdre_V2 ;
love_N = regGenN "amour" masculine ;
love_V2 = dirV2 (regV "aimer") ;
man_N = regGenN "homme" masculine ;
married_A2 = mkA2 (regA "marié") dative ;
meat_N = regGenN "viande" feminine ;
milk_N = regGenN "lait" masculine ;
moon_N = regGenN "lune" feminine ;
mother_N2 = deN2 (regGenN "mère" feminine) ;
mountain_N = regGenN "montagne" feminine ;
music_N = regGenN "musique" feminine ;
narrow_A = regA "étroit" ;
new_A = prefA (compADeg (mkA "nouveau" "nouvelle" "nouveaux" "nouvellement")) ;
newspaper_N = regGenN "journal" masculine ;
oil_N = regGenN "huile" feminine ;
old_A =
prefA (compADeg (mkA "vieux" "vieille" "vieux" "vieillement")) ; ---- vieil
open_V2 = ouvrir_V2 ;
paint_V2A = mkV2A (v2V peindre_V2) accusative (mkPrep "en") ;
paper_N = regGenN "papier" masculine ;
paris_PN = mkPN "Paris" masculine ;
peace_N = regGenN "paix" feminine ;
pen_N = regGenN "stylo" masculine ;
planet_N = regGenN "planète" feminine ;
plastic_N = regGenN "plastic" masculine ;
play_V2 = dirV2 (regV "jouer") ;
policeman_N = regGenN "policier" masculine ;
priest_N = regGenN "prêtre" masculine ;
probable_AS = mkAS (regA "probable") ;
queen_N = regGenN "reine" feminine ;
radio_N = regGenN "radio" feminine ;
rain_V0 = mkV0 (pleuvoir_V) ;
read_V2 = lire_V2 ;
red_A = regA "rouge" ;
religion_N = regGenN "religion" feminine ;
restaurant_N = regGenN "restaurant" masculine ;
river_N = regGenN "rivière" feminine ;
rock_N = regGenN "rocher" masculine ;
roof_N = regGenN "toit" masculine ;
rubber_N = regGenN "caoutchuc" masculine ;
run_V = v2V courir_V2 ;
say_VS = mkVS (v2V dire_V2) ;
school_N = regGenN "école" feminine ;
science_N = regGenN "science" feminine ;
sea_N = regGenN "mer" feminine ;
seek_V2 = dirV2 (regV "chercher") ;
see_V2 = voir_V2 ;
sell_V3 = dirV3 (v2V vendre_V2) dative ;
send_V3 = dirV3 (v2V envoyer_V2) dative ;
sheep_N = regGenN "mouton" masculine ;
ship_N = regGenN "bateau" masculine ;
shirt_N = regGenN "chemise" feminine ;
shoe_N = regGenN "chaussure" feminine ;
shop_N = regGenN "magasin" masculine ;
short_A = regA "court" ; ---- bref
silver_N = regGenN "argent" masculine ;
sister_N = regGenN "soeur" feminine ;
sleep_V = v2V dormir_V2 ;
small_A = prefA (regA "petit") ;
snake_N = regGenN "serpent" masculine ;
sock_N = regGenN "chaussette" feminine ;
speak_V2 = dirV2 (regV "parler") ;
star_N = regGenN "étoile" feminine ;
steel_N = regGenN "acier" masculine ;
stone_N = regGenN "pierre" feminine ;
stove_N = regGenN "four" masculine ;
student_N = regGenN "étudiant" masculine ;
stupid_A = regA "stupide" ;
sun_N = regGenN "soleil" masculine ;
switch8off_V2 = éteindre_V2 ;
switch8on_V2 = dirV2 (regV "allumer") ; ----
table_N = regGenN "table" feminine ;
talk_V3 = mkV3 (regV "parler") dative genitive ;
teacher_N = regGenN "professeur" masculine ;
teach_V2 = dirV2 (regV "enseigner") ;
television_N = regGenN "télévision" feminine ;
thick_A = compADeg (mkA "épais" "épaisse" "épais" "épaissement") ;
thin_A = regA "fin" ;
train_N = regGenN "train" masculine ;
travel_V = regV "voyager" ;
tree_N = regGenN "arbre" masculine ;
---- trousers_N = regGenN "pantalon" masculine ;
ugly_A = regA "laide" ;
understand_V2 = comprendre_V2 ;
university_N = regGenN "université" feminine ;
village_N = regGenN "village" masculine ;
wait_V2 = attendre_V2 ; ---- dative?
walk_V = regV "marcher" ;
warm_A = regA "chaud" ;
war_N = regGenN "guerre" masculine ;
watch_V2 = dirV2 (regV "regarder") ;
water_N = regGenN "eau" feminine ;
white_A = compADeg (mkA "blanc" "blanche" "blancs" "blanchement") ;
window_N = regGenN "fenêtre" feminine ;
wine_N = regGenN "vin" masculine ;
win_V2 = dirV2 (regV "gagner") ; ---- vaincre
woman_N = regGenN "femme" feminine ;
wonder_VQ = mkVQ (reflV (regV "étonner")) ;
wood_N = regGenN "bois" masculine ;
write_V2 = écrire_V2 ;
yellow_A = regA "jaune" ;
young_A = prefA (regA "jeune") ;
do_V2 = faire_V2 ;
now_Adv = mkAdv "maintenant" ;
already_Adv = mkAdv "déjà" ;
song_N = regGenN "chanson" feminine ;
add_V3 = dirV3 (regV "ajouter") dative ;
number_N = regGenN "nombre" masculine ; ---- numéro
put_V2 = mettre_V2 ;
stop_V = reflV (regV "arrêter") ;
jump_V = regV "sauter" ;
left_Ord = M.mkOrd (regA "gauche") ;
right_Ord = M.mkOrd (regA "droite") ;
far_Adv = mkAdv "loin" ;
correct_A = regA "correct" ;
dry_A = (mkA "sec" "sèche" "secs" "sèches") ;
dull_A = regA "émoussé" ;
full_A = regA "plein" ;
heavy_A = regA "lourd" ;
near_A = regA "proche" ;
rotten_A = regA "pourri" ;
round_A = regA "rond" ;
sharp_A = regA "tranchant" ;
smooth_A = regA "lisse" ;
straight_A = regA "droite" ;
wet_A = regA "mouillé" ;
wide_A = regA "large" ;
animal_N = regN "animal" ;
ashes_N = regGenN "cendre" masculine ;
back_N = regN "dos" ;
bark_N = regN "écorce" ;
belly_N = regGenN "ventre" masculine ;
blood_N = regN "sang" ;
bone_N = regN "os" ;
breast_N = regN "sein" ; --- poitrine
cloud_N = regGenN "nuage" masculine ;
day_N = regN "jour" ;
dust_N = regN "poussière" ;
ear_N = regN "oreille" ;
earth_N = regN "terre" ;
egg_N = regN "oeuf" ;
eye_N = mkN "oeil" "yeux" masculine ;
fat_N = regN "graisse" ;
feather_N = regN "plume" ;
fingernail_N = regGenN "ongle" masculine ;
fire_N = regN "feu" ;
flower_N = regGenN "fleur" feminine ;
fog_N = regN "brouillard" ;
foot_N = regN "pied" ;
forest_N = regGenN "forêt" feminine ;
grass_N = regN "herbe" ;
guts_N = regN "entraille" ;
hair_N = regN "cheveu" ;
hand_N = regGenN "main" feminine ;
head_N = regN "tête" ;
heart_N = regN "coeur" ;
horn_N = regGenN "corne" masculine ;
husband_N = regN "mari" ;
ice_N = regN "glace" ;
knee_N = regN "genou" ;
leaf_N = regN "feuille" ;
leg_N = regN "jambe" ;
liver_N = regGenN "foie" masculine ;
louse_N = regN "pou" ;
mouth_N = regN "bouche" ;
name_N = regN "nom" ;
neck_N = mkN "cou" "cous" masculine ;
night_N = regGenN "nuit" feminine ;
nose_N = regN "nez" ;
person_N = regN "personne" ;
rain_N = regN "pluie" ;
road_N = regN "route" ;
root_N = regN "racine" ;
rope_N = regN "corde" ;
salt_N = regN "sel" ;
sand_N = regGenN "sable" masculine ;
seed_N = regN "graine" ;
skin_N = regN "peau" ;
sky_N = mkN "ciel" "cieux" masculine ;
smoke_N = regN "fumée" ;
snow_N = regN "neige" ;
stick_N = regN "bâton" ;
tail_N = regN "queue" ;
tongue_N = regN "langue" ;
tooth_N = regGenN "dent" feminine ;
wife_N = regN "femme" ;
wind_N = regN "vent" ;
wing_N = regN "aile" ;
worm_N = regN "ver" ;
year_N = regN "an" ; --- année
bite_V2 = mordre_V2 ;
blow_V = regV "souffler" ;
breathe_V = regV "respirer" ;
burn_V = regV "brûler" ;
count_V2 = dirV2 (regV "conter") ;
cut_V2 = dirV2 (regV "tailler") ;
dig_V = regV "creuser" ;
fall_V = regV "tomber" ;
fight_V2 = dirV2 (regV "lutter") ;
float_V = regV "flotter" ;
flow_V = regV "couler" ;
fly_V = regV "voler" ;
freeze_V = reg3V "geler" "gèle" "gèlera" ;
give_V3 = dirdirV3 (regV "donner") ;
hit_V2 = dirV2 (regV "frapper") ;
hunt_V2 = dirV2 (regV "chasser") ;
kill_V2 = dirV2 (regV "tuer") ;
laugh_V = rire_V2 ;
lie_V = reflV (v2V étendre_V2) ;
play_V = regV "jouer" ;
pull_V2 = dirV2 (regV "tirer") ;
push_V2 = dirV2 (regV "pousser") ;
rub_V2 = dirV2 (regV "frotter") ;
scratch_V2 = dirV2 (regV "gratter") ;
sew_V = coudre_V2 ;
sing_V = regV "chanter" ;
sit_V = reflV (v2V asseoir_V2) ;
smell_V = v2V ( sentir_V2) ;
spit_V = regV "cracher" ;
squeeze_V2 = dirV2 (regV "serrer") ;
stab_V2 = dirV2 (regV "poignarder") ;
stand_V = reflV (reg3V "lever" "lève" "lèvera") ;
suck_V2 = dirV2 (regV "sucer") ;
swell_V = regV "gonfler" ;
swim_V = regV "nager" ;
think_V = regV "penser" ;
throw_V2 = dirV2 (regV "jeter") ;
tie_V2 = dirV2 (regV "lier") ;
turn_V = regV "tourner" ;
vomit_V = regV "vomir" ;
wash_V2 = dirV2 (regV "laver") ;
wipe_V2 = dirV2 (regV "essuyer") ;
hold_V2 = tenir_V2 ;
split_V2 = fendre_V2 ;
sit_V = reflV (v2V asseoir_V2) ;
grammar_N = regN "grammaire" ;
language_N = regN "langue" ;
rule_N = regN "règle" ;
john_PN = regPN "Jean" ;
question_N = regN "question" ;
ready_A = regA "prêt" ;
reason_N = regGenN "raison" feminine ;
today_Adv = mkAdv "aujourd'hui" ;
uncertain_A = regA "incertain" ;
} ;

1238
lib/resource/exper/french/MorphoFre.gf
View File

File diff suppressed because it is too large Load Diff

4
lib/resource/exper/french/NounFre.gf
View File

@@ -1,4 +0,0 @@
--# -path=.:romance:abstract:../common:prelude
concrete NounFre of Noun = CatFre ** NounRomance with
(ResRomance = ResFre) ;

148
lib/resource/exper/french/NumeralFre.gf
View File

@@ -1,148 +0,0 @@
concrete NumeralFre of Numeral = CatFre **
open CommonRomance, ResRomance, MorphoFre, Prelude in {
-- originally written in 1998, automatically translated to current notation...
-- last modified 24/1/2006, adding ordinals
-- Auxiliaries
oper
digitPl : {s : DForm => Str; inh : DForm ; n : Number} ->
{s : CardOrd => DForm => Str ; inh : DForm ; n : Number} = \d -> {
s = \\co,df => let ds = d.s ! df in
case co of {
NCard _ => ds ;
NOrd _ _ => case last ds of {
"q" => "uième" ;
"e" => init ds + "ième" ;
_ => ds + "ième"
}
} ;
inh = d.inh ; n = d.n
} ;
cardOrd : CardOrd -> Str -> Str -> Str = \co, x,y -> case co of {
NCard _ => x ;
NOrd _ _ => y
} ;
lincat
Digit = {s : CardOrd => DForm => Str ; inh : DForm ; n : Number} ;
Sub10 = {s : CardOrd => {p1 : DForm ; p2 : Place} => Str ; inh : Number} ;
Sub100 = {s : CardOrd => Place => Str ; n : Number} ;
Sub1000 = {s : CardOrd => Place => Str ; n : Number} ;
Sub1000000 = {s : CardOrd => Str ; n : Number} ;
lin num x0 = x0 ;
lin n2 =
digitPl {inh = unit ; n = Sg ; s = table {unit => "deux" ; teen => "douze" ; jten => "vingt" ; ten => "vingt" ; tenplus => "vingt"}} ;
lin n3 =
digitPl {inh = unit ; n = Sg ; s = table {unit => "trois" ; teen => "treize" ; jten => "trente" ; ten => "trente" ; tenplus => "trente"}} ;
lin n4 =
digitPl {inh = unit ; n = Sg ; s = table {unit => "quatre" ; teen => "quatorze" ; jten => "quarante" ; ten => "quarante" ; tenplus => "quarante"}} ;
lin n5 =
digitPl {inh = unit ; n = Sg ; s = table {unit => "cinq" ; teen => "quinze" ; jten => "cinquante" ; ten => "cinquante" ; tenplus => "cinquante"}} ;
lin n6 =
digitPl {inh = unit ; n = Sg ; s = table {unit => "six" ; teen => "seize" ; jten => "soixante" ; ten => "soixante" ; tenplus => "soixante"}} ;
lin n7 =
digitPl {inh = teen ; n = Sg ; s = table {unit => "sept" ; teen => "dix-sept" ; jten => "soixante-dix" ; ten => "soixante-dix" ; tenplus => "soixante"}} ;
lin n8 =
digitPl {inh = unit ; n = Pl ; s = table {unit => "huit" ; teen => "dix-huit" ; jten => "quatre-vingts" ; ten => "quatre-vingt" ; tenplus => "quatre-vingt"}} ;
lin n9 =
digitPl {inh = teen ; n = Pl ; s = table {unit => "neuf" ; teen => "dix-neuf" ; jten => "quatre-vingt-dix" ; ten => "quatre-vingt-dix" ; tenplus => "quatre-vingt"}} ;
lin pot01 =
{inh = Sg ; s = \\g => let dix = cardOrd g "dix" "dixième" in table {
{p1 = unit ; p2 = indep} => cardOrd g "un" "unième" ; {p1 = unit ; p2 = attr} => [] ; {p1 = teen ;
p2 = indep} => cardOrd g "onze" "onzième" ; {p1 = teen ; p2 = attr} => [] ; {p1 = jten ;
p2 = indep} => dix ; {p1 = jten ; p2 = attr} => [] ; {p1 = ten ;
p2 = indep} => dix ; {p1 = ten ; p2 = attr} => [] ; {p1 = tenplus
; p2 = indep} => dix ; {p1 = tenplus ; p2 = attr} => []} ; n = Sg} ;
lin pot0 d =
{inh = Pl ; s = \\g => table {{p1 = unit ; p2 = indep} => d.s ! g ! unit
; {p1 = unit ; p2 = attr} => d.s ! g ! unit ; {p1 = teen ; p2 = indep}
=> d.s ! g ! teen ; {p1 = teen ; p2 = attr} => d.s ! g ! teen ; {p1 = jten ;
p2 = indep} => d.s ! g ! jten ; {p1 = jten ; p2 = attr} => d.s ! g ! jten ;
{p1 = ten ; p2 = indep} => d.s ! g ! ten ; {p1 = ten ; p2 = attr} => d.s
! g ! ten ; {p1 = tenplus ; p2 = indep} => d.s ! g ! tenplus ; {p1 = tenplus
; p2 = attr} => d.s ! g ! tenplus} ; n = Pl} ;
lin pot110 =
{s = \\g => table {_ => cardOrd g "dix" "dixième"} ; n = Pl} ;
lin pot111 =
{s = \\g => table {_ => cardOrd g "onze" "onzième"} ; n = Pl} ;
lin pot1to19 d =
{s = \\g => table {indep => d.s ! g ! teen ; attr => d.s ! g ! teen} ; n = Pl} ;
lin pot0as1 n =
{s = \\g => table {indep => n.s ! g ! {p1 = unit ; p2 = indep} ;
attr => n.s ! g ! {p1 = unit ; p2 = attr}} ; n = n.inh} ;
lin pot1 d =
{s = \\g => table {indep => d.s ! g ! jten ; attr => d.s ! g ! ten}
; n = Pl} ;
lin pot1plus d e =
{s = \\g => table {indep => (d.s ! (NCard Masc) ! tenplus) ++ (table {{p1 = Sg
; p2 = Sg} => "et" ; {p1 = Sg ; p2 = pl} => "-" ; {p1 = Pl ; p2 =
Sg} => "-" ; {p1 = Pl ; p2 = pl} => "-"} ! {p1 = d.n ; p2 =
e.inh}) ++ e.s ! g ! {p1 = d.inh ; p2 = indep} ; attr => (d.s ! (NCard Masc) !
tenplus) ++ (table {{p1 = Sg ; p2 = Sg} => "et" ; {p1 = Sg ; p2 =
pl} => "-" ; {p1 = Pl ; p2 = Sg} => "-" ; {p1 = Pl ; p2 = pl} =>
"-"} ! {p1 = d.n ; p2 = e.inh}) ++ e.s ! g ! {p1 = d.inh ; p2 =
indep}} ; n = Pl} ;
lin pot1as2 n = n ;
lin pot2 d =
{s = \\g => table {indep => (d.s ! NCard Masc ! {p1 = unit ; p2 = attr})
++ table {Sg => cardOrd g "cent" "centième" ; Pl => cardOrd g "cents" "centième"} ! (d.inh) ; attr => (d.s !
NCard Masc ! {p1 = unit ; p2 = attr}) ++ cardOrd g "cent" "centième"} ; n = Pl} ;
lin pot2plus d e =
{s = \\g => table {indep => (d.s ! NCard Masc ! {p1 = unit ; p2 = attr})
++ "cent" ++ e.s ! g ! indep ; attr => (d.s ! NCard Masc ! {p1 = unit ; p2
= attr}) ++ "cent" ++ e.s ! g ! indep} ; n = Pl} ;
lin pot2as3 n =
{s = \\g => n.s ! g ! indep ; n = n.n} ;
lin pot3 n =
{s = \\g => (n.s ! NCard Masc ! attr) ++ cardOrd g "mille" "millième" ; n = Pl} ;
lin pot3plus n m =
{s = \\g => (n.s ! NCard Masc ! attr) ++ "mille" ++ m.s ! g ! indep ; n =
Pl} ;
-- numerals as sequences of digits
lincat
Dig = TDigit ;
lin
IDig d = d ;
IIDig d i = {
s = \\o => d.s ! NCard Masc ++ i.s ! o ;
n = Pl
} ;
D_0 = mkDig "0" ;
D_1 = mk3Dig "1" "1er" Sg ; ---- gender
D_2 = mk2Dig "2" "2ème" ;
D_3 = mk2Dig "3" "3ème" ;
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
mk2Dig : Str -> Str -> TDigit = \c,o -> mk3Dig c o Pl ;
mkDig : Str -> TDigit = \c -> mk2Dig c (c + "ème") ;
mk3Dig : Str -> Str -> Number -> TDigit = \c,o,n -> {
s = table {NCard _ => c ; NOrd _ _ => o} ; ---- gender
n = n
} ;
TDigit = {
n : Number ;
s : CardOrd => Str
} ;
}

447
lib/resource/exper/french/ParadigmsFre.gf
View File

@@ -1,447 +0,0 @@
--# -path=.:../romance:../common:../abstract:../../prelude
--1 French Lexical Paradigms
--
-- Aarne Ranta 2001 - 2006
--
-- 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 $MorphoFre.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 [``IrregFre`` ../../french/IrregFre.gf],
-- which covers all irregularly inflected verbs.
resource ParadigmsFre =
open
(Predef=Predef),
Prelude,
CommonRomance,
ResFre,
MorphoFre,
CatFre in {
flags optimize=all ;
--2 Parameters
--
-- To abstract over gender names, we define the following identifiers.
oper
Gender : Type ;
masculine : Gender ;
feminine : Gender ;
-- To abstract over number names, we define the following.
Number : Type ;
singular : Number ;
plural : Number ;
-- Prepositions used in many-argument functions are either strings
-- (including the 'accusative' empty string) or strings that
-- amalgamate with the following word (the 'genitive' "de" and the
-- 'dative' "à").
accusative : Prep ;
genitive : Prep ;
dative : Prep ;
mkPrep : Str -> Prep ;
--2 Nouns
mkN : overload {
-- The regular function uses heuristics to compute the
-- plural and the gender from the singular. The plural
-- heuristic currently
-- covers the cases "pas-pas", "prix-prix", "nez-nez",
-- "bijou-bijoux", "cheveu-cheveux", "plateau-plateaux", "cheval-chevaux".
-- The gender heuristic is less reliable: it treats as feminine all
-- nouns ending with "e" and "ion", all others as masculine.
mkN : (cheval : Str) -> N ;
-- Adding gender information widens the scope of the regular pattern.
mkN : (foie : Str) -> Gender -> N ;
-- In the worst case, both singular and plural forms and the gender are needed.
mkN : (oeil,yeux : Str) -> Gender -> N ;
--3 Compound nouns
--
-- Some nouns are ones where the first part is inflected as a noun but
-- the second part is not inflected. e.g. "numéro de téléphone".
-- They could be formed in syntax, but we give a shortcut here since
-- they are frequent in lexica.
mkN : N -> Str -> N
} ;
--3 Relational nouns
--
-- Relational nouns ("fille de x") need a case and a preposition.
mkN2 : N -> Prep -> N2 ;
-- The most common cases are the genitive "de" and the dative "à",
-- with the empty preposition.
deN2 : N -> N2 ;
aN2 : N -> N2 ;
-- Three-place relational nouns ("la connection de x à y") need two prepositions.
mkN3 : N -> Prep -> Prep -> N3 ;
--3 Relational common noun phrases
--
-- In some cases, you may want to make a complex $CN$ into a
-- relational noun (e.g. "la vieille église de"). However, $N2$ and
-- $N3$ are purely lexical categories. But you can use the $AdvCN$
-- and $PrepNP$ constructions to build phrases like this.
--
--3 Proper names and noun phrases
--
-- Proper names need a string and a gender. If no gender is given, the
-- feminine is used for strings ending with "e", the masculine for other strings.
mkPN : overload {
mkPN : Str -> PN ;
mkPN : Str -> Gender -> PN
} ;
--2 Adjectives
mkA : overload {
-- For regular adjectives, all forms are derived from the
-- masculine singular. The heuristic takes into account certain
-- deviant endings: "banal-banale-banaux", "chinois-chinoise-chinois",
-- "heureux-heureuse-heureux", "italien-italienne", "jeune-jeune",
-- "amer-amère", "carré- - -carrément", "joli- - -joliment".
mkA : (cher : Str) -> A ;
-- Often just the feminine singular is deviant.
mkA : (sec,seche : Str) -> A ;
-- This is the worst-case paradigm for the positive forms.
mkA : (banal,banale,banaux,banalement : Str) -> A ;
-- If comparison forms are irregular (i.e. not formed by "plus", e.g.
-- "bon-meilleur"), the positive and comparative can be given as separate
-- adjectives.
mkA : A -> A -> A
} ;
-- The functions create by default postfix adjectives. To switch
-- them to prefix ones (i.e. ones placed before the noun in
-- modification, as in "petite maison"), the following function is
-- provided.
prefixA : A -> A ;
--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.
mkAdv : Str -> Adv ;
-- Some appear next to the verb (e.g. "toujours").
mkAdV : Str -> AdV ;
-- Adverbs modifying adjectives and sentences can also be formed.
mkAdA : Str -> AdA ;
--2 Verbs
--
-- Irregular verbs are given in the module $IrregFre$.
-- If a verb should be missing in that list, the module
-- $BeschFre$ gives all the patterns of the "Bescherelle" book.
--
-- Regular verbs are ones with the infinitive "er" or "ir", the
-- latter with plural present indicative forms as "finissons".
-- The regular verb function in the first conjugation recognizes
-- these endings, as well as the variations among
-- "aimer, céder, placer, peser, jeter, placer, manger, assiéger, payer".
--
-- Sometimes, however, it is not predictable which variant of the "er"
-- conjugation is to be selected. Then it is better to use the function
-- that gives the third person singular present indicative and future
-- (("il") "jette", "jettera") as second argument.
mkV : overload {
mkV : (finir : Str) -> V ;
mkV : (jeter,jette,jettera : Str) -> V ;
-- The $IrregFre$ list gives some verbs as two-place. These verbs can be
-- reused as one-place verbs.
mkV : V2 -> V
} ;
-- The function $mkV$ gives the default compound auxiliary "avoir".
-- To change it to "être", use the following function.
etreV : V -> V ;
-- This function turns a verb into reflexive, which implies the auxiliary "être".
reflV : V -> V ;
--3 Two-place verbs
--
-- Two-place verbs need a preposition, except the special case with direct object.
-- (transitive verbs).
mkV2 = overload {
mkV2 : V -> V2 = dirV2 ;
mkV2 : V -> Prep -> V2 = mmkV2
} ;
--3 Three-place verbs
--
-- Three-place (ditransitive) verbs need two prepositions, of which
-- the first one or both can be absent.
mkV3 : overload {
mkV3 : V -> V3 ; -- donner,_,_
mkV3 : V -> Prep -> V3 ; -- placer,_,dans
mkV3 : V -> Prep -> Prep -> V3 -- parler, à, de
} ;
--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 ; -- plain infinitive: "je veux parler"
deVV : V -> VV ; -- "j'essaie de parler"
aVV : V -> VV ; -- "j'arrive à parler"
mkV2V : V -> Prep -> Prep -> V2V ;
mkVA : V -> VA ;
mkV2A : V -> Prep -> Prep -> V2A ;
mkVQ : V -> VQ ;
mkV2Q : V -> Prep -> V2Q ;
mkAS : A -> AS ;
mkA2S : A -> Prep -> A2S ;
mkAV : A -> Prep -> AV ;
mkA2V : A -> Prep -> Prep -> A2V ;
-- Notice: categories $AS, A2S, AV, A2V$ are just $A$,
-- and the second argument is given as an adverb. Likewise
-- $V0$ is just $V$.
V0 : Type ;
AS, A2S, AV, A2V : Type ;
--.
--2 Definitions of the paradigms
--
-- The definitions should not bother the user of the API. So they are
-- hidden from the document.
Gender = MorphoFre.Gender ;
Number = MorphoFre.Number ;
masculine = Masc ;
feminine = Fem ;
singular = Sg ;
plural = Pl ;
Preposition = Compl ;
accusative = complAcc ** {lock_Prep = <>} ;
genitive = complGen ** {lock_Prep = <>} ;
dative = complDat ** {lock_Prep = <>} ;
mkPrep p = {s = p ; c = Acc ; isDir = False ; lock_Prep = <>} ;
--- obsolete
Preposition : Type ;
mkPreposition : Str -> Preposition ;
mkPreposition = mkPrep ;
regGenN : Str -> Gender -> N ;
regN : Str -> N ;
mk2N : (oeil,yeux : Str) -> Gender -> N ;
mk2N x y g = mkCNomIrreg x y g ** {lock_N = <>} ;
regN x = regGenN x g where {
g = case <x : Str> of {
_ + ("e" | "ion") => Fem ;
_ => Masc
}
} ;
regGenN x g = mkNomReg x g ** {lock_N = <>} ;
compN : N -> Str -> N ;
compN x y = {s = \\n => x.s ! n ++ y ; g = x.g ; lock_N = <>} ;
mkN = overload {
mkN : Str -> N = regN ;
mkN : Str -> Gender -> N = regGenN ;
mkN : (oeil,yeux : Str) -> Gender -> N = mk2N ;
mkN : N -> Str -> N = compN
} ;
mkN2 = \n,p -> n ** {lock_N2 = <> ; c2 = p} ;
deN2 n = mkN2 n genitive ;
aN2 n = mkN2 n dative ;
mkN3 = \n,p,q -> n ** {lock_N3 = <> ; c2 = p ; c3 = q} ;
regPN x = mk2PN x g where {
g = case last x of {
"e" => feminine ;
_ => masculine
}
} ;
mkPN = overload {
mkPN : Str -> PN = regPN ;
mkPN : Str -> Gender -> PN = \x,g -> {s = x ; g = g} ** {lock_PN = <>} ;
} ;
mk4A a b c d = compADeg {s = \\_ => (mkAdj a c b d).s ; isPre = False ; lock_A = <>} ;
regA a = compADeg {s = \\_ => (mkAdjReg a).s ; isPre = False ; lock_A = <>} ;
prefA a = {s = a.s ; isPre = True ; lock_A = <>} ;
mkA2 a p = a ** {c2 = p ; lock_A2 = <>} ;
mkA = overload {
mkA : Str -> A = regA ;
mkA : (sec,seche : Str) -> A = \sec,seche -> mk4A sec seche (sec + "s") (seche + "ment") ;
mkA : (banal,banale,banaux,banalement : Str) -> A = mk4A ;
mkA : A -> A -> A = mkADeg
};
prefixA a = {s = a.s ; isPre = True ; lock_A = <>} ;
mkAdv x = ss x ** {lock_Adv = <>} ;
mkAdV x = ss x ** {lock_AdV = <>} ;
mkAdA x = ss x ** {lock_AdA = <>} ;
regV x = let v = vvf (mkVerbReg x) in {s = v ; vtyp = VHabere ; lock_V = <>} ;
reg3V x y z = let v = vvf (mkVerb3Reg x y z) in {s = v ; vtyp = VHabere ; lock_V = <>} ;
etreV v = {s = v.s ; vtyp = VEsse ; lock_V = <>} ;
reflV v = {s = v.s ; vtyp = VRefl ; lock_V = <>} ;
mmkV3 v p q = v ** {c2 = p ; c3 = q ; lock_V3 = <>} ;
dirV3 v p = mmkV3 v accusative p ;
dirdirV3 v = dirV3 v dative ;
mkV3 = overload {
mkV3 : V -> V3 = dirdirV3 ; -- donner,_,_
mkV3 : V -> Prep -> V3 = dirV3 ; -- placer,_,sur
mkV3 : V -> Prep -> Prep -> V3 = mmkV3 -- parler, à, de
} ;
V0 : Type = V ;
AS, AV : Type = A ;
A2S, A2V : Type = A2 ;
mkV0 v = v ** {lock_V0 = <>} ;
mkVS v = v ** {m = \\_ => Indic ; lock_VS = <>} ; ---- more moods
mkV2S v p = mmkV2 v p ** {mn,mp = Indic ; lock_V2S = <>} ;
mkVV v = v ** {c2 = complAcc ; lock_VV = <>} ;
deVV v = v ** {c2 = complGen ; lock_VV = <>} ;
aVV v = v ** {c2 = complDat ; lock_VV = <>} ;
mkV2V v p q = mmkV3 v p q ** {lock_V2V = <>} ;
mkVA v = v ** {lock_VA = <>} ;
mkV2A v p q = mmkV3 v p q ** {lock_V2A = <>} ;
mkVQ v = v ** {lock_VQ = <>} ;
mkV2Q v p = mmkV2 v p ** {lock_V2Q = <>} ;
mkAS v = v ** {lock_AS = <>} ; ---- more moods
mkA2S v p = mkA2 v p ** {lock_A2S = <>} ;
mkAV v p = v ** {c = p.p1 ; s2 = p.p2 ; lock_AV = <>} ;
mkA2V v p q = mkA2 v p ** {s3 = q.p2 ; c3 = q.p1 ; lock_A2V = <>} ;
--------------------------- obsolete
makeNP : Str -> Gender -> Number -> NP ;
makeNP x g n = {s = (pn2np {s=x;g= g}).s; a = agrP3 g n ; hasClit = False} ** {lock_NP = <>} ;
regPN : Str -> PN ;
mk2PN : Str -> Gender -> PN = \x,g -> {s = x ; g = g} ** {lock_PN = <>} ;
mkADeg : A -> A -> A ;
compADeg : A -> A ;
regA : Str -> A ;
mk4A : (banal,banale,banaux,banalement : Str) -> A ;
prefA : A -> A ;
mkADeg a b =
{s = table {Posit => a.s ! Posit ; _ => b.s ! Posit} ; isPre = a.isPre ; lock_A = <>} ;
compADeg a =
{s = table {Posit => a.s ! Posit ; _ => \\f => "plus" ++ a.s ! Posit ! f} ;
isPre = a.isPre ;
lock_A = <>} ;
prefA a = {s = a.s ; isPre = True ; lock_A = <>} ;
mkV = overload {
mkV : Str -> V = regV ;
mkV : (jeter,jette,jettera : Str) -> V = reg3V ;
mkV : V2 -> V = v2V
} ;
regV : Str -> V ;
reg3V : (jeter,jette,jettera : Str) -> V ;
mmkV2 : V -> Prep -> V2 ;
mmkV2 v p = v ** {c2 = p ; lock_V2 = <>} ;
dirV2 : V -> V2 = \v -> mmkV2 v accusative ;
v2V : V2 -> V ;
v2V v = v ** {lock_V = <>} ;
mmkV3 : V -> Prep -> Prep -> V3 ; -- parler, à, de
dirV3 : V -> Prep -> V3 ; -- donner,_,à
dirdirV3 : V -> V3 ; -- donner,_,_
} ;

26
lib/resource/exper/french/PhonoFre.gf
View File

@@ -1,26 +0,0 @@
resource PhonoFre = open Prelude in {
oper
voyelle : Strs = strs {
"a" ; "à" ; "â " ; "e" ; "é" ; "è" ; "ê¨" ;
"h" ;
"i" ; "î" ; "o" ; "ô" ; "u" ; "û" ; "y"
} ;
elision : Str -> Str = \d -> d + pre {"e" ; "'" / voyelle} ;
-- The following morphemes are the most common uses of elision.
elisDe = elision "d" ;
elisLa = pre {"la" ; "l'" / voyelle} ;
elisLe = elision "l" ;
elisNe = elision "n" ;
elisQue = elision "qu" ;
-- The subjunction "si" has a special kind of elision. The rule is
-- only approximatively correct, for "si" is not really elided before
-- the string "il" in general, but before the pronouns "il" and "ils".
elisSi = pre {"si" ; "s'" / strs {"il"}} ;
}

2
lib/resource/exper/french/PhraseFre.gf
View File

@@ -1,2 +0,0 @@
concrete PhraseFre of Phrase = CatFre ** PhraseRomance with
(ResRomance = ResFre) ;

2
lib/resource/exper/french/QuestionFre.gf
View File

@@ -1,2 +0,0 @@
concrete QuestionFre of Question = CatFre ** QuestionRomance with
(ResRomance = ResFre) ;

2
lib/resource/exper/french/RelativeFre.gf
View File

@@ -1,2 +0,0 @@
concrete RelativeFre of Relative = CatFre ** RelativeRomance with
(ResRomance = ResFre) ;

13
lib/resource/exper/french/ResFre.gf
View File

@@ -1,13 +0,0 @@
--1 French 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$.
--
instance ResFre of ResRomance = DiffFre ** open CommonRomance, Prelude in {
flags optimize=noexpand ;
} ;

2
lib/resource/exper/french/SentenceFre.gf
View File

@@ -1,2 +0,0 @@
concrete SentenceFre of Sentence = CatFre ** SentenceRomance with
(ResRomance = ResFre) ;

153
lib/resource/exper/french/StructuralFre.gf
View File

@@ -1,153 +0,0 @@
--# -path=.:../abstract:../romance:../common:prelude
concrete StructuralFre of Structural = CatFre **
open PhonoFre, MorphoFre, ParadigmsFre, IrregFre, Prelude in {
flags optimize=all ;
lin
above_Prep = {s = ["au dessus"] ; c = MorphoFre.genitive ; isDir = False} ;
after_Prep = mkPreposition "après" ;
all_Predet = {
s = \\a,c => prepCase c ++ aagrForms "tout" "toute" "tous" "toutes" ! a ;
c = Nom
} ;
almost_AdA, almost_AdN = ss "presque" ;
always_AdV = ss "toujours" ;
although_Subj = ss ("bien" ++ elisQue) ** {m = Conjunct} ;
and_Conj = {s1 = [] ; s2 = "et" ; n = Pl} ;
because_Subj = ss ("parce" ++ elisQue) ** {m = Indic} ;
before_Prep = mkPreposition "avant" ;
behind_Prep = mkPreposition "derrière" ;
between_Prep = mkPreposition "entre" ;
both7and_DConj = {s1,s2 = "et" ; n = Pl} ;
but_PConj = ss "mais" ;
by8agent_Prep = mkPreposition "par" ;
by8means_Prep = mkPreposition "par" ;
can8know_VV = mkVV (savoir_V2 ** {lock_V = <>}) ;
can_VV = mkVV pouvoir_V ;
during_Prep = mkPreposition "pendant" ;
either7or_DConj = {s1,s2 = "ou" ; n = Pl} ;
everybody_NP = pn2np (mkPN ["tout le monde"] Masc) ;
every_Det = {s = \\_,_ => "chaque" ; n = Sg} ;
everything_NP = pn2np (mkPN ["tout"] Masc) ;
everywhere_Adv = ss "partout" ;
few_Det = {s = \\g,c => prepCase c ++ "peu" ++ elisDe ; n = Pl} ;
--- DEPREC first_Ord = {s = \\ag => (regA "premier").s ! Posit ! AF ag.g ag.n} ;
for_Prep = mkPreposition "pour" ;
from_Prep = complGen ; ---
he_Pron =
mkPronoun
"il" (elision "l") "lui" "lui" "son" (elisPoss "s") "ses"
Masc Sg P3 ;
here7from_Adv = ss "d'ici" ;
here7to_Adv = ss "ici" ;
here_Adv = ss "ici" ;
how_IAdv = ss "comment" ;
how8many_IDet = {s = \\_,c => prepCase c ++ "combien" ++ elisDe ; n = Pl} ;
if_Subj = ss elisSi ** {m = Indic} ;
in8front_Prep = mkPreposition "devant" ;
i_Pron =
mkPronoun
(elision "j") (elision "m") (elision "m") "moi" "mon" (elisPoss "m") "mes"
Masc Sg P1 ;
in_Prep = mkPreposition "dans" ;
it_Pron =
mkPronoun
"il" (elision "l") "lui" "lui" "son" (elisPoss "s") "ses"
Masc Sg P3 ;
less_CAdv = ss "moins" ;
many_Det = {s = \\_,c => prepCase c ++ "plusieurs" ; n = Pl} ;
more_CAdv = ss "plus" ;
most_Predet = {s = \\_,c => prepCase c ++ ["la plupart"] ; c = CPrep P_de} ;
much_Det = {s = \\_,c => prepCase c ++ "beaucoup" ++ elisDe ; n = Pl} ;
must_VV = mkVV (devoir_V2 ** {lock_V = <>}) ;
---b no_Phr = ss "non" ;
no_Utt = ss "non" ;
on_Prep = mkPreposition "sur" ;
--- DEPREC one_Quant = {s = \\g,c => prepCase c ++ genForms "un" "une" ! g} ;
only_Predet = {s = \\_,c => prepCase c ++ "seulement" ; c = Nom} ; --- seul(e)(s)
or_Conj = {s1 = [] ; s2 = "ou" ; n = Sg} ;
otherwise_PConj = ss "autrement" ;
part_Prep = complGen ;
please_Voc = ss ["s'il vous plaît"] ;
possess_Prep = complGen ;
quite_Adv = ss "assez" ;
she_Pron =
mkPronoun
"elle" elisLa "lui" "elle" "son" (elisPoss "s") "ses"
Fem Sg P3 ;
so_AdA = ss "si" ;
somebody_NP = pn2np (mkPN ["quelqu'un"] Masc) ;
somePl_Det = {s = \\_,c => prepCase c ++ "quelques" ; n = Pl} ;
someSg_Det = {s = \\_,c => prepCase c ++ elision "quelqu" ; n = Sg} ;
something_NP = pn2np (mkPN ["quelque chose"] Masc) ;
somewhere_Adv = ss ["quelque part"] ; --- ne - pas
that_Quant = {s =
table {
Sg => \\g,c => prepCase c ++ genForms "ce" "cette" ! g ; ---- cet ; là
Pl => \\_,_ => "ces"
}
} ;
---b that_NP = makeNP ["cela"] Masc Sg ;
there7from_Adv = ss ["de là"] ;
there7to_Adv = ss "là" ; --- y
there_Adv = ss "là" ;
therefore_PConj = ss "donc" ;
---b these_NP = makeNP ["ceux-ci"] Masc Pl ;
they_Pron = mkPronoun
"ils" "les" "leur" "eux" "leur" "leur" "leurs"
Masc Pl P3 ;
this_Quant = {s =
table {
Sg => \\g,c =>
prepCase c ++
genForms (pre {"ce" ; "cet" / voyelle}) "cette" ! g ; --- ci
Pl => \\_,_ => "ces"
}
} ;
---b this_NP = pn2np (mkPN ["ceci"] Masc) ;
---b those_NP = makeNP ["ceux-là"] Masc Pl ;
through_Prep = mkPreposition "par" ;
too_AdA = ss "trop" ;
to_Prep = complDat ;
under_Prep = mkPreposition "sous" ;
very_AdA = ss "très" ;
want_VV = mkVV (vouloir_V2 ** {lock_V = <>}) ;
we_Pron =
mkPronoun "nous" "nous" "nous" "nous" "notre" "notre" "nos"
Masc Pl P1 ;
whatSg_IP =
{s = \\c => prepCase c ++ "quoi" ; a = a}
where {a = aagr Masc Sg} ;
whatPl_IP =
{s = \\c => prepCase c ++ "quoi" ; a = a}
where {a = aagr Masc Pl} ;
when_IAdv = ss "quand" ;
when_Subj = ss "quand" ** {m = Indic} ;
where_IAdv = ss "où" ;
which_IQuant = {
s = \\n,g,c =>
prepCase c ++ aagrForms "quel" "quelle" "quels" "quelles" ! aagr g n
} ;
---b whichSg_IDet = {s = \\g,c => prepCase c ++ genForms "quel" "quelle" ! g ; n = Sg} ;
---b whichPl_IDet = {s = \\g,c => prepCase c ++ genForms "quels" "quelles" ! g; n = Pl} ;
whoPl_IP = {s = \\c => prepCase c ++ "qui" ; a = aagr Masc Pl} ;
whoSg_IP = {s = \\c => prepCase c ++ "qui" ; a = aagr Masc Sg} ;
why_IAdv = ss "pourquoi" ;
without_Prep = mkPreposition "sans" ;
with_Prep = mkPreposition "avec" ;
yes_Utt = ss "oui" ; --- si
---b yes_Phr = ss "oui" ; --- si
youSg_Pron = mkPronoun
"tu" (elision "t") (elision "t") "toi" "ton" (elisPoss "t") "tes"
Masc Sg P2 ;
youPl_Pron, youPol_Pron =
mkPronoun
"vous" "vous" "vous" "vous" "votre" "votre" "vos"
Masc Pl P2 ;
}

4
lib/resource/exper/french/VerbFre.gf
View File

@@ -1,4 +0,0 @@
--# -path=.:romance:abstract:../common:prelude
concrete VerbFre of Verb = CatFre ** VerbRomance with
(ResRomance = ResFre) ;

152
lib/resource/exper/restest.gfs
View File

@@ -1,152 +0,0 @@
! date >echo treebank.txt
dc %ttb pt #1 | tb | af treebank.txt
%ttb PositA warm_A
%ttb ComparA warm_A (UsePron i_Pron)
%ttb ComplA2 married_A2 (UsePron she_Pron)
%ttb ReflA2 married_A2
%ttb PositA (UseA2 married_A2)
%ttb SentAP (PositA good_A) (EmbedS (UseCl TPres ASimul PPos (PredVP (UsePron she_Pron) (UseComp (CompAdv here_Adv)))))
%ttb AdAP very_AdA (PositA warm_A)
%ttb PositAdvAdj warm_A
%ttb PrepNP in_Prep (DetArtSg DefArt (UseN house_N))
%ttb ComparAdvAdj more_CAdv warm_A (UsePN john_PN)
%ttb ComparAdvAdjS more_CAdv warm_A (UseCl TPres ASimul PPos (PredVP (UsePron he_Pron) (UseV run_V)))
%ttb SubjS when_Subj (UseCl TPres ASimul PPos (PredVP (UsePron she_Pron) (UseV sleep_V)))
%ttb AdNum (AdnCAdv more_CAdv) (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n5))))))
%ttb ConjS and_Conj (BaseS (UseCl TPres ASimul PPos (PredVP (UsePron he_Pron) (UseV walk_V))) (UseCl TPres ASimul PPos (PredVP (UsePron she_Pron) (UseV run_V))))
%ttb ConjAP and_Conj (BaseAP (PositA cold_A) (PositA warm_A))
%ttb ConjNP or_Conj (BaseNP (UsePron she_Pron) (UsePron we_Pron))
%ttb ConjAdv or_Conj (BaseAdv here_Adv there_Adv)
%ttb DConjS either7or_DConj (BaseS (UseCl TPres ASimul PPos (PredVP (UsePron he_Pron) (UseV walk_V))) (UseCl TPres ASimul PPos (PredVP (UsePron she_Pron) (UseV run_V))))
%ttb DConjAP both7and_DConj (BaseAP (PositA warm_A) (PositA cold_A))
%ttb DConjNP either7or_DConj (BaseNP (UsePron he_Pron) (UsePron she_Pron))
%ttb DConjAdv both7and_DConj (BaseAdv here_Adv there_Adv)
%ttb ImpersCl (UseComp (CompAP (PositA hot_A)))
%ttb GenericCl (UseV sleep_V)
%ttb CleftNP (UsePron i_Pron) (UseRCl TPast ASimul PPos (RelVP IdRP (ComplSlash (SlashV2a do_V2) (UsePron it_Pron))))
%ttb CleftAdv here_Adv (UseCl TPast ASimul PPos (PredVP (UsePron she_Pron) (UseV sleep_V)))
%ttb ExistNP (DetArtSg IndefArt (UseN house_N))
%ttb ExistIP (IdetCN (IdetQuant which_IQuant NumPl) (UseN house_N))
%ttb PredVP (UsePron i_Pron) (ProgrVP (UseV sleep_V))
%ttb ImpPl1 (UseV go_V)
%ttb DetArtSg DefArt (UseN man_N)
%ttb UsePN john_PN
%ttb UsePron he_Pron
%ttb PredetNP only_Predet (DetArtSg DefArt (UseN man_N))
%ttb PPartNP (DetArtSg DefArt (UseN man_N)) see_V2
%ttb AdvNP (UsePN paris_PN) today_Adv
%ttb RelNP (UsePN paris_PN) (UseRCl TPres ASimul PPos (RelVP IdRP (UseComp (CompAdv here_Adv))))
%ttb DetNP (DetQuant this_Quant (NumCard (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n5))))))))
%ttb DetCN (DetQuantOrd this_Quant (NumCard (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n5))))))) (OrdSuperl good_A)) (UseN man_N)
%ttb DetCN (DetQuant this_Quant (NumCard (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n5)))))))) (UseN man_N)
%ttb DetCN (DetQuant this_Quant NumPl) (UseN man_N)
%ttb DetCN (DetQuant this_Quant NumSg) (UseN man_N)
%ttb NumCard (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n5))))))
%ttb NumCard (NumDigits (IIDig D_5 (IDig D_1)))
%ttb NumCard (NumNumeral (num (pot2as3 (pot1as2 (pot1plus n5 pot01)))))
%ttb NumCard (AdNum almost_AdN (NumDigits (IIDig D_5 (IDig D_1))))
%ttb OrdDigits (IIDig D_5 (IDig D_1))
%ttb OrdNumeral (num (pot2as3 (pot1as2 (pot1plus n5 pot01))))
%ttb OrdSuperl warm_A
%ttb DetCN (DetArtOrd DefArt (NumCard (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n5))))))) (OrdSuperl good_A)) (UseN man_N)
%ttb DetCN (DetArtCard DefArt (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n5))))))) (UseN man_N)
%ttb DetCN (DetArtCard IndefArt (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 pot01)))))) (UseN man_N)
%ttb DetCN (DetArtCard DefArt (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 pot01)))))) (UseN man_N)
%ttb DetArtSg DefArt (UseN man_N)
%ttb DetArtPl DefArt (UseN man_N)
%ttb MassNP (UseN beer_N)
%ttb DetCN (DetQuant (PossPron i_Pron) NumSg) (UseN house_N)
%ttb UseN house_N
%ttb ComplN2 mother_N2 (DetArtSg DefArt (UseN king_N))
%ttb ComplN2 (ComplN3 distance_N3 (DetCN (DetQuant this_Quant NumSg) (UseN city_N))) (UsePN paris_PN)
%ttb UseN2 mother_N2
%ttb ComplN2 (Use2N3 distance_N3) (DetCN (DetQuant this_Quant NumSg) (UseN city_N))
%ttb ComplN2 (Use3N3 distance_N3) (UsePN paris_PN)
%ttb UseN2 (Use2N3 distance_N3)
%ttb AdjCN (PositA big_A) (UseN house_N)
%ttb RelCN (UseN house_N) (UseRCl TPast ASimul PPos (RelSlash IdRP (SlashVP (UsePN john_PN) (SlashV2a buy_V2))))
%ttb AdvCN (UseN house_N) (PrepNP on_Prep (DetArtSg DefArt (UseN hill_N)))
%ttb SentCN (UseN question_N) (EmbedQS (UseQCl TPres ASimul PPos (QuestIAdv where_IAdv (PredVP (UsePron she_Pron) (UseV sleep_V)))))
%ttb ApposCN (UseN city_N) (UsePN paris_PN)
%ttb num (pot2as3 (pot1as2 (pot0as1 (pot0 n6))))
%ttb num (pot2as3 (pot1as2 (pot0as1 pot01)))
%ttb num (pot2as3 (pot1as2 (pot1 n6)))
%ttb num (pot2as3 (pot1as2 pot110))
%ttb num (pot2as3 (pot1as2 pot111))
%ttb num (pot2as3 (pot1as2 (pot1to19 n6)))
%ttb num (pot2as3 (pot1as2 (pot1 n6)))
%ttb num (pot2as3 (pot1as2 (pot1plus n6 (pot0 n5))))
%ttb num (pot2as3 (pot2 (pot0 n4)))
%ttb num (pot2as3 (pot2plus (pot0 n4) (pot1plus n6 (pot0 n7))))
%ttb num (pot3 (pot2plus (pot0 n4) (pot1plus n6 (pot0 n7))))
%ttb num (pot3plus (pot2plus (pot0 n4) (pot1plus n6 (pot0 n7))) (pot1as2 (pot1plus n8 (pot0 n9))))
%ttb IDig D_8
%ttb IIDig D_8 (IIDig D_0 (IIDig D_0 (IIDig D_1 (IIDig D_7 (IIDig D_8 (IDig D_9))))))
%ttb PhrUtt but_PConj (UttImpSg PPos (ImpVP (AdvVP (UseV come_V) here_Adv))) (VocNP (DetCN (DetQuant (PossPron i_Pron) NumSg) (UseN friend_N)))
%ttb PhrUtt NoPConj (UttS (UseCl TPres ASimul PPos (PredVP (UsePN john_PN) (UseV walk_V)))) NoVoc
%ttb UttQS (UseQCl TPres ASimul PPos (QuestCl (PredVP (UsePron it_Pron) (UseComp (CompAP (PositA good_A))))))
%ttb UttImpSg PNeg (ImpVP (ReflVP (SlashV2a love_V2)))
%ttb UttImpPl PNeg (ImpVP (ReflVP (SlashV2a love_V2)))
%ttb UttImpPol PNeg (ImpVP (UseV sleep_V))
%ttb UttIP whoPl_IP
%ttb UttIP whoSg_IP
%ttb UttIAdv why_IAdv
%ttb UttNP (DetCN (DetQuant this_Quant NumSg) (UseN man_N))
%ttb UttAdv here_Adv
%ttb UttVP (UseV sleep_V)
%ttb VocNP (DetCN (DetQuant (PossPron i_Pron) NumSg) (UseN friend_N))
%ttb QuestCl (PredVP (UsePN john_PN) (UseV walk_V))
%ttb QuestVP whoSg_IP (UseV walk_V)
%ttb QuestSlash whoSg_IP (SlashVP (UsePN john_PN) (SlashV2a love_V2))
%ttb QuestIAdv why_IAdv (PredVP (UsePN john_PN) (UseV walk_V))
%ttb QuestIComp (CompIAdv where_IAdv) (UsePN john_PN)
%ttb IdetCN (IdetQuant which_IQuant (NumCard (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n5)))))))) (UseN song_N)
%ttb IdetIP (IdetQuant which_IQuant (NumCard (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n5))))))))
%ttb AdvIP whoSg_IP (PrepNP in_Prep (UsePN paris_PN))
%ttb IdetIP (IdetQuant which_IQuant NumSg)
%ttb PrepIP with_Prep whoSg_IP
%ttb QuestIComp (CompIAdv where_IAdv) (UsePron it_Pron)
%ttb QuestIComp (CompIP whoSg_IP) (UsePron it_Pron)
%ttb ExistNP (DetArtSg IndefArt (RelCN (UseN woman_N) (UseRCl TPres ASimul PPos (RelCl (PredVP (UsePN john_PN) (ComplSlash (SlashV2a love_V2) (UsePron she_Pron)))))))
%ttb ExistNP (DetArtSg IndefArt (RelCN (UseN woman_N) (UseRCl TPres ASimul PPos (RelVP IdRP (ComplSlash (SlashV2a love_V2) (UsePN john_PN))))))
%ttb ExistNP (DetArtSg IndefArt (RelCN (UseN woman_N) (UseRCl TPres ASimul PPos (RelSlash IdRP (SlashVP (UsePN john_PN) (SlashV2a love_V2))))))
%ttb ExistNP (DetArtSg IndefArt (RelCN (UseN woman_N) (UseRCl TPres ASimul PPos (RelSlash (FunRP possess_Prep (DetArtSg DefArt (UseN2 mother_N2)) IdRP) (SlashVP (UsePN john_PN) (SlashV2a love_V2))))))
%ttb PredVP (UsePN john_PN) (UseV walk_V)
%ttb PredSCVP (EmbedS (UseCl TPres ASimul PPos (PredVP (UsePron she_Pron) (UseV go_V)))) (UseComp (CompAP (PositA good_A)))
%ttb RelCN (UseN girl_N) (UseRCl TPres ASimul PPos (RelSlash IdRP (SlashVP (UsePron he_Pron) (SlashV2a see_V2))))
%ttb RelCN (UseN girl_N) (UseRCl TPres ASimul PPos (RelSlash IdRP (AdvSlash (SlashVP (UsePron he_Pron) (SlashV2a see_V2)) today_Adv)))
%ttb RelCN (UseN girl_N) (UseRCl TPres ASimul PPos (RelSlash IdRP (SlashPrep (PredVP (UsePron he_Pron) (UseV walk_V)) with_Prep)))
%ttb RelCN (UseN girl_N) (UseRCl TPres ASimul PPos (RelSlash IdRP (SlashVS (UsePron she_Pron) say_VS (UseSlash TPres ASimul PPos (SlashVP (UsePron he_Pron) (SlashV2a love_V2))))))
%ttb ImpVP (ReflVP (SlashV2a love_V2))
%ttb EmbedS (UseCl TPres ASimul PPos (PredVP (UsePron she_Pron) (UseV go_V)))
%ttb EmbedQS (UseQCl TPres ASimul PPos (QuestVP whoSg_IP (UseV go_V)))
%ttb EmbedVP (UseV go_V)
%ttb UseCl TCond AAnter PNeg (PredVP (UsePN john_PN) (UseV walk_V))
%ttb UseQCl TCond AAnter PNeg (QuestCl (PredVP (UsePN john_PN) (UseV walk_V)))
%ttb RelCN (UseN girl_N) (UseRCl TCond AAnter PNeg (RelVP IdRP (UseV walk_V)))
%ttb RelCN (UseN girl_N) (UseRCl TCond AAnter PNeg (RelSlash IdRP (SlashPrep (PredVP (UsePron i_Pron) (UseV walk_V)) with_Prep)))
%ttb RelS (UseCl TPres ASimul PPos (PredVP (UsePron she_Pron) (UseV sleep_V))) (UseRCl TPres ASimul PPos (RelVP IdRP (UseComp (CompAP (PositA good_A)))))
%ttb TEmpty
%ttb TFullStop (PhrUtt NoPConj (UttS (UseCl TPres ASimul PPos (PredVP (UsePN john_PN) (UseV walk_V)))) NoVoc) TEmpty
%ttb TQuestMark (PhrUtt NoPConj (UttQS (UseQCl TPres ASimul PPos (QuestCl (PredVP (UsePron they_Pron) (UseComp (CompAdv here_Adv)))))) NoVoc) TEmpty
%ttb TExclMark (PhrUtt NoPConj (ImpPl1 (UseV go_V)) NoVoc) TEmpty
%ttb PredVP (UsePron i_Pron) (UseV sleep_V)
%ttb PredVP (UsePron i_Pron) (ComplVV want_VV (UseV run_V))
%ttb PredVP (UsePron i_Pron) (ComplVS say_VS (UseCl TPres ASimul PPos (PredVP (UsePron she_Pron) (UseV run_V))))
%ttb PredVP (UsePron i_Pron) (ComplVQ wonder_VQ (UseQCl TPres ASimul PPos (QuestVP whoSg_IP (UseV run_V))))
%ttb PredVP (UsePron they_Pron) (ComplVA become_VA (PositA red_A))
%ttb PredVP (UsePron i_Pron) (ComplSlash (Slash3V3 give_V3 (UsePron he_Pron)) (UsePron it_Pron))
%ttb PredVP (UsePron i_Pron) (ComplSlash (SlashV2V beg_V2V (UseV go_V)) (UsePron she_Pron))
%ttb PredVP (UsePron i_Pron) (ComplSlash (SlashV2S answer_V2S (UseCl TPres ASimul PPos (PredVP (UsePron it_Pron) (UseComp (CompAP (PositA good_A)))))) (UsePron he_Pron))
%ttb PredVP (UsePron i_Pron) (ComplSlash (SlashV2Q ask_V2Q (UseQCl TPast ASimul PPos (QuestVP whoSg_IP (UseV come_V)))) (UsePron he_Pron))
%ttb PredVP (UsePron i_Pron) (ComplSlash (SlashV2A paint_V2A (PositA red_A)) (UsePron it_Pron))
%ttb RelCN (UseN car_N) (UseRCl TPres ASimul PPos (RelSlash IdRP (SlashVP (UsePron i_Pron) (SlashVV want_VV (SlashV2a buy_V2)))))
%ttb RelCN (UseN car_N) (UseRCl TPres ASimul PPos (RelSlash IdRP (SlashVP (UsePron they_Pron) (SlashV2VNP beg_V2V (UsePron i_Pron) (SlashV2a buy_V2)))))
%ttb PredVP (UsePron he_Pron) (ReflVP (SlashV2a love_V2))
%ttb PredVP (DetNP (DetQuant this_Quant NumSg)) (UseComp (CompAP (PositA warm_A)))
%ttb PredVP (UsePron we_Pron) (PassV2 love_V2)
%ttb PredVP (UsePron we_Pron) (AdvVP (UseV sleep_V) here_Adv)
%ttb PredVP (UsePron we_Pron) (AdVVP always_AdV (UseV sleep_V))
%ttb PredVP (UsePron we_Pron) (UseComp (CompAP (PositA small_A)))
%ttb PredVP (UsePron i_Pron) (UseComp (CompNP (DetArtSg IndefArt (UseN man_N))))
%ttb PredVP (UsePron i_Pron) (UseComp (CompAdv here_Adv))

41
lib/resource/exper/romance/AdjectiveRomance.gf
View File

@@ -1,41 +0,0 @@
incomplete concrete AdjectiveRomance of Adjective =
CatRomance ** open CommonRomance, ResRomance, Prelude in {
lin
PositA a = {
s = a.s ! Posit ;
isPre = a.isPre
} ;
ComparA a np = {
s = \\af => a.s ! Compar ! af ++ conjThan ++ np.s ! Ton Nom ;
isPre = False
} ;
-- $SuperlA$ belongs to determiner syntax in $Noun$.
ComplA2 adj np = {
s = \\af => adj.s ! Posit ! af ++ appCompl adj.c2 np.s ;
isPre = False
} ;
ReflA2 adj = {
s = \\af =>
adj.s ! Posit ! af ++ adj.c2.s ++
adj.c2.s ++ prepCase adj.c2.c ++ reflPron Sg P3 Nom ; --- agr
isPre = False
} ;
SentAP ap sc = {
s = \\a => ap.s ! a ++ sc.s ; --- mood
isPre = False
} ;
AdAP ada ap = {
s = \\a => ada.s ++ ap.s ! a ;
isPre = ap.isPre
} ;
UseA2 a = a ** {isPre = False} ;
}

26
lib/resource/exper/romance/AdverbRomance.gf
View File

@@ -1,26 +0,0 @@
incomplete concrete AdverbRomance of Adverb =
CatRomance ** open CommonRomance, ResRomance, Prelude in {
lin
PositAdvAdj a = {
s = a.s ! Posit ! AA
} ;
ComparAdvAdj cadv a np = {
s = cadv.s ++ a.s ! Posit ! AA ++ conjThan ++ np.s ! Ton Nom
} ;
ComparAdvAdjS cadv a s = {
s = cadv.s ++ a.s ! Posit ! AA ++ conjThan ++ s.s ! Conjunct --- ne
} ;
PrepNP prep np = {s = prep.s ++ np.s ! case2npform prep.c} ;
AdAdv = cc2 ;
SubjS subj s = {
s = subj.s ++ s.s ! subj.m
} ;
---b AdvSC s = s ;
AdnCAdv cadv = {s = cadv.s ++ conjThan} ;
}

106
lib/resource/exper/romance/CatRomance.gf
View File

@@ -1,106 +0,0 @@
incomplete concrete CatRomance of Cat =
CommonX - [Tense,TPres,TPast,TFut,TCond]
** open Prelude, CommonRomance, ResRomance, (R = ParamX) in {
flags optimize=all_subs ;
lincat
-- Tensed/Untensed
S = {s : Mood => Str} ;
QS = {s : QForm => Str} ;
RS = {s : Mood => Agr => Str ; c : Case} ;
SSlash = {
s : AAgr => Mood => Str ;
c2 : Compl
} ;
-- Sentence
Cl = {s : Direct => RTense => Anteriority => Polarity => Mood => Str} ;
ClSlash = {
s : AAgr => Direct => RTense => Anteriority => Polarity => Mood => Str ;
c2 : Compl
} ;
Imp = {s : Polarity => ImpForm => Gender => Str} ;
-- Question
QCl = {s : RTense => Anteriority => Polarity => QForm => Str} ;
IP = {s : Case => Str ; a : AAgr} ;
IComp = {s : AAgr => Str} ;
IDet = {s : Gender => Case => Str ; n : Number} ;
IQuant = {s : Number => Gender => Case => Str} ;
-- Relative
RCl = {
s : Agr => RTense => Anteriority => Polarity => Mood => Str ;
c : Case
} ;
RP = {s : Bool => AAgr => Case => Str ; a : AAgr ; hasAgr : Bool} ;
-- Verb
VP = CommonRomance.VP ;
VPSlash = CommonRomance.VP ** {c2 : Compl} ;
Comp = {s : Agr => Str} ;
-- Adjective
AP = {s : AForm => Str ; isPre : Bool} ;
-- Noun
CN = {s : Number => Str ; g : Gender} ;
NP,Pron = Pronoun ;
Det = {s : Gender => Case => Str ; n : Number} ;
--- QuantSg = {s : Gender => Case => Str} ;
--- QuantPl = {s : Bool => Gender => Case => Str} ;
Quant = {s : Number => Gender => Case => Str} ;
Art = {s : Bool => Number => Gender => Case => Str} ;
Predet = {s : AAgr => Case => Str ; c : Case} ; -- c : la plupart de
Num = {s : Gender => Str ; isNum : Bool ; n : Number} ;
Card = {s : Gender => Str ; n : Number} ;
Ord = {s : AAgr => Str} ;
-- Numeral
Numeral = {s : CardOrd => Str ; n : Number} ;
Digits = {s : CardOrd => Str ; n : Number} ;
-- Structural
---b Conj = {s : Str ; n : Number} ;
---b DConj = {s1,s2 : Str ; n : Number} ;
Conj = {s1,s2 : Str ; n : Number} ;
Subj = {s : Str ; m : Mood} ;
Prep = {s : Str ; c : Case ; isDir : Bool} ;
-- Open lexical classes, e.g. Lexicon
V, VQ, VA = Verb ;
V2, VV, V2S, V2Q = Verb ** {c2 : Compl} ;
V3, V2A, V2V = Verb ** {c2,c3 : Compl} ;
VS = Verb ** {m : Polarity => Mood} ;
A = {s : Degree => AForm => Str ; isPre : Bool} ;
A2 = {s : Degree => AForm => Str ; c2 : Compl} ;
N = Noun ;
N2 = Noun ** {c2 : Compl} ;
N3 = Noun ** {c2,c3 : Compl} ;
PN = {s : Str ; g : Gender} ;
-- tense augmented with passé simple
Tense = {s : Str ; t : RTense} ;
lin
TPres = {s = []} ** {t = RPres} ;
TPast = {s = []} ** {t = RPast} ; --# notpresent
TFut = {s = []} ** {t = RFut} ; --# notpresent
TCond = {s = []} ** {t = RCond} ; --# notpresent
}

216
lib/resource/exper/romance/CommonRomance.gf
View File

@@ -1,216 +0,0 @@
----1 Auxiliary operations common for Romance languages
--
-- This module contains operations that are shared by the Romance
-- languages. The complete set of auxiliary operations needed to
-- implement [Test Test.html] is defined in [ResRomance ResRomance.html],
-- which depends on [DiffRomance DiffRomance.html].
--
resource CommonRomance = ParamX ** open Prelude in {
flags optimize=all ;
--2 Enumerated parameter types for morphology
--
-- These types are the ones found in school grammars.
-- Their parameter values are atomic.
param
Gender = Masc | Fem ;
Mood = Indic | Conjunct ;
Direct = DDir | DInv ;
-- Adjectives are inflected in gender and number, and there is also an
-- adverbial form (e.g. "infiniment"), which has different paradigms and
-- can even be irregular ("bien").
-- Comparative adjectives are moreover inflected in degree
-- (which in Romance is usually syntactic, though).
AForm = AF Gender Number | AA ;
-- Gender is not morphologically determined for first and second person pronouns.
PronGen = PGen Gender | PNoGen ;
-- Cardinal numerals have gender, ordinal numerals have full number as well.
CardOrd = NCard Gender | NOrd Gender Number ;
-- The following coercions are useful:
oper
prongen2gender : PronGen -> Gender = \p -> case p of {
PGen g => g ;
PNoGen => variants {Masc ; Fem} --- the best we can do for je, tu, nous, vous
} ;
aform2gender : AForm -> Gender = \a -> case a of {
AF g _ => g ;
_ => Masc -- "le plus lentement"
} ;
aform2number : AForm -> Number = \a -> case a of {
AF _ n => n ;
_ => Sg -- "le plus lentement"
} ;
conjGender : Gender -> Gender -> Gender = \m,n ->
case <m,n> of {
<Fem,Fem> => Fem ;
_ => Masc
} ;
conjAgr : Agr -> Agr -> Agr = \a,b -> {
g = conjGender a.g b.g ;
n = conjNumber a.n b.n ;
p = conjPerson a.p b.p
} ;
--3 Verbs
--
-- In the current syntax, we use
-- a reduced conjugation with only the present tense infinitive,
-- indicative, subjunctive, and imperative forms.
-- But our morphology has full Bescherelle conjunctions:
-- so we use a coercion between full and reduced verbs.
-- The full conjugations and the coercions are defined separately for French
-- and Italian, since they are not identical. The differences are mostly due
-- to Bescherelle structuring the forms in different groups; the
-- gerund and the present participles show real differences.
--
-- For Italian contracted forms, $VInfin$ should have
-- an alternative form, whose proper place is $Diff$.
param
VF =
VInfin Bool
| VFin TMood Number Person
| VImper NumPersI
| VPart Gender Number
| VGer
;
TMood =
VPres Mood
| VImperf Mood --# notpresent
| VPasse --# notpresent
| VFut --# notpresent
| VCondit --# notpresent
;
NumPersI = SgP2 | PlP1 | PlP2 ;
VPForm =
VPFinite TMood Anteriority
| VPImperat
| VPGerund
| VPInfinit Anteriority Bool ;
RTense =
RPres
| RPast --# notpresent
| RPasse --# notpresent
| RFut --# notpresent
| RCond --# notpresent
;
-- Agreement of adjectives, verb phrases, and relative pronouns.
oper
AAgr : Type = {g : Gender ; n : Number} ;
Agr : Type = AAgr ** {p : Person} ;
param
RAgr = RAg {g : Gender ; n : Number} | RNoAg ; --- AAgr
-- Clitic slots.
CAgr = CPron Gender Number Person | CRefl | CNone ; --- Agr
--- CAgr = CPron {g : Gender ; n : Number ; p : Person} | CRefl | CNone ; --- Agr
oper
aagr : Gender -> Number -> AAgr = \g,n ->
{g = g ; n = n} ;
agrP3 : Gender -> Number -> Agr = \g,n ->
aagr g n ** {p = P3} ;
vf2numpers : VF -> (Number * Person) = \v -> case v of {
VFin _ n p => <n,p> ;
_ => <Sg,P3> ----
} ;
presInd = VPres Indic ;
-- The imperative forms depend on number and person.
vImper : Number -> Person -> VF = \n,p -> case <n,p> of {
<Sg,P2> => VImper SgP2 ;
<Pl,P1> => VImper PlP1 ;
<Pl,P2> => VImper PlP2 ;
_ => VInfin False
} ;
---
oper
genForms : Str -> Str -> Gender => Str = \bon,bonne ->
table {
Masc => bon ;
Fem => bonne
} ;
aagrForms : (x1,_,_,x4 : Str) -> (AAgr => Str) = \tout,toute,tous,toutes ->
table {
{g = g ; n = Sg} => genForms tout toute ! g ;
{g = g ; n = Pl} => genForms tous toutes ! g
} ;
Noun = {s : Number => Str ; g : Gender} ;
Adj = {s : AForm => Str} ;
appVPAgr : VPAgr -> AAgr -> AAgr = \vp,agr ->
case vp of {
VPAgrSubj => agr ;
VPAgrClit a => a
} ;
vpAgrNone : VPAgr = VPAgrClit (aagr Masc Sg) ;
oper
mkOrd : {s : Degree => AForm => Str} -> {s : AAgr => Str} ;
mkOrd x = {s = \\ag => x.s ! Posit ! AF ag.g ag.n} ;
-- This is used in Spanish and Italian to bind clitics with preceding verb.
bindIf : Bool -> Str = \b -> if_then_Str b BIND [] ;
param
VPAgr =
VPAgrSubj -- elle est partie, elle s'est vue
| VPAgrClit -- elle a dormi; elle les a vues
{g : Gender ; n : Number} ;
oper
VP : Type = {
s : VPForm => {
fin : Agr => Str ; -- ai
inf : AAgr => Str -- dit
} ;
agr : VPAgr ; -- dit/dite dep. on verb, subj, and clitic
neg : Polarity => (Str * Str) ; -- ne-pas
clAcc : CAgr ; -- le/se
clDat : CAgr ; -- lui
clit2 : Str ; -- y en
comp : Agr => Str ; -- content(e) ; à ma mère ; hier
ext : Polarity => Str ; -- que je dors / que je dorme
} ;
}

70
lib/resource/exper/romance/ConjunctionRomance.gf
View File

@@ -1,70 +0,0 @@
incomplete concrete ConjunctionRomance of Conjunction =
CatRomance ** open CommonRomance, ResRomance, Coordination, Prelude in {
flags optimize=all_subs ;
lin
{---b
ConjS conj ss = conjunctTable Mood conj ss ;
DConjS conj ss = conjunctDistrTable Mood conj ss ;
ConjAdv conj ss = conjunctSS conj ss ;
DConjAdv conj ss = conjunctDistrSS conj ss ;
ConjNP conj ss = conjunctTable NPForm conj ss ** {
a = {g = ss.a.g ; n = conjNumber conj.n ss.a.n ; p = ss.a.p} ;
hasClit = False
} ;
DConjNP conj ss = conjunctDistrTable NPForm conj ss ** {
a = {g = ss.a.g ; n = conjNumber conj.n ss.a.n ; p = ss.a.p} ;
hasClit = False
} ;
ConjAP conj ss = conjunctTable AForm conj ss ** {
isPre = ss.isPre
} ;
DConjAP conj ss = conjunctDistrTable AForm conj ss ** {
isPre = ss.isPre
} ;
---}
ConjS conj ss = conjunctDistrTable Mood conj ss ;
ConjAdv conj ss = conjunctDistrSS conj ss ;
ConjNP conj ss = conjunctDistrTable NPForm conj ss ** {
a = {g = ss.a.g ; n = conjNumber conj.n ss.a.n ; p = ss.a.p} ;
hasClit = False
} ;
ConjAP conj ss = conjunctDistrTable AForm conj ss ** {
isPre = ss.isPre
} ;
-- These fun's are generated from the list cat's.
BaseS = twoTable Mood ;
ConsS = consrTable Mood comma ;
BaseAdv = twoSS ;
ConsAdv = consrSS comma ;
BaseNP x y = {
s1 = \\c => x.s ! stressedCase c ;
s2 = \\c => y.s ! (conjunctCase c) ;
a = conjAgr x.a y.a
} ;
ConsNP x xs = {
s1 = \\c => x.s ! stressedCase c ++ comma ++ xs.s1 ! (conjunctCase c) ;
s2 = \\c => xs.s2 ! (conjunctCase c) ;
a = conjAgr x.a xs.a
} ;
BaseAP x y = twoTable AForm x y ** {isPre = andB x.isPre y.isPre} ;
ConsAP xs x = consrTable AForm comma xs x ** {isPre = andB xs.isPre x.isPre} ;
lincat
[S] = {s1,s2 : Mood => Str} ;
[Adv] = {s1,s2 : Str} ;
[NP] = {s1,s2 : NPForm => Str ; a : Agr} ;
[AP] = {s1,s2 : AForm => Str ; isPre : Bool} ;
}

108
lib/resource/exper/romance/DiffRomance.gf
View File

@@ -1,108 +0,0 @@
--1 Differences between Romance languages
interface DiffRomance = open CommonRomance, Prelude in {
-- The first eight constants show the essential differences
-- between French, Italian, and Romance syntaxes (as regards the
-- resource API). The other constants are either derivatively
-- dependent, or have as values strings, which are language-dependent
-- anyway.
--2 Constants whose definitions fundamentally depend on language
-- Prepositions that fuse with the article
-- (Fre, Spa "de", "a"; Ita also "con", "da", "in", "su).
param Prepos ;
-- Which types of verbs exist, in terms of auxiliaries.
-- (Fre, Ita "avoir", "être", and refl; Spa only "haber" and refl).
param VType ;
-- Derivatively, if/when the participle agrees to the subject.
-- (Fre "elle est partie", Ita "lei è partita", Spa not)
oper partAgr : VType -> VPAgr ;
-- Whether participle agrees to foregoing clitic.
-- (Fre "je l'ai vue", Spa "yo la he visto")
oper vpAgrClit : Agr -> VPAgr ;
-- Whether a preposition is repeated in conjunction
-- (Fre "la somme de 3 et de 4", Ita "la somma di 3 e 4").
oper conjunctCase : NPForm -> NPForm ;
-- How infinitives and clitics are placed relative to each other
-- (Fre "la voir", Ita "vederla"). The $Bool$ is used for indicating
-- if there are any clitics.
oper clitInf : Bool -> Str -> Str -> Str ;
-- To render pronominal arguments as clitics and/or ordinary complements.
-- Returns $True$ if there are any clitics.
oper pronArg : Number -> Person -> CAgr -> CAgr -> Str * Str * Bool ;
-- To render imperatives (with their clitics etc).
oper mkImperative : Bool -> Person -> CommonRomance.VP -> {s : Polarity => AAgr => Str} ;
--2 Constants that must derivatively depend on language
param NPForm = Ton Case | Aton Case | Poss {g : Gender ; n : Number} ; --- AAgr
oper dative : Case ;
oper genitive : Case ;
vRefl : VType ;
isVRefl : VType -> Bool ;
--2 Strings
prepCase : Case -> Str ;
partitive : Gender -> Case -> Str ;
artDef : Gender -> Number -> Case -> Str ;
artIndef : Gender -> Number -> Case -> Str ;
-- This is the definite article in Italian, $prepCase c$ in French and Spanish.
possCase : Gender -> Number -> Case -> Str ;
auxVerb : VType -> (VF => Str) ;
negation : Polarity => (Str * Str) ;
copula : Verb ;
conjThan : Str ;
conjThat : Str ;
subjIf : Str ;
relPron : Bool => AAgr => Case => Str ;
pronSuch : AAgr => Str ;
partQIndir : Str ; -- ce, ciò
reflPron : Number -> Person -> Case -> Str ;
-- argPron : Gender -> Number -> Person -> Case -> Str ;
auxPassive : Verb ;
--2 Contants needed in type signatures above
param
Case = Nom | Acc | CPrep Prepos ;
oper
Verb = {s : VF => Str ; vtyp : VType} ;
}

14
lib/resource/exper/romance/ExtRomance.gf
View File

@@ -1,14 +0,0 @@
incomplete concrete ExtRomance of ExtRomanceAbs =
CatRomance ** open DiffRomance, ResRomance in {
lin
DefSgN predet noun = let g = noun.g in {
s = \\c => predet.s ! gennum g Sg ++ noun.s ! Sg ! Def ! caseNP c ;
a = agrP3 g Sg
} ;
DefPlN predet noun = let g = noun.g in {
s = \\c => predet.s ! Plg ++ noun.s ! Pl ! Def ! caseNP c ;
a = agrP3 g Sg
} ;
}

21
lib/resource/exper/romance/ExtraRomance.gf
View File

@@ -1,21 +0,0 @@
incomplete concrete ExtraRomance of ExtraRomanceAbs = CatRomance **
open
CommonRomance,
Coordination,
ResRomance in {
lin TPasseSimple = {s = []} ** {t = RPasse} ; --# notpresent
lincat
VPI = {s : Str} ;
[VPI] = {s1,s2 : Str} ;
lin
BaseVPI = twoSS ;
ConsVPI = consrSS comma ;
MkVPI vp = {s = infVP vp (agrP3 Masc Sg)} ;
ConjVPI = conjunctSS ;
ComplVPIVV v vpi =
insertComplement (\\a => prepCase v.c2.c ++ vpi.s) (predV v) ;
}

7
lib/resource/exper/romance/ExtraRomanceAbs.gf
View File

@@ -1,7 +0,0 @@
abstract ExtraRomanceAbs = Cat, Extra[
VPI,ListVPI,BaseVPI,ConsVPI,MkVPI,ComplVPIVV,ConjVPI,
VV,VP,Conj] ** {
fun TPasseSimple : Tense ; --# notpresent
}

210
lib/resource/exper/romance/NounRomance.gf
View File

@@ -1,210 +0,0 @@
incomplete concrete NounRomance of Noun =
CatRomance ** open CommonRomance, ResRomance, Prelude in {
flags optimize=all_subs ;
lin
DetCN det cn =
let
g = cn.g ;
n = det.n
in {
s = \\c => let cs = npform2case c in
det.s ! g ! cs ++ cn.s ! n ;
a = agrP3 g n ;
hasClit = False
} ;
UsePN = pn2np ;
UsePron p = p ;
PredetNP pred np = {
s = \\c => pred.s ! aagr (np.a.g) (np.a.n) ! npform2case c ++ --- subtype
np.s ! case2npform pred.c ;
a = np.a ;
hasClit = False
} ;
PPartNP np v2 = {
s = \\c => np.s ! c ++ v2.s ! VPart np.a.g np.a.n ;
a = np.a ;
hasClit = False
} ;
RelNP np rs = {
s = \\c => np.s ! c ++ rs.s ! Indic ! np.a ;
a = np.a ;
hasClit = False
} ;
AdvNP np adv = {
s = \\c => np.s ! c ++ adv.s ;
a = np.a ;
hasClit = False
} ;
DetQuantOrd quant num ord = {
s = \\g,c => quant.s ! num.n ! g ! c ++ num.s ! g ++
ord.s ! aagr g num.n ;
n = num.n
} ;
DetQuant quant num = {
s = \\g,c => quant.s ! num.n ! g ! c ++ num.s ! g ;
n = num.n
} ;
{---b
DetSg quant ord = {
s = \\g,c => quant.s ! False ! Sg ! g ! c ++ ord.s ! aagr g Sg ;
n = Sg
} ;
DetPl quant num ord = {
s = \\g,c => quant.s ! num.isNum ! num.n ! g ! c ++ num.s ! g ++
ord.s ! aagr g Pl ;
n = num.n
} ;
-}
DetNP det =
let
g = Masc ; ---- Fem in Extra
n = det.n
in {
s = \\c => let cs = npform2case c in
det.s ! g ! cs ;
a = agrP3 g n ;
hasClit = False
} ;
PossPron p = {
s = \\n,g,c => possCase g n c ++ p.s ! Poss (aagr g n) ---- il mio!
} ;
NumSg = {s = \\_ => [] ; isNum = False ; n = Sg} ;
NumPl = {s = \\_ => [] ; isNum = False ; n = Pl} ;
---b NoNum = {s = \\_ => [] ; isNum = False ; n = Pl} ;
---b NoOrd = {s = \\_ => []} ;
---b NumInt n = {s = \\_ => n.s ; isNum = True ; n = Pl} ;
---b OrdInt n = {s = \\_ => n.s ++ "."} ; ---
NumCard n = n ** {isNum = True} ;
NumDigits nu = {s = \\g => nu.s ! NCard g ; n = nu.n} ;
OrdDigits nu = {s = \\a => nu.s ! NOrd a.g a.n} ;
NumNumeral nu = {s = \\g => nu.s ! NCard g ; n = nu.n} ;
OrdNumeral nu = {s = \\a => nu.s ! NOrd a.g a.n} ;
AdNum adn num = {s = \\a => adn.s ++ num.s ! a ; isNum = num.isNum ; n = num.n} ;
OrdSuperl adj = {s = \\a => adj.s ! Superl ! AF a.g a.n} ;
DetArtOrd quant num ord = {
s = \\g,c => quant.s ! num.isNum ! num.n ! g ! c ++ num.s ! g ++
ord.s ! aagr g num.n ;
n = num.n
} ;
DetArtCard quant num = {
s = \\g,c => quant.s ! True ! num.n ! g ! c ++ num.s ! g ;
n = num.n
} ;
DetArtSg det cn =
let
g = cn.g ;
n = Sg
in {
s = \\c => let cs = npform2case c in
det.s ! False ! n ! g ! cs ++ cn.s ! n ;
a = agrP3 g n ;
hasClit = False
} ;
DetArtPl det cn =
let
g = cn.g ;
n = Pl
in {
s = \\c => let cs = npform2case c in
det.s ! False ! n ! g ! cs ++ cn.s ! n ;
a = agrP3 g n ;
hasClit = False
} ;
DefArt = {
s = \\_,n,g,c => artDef g n c
} ;
IndefArt = {
s = \\b,n,g,c => if_then_Str b [] (artIndef g n c) ;
} ;
MassNP cn = let
g = cn.g ;
n = Sg
in {
s = \\c => partitive g (npform2case c) ++ cn.s ! n ;
a = agrP3 g n ;
hasClit = False
} ;
{---b
MassDet = {
s = \\b,n,g,c => case <b,n> of {
<False,Sg> => partitive g c ;
_ => prepCase genitive ----
}
} ;
-}
-- This is based on record subtyping.
UseN, UseN2 = \noun -> noun ;
---b UseN3 = \noun -> noun ;
Use2N3 f = f ;
Use3N3 f = f ** {c2 = f.c3} ;
ComplN2 f x = {
s = \\n => f.s ! n ++ appCompl f.c2 x.s ;
g = f.g ;
} ;
ComplN3 f x = {
s = \\n => f.s ! n ++ appCompl f.c2 x.s ;
g = f.g ;
c2 = f.c3
} ;
AdjCN ap cn =
let
g = cn.g
in {
s = \\n => preOrPost ap.isPre (ap.s ! (AF g n)) (cn.s ! n) ;
g = g ;
} ;
RelCN cn rs = let g = cn.g in {
s = \\n => cn.s ! n ++ rs.s ! Indic ! agrP3 g n ; --- mood
g = g
} ;
SentCN cn sc = let g = cn.g in {
s = \\n => cn.s ! n ++ sc.s ;
g = g
} ;
AdvCN cn sc = let g = cn.g in {
s = \\n => cn.s ! n ++ sc.s ;
g = g
} ;
ApposCN cn np = let g = cn.g in {
s = \\n => cn.s ! n ++ np.s ! Ton Nom ;
g = g
} ;
}

27
lib/resource/exper/romance/PhraseRomance.gf
View File

@@ -1,27 +0,0 @@
incomplete concrete PhraseRomance of Phrase =
CatRomance ** open CommonRomance, ResRomance, Prelude in {
flags optimize = all_subs ;
lin
PhrUtt pconj utt voc = {s = pconj.s ++ utt.s ++ voc.s} ;
UttS s = {s = s.s ! Indic} ;
UttQS qs = {s = qs.s ! QDir} ;
UttImpSg pol imp = {s = pol.s ++ imp.s ! pol.p ! ImpF Sg False ! Fem} ;
UttImpPl pol imp = {s = pol.s ++ imp.s ! pol.p ! ImpF Pl False ! Fem} ;
UttImpPol pol imp = {s = pol.s ++ imp.s ! pol.p ! ImpF Sg True ! Fem} ;
UttIP ip = {s = ip.s ! Nom} ; --- Acc also
UttIAdv iadv = iadv ;
UttNP np = {s = np.s ! Ton Nom} ;
UttVP vp = {s = infVP vp (agrP3 Fem Sg)} ; --- Agr
UttAdv adv = adv ;
NoPConj = {s = []} ;
PConjConj conj = {s = conj.s2} ;
NoVoc = {s = []} ;
VocNP np = {s = "," ++ np.s ! Ton Nom} ;
}

109
lib/resource/exper/romance/QuestionRomance.gf
View File

@@ -1,109 +0,0 @@
incomplete concrete QuestionRomance of Question =
CatRomance ** open CommonRomance, ResRomance, Prelude in {
flags optimize=all_subs ;
lin
QuestCl cl = {
s = \\t,a,p =>
let cls = cl.s ! DDir ! t ! a ! p ---- DInv?
in table {
QDir => cls ! Indic ;
QIndir => subjIf ++ cls ! Indic
}
} ;
QuestVP qp vp = {
s = \\t,a,b,_ =>
let
cl = mkClause (qp.s ! Nom) False (agrP3 qp.a.g qp.a.n) vp
in
cl.s ! DDir ! t ! a ! b ! Indic
} ;
QuestSlash ip slash = {
s = \\t,a,p =>
let
cls : Direct -> Str =
\d -> slash.s ! ip.a ! d ! t ! a ! p ! Indic ;
who = slash.c2.s ++ ip.s ! slash.c2.c
in table {
QDir => who ++ cls DInv ;
QIndir => partQIndir ++ who ++ cls DDir
}
} ;
QuestIAdv iadv cl = {
s = \\t,a,p,_ =>
let
cls = cl.s ! DInv ! t ! a ! p ! Indic ;
why = iadv.s
in why ++ cls
} ;
QuestIComp icomp np = {
s = \\t,a,p,_ =>
let
vp = predV copula ;
cls = (mkClause (np.s ! Aton Nom) np.hasClit np.a vp).s !
DInv ! t ! a ! p ! Indic ;
why = icomp.s ! {g = np.a.g ; n = np.a.n}
in why ++ cls
} ;
PrepIP p ip = {
s = p.s ++ ip.s ! p.c
} ;
AdvIP ip adv = {
s = \\c => ip.s ! c ++ adv.s ;
a = ip.a
} ;
IdetCN idet cn =
let
g = cn.g ;
n = idet.n ;
a = aagr g n
in {
s = \\c => idet.s ! g ! c ++ cn.s ! n ;
a = a
} ;
IdetIP idet =
let
g = Masc ; ---- Fem in Extra
n = idet.n ;
a = aagr g n
in {
s = \\c => idet.s ! g ! c ;
a = a
} ;
IdetQuant idet num =
let
n = num.n ;
in {
s = \\g,c => idet.s ! n ! g ! c ++ num.s ! g ;
n = n
} ;
CompIAdv a = {s = \\_ => a.s} ;
CompIP p = {s = \\_ => p.s ! Nom} ;
}
{- ---b
IDetCN idet num ord cn =
let
g = cn.g ;
n = idet.n ;
a = aagr g n
in {
s = \\c => idet.s ! g ! c ++ num.s ! g ++ ord.s ! a ++ cn.s ! n ;
a = a
} ;
-}

50
lib/resource/exper/romance/RelativeRomance.gf
View File

@@ -1,50 +0,0 @@
incomplete concrete RelativeRomance of Relative =
CatRomance ** open Prelude, CommonRomance, ResRomance in {
flags optimize=all_subs ;
lin
RelCl cl = {
s = \\ag,t,a,p,m => pronSuch ! ag ++ conjThat ++
cl.s ! DDir ! t ! a ! p ! m ;
c = Nom
} ;
--- more efficient to compile than case inside mkClause; see log.txt
RelVP rp vp = case rp.hasAgr of {
True => {s = \\ag =>
(mkClause
(rp.s ! False ! {g = ag.g ; n = ag.n} ! Nom) False
{g = rp.a.g ; n = rp.a.n ; p = P3}
vp).s ! DDir ; c = Nom} ;
False => {s = \\ag =>
(mkClause
(rp.s ! False ! {g = ag.g ; n = ag.n} ! Nom) False
ag
vp).s ! DDir ; c = Nom
}
} ;
RelSlash rp slash = {
s = \\ag,t,a,p,m =>
let aag = {g = ag.g ; n = ag.n}
in
slash.c2.s ++
rp.s ! False ! aag ! slash.c2.c ++
slash.s ! aag ! DDir ! t ! a ! p ! m ; --- ragr
c = Acc
} ;
FunRP p np rp = {
s = \\_,a,c => np.s ! Ton Nom ++ p.s ++ rp.s ! True ! a ! p.c ;
a = {g = np.a.g ; n = np.a.n} ;
hasAgr = True
} ;
IdRP = {
s = relPron ;
a = {g = Masc ; n = Sg} ;
hasAgr = False
} ;
}

252
lib/resource/exper/romance/ResRomance.gf
View File

@@ -1,252 +0,0 @@
--1 Romance auxiliary operations.
--
interface ResRomance = DiffRomance ** open CommonRomance, Prelude in {
flags optimize=all ;
--2 Constants uniformly defined in terms of language-dependent constants
oper
nominative : Case = Nom ;
accusative : Case = Acc ;
Pronoun = {s : NPForm => Str ; a : Agr ; hasClit : Bool} ;
Compl : Type = {s : Str ; c : Case ; isDir : Bool} ;
complAcc : Compl = {s = [] ; c = accusative ; isDir = True} ;
complGen : Compl = {s = [] ; c = genitive ; isDir = False} ;
complDat : Compl = {s = [] ; c = dative ; isDir = True} ;
pn2np : {s : Str ; g : Gender} -> Pronoun = \pn -> {
s = \\c => prepCase (npform2case c) ++ pn.s ;
a = agrP3 pn.g Sg ;
hasClit = False
} ;
npform2case : NPForm -> Case = \p -> case p of {
Ton x => x ;
Poss _ => genitive ;
Aton x => x
} ;
case2npform : Case -> NPForm = \c -> case c of {
Nom => Ton Nom ;
Acc => Ton Acc ;
_ => Ton c
} ;
-- Pronouns in $NP$ lists are always in stressed forms.
stressedCase : NPForm -> NPForm = \c -> case c of {
Aton k => Ton k ;
_ => c
} ;
appCompl : Compl -> (NPForm => Str) -> Str = \comp,np ->
comp.s ++ np ! Ton comp.c ;
predV : Verb -> VP = \verb ->
let
vfin : TMood -> Agr -> Str = \tm,a -> verb.s ! VFin tm a.n a.p ;
vpart : AAgr -> Str = \a -> verb.s ! VPart a.g a.n ;
vinf : Bool -> Str = \b -> verb.s ! VInfin b ;
vger = verb.s ! VGer ;
typ = verb.vtyp ;
aux = auxVerb typ ;
habet : TMood -> Agr -> Str = \tm,a -> aux ! VFin tm a.n a.p ;
habere : Str = aux ! VInfin False ;
vimp : Agr -> Str = \a -> case <a.n,a.p> of {
<Pl,P1> => verb.s ! VImper PlP1 ;
<_, P3> => verb.s ! VFin (VPres Conjunct) a.n P3 ;
<Sg,_> => verb.s ! VImper SgP2 ;
<Pl,_> => verb.s ! VImper PlP2
} ;
vf : (Agr -> Str) -> (AAgr -> Str) -> {
fin : Agr => Str ;
inf : AAgr => Str
} =
\fin,inf -> {
fin = \\a => fin a ;
inf = \\a => inf a
} ;
in {
s = table {
VPFinite t Simul => vf (vfin t) (\_ -> []) ;
VPFinite t Anter => vf (habet t) vpart ; --# notpresent
VPInfinit Anter b=> vf (\_ -> []) (\a -> habere ++ vpart a) ; --# notpresent
VPImperat => vf vimp (\_ -> []) ;
VPGerund => vf (\_ -> []) (\_ -> vger) ;
VPInfinit Simul b=> vf (\_ -> []) (\_ -> vinf b)
} ;
agr = partAgr typ ;
neg = negation ;
clAcc = case isVRefl typ of {
True => CRefl ;
_ => CNone
} ;
clDat = CNone ; --- no dative refls
clit2 = [] ;
comp = \\a => [] ;
ext = \\p => []
} ;
insertObject : Compl -> Pronoun -> VP -> VP = \c,np,vp ->
let
vpacc = vp.clAcc ;
vpdat = vp.clDat ;
vpagr = vp.agr ;
npa = np.a ;
cpron = CPron npa.g npa.n npa.p ;
noNewClit = <vpacc, vpdat, appCompl c np.s, vpagr> ;
cc : CAgr * CAgr * Str * VPAgr = case <np.hasClit,c.isDir> of {
<True,True> => case c.c of {
Acc => <cpron, vpdat, [], vpAgrClit npa> ;
_ => <vpacc, cpron, [], vpagr> -- must be dat
} ;
_ => noNewClit
} ;
in {
s = vp.s ;
agr = cc.p4 ;
clAcc = cc.p1 ;
clDat = cc.p2 ;
clit2 = vp.clit2 ;
neg = vp.neg ;
comp = \\a => cc.p3 ++ vp.comp ! a ;
ext = vp.ext ;
} ;
insertComplement : (Agr => Str) -> VP -> VP = \co,vp -> {
s = vp.s ;
agr = vp.agr ;
clAcc = vp.clAcc ;
clDat = vp.clDat ;
clit2 = vp.clit2 ;
neg = vp.neg ;
comp = \\a => vp.comp ! a ++ co ! a ;
ext = vp.ext ;
} ;
-- Agreement with preceding relative or interrogative:
-- "les femmes que j'ai aimées"
insertAgr : AAgr -> VP -> VP = \ag,vp -> {
s = vp.s ;
agr = vpAgrClit (agrP3 ag.g ag.n) ;
clAcc = vp.clAcc ;
clDat = vp.clDat ;
clit2 = vp.clit2 ;
neg = vp.neg ;
comp = vp.comp ;
ext = vp.ext ;
} ;
insertAdv : Str -> VP -> VP = \co,vp -> {
s = vp.s ;
agr = vp.agr ;
clAcc = vp.clAcc ;
clDat = vp.clDat ;
clit2 = vp.clit2 ;
neg = vp.neg ;
comp = \\a => vp.comp ! a ++ co ;
ext = vp.ext ;
} ;
insertAdV : Str -> VP -> VP = \co,vp -> {
s = vp.s ;
agr = vp.agr ;
clAcc = vp.clAcc ;
clDat = vp.clDat ;
clit2 = vp.clit2 ;
neg = \\b => let vpn = vp.neg ! b in {p1 = vpn.p1 ; p2 = vpn.p2 ++ co} ;
comp = vp.comp ;
ext = vp.ext ;
} ;
insertClit2 : Str -> VP -> VP = \co,vp -> {
s = vp.s ;
agr = vp.agr ;
clAcc = vp.clAcc ;
clDat = vp.clDat ;
clit2 = vp.clit2 ++ co ; ---- y en
neg = vp.neg ;
comp = vp.comp ;
ext = vp.ext ;
} ;
insertExtrapos : (Polarity => Str) -> VP -> VP = \co,vp -> {
s = vp.s ;
agr = vp.agr ;
clAcc = vp.clAcc ;
clDat = vp.clDat ;
clit2 = vp.clit2 ;
neg = vp.neg ;
comp = vp.comp ;
ext = \\p => vp.ext ! p ++ co ! p ;
} ;
mkVPSlash : Compl -> VP -> VP ** {c2 : Compl} = \c,vp -> vp ** {c2 = c} ;
mkClause : Str -> Bool -> Agr -> VP ->
{s : Direct => RTense => Anteriority => Polarity => Mood => Str} =
\subj,hasClit,agr,vp -> {
s = \\d,t,a,b,m =>
let
tm = case t of {
RPast => VImperf m ; --# notpresent
RFut => VFut ; --# notpresent
RCond => VCondit ; --# notpresent
RPasse => VPasse ; --# notpresent
RPres => VPres m
} ;
vps = vp.s ! VPFinite tm a ;
verb = vps.fin ! agr ;
inf = vps.inf ! (appVPAgr vp.agr (aagr agr.g agr.n)) ; --- subtype bug
neg = vp.neg ! b ;
clpr = pronArg agr.n agr.p vp.clAcc vp.clDat ;
compl = clpr.p2 ++ vp.comp ! agr ++ vp.ext ! b
in
case d of {
DDir =>
subj ++ neg.p1 ++ clpr.p1 ++ vp.clit2 ++ verb ++ neg.p2 ++ inf ;
DInv =>
neg.p1 ++ clpr.p1 ++ vp.clit2 ++ verb ++
preOrPost hasClit subj (neg.p2 ++ inf)
}
++ compl
} ;
--- in French, pronouns should
--- have a "-" with possibly a special verb form with "t":
--- "comment fera-t-il" vs. "comment fera Pierre"
infVP : VP -> Agr -> Str = \vp,agr ->
let
clpr = pronArg agr.n agr.p vp.clAcc vp.clDat ;
inf = (vp.s ! VPInfinit Simul clpr.p3).inf ! (aagr agr.g agr.n) ;
neg = vp.neg ! Pos ; --- Neg not in API
obj = neg.p2 ++ clpr.p2 ++ vp.comp ! agr ++ vp.ext ! Pos ---- pol
in
clitInf clpr.p3 (clpr.p1 ++ vp.clit2) inf ++ obj ;
}
-- insertObject:
-- p -cat=Cl -tr "la femme te l' envoie"
-- PredVP (DetCN (DetSg DefSg NoOrd) (UseN woman_N))
-- (ComplV3 send_V3 (UsePron he_Pron) (UsePron thou_Pron))
-- la femme te l' a envoyé
--
-- p -cat=Cl -tr "la femme te lui envoie"
-- PredVP (DetCN (DetSg DefSg NoOrd) (UseN woman_N))
-- (ComplV3 send_V3 (UsePron thou_Pron) (UsePron he_Pron))
-- la femme te lui a envoyée

94
lib/resource/exper/romance/SentenceRomance.gf
View File

@@ -1,94 +0,0 @@
incomplete concrete SentenceRomance of Sentence =
CatRomance ** open Prelude, CommonRomance, ResRomance in {
flags optimize=all_subs ;
lin
PredVP np vp = mkClause (np.s ! Aton Nom) np.hasClit np.a vp ;
PredSCVP sc vp = mkClause sc.s False (agrP3 Masc Sg) vp ;
ImpVP vp = {
s = \\p,i,g => case i of {
ImpF n b => (mkImperative b P2 vp).s ! p ! (aagr g n)
}
} ;
SlashVP np v2 =
-- agreement decided afterwards: la fille qu'il a trouvée
{s = \\ag =>
let vp = case <v2.c2.c, v2.c2.isDir> of {
<Acc,True> => insertAgr ag v2 ;
_ => v2
}
in (mkClause (np.s ! Aton Nom) np.hasClit np.a vp).s ;
c2 = v2.c2
} ;
{---b
SlashV2 np v2 =
{s = \\d,ag =>case <v2.c2.c,v2.c2.isDir> of {
<Acc,True> =>
(mkClause (np.s ! Aton Nom) np.hasClit np.a
(insertAgr ag (predV v2))).s ! d ;
_ => (mkClause (np.s ! Aton Nom) np.hasClit np.a (predV v2)).s ! d
} ;
c2 = v2.c2
} ;
SlashVVV2 np vv v2 =
{s = \\d,_ =>
(mkClause
(np.s ! Aton Nom) np.hasClit np.a
(insertComplement
(\\a => prepCase vv.c2.c ++ v2.s ! VInfin False) (predV vv))).s ! d;
c2 = v2.c2
} ;
-}
AdvSlash slash adv = {
s = \\ag,d,t,a,b,m => slash.s ! ag ! d ! t ! a ! b ! m ++ adv.s ;
c2 = slash.c2
} ;
SlashPrep cl prep = {
s = \\_ => cl.s ;
c2 = {s = prep.s ; c = prep.c ; isDir = False}
} ;
SlashVS np vs slash =
{s = \\ag =>
(mkClause
(np.s ! Aton Nom) np.hasClit np.a
(insertExtrapos (\\b => conjThat ++ slash.s ! ag ! (vs.m ! b))
(predV vs))
).s ;
c2 = slash.c2
} ;
EmbedS s = {s = conjThat ++ s.s ! Indic} ; --- mood
EmbedQS qs = {s = qs.s ! QIndir} ;
EmbedVP vp = {s = infVP vp (agrP3 Masc Sg)} ; --- agr ---- compl
UseCl t a p cl = {
s = \\o => t.s ++ a.s ++ p.s ++ cl.s ! DDir ! t.t ! a.a ! p.p ! o
} ;
UseQCl t a p cl = {
s = \\q => t.s ++ a.s ++ p.s ++ cl.s ! t.t ! a.a ! p.p ! q
} ;
UseRCl t a p cl = {
s = \\r,ag => t.s ++ a.s ++ p.s ++ cl.s ! ag ! t.t ! a.a ! p.p ! r ;
c = cl.c
} ;
UseSlash t a p cl = {
s = \\ag,mo =>
t.s ++ a.s ++ p.s ++ cl.s ! ag ! DDir ! t.t ! a.a ! p.p ! mo ;
c2 = cl.c2
} ;
AdvS a s = {s = \\o => a.s ++ "," ++ s.s ! o} ;
RelS s r = {
s = \\o => s.s ! o ++ "," ++ partQIndir ++ r.s ! Indic ! agrP3 Masc Sg
} ;
}

117
lib/resource/exper/romance/VerbRomance.gf
View File

@@ -1,117 +0,0 @@
incomplete concrete VerbRomance of Verb =
CatRomance ** open Prelude, CommonRomance, ResRomance in {
flags optimize=all_subs ;
lin
UseV = predV ;
ComplVV v vp =
insertComplement (\\a => prepCase v.c2.c ++ infVP vp a) (predV v) ;
ComplVS v s = insertExtrapos (\\b => conjThat ++ s.s ! (v.m ! b)) (predV v) ;
ComplVQ v q = insertExtrapos (\\_ => q.s ! QIndir) (predV v) ;
ComplVA v ap =
insertComplement (\\a => ap.s ! AF a.g a.n) (predV v) ;
SlashV2a v = mkVPSlash v.c2 (predV v) ;
Slash2V3 v np = mkVPSlash v.c3 (insertObject v.c2 np (predV v)) ;
Slash3V3 v np = mkVPSlash v.c2 (insertObject v.c3 np (predV v)) ;
SlashV2V v vp =
mkVPSlash v.c2
(insertComplement
(\\a => prepCase v.c2.c ++ infVP vp a)
(predV v)) ;
SlashV2S v s =
mkVPSlash v.c2
(insertExtrapos
(\\b => s.s ! Indic) ---- mood
(predV v)) ;
SlashV2Q v q =
mkVPSlash v.c2
(insertExtrapos
(\\_ => q.s ! QIndir)
(predV v)) ;
SlashV2A v ap =
let af = AF Masc Sg
{- ---- lincat should be fixed
let af = case v.c3.isDir of {
True => AF np.a.g np.a.n ; -- ... bleues
_ => AF Masc Sg -- il les peint en bleu
}
-}
in
mkVPSlash v.c2
(insertComplement
(\\_ => v.c3.s ++ prepCase v.c3.c ++ ap.s ! af)
(predV v)) ;
ComplSlash vp np = insertObject vp.c2 np vp ;
ReflVP v = case v.c2.isDir of {
True => v ** {vtyp = vRefl} ;
False => insertComplement
(\\a => v.c2.s ++ reflPron a.n a.p v.c2.c) v
} ;
SlashVV v vp =
mkVPSlash vp.c2
(insertComplement (\\a => prepCase v.c2.c ++ infVP vp a) (predV v)) ;
SlashV2VNP v np vp =
mkVPSlash vp.c2
(insertComplement
(\\a => prepCase v.c2.c ++ infVP vp a)
(insertObject v.c2 np (predV v))) ;
UseComp comp = insertComplement comp.s (predV copula) ;
CompAP ap = {s = \\ag => ap.s ! AF ag.g ag.n} ;
CompNP np = {s = \\_ => np.s ! Ton Acc} ;
CompAdv a = {s = \\_ => a.s} ;
AdvVP vp adv = insertAdv adv.s vp ;
AdVVP adv vp = insertAdV adv.s vp ;
PassV2 v = insertComplement (\\a => v.s ! VPart a.g a.n) (predV auxPassive) ;
}
{---b
ComplV2 v np1 = insertObject v.c2 np1 (predV v) ;
ComplV3 v np1 np2 = insertObject v.c3 np2 (insertObject v.c2 np1 (predV v)) ;
ComplV2V v np vp =
insertComplement (\\a => prepCase v.c2.c ++ infVP vp a)
(insertObject v.c2 np (predV v)) ;
ComplV2S v np s =
insertExtrapos (\\b => s.s ! Indic) ---- mood
(insertObject v.c2 np (predV v)) ;
ComplV2Q v np q =
insertExtrapos (\\_ => q.s ! QIndir)
(insertObject v.c2 np (predV v)) ;
ComplV2A v np ap =
let af = case v.c3.isDir of {
True => AF np.a.g np.a.n ; -- ... bleues
_ => AF Masc Sg -- il les peint en bleu
}
in
insertComplement
(\\a => v.c3.s ++ prepCase v.c3.c ++ ap.s ! af)
(insertObject v.c2 np (predV v)) ;
ReflV2 v = case v.c2.isDir of {
True => predV {s = v.s ; vtyp = vRefl} ;
False => insertComplement
(\\a => v.c2.s ++ reflPron a.n a.p v.c2.c) (predV v)
} ;
UseVS, UseVQ = \vv -> {s = vv.s ; c2 = complAcc ; vtyp = vv.vtyp} ;
-}