mirror of
https://github.com/GrammaticalFramework/gf-rgl.git
synced 2026-06-14 17:40:12 -06:00
298 lines
7.9 KiB
Plaintext
298 lines
7.9 KiB
Plaintext
--# -path=.:../abstract:../common:../../prelude
|
|
|
|
--1 Hungarian auxiliary operations.
|
|
|
|
-- This module contains operations that are needed to make the
|
|
-- resource syntax work.
|
|
-- Some parameters, such as $Number$, are inherited from $ParamX$.
|
|
resource ResHun = ParamHun ** open Prelude, Predef, ParamHun in {
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Nouns
|
|
oper
|
|
Noun = {s : Number => Case => Str} ;
|
|
|
|
endCase : Case -> HarmForms = \c -> case c of {
|
|
Nom => harm1 [] ;
|
|
Acc => harm3 "ot" "et" "öt" ;
|
|
Dat => harm "nak" "nek" ;
|
|
Ill => harm "ba" "be" ;
|
|
Ine => harm "ban" "ben" ;
|
|
Ela => harm "ból" "ből" ;
|
|
All => harm3 "hoz" "hez" "höz" ;
|
|
Ade => harm "nál" "nél" ;
|
|
Abl => harm "tól" "től" ;
|
|
Sub => harm "ra" "re" ;
|
|
Sup => harm3 "on" "en" "ön" ;
|
|
Del => harm "ról" "ről" ;
|
|
Ins => harm "al" "el" ;
|
|
Cau => harm1 "ért" ;
|
|
Tra => harm "á" "é" -- TODO consonant assimilation
|
|
-- Ess => harm "stul" "stül" ;
|
|
-- Ter => harm1 "ig" ;
|
|
-- For => harm1 "ként" ;
|
|
-- Tem => harm1 "kor"
|
|
} ;
|
|
|
|
endNumber : Number -> HarmForms = \n -> case n of {
|
|
Sg => harm1 [] ;
|
|
Pl => harm3 "ok" "ek" "ök" -- TODO: vowel assimilation
|
|
} ;
|
|
|
|
harm3 : Str -> Str -> Str -> HarmForms = \a,e,o -> <a,e,o> ;
|
|
harm : Str -> Str -> HarmForms = \a,e -> harm3 a e e ;
|
|
harm1 : Str -> HarmForms = \i -> harm i i ;
|
|
|
|
getHarm : Str -> Harm = \s -> case s of {
|
|
_ + ("a" | "á" | "o" | "ó" | "u" | "ú") + _ => H_a ;
|
|
_ + ("ö" | "ő" | "ü") + _ => H_o ;
|
|
_ => H_e
|
|
} ;
|
|
|
|
HarmForms : Type = Str * Str * Str ;
|
|
|
|
useHarm : Harm -> HarmForms -> Str = \h,ss -> case h of {
|
|
H_a => ss.p1 ;
|
|
H_e => ss.p2 ;
|
|
H_o => ss.p3
|
|
} ;
|
|
|
|
putHarmEnding : HarmForms -> Str -> Str = \hs,w ->
|
|
w + useHarm (getHarm w) hs ;
|
|
|
|
mkNoun : Str -> Noun = \w -> {
|
|
s = \\n,c =>
|
|
let h = getHarm w
|
|
in
|
|
w + useHarm h (endNumber n) + useHarm h (endCase c)
|
|
} ;
|
|
|
|
---------------------------------------------
|
|
-- NP
|
|
|
|
NounPhrase : Type = {
|
|
s : Case => Str ;
|
|
agr : Person*Number ;
|
|
isPron : Bool ;
|
|
empty : Str ; -- standard trick for pro-drop
|
|
} ;
|
|
|
|
emptyNP : NounPhrase = {
|
|
s = \\_ => [] ;
|
|
agr = <P3,Sg> ;
|
|
isPron = False ;
|
|
empty = [] ;
|
|
} ;
|
|
|
|
indeclNP : Str -> NounPhrase = \s -> emptyNP ** {s = \\c => s} ;
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Pronouns
|
|
|
|
Pronoun : Type = NounPhrase ** {
|
|
-- poss : { -- for PossPron : Pron -> Quant
|
|
-- } ;
|
|
} ;
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Det, Quant, Card, Ord
|
|
|
|
-- Quant has variable number:
|
|
-- e.g. this_Quant has both "this" and "these"
|
|
Quant : Type = {
|
|
s, -- form that comes before noun: "{this} car"
|
|
sp : Number => Case => Str ; -- independent form, "I like {this}" (DetNP)
|
|
isIndefArt : Bool ; -- standard trick to prevent "a one car"
|
|
} ;
|
|
|
|
mkQuant : (s,sp : Str) -> Quant = \s,sp -> {
|
|
s = (mkNoun s).s ;
|
|
sp = (mkNoun sp).s ;
|
|
isIndefArt = False ;
|
|
} ;
|
|
|
|
-- Det is formed in DetQuant : Quant -> Num -> Det
|
|
-- so it has an inherent number.
|
|
Determiner : Type = {
|
|
s,
|
|
sp : Case => Str ;
|
|
n : Number ;
|
|
numtype : NumType ; -- Whether its Num component is digit, numeral or Sg/Pl
|
|
} ;
|
|
|
|
Num : Type = {
|
|
s : Place => Str ; -- Independent or attribute
|
|
n : Number ; -- Singular or plural
|
|
numtype : NumType ; -- Digit, numeral or Sg/Pl : makes a difference in many languages
|
|
} ;
|
|
|
|
baseNum : Num = {
|
|
s = \\_ => [] ;
|
|
n = Sg ;
|
|
numtype = NoNum
|
|
} ;
|
|
|
|
{- Numeral can become Num via
|
|
Noun.gf: NumNumeral : Numeral -> Card ;
|
|
Noun.gf: NumCard : Card -> Num ;
|
|
-}
|
|
Numeral : Type = Num ** {
|
|
-- TODO add ordinal
|
|
} ;
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Postpositions
|
|
|
|
Postposition : Type = {s : Str ; c : Case} ;
|
|
|
|
mkPrep : Str -> Postposition = \str -> {s=str ; c=Nom} ;
|
|
|
|
emptyPP : Postposition = mkPrep [] ;
|
|
|
|
------------------
|
|
-- Conj
|
|
|
|
Conj : Type = {
|
|
s1 : Str ;
|
|
s2 : Str ;
|
|
n : Number ;
|
|
} ;
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Adjectives
|
|
|
|
Adjective : Type = {s : Number => Str} ;
|
|
|
|
mkAdj : Str -> Adjective = \sg -> {
|
|
s = \\n =>
|
|
let h = getHarm sg
|
|
in sg + useHarm h (endNumber n)
|
|
} ;
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Verbs
|
|
|
|
verbEndings : Person*Number => HarmForms = table {
|
|
<P1,Sg> => harm3 "ok" "ek" "ök" ;
|
|
<P2,Sg> => harm1 "sz" ;
|
|
<P3,Sg> => harm1 [] ;
|
|
<P1,Pl> => harm "unk" "ünk" ;
|
|
<P2,Pl> => harm3 "tok" "tek" "tök" ; -- TODO allomorphs -otok, -etek, -ötök
|
|
<P3,Pl> => harm "nak" "nek" -- TODO allomorphs -anak, -enek
|
|
} ;
|
|
|
|
Verb : Type = {
|
|
s : VForm => Str ;
|
|
sc : SubjCase ; -- subject case
|
|
} ;
|
|
Verb2 : Type = Verb ** {
|
|
c2 : Case -- object case
|
|
} ;
|
|
Verb3 : Type = Verb2 ** {
|
|
-- c3 : Case -- indirect object case
|
|
} ;
|
|
|
|
mkVerb2 : Str -> Verb2 = \sg3 -> vtov2 (mkVerb sg3) ;
|
|
mkVerb3 : Str -> Verb3 = \sg3 -> v2tov3 (mkVerb2 sg3) ;
|
|
|
|
vtov2 : Verb -> Verb2 = \v -> v ** {c2 = Acc} ;
|
|
v2tov3 : Verb2 -> Verb3 = \v -> v ** {c3 = Dat} ;
|
|
|
|
mkVerb : (sg3 : Str) -> Verb = mkVerbReg "TODO:infinitive" ; -- TODO
|
|
|
|
mkVerbReg : (inf, sg3 : Str) -> Verb = \inf,sg3 ->
|
|
let harmony : Harm = getHarm sg3 ;
|
|
sg1 : Str = sg3 + useHarm harmony (verbEndings!<P1,Sg>) ;
|
|
sg2 : Str = sg3 + "sz" ;
|
|
pl1 : Str = sg3 + useHarm harmony (verbEndings!<P1,Pl>) ;
|
|
pl2 : Str = sg3 + useHarm harmony (verbEndings!<P2,Pl>) ;
|
|
pl3 : Str = sg3 + useHarm harmony (verbEndings!<P3,Pl>) ;
|
|
in mkVerbFull sg1 sg2 sg3 pl1 pl2 pl3 inf ;
|
|
|
|
mkVerbFull : (x1,_,_,_,_,_,x7 : Str) -> Verb =
|
|
\sg1,sg2,sg3,pl1,pl2,pl3,inf -> {
|
|
s = table {
|
|
VInf => inf ;
|
|
VFin P1 Sg => sg1 ;
|
|
VFin P2 Sg => sg2 ;
|
|
VFin P3 Sg => sg3 ;
|
|
VFin P1 Pl => pl1 ;
|
|
VFin P2 Pl => pl2 ;
|
|
VFin P3 Pl => pl3
|
|
} ;
|
|
sc = SCNom
|
|
} ;
|
|
|
|
copula : Verb = mkVerbFull
|
|
"vagyok"
|
|
"vagy"
|
|
"van"
|
|
"vagyunk"
|
|
"vagytok"
|
|
"vannak"
|
|
"lenni" ;
|
|
|
|
------------------
|
|
-- VP
|
|
|
|
VerbPhrase : Type = Verb ** {
|
|
obj : Str ;
|
|
adv : Str ;
|
|
} ; -- TODO more fields
|
|
|
|
VPSlash : Type = Verb2 ** {
|
|
adv : Str ;
|
|
} ;
|
|
|
|
useV : Verb -> VerbPhrase = \v -> v ** {
|
|
obj,adv = [] ;
|
|
} ;
|
|
|
|
useVc : Verb2 -> VPSlash = \v2 -> v2 ** {
|
|
adv = [] ;
|
|
} ;
|
|
|
|
insertObj : VPSlash -> NounPhrase -> VerbPhrase = \vps,np -> vps ** {
|
|
obj = np.s ! vps.c2 ;
|
|
|
|
-- If verb's subject case is Dat and object Nom, verb agrees with obj.
|
|
s = \\vf => case <vps.sc,vps.c2> of {
|
|
<SCDat,Nom> => vps.s ! agr2vf np.agr ;
|
|
_ => vps.s ! vf } ;
|
|
} ;
|
|
|
|
insertAdv : VerbPhrase -> SS -> VerbPhrase = \vp,adv -> vp ** {adv = adv.s} ;
|
|
insertAdvSlash : VPSlash -> SS -> VPSlash = \vps,adv -> vps ** {adv = adv.s} ;
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Cl, S
|
|
|
|
Clause : Type = {s : Tense => Anteriority => Polarity => Str} ;
|
|
|
|
{- After PredVP, we might still want to add more adverbs (QuestIAdv),
|
|
but we're done with verb inflection.
|
|
-}
|
|
ClSlash : Type = Clause ;
|
|
|
|
QClause : Type = Clause ;
|
|
|
|
-- RClause : Type = {s : NForm => Tense => Anteriority => Polarity => Str} ;
|
|
|
|
Sentence : Type = {s : Str} ;
|
|
|
|
predVP : NounPhrase -> VerbPhrase -> ClSlash = \np,vp -> vp ** {
|
|
s = \\t,a,p => let subjcase : Case = case vp.sc of {
|
|
SCNom => Nom ;
|
|
SCDat => Dat }
|
|
in np.s ! subjcase
|
|
++ np.empty -- standard trick for prodrop
|
|
++ vp.obj
|
|
++ vp.adv
|
|
++ vp.s ! agr2vf np.agr
|
|
} ;
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- linrefs
|
|
|
|
}
|