GitHub/gf-core
1
0
Fork 1
mirror of https://github.com/GrammaticalFramework/gf-core.git synced 2026-05-21 17:12:50 -06:00
Code Issues Packages Projects Releases Wiki Activity

Latvian: a lot of code refactoring

Browse Source
This commit is contained in:
normundsg
2013-06-21 12:04:26 +00:00
parent e720d47700
commit e7b22ac609
11 changed files with 316 additions and 302 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
lib/src/latvian/CatLav.gf
View File

@@ -61,20 +61,11 @@ lincat
Pron = Pronoun ; Pron = Pronoun ;
Det = { Det = { s : Gender => Case => Str ; num : Number ; defin : Definiteness ; pol : Polarity } ;
s : Gender => Case => Str ;
num : Number ;
defin : Definiteness ;
pol : Polarity
} ;
Predet = { s : Gender => Str } ; Predet = { s : Gender => Str } ;
Quant = { Quant = { s : Gender => Number => Case => Str ; defin : Definiteness ; pol : Polarity } ;
s : Gender => Number => Case => Str ;
defin : Definiteness ;
pol : Polarity
} ;
Num = { s : Gender => Case => Str ; num : Number ; hasCard : Bool } ; Num = { s : Gender => Case => Str ; num : Number ; hasCard : Bool } ;
@@ -100,13 +91,13 @@ lincat
V, VV, VQ, VA = Verb ; V, VV, VQ, VA = Verb ;
V2, V2V, V2Q, V2A = Verb ** { focus : Preposition } ; V2, V2V, V2Q, V2A = Verb ** { rightVal : Preposition } ;
V3 = Verb ** { focus1, focus2 : Preposition } ; V3 = Verb ** { rightVal1, rightVal2 : Preposition } ;
VS = Verb ** { conj : Subj } ; VS = Verb ** { conj : Subj } ;
V2S = Verb ** { conj : Subj ; focus : Preposition } ; V2S = Verb ** { conj : Subj ; rightVal : Preposition } ;
A = Adjective ; A = Adjective ;

2
lib/src/latvian/ExtraLav.gf
View File

@@ -80,7 +80,7 @@ lin
s = \\agrAgr => s = \\agrAgr =>
temp.s ++ temp.s ++
-- TODO: verb moods other than Ind -- TODO: verb moods other than Ind
buildVerb vp.v (Ind temp.a temp.t) pol.p agrAgr.agr agrAgr.pol vp.agr.focus ++ buildVerb vp.v (Ind temp.a temp.t) pol.p agrAgr.agr agrAgr.pol vp.rightPol ++
vp.compl ! agrAgr.agr vp.compl ! agrAgr.agr
} ; } ;

6
lib/src/latvian/IdiomLav.gf
View File

@@ -18,7 +18,7 @@ lin
let agr = AgrP3 Sg Masc let agr = AgrP3 Sg Masc
in { in {
s = \\mood,pol => s = \\mood,pol =>
buildVerb vp.v mood pol agr Pos vp.agr.focus ++ -- Verb buildVerb vp.v mood pol agr Pos vp.rightPol ++ -- Verb
vp.compl ! agr -- Object(s), complements, adverbial modifiers vp.compl ! agr -- Object(s), complements, adverbial modifiers
} ; } ;
@@ -26,7 +26,7 @@ lin
let agr = AgrP3 Sg Masc let agr = AgrP3 Sg Masc
in { in {
s = \\mood,pol => s = \\mood,pol =>
buildVerb vp.v mood pol agr Pos vp.agr.focus ++ buildVerb vp.v mood pol agr Pos vp.rightPol ++
vp.compl ! agr vp.compl ! agr
} ; } ;
@@ -53,7 +53,7 @@ lin
; ;
ImpP3 np vp = { ImpP3 np vp = {
s = "lai" ++ np.s ! Nom ++ buildVerb vp.v (Ind Simul Pres) Pos np.agr np.pol vp.agr.focus ++ vp.compl ! np.agr ; s = "lai" ++ np.s ! Nom ++ buildVerb vp.v (Ind Simul Pres) Pos np.agr np.pol vp.rightPol ++ vp.compl ! np.agr ;
} ; } ;
-- FIXME: placeholder -- FIXME: placeholder

145
lib/src/latvian/ParadigmsLav.gf
View File

@@ -1,12 +1,12 @@
--# -path=.:abstract:common:prelude --# -path=.:abstract:common:prelude
resource ParadigmsLav = open resource ParadigmsLav = open
ResLav, ParadigmsVerbsLav,
CatLav,
ParadigmsNounsLav, ParadigmsNounsLav,
ParadigmsPronounsLav, ParadigmsPronounsLav,
ParadigmsAdjectivesLav, ParadigmsAdjectivesLav,
ParadigmsVerbsLav, ResLav,
CatLav,
Prelude, Prelude,
Predef Predef
in { in {
@@ -15,8 +15,10 @@ flags coding = utf8 ;
oper oper
-- Parameters
masculine : Gender = Masc ; masculine : Gender = Masc ;
feminine : Gender = Fem ; feminine : Gender = Fem ;
singular : Number = Sg ; singular : Number = Sg ;
plural : Number = Pl ; plural : Number = Pl ;
@@ -30,134 +32,137 @@ oper
second_conjugation : Conjugation = C2 ; second_conjugation : Conjugation = C2 ;
third_conjugation : Conjugation = C3 ; third_conjugation : Conjugation = C3 ;
active_voice : Voice = Act ; active_voice : Voice = Act ;
passive_voice : Voice = Pass ; passive_voice : Voice = Pass ;
-- Nouns
mkN = overload { mkN = overload {
mkN : (lemma : Str) -> N = \l -> lin N (mkNoun l) ; mkN : (lemma : Str) -> N = \l -> lin N (mkNoun l) ;
mkN : (lemma : Str) -> Bool -> N = \l,p -> lin N (mkNounByPal l p) ;
mkN : (lemma : Str) -> Bool -> N = \l,p -> lin N (mkNounByPal l p) ; mkN : (lemma : Str) -> Gender -> N = \l,g -> lin N (mkNounByGend l g) ;
mkN : (lemma : Str) -> Gender -> N = \l,g -> lin N (mkNounByGend l g) ; mkN : (lemma : Str) -> Declension -> N = \l,d -> lin N (mkNounByDecl l d) ;
mkN : (lemma : Str) -> Declension -> N = \l,d -> lin N (mkNounByDecl l d) ; mkN : (lemma : Str) -> Gender -> Bool -> N = \l,g,p -> lin N (mkNounByGendPal l g p) ;
mkN : (lemma : Str) -> Declension -> Bool -> N = \l,d,p -> lin N (mkNounByDeclPal l d p) ;
mkN : (lemma : Str) -> Gender -> Bool -> N = \l,g,p -> lin N (mkNounByGendPal l g p) ; mkN : (lemma : Str) -> Gender -> Declension -> N = \l,g,d -> lin N (mkNounByGendDecl l g d) ;
mkN : (lemma : Str) -> Declension -> Bool -> N = \l,d,p -> lin N (mkNounByDeclPal l d p) ; mkN : (lemma : Str) -> Gender -> Declension -> Bool -> N = \l,g,d,p -> lin N (mkNounByGendDeclPal l g d p) ;
mkN : (lemma : Str) -> Gender -> Declension -> N = \l,g,d -> lin N (mkNounByGendDecl l g d) ;
mkN : (lemma : Str) -> Gender -> Declension -> Bool -> N = \l,g,d,p ->
lin N (mkNounByGendDeclPal l g d p) ;
} ; } ;
mkPN = overload { mkPN = overload {
mkN : (lemma : Str) -> PN = \l -> lin PN (mkProperNoun l Sg) ; mkN : (lemma : Str) -> PN = \l -> lin PN (mkProperNoun l Sg) ;
mkN : (lemma : Str) -> Number -> PN = \l,n -> lin PN (mkProperNoun l n) ; mkN : (lemma : Str) -> Number -> PN = \l,n -> lin PN (mkProperNoun l n) ;
} ; } ;
mkN2 = overload { mkN2 = overload {
mkN2 : N -> Preposition -> N2 = \n,p -> lin N2 n ** { prep = p ; isPre = True } ; mkN2 : N -> Prep -> N2 = \n,p -> lin N2 (n ** {prep = p ; isPre = True}) ;
mkN2 : N -> Preposition -> Bool -> N2 = \n,p,pp -> lin N2 n ** { prep = p ; isPre = pp } ; mkN2 : N -> Prep -> Bool -> N2 = \n,p,pos -> lin N2 (n ** {prep = p ; isPre = pos}) ;
} ; } ;
mkN3 : N -> Preposition -> Preposition -> N3 = \n,p1,p2 -> mkN3 : N -> Prep -> Prep -> N3 = \n,p1,p2 ->
lin N3 n ** { prep1 = p1 ; prep2 = p2 ; isPre1 = False ; isPre2 = False } ; lin N3 (n ** {prep1 = p1 ; prep2 = p2 ; isPre1 = False ; isPre2 = False}) ;
-- Adjectives
mkA = overload { mkA = overload {
mkA : (lemma : Str) -> A = \s -> lin A (mkAdjective s) ; mkA : (lemma : Str) -> A = \s -> lin A (mkAdjective s) ;
mkA : (lemma : Str) -> AType -> A = \s,t -> lin A (mkAdjectiveByType s t) ; mkA : (lemma : Str) -> AType -> A = \s,t -> lin A (mkAdjectiveByType s t) ;
-- TODO: nav forši, ka jānorāda Voice, bet kā lai aptiet?
-- TODO: drīzāk jānorāda Str (divdabja forma) + Voice - pārējais iekšēji (auto) mkA : (v : V) -> Voice -> A = \v,p -> lin A (mkAdjective_Participle v p) ;
-- Turklāt Adj f-cijā iespējams būtu ok, ja pa tiešo izsauktu mkAdjective?!
-- Tomēr diez vai: IsUsi...
-- mkA2 gadījumā: vai Voice var noteikt pēc obj_Prep? Diez vai...
mkA : (v : Verb) -> Voice -> A = \v,p -> lin A (mkAdjective_Participle v p) ;
} ; } ;
AS, AV = A ; AS, AV = A ;
mkAS : A -> AS = \a -> lin A a ; mkAS : A -> AS = \a -> lin A a ;
mkAV : A -> AV = \a -> lin A a ; mkAV : A -> AV = \a -> lin A a ;
mkA2 : A -> Prep -> A2 = \a,p -> lin A2 (a ** { prep = p }) ; mkA2 : A -> Prep -> A2 = \a,p -> lin A2 (a ** {prep = p}) ;
A2S, A2V = A2 ; A2S, A2V = A2 ;
mkA2S : A -> Prep -> A2S =\a,p -> lin A2 (a ** { prep = p }) ; mkA2S : A -> Prep -> A2S = \a,p -> lin A2 (a ** {prep = p}) ;
mkA2V : A -> Prep -> A2V = \a,p -> lin A2 (a ** { prep = p }) ; mkA2V : A -> Prep -> A2V = \a,p -> lin A2 (a ** {prep = p}) ;
-- Verbs -- Verbs
mkV = overload { mkV = overload {
mkV : Str -> V = \s -> lin V (mkVerb_Irreg s Nom) ; mkV : Str -> V = \s -> lin V (mkVerb_Irreg s Nom) ;
mkV : Str -> Case -> V = \s,c -> lin V (mkVerb_Irreg s c) ; mkV : Str -> Case -> V = \s,c -> lin V (mkVerb_Irreg s c) ;
mkV : Str -> Conjugation -> V = \s,c -> lin V (mkVerb s c Nom) ;
mkV : Str -> Conjugation -> V = \s,conj -> lin V (mkVerb s conj Nom) ;
mkV : Str -> Conjugation -> Case -> V = \s,conj,c -> lin V (mkVerb s conj c) ; mkV : Str -> Conjugation -> Case -> V = \s,conj,c -> lin V (mkVerb s conj c) ;
mkV : Str -> Str -> Str -> V = \s1,s2,s3 -> lin V (mkVerbC1 s1 s2 s3 Nom) ;
mkV : Str -> Str -> Str -> V = \s1,s2,s3 -> lin V (mkVerbC1 s1 s2 s3 Nom) ;
mkV : Str -> Str -> Str -> Case -> V = \s1,s2,s3,c -> lin V (mkVerbC1 s1 s2 s3 c) ; mkV : Str -> Str -> Str -> Case -> V = \s1,s2,s3,c -> lin V (mkVerbC1 s1 s2 s3 c) ;
} ; } ;
mkV2 = overload { mkV2 = overload {
mkV2 : V -> V2 = \v -> lin V2 v ** { focus = acc_Prep } ; --mkV2 : V -> V2 = \v -> lin V2 (v ** {rightVal = acc_Prep}) ;
mkV2 : V -> Preposition -> V2 = \v,p -> lin V2 v ** { focus = p } ; --mkV2 : V -> Prep -> V2 = \v,p -> lin V2 (v ** {rightVal = p}) ;
mkV2 : V -> V2 = \v -> lin V2 {s = v.s ; leftVal = v.leftVal ; rightVal = acc_Prep} ;
mkV2 : V -> Prep -> V2 = \v,p -> lin V2 {s = v.s ; leftVal = v.leftVal ; rightVal = p} ;
} ; } ;
mkVS = overload { mkVS = overload {
mkVS : V -> Subj -> VS = \v,c -> lin VS v ** { conj = c ; topic = Nom } ; mkVS : V -> Subj -> VS = \v,c -> lin VS {s = v.s ; leftVal = Nom ; conj = c} ;
mkVS : V -> Subj -> Case -> VS = \v,c,s -> lin VS v ** { conj = c ; topic = s } ; mkVS : V -> Subj -> Case -> VS = \v,c,s -> lin VS {s = v.s ; leftVal = s ; conj = c} ;
} ; } ;
mkVQ = overload { mkVQ = overload {
mkVQ : V -> VQ = \v -> lin VQ v ** { topic = Nom } ; mkVQ : V -> VQ = \v -> lin VQ {s = v.s ; leftVal = Nom} ;
mkVQ : V -> Case -> VQ = \v,c -> lin VQ v ** { topic = c } ; mkVQ : V -> Case -> VQ = \v,c -> lin VQ {s = v.s ; leftVal = c} ;
} ; } ;
mkVV = overload { mkVV = overload {
mkVV : V -> VV = \v -> lin VV v ** { topic = Nom } ; mkVV : V -> VV = \v -> lin VV {s = v.s ; leftVal = Nom} ;
mkVV : V -> Case -> VV = \v,c -> lin VV v ** { topic = c } ; mkVV : V -> Case -> VV = \v,c -> lin VV {s = v.s ; leftVal = c} ;
} ; } ;
mkV3 = overload { mkV3 = overload {
mkV3 : V -> Preposition -> Preposition -> V3 = \v,p1,p2 -> mkV3 : V -> V3 = \v -> lin V3 (v ** {rightVal1 = acc_Prep ; rightVal2 = dat_Prep}) ;
lin V3 v ** { topic = Nom ; focus1 = p1 ; focus2 = p2 } ; mkV3 : V -> Prep -> Prep -> V3 = \v,p1,p2 -> lin V3 (v ** {rightVal1 = p1 ; rightVal2 = p2}) ;
mkV3 : V -> Case -> Preposition -> Preposition -> V3 = \v,c,p1,p2 ->
lin V3 v ** { topic = c ; focus1 = p1 ; focus2 = p2 } ;
} ; } ;
mkVA : V -> VA = \v -> lin VA v ; mkVA : V -> VA = \v -> lin VA v ;
mkV2S : V -> Subj -> Preposition -> V2S = \v,c,o -> lin V2S v ** { conj = c ; focus = o } ; mkV2A : V -> Prep -> V2A = \v,p -> lin V2A (v ** {rightVal = p}) ;
mkV2A : V -> Preposition -> V2A = \v,o -> lin V2A v ** { focus = o } ; mkV2Q : V -> Prep -> V2Q = \v,p -> lin V2Q (v ** {rightVal = p}) ;
mkV2Q : V -> Preposition -> V2Q = \v,o -> lin V2Q v ** { focus = o } ; mkV2V : V -> Prep -> V2V = \v,p -> lin V2V (v ** {rightVal = p}) ;
mkV2V : V -> Preposition -> V2V = \v,o -> lin V2V v ** { focus = o } ;
mkCAdv : Str -> Str -> Degree -> CAdv = \s,p,d -> lin CAdv { s = s ; prep = p ; deg = d } ; mkV2S : V -> Subj -> Prep -> V2S = \v,c,p -> lin V2S (v ** {conj = c ; rightVal = p}) ;
-- Prepositions
mkPrep = overload { mkPrep = overload {
mkPrep : Str -> Case -> Case -> Preposition = \prep,sg,pl -> mkPrep : Str -> Case -> Case -> Prep = \p,sg,pl -> lin Prep {s = p ; c = table {Sg => sg ; Pl => pl}} ;
lin Prep { s = prep ; c = table { Sg => sg ; Pl => pl } } ; mkPrep : Case -> Prep = \c -> lin Prep {s = [] ; c = \\_ => c} ;
mkPrep : Case -> Preposition = \c -> lin Prep { s = [] ; c = table { _ => c } } ;
} ; } ;
-- empty fake prepositions for valences nom_Prep : Prep = mkPrep Nom ;
-- rections that are expressed by simple cases without any prepositions gen_Prep : Prep = mkPrep Gen ;
nom_Prep = mkPrep Nom ; dat_Prep : Prep = mkPrep Dat ;
gen_Prep = mkPrep Gen ; acc_Prep : Prep = mkPrep Acc ;
dat_Prep = mkPrep Dat ; loc_Prep : Prep = mkPrep Loc ;
acc_Prep = mkPrep Acc ;
loc_Prep = mkPrep Loc ; -- Adverbs
mkAdv : Str -> Adv = \x -> lin Adv (ss x) ; mkAdv : Str -> Adv = \x -> lin Adv (ss x) ;
mkAdV : Str -> AdV = \x -> lin AdV (ss x) ; mkAdV : Str -> AdV = \x -> lin AdV (ss x) ;
mkAdA : Str -> AdA = \x -> lin AdA (ss x) ; mkAdA : Str -> AdA = \x -> lin AdA (ss x) ;
mkAdN : Str -> AdN = \x -> lin AdN (ss x) ; mkAdN : Str -> AdN = \x -> lin AdN (ss x) ;
mkCAdv : Str -> Str -> Degree -> CAdv = \s,p,d -> lin CAdv {s = s ; prep = p ; deg = d} ;
-- Conjunctions
mkConj = overload { mkConj = overload {
mkConj : Str -> Conj = \y -> mk2Conj [] y Pl ; mkConj : Str -> Conj = \c -> mk2Conj [] c Pl ;
mkConj : Str -> Number -> Conj = \y,n -> mk2Conj [] y n ; mkConj : Str -> Number -> Conj = \c,n -> mk2Conj [] c n ;
mkConj : Str -> Str -> Conj = \x,y -> mk2Conj x y Pl ;
mkConj : Str -> Str -> Conj = \c1,c2 -> mk2Conj c1 c2 Pl ;
mkConj : Str -> Str -> Number -> Conj = mk2Conj ; mkConj : Str -> Str -> Number -> Conj = mk2Conj ;
} ; } ;
mk2Conj : Str -> Str -> Number -> Conj = \x,y,n -> lin Conj (sd2 x y ** { num = n }) ; mk2Conj : Str -> Str -> Number -> Conj = \c1,c2,n -> lin Conj (sd2 c1 c2 ** {num = n}) ;
viens = mkNumSpec "viens" "pirmais" "vien" "" Sg ; -- Numerals: need review (TODO)
mkNumReg : Str -> Str -> Number -> { s : DForm => CardOrd => Gender => Case => Str } = mkNumReg : Str -> Str -> Number -> { s : DForm => CardOrd => Gender => Case => Str } =
\pieci,piektais,n -> mkNumSpec pieci piektais (cutStem pieci) (cutStem pieci) n ; \pieci,piektais,n -> mkNumSpec pieci piektais (cutStem pieci) (cutStem pieci) n ;
@@ -193,6 +198,8 @@ oper
} }
} ; } ;
viens = mkNumSpec "viens" "pirmais" "vien" "" Sg ;
simts : CardOrd => Gender => Number => Case => Str = simts : CardOrd => Gender => Number => Case => Str =
let let
card = mkNoun_D1 "simts" ; card = mkNoun_D1 "simts" ;

44
lib/src/latvian/ParadigmsVerbsLav.gf
View File

@@ -9,35 +9,35 @@ oper
Verb_TMP : Type = {s : VForm => Str} ; Verb_TMP : Type = {s : VForm => Str} ;
-- Second and third conjugations -- Second and third conjugations
mkVerb : Str -> Conjugation -> Case -> Verb = \lemma,conj,topic -> { mkVerb : Str -> Conjugation -> Case -> Verb = \lemma,conj,leftVal -> {
s = table { s = table {
Pos => (mkVerb_Pos lemma conj).s ; Pos => (mkVerb_Pos lemma conj).s ;
Neg => (filter_Neg (mkVerb_Pos ("ne"+lemma) conj)).s Neg => (filter_Neg (mkVerb_Pos ("ne"+lemma) conj)).s
} ; } ;
topic = topic leftVal = leftVal
} ; } ;
-- First conjugation -- First conjugation
mkVerbC1 : Str -> Str -> Str -> Case -> Verb = \lemma,lemma2,lemma3,topic -> { mkVerbC1 : Str -> Str -> Str -> Case -> Verb = \lemma,lemma2,lemma3,leftVal -> {
s = table { s = table {
Pos => (mkVerbC1_Pos lemma lemma2 lemma3).s ; Pos => (mkVerbC1_Pos lemma lemma2 lemma3).s ;
Neg => (filter_Neg (mkVerbC1_Pos ("ne"+lemma) ("ne"+lemma2) ("ne"+lemma3))).s Neg => (filter_Neg (mkVerbC1_Pos ("ne"+lemma) ("ne"+lemma2) ("ne"+lemma3))).s
} ; } ;
topic = topic leftVal = leftVal
} ; } ;
mkVerb_Pos : Str -> Conjugation -> Verb_TMP = \lemma,conj -> mkVerb_Pos : Str -> Conjugation -> Verb_TMP = \lemma,conj ->
case lemma of { case lemma of {
-- TODO: "ir" => -- TODO: "ir"
s + ("t") => mkRegVerb lemma conj ; s + ("ties") => mkReflVerb lemma conj ;
s + ("ties") => mkReflVerb lemma conj _ => mkRegVerb lemma conj
} ; } ;
mkVerbC1_Pos : Str -> Str -> Str -> Verb_TMP = \lemma,lemma2,lemma3 -> mkVerbC1_Pos : Str -> Str -> Str -> Verb_TMP = \lemma,lemma2,lemma3 ->
case lemma of { case lemma of {
-- TODO: "ir" => -- TODO: "ir"
s + ("t") => mkVerb_C1 lemma lemma2 lemma3 ; s + ("ties") => mkVerb_C1_Refl lemma lemma2 lemma3 ;
s + ("ties") => mkVerb_C1_Refl lemma lemma2 lemma3 _ => mkVerb_C1 lemma lemma2 lemma3
} ; } ;
mkRegVerb : Str -> Conjugation -> Verb_TMP = \lemma,conj -> mkRegVerb : Str -> Conjugation -> Verb_TMP = \lemma,conj ->
@@ -344,19 +344,19 @@ oper
} }
} ; } ;
mkVerb_Irreg : Str -> Case -> Verb = \lemma,topic -> mkVerb_Irreg : Str -> Case -> Verb = \lemma,leftVal ->
case lemma of { case lemma of {
"būt" => mkVerb_Irreg_Be topic ; "būt" => mkVerb_Irreg_Be leftVal ;
"iet" => mkVerb_Irreg_Go topic ; "iet" => mkVerb_Irreg_Go leftVal ;
#prefix + "iet" => mkVerb_Irreg_Go_Prefix (Predef.tk 3 lemma) topic ; #prefix + "iet" => mkVerb_Irreg_Go_Prefix (Predef.tk 3 lemma) leftVal ;
"gulēt" => mkVerb_Irreg_Sleep topic "gulēt" => mkVerb_Irreg_Sleep leftVal
-- FIXME: "gulēt" should be treated as a regular verb (C3: gulēt, sēdēt etc.) -- FIXME: "gulēt" should be treated as a regular verb (C3: gulēt, sēdēt etc.)
-- TODO: add "dot"/Give (+prefix, +refl) -- TODO: add "dot"/Give (+prefix, +refl)
-- TODO: multiple prefixes -- TODO: multiple prefixes
-- TODO: move to IrregLav? -- TODO: move to IrregLav?
} ; } ;
mkVerb_Irreg_Be : Case -> Verb = \topic -> { mkVerb_Irreg_Be : Case -> Verb = \leftVal -> {
s = table { s = table {
Pos => table { Pos => table {
VInd P1 Sg Pres => "esmu" ; VInd P1 Sg Pres => "esmu" ;
@@ -378,12 +378,12 @@ oper
x => (mkVerb_C1 "nebūt" "neesu" "nebiju").s ! x -- the incorrect 'neesu' will be overriden x => (mkVerb_C1 "nebūt" "neesu" "nebiju").s ! x -- the incorrect 'neesu' will be overriden
} }
} ; } ;
topic = topic leftVal = leftVal
} ; } ;
mkVerb_Irreg_Go : Case -> Verb = \topic -> mkVerb_Irreg_Go_Prefix "" topic ; mkVerb_Irreg_Go : Case -> Verb = \leftVal -> mkVerb_Irreg_Go_Prefix "" leftVal ;
mkVerb_Irreg_Go_Prefix : Str -> Case -> Verb = \pref,topic -> { mkVerb_Irreg_Go_Prefix : Str -> Case -> Verb = \pref,leftVal -> {
s = table { s = table {
Pos => table { Pos => table {
VInd P3 _ Pres => pref + "iet" ; VInd P3 _ Pres => pref + "iet" ;
@@ -397,10 +397,10 @@ oper
x => (mkVerb_C1 ("ne" + pref + "iet") ("ne" + pref + "eju") ("ne" + pref + "gāju")).s ! x x => (mkVerb_C1 ("ne" + pref + "iet") ("ne" + pref + "eju") ("ne" + pref + "gāju")).s ! x
} }
} ; } ;
topic = topic leftVal = leftVal
} ; } ;
mkVerb_Irreg_Sleep : Case -> Verb = \topic -> { mkVerb_Irreg_Sleep : Case -> Verb = \leftVal -> {
s = table { s = table {
Pos => table { Pos => table {
VInd P2 Sg Pres => (mkVerb_C3 "gulēt").s ! VInd P2 Sg Pres ; VInd P2 Sg Pres => (mkVerb_C3 "gulēt").s ! VInd P2 Sg Pres ;
@@ -429,7 +429,7 @@ oper
x => (mkVerb_C3 "negulēt").s ! x x => (mkVerb_C3 "negulēt").s ! x
} }
} ; } ;
topic = topic leftVal = leftVal
} ; } ;
-- Auxiliaries: palatalization rules -- Auxiliaries: palatalization rules

2
lib/src/latvian/QuestionLav.gf
View File

@@ -15,7 +15,7 @@ flags
lin lin
QuestCl cl = { s = \\m,p => "vai" ++ cl.s ! m ! p } ; QuestCl cl = { s = \\m,p => "vai" ++ cl.s ! m ! p } ;
QuestVP ip vp = { s = \\m,p => ip.s ! Nom ++ buildVerb vp.v m p (AgrP3 ip.num Masc) Pos vp.agr.focus } ; QuestVP ip vp = { s = \\m,p => ip.s ! Nom ++ buildVerb vp.v m p (AgrP3 ip.num Masc) Pos vp.rightPol } ;
QuestSlash ip slash = { s = \\m,p => slash.prep.s ++ ip.s ! (slash.prep.c ! ip.num) ++ slash.s ! m ! p } ; QuestSlash ip slash = { s = \\m,p => slash.prep.s ++ ip.s ! (slash.prep.c ! ip.num) ++ slash.s ! m ! p } ;

8
lib/src/latvian/RelativeLav.gf
View File

@@ -20,7 +20,7 @@ oper
-- TODO: PassV2 verbs jāsaskaņo ar objektu, nevis subjektu (by8means_Prep: AgP3 Sg Masc) - done? -- TODO: PassV2 verbs jāsaskaņo ar objektu, nevis subjektu (by8means_Prep: AgP3 Sg Masc) - done?
mkRelClause : RP -> CatLav.VP -> RCl = \rp,vp -> mkRelClause : RP -> CatLav.VP -> RCl = \rp,vp ->
let subjInTopic : Bool = case <vp.voice, vp.topic> of { let subjInTopic : Bool = case <vp.voice, vp.leftVal> of {
<Act, Nom> => True ; <Act, Nom> => True ;
<Act, _ > => False ; <Act, _ > => False ;
<Pass, Acc> => False ; <Pass, Acc> => False ;
@@ -30,11 +30,11 @@ oper
s = \\mood,pol,agr => s = \\mood,pol,agr =>
case mood of { -- subject case mood of { -- subject
Deb _ _ => rp.s ! Masc ! Dat ; --# notpresent Deb _ _ => rp.s ! Masc ! Dat ; --# notpresent
_ => rp.s ! Masc ! vp.topic _ => rp.s ! Masc ! vp.leftVal
} ++ } ++
case subjInTopic of { -- verb case subjInTopic of { -- verb
True => buildVerb vp.v mood pol (AgrP3 (fromAgr agr).num (fromAgr agr).gend) Pos vp.agr.focus ; True => buildVerb vp.v mood pol (AgrP3 (fromAgr agr).num (fromAgr agr).gend) Pos vp.rightPol ;
False => buildVerb vp.v mood pol vp.agr.subj Pos vp.agr.focus False => buildVerb vp.v mood pol vp.rightAgr Pos vp.rightPol
} ++ } ++
vp.compl ! agr -- object(s), complements, adverbial modifiers vp.compl ! agr -- object(s), complements, adverbial modifiers
} ; } ;

79
lib/src/latvian/ResLav.gf
View File

@@ -38,7 +38,7 @@ param
Ind Anteriority Tense Ind Anteriority Tense
| Rel Anteriority Tense --# notpresent | Rel Anteriority Tense --# notpresent
| Deb Anteriority Tense --# notpresent | Deb Anteriority Tense --# notpresent
| Condit Anteriority --# notpresent | Condit Anteriority --# notpresent
; ;
VForm = VForm =
@@ -50,7 +50,7 @@ param
| VDebRel -- the relative subtype of debitive | VDebRel -- the relative subtype of debitive
| VPart Voice Gender Number Case ; | VPart Voice Gender Number Case ;
-- Number and Gender has to be agreed in predicative nominal clauses -- Number and gender has to be agreed in predicative nominal clauses
Agreement = Agreement =
AgrP1 Number Gender AgrP1 Number Gender
| AgrP2 Number Gender | AgrP2 Number Gender
@@ -74,46 +74,46 @@ oper
Adjective : Type = { s : AForm => Str } ; Adjective : Type = { s : AForm => Str } ;
Preposition : Type = { s : Str ; c : Number => Case } ; Preposition : Type = { s : Str ; c : Number => Case } ;
-- For simple case-based valences, the preposition is empty ([])
-- TODO: position of prepositions (pre or post) ?
Verb : Type = { s : Polarity => VForm => Str ; topic : Case } ; Verb : Type = { s : Polarity => VForm => Str ; leftVal : Case } ;
VP : Type = { VP : Type = {
v : Verb ; v : Verb ;
agr : { compl : Agreement => Str ; -- the subject-complement agreement
subj : Agreement ; -- the verb-subject agreement (the subject can be in the focus part of a clause) voice : Voice ;
focus : Polarity -- the verb-focus agreement (for the double negation) -- TODO: jāpārsauc par pol, lai nejūk citur leftVal : Case ; -- the left valence (typically, the subject)
} ; rightAgr : Agreement ; -- for the potential subject-verb agreement (the subject can be on the right side)
compl : Agreement => Str ; -- the complement-subject agreement rightPol : Polarity -- for the potential double negation
voice : Voice ;
topic : Case -- the valence of the topic NP (typically, the subject)
} ; } ;
VPSlash : Type = VP ** { focus : Preposition } ; -- the valence of the focus NP (typically, the object) VPSlash : Type = VP ** { rightVal : Preposition } ; -- the right valence (typically, the object)
insertObj : (Agreement => Str) -> VP -> VP = \obj,vp -> {
v = vp.v ;
agr = vp.agr ;
compl = \\agr => vp.compl ! agr ++ obj ! agr ;
voice = vp.voice ;
topic = vp.topic
} ;
insertObjC : (Agreement => Str) -> VPSlash -> VPSlash = \obj,vp ->
insertObj obj vp ** { focus = vp.focus } ;
insertObjPre : (Agreement => Str) -> VP -> VP = \obj,vp -> {
v = vp.v ;
agr = vp.agr ;
compl = \\agr => obj ! agr ++ vp.compl ! agr ;
voice = vp.voice ;
topic = vp.topic
} ;
buildVP : VP -> Polarity -> VForm -> Agreement -> Str = \vp,pol,vf,agr -> buildVP : VP -> Polarity -> VForm -> Agreement -> Str = \vp,pol,vf,agr ->
vp.v.s ! pol ! vf ++ vp.compl ! agr ; vp.v.s ! pol ! vf ++ vp.compl ! agr ;
insertObj : (Agreement => Str) -> VP -> VP = \obj,vp -> {
v = vp.v ;
compl = \\agr => vp.compl ! agr ++ obj ! agr ;
voice = vp.voice ;
leftVal = vp.leftVal ;
rightAgr = vp.rightAgr ;
rightPol = vp.rightPol
} ;
insertObjPre : (Agreement => Str) -> VP -> VP = \obj,vp -> {
v = vp.v ;
compl = \\agr => obj ! agr ++ vp.compl ! agr ;
voice = vp.voice ;
leftVal = vp.leftVal ;
rightAgr = vp.rightAgr ;
rightPol = vp.rightPol
} ;
insertObjSlash : (Agreement => Str) -> VPSlash -> VPSlash = \obj,vp ->
insertObj obj vp ** { rightVal = vp.rightVal } ;
getInf : Verb -> Str = \v -> v.s ! Pos ! VInf ;
toAgr : Person -> Number -> Gender -> Agreement = \pers,num,gend -> toAgr : Person -> Number -> Gender -> Agreement = \pers,num,gend ->
case pers of { case pers of {
P1 => AgrP1 num gend ; P1 => AgrP1 num gend ;
@@ -132,16 +132,15 @@ oper
let let
a1 = fromAgr agr1 ; a1 = fromAgr agr1 ;
a2 = fromAgr agr2 a2 = fromAgr agr2
in in toAgr
toAgr (conjPerson a1.pers a2.pers)
(conjPerson a1.pers a2.pers) -- FIXME: personu apvienošana ir tricky un ir jāuztaisa korekti (conjNumber a1.num a2.num)
(conjNumber a1.num a2.num) (conjGender a1.gend a2.gend) ;
(conjGender a1.gend a2.gend) ;
conjGender : Gender -> Gender -> Gender = \gend1,gend2 -> conjGender : Gender -> Gender -> Gender = \gend1,gend2 ->
case gend1 of { case gend1 of {
Fem => gend2 ; Fem => gend2 ;
_ => Masc Masc => Masc
} ; } ;
vowel : pattern Str = #("a"|"ā"|"e"|"ē"|"i"|"ī"|"o"|"u"|"ū") ; vowel : pattern Str = #("a"|"ā"|"e"|"ē"|"i"|"ī"|"o"|"u"|"ū") ;

23
lib/src/latvian/SentenceLav.gf
View File

@@ -18,7 +18,7 @@ lin
ImpVP vp = { s = \\pol,num => vp.v.s ! pol ! (VImp num) ++ vp.compl ! (AgrP2 num Masc) } ; ImpVP vp = { s = \\pol,num => vp.v.s ! pol ! (VImp num) ++ vp.compl ! (AgrP2 num Masc) } ;
SlashVP np vp = mkClause np vp ** { prep = vp.focus } ; SlashVP np vp = mkClause np vp ** { prep = vp.rightVal } ;
AdvSlash slash adv = { AdvSlash slash adv = {
s = \\m,p => slash.s ! m ! p ++ adv.s ; s = \\m,p => slash.s ! m ! p ++ adv.s ;
@@ -33,10 +33,11 @@ lin
np np
(lin VP { (lin VP {
v = vs ; v = vs ;
agr = { subj = variants {} ; focus = Pos } ;
compl = \\_ => "," ++ vs.conj.s ++ sslash.s ; compl = \\_ => "," ++ vs.conj.s ++ sslash.s ;
voice = Act ; voice = Act ;
topic = vs.topic leftVal = vs.leftVal ;
rightAgr = AgrP3 Sg Masc ;
rightPol = Pos ;
}) ** { prep = sslash.prep } ; }) ** { prep = sslash.prep } ;
-- ComplVS v s = { v = v ; compl = \\_ => "," ++ v.subj.s ++ s.s } ; -- ComplVS v s = { v = v ; compl = \\_ => "," ++ v.subj.s ++ s.s } ;
@@ -65,27 +66,27 @@ lin
oper oper
-- TODO: PassV2 verbs jāsaskaņo ar objektu, nevis subjektu (by8means_Prep: AgP3 Sg Masc) -- TODO: PassV2 verbs jāsaskaņo ar objektu, nevis subjektu (by8means_Prep: AgP3 Sg Masc)
mkClause : NP -> CatLav.VP -> Cl = \np,vp -> mkClause : NP -> CatLav.VP -> Cl = \np,vp ->
let agr : Agreement = case <vp.voice, vp.topic> of { let agr : Agreement = case <vp.voice, vp.leftVal> of {
<Act, Nom> => np.agr ; <Act, Nom> => np.agr ;
<Act, _ > => vp.agr.subj ; <Act, _ > => vp.rightAgr ;
<Pass, Acc> => vp.agr.subj ; <Pass, Acc> => vp.rightAgr ;
<Pass, _ > => np.agr <Pass, _ > => np.agr
} }
in lin Cl { in lin Cl {
s = \\mood,pol => s = \\mood,pol =>
case mood of { -- subject case mood of { -- subject
Deb _ _ => np.s ! Dat ; --# notpresent Deb _ _ => np.s ! Dat ; --# notpresent
_ => np.s ! vp.topic _ => np.s ! vp.leftVal
} ++ } ++
buildVerb vp.v mood pol agr np.pol vp.agr.focus ++ -- verb buildVerb vp.v mood pol agr np.pol vp.rightPol ++ -- verb
vp.compl ! np.agr -- object(s), complements, adverbial modifiers vp.compl ! np.agr -- object(s), complements, adverbial modifiers
} ; } ;
-- FIXME: quick&dirty - lai kompilētos pret RGL API -- FIXME: quick&dirty - lai kompilētos pret RGL API
-- Eng: PredSCVP sc vp = mkClause sc.s (agrP3 Sg) vp -- Eng: PredSCVP sc vp = mkClause sc.s (agrP3 Sg) vp
-- Ar SC nav iespējams neko saskaņot (sk. Cat.gf un Common.gf) -- Ar SC nav iespējams neko saskaņot (sk. Cat.gf un Common.gf)
mkClauseSC : SC -> CatLav.VP -> Cl = \sc,vp -> lin Cl { mkClauseSC : SC -> CatLav.VP -> Cl = \sc,vp -> lin Cl {
s = \\mood,pol => sc.s ++ buildVerb vp.v mood pol (AgrP3 Sg Masc) Pos vp.agr.focus ++ vp.compl ! (AgrP3 Sg Masc) s = \\mood,pol => sc.s ++ buildVerb vp.v mood pol (AgrP3 Sg Masc) Pos vp.rightPol ++ vp.compl ! (AgrP3 Sg Masc)
} ; } ;
} }

2
lib/src/latvian/StructuralLav.gf
View File

@@ -241,7 +241,7 @@ lin
if_Subj = ss "ja" ; if_Subj = ss "ja" ;
that_Subj = ss "ka" ; that_Subj = ss "ka" ;
all_Predet = { s = table { Masc => "visi" ; Fem => "visas" } } ; all_Predet = { s = table { Masc => "visi" ; Fem => "visas" } } ; -- FIXME: cases
only_Predet = { s = table { _ => "tikai"} } ; only_Predet = { s = table { _ => "tikai"} } ;
most_Predet = { s = table { _ => "vairums"} } ; most_Predet = { s = table { _ => "vairums"} } ;

270
lib/src/latvian/VerbLav.gf
View File

@@ -25,179 +25,197 @@ lin
-- V -> VP -- V -> VP
-- e.g. 'sleep' -- e.g. 'sleep'
UseV v = { UseV v = {
v = v ; v = v ;
agr = { subj = defaultAgr ; focus = Pos } ; compl = \\_ => [] ;
compl = \\_ => [] ; voice = Act ;
voice = Act ; leftVal = v.leftVal ;
topic = v.topic rightAgr = AgrP3 Sg Masc ;
rightPol = Pos
} ; } ;
-- VV -> VP -> VP -- VV -> VP -> VP
-- e.g. 'want to run' -- e.g. 'want to run'
ComplVV vv vp = { ComplVV vv vp = {
v = vv ; v = vv ;
agr = { subj = defaultAgr ; focus = Pos } ; compl = \\agr => buildVP vp Pos VInf agr ;
compl = \\agr => buildVP vp Pos VInf agr ; voice = Act ;
voice = Act ; leftVal = vv.leftVal ;
topic = vv.topic rightAgr = AgrP3 Sg Masc ;
rightPol = Pos
} ; } ;
-- VS -> S -> VP -- VS -> S -> VP
-- e.g. 'say that she runs' -- e.g. 'say that she runs'
ComplVS vs s = { ComplVS vs s = {
v = vs ; v = vs ;
agr = { subj = defaultAgr ; focus = Pos } ; compl = \\_ => "," ++ vs.conj.s ++ s.s ;
compl = \\_ => "," ++ vs.conj.s ++ s.s ; voice = Act ;
voice = Act ; leftVal = vs.leftVal ;
topic = vs.topic rightAgr = AgrP3 Sg Masc ;
rightPol = Pos
} ; } ;
-- VQ -> QS -> VP -- VQ -> QS -> VP
-- e.g. 'wonder who runs' -- e.g. 'wonder who runs'
ComplVQ vq qs = { ComplVQ vq qs = {
v = vq ; v = vq ;
agr = { subj = defaultAgr ; focus = Pos } ; compl = \\_ => "," ++ qs.s ;
compl = \\_ => "," ++ qs.s ; voice = Act ;
voice = Act ; leftVal = vq.leftVal ;
topic = vq.topic rightAgr = AgrP3 Sg Masc ;
rightPol = Pos
} ; } ;
-- VA -> AP -> VP -- VA -> AP -> VP
-- e.g. '(they) become red' -- e.g. '(they) become red'
ComplVA va ap = { ComplVA va ap = {
v = va ; v = va ;
agr = { subj = defaultAgr ; focus = Pos } ; compl = \\agr => ap.s ! Indef ! (fromAgr agr).gend ! (fromAgr agr).num ! Nom ;
compl = \\agr => ap.s ! Indef ! (fromAgr agr).gend ! (fromAgr agr).num ! Nom ; voice = Act ;
voice = Act ; leftVal = va.leftVal ;
topic = va.topic rightAgr = AgrP3 Sg Masc ;
rightPol = Pos
} ; } ;
-- V2 -> VPSlash -- V2 -> VPSlash
-- e.g. 'love (it)' -- e.g. 'love (it)'
SlashV2a v2 = { SlashV2a v2 = {
v = v2 ; v = v2 ;
agr = { subj = defaultAgr ; focus = Pos } ; compl = \\_ => [] ; -- will be overriden
compl = \\_ => [] ; voice = Act ;
voice = Act ; leftVal = v2.leftVal ;
topic = v2.topic ; rightAgr = AgrP3 Sg Masc ; -- will be overriden
focus = v2.focus rightPol = Pos ; -- will be overriden
rightVal = v2.rightVal
} ; } ;
-- V3 -> NP -> VPSlash -- V3 -> NP -> VPSlash
-- e.g. 'give it (to her)' -- e.g. 'give it (to her)'
Slash2V3 v3 np = insertObjC Slash2V3 v3 np = insertObjSlash
(\\_ => v3.focus2.s ++ np.s ! (v3.focus2.c ! (fromAgr np.agr).num)) (\\_ => v3.rightVal2.s ++ np.s ! (v3.rightVal2.c ! (fromAgr np.agr).num))
{ {
v = v3 ; v = v3 ;
agr = { subj = np.agr ; focus = np.pol } ; compl = \\_ => [] ; -- will be overriden
compl = \\_ => [] ; voice = Act ;
voice = Act ; leftVal = v3.leftVal ;
topic = v3.topic ; rightAgr = np.agr ;
focus = v3.focus1 rightPol = np.pol ;
rightVal = v3.rightVal1
} ; } ;
-- FIXME: "vīrietis runā par ābolus ar sievieti" ("a man talks to a woman about apples") -- FIXME: "vīrietis runā par ābolus ar sievieti" ("a man talks to a woman about apples")
-- FIXME: the order of objects (?) -- FIXME: the order of objects (?)
-- TODO: test val (P1 un P2) un objNeg -- FIXME: Slash2V3 = Slash3V3 (?)
-- V3 -> NP -> VPSlash -- V3 -> NP -> VPSlash
-- e.g. 'give (it) to her' -- e.g. 'give (it) to her'
Slash3V3 v3 np = insertObjC Slash3V3 v3 np = insertObjSlash
(\\_ => v3.focus2.s ++ np.s ! (v3.focus2.c ! (fromAgr np.agr).num)) (\\_ => v3.rightVal2.s ++ np.s ! (v3.rightVal2.c ! (fromAgr np.agr).num))
{ {
v = v3 ; v = v3 ;
agr = { subj = np.agr ; focus = np.pol } ; compl = \\_ => [] ; -- will be overriden
compl = \\_ => [] ; voice = Act ;
voice = Act ; leftVal = v3.leftVal ;
topic = v3.topic ; rightAgr = np.agr ;
focus = v3.focus1 rightPol = np.pol ;
rightVal = v3.rightVal1
} ; } ;
-- TODO: val other than P3 Sg Masc
-- TODO: test objNeg
-- V2V -> VP -> VPSlash -- V2V -> VP -> VPSlash
-- e.g. 'beg (her) to go' -- e.g. 'beg (her) to go'
SlashV2V v2v vp = { SlashV2V v2v vp = {
v = v2v ; v = v2v ;
agr = { subj = defaultAgr ; focus = Pos } ; compl = \\agr => buildVP vp Pos VInf agr ;
compl = \\agr => buildVP vp Pos VInf agr ; voice = Act ;
voice = Act ; leftVal = v2v.leftVal ;
topic = v2v.topic ; rightAgr = AgrP3 Sg Masc ;
focus = v2v.focus rightPol = Pos ;
rightVal = v2v.rightVal
} ; } ;
-- V2S -> S -> VPSlash -- V2S -> S -> VPSlash
-- e.g. 'answer (to him) that it is good' -- e.g. 'answer (to him) that it is good'
SlashV2S v2s s = { SlashV2S v2s s = {
v = v2s ; v = v2s ;
agr = { subj = defaultAgr ; focus = Pos } ; compl = \\_ => "," ++ v2s.conj.s ++ s.s ;
compl = \\_ => "," ++ v2s.conj.s ++ s.s ; voice = Act ;
voice = Act ; leftVal = v2s.leftVal ;
topic = v2s.topic ; rightAgr = AgrP3 Sg Masc ;
focus = v2s.focus rightPol = Pos ;
rightVal = v2s.rightVal
} ; } ;
-- V2Q -> QS -> VPSlash -- V2Q -> QS -> VPSlash
-- e.g. 'ask (him) who came' -- e.g. 'ask (him) who came'
SlashV2Q v2q qs = { SlashV2Q v2q qs = {
v = v2q ; v = v2q ;
agr = { subj = defaultAgr ; focus = Pos } ; compl = \\_ => "," ++ qs.s ;
compl = \\_ => "," ++ qs.s ; voice = Act ;
voice = Act ; leftVal = v2q.leftVal ;
topic = v2q.topic ; rightAgr = AgrP3 Sg Masc ;
focus = v2q.focus rightPol = Pos ;
rightVal = v2q.rightVal
} ; } ;
-- V2A -> AP -> VPSlash -- V2A -> AP -> VPSlash
-- e.g. 'paint (it) red' -- e.g. 'paint (it) red'
SlashV2A v2a ap = { SlashV2A v2a ap = {
v = v2a ; v = v2a ;
agr = { subj = defaultAgr ; focus = Pos } ; compl = \\agr => ap.s ! Indef ! (fromAgr agr).gend ! (fromAgr agr).num ! Nom ;
compl = \\agr => ap.s ! Indef ! (fromAgr agr).gend ! (fromAgr agr).num ! Nom ; voice = Act ;
voice = Act ; leftVal = v2a.leftVal ;
topic = v2a.topic ; rightAgr = AgrP3 Sg Masc ;
focus = v2a.focus rightPol = Pos ;
rightVal = v2a.rightVal
} ; } ;
-- VPSlash -> NP -> VP -- VPSlash -> NP -> VP
-- e.g. 'love it' -- e.g. 'love it'
ComplSlash vpslash np = ComplSlash vpslash np =
let agr : Agreement = np.agr in { let agr : Agreement = np.agr in {
v = vpslash.v ; v = vpslash.v ;
agr = { subj = agr ; focus = np.pol } ; {-
compl = \\agr => case vpslash.voice of { compl = \\agr => case vpslash.voice of {
Act => vpslash.focus.s ++ np.s ! (vpslash.focus.c ! (fromAgr agr).num) ; Act => vpslash.rightVal.s ++ np.s ! (vpslash.rightVal.c ! (fromAgr agr).num) ;
Pass => case vpslash.focus.c ! (fromAgr agr).num of { Pass => case vpslash.rightVal.c ! (fromAgr agr).num of {
Nom => np.s ! (vpslash.focus.c ! Sg) ; Nom => np.s ! (vpslash.rightVal.c ! Sg) ;
_ => vpslash.focus.s ++ np.s ! (vpslash.focus.c ! (fromAgr agr).num) _ => vpslash.rightVal.s ++ np.s ! (vpslash.rightVal.c ! (fromAgr agr).num)
} }
} ++ vpslash.compl ! agr ; } ++ vpslash.compl ! agr ;
voice = vpslash.voice ; -}
topic = vpslash.topic ; compl = \\agr => vpslash.rightVal.s ++
focus = vpslash.focus np.s ! (vpslash.rightVal.c ! (fromAgr agr).num) ++
vpslash.compl ! agr ;
voice = vpslash.voice ;
leftVal = vpslash.leftVal ;
rightAgr = np.agr ;
rightPol = np.pol ;
rightVal = vpslash.rightVal ;
} ; } ;
-- VV -> VPSlash -> VPSlash -- VV -> VPSlash -> VPSlash
-- e.g. 'want to buy' -- e.g. 'want to buy'
SlashVV vv vpslash = { SlashVV vv vpslash = {
v = vv ; v = vv ;
agr = { subj = defaultAgr ; focus = Pos } ; compl = \\agr => buildVP vpslash Pos VInf agr ;
compl = \\agr => buildVP vpslash Pos VInf agr ; voice = Act ;
voice = Act ; leftVal = vv.leftVal ;
topic = vv.topic ; rightAgr = AgrP3 Sg Masc ;
focus = defaultPrep rightPol = Pos ;
rightVal = nom_Prep
} ; } ;
-- V2V -> NP -> VPSlash -> VPSlash -- V2V -> NP -> VPSlash -> VPSlash
-- e.g. '-- beg me to buy' -- e.g. '-- beg me to buy'
SlashV2VNP v2v np vpslash = insertObjC SlashV2VNP v2v np vpslash = insertObjSlash
(\\_ => v2v.focus.s ++ np.s ! (v2v.focus.c ! (fromAgr np.agr).num)) (\\_ => v2v.rightVal.s ++ np.s ! (v2v.rightVal.c ! (fromAgr np.agr).num))
{ {
v = v2v ; v = v2v ;
agr = { subj = np.agr ; focus = np.pol } ; compl = \\agr => buildVP vpslash Pos VInf agr ;
compl = \\agr => buildVP vpslash Pos VInf agr ; voice = Act ;
voice = Act ; leftVal = v2v.leftVal ;
topic = v2v.topic ; rightAgr = np.agr ;
focus = v2v.focus rightPol = np.pol ;
rightVal = v2v.rightVal
} ; } ;
-- Other ways of forming verb phrases -- Other ways of forming verb phrases
@@ -205,28 +223,30 @@ lin
-- VPSlash -> VP -- VPSlash -> VP
-- e.g. 'love himself' -- e.g. 'love himself'
ReflVP vpslash = insertObjPre ReflVP vpslash = insertObjPre
(\\agr => vpslash.focus.s ++ reflPron ! (vpslash.focus.c ! (fromAgr agr).num)) (\\agr => vpslash.rightVal.s ++ reflPron ! (vpslash.rightVal.c ! (fromAgr agr).num))
vpslash ; vpslash ;
-- Comp -> VP -- Comp -> VP
-- e.g. 'be warm' -- e.g. 'be warm'
UseComp comp = { UseComp comp = {
v = mkV "būt" ; v = mkV "būt" ;
agr = { subj = defaultAgr ; focus = Pos } ; compl = \\agr => comp.s ! agr ;
compl = \\agr => comp.s ! agr ; voice = Act ;
voice = Act ; leftVal = Nom ;
topic = Nom rightAgr = AgrP3 Sg Masc ;
rightPol = Pos
} ; } ;
-- V2 -> VP -- V2 -> VP
-- e.g. 'be loved' -- e.g. 'be loved'
PassV2 v2 = { PassV2 v2 = {
v = v2 ; v = v2 ;
agr = { subj = defaultAgr ; focus = Pos } ; compl = \\_ => [] ;
compl = \\_ => [] ; voice = Pass ;
voice = Pass ; leftVal = v2.rightVal.c ! Sg ;
topic = v2.focus.c ! Sg ; rightAgr = AgrP3 Sg Masc ;
focus = mkPrep v2.topic rightPol = Pos
--rightVal = mkPrep v2.leftVal
} ; } ;
-- TODO: val - should not be overriden in ComplSlash etc.? -- TODO: val - should not be overriden in ComplSlash etc.?
-- TODO: val - P3 Sg Masc restriction - never used? -- TODO: val - P3 Sg Masc restriction - never used?
@@ -248,8 +268,8 @@ lin
-- VP -> Prep -> VPSlash -- VP -> Prep -> VPSlash
-- e.g. 'live in (it)' -- e.g. 'live in (it)'
VPSlashPrep vp prep = vp ** { focus = prep } ; VPSlashPrep vp prep = vp ** { rightVal = prep } ;
-- TODO: šajā brīdī ir jāignorē prep (by8agent_Prep); tas jāaizstāj ar v2.topic (?) -- TODO: šajā brīdī ir jāignorē prep (by8agent_Prep); tas jāaizstāj ar v2.left (?)
-- Tad varēs dzēst ārā komentāru pie StructuralLav.by8agent_Prep (?) -- Tad varēs dzēst ārā komentāru pie StructuralLav.by8agent_Prep (?)
-- Complements to copula -- Complements to copula
@@ -275,16 +295,12 @@ lin
oper oper
defaultAgr : Agreement = AgrP3 Sg Masc ; -- variants {}
defaultPrep : Preposition = nom_Prep ;
-- FIXME: the type of the participle form - depending on what?! (currently fixed) -- FIXME: the type of the participle form - depending on what?! (currently fixed)
buildVerb : Verb -> VMood -> Polarity -> Agreement -> Polarity -> Polarity -> Str = buildVerb : Verb -> VMood -> Polarity -> Agreement -> Polarity -> Polarity -> Str =
\v,mood,pol,agr,polTopic,polFocus -> \v,mood,pol,agr,leftPol,rightPol ->
let let
polFinal : Polarity = case <polTopic, polFocus> of { finalPol : Polarity = case <leftPol, rightPol> of {
-- double negation, if the topic/focus NP has a negated determiner <Neg, _> => Neg ; -- double negation, if the left/right NP has a negated determiner
<Neg, _> => Neg ;
<_, Neg> => Neg ; <_, Neg> => Neg ;
_ => pol _ => pol
} ; } ;
@@ -292,23 +308,23 @@ oper
; --# notpresent ; --# notpresent
part = v.s ! Pos ! (VPart Pass agr.gend agr.num Nom) --# notpresent part = v.s ! Pos ! (VPart Pass agr.gend agr.num Nom) --# notpresent
in case mood of { in case mood of {
Ind Simul tense => v.s ! polFinal ! (VInd agr.pers agr.num tense) Ind Simul tense => v.s ! finalPol ! (VInd agr.pers agr.num tense)
; --# notpresent ; --# notpresent
Ind Anter tense => (mkV "būt").s ! polFinal ! (VInd agr.pers agr.num tense) ++ part ; --# notpresent Ind Anter tense => (mkV "būt").s ! finalPol ! (VInd agr.pers agr.num tense) ++ part ; --# notpresent
-- FIXME(?): Rel _ Past => ... -- FIXME(?): Rel _ Past => ...
Rel _ Past => NON_EXISTENT ; --# notpresent Rel _ Past => NON_EXISTENT ; --# notpresent
Rel Simul tense => v.s ! polFinal ! (VRel tense) ; --# notpresent Rel Simul tense => v.s ! finalPol ! (VRel tense) ; --# notpresent
Rel Anter tense => (mkV "būt").s ! polFinal ! (VRel tense) ++ part ; --# notpresent Rel Anter tense => (mkV "būt").s ! finalPol ! (VRel tense) ++ part ; --# notpresent
Deb Simul tense => (mkV "būt").s ! polFinal ! (VInd P3 Sg tense) ++ --# notpresent Deb Simul tense => (mkV "būt").s ! finalPol ! (VInd P3 Sg tense) ++ --# notpresent
v.s ! Pos ! VDeb ; --# notpresent v.s ! Pos ! VDeb ; --# notpresent
Deb Anter tense => (mkV "būt").s ! polFinal ! (VInd P3 Sg tense) ++ --# notpresent Deb Anter tense => (mkV "būt").s ! finalPol ! (VInd P3 Sg tense) ++ --# notpresent
(mkV "būt").s ! Pos ! (VPart Pass Masc Sg Nom) ++ --# notpresent (mkV "būt").s ! Pos ! (VPart Pass Masc Sg Nom) ++ --# notpresent
v.s ! Pos ! VDeb ; --# notpresent v.s ! Pos ! VDeb ; --# notpresent
Condit Simul => v.s ! polFinal ! (VInd agr.pers agr.num ParamX.Cond) ; --# notpresent Condit Simul => v.s ! finalPol ! (VInd agr.pers agr.num ParamX.Cond) ; --# notpresent
Condit Anter => (mkV "būt").s ! polFinal ! (VInd agr.pers agr.num ParamX.Cond) ++ part --# notpresent Condit Anter => (mkV "būt").s ! finalPol ! (VInd agr.pers agr.num ParamX.Cond) ++ part --# notpresent
} ; } ;
} }