diff --git a/lib/resource/french/SyntaxFre.gf b/lib/resource/french/SyntaxFre.gf index f3dae1f5c..feeb138d1 100644 --- a/lib/resource/french/SyntaxFre.gf +++ b/lib/resource/french/SyntaxFre.gf @@ -114,10 +114,12 @@ oper AEsse => verbEtre } ; +{- ---G progressiveVerbPhrase : VerbPhrase -> VerbGroup = \vp -> predClauseBeGroup (complCopula (\\g,n,p => "en" ++ "train" ++ elisDe ++ vp.s ! VIInfinit ! g ! n ! p)) ; +-} -- The "ne - pas" negation. @@ -328,6 +330,4 @@ oper negNe = elisNe ; negPas = "pas" ; - predVerb0 rain = predVerbClause (pronNounPhrase pronImpers) rain (complVerb rain) ; - } diff --git a/lib/resource/italian/SyntaxIta.gf b/lib/resource/italian/SyntaxIta.gf index d77c66daf..3053b1151 100644 --- a/lib/resource/italian/SyntaxIta.gf +++ b/lib/resource/italian/SyntaxIta.gf @@ -14,7 +14,7 @@ oper nounPhraseOn = mkNameNounPhrase "si" Masc ; --- can be plural dep. on object - pronImpers : NounPhrase = pronNounPhrase pronIl ; ---- should be empty + pronImpers : NounPhrase = mkNameNounPhrase [] Masc ; partitiveNounPhrase = \n,vino -> normalNounPhrase @@ -275,7 +275,4 @@ oper negNe = "non" ; negPas = [] ; - predVerb0 rain = predVerbClause (mkNameNounPhrase [] Masc) rain (complVerb rain) ; - } - diff --git a/lib/resource/romance/ClauseRomance.gf b/lib/resource/romance/ClauseRomance.gf index e0485ce41..a028388b5 100644 --- a/lib/resource/romance/ClauseRomance.gf +++ b/lib/resource/romance/ClauseRomance.gf @@ -44,6 +44,11 @@ incomplete concrete ClauseRomance of Clause = CategoriesRomance ** SPredVA subj verb adj = sats2clause ( insertExtrapos (mkSats subj verb) (\\_ => adj.s ! AF (pgen2gen subj.g) subj.n)) ; + SPredV2A subj verb obj adj = + sats2clause ( + insertExtrapos + (mkSatsObject subj verb obj) + (\\_ => adj.s ! AF (pgen2gen obj.g) obj.n)) ; SPredVV subj verb vp = sats2clause ( @@ -52,14 +57,21 @@ incomplete concrete ClauseRomance of Clause = CategoriesRomance ** (\\_ => prepCase verb.c ++ vp.s ! VIInfinit ! pgen2gen subj.g ! subj.n ! subj.p) ) ; --- SPredObjV2V + SPredObjV2V subj verb obj vp = + sats2clause ( + insertExtrapos + (mkSatsObject subj verb obj) + (\\_ => prepCase verb.c ++ vp.s ! VIInfinit ! pgen2gen obj.g ! obj.n ! obj.p) + ) ; + SPredSubjV2V subj verb obj vp = + sats2clause ( + insertExtrapos + (mkSatsObject subj verb obj) + (\\_ => prepCase verb.c ++ vp.s ! VIInfinit ! pgen2gen subj.g ! subj.n ! subj.p) + ) ; -- SPredProgVP --- SPredSubjV2V - --- SPredV2A - SPredAP subj adj = sats2clause (mkSatsCopula subj (adj.s ! AF (pgen2gen subj.g) subj.n)) ; @@ -112,6 +124,12 @@ incomplete concrete ClauseRomance of Clause = CategoriesRomance ** sats2quest ( insertExtrapos (mkSats (intNounPhrase subj) verb) (\\_ => adj.s ! AF subj.g subj.n)) ; + QPredV2A subj verb obj adj = + sats2quest ( + insertExtrapos + (mkSatsObject (intNounPhrase subj) verb obj) + (\\_ => adj.s ! AF (pgen2gen obj.g) obj.n)) ; + QPredVV subj verb vp = sats2quest ( insertExtrapos @@ -119,15 +137,21 @@ incomplete concrete ClauseRomance of Clause = CategoriesRomance ** (\\_ => prepCase verb.c ++ vp.s ! VIInfinit ! subj.g ! (intNounPhrase subj).n ! P3) ) ; --- QPredObjV2V + QPredObjV2V subj verb obj vp = + sats2quest ( + insertExtrapos + (mkSatsObject (intNounPhrase subj) verb obj) + (\\_ => prepCase verb.c ++ vp.s ! VIInfinit ! pgen2gen obj.g ! obj.n ! obj.p) + ) ; + QPredSubjV2V subj verb obj vp = + sats2quest ( + insertExtrapos + (mkSatsObject (intNounPhrase subj) verb obj) + (\\_ => prepCase verb.c ++ vp.s ! VIInfinit ! subj.g ! subj.n ! P3) + ) ; -- QPredProgVP --- QPred(IntNounPhrase Subj)V2V - --- QPredV2A - - QPredAP subj adj = sats2quest (mkSatsCopula (intNounPhrase subj) (adj.s ! AF subj.g subj.n)) ; QPredCN subj cn = diff --git a/lib/resource/romance/SyntaxRomance.gf b/lib/resource/romance/SyntaxRomance.gf index 2b87e8cf7..2132b1322 100644 --- a/lib/resource/romance/SyntaxRomance.gf +++ b/lib/resource/romance/SyntaxRomance.gf @@ -294,12 +294,10 @@ oper ---- Need proper mode in the negative case. predAdjSent : (Adjective ** {mp,mn : Mode}) -> Sentence -> Clause = - \probable,ildort -> - predCopula pronImpers - (complCopula - (\\_,_,_ => probable.s ! AF Masc Sg ++ elisQue ++ ildort.s ! probable.mp)) ; - ----- This rule in abstract syntax misses clitics. + \adj,ildort -> + sats2clause ( + insertExtrapos (mkSatsCopula pronImpers (adj.s ! AF Masc Sg)) + (\\b => embedConj ++ ildort.s ! if_then_else Mode b adj.mp adj.mn)) ; predAdjSent2 : (AdjCompl ** {mp,mn : Mode}) -> NounPhrase -> ( Adjective ** {mp,mn : Mode}) = \facile,jean -> @@ -436,7 +434,6 @@ param oper VerbPhrase = {s : VIForm => Gender => Number => Person => Str} ; - VerbGroup = {s : Bool => Gender => VPForm => Str} ; vpf2vf : VPForm -> VF = \vpf -> case vpf of { VPF _ vf => vf @@ -459,29 +456,6 @@ oper -- Predication is language-dependent in the negative case. - complVerb : Verb -> Complemnt = \verb -> - mkCompl verb (\\_,_,_ => []) ; - - mkCompl : Verb -> (Gender => Number => Person => Str) -> Complemnt = - \verb,comp -> complNoClit ( - \\g,n,p => VPart g n ; - AHabere => VPart Masc Sg - }), - comp ! g ! n ! p - >) ; - - complNoClit : (Gender => Number => Person => (Str*Str)) -> Complemnt = - \comp -> \\g,n,p => - let com = comp ! g ! n ! p in - {clit = [] ; part = com.p1 ; compl = com.p2} ; - - complCopula : (Gender => Number => Person => Str) -> Complemnt = - mkCompl copula ; - - predCopula : NounPhrase -> Complemnt -> Clause = \np,co -> - predVerbClause np copula co ; - negVerb : Str -> Str ; -- Verb phrases can also be formed from adjectives ("est bon"), @@ -493,18 +467,6 @@ oper -- The third rule is overgenerating: "est chaque homme" has to be ruled out -- on semantic grounds. - complAdjective : AdjPhrase -> Complemnt = \bon -> - complCopula (\\g,n,_ => bon.s ! AF g n) ; - - complCommNoun : CommNounPhrase -> Complemnt = \homme -> - complCopula (\\_,n,_ => indefNoun n homme) ; - - complNounPhrase : NounPhrase -> Complemnt = \jean -> - complCopula (\\_,_,_ => jean.s ! stressed nominative) ; - - complAdverb : Adverb -> Complemnt = \dehors -> - complCopula (\\_,_,_ => dehors.s) ; - complVerbAdj : AdjCompl -> VerbPhrase -> AdjPhrase = \facile,ouvrir -> {s = \\gn => ---- p facile.s ! gn ++ prepCase facile.c ++ facile.s2 ++ @@ -522,20 +484,16 @@ oper p = False } ; - progressiveVerbPhrase : VerbPhrase -> VerbGroup ; - --- Passivization is like adjectival predication. - - passVerb : Verb -> Complemnt = \aimer -> - complCopula (\\g,n,_ => aimer.s ! VPart g n) ; - -- complement a verb with noun phrase and optional preposition TransVerb : Type = Verb ** Complement ; + complementOfTransVerb : TransVerb -> Complement = \v -> {s2 = v.s2 ; c = v.c} ; + + + verbOfTransVerb : TransVerb -> Verb = \v -> {s = v.s ; aux = v.aux} ; - complementOfTransVerb : TransVerb -> Complement = \v -> {s2 = v.s2 ; c = v.c} ; isNounPhraseClit : NounPhrase -> Bool = \n -> case n.c of { Clit0 => False ; @@ -565,43 +523,6 @@ oper -- "aime Jean" ; "n'aime pas Jean" ; "l'aime" ; "ne l'aime pas". -- More will be needed when we add ditransitive verbs. - complTransVerb : TransVerb -> NounPhrase -> Complemnt = \aime,jean -> - complTransVerbGen aime jean (\\_,_,_ => []) ; - - complTransVerbGen : TransVerb -> NounPhrase -> - (Gender => Number => Person => Str) -> Complemnt = - \aime,jean,ici -> - let - clit = andB (isNounPhraseClit jean) (isTransVerbClit aime) ; - Jean = jean.s ! (case2pformClit aime.c) ; - aimee = if_then_Str clit - (aime.s ! VPart (pgen2gen jean.g) jean.n) - (aime.s ! VPart Masc Sg) - in - \\g,n,p => - let Ici = ici ! g ! n ! p - in - case clit of { - True => {clit = Jean ; part = aimee ; compl = Ici} ; - False => {clit = [] ; part = aimee ; compl = Jean ++ Ici} - } ; - ------ add auxVerb to Complemnt to switch to $esse$ in refl ? - - reflTransVerb : TransVerb -> Complemnt = \aime -> - let - clit = isTransVerbClit aime ; - in - \\g,n,p => - let - soi = reflPron ! n ! p ! unstressed accusative ; ---- (case2pformClit aime.c) ; - aimee = aime.s ! VPart g n - in - case clit of { - True => {clit = soi ; part = aimee ; compl = []} ; - False => {clit = [] ; part = aimee ; compl = soi} - } ; - reflPron : Number => Person => NPFormA => Str ; reflPronNounPhrase : Gender -> Number -> Person -> NounPhrase = \g,n,p -> @@ -655,60 +576,14 @@ oper --- This must be completed to account for the order of the clitics. --- In the rule below, the last argument cannot get cliticized. - complDitransVerb : - DitransVerb -> NounPhrase -> NounPhrase -> Complemnt = \donner,jean,vin -> - complTransVerbGen - donner jean - (\\_,_,_ => donner.s3 ++ vin.s ! case2pform donner.c3) ; - -{- - {s = \\b,g,w => - let - adonne = formVerb2 donner g w ; - a = adonne.verb ; - isClit = isDitransVerbClit donner ; - cJean = andB (isNounPhraseClit jean) (isClit.p1) ; - cVin = andB (isNounPhraseClit vin) (isClit.p2) ; - donne = if_then_Str cVin - (adonne.part ! pgen2gen vin.g ! vin.n) - (adonne.part ! Masc ! Sg) ; - Jean = jean.s ! (case2pformClit donner.c) ; - Vin = vin.s ! (case2pformClit donner.c3) ; - aJean = if_then_Str cJean [] Jean ; - duVin = if_then_Str cVin [] Vin ; - lui = if_then_Str cJean Jean [] ; - te = if_then_Str cVin Vin [] - in - posNeg b (te ++ lui ++ a) (donne ++ aJean ++ duVin) - } ; --} - -- The following macro builds the "ne - pas" or "non" negation. The second -- string argument is used for the complement of a verb phrase. In Italian, -- one string argument would actually be enough. posNeg : Bool -> (verb, compl : Str) -> Str ; - complDitransAdjVerb : - TransVerb -> NounPhrase -> AdjPhrase -> Complemnt = \rend,toi,sec -> - complTransVerbGen rend toi (\\g,n,_ => sec.s ! AF g n) ; - DitransVerbVerb = TransVerb ** {c3 : CaseA} ; - complDitransVerbVerb : - Bool -> DitransVerbVerb -> NounPhrase -> VerbPhrase -> Complemnt = - \obj, demander, toi, nager -> - complTransVerbGen demander toi - (\\g,n,p => - let - agr : Gender * Number * Person = case obj of { - True => ; - False => - } - in - prepCase demander.c ++ - nager.s ! VIInfinit ! agr.p1 ! agr.p2 ! agr.p3) ; - --2 Adverbs -- @@ -720,9 +595,6 @@ oper Adverb : Type = SS ; - adVerbPhrase : VerbGroup -> Adverb -> VerbGroup = \chante, bien -> - {s = \\b,g,v => chante.s ! b ! g ! v ++ bien.s} ; - advVerbPhrase : VerbPhrase -> Adverb -> VerbPhrase = \chante, bien -> {s = \\v,g,n,p => chante.s ! v ! g ! n ! p ++ bien.s} ; @@ -788,88 +660,6 @@ oper Clause = {s : Bool => ClForm => Str} ; - ---- VIForm = VIInfinit | VIImperat Bool Number ; - predVerbGroup : Bool -> {s : Str ; a : Anteriority} -> VerbGroup -> VerbPhrase = - \b,ant,vg -> - {s = \\vi,g,n,p => ant.s ++ vg.s ! b ! g ! VPF ant.a VInfin ---- imper - } ; - - cl2vp : ClForm -> Number -> Person -> VPForm = \c,n,p -> case c of { - ClPres a m => VPF a (VFin (VPres m) n p) ; - ClImperf a m => VPF a (VFin (VImperf m) n p) ; - ClPasse a => VPF a (VFin VPasse n p) ; - ClFut a => VPF a (VFin VFut n p) ; - ClCondit a => VPF a (VFin VCondit n p) ; - ClInfinit a => VPF a VInfin - } ; - - vp2cl : VPForm -> ClForm = \vf -> case vf of { - VPF a (VFin (VPres m) _ _) => ClPres a m ; - VPF a (VFin (VImperf m) _ _) => ClImperf a m ; - VPF a (VFin (VPasse) _ _) => ClPasse a ; - VPF a (VFin (VFut) _ _) => ClFut a ; - VPF a (VFin (VCondit) _ _) => ClCondit a ; - VPF a VInfin => ClInfinit a ; - _ => ClInfinit Simul ---- imper - } ; - - - Complemnt = Gender => Number => Person => {clit, part, compl : Str} ; ---- ment - - predVerbClause : NounPhrase -> Verb -> Complemnt -> Clause = \np,verb,comp -> - let nv = predVerbClauseGen np verb comp in - {s = \\b,cl => let nvg = nv ! b ! cl in nvg.p1 ++ nvg.p2} ; - - predVerbClauseGen : NounPhrase -> Verb -> Complemnt -> - (Bool => ClForm => (Str * Str)) = \np,verb,comp -> - let - jean = np.s ! unstressed nominative ; - co = comp ! pgen2gen np.g ! np.n ! np.p ; - la = co.clit ; - ici = co.compl ; - aimee = co.part ; - aime : TMode -> Str = \t -> verb.s ! (VFin t np.n np.p) ; - avoir : TMode -> Str = \t -> (auxVerb verb).s ! (VFin t np.n np.p) ; - aimer = verb.s ! VInfin ; - avoirr = (auxVerb verb).s ! VInfin - in - \\b => table { - ClPres Simul m => ; - ClPres a m => ; - ClImperf Simul m => ; - ClImperf a m => ; - ClPasse Simul => ; - ClPasse a => ; - ClFut Simul => ; - ClFut a => ; - ClCondit Simul => ; - ClCondit a => ; - ClInfinit Simul => ; - ClInfinit a => - } ; - --- These three function are just to restore the $VerbGroup$ ($VP$) based structure. - - predVerbGroupClause : NounPhrase -> VerbGroup -> Clause = \np,vp -> - let - it = np.s ! unstressed nominative - in - {s = \\b,cf => it ++ vp.s ! b ! pgen2gen np.g ! cl2vp cf np.n np.p} ; - - predClauseGroup : Verb -> Complemnt -> VerbGroup = \verb,comp -> - let - nvg : PronGen -> Number -> Person -> (Bool => ClForm => (Str * Str)) = - \g,n,p -> - predVerbClauseGen {s = \\_ => [] ; g=g ; n=n ; p=p ; c=Clit0} verb comp - -- clit type irrelevant in subject position - in - {s = \\b,g,vf => - (nvg (PGen g) (nombreVerbPhrase vf) (personVerbPhrase vf) ! b ! (vp2cl vf)).p2 - } ; - - predClauseBeGroup : Complemnt -> VerbGroup = - predClauseGroup copula ; - --3 Sentence-complement verbs -- @@ -882,37 +672,6 @@ oper subordMode : SentenceVerb -> Bool -> Mode = \verb,b -> if_then_else Mode b verb.mp verb.mn ; - - complSentVerb : SentenceVerb -> Sentence -> Complemnt = \croire,jeanboit -> - mkCompl - croire - (\\g,n,p => - ----- add Bool to Complemnt ? - ----- let m = if_then_else Mode b croire.mp croire.mn - embedConj ++ jeanboit.s ! croire.mp) ; - - complDitransSentVerb : - (TransVerb ** {mp, mn : Mode}) -> NounPhrase -> Sentence -> Complemnt = - \dire,lui,jeanboit -> - complTransVerbGen - dire lui - (\\g,n,p => - embedConj ++ jeanboit.s ! dire.mp) ; - - complQuestVerb : Verb -> QuestionSent -> Complemnt = \demander,sijeanboit -> - mkCompl - demander - (\\g,n,p => sijeanboit.s ! IndirQ) ; - - complDitransQuestVerb : TransVerb -> NounPhrase -> QuestionSent -> Complemnt = - \dire,lui,jeanboit -> - complTransVerbGen - dire lui - (\\g,n,p => jeanboit.s ! IndirQ) ; - - complAdjVerb : Verb -> AdjPhrase -> Complemnt = \sent,bon -> - mkCompl sent (\\g,n,_ => bon.s ! AF g n) ; - verbSent : Verb -> Mode -> Mode -> SentenceVerb = \v,mp,mn -> v ** {mp = mp ; mn = mn} ; @@ -928,14 +687,8 @@ oper VerbVerb : Type = Verb ** {c : CaseA} ; - complVerbVerb : VerbVerb -> VerbPhrase -> Complemnt = \devoir, nager -> - mkCompl - devoir - (\\g,n,p => prepCase devoir.c ++ nager.s ! VIInfinit ! g ! n ! p) ; - mkVerbVerbDir : Verb -> VerbVerb = \v -> v ** {c = accusative} ; - --2 Sentences missing noun phrases -- -- This is one instance of Gazdar's *slash categories*, corresponding to his @@ -1007,11 +760,6 @@ oper -- Relative clauses can be formed from both verb phrases ("qui dort") and -- slash expressions ("que je vois", "dont je parle"). - relVerbPhrase : RelPron -> VerbGroup -> RelClause = \qui,dort -> - {s = \\b,cl,g,n,p => - allRelForms qui g n nominative ++ dort.s ! b ! g ! cl2vp cl n p - } ; - relSlash : RelPron -> ClauseSlashNounPhrase -> RelClause = \dont,jeparle -> {s = \\b,cl,g,n,p => jeparle.s2 ++ allRelForms dont g n jeparle.c ++ jeparle.s ! b ! cl @@ -1126,9 +874,6 @@ oper -- -- N.B. inversion variants and "est-ce que" are treated as above. - intVerbPhrase : IntPron -> VerbGroup -> Question = \ip,vg -> - questClause (predVerbGroupClause (intNounPhrase ip) vg) ; - intSlash : IntPron -> ClauseSlashNounPhrase -> Question ; intNounPhrase : IntPron -> NounPhrase = \ip -> @@ -1386,10 +1131,6 @@ oper B ++ si.s ++ As } ; - subjunctVerbPhrase : VerbGroup -> Subjunction -> Sentence -> VerbGroup = - \V, si, A -> - adVerbPhrase V (ss (si.s ++ A.s ! si.m)) ; - --2 One-word utterances -- -- An utterance can consist of one phrase of almost any category, @@ -1571,7 +1312,7 @@ negNe, negPas : Str ; in {s = \\b,f,_ => cl.s ! b ! f} ; -predVerb0 : Verb -> Clause ; - +predVerb0 : Verb -> Clause = \rain -> + sats2clause (mkSats (pronNounPhrase pronImpers) rain) ; } diff --git a/lib/resource/romance/SyntaxRomanceVP.gf b/lib/resource/romance/SyntaxRomanceVP.gf new file mode 100644 index 000000000..2b87e8cf7 --- /dev/null +++ b/lib/resource/romance/SyntaxRomanceVP.gf @@ -0,0 +1,1577 @@ +--1 A Small Romance Resource Syntax +-- +-- Aarne Ranta 2002 +-- +-- This resource grammar contains definitions needed to construct +-- indicative, interrogative, and imperative sentences in Romance languages. +-- We try to share as much as possible. Even if the definitions of certain +-- operations are different in $syntax.Fra.gf$ and $syntax.Ita.gf$, we can +-- often give their type signatures in this file. +-- +-- The following files are presupposed: + +interface SyntaxRomance = TypesRomance ** open Prelude, (CO=Coordination) in { + +--2 Common Nouns +-- +-- Common nouns are defined as number-dependent strings with a gender. +-- Complex common noun ($CommNounPhrase$) have the same type as simple ones. +-- (The distinction is made just because of uniformity with other languages.) + +oper + CommNoun : Type = {s : Number => Str ; g : Gender} ; + CommNounPhrase = CommNoun ; + noun2CommNounPhrase : CommNounPhrase -> CommNoun = \x -> x ; + + commonNounComp : CommNoun -> Str -> CommNoun = \numero, detelephone -> + {s = \\n => numero.s ! n ++ detelephone ; + g = numero.g + } ; + + +--2 Noun phrase +-- +-- The worst case is pronouns, which have inflection in the possessive +-- forms. Other noun phrases express all possessive forms with the genitive case. +-- Proper names are the simples example. + + ProperName : Type = {s : Str ; g : Gender} ; + + NounPhrase : Type = Pronoun ; -- the worst case + + nameNounPhrase : ProperName -> NounPhrase ; + + mkProperName : Str -> Gender -> ProperName = \jean,m -> + {s = jean ; g = m} ; + + mkNameNounPhrase : Str -> Gender -> NounPhrase = \jean,m -> + nameNounPhrase (mkProperName jean m) ; + + nounPhraseOn : NounPhrase ; + + normalNounPhrase : (CaseA => Str) -> Gender -> Number -> NounPhrase = \cs,g,n -> + {s = \\p => cs ! (pform2case p) ; + g = PGen g ; + n = n ; + p = P3 ; -- third person + c = Clit0 -- not clitic + } ; + + pronNounPhrase : Pronoun -> NounPhrase = \pro -> pro ; + +-- Many determiners can be modified with numerals, which may be inflected in +-- gender. The label $isNo$ is a hack used to force $des$ for plural +-- indefinite with $noNum$. + + Numeral : Type = {s : Gender => Str ; n : Number ; isNo : Bool} ; + + pronWithNum : Pronoun -> Numeral -> Pronoun = \nous,deux -> + {s = \\c => nous.s ! c ++ deux.s ! pgen2gen nous.g ; + g = nous.g ; + n = nous.n ; + p = nous.p ; + c = nous.c + } ; + + noNum : Numeral = {s = \\_ => [] ; n = Pl ; isNo = True} ; + +-- The existence construction "il y a", "c'è / ci sono" is defined separately, +-- and ad hoc, in each language. + + existNounPhrase : NounPhrase -> Clause ; + + +--2 Determiners +-- +-- Determiners are inflected according to the gender of the nouns they determine. +-- The determiner determines the number of the argument noun. + + Determiner : Type = {s : Gender => Str ; n : Number} ; + DeterminerNum : Type = {s : Gender => Str} ; + + detNounPhrase : Determiner -> CommNoun -> NounPhrase = \tout, homme -> + normalNounPhrase + (\\c => prepCase c ++ tout.s ! homme.g ++ homme.s ! tout.n) + homme.g + tout.n ; + + + numDetNounPhrase : DeterminerNum -> Numeral -> CommNounPhrase -> NounPhrase = + \tous, six, homme -> + normalNounPhrase + (\\c => prepCase c ++ tous.s ! homme.g ++ six.s ! homme.g ++ homme.s ! six.n) + homme.g + six.n ; + +--- Here one would like to provide a feminine variant as well. + + justNumDetNounPhrase : DeterminerNum -> Numeral -> NounPhrase = + \tous, six -> + normalNounPhrase + (\\c => prepCase c ++ tous.s ! Masc ++ six.s ! Masc) + Masc + six.n ; + +-- The following macros are sufficient to define most determiners, +-- as shown by the examples that follow. + + mkDeterminer : Number -> Str -> Str -> Determiner = \n,tous,toutes -> + {s = genForms tous toutes ; n = n} ; + + mkDeterminer1 : Number -> Str -> Determiner = \n,chaque -> + mkDeterminer n chaque chaque ; + + mkDeterminerNum : Str -> Str -> DeterminerNum = + \tous,toutes -> + {s = \\g => genForms tous toutes ! g} ; + + +-- Indefinite and definite noun phrases are treated separately, +-- since noun phrases formed by them also depend on case. +-- The indefinite case with a numeral has no separate article: +-- "il y a 86 voitures", not "il y a des 86 voitures". + + indefNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n,mec -> + normalNounPhrase + (\\c => artIndef mec.g n c ++ mec.s ! n) + mec.g + n ; + + indefNounPhraseNum : Numeral -> CommNounPhrase -> NounPhrase = \nu,mec -> + normalNounPhrase + (\\c => case nu.isNo of { + True => artIndef mec.g Pl c ++ mec.s ! Pl ; + _ => prepCase c ++ nu.s ! mec.g ++ mec.s ! nu.n + } + ) + mec.g + nu.n ; + + defNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n,mec -> + normalNounPhrase + (\\c => artDef mec.g n c ++ mec.s ! n) + mec.g + n ; + + defNounPhraseNum : Numeral -> CommNounPhrase -> NounPhrase = \nu,mec -> + normalNounPhrase + (\\c => artDef mec.g nu.n c ++ nu.s !mec.g ++ mec.s ! nu.n) + mec.g + nu.n ; + +-- We often need indefinite noun phrases synacategorematically. + + indefNoun : Number -> CommNounPhrase -> Str = \n,mec -> + (indefNounPhrase n mec).s ! case2pform nominative ; + +-- Genitives of noun phrases can be used like determiners, to build noun phrases. +-- The number argument makes the difference between "ma maison" - "mes maisons". +-- The clitic type of the NP decides between "ma maison" and "la maison de Jean". + + npGenDet : Number -> NounPhrase -> CommNounPhrase -> NounPhrase = + \n,jeanne,mec -> + let {str : CaseA => Str = case jeanne.c of { + Clit0 => npGenDe n jeanne mec ; + _ => npGenPoss n jeanne mec + } + } in + normalNounPhrase str mec.g n ; + + npGenDetNum : Numeral -> NounPhrase -> CommNounPhrase -> NounPhrase = + \nu,jeanne,mec -> + let {str : CaseA => Str = case jeanne.c of { + Clit0 => npGenDeNum nu jeanne mec ; + _ => npGenPossNum nu jeanne mec + } + } in + normalNounPhrase str mec.g nu.n ; + +-- These auxiliary rules define the genitive with "de" and with the possessive. +-- Here there is a difference between French and Italian: Italian has a definite +-- article before possessives (with certain exceptions). + + npGenDe : Number -> NounPhrase -> CommNounPhrase -> CaseA => Str = + \n,jeanne,mec -> + \\c => artDef mec.g n c ++ mec.s ! n ++ jeanne.s ! case2pform genitive ; + + npGenDeNum : Numeral -> NounPhrase -> CommNounPhrase -> CaseA => Str = + \nu,jeanne,mec -> + \\c => artDef mec.g nu.n c ++ nu.s ! mec.g ++ mec.s ! nu.n ++ + jeanne.s ! case2pform genitive ; + + npGenPoss : Number -> NounPhrase -> CommNounPhrase -> CaseA => Str ; + + npGenPossNum : Numeral -> NounPhrase -> CommNounPhrase -> CaseA => Str ; + +-- Constructions like "l'idée que la terre est ronde" are formed at the +-- first place as common nouns, so that one can also have "la suggestion que...". + + nounThatSentence : CommNounPhrase -> Sentence -> CommNounPhrase = \idee,x -> + {s = \\n => idee.s ! n ++ elisQue ++ x.s ! Ind ; + g = idee.g + } ; + + +-- The partitive noun phrase has special nominative and accusative, which look like +-- genitives ("du vin, avec du vin", as well as genitive form, where the definite +-- article contracts away ("de vin"). + + partitiveNounPhrase : Number -> CommNounPhrase -> NounPhrase ; + + +--2 Adjectives +-- +-- Adjectives have a parameter $p$ telling if postposition is +-- allowed (complex APs). There is no real need in Romance languages to distinguish +-- between simple adjectives and adjectival phrases. + + Adjective : Type = Adj ** {p : Bool} ; + + adjPre = True ; adjPost = False ; + + AdjPhrase : Type = Adjective ; + + adj2adjPhrase : Adjective -> AdjPhrase = \x -> x ; + + mkAdjective : Adj -> Bool -> Adjective = \adj,p -> adj ** {p = p} ; + + +--3 Comparison adjectives +-- +-- The type is defined in $TypesRomance$. Syntax adds to lexicon the position +-- information. + + AdjDegr = AdjComp ** {p : Bool} ; + + mkAdjDegr : AdjComp -> Bool -> AdjDegr = \adj,p -> + adj ** {p = p} ; + + mkAdjDegrLong : Adj -> Bool -> AdjDegr = \adj,p -> + adjCompLong adj ** {p = p} ; + + +-- Each of the comparison forms has a characteristic use: +-- +-- Positive forms are used alone, as adjectival phrases ("bon"). + + positAdjPhrase : AdjDegr -> AdjPhrase = \bon -> + {s = bon.s ! Pos ; + p = bon.p + } ; + +-- Comparative forms are used with an object of comparison, as +-- adjectival phrases ("meilleur que toi"). The comparing conjunction +-- is of course language-dependent; Italian moreover has the free +-- variants "che" and "di". + + comparAdjPhrase : AdjDegr -> NounPhrase -> AdjPhrase = \bon, toi -> + {s = \\a => bon.s ! Comp ! a ++ comparConj ++ + toi.s ! stressed accusative ; + p = False + } ; + + comparConj : Str ; + +-- Superlative forms are used with a common noun, picking out the +-- maximal representative of a domain +-- ("le meilleur mec", "le mec le plus intelligent"). + + superlNounPhrase : AdjDegr -> CommNoun -> NounPhrase = \bon, mec -> + normalNounPhrase + (\\c => artDef mec.g Sg c ++ if_then_else Str bon.p + (bon.s ! Comp ! AF mec.g Sg ++ mec.s ! Sg) + (mec.s ! Sg ++ artDef mec.g Sg nominative ++ bon.s ! Comp ! AF mec.g Sg) + ) + mec.g + Sg ; + + superlAdjPhrase : AdjDegr -> AdjPhrase = \bon -> + {s = \\a => artDef (genAForm a) (numAForm a) nominative ++ bon.s ! Comp ! a ; + p = bon.p + } ; + +-- Sentence-complement adjectives. +---- Need proper mode in the negative case. + + predAdjSent : (Adjective ** {mp,mn : Mode}) -> Sentence -> Clause = + \probable,ildort -> + predCopula pronImpers + (complCopula + (\\_,_,_ => probable.s ! AF Masc Sg ++ elisQue ++ ildort.s ! probable.mp)) ; + +---- This rule in abstract syntax misses clitics. + + predAdjSent2 : (AdjCompl ** {mp,mn : Mode}) -> NounPhrase -> + ( Adjective ** {mp,mn : Mode}) = \facile,jean -> + complAdj facile jean ** {mp = facile.mp ; mn = facile.mn} ; + + pronImpers : NounPhrase ; + +-- $pronImpers = pronNounPhrase pronIl$ in French, empty in Italian +-- and Spanish. + +--3 Prepositions and complements +-- +-- Most prepositions are just strings. But "à" and "de" are treated as cases in +-- French. In Italian, there are more prepositions treated in this way: +-- "a", "di", "da", "in", "su", "con". +-- An invariant is that, if the preposition is not empty ($[]$), then the case +-- is $Acc$. + + Preposition = Str ; + + Complement = {s2 : Preposition ; c : CaseA} ; + + complement : Str -> Complement = \par -> + {s2 = par ; c = nominative} ; + + complementDir : Complement = complement [] ; + + complementCas : CaseA -> Complement = \c -> + {s2 = [] ; c = c} ; + + +--3 Two-place adjectives +-- +-- A two-place adjective is an adjective with a preposition used before +-- the complement, and the complement case. + + AdjCompl = AdjPhrase ** Complement ; + + mkAdjCompl : Adj -> Bool -> Complement -> AdjCompl = \adj,p,c -> + mkAdjective adj p ** c ; + + complAdj : AdjCompl -> NounPhrase -> AdjPhrase = \relie,jean -> + {s = \\a => relie.s ! a ++ relie.s2 ++ jean.s ! case2pform relie.c ; + p = False + } ; + + +--3 Modification of common nouns +-- +-- The two main functions of adjective are in predication ("Jean est jeune") +-- and in modification ("un jeune homme"). Predication will be defined +-- later, in the chapter on verbs. +-- +-- Modification must pay attention to pre- and post-noun +-- adjectives: "jeune homme"; "homme intelligent". + + modCommNounPhrase : AdjPhrase -> CommNounPhrase -> CommNounPhrase = \bon,mec -> + {s = \\n => if_then_else Str bon.p + (bon.s ! AF mec.g n ++ mec.s ! n) + (mec.s ! n ++ bon.s ! AF mec.g n) ; + g = mec.g + } ; + +--2 Function expressions + +-- A function expression is a common noun together with the +-- preposition prefixed to its argument ("mère de x"). +-- The type is analogous to two-place adjectives and transitive verbs. + + Function : Type = CommNounPhrase ** Complement ; + +-- The application of a function gives, in the first place, a common noun: +-- "mor/mödrar till Johan". From this, other rules of the resource grammar +-- give noun phrases, such as "la mère de Jean", "les mères de Jean", +-- "les mères de Jean et de Marie", and "la mère de Jean et de Marie" (the +-- latter two corresponding to distributive and collective functions, +-- respectively). Semantics will eventually tell when each +-- of the readings is meaningful. + + appFunComm : Function -> NounPhrase -> CommNounPhrase = \mere,jean -> + {s = \\n => mere.s ! n ++ mere.s2 ++ jean.s ! case2pform mere.c ; + g = mere.g + } ; + +-- Two-place functions add one argument place. + + Function2 = Function ** {s3 : Preposition ; c3 : CaseA} ; + +-- There application starts by filling the first place. + + appFun2 : Function2 -> NounPhrase -> Function = \vol, paris -> + {s = \\n => vol.s ! n ++ vol.s2 ++ paris.s ! case2pform vol.c ; + g = vol.g ; + s2 = vol.s3 ; + c = vol.c3 + } ; + + +-- It is possible to use a function word as a common noun; the semantics is +-- often existential or indexical. + + funAsCommNounPhrase : Function -> CommNounPhrase = \x -> x ; + +-- The following is an aggregate corresponding to the original function application +-- producing "ma mère" and "la mère de Jean". It does not appear in the +-- resource grammar API any longer. + + appFun : Bool -> Function -> NounPhrase -> NounPhrase = \coll, mere, jean -> + let + n = jean.n ; + g = mere.g ; nf = if_then_else Number coll Sg n + in variants { + defNounPhrase nf (appFunComm mere jean) ; + npGenDet nf jean mere + } ; + + +--2 Verbs +-- +--3 Verb phrases +-- +-- Unlike many other languages, verb phrases in Romance languages +-- are not discontinuous. +-- We use clitic parameters instead. +-- +-- (It is not quite sure, though, whether this +-- will suffice in French for examples like "je n'*y* vais pas": one may want to +-- add "y" to "ne vais pas" instead of "ne - pas" to "y vais".) + +param + VPForm = VPF Anteriority VF ; + Anteriority = Simul | Anter ; + VIForm = VIInfinit | VIImperat Bool Number ; + +oper + VerbPhrase = {s : VIForm => Gender => Number => Person => Str} ; + VerbGroup = {s : Bool => Gender => VPForm => Str} ; + + vpf2vf : VPForm -> VF = \vpf -> case vpf of { + VPF _ vf => vf + } ; + + auxVerb : Verb -> Verb ; -- gives the auxiliary + + nombreVerbPhrase : VPForm -> Number = \v -> case v of { + VPF _ f => nombreVerb f + } ; + + personVerbPhrase : VPForm -> Person = \v -> case v of { + VPF _ f => personVerb f + } ; + + isNotImperative : VPForm -> Bool = \v -> case v of { + VPF _ (VImper _) => False ; + _ => True + } ; + +-- Predication is language-dependent in the negative case. + + complVerb : Verb -> Complemnt = \verb -> + mkCompl verb (\\_,_,_ => []) ; + + mkCompl : Verb -> (Gender => Number => Person => Str) -> Complemnt = + \verb,comp -> complNoClit ( + \\g,n,p => VPart g n ; + AHabere => VPart Masc Sg + }), + comp ! g ! n ! p + >) ; + + complNoClit : (Gender => Number => Person => (Str*Str)) -> Complemnt = + \comp -> \\g,n,p => + let com = comp ! g ! n ! p in + {clit = [] ; part = com.p1 ; compl = com.p2} ; + + complCopula : (Gender => Number => Person => Str) -> Complemnt = + mkCompl copula ; + + predCopula : NounPhrase -> Complemnt -> Clause = \np,co -> + predVerbClause np copula co ; + + negVerb : Str -> Str ; + +-- Verb phrases can also be formed from adjectives ("est bon"), +-- common nouns ("est un homme"), and noun phrases ("est Jean"). +-- We need a copula, which is of course language-dependent. + + copula : Verb ; + +-- The third rule is overgenerating: "est chaque homme" has to be ruled out +-- on semantic grounds. + + complAdjective : AdjPhrase -> Complemnt = \bon -> + complCopula (\\g,n,_ => bon.s ! AF g n) ; + + complCommNoun : CommNounPhrase -> Complemnt = \homme -> + complCopula (\\_,n,_ => indefNoun n homme) ; + + complNounPhrase : NounPhrase -> Complemnt = \jean -> + complCopula (\\_,_,_ => jean.s ! stressed nominative) ; + + complAdverb : Adverb -> Complemnt = \dehors -> + complCopula (\\_,_,_ => dehors.s) ; + + complVerbAdj : AdjCompl -> VerbPhrase -> AdjPhrase = \facile,ouvrir -> + {s = \\gn => ---- p + facile.s ! gn ++ prepCase facile.c ++ facile.s2 ++ + ouvrir.s ! VIInfinit ! Masc ! Sg ! P3 ; + p = False + } ; + + complVerbAdj2 : Bool -> AdjCompl -> NounPhrase -> VerbPhrase -> AdjPhrase = + \b,facile,lui,nager -> + {s = \\gn => ---- p + facile.s ! gn ++ + lui.s ! stressed dative ++ ---- also "pour lui" ? + prepCase facile.c ++ facile.s2 ++ + nager.s ! VIInfinit ! pgen2gen lui.g ! lui.n ! P3 ; ---- agr dep on b + p = False + } ; + + progressiveVerbPhrase : VerbPhrase -> VerbGroup ; + +-- Passivization is like adjectival predication. + + passVerb : Verb -> Complemnt = \aimer -> + complCopula (\\g,n,_ => aimer.s ! VPart g n) ; + +-- complement a verb with noun phrase and optional preposition + + TransVerb : Type = Verb ** Complement ; + + verbOfTransVerb : TransVerb -> Verb = \v -> + {s = v.s ; aux = v.aux} ; + complementOfTransVerb : TransVerb -> Complement = \v -> {s2 = v.s2 ; c = v.c} ; + + isNounPhraseClit : NounPhrase -> Bool = \n -> case n.c of { + Clit0 => False ; + _ => True + } ; + +-- This function is language-dependent, because it uses the language-dependent +-- type of case. + + isClitCase : CaseA -> Bool ; + + isTransVerbClit : TransVerb -> Bool = \v -> isClitCase v.c ; + + isDitransVerbClit : DitransVerb -> Bool * Bool = \v -> + ; + +--3 Transitive verbs +-- +-- Transitive verbs are verbs with a preposition for the complement, +-- in analogy with two-place adjectives and functions. +-- One might prefer to use the term "2-place verb", since +-- "transitive" traditionally means that the inherent preposition is empty. +-- Such a verb is one with a *direct object* - which may still be accusative, +-- dative, or genitive. +-- +-- In complementation, we do need some dispatching of clitic types: +-- "aime Jean" ; "n'aime pas Jean" ; "l'aime" ; "ne l'aime pas". +-- More will be needed when we add ditransitive verbs. + + complTransVerb : TransVerb -> NounPhrase -> Complemnt = \aime,jean -> + complTransVerbGen aime jean (\\_,_,_ => []) ; + + complTransVerbGen : TransVerb -> NounPhrase -> + (Gender => Number => Person => Str) -> Complemnt = + \aime,jean,ici -> + let + clit = andB (isNounPhraseClit jean) (isTransVerbClit aime) ; + Jean = jean.s ! (case2pformClit aime.c) ; + aimee = if_then_Str clit + (aime.s ! VPart (pgen2gen jean.g) jean.n) + (aime.s ! VPart Masc Sg) + in + \\g,n,p => + let Ici = ici ! g ! n ! p + in + case clit of { + True => {clit = Jean ; part = aimee ; compl = Ici} ; + False => {clit = [] ; part = aimee ; compl = Jean ++ Ici} + } ; + +----- add auxVerb to Complemnt to switch to $esse$ in refl ? + + reflTransVerb : TransVerb -> Complemnt = \aime -> + let + clit = isTransVerbClit aime ; + in + \\g,n,p => + let + soi = reflPron ! n ! p ! unstressed accusative ; ---- (case2pformClit aime.c) ; + aimee = aime.s ! VPart g n + in + case clit of { + True => {clit = soi ; part = aimee ; compl = []} ; + False => {clit = [] ; part = aimee ; compl = soi} + } ; + + reflPron : Number => Person => NPFormA => Str ; + + reflPronNounPhrase : Gender -> Number -> Person -> NounPhrase = \g,n,p -> + {s = reflPron ! n ! p ; + g = PGen g ; -- needed in participle agreement + n = n ; + p = p ; + c = Clit1 ---- depends on person? + } ; + +---- There is no adverbial form for the past participle. + + adjPastPart : Verb -> Adjective = \verb -> { + s = table { + AF g n => verb.s ! VPart g n ; + AA => verb.s ! VPart Masc Sg + } ; + p = False + } ; + + mkTransVerb : Verb -> Preposition -> CaseA -> TransVerb = \v,p,c -> + v ** {s2 = p ; c = c} ; + + mkTransVerbPrep : Verb -> Preposition -> TransVerb = \passer,par -> + mkTransVerb passer par accusative ; + + mkTransVerbCas : Verb -> CaseA -> TransVerb = \penser,a -> + mkTransVerb penser [] a ; + + mkTransVerbDir : Verb -> TransVerb = \aimer -> + mkTransVerbCas aimer accusative ; + +-- Transitive verbs can be used elliptically as verbs. The semantics +-- is left to applications. The definition is trivial, due to record +-- subtyping. + + transAsVerb : TransVerb -> Verb = \love -> + love ; + +-- *Ditransitive verbs* are verbs with three argument places. +-- We treat so far only the rule in which the ditransitive +-- verb takes both complements to form a verb phrase. + + DitransVerb = TransVerb ** {s3 : Preposition ; c3 : CaseA} ; + + mkDitransVerb : + Verb -> Preposition -> CaseA -> Preposition -> CaseA -> DitransVerb = + \v,p1,c1,p2,c2 -> + v ** {s2 = p1 ; c = c1 ; s3 = p2 ; c3 = c2} ; + +--- This must be completed to account for the order of the clitics. +--- In the rule below, the last argument cannot get cliticized. + + complDitransVerb : + DitransVerb -> NounPhrase -> NounPhrase -> Complemnt = \donner,jean,vin -> + complTransVerbGen + donner jean + (\\_,_,_ => donner.s3 ++ vin.s ! case2pform donner.c3) ; + +{- + {s = \\b,g,w => + let + adonne = formVerb2 donner g w ; + a = adonne.verb ; + isClit = isDitransVerbClit donner ; + cJean = andB (isNounPhraseClit jean) (isClit.p1) ; + cVin = andB (isNounPhraseClit vin) (isClit.p2) ; + donne = if_then_Str cVin + (adonne.part ! pgen2gen vin.g ! vin.n) + (adonne.part ! Masc ! Sg) ; + Jean = jean.s ! (case2pformClit donner.c) ; + Vin = vin.s ! (case2pformClit donner.c3) ; + aJean = if_then_Str cJean [] Jean ; + duVin = if_then_Str cVin [] Vin ; + lui = if_then_Str cJean Jean [] ; + te = if_then_Str cVin Vin [] + in + posNeg b (te ++ lui ++ a) (donne ++ aJean ++ duVin) + } ; +-} + +-- The following macro builds the "ne - pas" or "non" negation. The second +-- string argument is used for the complement of a verb phrase. In Italian, +-- one string argument would actually be enough. + + posNeg : Bool -> (verb, compl : Str) -> Str ; + + complDitransAdjVerb : + TransVerb -> NounPhrase -> AdjPhrase -> Complemnt = \rend,toi,sec -> + complTransVerbGen rend toi (\\g,n,_ => sec.s ! AF g n) ; + + DitransVerbVerb = TransVerb ** {c3 : CaseA} ; + + complDitransVerbVerb : + Bool -> DitransVerbVerb -> NounPhrase -> VerbPhrase -> Complemnt = + \obj, demander, toi, nager -> + complTransVerbGen demander toi + (\\g,n,p => + let + agr : Gender * Number * Person = case obj of { + True => ; + False => + } + in + prepCase demander.c ++ + nager.s ! VIInfinit ! agr.p1 ! agr.p2 ! agr.p3) ; + + +--2 Adverbs +-- +-- Adverbs are not inflected (we ignore comparison, and treat +-- compared adverbs as separate expressions; this could be done another way). +-- +-- (We should also take into account clitic ones, like "y", +-- as well as the position: "est toujours heureux" / "est heureux à Paris".) + + Adverb : Type = SS ; + + adVerbPhrase : VerbGroup -> Adverb -> VerbGroup = \chante, bien -> + {s = \\b,g,v => chante.s ! b ! g ! v ++ bien.s} ; + + advVerbPhrase : VerbPhrase -> Adverb -> VerbPhrase = \chante, bien -> + {s = \\v,g,n,p => chante.s ! v ! g ! n ! p ++ bien.s} ; + +-- Adverbs are typically generated by prefixing prepositions. +-- The rule for prepositional phrases also comprises the use of prepositions +-- treated as cases. Therefore, both a preposition and a case are needed +-- as arguments. + + prepNounPhrase : {s : Preposition ; c : CaseA} -> NounPhrase -> Adverb = \dans,jean -> + {s = dans.s ++ jean.s ! Ton dans.c} ; + + justPrep : Preposition -> {s : Preposition ; c : CaseA} = \sans -> + {s = sans ; c = prepositional} ; + + justCase : CaseA -> {s : Preposition ; c : CaseA} = \nom -> + {s = [] ; c = nom} ; + +-- This is a source of the "homme avec un téléscope" ambiguity, and may produce +-- strange things, like "les voitures toujours". +-- Semantics will have to make finer distinctions among adverbials. +-- French moreover says "les voitures d'hier" rather than "les voitures hier". + + advCommNounPhrase : CommNounPhrase -> Adverb -> CommNounPhrase = \mec,aparis -> + {s = \\n => mec.s ! n ++ aparis.s ; + g = mec.g + } ; + + advAdjPhrase : Adverb -> AdjPhrase -> AdjPhrase = \trop,lent -> + {s = \\a => trop.s ++ lent.s ! a ; + p = lent.p + } ; + +--2 Sentences +-- +-- Sentences depend on a *mode parameter* selecting between +-- indicative and subjunctive forms. + + Sentence : Type = SS1 Mode ; + +-- This is the traditional $S -> NP VP$ rule. It takes care of both +-- mode and agreement. + +param + Tense = Present | Past | Future | Condit ; + + ClForm = + ClPres Anteriority Mode + | ClImperf Anteriority Mode + | ClPasse Anteriority + | ClFut Anteriority + | ClCondit Anteriority + | ClInfinit Anteriority -- "naked infinitive" clauses + ; + +oper + useClForm : Tense -> Anteriority -> Mode -> ClForm = + \t,a,m -> case t of { + Present => ClPres a m ; + Past => ClImperf a m ; --- no passé simple + Future => ClFut a ; ---- mode + Condit => ClCondit a + } ; + + Clause = {s : Bool => ClForm => Str} ; + + ---- VIForm = VIInfinit | VIImperat Bool Number ; + predVerbGroup : Bool -> {s : Str ; a : Anteriority} -> VerbGroup -> VerbPhrase = + \b,ant,vg -> + {s = \\vi,g,n,p => ant.s ++ vg.s ! b ! g ! VPF ant.a VInfin ---- imper + } ; + + cl2vp : ClForm -> Number -> Person -> VPForm = \c,n,p -> case c of { + ClPres a m => VPF a (VFin (VPres m) n p) ; + ClImperf a m => VPF a (VFin (VImperf m) n p) ; + ClPasse a => VPF a (VFin VPasse n p) ; + ClFut a => VPF a (VFin VFut n p) ; + ClCondit a => VPF a (VFin VCondit n p) ; + ClInfinit a => VPF a VInfin + } ; + + vp2cl : VPForm -> ClForm = \vf -> case vf of { + VPF a (VFin (VPres m) _ _) => ClPres a m ; + VPF a (VFin (VImperf m) _ _) => ClImperf a m ; + VPF a (VFin (VPasse) _ _) => ClPasse a ; + VPF a (VFin (VFut) _ _) => ClFut a ; + VPF a (VFin (VCondit) _ _) => ClCondit a ; + VPF a VInfin => ClInfinit a ; + _ => ClInfinit Simul ---- imper + } ; + + + Complemnt = Gender => Number => Person => {clit, part, compl : Str} ; ---- ment + + predVerbClause : NounPhrase -> Verb -> Complemnt -> Clause = \np,verb,comp -> + let nv = predVerbClauseGen np verb comp in + {s = \\b,cl => let nvg = nv ! b ! cl in nvg.p1 ++ nvg.p2} ; + + predVerbClauseGen : NounPhrase -> Verb -> Complemnt -> + (Bool => ClForm => (Str * Str)) = \np,verb,comp -> + let + jean = np.s ! unstressed nominative ; + co = comp ! pgen2gen np.g ! np.n ! np.p ; + la = co.clit ; + ici = co.compl ; + aimee = co.part ; + aime : TMode -> Str = \t -> verb.s ! (VFin t np.n np.p) ; + avoir : TMode -> Str = \t -> (auxVerb verb).s ! (VFin t np.n np.p) ; + aimer = verb.s ! VInfin ; + avoirr = (auxVerb verb).s ! VInfin + in + \\b => table { + ClPres Simul m => ; + ClPres a m => ; + ClImperf Simul m => ; + ClImperf a m => ; + ClPasse Simul => ; + ClPasse a => ; + ClFut Simul => ; + ClFut a => ; + ClCondit Simul => ; + ClCondit a => ; + ClInfinit Simul => ; + ClInfinit a => + } ; + +-- These three function are just to restore the $VerbGroup$ ($VP$) based structure. + + predVerbGroupClause : NounPhrase -> VerbGroup -> Clause = \np,vp -> + let + it = np.s ! unstressed nominative + in + {s = \\b,cf => it ++ vp.s ! b ! pgen2gen np.g ! cl2vp cf np.n np.p} ; + + predClauseGroup : Verb -> Complemnt -> VerbGroup = \verb,comp -> + let + nvg : PronGen -> Number -> Person -> (Bool => ClForm => (Str * Str)) = + \g,n,p -> + predVerbClauseGen {s = \\_ => [] ; g=g ; n=n ; p=p ; c=Clit0} verb comp + -- clit type irrelevant in subject position + in + {s = \\b,g,vf => + (nvg (PGen g) (nombreVerbPhrase vf) (personVerbPhrase vf) ! b ! (vp2cl vf)).p2 + } ; + + predClauseBeGroup : Complemnt -> VerbGroup = + predClauseGroup copula ; + + +--3 Sentence-complement verbs +-- +-- Sentence-complement verbs take sentences as complements. +-- The mode of the complement depends on the verb, and can be different +-- for positive and negative uses of the verb +-- ("je crois qu'elle vient" -"je ne crois pas qu'elle vienne"), + + SentenceVerb : Type = Verb ** {mp, mn : Mode} ; + + subordMode : SentenceVerb -> Bool -> Mode = \verb,b -> + if_then_else Mode b verb.mp verb.mn ; + + complSentVerb : SentenceVerb -> Sentence -> Complemnt = \croire,jeanboit -> + mkCompl + croire + (\\g,n,p => + ----- add Bool to Complemnt ? + ----- let m = if_then_else Mode b croire.mp croire.mn + embedConj ++ jeanboit.s ! croire.mp) ; + + complDitransSentVerb : + (TransVerb ** {mp, mn : Mode}) -> NounPhrase -> Sentence -> Complemnt = + \dire,lui,jeanboit -> + complTransVerbGen + dire lui + (\\g,n,p => + embedConj ++ jeanboit.s ! dire.mp) ; + + complQuestVerb : Verb -> QuestionSent -> Complemnt = \demander,sijeanboit -> + mkCompl + demander + (\\g,n,p => sijeanboit.s ! IndirQ) ; + + complDitransQuestVerb : TransVerb -> NounPhrase -> QuestionSent -> Complemnt = + \dire,lui,jeanboit -> + complTransVerbGen + dire lui + (\\g,n,p => jeanboit.s ! IndirQ) ; + + complAdjVerb : Verb -> AdjPhrase -> Complemnt = \sent,bon -> + mkCompl sent (\\g,n,_ => bon.s ! AF g n) ; + + verbSent : Verb -> Mode -> Mode -> SentenceVerb = \v,mp,mn -> + v ** {mp = mp ; mn = mn} ; + +-- The embedding conjunction is language dependent. + + embedConj : Str ; + + +--3 Verb-complement verbs +-- +-- Verb-complement verbs take verb phrases as complements. +-- They can need an oblique case ("à", "de"), but they work like ordinary verbs. + + VerbVerb : Type = Verb ** {c : CaseA} ; + + complVerbVerb : VerbVerb -> VerbPhrase -> Complemnt = \devoir, nager -> + mkCompl + devoir + (\\g,n,p => prepCase devoir.c ++ nager.s ! VIInfinit ! g ! n ! p) ; + + mkVerbVerbDir : Verb -> VerbVerb = \v -> v ** {c = accusative} ; + + +--2 Sentences missing noun phrases +-- +-- This is one instance of Gazdar's *slash categories*, corresponding to his +-- $S/NP$. +-- We cannot have - nor would we want to have - a productive slash-category former. +-- Perhaps a handful more will be needed. +-- +-- Notice that the slash category has the same relation to sentences as +-- transitive verbs have to verbs: it's like a *sentence taking a complement*. + + ClauseSlashNounPhrase = Clause ** Complement ; + + dummyNounPhrase : NounPhrase = mkNameNounPhrase [] Masc ; + + slashTransVerb : NounPhrase -> TransVerb -> ClauseSlashNounPhrase = \np,v -> + sats2clause (mkSatsObject np v dummyNounPhrase) ** + complementOfTransVerb v ; + + + slashVerbVerb : NounPhrase -> VerbVerb -> TransVerb -> ClauseSlashNounPhrase = + \subj, verb, tv -> + sats2clause ( + insertExtrapos + (mkSats subj verb) + (\\_ => prepCase verb.c ++ tv.s ! VInfin) + ) ** complementOfTransVerb tv ; + + slashAdverb : Clause -> {s : Str ; c : CaseA} -> ClauseSlashNounPhrase = + \ilhabite,dans -> ilhabite ** {s2 = dans.s ; c = dans.c} ; + + +--2 Relative pronouns and relative clauses +-- +-- Relative pronouns are inflected in +-- gender, number, and case. They can also have an inherent case, +-- but this case if 'variable' in the sense that it +-- is sometimes just mediated from the correlate +-- ("homme qui est bon"), sometimes inherent to the +-- pronominal phrase itself ("homme dont la mère est bonne"). + +oper + + RelPron : Type = {s : RelFormA => Str ; g : RelGen} ; + + RelClause : Type = {s : Bool => ClForm => Gender => Number => Person => Str} ; + RelSentence : Type = {s : Mode => Gender => Number => Person => Str} ; + + mkGenRel : RelGen -> Gender -> Gender = \rg,g -> case rg of { + RG gen => gen ; + _ => g + } ; + +-- Simple relative pronouns ("qui", "dont", "par laquelle") +-- have no inherent gender. + + identRelPron : RelPron ; + + composRelPron : Gender -> Number -> CaseA -> Str ; + +-- Complex relative pronouns ("dont la mère") do have an inherent gender. + + funRelPron : Function -> RelPron -> RelPron ; + +-- There are often variants, i.e. short and long forms +-- ("que" - "lequel", "dont" -"duquel"), etc. + + allRelForms : RelPron -> Gender -> Number -> CaseA -> Str ; + +-- Relative clauses can be formed from both verb phrases ("qui dort") and +-- slash expressions ("que je vois", "dont je parle"). + + relVerbPhrase : RelPron -> VerbGroup -> RelClause = \qui,dort -> + {s = \\b,cl,g,n,p => + allRelForms qui g n nominative ++ dort.s ! b ! g ! cl2vp cl n p + } ; + + relSlash : RelPron -> ClauseSlashNounPhrase -> RelClause = \dont,jeparle -> + {s = \\b,cl,g,n,p => + jeparle.s2 ++ allRelForms dont g n jeparle.c ++ jeparle.s ! b ! cl + } ; + +-- A 'degenerate' relative clause is the one often used in mathematics, e.g. +-- "nombre x tel que x soit pair". + + relSuch : Clause -> RelClause = \A -> + {s = \\b,cl,g,n,p => suchPron g n ++ embedConj ++ A.s ! b ! cl + } ; + + suchPron : Gender -> Number -> Str ; + +-- The main use of relative clauses is to modify common nouns. +-- The result is a common noun, out of which noun phrases can be formed +-- by determiners. A comma is used before the relative clause. +-- +-- N.B. subjunctive relative clauses +-- ("je cherche un mec qui sache chanter") must have another structure +-- (unless common noun phrases are given a mode parameter...). + + modRelClause : CommNounPhrase -> RelSentence -> CommNounPhrase = \mec,quidort -> + {s = \\n => mec.s ! n ++ quidort.s ! Ind ! mec.g ! n ! P3 ; + g = mec.g + } ; + +--2 Interrogative pronouns +-- +-- If relative pronouns are adjective-like, interrogative pronouns are +-- noun-phrase-like. We use a simplified type, since we don't need the possessive +-- forms. +-- +-- N.B. "est-ce que", etc, will be added below +-- when pronouns are used in direct questions. + + IntPron : Type = {s : CaseA => Str ; g : Gender ; n : Number} ; + +-- In analogy with relative pronouns, we have a rule for applying a function +-- to a relative pronoun to create a new one. + + funIntPron : Function -> IntPron -> IntPron = \mere,qui -> + {s = \\c => + artDef mere.g qui.n c ++ mere.s ! qui.n ++ mere.s2 ++ qui.s ! mere.c ; + g = mere.g ; + n = qui.n + } ; + +-- There is a variety of simple interrogative pronouns: +-- "quelle maison", "qui", "quoi". Their definitions are language-dependent. + + nounIntPron : Number -> CommNounPhrase -> IntPron ; + intPronWho : Number -> IntPron ; + intPronWhat : Number -> IntPron ; + +--2 Utterances + +-- By utterances we mean whole phrases, such as +-- 'can be used as moves in a language game': indicatives, questions, imperative, +-- and one-word utterances. The rules are far from complete. +-- +-- N.B. we have not included rules for texts, which we find we cannot say much +-- about on this level. In semantically rich GF grammars, texts, dialogues, etc, +-- will of course play an important role as categories not reducible to utterances. +-- An example is proof texts, whose semantics show a dependence between premises +-- and conclusions. Another example is intersentential anaphora. + + Utterance = SS ; + + indicUtt : Sentence -> Utterance = \x -> ss (x.s ! Ind ++ ".") ; + interrogUtt : QuestionSent -> Utterance = \x -> ss (x.s ! DirQ ++ "?") ; + +--2 Questions +-- +-- Questions are either direct ("qui a pris la voiture") or indirect +-- ("ce qui a pris la voiture"). + +param + QuestForm = DirQ | IndirQ ; + +oper + Question = {s : Bool => ClForm => QuestForm => Str} ; + QuestionSent = {s : QuestForm => Str} ; + + +--3 Yes-no questions +-- +-- Yes-no questions are used both independently ("Tu es fatigué?") +-- and after interrogative adverbials ("Pourquoi tu es fatigué?"). +-- It is economical to handle with these two cases by the one +-- rule, $questVerbPhrase'$. The only difference is if "si" appears +-- in the indirect form. +-- +-- N.B. the inversion variant ("Es-tu fatigué?") is missing, mainly because our +-- verb morphology does not support the intervening "t" ("Marche-t-il?"). +-- The leading "est-ce que" is recognized as a variant, and requires +-- direct word order. + + questClause : Clause -> Question = \cl -> + {s = \\b,c => table { + DirQ => cl.s ! b ! c ; + IndirQ => cl.s ! b ! c + } + } ; + +----- questVerbPhrase : NounPhrase -> VerbPhrase -> Question ; + +--3 Wh-questions +-- +-- Wh-questions are of two kinds: ones that are like $NP - VP$ sentences, +-- others that are line $S/NP - NP$ sentences. +-- +-- N.B. inversion variants and "est-ce que" are treated as above. + + intVerbPhrase : IntPron -> VerbGroup -> Question = \ip,vg -> + questClause (predVerbGroupClause (intNounPhrase ip) vg) ; + + intSlash : IntPron -> ClauseSlashNounPhrase -> Question ; + + intNounPhrase : IntPron -> NounPhrase = \ip -> + {s = \\nf => ip.s ! pform2case nf ; g = PGen ip.g ; n = ip.n ; p = P3 ; c = Clit0} ; + +--3 Interrogative adverbials +-- +-- These adverbials will be defined in the lexicon: they include +-- "quand", "où", "comment", "pourquoi", etc, which are all invariant one-word +-- expressions. In addition, they can be formed by adding prepositions +-- to interrogative pronouns, in the same way as adverbials are formed +-- from noun phrases. +-- +-- N.B. inversion variants and "est-ce que" are treated as above. + + IntAdverb = SS ; + + questAdverbial : IntAdverb -> Clause -> Question = + \quand, jeanDort -> + {s = \\b,cl => + let + jeandort = jeanDort.s ! b ! cl + in + table { + DirQ => quand.s ++ jeandort ; ---- est-ce que + IndirQ => quand.s ++ jeandort + } + } ; + + + +--2 Imperatives +-- +-- We only consider second-person imperatives. +-- +-- N.B. following the API, we don't distinguish between +-- singular and plural "vous", nor between masculine and feminine. +-- when forming utterances. +-- +-- TODO: clitics, Italian negated imperative. + + Imperative = {s : Gender => Number => Str} ; + + imperVerbPhrase : Bool -> VerbPhrase -> Imperative = \b,dormir -> + {s = \\g,n => dormir.s ! VIImperat b n ! g ! n ! P2 + } ; + + imperUtterance : Number -> Imperative -> Utterance = \n,I -> + ss (I.s ! Masc ! n ++ "!") ; + +--2 Sentence adverbials +-- +-- Sentence adverbs is the largest class and open for +-- e.g. prepositional phrases. + + advClause : Clause -> Adverb -> Clause = \yousing,well -> + {s = \\b,c => yousing.s ! b ! c ++ well.s} ; + +-- Another class covers adverbials such as "autrement", "donc", which are prefixed +-- to a sentence to form a phrase. + + advSentence : SS -> Sentence -> Utterance = \donc,ildort -> + ss (donc.s ++ ildort.s ! Ind ++ ".") ; + + +--2 Coordination +-- +-- Coordination is to some extent orthogonal to the rest of syntax, and +-- has been treated in a generic way in the module $CO$ in the file +-- $coordination.gf$. The overall structure is independent of category, +-- but there can be differences in parameter dependencies. +-- +--3 Conjunctions +-- +-- Coordinated phrases are built by using conjunctions, which are either +-- simple ("et", "ou") or distributed ("et - et", "pu - ou"). + + Conjunction = CO.Conjunction ** {n : Number} ; + ConjunctionDistr = CO.ConjunctionDistr ** {n : Number} ; + +--3 Coordinating sentences +-- +-- We need a category of lists of sentences. It is a discontinuous +-- category, the parts corresponding to 'init' and 'last' segments +-- (rather than 'head' and 'tail', because we have to keep track of the slot between +-- the last two elements of the list). A list has at least two elements. +-- +-- N.B. we don't have repetion of "que" in subordinate coordinated sentences. + + ListSentence : Type = {s1,s2 : Mode => Str} ; + + twoSentence : (_,_ : Sentence) -> ListSentence = + CO.twoTable Mode ; + + consSentence : ListSentence -> Sentence -> ListSentence = + CO.consTable Mode CO.comma ; + +-- To coordinate a list of sentences by a simple conjunction, we place +-- it between the last two elements; commas are put in the other slots, +-- e.g. "Pierre fume, Jean boit et les autres regardsnt". + + conjunctSentence : Conjunction -> ListSentence -> Sentence = + CO.conjunctTable Mode ; + +-- To coordinate a list of sentences by a distributed conjunction, we place +-- the first part in front of the first element, the second +-- part between the last two elements, and commas in the other slots. +-- For sentences this is really not used. + + conjunctDistrSentence : ConjunctionDistr -> ListSentence -> Sentence = + CO.conjunctDistrTable Mode ; + +--3 Coordinating adjective phrases +-- +-- The structure is the same as for sentences. The result is a prefix adjective +-- if and only if all elements are prefix. + + ListAdjPhrase : Type = + {s1,s2 : AForm => Str ; p : Bool} ; + + twoAdjPhrase : (_,_ : AdjPhrase) -> ListAdjPhrase = \x,y -> + CO.twoTable AForm x y ** {p = andB x.p y.p} ; + + consAdjPhrase : ListAdjPhrase -> AdjPhrase -> ListAdjPhrase = \xs,x -> + CO.consTable AForm CO.comma xs x ** {p = andB xs.p x.p} ; + + conjunctAdjPhrase : Conjunction -> ListAdjPhrase -> AdjPhrase = \c,xs -> + CO.conjunctTable AForm c xs ** {p = xs.p} ; + + conjunctDistrAdjPhrase : ConjunctionDistr -> ListAdjPhrase -> AdjPhrase = \c,xs -> + CO.conjunctDistrTable AForm c xs ** {p = xs.p} ; + + +--3 Coordinating noun phrases +-- +-- The structure is the same as for sentences. The result is either always plural +-- or plural if any of the components is, depending on the conjunction. +-- The gender is masculine if any of the components is. A coordinated noun phrase +-- cannot be clitic. + + ListNounPhrase : Type = + {s1,s2 : CaseA => Str ; g : PronGen ; n : Number ; p : Person} ; + + twoNounPhrase : (_,_ : NounPhrase) -> ListNounPhrase = \x,y -> + {s1 = \\c => x.s ! stressed c ; s2 = \\c => y.s ! stressed c} ** + {n = conjNumber x.n y.n ; g = conjGender x.g y.g ; p = conjPers x.p y.p} ; + + consNounPhrase : ListNounPhrase -> NounPhrase -> ListNounPhrase = \xs,x -> + {s1 = \\c => xs.s1 ! c ++ CO.comma ++ xs.s2 ! c ; + s2 = \\c => x.s ! stressed c} ** + {n = conjNumber xs.n x.n ; g = conjGender xs.g x.g ; p =conjPers xs.p x.p} ; + + conjunctNounPhrase : Conjunction -> ListNounPhrase -> NounPhrase = \co,xs -> + {s = \\c => xs.s1 ! pform2case c ++ co.s ++ xs.s2 ! pform2case c} ** + {n = conjNumber co.n xs.n ; g = xs.g ; p = xs.p ; c = Clit0 } ; + + conjunctDistrNounPhrase : ConjunctionDistr -> ListNounPhrase -> NounPhrase = + \co,xs -> + {s = \\c => co.s1++ xs.s1 ! pform2case c ++ co.s2 ++ xs.s2 ! pform2case c} ** + {n = conjNumber co.n xs.n ; g = xs.g ; p = xs.p ; c = Clit0} ; + + +-- We have to define a calculus of numbers of genders. For numbers, +-- it is like the conjunction with $Pl$ corresponding to $False$. For genders, +-- $Masc$ corresponds to $False$. + + conjNumber : Number -> Number -> Number = \m,n -> case of { + => Sg ; + _ => Pl + } ; + + conjGen : Gender -> Gender -> Gender = \m,n -> case of { + => Fem ; + _ => Masc + } ; + + conjGender : PronGen -> PronGen -> PronGen = \m,n -> case of { + => PGen Fem ; + _ => PNoGen + } ; + +-- For persons, we go in the descending order: +-- "moi et toi sommes forts", "lui ou toi es fort". +-- This is not always quite clear. + + conjPers : Person -> Person -> Person = \p,q -> case of { + => P3 ; + => P1 ; + <_,P1> => P1 ; + _ => P2 + } ; + +--3 Coordinating adverbs +-- +-- We need a category of lists of adverbs. It is a discontinuous +-- category, the parts corresponding to 'init' and 'last' segments +-- (rather than 'head' and 'tail', because we have to keep track of the slot between +-- the last two elements of the list). A list has at least two elements. + + ListAdverb : Type = SD2 ; + + twoAdverb : (_,_ : Adverb) -> ListAdverb = CO.twoSS ; + + consAdverb : ListAdverb -> Adverb -> ListAdverb = + CO.consSS CO.comma ; + +-- To coordinate a list of adverbs by a simple conjunction, we place +-- it between the last two elements; commas are put in the other slots, + + conjunctAdverb : Conjunction -> ListAdverb -> Adverb = \c,xs -> + ss (CO.conjunctX c xs) ; + +-- To coordinate a list of adverbs by a distributed conjunction, we place +-- the first part (e.g. "either") in front of the first element, the second +-- part ("or") between the last two elements, and commas in the other slots. + + conjunctDistrAdverb : ConjunctionDistr -> ListAdverb -> Adverb = + \c,xs -> + ss (CO.conjunctDistrX c xs) ; + + + + +--2 Subjunction +-- +-- Subjunctions ("si", "quand", etc) +-- are a different way to combine sentences than conjunctions. +-- The main clause can be a sentences, an imperatives, or a question, +-- but the subjoined clause must be a sentence. The inherent mood can be +-- indicative ("si", "quand") or subjunctive ("bien que"). + + Subjunction = {s : Str ; m : Mode} ; + + subjunctSentence : Subjunction -> Sentence -> Sentence -> Sentence = \si,A,B -> + {s = \\m => subjunctVariants si A (B.s ! m) + } ; + + subjunctImperative : Subjunction -> Sentence -> Imperative -> Imperative = + \si,A,B -> + {s = \\g,n => subjunctVariants si A (B.s ! g ! n) + } ; + + subjunctQuestion : Subjunction -> Sentence -> QuestionSent -> QuestionSent = \si,A,B -> + {s = \\q => subjunctVariants si A (B.s ! q) + } ; + +-- There are uniformly two variant word orders, e.g. +-- "si tu fume je m'en vais" +-- and "je m'en vais si tu fume". + + subjunctVariants : Subjunction -> Sentence -> Str -> Str = \si,A,B -> + let {As = A.s ! si.m} in + variants { + si.s ++ As ++ B ; + B ++ si.s ++ As + } ; + + subjunctVerbPhrase : VerbGroup -> Subjunction -> Sentence -> VerbGroup = + \V, si, A -> + adVerbPhrase V (ss (si.s ++ A.s ! si.m)) ; + +--2 One-word utterances +-- +-- An utterance can consist of one phrase of almost any category, +-- the limiting case being one-word utterances. These +-- utterances are often (but not always) in what can be called the +-- default form of a category, e.g. the nominative. +-- This list is far from exhaustive. + + useNounPhrase : NounPhrase -> Utterance = \jean -> + postfixSS "." (defaultNounPhrase jean) ; + useCommonNounPhrase : Number -> CommNounPhrase -> Utterance = \n,mec -> + useNounPhrase (indefNounPhrase n mec) ; + + verbUtterance : VerbPhrase -> Utterance = \vp -> + ss (vp.s ! VIInfinit ! Masc ! Sg ! P3) ; + + +-- one-form variants + + defaultNounPhrase : NounPhrase -> SS = \jean -> + ss (jean.s ! stressed nominative) ; + + defaultQuestion : QuestionSent -> SS = \quiesttu -> + ss (quiesttu.s ! DirQ) ; + + defaultSentence : Sentence -> SS = \x -> ss (x.s ! Ind) ; + +----- moved from Types + + artDef : Gender -> Number -> CaseA -> Str ; + artIndef : Gender -> Number -> CaseA -> Str ; + genForms : Str -> Str -> Gender => Str ; + +----- moved from Res ; should not be here (pronouns are also in MorphoIta...) + + pronJe, pronTu, pronIl, pronElle, pronNous, pronVous, pronIls, pronElles : + Pronoun ; + chaqueDet, quelDet, plupartDet : Determiner ; + + commentAdv, quandAdv, ouAdv, pourquoiAdv : Adverb ; + + etConj, ouConj : Conjunction ; + etetConj, ououConj : ConjunctionDistr ; + siSubj, quandSubj : Subjunction ; + + ouiPhr, noPhr : Utterance ; + +--------------------------------------------------------------------- +---- for Sats; to be moved earlier + + Sats : Type = { + s1 : Str ; -- je je + s3 : Str ; -- (ne) le lui (ne) + s4 : VF => Str ; -- ai ai + s5 : Str ; -- toujours (pas) toujours (pas) + s6 : Str ; -- (dit) directement (voulu) le lui dire directement + s7 : Bool => Str; -- qu'il pleu/pleuve + aux : VAux ; + g,g2 : Gender ; -- features for main verb and participle + n,n2 : Number ; + p : Person -- feature of subject + + } ; + + verbClForm : + Verb -> ClForm -> Gender -> Number -> Person -> Gender -> Number -> (Str * Str) = + \verb,cl,g,n,p,g2,n2 -> + let + aimee = verb.s ! VPart g2 n2 ; + auxv = (auxVerb verb).s ; + aime : TMode -> Str = \t -> verb.s ! (VFin t n p) ; + avoir : TMode -> Str = \t -> auxv ! (VFin t n p) ; + aimer = verb.s ! VInfin ; + avoirr = auxv ! VInfin + in + case cl of { + ClPres Simul m => ; + ClPres a m => ; + ClImperf Simul m => ; + ClImperf a m => ; + ClPasse Simul => ; + ClPasse a => ; + ClFut Simul => ; + ClFut a => ; + ClCondit Simul => ; + ClCondit a => ; + ClInfinit Simul => ; + ClInfinit a => + } ; + + mkSats : NounPhrase -> Verb -> Sats = \subj,verb -> + let ifEsse : (T : Type) -> T -> T -> T = \T,e,h -> + case verb.aux of { + AEsse => e ; + AHabere => h + } + in + {s1 = subj.s ! unstressed nominative ; + s3 = [] ; + s4 = verb.s ; + s5, s6 = [] ; + s7 = \\_ => [] ; + aux = verb.aux ; + g = pgen2gen subj.g ; + n = subj.n ; + p = subj.p ; + g2 = ifEsse Gender (pgen2gen subj.g) Masc ; + n2 = ifEsse Number subj.n Sg + } ; + + insertObject : Sats -> CaseA -> Str -> NounPhrase -> Sats = \sats, c, prep, obj -> + let + ifClit : (T : Type) -> T -> T -> T = + \T -> if_then_else T (andB (isNounPhraseClit obj) (isClitCase c)) ; + object = obj.s ! (case2pformClit c) ; + clit = ifClit Str object [] ; + np = ifClit Str [] object + in + {s1 = sats.s1 ; + s3 = sats.s3 ++ clit ; ---- or clit ++ s3, dep. on clits + s4 = sats.s4 ; + s5 = sats.s5 ; + s6 = sats.s6 ++ prep ++ np ; + s7 = sats.s7 ; + aux = sats.aux ; + g = sats.g ; + n = sats.n ; + g2 = ifClit Gender (pgen2gen obj.g) sats.g2 ; ---- only for clit acc + n2 = ifClit Number obj.n sats.n2 ; + p = sats.p + } ; + + insertExtrapos : Sats -> (Bool => Str) -> Sats = \sats,obj -> + {s1 = sats.s1 ; + s3 = sats.s3 ; + s4 = sats.s4 ; + s5 = sats.s5 ; + s6 = sats.s6 ; + s7 = obj ; + aux = sats.aux ; + g = sats.g ; + n = sats.n ; + g2 = sats.g2 ; + n2 = sats.n2 ; + p = sats.p + } ; + + mkSatsObject : NounPhrase -> TransVerb -> NounPhrase -> Sats = \subj,verb,obj -> + insertObject (mkSats subj verb) verb.c verb.s2 obj ; + + mkSatsCopula : NounPhrase -> Str -> Sats = \subj,obj -> + mkSatsObject subj + (mkTransVerbDir copula) --- hack to reuse + (nameNounPhrase (mkProperName obj Masc)) ; --- this function + + sats2clause : Sats -> Clause = + \sats -> {s = \\b,cf => + let + je = sats.s1 ; + lui = sats.s3 ; + dire = verbClForm {s = sats.s4 ; aux = sats.aux} + cf sats.g sats.n sats.p sats.g2 sats.n2 ; + ai = dire.p1 ; + dit = dire.p2 ; + toujours = sats.s5 ; + directement = sats.s6 ; + ne = if_then_Str b [] negNe ; + pas = if_then_Str b [] negPas ; + oui = sats.s7 ! b + in + je ++ ne ++ lui ++ ai ++ toujours ++ pas ++ dit ++ directement ++ oui + } ; + +negNe, negPas : Str ; + + + sats2quest : Sats -> Question = \x -> + let cl = sats2clause x + in + {s = \\b,f,_ => cl.s ! b ! f} ; + +predVerb0 : Verb -> Clause ; + + +} diff --git a/lib/resource/spanish/SyntaxSpa.gf b/lib/resource/spanish/SyntaxSpa.gf index f2c2abd43..ecffc7873 100644 --- a/lib/resource/spanish/SyntaxSpa.gf +++ b/lib/resource/spanish/SyntaxSpa.gf @@ -11,7 +11,7 @@ oper nounPhraseOn = mkNameNounPhrase "se" Masc ; --- can be plural dep. on object - pronImpers = pronIl ; ---- should be [] ? + pronImpers : NounPhrase = mkNameNounPhrase [] Masc ; partitiveNounPhrase = \n,vino -> normalNounPhrase @@ -358,7 +358,5 @@ oper negNe = "no" ; negPas = [] ; - predVerb0 rain = predVerbClause (mkNameNounPhrase [] Masc) rain (complVerb rain) ; - }