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

mkA revised

Browse Source
This commit is contained in:
ra.monique
2009-03-04 11:12:06 +00:00
parent dbed089bfa
commit c20d766c54
1 changed files with 386 additions and 380 deletions
Download Patch File Download Diff File Expand all files Collapse all files

766
next-lib/src/romanian/ParadigmsRon.gf
View File

@@ -1,313 +1,319 @@
--# -path=.:../romance:../common:../abstract:../../prelude --# -path=.:../romance:../common:../abstract:../../prelude
--1 Romanian Lexical Paradigms
--
-- Ramona Enache 2008 - 2009
--
resource ParadigmsRon =
open
(Predef=Predef),
Prelude,
MorphoRon,
CatRon,
BeschRon in {
flags optimize=all ;
--2 Parameters
--
-- To abstract over gender names, we define the following identifiers.
oper
NGender : Type ;
masculine : NGender ;
feminine : NGender ;
neuter : NGender ;
Gender : Type ;
Masculine : Gender ;
Feminine : Gender ;
--To abstract over animacy, we define the following :
Anim : Type ;
animate : Anim ;
inanimate : Anim;
-- To abstract over number names, we define the following.
Number : Type ;
singular : Number ;
plural : Number ;
-- prepositions which require cases :
Preposition : Type ;
NCase : Type ;
Acc : NCase ;
Dat : NCase ;
Gen : NCase ;
mkPrep : Str -> NCase -> Prep ;
noPrep : NCase -> Prep ;
--2 Nouns
--3 Relational nouns
--
-- Relational nouns need a noun and a preposition.
mkN2 : N -> Prep -> N2 ;
mkN2 n p = n ** {lock_N2 = <> ; c2 = p};
-- Three-place relational nouns need two prepositions.
mkN3 : N -> Prep -> Prep -> N3 ;
mkN3 n p q = n ** {lock_N3 = <> ; c2 = p ; c3 = q };
--1 Romanian Lexical Paradigms
--
-- Ramona Enache 2008 - 2009 --3 Proper names and noun phrases
-- --
-- Proper names need a string and a gender. If no gender is given, the
-- feminine is used for strings ending with "e", the masculine for other strings.
resource ParadigmsRon =
open mkPN = overload {
(Predef=Predef), mkPN : Str -> PN = mkPropN ;
Prelude, mkPN : Str -> Gender -> PN = mkPropNoun ;
MorphoRon, mkPN : Str -> Gender -> Number -> PN = mkProperNoun;
CatRon, } ;
BeschRon in {
flags optimize=all ; mkPropN : Str -> PN = \Ion ->
case last Ion of
--2 Parameters { "a" => mkPropNoun Ion Feminine ;
-- _ => mkPropNoun Ion Masculine
-- To abstract over gender names, we define the following identifiers. };
oper mkPropNoun : Str -> Gender -> PN = \Ion, gen ->
NGender : Type ; mkProperNoun Ion gen singular ;
masculine : NGender ; mkProperNoun : Str -> Gender -> Number -> PN = \Ion, gen, num ->
feminine : NGender ; {s = table {ANomAcc => Ion;
neuter : NGender ; AGenDat => case <last Ion,gen> of
{ <"a",Fem> => init Ion + "ei" ;
Gender : Type ; _ => "lui" ++ Ion
};
Masculine : Gender ; AVoc => Ion
Feminine : Gender ; };
g = gen ;
--To abstract over animacy, we define the following : n = num ;
lock_PN = <>
Anim : Type ; };
animate : Anim ;
inanimate : Anim;
-- To abstract over number names, we define the following. --3 Two-place adjectives
--
Number : Type ; -- Two-place adjectives need a preposition for their second argument.
singular : Number ; mkA2 : A -> Prep -> A2 ;
plural : Number ; mkA2 a p = a ** {c2 = p ; lock_A2 = <>} ;
-- prepositions which require cases : --.
--2 Definitions of the paradigms
Preposition : Type ; --
-- The definitions should not bother the user of the API. So they are
NCase : Type ; -- hidden from the document.
Acc : NCase ;
Dat : NCase ;
Gen : NCase ; NGender = MorphoRon.NGender ;
Number = MorphoRon.Number ;
mkPrep : Str -> NCase -> Prep ; Anim = MorphoRon.Animacy ;
noPrep : NCase -> Prep ; Gender = MorphoRon.Gender ;
NCase = MorphoRon.NCase ;
--2 Nouns
masculine = NMasc ;
feminine = NFem ;
neuter = NNeut ;
--3 Relational nouns
-- singular = Sg ;
-- Relational nouns need a noun and a preposition. plural = Pl ;
mkN2 : N -> Prep -> N2 ; animate = Animate ;
mkN2 n p = n ** {lock_N2 = <> ; c2 = p}; inanimate = Inanimate ;
-- Three-place relational nouns need two prepositions. Masculine = Masc ;
Feminine = Fem ;
mkN3 : N -> Prep -> Prep -> N3 ;
mkN3 n p q = n ** {lock_N3 = <> ; c2 = p ; c3 = q }; Acc = Ac ;
Dat = Da ;
Gen = Ge ;
--3 Proper names and noun phrases
-- Preposition = Compl ;
-- Proper names need a string and a gender. If no gender is given, the mkPrep ss cc = {s = ss ; c = cc; isDir = True; lock_Prep = <>} ;
-- feminine is used for strings ending with "e", the masculine for other strings. noPrep cc = mkPrep [] cc ;
mkPN = overload {
mkPN : Str -> PN = mkPropN ; compN : N -> Str -> N ;
mkPN : Str -> Gender -> PN = mkPropNoun ; compN x y = composeN x y ** {lock_N = <>} ;
mkPN : Str -> Gender -> Number -> PN = mkProperNoun;
} ; ccompN : N -> Str -> N ;
ccompN x y = ccompose x y ** {lock_N = <>} ;
mkPropN : Str -> PN = \Ion -> mkNI : Str -> Str -> NGender -> N;
case last Ion of mkNI s ss g = mkIn (mkNomIrreg s ss g) ** {lock_N = <>} ;
{ "a" => mkPropNoun Ion Feminine ;
_ => mkPropNoun Ion Masculine regN : Str -> NGender -> N ;
}; regN s g = mkIn (mkNomReg s g) ** {lock_N = <>};
mkPropNoun : Str -> Gender -> PN = \Ion, gen ->
mkProperNoun Ion gen singular ; mkVI : Str -> Str -> Str -> N;
mkVI s ss sss = mkIn (mkNomVIrreg s ss sss) ** {lock_N = <>} ;
mkProperNoun : Str -> Gender -> Number -> PN = \Ion, gen, num ->
{s = table {ANomAcc => Ion; mkIn : N -> N ;
AGenDat => case <last Ion,gen> of mkIn n = mkInanimate n ** {lock_N = <> };
{ <"a",Fem> => init Ion + "ei" ;
_ => "lui" ++ Ion mkAnim : N -> N ;
}; mkAnim n = mkAnimate n ** {lock_N = <> };
AVoc => Ion
}; chV : Str -> N -> N ;
g = gen ; chV s n = mkVocc n s ** {lock_N = <> } ;
n = num ;
lock_PN = <>
}; --smart paradigm for inferring the gender of the nouns
--partly based on the paper
--"COVERT SEMANTIC AND MORPHOPHONEMIC CATEGORIES IN THE ROMANIAN GENDER SYSTEM"
-- by Jan Louis Perkowski, Emil Vrabie
--3 Two-place adjectives mkSPN : Str -> N ;
-- mkSPN s = case s of
-- Two-place adjectives need a preposition for their second argument. { x + ("ã"|"e"|"a") => regN s feminine ;
x + ("el"|"mp"|"mb"|"en"|"id"|"at"|"ete"|"ol"|"et"|"or") => regN s masculine ;
mkA2 : A -> Prep -> A2 ; _ => regN s neuter
mkA2 a p = a ** {c2 = p ; lock_A2 = <>} ; };
--. mkNN : Str -> Str -> N ;
--2 Definitions of the paradigms mkNN s ss = case s of
-- { x + ("ã"|"e"|"a") => mkNI s ss feminine ;
-- The definitions should not bother the user of the API. So they are _ => case ss of
-- hidden from the document. {x + "uri" => mkNI s ss neuter ;
x + "e" => mkNI s ss neuter ;
_ => mkNI s ss masculine
NGender = MorphoRon.NGender ;
Number = MorphoRon.Number ; }
Anim = MorphoRon.Animacy ; };
Gender = MorphoRon.Gender ;
NCase = MorphoRon.NCase ; mkN = overload {
mkN : Str -> Str -> NGender -> N = mkNI; -- worst case - we need Singular + Plural form + gender
masculine = NMasc ; mkN : Str -> Str -> Str -> N = mkVI; -- very irregular nouns - feminine
feminine = NFem ; mkN : Str -> Str -> N = mkNN; -- needed Singular + Plural form, infers gender
neuter = NNeut ; mkN : Str -> NGender -> N = regN; -- needed Singular + gender, infers Plural form
mkN : Str -> N = mkSPN; -- needed Singular form, infers gender and Plural form
singular = Sg ; } ;
plural = Pl ;
--because the plurals ending in "uri" are becoming less and less frequent for neuter nouns,
animate = Animate ; --and because there is no way of infering the plural form by looking at the structure of the word
inanimate = Inanimate ; --we treat this case separately :
Masculine = Masc ; mkNR : Str -> N;
Feminine = Fem ; mkNR s = mkIn (mkNomNeut s) ** {lock_N = <>} ;
Acc = Ac ; --------------------------------------------------------------------
Dat = Da ;
Gen = Ge ; mkA = overload {
mkA : Str -> Str -> Str -> Str -> Str -> A = mk5A ;--worst case -- all 4 forms are needed + form for adverb
mkA : Str -> Str -> Str -> Str -> A = mk4A; -- 4 forms are needed
Preposition = Compl ; mkA : Str -> A = regA; -- regular adjectives
mkPrep ss cc = {s = ss ; c = cc; isDir = True; lock_Prep = <>} ; };
noPrep cc = mkPrep [] cc ;
mk4A : Str -> Str -> Str -> Str -> A;
mk4A a b c d =
compN : N -> Str -> N ; let adj = mkAdjSpec a b c d in
compN x y = composeN x y ** {lock_N = <>} ; {s = table { Posit => adj.s ;
Compar => \\f => "mai" ++ (adj.s ! f) ++ "decât";
ccompN : N -> Str -> N ; Superl => table {AF g n a c => artDem g n c ++ "mai" ++ adj.s ! (AF g n Indef c) ;
ccompN x y = ccompose x y ** {lock_N = <>} ; AA => artDem Masc Sg ANomAcc ++ "mai" ++ adj.s ! AA
mkNI : Str -> Str -> NGender -> N; }
mkNI s ss g = mkIn (mkNomIrreg s ss g) ** {lock_N = <>} ; }; isPre = False ; lock_A = <>} ;
regN : Str -> NGender -> N ; mk5A : Str -> Str -> Str -> Str -> Str -> A ;
regN s g = mkIn (mkNomReg s g) ** {lock_N = <>}; mk5A a b c d e =
let adj = mkAdjSSpec a b c d e in
{s = table { Posit => adj.s ;
mkVI : Str -> Str -> Str -> N; Compar => \\f => "mai" ++ (adj.s ! f) ++ "decât";
mkVI s ss sss = mkIn (mkNomVIrreg s ss sss) ** {lock_N = <>} ; Superl => table {AF g n a c => artDem g n c ++ "mai" ++ adj.s ! (AF g n Indef c);
AA => artDem Masc Sg ANomAcc ++ "mai" ++ adj.s ! AA
mkIn : N -> N ;
mkIn n = mkInanimate n ** {lock_N = <> }; }
}; isPre = False ; lock_A = <>} ;
mkAnim : N -> N ;
mkAnim n = mkAnimate n ** {lock_N = <> }; regA : Str -> A = \auriu -> let adj = mkAdjReg auriu in
{s = table {Posit => adj.s ;
chV : Str -> N -> N ; Compar => \\f => "mai" ++ (adj.s ! f) ++ "decât";
chV s n = mkVocc n s ** {lock_N = <> } ; Superl => table {AF g n a c => artDem g n c ++ "mai" ++ adj.s ! (AF g n Indef c);
AA => artDem Masc Sg ANomAcc ++ "mai" ++ adj.s ! AA
}
--smart paradigm for inferring the gender of the nouns }; isPre = False ; lock_A = <> } ;
--partly based on the paper
--"COVERT SEMANTIC AND MORPHOPHONEMIC CATEGORIES IN THE ROMANIAN GENDER SYSTEM" invarA : Str -> A = \auriu ->
-- by Jan Louis Perkowski, Emil Vrabie let adj =mkAdjInvar auriu in
{s = table { Posit => adj.s ;
mkSPN : Str -> N ; Compar => \\f => "mai" ++ (adj.s ! f) ++ "decât";
mkSPN s = case s of Superl => table {AF g n a c => artDem g n c ++ "mai" ++ adj.s ! (AF g n Indef c);
{ x + ("ã"|"e"|"a") => regN s feminine ; AA => artDem Masc Sg ANomAcc ++ "mai" ++ adj.s ! AA
x + ("el"|"mp"|"mb"|"en"|"id"|"at"|"ete"|"ol"|"et"|"or") => regN s masculine ;
_ => regN s neuter }
}; }; isPre = False ; lock_A = <>} ;
mkNN : Str -> Str -> N ; mkRMut : Str -> A = \auriu ->
mkNN s ss = case s of let adj = mkRegMut auriu in
{ x + ("ã"|"e"|"a") => mkNI s ss feminine ; {s = table { Posit => adj.s ;
_ => case ss of Compar => \\f => "mai" ++ (adj.s ! f) ++ "decât";
{x + "uri" => mkNI s ss neuter ; Superl => table {AF g n a c => artDem g n c ++ "mai" ++ adj.s ! (AF g n Indef c);
x + "e" => mkNI s ss neuter ; AA => artDem Masc Sg ANomAcc ++ "mai" ++ adj.s ! AA
_ => mkNI s ss masculine
}
} }; isPre = False ; lock_A = <>} ;
};
mkSMut : Str -> A = \auriu ->
mkN = overload { let adj = mkSpecMut auriu in
mkN : Str -> Str -> NGender -> N = mkNI; -- worst case - we need Singular + Plural form + gender {s = table { Posit => adj.s ;
mkN : Str -> Str -> Str -> N = mkVI; -- very irregular nouns - feminine Compar => \\f => "mai" ++ (adj.s ! f) ++ "decât";
mkN : Str -> Str -> N = mkNN; -- needed Singular + Plural form, infers gender Superl => table {AF g n a c => artDem g n c ++ "mai" ++ adj.s ! (AF g n Indef c);
mkN : Str -> NGender -> N = regN; -- needed Singular + gender, infers Plural form AA => artDem Masc Sg ANomAcc ++ "mai" ++ adj.s ! AA
mkN : Str -> N = mkSPN; -- needed Singular form, infers gender and Plural form
} ; }
}; isPre = False ; lock_A = <>} ;
--because the plurals ending in "uri" are becoming less and less frequent for neuter nouns,
--and because there is no way of infering the plural form by looking at the structure of the word mkADeg : A -> A -> A ;
--we treat this case separately : noComp : A -> A ;
mkNR : Str -> N;
mkNR s = mkIn (mkNomNeut s) ** {lock_N = <>} ; prefA : A -> A ;
-------------------------------------------------------------------- mkADeg a b =
{s = table {Posit => a.s ! Posit ; _ => b.s ! Posit} ; isPre = a.isPre ; lock_A = <>} ;
mk4A : Str -> Str -> Str -> Str -> A;
mk4A a b c d = noComp a =
let adj = mkAdjSpec a b c d in {s = \\_ => a.s ! Posit ;
{s = table { Posit => adj.s ; isPre = a.isPre ;
Compar => \\f => "mai" ++ (adj.s ! f) ++ "decât"; lock_A = <>} ;
Superl => table {AF g n a c => artDem g n c ++ "mai" ++ adj.s ! (AF g n Indef c) ;
AA => artDem Masc Sg ANomAcc ++ "mai" ++ adj.s ! AA prefA a = {s = a.s ; isPre = True ; lock_A = <>} ;
} --Adverbs :
}; isPre = False ; lock_A = <>} ;
mk5A : Str -> Str -> Str -> Str -> Str -> A ;
mk5A a b c d e =
let adj = mkAdjSSpec a b c d e in
{s = table { Posit => adj.s ;
Compar => \\f => "mai" ++ (adj.s ! f) ++ "decât";
Superl => table {AF g n a c => artDem g n c ++ "mai" ++ adj.s ! (AF g n Indef c);
AA => artDem Masc Sg ANomAcc ++ "mai" ++ adj.s ! AA
}
}; isPre = False ; lock_A = <>} ;
regA : Str -> A = \auriu -> let adj = mkAdjReg auriu in
{s = table {Posit => adj.s ;
Compar => \\f => "mai" ++ (adj.s ! f) ++ "decât";
Superl => table {AF g n a c => artDem g n c ++ "mai" ++ adj.s ! (AF g n Indef c);
AA => artDem Masc Sg ANomAcc ++ "mai" ++ adj.s ! AA
}
}; isPre = False ; lock_A = <> } ;
invarA : Str -> A = \auriu ->
let adj =mkAdjInvar auriu in
{s = table { Posit => adj.s ;
Compar => \\f => "mai" ++ (adj.s ! f) ++ "decât";
Superl => table {AF g n a c => artDem g n c ++ "mai" ++ adj.s ! (AF g n Indef c);
AA => artDem Masc Sg ANomAcc ++ "mai" ++ adj.s ! AA
}
}; isPre = False ; lock_A = <>} ;
mkRMut : Str -> A = \auriu ->
let adj = mkRegMut auriu in
{s = table { Posit => adj.s ;
Compar => \\f => "mai" ++ (adj.s ! f) ++ "decât";
Superl => table {AF g n a c => artDem g n c ++ "mai" ++ adj.s ! (AF g n Indef c);
AA => artDem Masc Sg ANomAcc ++ "mai" ++ adj.s ! AA
}
}; isPre = False ; lock_A = <>} ;
mkSMut : Str -> A = \auriu ->
let adj = mkSpecMut auriu in
{s = table { Posit => adj.s ;
Compar => \\f => "mai" ++ (adj.s ! f) ++ "decât";
Superl => table {AF g n a c => artDem g n c ++ "mai" ++ adj.s ! (AF g n Indef c);
AA => artDem Masc Sg ANomAcc ++ "mai" ++ adj.s ! AA
}
}; isPre = False ; lock_A = <>} ;
mkADeg : A -> A -> A ;
noComp : A -> A ;
prefA : A -> A ;
mkADeg a b =
{s = table {Posit => a.s ! Posit ; _ => b.s ! Posit} ; isPre = a.isPre ; lock_A = <>} ;
noComp a =
{s = \\_ => a.s ! Posit ;
isPre = a.isPre ;
lock_A = <>} ;
prefA a = {s = a.s ; isPre = True ; lock_A = <>} ;
--Adverbs :
mkAdv : Str -> Adv ; mkAdv : Str -> Adv ;
mkAdV : Str -> AdV ; mkAdV : Str -> AdV ;
mkAdA : Str -> AdA ; mkAdA : Str -> AdA ;
mkAdv x = ss x ** {lock_Adv = <>} ; mkAdv x = ss x ** {lock_Adv = <>} ;
mkAdV x = ss x ** {lock_AdV = <>} ; mkAdV x = ss x ** {lock_AdV = <>} ;
mkAdA x = ss x ** {lock_AdA = <>} ; mkAdA x = ss x ** {lock_AdA = <>} ;
--Verbs : --Verbs :
@@ -343,76 +349,76 @@ oper mkV : Str -> V = \s -> mkNV (regV s) ;
mkA2S : A -> Prep -> A2S ; mkA2S : A -> Prep -> A2S ;
mkAV : A -> Prep -> AV ; mkAV : A -> Prep -> AV ;
mkA2V : A -> Prep -> Prep -> A2V ; mkA2V : A -> Prep -> Prep -> A2V ;
mmkV3 : V -> Prep -> Prep -> V3; mmkV3 : V -> Prep -> Prep -> V3;
mmkV3 v p q = v ** {c2 = p ; c3 = q ; lock_V3 = <>} ; mmkV3 v p q = v ** {c2 = p ; c3 = q ; lock_V3 = <>} ;
dirV3 : V -> V3 ; dirV3 : V -> V3 ;
dirV3 v = mmkV3 v (noPrep Ac) (noPrep Da) ; dirV3 v = mmkV3 v (noPrep Ac) (noPrep Da) ;
mkV3 = overload { mkV3 = overload {
mkV3 : V -> V3 = dirV3 ; mkV3 : V -> V3 = dirV3 ;
mkV3 : V -> Prep -> Prep -> V3 = mmkV3 mkV3 : V -> Prep -> Prep -> V3 = mmkV3
} ; } ;
V0 : Type = V ; V0 : Type = V ;
AS, AV : Type = A ; AS, AV : Type = A ;
A2S, A2V : Type = A2 ; A2S, A2V : Type = A2 ;
mkV0 : V -> V0 ; mkV0 : V -> V0 ;
mkV0 v = v ** {lock_V0 = <>} ; mkV0 v = v ** {lock_V0 = <>} ;
mmkV2 : V -> Prep -> V2 ; mmkV2 : V -> Prep -> V2 ;
mmkV2 v p = v ** {c2 = p ; lock_V2 = <>} ; mmkV2 v p = v ** {c2 = p ; lock_V2 = <>} ;
dirV2 : V -> V2 ; dirV2 : V -> V2 ;
dirV2 v = mmkV2 v (noPrep Ac) ; dirV2 v = mmkV2 v (noPrep Ac) ;
mmkV3 : V -> Prep -> Prep -> V3 ; mmkV3 : V -> Prep -> Prep -> V3 ;
mmkV3 v p q = v ** {c2 = p ; c3 = q ; lock_V3 = <>} ; mmkV3 v p q = v ** {c2 = p ; c3 = q ; lock_V3 = <>} ;
mkVS : V -> VS ; mkVS : V -> VS ;
mkVS v = v ** {m = \\_ => Indic ; lock_VS = <>} ; mkVS v = v ** {m = \\_ => Indic ; lock_VS = <>} ;
mkV2S v p = mmkV2 v p ** {mn,mp = Indic ; lock_V2S = <>} ; mkV2S v p = mmkV2 v p ** {mn,mp = Indic ; lock_V2S = <>} ;
-- mkVV v = v ** {c2 = complAcc ; lock_VV = <>} ; -- mkVV v = v ** {c2 = complAcc ; lock_VV = <>} ;
-- deVV v = v ** {c2 = complGen ; lock_VV = <>} ; -- deVV v = v ** {c2 = complGen ; lock_VV = <>} ;
--aVV v = v ** {c2 = complDat ; lock_VV = <>} ; --aVV v = v ** {c2 = complDat ; lock_VV = <>} ;
mkV2V v p q = mmkV3 v p q ** {lock_V2V = <>} ; mkV2V v p q = mmkV3 v p q ** {lock_V2V = <>} ;
mkVA v = v ** {lock_VA = <>} ; mkVA v = v ** {lock_VA = <>} ;
mkV2A v p q = mmkV3 v p q ** {lock_V2A = <>} ; mkV2A v p q = mmkV3 v p q ** {lock_V2A = <>} ;
mkVQ : V -> VQ ; mkVQ : V -> VQ ;
mkVQ v = v ** {lock_VQ = <>} ; mkVQ v = v ** {lock_VQ = <>} ;
mkV2Q : V -> Prep -> V2Q ; mkV2Q : V -> Prep -> V2Q ;
mkV2Q v p = mmkV2 v p ** {lock_V2Q = <>} ; mkV2Q v p = mmkV2 v p ** {lock_V2Q = <>} ;
mkAS v = v ** {lock_AS = <>} ; ---- more moods mkAS v = v ** {lock_AS = <>} ; ---- more moods
mkA2S v p = mkA2 v p ** {lock_A2S = <>} ; mkA2S v p = mkA2 v p ** {lock_A2S = <>} ;
mkAV v p = v ** {c = p.p1 ; s2 = p.p2 ; lock_AV = <>} ; mkAV v p = v ** {c = p.p1 ; s2 = p.p2 ; lock_AV = <>} ;
mkA2V v p q = mkA2 v p ** {s3 = q.p2 ; c3 = q.p1 ; lock_A2V = <>} ; mkA2V v p q = mkA2 v p ** {s3 = q.p2 ; c3 = q.p1 ; lock_A2V = <>} ;
mkOrd : A -> Ord ; mkOrd : A -> Ord ;
mkOrd a = {s = a.s ! Posit ; isPre = a.isPre ; lock_Ord = <>} ; mkOrd a = {s = a.s ! Posit ; isPre = a.isPre ; lock_Ord = <>} ;
--mkComp a = --mkComp a =
--let adj = a.s ! Posit in --let adj = a.s ! Posit in
--{ s = table {Posit => adj ; --{ s = table {Posit => adj ;
-- Compar => \\f => "mai" ++ adj ! f ++ "decât"; -- Compar => \\f => "mai" ++ adj ! f ++ "decât";
-- Superl => table {AF g n a c => (artDem g n c) ++ "mai" ++ adj ! (AF g n a c); -- Superl => table {AF g n a c => (artDem g n c) ++ "mai" ++ adj ! (AF g n a c);
-- AA => "cel"++"mai" ++ adj ! AA -- AA => "cel"++"mai" ++ adj ! AA
-- } -- }
-- }; -- };
-- isPre = a.isPre ; -- isPre = a.isPre ;
-- lock_A = <> -- lock_A = <>
-- }; -- };
} ; } ;