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

optimization flags and improver eng

Browse Source
This commit is contained in:
aarne
2005-02-05 09:52:04 +00:00
parent e7f493fc7c
commit a89dc272e2
6 changed files with 228 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
resource/abstract/Rules.gf
View File

@@ -212,8 +212,6 @@ fun
ExistCN : CN -> Cl ; -- "there is a bar" ExistCN : CN -> Cl ; -- "there is a bar"
ExistNumCN : Num -> CN -> Cl ; -- "there are (86) bars" ExistNumCN : Num -> CN -> Cl ; -- "there are (86) bars"
--- The type signatures of these ones should be changed from VP to VPI. OneNP : NP ; -- "one (walks)"
OneVP : VP -> Cl ; -- "one walks"
} ; } ;

5
resource/english/BasicEng.gf
View File

@@ -1,8 +1,11 @@
--# -path=.:../abstract:../../prelude --# -path=.:../abstract:../../prelude
--# -val
concrete BasicEng of Basic = CategoriesEng ** open NewParadigmsEng in { concrete BasicEng of Basic = CategoriesEng ** open NewParadigmsEng in {
flags startcat=Phr ; lexer=textlit ; parser=chart ; unlexer=text ; flags
startcat=Phr ; lexer=textlit ; unlexer=text ;
optimize=all ;
lin lin
airplane_N = regN "airplane" ; airplane_N = regN "airplane" ;

97
resource/english/ClauseEng.gf
View File

@@ -1,64 +1,65 @@
--# -path=.:../abstract:../../prelude --# -path=.:../abstract:../../prelude
--# -opt
concrete ClauseEng of Clause = CategoriesEng ** concrete ClauseEng of Clause = CategoriesEng **
open Prelude, SyntaxEng in { open Prelude, SyntaxEng in {
lin flags optimize=all ;
SPredV np v = predVerbGroupClause np (predVerb v) ;
SPredPassV np v = predVerbGroupClause np (passVerb v) ;
SPredV2 np v x = predVerbGroupClause np (complTransVerb v x) ;
SPredReflV2 np v = predVerbGroupClause np (reflTransVerb v) ;
SPredVS np v x = predVerbGroupClause np (complSentVerb v x) ;
SPredVV np v x = predVerbGroupClause np (complVerbVerb v x) ;
SPredVQ np v x = predVerbGroupClause np (complQuestVerb v x) ;
SPredVA np v x = predVerbGroupClause np (complAdjVerb v x) ;
SPredV2A np v x y = predVerbGroupClause np (complDitransAdjVerb v x y) ;
SPredSubjV2V np v x y = predVerbGroupClause np (complDitransVerbVerb
False v x y) ;
SPredObjV2V np v x y = predVerbGroupClause np (complDitransVerbVerb
True v x y) ;
SPredV2S np v x y = predVerbGroupClause np (complDitransSentVerb v x y) ;
SPredV2Q np v x y = predVerbGroupClause np (complDitransQuestVerb v x y) ;
SPredAP np v = predBeGroup np (\\_ => v.s ! AAdj) ; lin
-- SPredAP np v = predVerbGroupClause np (predAdjective v) ; SPredV np v = predVerbClause np v (complVerb v) ;
SPredSuperl np a = predVerbGroupClause np (predAdjective (superlAdjPhrase a)) ; SPredPassV np v = predBeGroup np (passVerb v) ;
SPredCN np v = predVerbGroupClause np (predCommNoun v) ; SPredV2 np v x = predVerbClause np v (complTransVerb v x) ;
SPredNP np v = predVerbGroupClause np (predNounPhrase v) ; SPredReflV2 np v = predVerbClause np v (reflTransVerb v) ;
SPredPP np v = predVerbGroupClause np (predAdverb v) ; SPredVS np v x = predVerbClause np v (complSentVerb v x) ;
SPredAV np v x = predVerbGroupClause np (complVerbAdj v x) ; SPredVV np v x = predVerbClause np v (complVerbVerb v x) ;
SPredObjA2V np v x y = predVerbGroupClause np (complVerbAdj2 True v x y) ; SPredVQ np v x = predVerbClause np v (complQuestVerb v x) ;
SPredVA np v x = predVerbClause np v (complAdjVerb v x) ;
SPredV2A np v x y = predVerbClause np v (complDitransAdjVerb v x y) ;
SPredSubjV2V np v x y = predVerbClause np v (complDitransVerbVerb False v x y) ;
SPredObjV2V np v x y = predVerbClause np v (complDitransVerbVerb True v x y) ;
SPredV2S np v x y = predVerbClause np v (complDitransSentVerb v x y) ;
SPredV2Q np v x y = predVerbClause np v (complDitransQuestVerb v x y) ;
SPredAP np v = predBeGroup np (complAdjective v) ;
SPredSuperl np a = predBeGroup np (complAdjective (superlAdjPhrase a)) ;
SPredCN np v = predBeGroup np (complCommNoun v) ;
SPredNP np v = predBeGroup np (complNounPhrase v) ;
SPredPP np v = predBeGroup np (complAdverb v) ;
SPredAV np v x = predBeGroup np (complVerbAdj v x) ;
SPredObjA2V np v x y = predBeGroup np (complVerbAdj2 True v x y) ;
SPredProgVP = progressiveClause ; SPredProgVP = progressiveClause ;
QPredV np v = intVerbPhrase np (predVerb v) ; QPredV np v = intVerbClause np v (complVerb v) ;
QPredPassV np v = intVerbPhrase np (passVerb v) ; QPredPassV np v = predBeGroupQ np (passVerb v) ;
QPredV2 np v x = intVerbPhrase np (complTransVerb v x) ; QPredV2 np v x = intVerbClause np v (complTransVerb v x) ;
QPredReflV2 np v = intVerbPhrase np (reflTransVerb v) ; QPredReflV2 np v = intVerbClause np v (reflTransVerb v) ;
QPredVS np v x = intVerbPhrase np (complSentVerb v x) ; QPredVS np v x = intVerbClause np v (complSentVerb v x) ;
QPredVV np v x = intVerbPhrase np (complVerbVerb v x) ; QPredVV np v x = intVerbClause np v (complVerbVerb v x) ;
QPredVQ np v x = intVerbPhrase np (complQuestVerb v x) ; QPredVQ np v x = intVerbClause np v (complQuestVerb v x) ;
QPredVA np v x = intVerbPhrase np (complAdjVerb v x) ; QPredVA np v x = intVerbClause np v (complAdjVerb v x) ;
QPredV2A np v x y = intVerbPhrase np (complDitransAdjVerb v x y) ; QPredV2A np v x y = intVerbClause np v (complDitransAdjVerb v x y) ;
QPredSubjV2V np v x y = intVerbPhrase np (complDitransVerbVerb QPredSubjV2V np v x y = intVerbClause np v (complDitransVerbVerb
False v x y) ; False v x y) ;
QPredObjV2V np v x y = intVerbPhrase np (complDitransVerbVerb QPredObjV2V np v x y = intVerbClause np v (complDitransVerbVerb
True v x y) ; True v x y) ;
QPredV2S np v x y = intVerbPhrase np (complDitransSentVerb v x y) ; QPredV2S np v x y = intVerbClause np v (complDitransSentVerb v x y) ;
QPredV2Q np v x y = intVerbPhrase np (complDitransQuestVerb v x y) ; QPredV2Q np v x y = intVerbClause np v (complDitransQuestVerb v x y) ;
QPredAP np v = intVerbPhrase np (predAdjective v) ; QPredAP np v = predBeGroupQ np (complAdjective v) ;
QPredSuperl np a = intVerbPhrase np (predAdjective (superlAdjPhrase a)) ; QPredSuperl np a = predBeGroupQ np (complAdjective (superlAdjPhrase a)) ;
QPredCN np v = intVerbPhrase np (predCommNoun v) ; QPredCN np v = predBeGroupQ np (complCommNoun v) ;
QPredNP np v = intVerbPhrase np (predNounPhrase v) ; QPredNP np v = predBeGroupQ np (complNounPhrase v) ;
QPredPP np v = intVerbPhrase np (predAdverb v) ; QPredPP np v = predBeGroupQ np (complAdverb v) ;
QPredAV np v x = intVerbPhrase np (complVerbAdj v x) ; QPredAV np v x = predBeGroupQ np (complVerbAdj v x) ;
QPredObjA2V np v x y = intVerbPhrase np (complVerbAdj2 True v x y) ; QPredObjA2V np v x y = predBeGroupQ np (complVerbAdj2 True v x y) ;
IPredV a v = predVerbGroupI True a (predVerb v) ; IPredV a v = predVerbI True a v (complVerb v) ;
IPredV2 a v x = predVerbGroupI True a (complTransVerb v x) ; IPredV2 a v x = predVerbI True a v (complTransVerb v x) ;
---- SPredAP np v = predBeGroup np (\\_ => v.s ! AAdj) ;
IPredAP a v = predVerbGroupI True a (predAdjective v) ; IPredAP a v = predBeGroupI True a (complAdjective v) ;
{- {-
-- Use VPs -- Use VPs

11
resource/english/RulesEng.gf
View File

@@ -69,7 +69,7 @@ lin
-- verbs and verb prases -- verbs and verb prases
PredAS = predAdjSent ; PredAS = predAdjSent ;
PredV0 rain = predVerbGroupClause (pronNounPhrase pronIt) (predVerb rain) ; PredV0 rain = predVerbClause (pronNounPhrase pronIt) rain (complVerb rain) ;
-- Partial saturation. -- Partial saturation.
@@ -186,16 +186,17 @@ lin
----------------------- -----------------------
-- special constructions -- special constructions
OneVP = predVerbGroupClause (nameNounPhrase (nameReg "one" human)) ; OneNP = nameNounPhrase (nameReg "one" human) ;
---- ThereNP = thereIs ;
ExistCN A = predVerbGroupClause ExistCN A = predVerbClause
(nameNounPhrase (nameReg "there" Neutr)) (nameNounPhrase (nameReg "there" Neutr))
(mkTransVerbDir verbBe)
(complTransVerb (mkTransVerbDir verbBe) (complTransVerb (mkTransVerbDir verbBe)
(indefNounPhrase singular A)) ; (indefNounPhrase singular A)) ;
ExistNumCN nu A = ExistNumCN nu A =
predVerbGroupClause predVerbClause
(nameNounPhrasePl (nameReg "there" Neutr)) (nameNounPhrasePl (nameReg "there" Neutr))
(mkTransVerbDir verbBe)
(complTransVerb (mkTransVerbDir verbBe) (complTransVerb (mkTransVerbDir verbBe)
(indefNounPhraseNum plural nu A)) ; (indefNounPhraseNum plural nu A)) ;

236
resource/english/SyntaxEng.gf
View File

@@ -327,8 +327,8 @@ oper
SForm = SForm =
VFinite Tense Anteriority VFinite Tense Anteriority
| VInfinit Anteriority --- | VInfinit Anteriority
| VPresPart --- | VPresPart
; ;
-- This is how the syntactic verb phrase forms are realized as -- This is how the syntactic verb phrase forms are realized as
@@ -336,6 +336,7 @@ oper
oper oper
{- --vg
verbSForm : Bool -> Verb -> Bool -> SForm -> Agr -> {fin,inf : Str} = verbSForm : Bool -> Verb -> Bool -> SForm -> Agr -> {fin,inf : Str} =
\isAux,verb,b,sf,agr -> \isAux,verb,b,sf,agr ->
let let
@@ -380,6 +381,7 @@ oper
VInfinit Anter => parts neg (have ++ liked) ; VInfinit Anter => parts neg (have ++ liked) ;
VPresPart => parts neg liking VPresPart => parts neg liking
} ; } ;
-}
auxHave : Bool -> Tense -> Agr -> Str = \b,t,a -> auxHave : Bool -> Tense -> Agr -> Str = \b,t,a ->
let has = let has =
@@ -422,6 +424,7 @@ oper
negAux : Bool -> Str -> Str = \b,is -> if_then_Str b is (is + "n't") ; negAux : Bool -> Str -> Str = \b,is -> if_then_Str b is (is + "n't") ;
{- --vg
useVerbGen : Bool -> Verb -> (Agr => Str) -> VerbGroup = \isAux,verb,arg -> useVerbGen : Bool -> Verb -> (Agr => Str) -> VerbGroup = \isAux,verb,arg ->
let let
go = verbSForm isAux verb go = verbSForm isAux verb
@@ -436,6 +439,7 @@ oper
beGroup : (Agr => Str) -> VerbGroup = beGroup : (Agr => Str) -> VerbGroup =
useVerbAux (verbBe ** {s1 = []}) ; useVerbAux (verbBe ** {s1 = []}) ;
--vg -}
---- TODO: the contracted forms. ---- TODO: the contracted forms.
@@ -466,45 +470,49 @@ oper
-- All negative verb phrase behave as auxiliary ones in questions. -- All negative verb phrase behave as auxiliary ones in questions.
predVerbGroup : Bool -> Anteriority -> VerbGroup -> VerbPhrase = \b,ant,vg -> { predVerbI : Bool -> {s : Str ; a : Anteriority} -> Verb -> Complement -> VerbPhrase =
s = table { \b,ant,verb,comp ->
VIInfinit => \\a => vg.s2 ! b ! VInfinit ant ! a ; -- s1 is just neg for inf let
VIPresPart => \\a => vg.s2 ! b ! VPresPart ! a ans = ant.s ; --- just to avoid ? in parsing
inf = case ant.a of {
Simul => verb.s ! InfImp ;
Anter => "have" ++ verb.s ! PPart
}
in
{s = table {
VIInfinit => \\a => ans ++ inf ++ verb.s1 ++ comp ! a ;
VIPresPart => \\a => ans ++ verb.s ! PresPart ++ comp ! a
} ; } ;
s1 = if_then_Str b [] "not" s1 = if_then_Str b [] "not"
} ; } ;
predVerbGroupI : Bool -> {s : Str ; a : Anteriority} -> VerbGroup -> VerbPhrase =
\b,ant,vg ->
let vp = predVerbGroup b ant.a vg in
{s = \\f,a => ant.s ++ vp.s ! f ! a ;
s1 = vp.s1
} ;
-- A simple verb can be made into a verb phrase with an empty complement. -- A simple verb can be made into a verb phrase with an empty complement.
-- There are two versions, depending on if we want to negate the verb. -- There are two versions, depending on if we want to negate the verb.
-- N.B. negation is *not* a function applicable to a verb phrase, since -- N.B. negation is *not* a function applicable to a verb phrase, since
-- double negations with "don't" are not grammatical. -- double negations with "don't" are not grammatical.
predVerb : Verb -> VerbGroup = \walk -> complVerb : Verb -> Complement = \walk ->
useVerb walk (\\_ => []) ; \\_ => walk.s1 ;
mkComp : Verb -> Complement -> Complement = \verb,comp ->
\\a => verb.s1 ++ comp ! a ;
-- Verb phrases can also be formed from adjectives ("is old"), -- Verb phrases can also be formed from adjectives ("is old"),
-- common nouns ("is a man"), and noun phrases ("ist John"). -- common nouns ("is a man"), and noun phrases ("ist John").
-- The third rule is overgenerating: "is every man" has to be ruled out -- The third rule is overgenerating: "is every man" has to be ruled out
-- on semantic grounds. -- on semantic grounds.
predAdjective : Adjective -> VerbGroup = \old -> complAdjective : Adjective -> Complement = \old ->
beGroup (\\_ => old.s ! AAdj) ; (\\_ => old.s ! AAdj) ;
predCommNoun : CommNoun -> VerbGroup = \man -> complCommNoun : CommNoun -> Complement = \man ->
beGroup (\\a => indefNoun (fromAgr a).n man) ; (\\a => indefNoun (fromAgr a).n man) ;
predNounPhrase : NounPhrase -> VerbGroup = \john -> complNounPhrase : NounPhrase -> Complement = \john ->
beGroup (\\_ => john.s ! NomP) ; (\\_ => john.s ! NomP) ;
predAdverb : PrepPhrase -> VerbGroup = \elsewhere -> complAdverb : PrepPhrase -> Complement = \elsewhere ->
beGroup (\\_ => elsewhere.s) ; (\\_ => elsewhere.s) ;
{- --- compiles to 25k lines gfr 3/2/2005 {- --- compiles to 25k lines gfr 3/2/2005
predAdjSent : Adjective -> Sentence -> Clause = \bra,hansover -> predAdjSent : Adjective -> Sentence -> Clause = \bra,hansover ->
@@ -517,7 +525,21 @@ oper
predAdjSent : Adjective -> Sentence -> Clause = \bra,hansover -> predAdjSent : Adjective -> Sentence -> Clause = \bra,hansover ->
predBeGroup (pronNounPhrase pronIt) (\\n => bra.s ! AAdj ++ "that" ++ hansover.s) ; predBeGroup (pronNounPhrase pronIt) (\\n => bra.s ! AAdj ++ "that" ++ hansover.s) ;
predBeGroup : NounPhrase -> (Agr => Str) -> Clause = \itt,goo -> Complement = Agr => Str ;
predBeGroupI : Bool -> {s : Str ; a : Anteriority} -> Complement -> VerbPhrase =
\b,ant,vg ->
{s = table {
VIInfinit => \\a => ant.s ++ case ant.a of {
Simul => "be" ++ vg ! a ;
Anter => "have" ++ "been" ++ vg ! a
} ;
VIPresPart => \\a => "being" ++ vg ! a
} ;
s1 = if_then_Str b [] "not" ;
} ;
predBeGroup : NounPhrase -> Complement -> Clause = \itt,goo ->
let let
it = itt.s ! NomP ; it = itt.s ! NomP ;
good = goo ! itt.a ; good = goo ! itt.a ;
@@ -551,10 +573,11 @@ oper
VFinite t Anter => case o of { VFinite t Anter => case o of {
Dir => it ++ has b t ++ beengood t ; Dir => it ++ has b t ++ beengood t ;
Inv => has b t ++ it ++ beengood t Inv => has b t ++ it ++ beengood t
} ; }
VInfinit Simul => it ++ begood Future ; --- ;
VInfinit Anter => it ++ beengood Future ; --- VInfinit Simul => it ++ begood Future ;
VPresPart => it ++ "being" ++ good --- VInfinit Anter => it ++ beengood Future ;
--- VPresPart => it ++ "being" ++ good
} }
} ; } ;
@@ -578,8 +601,8 @@ oper
-- ("I switch on the radio" / "I switch the radio on"). -- ("I switch on the radio" / "I switch the radio on").
---- TODO: do this again. ---- TODO: do this again.
complTransVerb : TransVerb -> NounPhrase -> VerbGroup = \switch,radio -> complTransVerb : TransVerb -> NounPhrase -> Complement = \switch,radio ->
useVerb switch (\\_ => switch.s3 ++ radio.s ! AccP) ; mkComp switch (\\_ => switch.s3 ++ radio.s ! AccP) ;
-- Verbs that take direct object and a particle: -- Verbs that take direct object and a particle:
@@ -601,14 +624,14 @@ oper
-- Therefore, the function can also be used for "he is swum", etc. -- Therefore, the function can also be used for "he is swum", etc.
-- The syntax is the same as for adjectival predication. -- The syntax is the same as for adjectival predication.
passVerb : Verb -> VerbGroup = \love -> passVerb : Verb -> Complement = \love ->
predAdjective (adj2adjPhrase (regAdjective (love.s ! PPart))) ; complAdjective (adj2adjPhrase (regAdjective (love.s ! PPart))) ;
-- Transitive verbs can also be used reflexively. -- Transitive verbs can also be used reflexively.
-- But to formalize this we must make verb phrases depend on a person parameter. -- But to formalize this we must make verb phrases depend on a person parameter.
reflTransVerb : TransVerb -> VerbGroup = \love -> reflTransVerb : TransVerb -> Complement = \love ->
useVerb love (\\a => love.s1 ++ love.s3 ++ reflPron a) ; ---- mkComp love (\\a => love.s1 ++ love.s3 ++ reflPron a) ; ----
-- Transitive verbs can be used elliptically as verbs. The semantics -- Transitive verbs can be used elliptically as verbs. The semantics
-- is left to applications. The definition is trivial, due to record -- is left to applications. The definition is trivial, due to record
@@ -634,14 +657,14 @@ oper
} ; } ;
complDitransAdjVerb : complDitransAdjVerb :
TransVerb -> NounPhrase -> AdjPhrase -> VerbGroup = \gor,dig,sur -> TransVerb -> NounPhrase -> AdjPhrase -> Complement = \gor,dig,sur ->
useVerb mkComp
gor gor
(\\_ => gor.s1 ++ gor.s3 ++ dig.s ! AccP ++ sur.s ! AAdj) ; (\\_ => gor.s1 ++ gor.s3 ++ dig.s ! AccP ++ sur.s ! AAdj) ;
complAdjVerb : complAdjVerb :
Verb -> AdjPhrase -> VerbGroup = \seut,sur -> Verb -> AdjPhrase -> Complement = \seut,sur ->
useVerb mkComp
seut seut
(\\n => sur.s ! AAdj ++ seut.s1) ; (\\n => sur.s ! AAdj ++ seut.s1) ;
@@ -716,8 +739,6 @@ oper
APl P3 => "themselves" APl P3 => "themselves"
} ; } ;
progressiveVerbPhrase : VerbPhrase -> VerbGroup = \vp ->
beGroup (vp.s ! VIPresPart) ;
progressiveClause : NounPhrase -> VerbPhrase -> Clause = \np,vp -> progressiveClause : NounPhrase -> VerbPhrase -> Clause = \np,vp ->
predBeGroup np (vp.s ! VIPresPart) ; predBeGroup np (vp.s ! VIPresPart) ;
@@ -734,6 +755,64 @@ oper
---- compiles to 4k lines gfr. also relSlash, relVerbPhrase are bad ---- compiles to 4k lines gfr. also relSlash, relVerbPhrase are bad
oper oper
Verbal = VForm => Agr => Str ;
-- This applies to non-auxiliaries.
predVerbClause : NounPhrase -> Verb -> Complement -> Clause = \np,verb,comp ->
let
it = np.s ! NomP ;
agr = np.a ;
itgoes : Order -> Str -> Str -> Str = \o,x,y -> case o of {
Dir => it ++ x ++ y ;
Inv => x ++ it ++ y
} ;
goes : Tense -> Str = \t -> verb.s ! case <t,agr> of {
<Present,ASgP1> => Indic P1 ;
<Present,ASgP3 _> => Indic P3 ;
<Present,_> => Indic P2 ;
<Past,ASgP1> => Pastt Pl ;
<Past,ASgP3 _> => Pastt Sg ;
_ => Pastt Pl --- Future doesn't matter
} ;
off = comp ! agr ;
go = verb.s ! InfImp ++ off ;
gone = verb.s ! PPart ++ off ;
going = verb.s ! PresPart ++ off ;
have = "have" ;
has : Bool -> Tense -> Str = \b,t -> auxHave b t agr ;
does : Bool -> Tense -> Str = \b,t -> auxTense b t agr
in
{s = \\o,b,sf =>
let
neg = if_then_Str b [] "not" ;
in
case sf of {
VFinite Present Simul => case b of {
True => case o of {
Dir => it ++ goes Present ++ off ;
Inv => does b Present ++ it ++ go
} ;
False => itgoes o (does b Present) go
} ;
VFinite Past Simul => case b of {
True => case o of {
Dir => it ++ goes Past ++ off ;
Inv => does b Past ++ it ++ go
} ;
False => itgoes o (does b Past) go
} ;
VFinite t Simul => itgoes o (does b t) go ;
VFinite Present Anter => itgoes o (has b Present) gone ;
VFinite Past Anter => itgoes o (has b Past) gone ;
VFinite t Anter => itgoes o (does b t) (have ++ gone)
--- ;
--- VInfinit Simul => it ++ neg ++ go ;
--- VInfinit Anter => it ++ neg ++ (have ++ gone) ;
--- VPresPart => it ++ neg ++ going
}
} ;
{- --vg
predVerbGroupClause : NounPhrase -> VerbGroup -> Clause = predVerbGroupClause : NounPhrase -> VerbGroup -> Clause =
\yo,dosleep -> { \yo,dosleep -> {
s = \\o,b,c => s = \\o,b,c =>
@@ -755,7 +834,7 @@ oper
} }
} }
} ; } ;
-- vg -}
--3 Sentence-complement verbs --3 Sentence-complement verbs
-- --
@@ -766,20 +845,20 @@ oper
-- To generate "says that John walks" / "doesn't say that John walks": -- To generate "says that John walks" / "doesn't say that John walks":
---- TODO: the alternative without "that" ---- TODO: the alternative without "that"
complSentVerb : SentenceVerb -> Sentence -> VerbGroup = \say,johnruns -> complSentVerb : SentenceVerb -> Sentence -> Complement = \say,johnruns ->
useVerb say (\\_ => "that" ++ johnruns.s) ; mkComp say (\\_ => "that" ++ johnruns.s) ;
complQuestVerb : SentenceVerb -> QuestionSent -> VerbGroup = \se,omduler -> complQuestVerb : SentenceVerb -> QuestionSent -> Complement = \se,omduler ->
useVerb se (\\_ => se.s1 ++ omduler.s ! IndirQ) ; mkComp se (\\_ => se.s1 ++ omduler.s ! IndirQ) ;
complDitransSentVerb : TransVerb -> NounPhrase -> Sentence -> VerbGroup = complDitransSentVerb : TransVerb -> NounPhrase -> Sentence -> Complement =
\sa,honom,duler -> \sa,honom,duler ->
useVerb sa mkComp sa
(\\_ => sa.s1 ++ sa.s3 ++ honom.s ! AccP ++ "that" ++ duler.s) ; (\\_ => sa.s1 ++ sa.s3 ++ honom.s ! AccP ++ "that" ++ duler.s) ;
complDitransQuestVerb : TransVerb -> NounPhrase -> QuestionSent -> VerbGroup = complDitransQuestVerb : TransVerb -> NounPhrase -> QuestionSent -> Complement =
\sa,honom,omduler -> \sa,honom,omduler ->
useVerb sa mkComp sa
(\\_ => sa.s1 ++ sa.s3 ++ honom.s ! AccP ++ omduler.s ! IndirQ) ; (\\_ => sa.s1 ++ sa.s3 ++ honom.s ! AccP ++ omduler.s ! IndirQ) ;
@@ -799,16 +878,16 @@ oper
-- The contraction of "not" is not provided, since it would require changing -- The contraction of "not" is not provided, since it would require changing
-- the verb parameter type. -- the verb parameter type.
complVerbVerb : VerbVerb -> VerbPhrase -> VerbGroup = \try,run -> complVerbVerb : VerbVerb -> VerbPhrase -> Complement = \try,run ->
let let
taux = try.isAux ; taux = try.isAux ;
to = if_then_Str taux [] "to" ; to = if_then_Str taux [] "to" ;
torun : Agr => Str = torun : Agr => Str =
\\a => run.s1 ++ to ++ run.s ! VIInfinit ! a \\a => run.s1 ++ to ++ run.s ! VIInfinit ! a
in in
if_then_else VerbGroup taux ---- if_then_else VerbGroup taux
(useVerb try torun) ---- (useVerbAux try torun)
(useVerbAux try torun) ; (mkComp try torun) ;
-- The three most important example auxiliaries. -- The three most important example auxiliaries.
@@ -834,9 +913,9 @@ oper
DitransVerbVerb = TransVerb ** {s4 : Str} ; DitransVerbVerb = TransVerb ** {s4 : Str} ;
complDitransVerbVerb : complDitransVerbVerb :
Bool -> DitransVerbVerb -> NounPhrase -> VerbPhrase -> VerbGroup = Bool -> DitransVerbVerb -> NounPhrase -> VerbPhrase -> Complement =
\obj,be,dig,simma -> \obj,be,dig,simma ->
useVerb be mkComp be
(\\a => be.s1 ++ be.s3 ++ dig.s ! AccP ++ be.s3 ++ be.s4 ++ (\\a => be.s1 ++ be.s3 ++ dig.s ! AccP ++ be.s3 ++ be.s4 ++
simma.s1 ++ -- negation simma.s1 ++ -- negation
if_then_Str obj if_then_Str obj
@@ -851,17 +930,15 @@ oper
s3 = hitta.s3 s3 = hitta.s3
} ; } ;
complVerbAdj : Adjective -> VerbPhrase -> VerbGroup = \grei, simma -> complVerbAdj : Adjective -> VerbPhrase -> Complement = \grei, simma ->
beGroup
(\\a => (\\a =>
grei.s ! AAdj ++ simma.s1 ++ grei.s ! AAdj ++ simma.s1 ++
"to" ++ "to" ++
simma.s ! VIInfinit ! a) ; simma.s ! VIInfinit ! a) ;
complVerbAdj2 : complVerbAdj2 :
Bool -> AdjCompl -> NounPhrase -> VerbPhrase -> VerbGroup = Bool -> AdjCompl -> NounPhrase -> VerbPhrase -> Complement =
\obj,grei,dig,simma -> \obj,grei,dig,simma ->
beGroup
(\\a => (\\a =>
grei.s ! AAdj ++ grei.s ! AAdj ++
grei.s2 ++ dig.s ! AccP ++ grei.s2 ++ dig.s ! AccP ++
@@ -892,10 +969,10 @@ oper
slashTransVerbCl : NounPhrase -> TransVerb -> ClauseSlashNounPhrase = slashTransVerbCl : NounPhrase -> TransVerb -> ClauseSlashNounPhrase =
\you,lookat -> \you,lookat ->
let youlookat = (predVerbClause you lookat (complVerb lookat)).s in
{s = table { {s = table {
DirQ => \\b,f => (questVerbPhrase you (predVerb DirQ => youlookat ! Inv ;
lookat)).s ! b ! f ! DirQ ; IndirQ => youlookat ! Dir
IndirQ => (predVerbGroupClause you (predVerb lookat)).s ! Dir
} ; } ;
s2 = lookat.s3 s2 = lookat.s3
} ; } ;
@@ -927,11 +1004,11 @@ oper
RelClause : Type = {s : Bool => SForm => Agr => Str} ; RelClause : Type = {s : Bool => SForm => Agr => Str} ;
RelSentence : Type = {s : Agr => Str} ; RelSentence : Type = {s : Agr => Str} ;
------ relg
relVerbPhrase : RelPron -> VerbGroup -> RelClause = \who,walks -> relVerbPhrase : RelPron -> VerbGroup -> RelClause = \who,walks ->
{s = \\b,sf,a => {s = \\b,sf,a => []
let wa = fromAgr a in ---- let wa = fromAgr a in
(predVerbGroupClause (relNounPhrase who wa.g wa.n) walks).s ! Dir ---- (predVerbGroupClause (relNounPhrase who wa.g wa.n) walks).s ! Dir ! b ! sf
! b ! sf
} ; } ;
--- TODO: full tense variation in relative clauses. --- TODO: full tense variation in relative clauses.
@@ -1056,7 +1133,7 @@ oper
IndirQ => cl.s ! Dir ! b ! c IndirQ => cl.s ! Dir ! b ! c
} }
} ; } ;
{- --vg
questVerbPhrase : NounPhrase -> VerbGroup -> Question = questVerbPhrase : NounPhrase -> VerbGroup -> Question =
questVerbPhrase' False ; questVerbPhrase' False ;
@@ -1080,19 +1157,38 @@ oper
(predVerbGroupClause John walk).s ! Dir ! b ! cl (predVerbGroupClause John walk).s ! Dir ! b ! cl
} }
} ; } ;
-- vg -}
--3 Wh-questions --3 Wh-questions
-- --
-- Wh-questions are of two kinds: ones that are like $NP - VP$ sentences, -- Wh-questions are of two kinds: ones that are like $NP - VP$ sentences,
-- others that are line $S/NP - NP$ sentences. -- others that are line $S/NP - NP$ sentences.
intNounPhrase : IntPron -> NounPhrase = \who ->
{s = who.s ; a = toAgr who.n P3 who.g} ;
predBeGroupQ : IntPron -> Complement -> Question = \who,old ->
let whoisold = predBeGroup (intNounPhrase who) old
in
{s = \\b,sf,_ => whoisold.s ! Dir ! b ! sf} ;
{- --vg
intVerbPhrase : IntPron -> VerbGroup -> Question = \who,walk -> intVerbPhrase : IntPron -> VerbGroup -> Question = \who,walk ->
let let
who : NounPhrase = {s = who.s ; a = toAgr who.n P3 who.g} ; who : NounPhrase = {s = who.s ; a = toAgr who.n P3 who.g} ;
whowalks : Clause = predVerbGroupClause who walk whowalks : Clause = predVerbGroupClause who walk
in in
{s = \\b,sf,_ => whowalks.s ! Dir ! b ! sf} ; {s = \\b,sf,_ => whowalks.s ! Dir ! b ! sf} ;
--vg -}
intVerbClause : IntPron -> Verb -> Complement -> Question = \who,walk,here ->
let
who : NounPhrase = {s = who.s ; a = toAgr who.n P3 who.g} ;
whowalks : Clause = predVerbClause who walk here
in
{s = \\b,sf,_ => whowalks.s ! Dir ! b ! sf} ;
intSlash : IntPron -> ClauseSlashNounPhrase -> Question = \who,yousee -> intSlash : IntPron -> ClauseSlashNounPhrase -> Question = \who,yousee ->
{s = \\b,cl,q => {s = \\b,cl,q =>
let let

3
resource/scandinavian/RulesScand.gf
View File

@@ -99,7 +99,6 @@ lin
-- --
SlashV2 = slashTransVerb ; SlashV2 = slashTransVerb ;
OneVP = predVerbGroupClause npMan ;
IdRP = identRelPron ; IdRP = identRelPron ;
FunRP = funRelPron ; FunRP = funRelPron ;
@@ -172,7 +171,7 @@ lin
----------------------- -----------------------
-- special constructions -- special constructions
OneVP = predVerbGroupClause npMan ; OneNP = npMan ;
ExistCN A = predVerbGroupClause npDet ExistCN A = predVerbGroupClause npDet
(complTransVerb (mkDirectVerb (deponentVerb verbFinnas)) (complTransVerb (mkDirectVerb (deponentVerb verbFinnas))