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

added missing paradigm functions

Browse Source
This commit is contained in:
Krasimir Angelov
2025-02-07 18:24:27 +01:00
parent 186a12df0c
commit 777e572681
1 changed files with 216 additions and 207 deletions
Download Patch File Download Diff File Expand all files Collapse all files

423
src/urdu/ParadigmsUrd.gf
View File

@@ -1,207 +1,216 @@
--# -path=.:../abstract:../../prelude:../common --# -path=.:../abstract:../../prelude:../common
-- --
----1 Urdu Lexical Paradigms ----1 Urdu Lexical Paradigms
resource ParadigmsUrd = open resource ParadigmsUrd = open
Predef, Predef,
Prelude, Prelude,
MorphoUrd, MorphoUrd,
CatUrd, CatUrd,
CommonHindustani, CommonHindustani,
ParamX ParamX
in { in {
--2 Parameters --2 Parameters
oper oper
masculine : Gender ; masculine : Gender ;
feminine : Gender ; feminine : Gender ;
singular : Number; singular : Number;
plural : Number; plural : Number;
singular = Sg ; plural = Pl; singular = Sg ; plural = Pl;
masculine = Masc ; feminine = Fem ; --i masculine = Masc ; feminine = Fem ; --i
--2 Nouns --2 Nouns
mkN = overload { mkN = overload {
mkN : Str -> N -- Regular nouns like lRka, gender is judged from noun ending mkN : Str -> N -- Regular nouns like lRka, gender is judged from noun ending
= \s -> regNoun s ** {lock_N = <>} ; = \s -> regNoun s ** {lock_N = <>} ;
mkN : Str -> Gender -> N -- nouns whose gender is irregular like Admy mkN : Str -> Gender -> N -- nouns whose gender is irregular like Admy
= \s,g -> reggNoun s g ** {lock_N = <>} ; = \s,g -> reggNoun s g ** {lock_N = <>} ;
mkN : (x1,_,_,_,_,x6 : Str) -> Gender -> N -- worst case mkN : (x1,_,_,_,_,x6 : Str) -> Gender -> N -- worst case
= \sd,so,sv,pd,po,pv,g -> mkNoun sd so sv pd po pv g ** {lock_N = <>} ; = \sd,so,sv,pd,po,pv,g -> mkNoun sd so sv pd po pv g ** {lock_N = <>} ;
} ; } ;
mkN2 : N -> Prep -> Str -> N2; -- e.g maN ky mkN2 : N -> Prep -> Str -> N2; -- e.g maN ky
mkN2 = \n,p,c -> n ** {lock_N2 = <> ; c2 = p.s ! n.g ; c3 = c } ; mkN2 = \n,p,c -> n ** {lock_N2 = <> ; c2 = p.s ! n.g ; c3 = c } ;
mkN3 : N -> Prep -> Str -> Str-> N3 ; -- e.g faSlh - sE - ka mkN3 : N -> Prep -> Str -> Str-> N3 ; -- e.g faSlh - sE - ka
mkN3 = \n,p,q,r -> n ** {lock_N3 = <> ; c2 = p.s ! n.g ; c3 = q ; c4 = r} ; mkN3 = \n,p,q,r -> n ** {lock_N3 = <> ; c2 = p.s ! n.g ; c3 = q ; c4 = r} ;
-- Compound Nouns -- Compound Nouns
mkCmpdNoun : Str -> N -> N -- e.g t-alb elm mkCmpdNoun : Str -> N -> N -- e.g t-alb elm
= \s,noun -> {s =\\n,c => s ++ noun.s ! n ! c ; g = noun.g ; lock_N = <>}; = \s,noun -> {s =\\n,c => s ++ noun.s ! n ! c ; g = noun.g ; lock_N = <>};
-- Proper names -- Proper names
mkPN : Str -> PN = \s -> let n = regNoun s in {s = n.s ! Sg ; g = n.g ; lock_PN = <>} ; mkPN : Str -> PN = \s -> let n = regNoun s in {s = n.s ! Sg ; g = n.g ; lock_PN = <>} ;
personalPN : Str -> Str -> Str -> Str -> Str -> Str -> Str -> Number -> Gender -> UPerson -> Pron = personalPN : Str -> Str -> Str -> Str -> Str -> Str -> Str -> Number -> Gender -> UPerson -> Pron =
\s1,s2,s3,smp,sfp,pmp,pfp,nn,g,p -> let n = mkPron s1 s2 s3 in \s1,s2,s3,smp,sfp,pmp,pfp,nn,g,p -> let n = mkPron s1 s2 s3 in
{s = n.s ; {s = n.s ;
a = toAgr nn p g ; a = toAgr nn p g ;
ps = \\n,g => case <n,g> of { ps = \\n,g => case <n,g> of {
<Sg,Masc> =>smp ; <Sg,Masc> =>smp ;
<Sg,Fem> => sfp ; <Sg,Fem> => sfp ;
<Pl,Masc> => pmp ; <Pl,Masc> => pmp ;
<Pl,Fem> => pfp } ; lock_Pron = <>}; <Pl,Fem> => pfp } ; lock_Pron = <>};
demoPN : Str -> Str -> Str -> Quant = \s1,s2,s3 -> let n = makeDemonPronForm s1 s2 s3 in {s = n.s ; a = defaultAgr ; lock_Quant = <>}; demoPN : Str -> Str -> Str -> Quant = \s1,s2,s3 -> let n = makeDemonPronForm s1 s2 s3 in {s = n.s ; a = defaultAgr ; lock_Quant = <>};
mkDet : Str -> Str -> Str -> Str -> Number -> Det = \s1,s2,s3,s4,nb -> let dt = makeDet s1 s2 s3 s4 nb in {s = dt.s ; n = nb ; lock_Det = <>};
mkIP : (x1,x2,x3:Str) -> Number -> Gender -> IP = \s1,s2,s3,n,g -> let p = mkIntPronForm s1 s2 s3 in { s = p.s ; n = n ; g = g ; lock_IP = <>}; mkLN : Str -> LN = \s -> lin LN {s=s} ;
mkSN : Str -> SN = \s -> lin SN {s=s} ;
-- AdN mkGN : Str -> GN = \s -> lin GN {s=s} ;
mkAdN : Str -> AdN = \s -> {s = s ; p = False ; lock_AdN = <>} ;
--2 Adjectives mkDet : Str -> Str -> Str -> Str -> Number -> Det = \s1,s2,s3,s4,nb -> let dt = makeDet s1 s2 s3 s4 nb in {s = dt.s ; n = nb ; lock_Det = <>};
mkIP : (x1,x2,x3:Str) -> Number -> Gender -> IP = \s1,s2,s3,n,g -> let p = mkIntPronForm s1 s2 s3 in { s = p.s ; n = n ; g = g ; lock_IP = <>};
mkA = overload {
mkA : Str-> A -- e.g ach'a -- AdN
= \s -> regAdjective s ** {lock_A = <>} ; mkAdN : Str -> AdN = \s -> {s = s ; p = False ; lock_AdN = <>} ;
mkA : Str -> Str -> A2 -- e.g sE Xady krna --2 Adjectives
= \a,c -> let n = regAdjective a in {s = n.s; c2 = c} ** {lock_A2 = <>} ;
} ; mkA = overload {
mkA2 : A -> Str -> A2 ; mkA : Str-> A -- e.g ach'a
mkA2 a str = a ** {c2=str ; lock_A2 = <>} ; = \s -> regAdjective s ** {lock_A = <>} ;
mkA : Str -> Str -> A2 -- e.g sE Xady krna
-- compound Adjectives = \a,c -> let n = regAdjective a in {s = n.s; c2 = c} ** {lock_A2 = <>} ;
mkCompoundA : Str -> Str -> A ; -- e.g dra hwa } ;
mkCompoundA s1 s2 = compoundAdj s1 s2 ; mkA2 : A -> Str -> A2 ;
mkA2 a str = a ** {c2=str ; lock_A2 = <>} ;
--2 Verbs
-- compound Adjectives
mkV : Str -> V -- regular verbs like swna mkCompoundA : Str -> Str -> A ; -- e.g dra hwa
= \s -> mkVerb s ** {lock_V = <>} ; mkCompoundA s1 s2 = compoundAdj s1 s2 ;
mkV2 = overload { --2 Verbs
mkV2 : Str -> V2 -- e.g pyna
= \s -> mkVerb s ** {c2 = {s = [] ; c = VTrans} ; lock_V2 = <>} ; mkV : Str -> V -- regular verbs like swna
mkV2 : V -> V2 -- e.g pyna = \s -> mkVerb s ** {lock_V = <>} ;
= \v -> v ** {c2 = {s = [] ; c = VTrans} ; lock_V2 = <>} ;
mkV2 : V -> Str -> V2 -- e.g bnd krna mkV2 = overload {
= \v,p -> v ** {c2 = {s = p ; c = VTrans} ; lock_V2 = <>} ; mkV2 : Str -> V2 -- e.g pyna
} ; = \s -> mkVerb s ** {c2 = {s = [] ; c = VTrans} ; lock_V2 = <>} ;
dirV2 : V -> V2 = \v -> v ** {c2 = {s = [] ; c = VTrans} ; lock_V2 = <>} ; mkV2 : V -> V2 -- e.g pyna
= \v -> v ** {c2 = {s = [] ; c = VTrans} ; lock_V2 = <>} ;
mkV3 : V -> Str -> Str -> V3; -- e.g bycna mkV2 : V -> Str -> V2 -- e.g bnd krna
mkV3 v p q = v ** { c2 = p ; c3 = q ; lock_V3 = <>} ; = \v,p -> v ** {c2 = {s = p ; c = VTrans} ; lock_V2 = <>} ;
mkV2V : V -> Str -> Str -> Bool -> V2V ; -- e.g eltja krna - sE - kw } ;
mkV2V v s1 s2 b = v ** {isAux = b ; c1 = s1 ; c2 = s2 ; lock_V2V = <>} ; dirV2 : V -> V2 = \v -> v ** {c2 = {s = [] ; c = VTrans} ; lock_V2 = <>} ;
dirdirV3 : V -> V3 ;
dirdirV3 v = v ** { c2 = [] ; c3 = [] ; lock_V3 = <>} ; mkV3 : V -> Str -> Str -> V3; -- e.g bycna
mkV3 v p q = v ** { c2 = p ; c3 = q ; lock_V3 = <>} ;
-- compund verbs mkV2V : V -> Str -> Str -> Bool -> V2V ; -- e.g eltja krna - sE - kw
compoundV = overload { mkV2V v s1 s2 b = v ** {isAux = b ; c1 = s1 ; c2 = s2 ; lock_V2V = <>} ;
compoundV : Str -> V -> V -- e.g barX hwna dirdirV3 : V -> V3 ;
= \s,v -> {s = \\vf => v.s ! vf ; cvp = s ; lock_V = <>} ; dirdirV3 v = v ** { c2 = [] ; c3 = [] ; lock_V3 = <>} ;
compoundV : Str -> V2 -> V -- e.g bnd krna
= \s,v -> {s = \\vf => v.s ! vf ; cvp = s ; lock_V = <>} ; -- compund verbs
}; compoundV = overload {
compoundV : Str -> V -> V -- e.g barX hwna
= \s,v -> {s = \\vf => v.s ! vf ; cvp = s ; lock_V = <>} ;
----2 Adverbs compoundV : Str -> V2 -> V -- e.g bnd krna
mkAdv = overload { = \s,v -> {s = \\vf => v.s ! vf ; cvp = s ; lock_V = <>} ;
mkAdv : Str -> Adv -- e.g yhaN };
= \str -> {s = \\_ => str ; lock_Adv = <>};
mkAdv : Str -> Str -> Adv oper mkVA : V -> VA = \v -> lin VA v ;
= \m,f -> {s = table {Masc => m ; Fem => f} ; lock_Adv = <>}; oper mkV2S : V -> V2S = \v -> lin V2S v ** {c2={s = [] ; c = VTrans}} ;
};
----2 Adverbs
----2 Prepositions mkAdv = overload {
mkAdv : Str -> Adv -- e.g yhaN
mkPrep : Str -> Str -> Prep ; -- e.g ka - ky = \str -> {s = \\_ => str ; lock_Adv = <>};
mkPrep s1 s2 = makePrep s1 s2 ** {lock_Prep = <>}; mkAdv : Str -> Str -> Adv
= \m,f -> {s = table {Masc => m ; Fem => f} ; lock_Adv = <>};
--3 Determiners and quantifiers };
-- mkQuant : overload { mkAdV : Str -> AdV = \s -> lin AdV {s=s} ;
-- mkQuant : Pron -> Quant ;
-- mkQuant : (no_sg, no_pl, none_sg, non_pl : Str) -> Quant ; ----2 Prepositions
-- } ;
mkPrep : Str -> Str -> Prep ; -- e.g ka - ky
-- mkQuant = overload { mkPrep s1 s2 = makePrep s1 s2 ** {lock_Prep = <>};
-- mkQuant : Pron -> Quant = \p -> {s = \\_,_,c => p.s!c ;a = p.a ; lock_Quant = <>};
-- mkQuant : (no_sg, no_pl, none_sg, non_pl : Str) -> Quant = mkQuantifier; --3 Determiners and quantifiers
-- } ;
mkIQuant : Str -> IQuant = \s -> makeIQuant s ; -- mkQuant : overload {
-- mkQuant : Pron -> Quant ;
-- mkQuant : (no_sg, no_pl, none_sg, non_pl : Str) -> Quant ;
--2 Conjunctions -- } ;
mkConj : overload {
mkConj : Str -> Conj ; -- and (plural agreement) -- mkQuant = overload {
mkConj : Str -> Number -> Conj ; -- or (agrement number given as argument) -- mkQuant : Pron -> Quant = \p -> {s = \\_,_,c => p.s!c ;a = p.a ; lock_Quant = <>};
mkConj : Str -> Str -> Conj ; -- both ... and (plural) -- mkQuant : (no_sg, no_pl, none_sg, non_pl : Str) -> Quant = mkQuantifier;
mkConj : Str -> Str -> Number -> Conj ; -- either ... or (agrement number given as argument) -- } ;
} ; mkIQuant : Str -> IQuant = \s -> makeIQuant s ;
mkConj = overload {
mkConj : Str -> Conj = \y -> mk2Conj [] y plural ;
mkConj : Str -> Number -> Conj = \y,n -> mk2Conj [] y n ; --2 Conjunctions
mkConj : Str -> Str -> Conj = \x,y -> mk2Conj x y plural ; mkConj : overload {
mkConj : Str -> Str -> Number -> Conj = mk2Conj ; mkConj : Str -> Conj ; -- and (plural agreement)
} ; mkConj : Str -> Number -> Conj ; -- or (agrement number given as argument)
mkConj : Str -> Str -> Conj ; -- both ... and (plural)
mk2Conj : Str -> Str -> Number -> Conj = \x,y,n -> mkConj : Str -> Str -> Number -> Conj ; -- either ... or (agrement number given as argument)
lin Conj (sd2 x y ** {n = n}) ; } ;
mkConj = overload {
-- mkV0 : V -> V0 ; mkConj : Str -> Conj = \y -> mk2Conj [] y plural ;
mkVS : V -> VS; -- e.g drna mkConj : Str -> Number -> Conj = \y,n -> mk2Conj [] y n ;
mkVS v = v ; mkConj : Str -> Str -> Conj = \x,y -> mk2Conj x y plural ;
-- mkV2S : V -> Prep -> V2S ; mkConj : Str -> Str -> Number -> Conj = mk2Conj ;
mkVV : V -> VV = -- e.g cahna } ;
\v -> lin VV (v ** {isAux = False});
mk2Conj : Str -> Str -> Number -> Conj = \x,y,n ->
mkAdA : Str -> AdA ; lin Conj (sd2 x y ** {n = n}) ;
-- mkAdv x = lin Adv (ss x) ;
-- mkAdV x = lin AdV (ss x) ; -- mkV0 : V -> V0 ;
mkAdA x = lin AdA (ss x) ; mkVS : V -> VS; -- e.g drna
-- mkAdN x = lin AdN (ss x) ; mkVS v = v ;
-- mkV2S : V -> Prep -> V2S ;
-- mkV2V : V -> Prep -> Prep -> V2V ; mkVV : V -> VV = -- e.g cahna
-- mkVA : V -> VA ; \v -> lin VV (v ** {isAux = False});
-- mkV2A : V -> Prep -> V2A ;
mkVQ : V -> VQ ; -- e.g janna mkAdA : Str -> AdA ;
mkVQ v = v ; -- mkAdv x = lin Adv (ss x) ;
-- mkV2Q : V -> Prep -> V2Q ; -- mkAdV x = lin AdV (ss x) ;
-- mkAdA x = lin AdA (ss x) ;
-- mkAS : A -> AS ; -- mkAdN x = lin AdN (ss x) ;
-- mkA2S : A -> Prep -> A2S ;
-- mkAV : A -> AV ; -- mkV2V : V -> Prep -> Prep -> V2V ;
-- mkA2V : A -> Prep -> A2V ; -- mkVA : V -> VA ;
-- -- mkV2A : V -> Prep -> V2A ;
---- Notice: Categories $V0, AS, A2S, AV, A2V$ are just $A$. mkVQ : V -> VQ ; -- e.g janna
---- $V0$ is just $V$; the second argument is treated as adverb. mkVQ v = v ;
-- -- mkV2Q : V -> Prep -> V2Q ;
-- V0 : Type ; --
-- AS, A2S, AV, A2V : Type ; -- mkAS : A -> AS ;
-- -- mkA2S : A -> Prep -> A2S ;
----. -- mkAV : A -> AV ;
----2 Definitions of paradigms -- mkA2V : A -> Prep -> A2V ;
---- --
---- The definitions should not bother the user of the API. So they are ---- Notice: Categories $V0, AS, A2S, AV, A2V$ are just $A$.
---- hidden from the document. ---- $V0$ is just $V$; the second argument is treated as adverb.
-- --
-- Gender = MorphoHin.Gender ; -- V0 : Type ;
-- Number = MorphoHin.Number ; -- AS, A2S, AV, A2V : Type ;
-- Case = MorphoHin.Case ; --
-- human = Masc ; ----.
-- nonhuman = Neutr ; ----2 Definitions of paradigms
-- masculine = Masc ; ----
-- feminine = Fem ; ---- The definitions should not bother the user of the API. So they are
-- singular = Sg ; ---- hidden from the document.
-- plural = Pl ; --
-- nominative = Nom ; -- Gender = MorphoHin.Gender ;
-- genitive = Gen ; -- Number = MorphoHin.Number ;
-- Case = MorphoHin.Case ;
} -- human = Masc ;
-- nonhuman = Neutr ;
-- masculine = Masc ;
-- feminine = Fem ;
-- singular = Sg ;
-- plural = Pl ;
-- nominative = Nom ;
-- genitive = Gen ;
}