diff --git a/lib/src/hungarian/AdjectiveHun.gf b/lib/src/hungarian/AdjectiveHun.gf new file mode 100644 index 000000000..eb4afff4c --- /dev/null +++ b/lib/src/hungarian/AdjectiveHun.gf @@ -0,0 +1,59 @@ +concrete AdjectiveHun of Adjective = CatHun ** open ResHun, Prelude in +{ +--{ +-- +-- lin +-- +-- PositA a = { +-- s = \\_ => a.s ! AAdj Posit Nom ; +-- isPre = True +-- } ; +-- ComparA a np = { +-- s = \\_ => a.s ! AAdj Compar Nom ++ "than" ++ np.s ! npNom ; +-- isPre = False +-- } ; +-- UseComparA a = { +-- s = \\_ => a.s ! AAdj Compar Nom ; +-- isPre = True +-- } ; +-- +-- AdjOrd ord = { +-- s = \\_ => ord.s ! Nom ; +-- isPre = True +-- } ; +-- +-- CAdvAP ad ap np = { +-- s = \\a => ad.s ++ ap.s ! a ++ ad.p ++ np.s ! npNom ; +-- isPre = False +-- } ; +-- +-- ComplA2 a np = { +-- s = \\_ => a.s ! AAdj Posit Nom ++ a.c2 ++ np.s ! NPAcc ; +-- isPre = False +-- } ; +-- +-- ReflA2 a = { +-- s = \\ag => a.s ! AAdj Posit Nom ++ a.c2 ++ reflPron ! ag ; +-- isPre = False +-- } ; +-- +-- SentAP ap sc = { +-- s = \\a => ap.s ! a ++ sc.s ; +-- isPre = False +-- } ; +-- +-- AdAP ada ap = { +-- s = \\a => ada.s ++ ap.s ! a ; +-- isPre = ap.isPre +-- } ; +-- +-- UseA2 a = { +-- s = \\_ => a.s ! AAdj Posit Nom ; +-- isPre = True +-- } ; +-- +-- AdvAP ap adv = {s = \\a => ap.s ! a ++ adv.s ; isPre = False} ; +-- +--} + +} diff --git a/lib/src/hungarian/AdverbHun.gf b/lib/src/hungarian/AdverbHun.gf new file mode 100644 index 000000000..30c7864a6 --- /dev/null +++ b/lib/src/hungarian/AdverbHun.gf @@ -0,0 +1,25 @@ +concrete AdverbHun of Adverb = CatHun ** open ResHun, Prelude in +{ +--{ +-- +-- lin +-- PositAdvAdj a = {s = a.s ! AAdv} ; +-- ComparAdvAdj cadv a np = { +-- s = cadv.s ++ a.s ! AAdv ++ cadv.p ++ np.s ! npNom +-- } ; +-- ComparAdvAdjS cadv a s = { +-- s = cadv.s ++ a.s ! AAdv ++ cadv.p ++ s.s +-- } ; +-- +-- PrepNP prep np = {s = prep.s ++ np.s ! NPAcc} ; +-- +-- AdAdv = cc2 ; +-- PositAdAAdj a = {s = a.s ! AAdv} ; +-- +-- SubjS = cc2 ; +-- +-- AdnCAdv cadv = {s = cadv.s ++ cadv.p} ; +-- +--} + +} diff --git a/lib/src/hungarian/AllEngHun.gf b/lib/src/hungarian/AllEngHun.gf new file mode 100644 index 000000000..edf3b1871 --- /dev/null +++ b/lib/src/hungarian/AllEngHun.gf @@ -0,0 +1,13 @@ +--# -path=.:../abstract:../common:prelude + +abstract AllHunAbs = + Lang, + IrregHunAbs-[ + blow_V,burn_V,come_V,dig_V,fall_V,fly_V,freeze_V,go_V,lie_V,run_V, + sew_V,sing_V,sit_V,sleep_V,spit_V,stand_V,swell_V,swim_V,think_V], + ExtraHunAbs + ** +{ +--{} ; + +} diff --git a/lib/src/hungarian/AllHun.gf b/lib/src/hungarian/AllHun.gf new file mode 100644 index 000000000..fd5af02a2 --- /dev/null +++ b/lib/src/hungarian/AllHun.gf @@ -0,0 +1,13 @@ +--# -path=.:../abstract:../common:prelude + +concrete AllHun of AllHunAbs = + LangHun, + IrregHun-[ + blow_V,burn_V,come_V,dig_V,fall_V,fly_V,freeze_V,go_V,lie_V,run_V, + sew_V,sing_V,sit_V,sleep_V,spit_V,stand_V,swell_V,swim_V,think_V], + ExtraHun + ** +{ +--{} ; + +} diff --git a/lib/src/hungarian/BackwardHun.gf b/lib/src/hungarian/BackwardHun.gf new file mode 100644 index 000000000..7d42b77b4 --- /dev/null +++ b/lib/src/hungarian/BackwardHun.gf @@ -0,0 +1,80 @@ +concrete BackwardHun of Backward = CatHun ** open ResHun in +{ +--{ +-- +-- flags optimize=all_subs ; +-- +-- lin +-- +---- A repository of obsolete constructs, needed for backward compatibility. +---- They create spurious ambiguities if used in combination with Lang. +-- +---- from Verb 19/4/2008 +-- +-- ComplV2 v np = insertObj (\\_ => v.c2 ++ np.s ! Acc) (predV v) ; +-- ComplV3 v np np2 = +-- insertObj (\\_ => v.c2 ++ np.s ! Acc ++ v.c3 ++ np2.s ! Acc) (predV v) ; +-- ComplV2V v np vp = +-- insertObj (\\a => infVP v.isAux vp a) +-- (insertObj (\\_ => v.c2 ++ np.s ! Acc) (predV v)) ; +-- ComplV2S v np s = +-- insertObj (\\_ => conjThat ++ s.s) +-- (insertObj (\\_ => v.c2 ++ np.s ! Acc) (predV v)) ; +-- ComplV2Q v np q = +-- insertObj (\\_ => q.s ! QIndir) +-- (insertObj (\\_ => v.c2 ++ np.s ! Acc) (predV v)) ; +-- ComplV2A v np ap = +-- insertObj (\\_ => v.c2 ++ np.s ! Acc ++ ap.s ! np.a) (predV v) ; +-- +-- ReflV2 v = insertObj (\\a => v.c2 ++ reflPron ! a) (predV v) ; +-- +---- from Sentence 19/4/2008 +-- +-- SlashV2 np v2 = +-- mkClause (np.s ! Nom) np.a (predV v2) ** {c2 = v2.c2} ; +-- +-- SlashVVV2 np vv v2 = +-- mkClause (np.s ! Nom) np.a +-- (insertObj (\\a => infVP vv.isAux (predV v2) a) (predVV vv)) ** +-- {c2 = v2.c2} ; +-- +---- from Noun 19/4/2008 +-- +-- NumInt n = {s = n.s ; n = Pl} ; +-- OrdInt n = {s = n.s ++ "th"} ; --- DEPRECATED +-- +-- DetSg quant ord = { +-- s = quant.s ! Sg ++ ord.s ; +-- n = Sg +-- } ; +-- +-- DetPl quant num ord = { +-- s = quant.s ! num.n ++ num.s ++ ord.s ; +-- n = num.n +-- } ; +-- +-- NoNum = {s = []; n = Pl } ; +-- +-- DefArt = {s = \\_ => artDef} ; +-- +-- IndefArt = { +-- s = table { +-- Sg => artIndef ; +-- Pl => [] +-- } +-- } ; +-- +-- MassDet = {s = \\_ => []} ; +-- +-- +-- +---- from Structural 19/4/2008 +-- +-- that_NP = regNP "that" Sg ; +-- these_NP = regNP "these" Pl ; +-- this_NP = regNP "this" Sg ; +-- those_NP = regNP "those" Pl ; +-- +--} + +} diff --git a/lib/src/hungarian/CatHun.gf b/lib/src/hungarian/CatHun.gf new file mode 100644 index 000000000..5c6541564 --- /dev/null +++ b/lib/src/hungarian/CatHun.gf @@ -0,0 +1,94 @@ +concrete CatHun of Cat = CommonX ** open ResHun, Prelude in +{ + lincat +-- +---- exception to CommonX, due to the distinction contracted/uncontracted negation +-- +-- Pol = {s : Str ; p : CPolarity} ; +-- +---- Tensed/Untensed +-- +-- S = {s : Str} ; +-- QS = {s : QForm => Str} ; +-- RS = {s : Agr => Str ; c : NPCase} ; -- c for it clefts +-- SSlash = {s : Str ; c2 : Str} ; +-- +---- Sentence +-- +-- Cl = {s : ResHun.Tense => Anteriority => CPolarity => Order => Str} ; +-- ClSlash = { +-- s : ResHun.Tense => Anteriority => CPolarity => Order => Str ; +-- c2 : Str +-- } ; +-- Imp = {s : CPolarity => ImpForm => Str} ; +-- +---- Question +-- +-- QCl = {s : ResHun.Tense => Anteriority => CPolarity => QForm => Str} ; +-- IP = {s : NPCase => Str ; n : Number} ; +-- IComp = {s : Str} ; +-- IDet = {s : Str ; n : Number} ; +-- IQuant = {s : Number => Str} ; +-- +---- Relative +-- +-- RCl = { +-- s : ResHun.Tense => Anteriority => CPolarity => Agr => Str ; +-- c : NPCase +-- } ; +-- RP = {s : RCase => Str ; a : RAgr} ; +-- +---- Verb +-- +-- VP = ResHun.VP ; +-- VPSlash = ResHun.VP ** {c2 : Str} ; +-- Comp = {s : Agr => Str} ; +-- +---- Adjective +-- +-- AP = {s : Agr => Str ; isPre : Bool} ; +-- +---- Noun +-- + N = {s : Number => Case => Str} ; +-- NP = {s : NPCase => Str ; a : Agr} ; +-- Pron = {s : NPCase => Str ; sp : Case => Str ; a : Agr} ; +-- Det = {s : Str ; sp : NPCase => Str ; n : Number ; hasNum : Bool} ; +-- Predet = {s : Str} ; +-- Ord = { s : Case => Str } ; +-- Num = {s : Case => Str ; n : Number ; hasCard : Bool} ; +-- Card = {s : Case => Str ; n : Number} ; +-- Quant = {s : Bool => Number => Str ; sp : Bool => Number => NPCase => Str} ; +-- +---- Numeral +-- +-- Numeral = {s : CardOrd => Case => Str ; n : Number} ; +-- Digits = {s : CardOrd => Case => Str ; n : Number ; tail : DTail} ; +-- +---- Structural +-- +-- Conj = {s1,s2 : Str ; n : Number} ; +-----b Conj = {s : Str ; n : Number} ; +-----b DConj = {s1,s2 : Str ; n : Number} ; +-- Subj = {s : Str} ; +-- Prep = {s : Str} ; +-- +---- Open lexical classes, e.g. Lexicon +-- +-- V, VS, VQ, VA = Verb ; -- = {s : VForm => Str} ; +-- V2, V2A, V2Q, V2S = Verb ** {c2 : Str} ; +-- V3 = Verb ** {c2, c3 : Str} ; +-- VV = {s : VVForm => Str ; typ : VVType} ; +-- V2V = Verb ** {c2,c3 : Str ; typ : VVType} ; +-- +-- A = {s : AForm => Str} ; +-- A2 = {s : AForm => Str ; c2 : Str} ; +-- +-- N = {s : Number => Case => Str ; g : Gender} ; +-- N2 = {s : Number => Case => Str ; g : Gender} ** {c2 : Str} ; +-- N3 = {s : Number => Case => Str ; g : Gender} ** {c2,c3 : Str} ; +-- PN = {s : Case => Str ; g : Gender} ; +-- +--} + +} diff --git a/lib/src/hungarian/ConjunctionHun.gf b/lib/src/hungarian/ConjunctionHun.gf new file mode 100644 index 000000000..67b83578b --- /dev/null +++ b/lib/src/hungarian/ConjunctionHun.gf @@ -0,0 +1,58 @@ +concrete ConjunctionHun of Conjunction = + CatHun ** open ResHun, Coordination, Prelude in +{ +--{ +-- +-- flags optimize=all_subs ; +-- +-- lin +-- +-- ConjS = conjunctDistrSS ; +-- +-- ConjAdv = conjunctDistrSS ; +-- +-- ConjNP conj ss = conjunctDistrTable NPCase conj ss ** { +-- a = conjAgr (agrP3 conj.n) ss.a +-- } ; +-- +-- ConjAP conj ss = conjunctDistrTable Agr conj ss ** { +-- isPre = ss.isPre +-- } ; +-- +-- ConjRS conj ss = conjunctDistrTable Agr conj ss ** { +-- c = ss.c +-- } ; +-- +-- ConjIAdv = conjunctDistrSS ; +-- +-- ConjCN co ns = conjunctDistrTable2 Number Case co ns ** {g = Neutr} ; --- gender? +-- +---- These fun's are generated from the list cat's. +-- +-- BaseS = twoSS ; +-- ConsS = consrSS comma ; +-- BaseAdv = twoSS ; +-- ConsAdv = consrSS comma ; +-- BaseNP x y = twoTable NPCase x y ** {a = conjAgr x.a y.a} ; +-- ConsNP xs x = consrTable NPCase comma xs x ** {a = conjAgr xs.a x.a} ; +-- BaseAP x y = twoTable Agr x y ** {isPre = andB x.isPre y.isPre} ; +-- ConsAP xs x = consrTable Agr comma xs x ** {isPre = andB xs.isPre x.isPre} ; +-- BaseRS x y = twoTable Agr x y ** {c = y.c} ; +-- ConsRS xs x = consrTable Agr comma xs x ** {c = xs.c} ; +-- BaseIAdv = twoSS ; +-- ConsIAdv = consrSS comma ; +-- BaseCN = twoTable2 Number Case ; +-- ConsCN = consrTable2 Number Case comma ; +-- +-- lincat +-- [S] = {s1,s2 : Str} ; +-- [Adv] = {s1,s2 : Str} ; +-- [IAdv] = {s1,s2 : Str} ; +-- [NP] = {s1,s2 : NPCase => Str ; a : Agr} ; +-- [AP] = {s1,s2 : Agr => Str ; isPre : Bool} ; +-- [RS] = {s1,s2 : Agr => Str ; c : NPCase} ; +-- [CN] = {s1,s2 : Number => Case => Str} ; +-- +--} + +} diff --git a/lib/src/hungarian/ExtraEngHun.gf b/lib/src/hungarian/ExtraEngHun.gf new file mode 100644 index 000000000..1339ee3a3 --- /dev/null +++ b/lib/src/hungarian/ExtraEngHun.gf @@ -0,0 +1,40 @@ +abstract ExtraHunAbs = Extra - [ProDrop] ** +{ +--{ +-- +---- uncontracted negative polarity; contracted is the default for PNeg +-- fun +-- UncNeg : Pol ; +-- +---- freely compounded nouns +-- +-- CompoundCN : CN -> CN -> CN ; -- rock album +-- +-- that_RP : RP ; -- "that" as a relational pronoun (IdRP is "which" / "who") +-- +-- each_Det : Det ; +-- any_Quant : Quant ; +-- +---- infinitive without to +-- +-- UttVPShort : VP -> Utt ; +-- +---- emphasizing "do", e.g. "John does walk" +-- +-- do_VV : VV ; +-- +-- +----- these are obsolete: use UncNeg : Pol instead +-- +-- fun +-- UncNegCl : Temp -> Pol -> Cl -> S ; +-- UncNegQCl : Temp -> Pol -> QCl -> QS ; +-- UncNegRCl : Temp -> Pol -> RCl -> RS ; +-- +-- UncNegImpSg : Pol -> Imp -> Utt; -- do not help yourself +-- UncNegImpPl : Pol -> Imp -> Utt; -- do not help yourselves +-- +-- +--} + +} diff --git a/lib/src/hungarian/ExtraHun.gf b/lib/src/hungarian/ExtraHun.gf new file mode 100644 index 000000000..072e85f7c --- /dev/null +++ b/lib/src/hungarian/ExtraHun.gf @@ -0,0 +1,164 @@ +concrete ExtraHun of ExtraHunAbs = CatHun ** + open ResHun, Coordination, Prelude, MorphoHun, ParadigmsHun in +{ +--{ +-- +-- lin +-- GenNP np = {s = \\_,_ => np.s ! npGen ; sp = \\_,_,_ => np.s ! npGen} ; +-- GenIP ip = {s = \\_ => ip.s ! NCase Gen} ; +-- GenRP nu cn = { +-- s = \\c => "whose" ++ nu.s ! Nom ++ +-- case c of { +-- RC _ (NCase Gen) => cn.s ! nu.n ! Gen ; +-- _ => cn.s ! nu.n ! Nom +-- } ; +-- a = RAg (agrP3 Sg) +-- } ; +-- +-- ComplBareVS v s = insertObj (\\_ => s.s) (predV v) ; +-- +-- StrandRelSlash rp slash = { +-- s = \\t,a,p,ag => +-- rp.s ! RC (fromAgr ag).g NPAcc ++ slash.s ! t ! a ! p ! ODir ++ slash.c2 ; +-- c = NPAcc +-- } ; +-- EmptyRelSlash slash = { +-- s = \\t,a,p,_ => slash.s ! t ! a ! p ! ODir ++ slash.c2 ; +-- c = NPAcc +-- } ; +-- +-- StrandQuestSlash ip slash = +-- {s = \\t,a,b,q => +-- (mkQuestion (ss (ip.s ! NPAcc)) slash).s ! t ! a ! b ! q ++ slash.c2 +-- }; +-- +-- lincat +-- VPI = {s : VPIForm => Agr => Str} ; +-- [VPI] = {s1,s2 : VPIForm => Agr => Str} ; +-- +-- lin +-- BaseVPI = twoTable2 VPIForm Agr ; +-- ConsVPI = consrTable2 VPIForm Agr comma ; +-- +-- MkVPI vp = { +-- s = \\v,a => vp.ad ++ vp.inf ++ vp.s2 ! a +-- } ; +-- ConjVPI = conjunctDistrTable2 VPIForm Agr ; +-- ComplVPIVV vv vpi = +------ insertObj (\\a => infVP vv.typ vpi a) (predVV vv) ; +-- let isAux = case vv.typ of {VVAux => True ; _ => False} in +-- insertObj (\\a => (if_then_Str isAux [] "to") ++ vpi.s ! VPIInf ! a) (predVV vv) ; +-- +-- lin +-- that_RP = +-- { s = table { +-- RC _ (NCase Gen) => "whose" ; +-- RC _ _ => "that" ; +-- _ => "that" ---- "in that" ? +---- RPrep Neutr => "which" ; +---- RPrep _ => "whom" +-- } ; +-- a = RNoAg +-- } ; +-- +-- each_Det = mkDeterminer Sg "each" ; +-- any_Quant = mkQuant "any" "any" ; +-- +---- for VP conjunction +-- +-- param +-- VPIForm = VPIInf | VPIPPart ; +-- +-- lincat +-- VPS = {s : Agr => Str} ; +-- [VPS] = {s1,s2 : Agr => Str} ; +-- +-- lin +-- BaseVPS = twoTable Agr ; +-- ConsVPS = consrTable Agr comma ; +-- +-- PredVPS np vpi = {s = np.s ! npNom ++ vpi.s ! np.a} ; +-- +-- MkVPS t p vp = { +-- s = \\a => +-- let +-- verb = vp.s ! t.t ! t.a ! p.p ! ODir ! a ; +-- verbf = verb.aux ++ verb.adv ++ verb.fin ++ verb.inf ; +-- in t.s ++ p.s ++ vp.ad ++ verbf ++ vp.s2 ! a +-- } ; +-- +-- ConjVPS = conjunctDistrTable Agr ; +-- +-- ICompAP ap = {s = "how" ++ ap.s ! agrP3 Sg} ; ---- IComp should have agr! +-- +-- IAdvAdv adv = {s = "how" ++ adv.s} ; +-- +-- PartVP vp = { +-- s = \\a => vp.ad ++ vp.prp ++ vp.s2 ! a ; +-- isPre = False ---- depends on whether there are complements +-- } ; +-- +-- EmbedPresPart vp = {s = infVP VVPresPart vp (agrP3 Sg)} ; --- agr +-- +-- UttVPShort vp = {s = infVP VVAux vp (agrP3 Sg)} ; +-- +-- do_VV = { +-- s = table { +-- VVF VInf => ["do"] ; +-- VVF VPres => "does" ; +-- VVF VPPart => ["done"] ; ---- +-- VVF VPresPart => ["doing"] ; +-- VVF VPast => ["did"] ; --# notpresent +-- VVPastNeg => ["didn't"] ; --# notpresent +-- VVPresNeg => "doesn't" +-- } ; +-- typ = VVAux +-- } ; +-- +-- +--lin +-- UncNeg = {s = [] ; p = CNeg False} ; +-- +-- PassVPSlash vps = +-- let +-- be = predAux auxBe ; +-- ppt = vps.ptp +-- in { +-- s = be.s ; +-- prp = be.prp ; +-- ptp = be.ptp ; +-- inf = be.inf ; +-- ad = vps.ad ; +-- s2 = \\a => ppt ++ vps.s2 ! a ---- order +-- } ; +-- +-------------- +----- obsolete: use UncNeg : Pol +-- +-- UncNegCl t p cl = { +-- s = t.s ++ p.s ++ cl.s ! t.t ! t.a ! unc p.p ! ODir +-- } ; +-- UncNegQCl t p cl = { +-- s = \\q => t.s ++ p.s ++ cl.s ! t.t ! t.a ! unc p.p ! q +-- } ; +-- UncNegRCl t p cl = { +-- s = \\r => t.s ++ p.s ++ cl.s ! t.t ! t.a ! unc p.p ! r ; +-- c = cl.c +-- } ; +-- +-- UncNegImpSg p imp = {s = p.s ++ imp.s ! unc p.p ! ImpF Sg False} ; +-- UncNegImpPl p imp = {s = p.s ++ imp.s ! unc p.p ! ImpF Pl False} ; +-- +-- CompoundCN a b = {s = \\n,c => a.s ! Sg ! Nom ++ b.s ! n ! c ; g = b.g} ; +-- +-- oper +-- unc : CPolarity -> CPolarity = \x -> case x of { +-- CNeg _ => CNeg False ; +-- _ => x +-- } ; +--------- +-- +-- +--} + +} diff --git a/lib/src/hungarian/GrammarHun.gf b/lib/src/hungarian/GrammarHun.gf new file mode 100644 index 000000000..b65226d17 --- /dev/null +++ b/lib/src/hungarian/GrammarHun.gf @@ -0,0 +1,31 @@ +--# -path=.:../abstract:../common:prelude + +concrete GrammarHun of Grammar = + NounHun, + VerbHun, + AdjectiveHun, + AdverbHun, + NumeralHun, + SentenceHun, + QuestionHun, + RelativeHun, + ConjunctionHun, + PhraseHun, + TextX - [Pol,PPos,PNeg], + StructuralHun, + IdiomHun, + TenseX - [Pol,PPos,PNeg] + ** open ResHun, Prelude in +{ +--{ +-- +--flags startcat = Phr ; unlexer = text ; lexer = text ; +-- +--lin +-- PPos = {s = [] ; p = CPos} ; +-- PNeg = {s = [] ; p = CNeg True} ; -- contracted: don't +-- +-- +--} ; + +} diff --git a/lib/src/hungarian/IdiomHun.gf b/lib/src/hungarian/IdiomHun.gf new file mode 100644 index 000000000..0710d0e4d --- /dev/null +++ b/lib/src/hungarian/IdiomHun.gf @@ -0,0 +1,36 @@ +concrete IdiomHun of Idiom = CatHun ** open Prelude, ResHun in +{ +--{ +-- +-- flags optimize=all_subs ; +-- +-- lin +-- ImpersCl vp = mkClause "it" (agrP3 Sg) vp ; +-- GenericCl vp = mkClause "one" (agrP3 Sg) vp ; +-- +-- CleftNP np rs = mkClause "it" (agrP3 Sg) +-- (insertObj (\\_ => rs.s ! np.a) +-- (insertObj (\\_ => np.s ! rs.c) (predAux auxBe))) ; +-- +-- CleftAdv ad s = mkClause "it" (agrP3 Sg) +-- (insertObj (\\_ => conjThat ++ s.s) +-- (insertObj (\\_ => ad.s) (predAux auxBe))) ; +-- +-- ExistNP np = +-- mkClause "there" (agrP3 (fromAgr np.a).n) +-- (insertObj (\\_ => np.s ! NPAcc) (predAux auxBe)) ; +-- +-- ExistIP ip = +-- mkQuestion (ss (ip.s ! npNom)) +-- (mkClause "there" (agrP3 ip.n) (predAux auxBe)) ; +-- +-- ProgrVP vp = insertObj (\\a => vp.ad ++ vp.prp ++ vp.s2 ! a) (predAux auxBe) ; +-- +-- ImpPl1 vp = {s = "let's" ++ infVP VVAux vp (AgP1 Pl)} ; +-- +-- ImpP3 np vp = {s = "let" ++ np.s ! NPAcc ++ infVP VVAux vp np.a} ; +-- +--} +-- + +} diff --git a/lib/src/hungarian/IrregHun.gf b/lib/src/hungarian/IrregHun.gf new file mode 100644 index 000000000..f113b81e1 --- /dev/null +++ b/lib/src/hungarian/IrregHun.gf @@ -0,0 +1,185 @@ +--# -path=.:prelude:../abstract:../common + +concrete IrregHun of IrregHunAbs = CatHun ** open ParadigmsHun in +{ +--{ +-- +--flags optimize=values ; +-- +-- lin +-- awake_V = irregV "awake" "awoke" "awoken" ; +-- bear_V = irregV "bear" "bore" "born" ; +-- beat_V = irregV "beat" "beat" "beat" ; +-- become_V = irregV "become" "became" "become" ; +-- begin_V = irregV "begin" "began" "begun" ; +-- bend_V = irregV "bend" "bent" "bent" ; +-- beset_V = irregV "beset" "beset" "beset" ; +-- bet_V = irregDuplV "bet" "bet" "bet" ; +-- bid_V = irregDuplV "bid" (variants {"bid" ; "bade"}) (variants {"bid" ; "bidden"}) ; +-- bind_V = irregV "bind" "bound" "bound" ; +-- bite_V = irregV "bite" "bit" "bitten" ; +-- bleed_V = irregV "bleed" "bled" "bled" ; +-- blow_V = irregV "blow" "blew" "blown" ; +-- break_V = irregV "break" "broke" "broken" ; +-- breed_V = irregV "breed" "bred" "bred" ; +-- bring_V = irregV "bring" "brought" "brought" ; +-- broadcast_V = irregV "broadcast" "broadcast" "broadcast" ; +-- build_V = irregV "build" "built" "built" ; +-- burn_V = irregV "burn" (variants {"burned" ; "burnt"}) (variants {"burned" ; "burnt"}) ; +-- burst_V = irregV "burst" "burst" "burst" ; +-- buy_V = irregV "buy" "bought" "bought" ; +-- cast_V = irregV "cast" "cast" "cast" ; +-- catch_V = irregV "catch" "caught" "caught" ; +-- choose_V = irregV "choose" "chose" "chosen" ; +-- cling_V = irregV "cling" "clung" "clung" ; +-- come_V = irregV "come" "came" "come" ; +-- cost_V = irregV "cost" "cost" "cost" ; +-- creep_V = irregV "creep" "crept" "crept" ; +-- cut_V = irregDuplV "cut" "cut" "cut" ; +-- deal_V = irregV "deal" "dealt" "dealt" ; +-- dig_V = irregDuplV "dig" "dug" "dug" ; +-- dive_V = irregV "dive" (variants {"dived" ; "dove"}) "dived" ; +-- do_V = mk5V "do" "does" "did" "done" "doing" ; +-- draw_V = irregV "draw" "drew" "drawn" ; +-- dream_V = irregV "dream" (variants {"dreamed" ; "dreamt"}) (variants {"dreamed" ; "dreamt"}) ; +-- drive_V = irregV "drive" "drove" "driven" ; +-- drink_V = irregV "drink" "drank" "drunk" ; +-- eat_V = irregV "eat" "ate" "eaten" ; +-- fall_V = irregV "fall" "fell" "fallen" ; +-- feed_V = irregV "feed" "fed" "fed" ; +-- feel_V = irregV "feel" "felt" "felt" ; +-- fight_V = irregV "fight" "fought" "fought" ; +-- find_V = irregV "find" "found" "found" ; +-- fit_V = irregDuplV "fit" "fit" "fit" ; +-- flee_V = irregV "flee" "fled" "fled" ; +-- fling_V = irregV "fling" "flung" "flung" ; +-- fly_V = irregV "fly" "flew" "flown" ; +-- forbid_V = irregDuplV "forbid" "forbade" "forbidden" ; +-- forget_V = irregDuplV "forget" "forgot" "forgotten" ; +-- forgive_V = irregV "forgive" "forgave" "forgiven" ; +-- forsake_V = irregV "forsake" "forsook" "forsaken" ; +-- freeze_V = irregV "freeze" "froze" "frozen" ; +-- get_V = irregDuplV "get" "got" "gotten" ; +-- give_V = irregV "give" "gave" "given" ; +-- go_V = mk5V "go" "goes" "went" "gone" "going" ; +-- grind_V = irregV "grind" "ground" "ground" ; +-- grow_V = irregV "grow" "grew" "grown" ; +-- hang_V = irregV "hang" "hung" "hung" ; +-- have_V = mk5V "have" "has" "had" "had" "having" ; +-- hear_V = irregV "hear" "heard" "heard" ; +-- hide_V = irregV "hide" "hid" "hidden" ; +-- hit_V = irregDuplV "hit" "hit" "hit" ; +-- hold_V = irregV "hold" "held" "held" ; +-- hurt_V = irregV "hurt" "hurt" "hurt" ; +-- keep_V = irregV "keep" "kept" "kept" ; +-- kneel_V = irregV "kneel" "knelt" "knelt" ; +-- knit_V = irregDuplV "knit" "knit" "knit" ; +-- know_V = irregV "know" "knew" "know" ; +-- lay_V = irregV "lay" "laid" "laid" ; +-- lead_V = irregV "lead" "led" "led" ; +-- leap_V = irregV "leap" (variants {"leaped" ; "lept"}) (variants {"leaped" ; "lept"}) ; +-- learn_V = irregV "learn" (variants {"learned" ; "learnt"}) (variants {"learned" ; "learnt"}) ; +-- leave_V = irregV "leave" "left" "left" ; +-- lend_V = irregV "lend" "lent" "lent" ; +-- let_V = irregDuplV "let" "let" "let" ; +-- lie_V = irregV "lie" "lay" "lain" ; +-- light_V = irregV "light" (variants {"lighted" ; "lit"}) "lighted" ; +-- lose_V = irregV "lose" "lost" "lost" ; +-- make_V = irregV "make" "made" "made" ; +-- mean_V = irregV "mean" "meant" "meant" ; +-- meet_V = irregV "meet" "met" "met" ; +-- misspell_V = irregV "misspell" (variants {"misspelled" ; "misspelt"}) (variants {"misspelled" ; "misspelt"}) ; +-- mistake_V = irregV "mistake" "mistook" "mistaken" ; +-- mow_V = irregV "mow" "mowed" (variants {"mowed" ; "mown"}) ; +-- overcome_V = irregV "overcome" "overcame" "overcome" ; +-- overdo_V = mk5V "overdo" "overdoes" "overdid" "overdone" "overdoing" ; +-- overtake_V = irregV "overtake" "overtook" "overtaken" ; +-- overthrow_V = irregV "overthrow" "overthrew" "overthrown" ; +-- pay_V = irregV "pay" "paid" "paid" ; +-- plead_V = irregV "plead" "pled" "pled" ; +-- prove_V = irregV "prove" "proved" (variants {"proved" ; "proven"}) ; +-- put_V = irregDuplV "put" "put" "put" ; +-- quit_V = irregDuplV "quit" "quit" "quit" ; +-- read_V = irregV "read" "read" "read" ; +-- rid_V = irregDuplV "rid" "rid" "rid" ; +-- ride_V = irregV "ride" "rode" "ridden" ; +-- ring_V = irregV "ring" "rang" "rung" ; +-- rise_V = irregV "rise" "rose" "risen" ; +-- run_V = irregDuplV "run" "ran" "run" ; +-- saw_V = irregV "saw" "sawed" (variants {"sawed" ; "sawn"}) ; +-- say_V = irregV "say" "said" "said" ; +-- see_V = irregV "see" "saw" "seen" ; +-- seek_V = irregV "seek" "sought" "sought" ; +-- sell_V = irregV "sell" "sold" "sold" ; +-- send_V = irregV "send" "sent" "sent" ; +-- set_V = irregDuplV "set" "set" "set" ; +-- sew_V = irregV "sew" "sewed" (variants {"sewed" ; "sewn"}) ; +-- shake_V = irregV "shake" "shook" "shaken" ; +-- shave_V = irregV "shave" "shaved" (variants {"shaved" ; "shaven"}) ; +-- shear_V = irregV "shear" "shore" "shorn" ; +-- shed_V = irregDuplV "shed" "shed" "shed" ; +-- shine_V = irregV "shine" "shone" "shone" ; +-- shoe_V = irregV "shoe" "shoed" (variants {"shoed" ; "shod"}) ; +-- shoot_V = irregV "shoot" "shot" "shot" ; +-- show_V = irregV "show" "showed" (variants {"showed" ; "shown"}) ; +-- shrink_V = irregV "shrink" "shrank" "shrunk" ; +-- shut_V = irregDuplV "shut" "shut" "shut" ; +-- sing_V = irregV "sing" "sang" "sung" ; +-- sink_V = irregV "sink" "sank" "sunk" ; +-- sit_V = irregDuplV "sit" "sat" "sat" ; +-- sleep_V = irregV "sleep" "slept" "slept" ; +-- slay_V = irregV "slay" "slew" "slain" ; +-- slide_V = irregV "slide" "slid" "slid" ; +-- sling_V = irregV "sling" "slung" "slung" ; +-- slit_V = irregDuplV "slit" "slit" "slit" ; +-- smite_V = irregV "smite" "smote" "smitten" ; +-- sow_V = irregV "sow" "sowed" (variants {"sowed" ; "sown"}) ; +-- speak_V = irregV "speak" "spoke" "spoken" ; +-- speed_V = irregV "speed" "sped" "sped" ; +-- spend_V = irregV "spend" "spent" "spent" ; +-- spill_V = irregV "spill" (variants {"spilled" ; "spilt"}) (variants {"spilled" ; "spilt"}) ; +-- spin_V = irregDuplV "spin" "spun" "spun" ; +-- spit_V = irregDuplV "spit" (variants {"spit" ; "spat"}) "spit" ; +-- split_V = irregDuplV "split" "split" "split" ; +-- spread_V = irregV "spread" "spread" "spread" ; +-- spring_V = irregV "spring" (variants {"sprang" ; "sprung"}) "sprung" ; +-- stand_V = irregV "stand" "stood" "stood" ; +-- steal_V = irregV "steal" "stole" "stolen" ; +-- stick_V = irregV "stick" "stuck" "stuck" ; +-- sting_V = irregV "sting" "stung" "stung" ; +-- stink_V = irregV "stink" "stank" "stunk" ; +-- stride_V = irregV "stride" "strod" "stridden" ; +-- strike_V = irregV "strike" "struck" "struck" ; +-- string_V = irregV "string" "strung" "strung" ; +-- strive_V = irregV "strive" "strove" "striven" ; +-- swear_V = irregV "swear" "swore" "sworn" ; +-- sweep_V = irregV "sweep" "swept" "swept" ; +-- swell_V = irregV "swell" "swelled" (variants {"swelled" ; "swollen"}) ; +-- swim_V = irregDuplV "swim" "swam" "swum" ; +-- swing_V = irregV "swing" "swung" "swung" ; +-- take_V = irregV "take" "took" "taken" ; +-- teach_V = irregV "teach" "taught" "taught" ; +-- tear_V = irregV "tear" "tore" "torn" ; +-- tell_V = irregV "tell" "told" "told" ; +-- think_V = irregV "think" "thought" "thought" ; +-- thrive_V = irregV "thrive" (variants {"thrived" ; "throve"}) "thrived" ; +-- throw_V = irregV "throw" "threw" "thrown" ; +-- thrust_V = irregV "thrust" "thrust" "thrust" ; +-- tread_V = irregV "tread" "trod" "trodden" ; +-- understand_V = irregV "understand" "understood" "understood" ; +-- uphold_V = irregV "uphold" "upheld" "upheld" ; +-- upset_V = irregDuplV "upset" "upset" "upset" ; +-- wake_V = irregV "wake" "woke" "woken" ; +-- wear_V = irregV "wear" "wore" "worn" ; +-- weave_V = irregV "weave" (variants {"weaved" ; "wove"}) (variants {"weaved" ; "woven"}) ; +-- wed_V = irregDuplV "wed" "wed" "wed" ; +-- weep_V = irregV "weep" "wept" "wept" ; +-- wind_V = irregV "wind" "wound" "wound" ; +-- win_V = irregDuplV "win" "won" "won" ; +-- withhold_V = irregV "withhold" "withheld" "withheld" ; +-- withstand_V = irregV "withstand" "withstood" "withstood" ; +-- wring_V = irregV "wring" "wrung" "wrung" ; +-- write_V = irregV "write" "wrote" "written" ; +--} + +} diff --git a/lib/src/hungarian/IrregHunAbs.gf b/lib/src/hungarian/IrregHunAbs.gf new file mode 100644 index 000000000..5c3edd3a7 --- /dev/null +++ b/lib/src/hungarian/IrregHunAbs.gf @@ -0,0 +1,180 @@ +abstract IrregHunAbs = Cat ** +{ +--{ +--fun +-- awake_V : V ; +-- bear_V : V ; +-- beat_V : V ; +-- become_V : V ; +-- begin_V : V ; +-- bend_V : V ; +-- beset_V : V ; +-- bet_V : V ; +-- bid_V : V ; +-- bind_V : V ; +-- bite_V : V ; +-- bleed_V : V ; +-- blow_V : V ; +-- break_V : V ; +-- breed_V : V ; +-- bring_V : V ; +-- broadcast_V : V ; +-- build_V : V ; +-- burn_V : V ; +-- burst_V : V ; +-- buy_V : V ; +-- cast_V : V ; +-- catch_V : V ; +-- choose_V : V ; +-- cling_V : V ; +-- come_V : V ; +-- cost_V : V ; +-- creep_V : V ; +-- cut_V : V ; +-- deal_V : V ; +-- dig_V : V ; +-- dive_V : V ; +-- do_V : V ; +-- draw_V : V ; +-- dream_V : V ; +-- drive_V : V ; +-- drink_V : V ; +-- eat_V : V ; +-- fall_V : V ; +-- feed_V : V ; +-- feel_V : V ; +-- fight_V : V ; +-- find_V : V ; +-- fit_V : V ; +-- flee_V : V ; +-- fling_V : V ; +-- fly_V : V ; +-- forbid_V : V ; +-- forget_V : V ; +-- forgive_V : V ; +-- forsake_V : V ; +-- freeze_V : V ; +-- get_V : V ; +-- give_V : V ; +-- go_V : V ; +-- grind_V : V ; +-- grow_V : V ; +-- hang_V : V ; +-- have_V : V ; +-- hear_V : V ; +-- hide_V : V ; +-- hit_V : V ; +-- hold_V : V ; +-- hurt_V : V ; +-- keep_V : V ; +-- kneel_V : V ; +-- knit_V : V ; +-- know_V : V ; +-- lay_V : V ; +-- lead_V : V ; +-- leap_V : V ; +-- learn_V : V ; +-- leave_V : V ; +-- lend_V : V ; +-- let_V : V ; +-- lie_V : V ; +-- light_V : V ; +-- lose_V : V ; +-- make_V : V ; +-- mean_V : V ; +-- meet_V : V ; +-- misspell_V : V ; +-- mistake_V : V ; +-- mow_V : V ; +-- overcome_V : V ; +-- overdo_V : V ; +-- overtake_V : V ; +-- overthrow_V : V ; +-- pay_V : V ; +-- plead_V : V ; +-- prove_V : V ; +-- put_V : V ; +-- quit_V : V ; +-- read_V : V ; +-- rid_V : V ; +-- ride_V : V ; +-- ring_V : V ; +-- rise_V : V ; +-- run_V : V ; +-- saw_V : V ; +-- say_V : V ; +-- see_V : V ; +-- seek_V : V ; +-- sell_V : V ; +-- send_V : V ; +-- set_V : V ; +-- sew_V : V ; +-- shake_V : V ; +-- shave_V : V ; +-- shear_V : V ; +-- shed_V : V ; +-- shine_V : V ; +-- shoe_V : V ; +-- shoot_V : V ; +-- show_V : V ; +-- shrink_V : V ; +-- shut_V : V ; +-- sing_V : V ; +-- sink_V : V ; +-- sit_V : V ; +-- sleep_V : V ; +-- slay_V : V ; +-- slide_V : V ; +-- sling_V : V ; +-- slit_V : V ; +-- smite_V : V ; +-- sow_V : V ; +-- speak_V : V ; +-- speed_V : V ; +-- spend_V : V ; +-- spill_V : V ; +-- spin_V : V ; +-- spit_V : V ; +-- split_V : V ; +-- spread_V : V ; +-- spring_V : V ; +-- stand_V : V ; +-- steal_V : V ; +-- stick_V : V ; +-- sting_V : V ; +-- stink_V : V ; +-- stride_V : V ; +-- strike_V : V ; +-- string_V : V ; +-- strive_V : V ; +-- swear_V : V ; +-- sweep_V : V ; +-- swell_V : V ; +-- swim_V : V ; +-- swing_V : V ; +-- take_V : V ; +-- teach_V : V ; +-- tear_V : V ; +-- tell_V : V ; +-- think_V : V ; +-- thrive_V : V ; +-- throw_V : V ; +-- thrust_V : V ; +-- tread_V : V ; +-- understand_V : V ; +-- uphold_V : V ; +-- upset_V : V ; +-- wake_V : V ; +-- wear_V : V ; +-- weave_V : V ; +-- wed_V : V ; +-- weep_V : V ; +-- wind_V : V ; +-- win_V : V ; +-- withhold_V : V ; +-- withstand_V : V ; +-- wring_V : V ; +-- write_V : V ; +--} + +} diff --git a/lib/src/hungarian/LangHun.gf b/lib/src/hungarian/LangHun.gf new file mode 100644 index 000000000..a15285fca --- /dev/null +++ b/lib/src/hungarian/LangHun.gf @@ -0,0 +1,14 @@ +--# -path=.:../abstract:../common:../prelude + +concrete LangHun of Lang = + GrammarHun, + LexiconHun + ** +{ +--{ +-- +--flags startcat = Phr ; unlexer = text ; lexer = text ; +-- +--} ; + +} diff --git a/lib/src/hungarian/LexiconHun.gf b/lib/src/hungarian/LexiconHun.gf new file mode 100644 index 000000000..e068cdacc --- /dev/null +++ b/lib/src/hungarian/LexiconHun.gf @@ -0,0 +1,383 @@ +--# -path=.:prelude + +concrete LexiconHun of Lexicon = CatHun ** + open ParadigmsHun, Prelude in +{ +--{ +-- + flags coding = utf8 ; + +-- +lin +-- airplane_N = regN "airplane" ; +-- alas_Interj = ss "alas" ; +-- answer_V2S = mkV2S (mkV "answer" "answered") toP ; +-- apartment_N = regN "apartment" ; +-- apple_N = regN "apple" ; +-- art_N = regN "art" ; +-- ask_V2Q = mkV2Q (regV "ask") noPrep ; +-- baby_N = regN "baby" ; +-- bad_A = mkADeg "bad" "worse" "worst" "badly" ; +-- bank_N = regN "bank" ; +-- beautiful_A = compoundADeg (regA "beautiful") ; +-- become_VA = mkVA (irregV "become" "became" "become") ; +-- beer_N = regN "beer" ; +-- beg_V2V = mkV2V (regDuplV "beg") noPrep toP ; +-- -- prevent_V2V = ingV2V (mkV "prevent") noPrep (mkPrep "from") ; +-- -- make_V2V = mkV2V make_V noPrep noPrep ; +-- big_A = duplADeg "big" ; +-- bike_N = regN "bike" ; +-- bird_N = regN "bird" ; +-- black_A = regADeg "black" ; +-- blue_A = regADeg "blue" ; +-- boat_N = regN "boat" ; +-- book_N = regN "book" ; +-- boot_N = regN "boot" ; +-- boss_N = mkN human (regN "boss") ; +-- boy_N = mkN masculine (regN "boy") ; +-- bread_N = regN "bread" ; +-- break_V2 = dirV2 (irregV "break" "broke" "broken") ; +-- broad_A = regADeg "broad" ; +-- brother_N2 = mkN2 (mkN masculine (mkN "brother")) (mkPrep "of") ; +-- brown_A = regADeg "brown" ; +-- butter_N = regN "butter" ; +-- buy_V2 = dirV2 (irregV "buy" "bought" "bought") ; +-- camera_N = regN "camera" ; +-- cap_N = regN "cap" ; +-- car_N = regN "car" ; +-- carpet_N = regN "carpet" ; +-- cat_N = regN "cat" ; +-- ceiling_N = regN "ceiling" ; +-- chair_N = regN "chair" ; +-- cheese_N = regN "cheese" ; + child_N = mkN "gyerek" ; +-- church_N = regN "church" ; +-- city_N = regN "city" ; +-- clean_A = regADeg "clean" ; +-- clever_A = mkA "clever" "cleverer" ; +-- close_V2 = dirV2 (regV "close") ; +-- coat_N = regN "coat" ; +-- cold_A = regADeg "cold" ; +-- come_V = (irregV "come" "came" "come") ; +-- computer_N = regN "computer" ; +-- country_N = regN "country" ; +-- cousin_N = mkN human (regN "cousin") ; +-- cow_N = regN "cow" ; +-- die_V = (regV "die") ; +-- dirty_A = regADeg "dirty" ; +-- distance_N3 = mkN3 (regN "distance") fromP toP ; +-- doctor_N = mkN human (regN "doctor") ; +-- dog_N = regN "dog" ; +-- door_N = regN "door" ; +-- drink_V2 = dirV2 (irregV "drink" "drank" "drunk") ; +-- easy_A2V = mkA2V (regA "easy") forP ; +-- eat_V2 = dirV2 (irregV "eat" "ate" "eaten") ; +-- empty_A = regADeg "empty" ; +-- enemy_N = regN "enemy" ; +-- factory_N = regN "factory" ; +-- father_N2 = mkN2 (mkN masculine (mkN "father")) (mkPrep "of") ; +-- fear_VS = mkVS (regV "fear") ; +-- find_V2 = dirV2 (irregV "find" "found" "found") ; +-- fish_N = mk2N "fish" "fish" ; +-- floor_N = regN "floor" ; +-- forget_V2 = dirV2 (irregDuplV "forget" "forgot" "forgotten") ; +-- fridge_N = regN "fridge" ; +-- friend_N = mkN human (regN "friend") ; +-- fruit_N = regN "fruit" ; +-- fun_AV = mkAV (regA "fun") ; +-- garden_N = regN "garden" ; +-- girl_N = mkN feminine (regN "girl") ; +-- glove_N = regN "glove" ; +-- gold_N = regN "gold" ; +-- good_A = mkADeg "good" "better" "best" "well" ; +-- go_V = mk5V "go" "goes" "went" "gone" "going" ; +-- green_A = regADeg "green" ; +-- harbour_N = regN "harbour" ; +-- hate_V2 = dirV2 (regV "hate") ; +-- hat_N = regN "hat" ; +-- hear_V2 = dirV2 (irregV "hear" "heard" "heard") ; +-- hill_N = regN "hill" ; +-- hope_VS = mkVS (regV "hope") ; +-- horse_N = regN "horse" ; +-- hot_A = duplADeg "hot" ; + house_N = mkN "ház" ; +-- important_A = compoundADeg (regA "important") ; +-- industry_N = regN "industry" ; +-- iron_N = regN "iron" ; +-- king_N = mkN masculine (regN "king") ; +-- know_V2 = dirV2 (irregV "know" "knew" "known") ; +-- know_VQ = mkVQ (irregV "know" "knew" "known") ; +-- know_VS = mkVS (irregV "know" "knew" "known") ; +-- lake_N = regN "lake" ; +-- lamp_N = regN "lamp" ; +-- learn_V2 = dirV2 (regV "learn") ; +-- leather_N = regN "leather" ; +-- leave_V2 = dirV2 (irregV "leave" "left" "left") ; +-- like_V2 = dirV2 (regV "like") ; +-- listen_V2 = prepV2 (regV "listen") toP ; +-- live_V = (regV "live") ; +-- long_A = regADeg "long" ; +-- lose_V2 = dirV2 (irregV "lose" "lost" "lost") ; +-- love_N = regN "love" ; +-- love_V2 = dirV2 (regV "love") ; +-- man_N = mkN masculine (mk2N "man" "men") ; +-- married_A2 = mkA2 (regA "married") toP ; +-- meat_N = regN "meat" ; +-- milk_N = regN "milk" ; +-- moon_N = regN "moon" ; +-- mother_N2 = mkN2 (mkN feminine (mkN "mother")) (mkPrep "of") ; +-- mountain_N = regN "mountain" ; +-- music_N = regN "music" ; +-- narrow_A = regADeg "narrow" ; +-- new_A = regADeg "new" ; +-- newspaper_N = regN "newspaper" ; +-- oil_N = regN "oil" ; +-- old_A = regADeg "old" ; +-- open_V2 = dirV2 (regV "open") ; +-- paint_V2A = mkV2A (regV "paint") noPrep ; +-- paper_N = regN "paper" ; +-- paris_PN = mkPN (mkN nonhuman (mkN "Paris")) ; +-- peace_N = regN "peace" ; +-- pen_N = regN "pen" ; +-- planet_N = regN "planet" ; +-- plastic_N = regN "plastic" ; +-- play_V2 = dirV2 (regV "play") ; +-- policeman_N = mkN masculine (mkN "policeman" "policemen") ; +-- priest_N = mkN human (regN "priest") ; +-- probable_AS = mkAS (regA "probable") ; +-- queen_N = mkN feminine (regN "queen") ; +-- radio_N = regN "radio" ; +-- rain_V0 = mkV0 (regV "rain") ; +-- read_V2 = dirV2 (irregV "read" "read" "read") ; +-- red_A = duplADeg "red" ; +-- religion_N = regN "religion" ; +-- restaurant_N = regN "restaurant" ; +-- river_N = regN "river" ; +-- rock_N = regN "rock" ; +-- roof_N = regN "roof" ; +-- rubber_N = regN "rubber" ; +-- run_V = (irregDuplV "run" "ran" "run") ; +-- say_VS = mkVS (irregV "say" "said" "said") ; +-- school_N = regN "school" ; +-- science_N = regN "science" ; +-- sea_N = regN "sea" ; +-- seek_V2 = dirV2 (irregV "seek" "sought" "sought") ; +-- see_V2 = dirV2 (irregV "see" "saw" "seen") ; +-- sell_V3 = dirV3 (irregV "sell" "sold" "sold") toP ; +-- send_V3 = dirV3 (irregV "send" "sent" "sent") toP ; +-- sheep_N = mk2N "sheep" "sheep" ; +-- ship_N = regN "ship" ; +-- shirt_N = regN "shirt" ; +-- shoe_N = regN "shoe" ; +-- shop_N = regN "shop" ; +-- short_A = regADeg "short" ; +-- silver_N = regN "silver" ; +-- sister_N = mkN feminine (mkN "sister") ; +-- sleep_V = (irregV "sleep" "slept" "slept") ; +-- small_A = regADeg "small" ; +-- snake_N = regN "snake" ; +-- sock_N = regN "sock" ; +-- speak_V2 = dirV2 (irregV "speak" "spoke" "spoken") ; +-- star_N = regN "star" ; +-- steel_N = regN "steel" ; +-- stone_N = regN "stone" ; +-- stove_N = regN "stove" ; +-- student_N = mkN human (regN "student") ; +-- stupid_A = mkA "stupid" ; +-- sun_N = regN "sun" ; +-- switch8off_V2 = dirV2 (partV (regV "switch") "off") ; +-- switch8on_V2 = dirV2 (partV (regV "switch") "on") ; +-- table_N = regN "table" ; +-- talk_V3 = mkV3 (regV "talk") toP aboutP ; +-- teacher_N = mkN human (regN "teacher") ; +-- teach_V2 = dirV2 (irregV "teach" "taught" "taught") ; +-- television_N = regN "television" ; +-- thick_A = regADeg "thick" ; +-- thin_A = duplADeg "thin" ; +-- train_N = regN "train" ; +-- travel_V = (regDuplV "travel") ; +-- tree_N = regN "tree" ; +-- ---- trousers_N = regN "trousers" ; +-- ugly_A = mkA "ugly" ; +-- understand_V2 = dirV2 (irregV "understand" "understood" "understood") ; +-- university_N = regN "university" ; +-- village_N = regN "village" ; +-- wait_V2 = prepV2 (regV "wait") forP ; +-- walk_V = (regV "walk") ; +-- warm_A = regADeg "warm" ; +-- war_N = regN "war" ; +-- watch_V2 = dirV2 (regV "watch") ; +-- water_N = regN "water" ; +-- white_A = mkA "white" ; +-- window_N = regN "window" ; +-- wine_N = regN "wine" ; +-- win_V2 = dirV2 (irregDuplV "win" "won" "won") ; +-- woman_N = mkN feminine (mk2N "woman" "women") ; +-- wonder_VQ = mkVQ (mkV "wonder" "wondered") ; +-- wood_N = regN "wood" ; +-- write_V2 = dirV2 (irregV "write" "wrote" "written") ; +-- yellow_A = mkA "yellow" ; +-- young_A = regADeg "young" ; +-- +-- do_V2 = dirV2 (mk5V "do" "does" "did" "done" "doing") ; +-- now_Adv = mkAdv "now" ; +-- already_Adv = mkAdv "already" ; +-- song_N = regN "song" ; +-- add_V3 = dirV3 (regV "add") toP ; +-- number_N = regN "number" ; +-- put_V2 = prepV2 (irregDuplV "put" "put" "put") noPrep ; +-- stop_V = regDuplV "stop" ; +-- jump_V = regV "jump" ; +-- +-- left_Ord = mkOrd "left" ; +-- right_Ord = mkOrd "right" ; +-- far_Adv = mkAdv "far" ; +-- correct_A = (regA "correct") ; +-- dry_A = regA "dry" ; +-- dull_A = regA "dull" ; +-- full_A = regA "full" ; +-- heavy_A = regA "heavy" ; +-- near_A = regA "near" ; +-- rotten_A = (regA "rotten") ; +-- round_A = regA "round" ; +-- sharp_A = regA "sharp" ; +-- smooth_A = regA "smooth" ; +-- straight_A = regA "straight" ; +-- wet_A = regA "wet" ; ---- +-- wide_A = regA "wide" ; +-- animal_N = regN "animal" ; +-- ashes_N = regN "ash" ; -- FIXME: plural only? +-- back_N = regN "back" ; +-- bark_N = regN "bark" ; +-- belly_N = regN "belly" ; +-- blood_N = regN "blood" ; +-- bone_N = regN "bone" ; +-- breast_N = regN "breast" ; +-- cloud_N = regN "cloud" ; +-- day_N = regN "day" ; +-- dust_N = regN "dust" ; +-- ear_N = regN "ear" ; +-- earth_N = regN "earth" ; +-- egg_N = regN "egg" ; +-- eye_N = regN "eye" ; +-- fat_N = regN "fat" ; +-- feather_N = regN "feather" ; +-- fingernail_N = regN "fingernail" ; +-- fire_N = regN "fire" ; +-- flower_N = regN "flower" ; +-- fog_N = regN "fog" ; +-- foot_N = mk2N "foot" "feet" ; +-- forest_N = regN "forest" ; +-- grass_N = regN "grass" ; +-- guts_N = regN "gut" ; -- FIXME: no singular +-- hair_N = regN "hair" ; +-- hand_N = regN "hand" ; +-- head_N = regN "head" ; +-- heart_N = regN "heart" ; +-- horn_N = regN "horn" ; +-- husband_N = mkN masculine (regN "husband") ; +-- ice_N = regN "ice" ; +-- knee_N = regN "knee" ; +-- leaf_N = mk2N "leaf" "leaves" ; +-- leg_N = regN "leg" ; +-- liver_N = regN "liver" ; +-- louse_N = mk2N "louse" "lice" ; +-- mouth_N = regN "mouth" ; +-- name_N = regN "name" ; +-- neck_N = regN "neck" ; +-- night_N = regN "night" ; +-- nose_N = regN "nose" ; +-- person_N = mkN human (regN "person") ; +-- rain_N = regN "rain" ; +-- road_N = regN "road" ; +-- root_N = regN "root" ; +-- rope_N = regN "rope" ; +-- salt_N = regN "salt" ; +-- sand_N = regN "sand" ; +-- seed_N = regN "seed" ; +-- skin_N = regN "skin" ; +-- sky_N = regN "sky" ; +-- smoke_N = regN "smoke" ; +-- snow_N = regN "snow" ; +-- stick_N = regN "stick" ; +-- tail_N = regN "tail" ; +-- tongue_N = regN "tongue" ; +-- tooth_N = mk2N "tooth" "teeth" ; +-- wife_N = mkN feminine (mk2N "wife" "wives") ; +-- wind_N = regN "wind" ; +-- wing_N = regN "wing" ; +-- worm_N = regN "worm" ; +-- year_N = regN "year" ; +-- blow_V = IrregHun.blow_V ; +-- breathe_V = dirV2 (regV "breathe") ; +-- burn_V = IrregHun.burn_V ; +-- dig_V = IrregHun.dig_V ; +-- fall_V = IrregHun.fall_V ; +-- float_V = regV "float" ; +-- flow_V = regV "flow" ; +-- fly_V = IrregHun.fly_V ; +-- freeze_V = IrregHun.freeze_V ; +-- give_V3 = dirV3 give_V toP ; +-- laugh_V = regV "laugh" ; +-- lie_V = IrregHun.lie_V ; +-- play_V = regV "play" ; +-- sew_V = IrregHun.sew_V ; +-- sing_V = IrregHun.sing_V ; +-- sit_V = IrregHun.sit_V ; +-- smell_V = regV "smell" ; +-- spit_V = IrregHun.spit_V ; +-- stand_V = IrregHun.stand_V ; +-- swell_V = IrregHun.swell_V ; +-- swim_V = IrregHun.swim_V ; +-- think_V = IrregHun.think_V ; +-- turn_V = regV "turn" ; +-- vomit_V = mkV "vomit" "vomited" ; +-- +-- bite_V2 = dirV2 IrregHun.bite_V ; +-- count_V2 = dirV2 (regV "count") ; +-- cut_V2 = dirV2 IrregHun.cut_V ; +-- fear_V2 = dirV2 (regV "fear") ; +-- fight_V2 = dirV2 fight_V ; +-- hit_V2 = dirV2 hit_V ; +-- hold_V2 = dirV2 hold_V ; +-- hunt_V2 = dirV2 (regV "hunt") ; +-- kill_V2 = dirV2 (regV "kill") ; +-- pull_V2 = dirV2 (regV "pull") ; +-- push_V2 = dirV2 (regV "push") ; +-- rub_V2 = dirV2 (regDuplV "rub") ; +-- scratch_V2 = dirV2 (regV "scratch") ; +-- split_V2 = dirV2 split_V ; +-- squeeze_V2 = dirV2 (regV "squeeze") ; +-- stab_V2 = dirV2 (regDuplV "stab") ; +-- suck_V2 = dirV2 (regV "suck") ; +-- throw_V2 = dirV2 throw_V ; +-- tie_V2 = dirV2 (regV "tie") ; +-- wash_V2 = dirV2 (regV "wash") ; +-- wipe_V2 = dirV2 (regV "wipe") ; +-- +---- other_A = regA "other" ; +-- +-- grammar_N = regN "grammar" ; +-- language_N = regN "language" ; +-- rule_N = regN "rule" ; +-- +---- added 4/6/2007 +-- john_PN = mkPN (mkN masculine (mkN "John")) ; +-- question_N = regN "question" ; +-- ready_A = regA "ready" ; +-- reason_N = regN "reason" ; +-- today_Adv = mkAdv "today" ; +-- uncertain_A = regA "uncertain" ; +-- +--oper +-- aboutP = mkPrep "about" ; +-- atP = mkPrep "at" ; +-- forP = mkPrep "for" ; +-- fromP = mkPrep "from" ; +-- inP = mkPrep "in" ; +-- onP = mkPrep "on" ; +-- toP = mkPrep "to" ; +-- +--} ; + +} diff --git a/lib/src/hungarian/MorphoHun.gf b/lib/src/hungarian/MorphoHun.gf new file mode 100644 index 000000000..fa984088f --- /dev/null +++ b/lib/src/hungarian/MorphoHun.gf @@ -0,0 +1,47 @@ +--# -path=.:../../prelude + +--1 A Simple Hunlish Resource Morphology +-- +-- Aarne Ranta 2002 -- 2005 +-- +-- This resource morphology contains definitions needed in the resource +-- syntax. To build a lexicon, it is better to use $ParadigmsHun$, which +-- gives a higher-level access to this module. + +resource MorphoHun = open Prelude, (Predef=Predef), ResHun in +{ +--{ +-- +-- flags optimize=all ; +-- +----2 Determiners +-- +-- oper +-- +-- mkDeterminer : Number -> Str -> +-- {s : Str ; sp : NPCase => Str; n : Number ; hasNum : Bool} = \n,s -> +-- {s = s; +-- sp = \\c => regGenitiveS s ! npcase2case c ; +-- n = n ; +-- hasNum = True ; -- doesn't matter since s = sp +-- } ; +-- +----2 Pronouns +-- +-- +-- mkPron : (i,me,my,mine : Str) -> Number -> Person -> Gender -> +-- {s : NPCase => Str ; sp : Case => Str ; a : Agr} = +-- \i,me,my,mine,n,p,g -> { +-- s = table { +-- NCase Nom => i ; +-- NPAcc => me ; +-- NCase Gen => my +-- } ; +-- a = toAgr n p g ; +-- sp = regGenitiveS mine +-- } ; +-- +--} ; +-- + +} diff --git a/lib/src/hungarian/NounHun.gf b/lib/src/hungarian/NounHun.gf new file mode 100644 index 000000000..be7cc5fe7 --- /dev/null +++ b/lib/src/hungarian/NounHun.gf @@ -0,0 +1,144 @@ +concrete NounHun of Noun = CatHun ** open MorphoHun, ResHun, Prelude in +{ +--{ +-- +-- flags optimize=all_subs ; +-- +-- lin +-- DetCN det cn = { +-- s = \\c => det.s ++ cn.s ! det.n ! npcase2case c ; +-- a = agrgP3 det.n cn.g +-- } ; +-- +-- UsePN pn = {s = \\c => pn.s ! npcase2case c ; a = agrgP3 Sg pn.g} ; +-- UsePron p = p ; +-- +-- PredetNP pred np = { +-- s = \\c => pred.s ++ np.s ! c ; +-- a = np.a +-- } ; +-- +-- PPartNP np v2 = { +-- s = \\c => np.s ! c ++ v2.s ! VPPart ; +-- a = np.a +-- } ; +-- +-- RelNP np rs = { +-- s = \\c => np.s ! c ++ "," ++ rs.s ! np.a ; +-- a = np.a +-- } ; +-- +-- AdvNP np adv = { +-- s = \\c => np.s ! c ++ adv.s ; +-- a = np.a +-- } ; +-- +-- DetQuant quant num = { +-- s = quant.s ! num.hasCard ! num.n ++ num.s ! Nom; +-- sp = \\c => case num.hasCard of { +-- False => quant.sp ! num.hasCard ! num.n ! c ++ num.s ! Nom ; +-- True => quant.sp ! num.hasCard ! num.n ! npNom ++ num.s ! npcase2case c +-- } ; +-- n = num.n ; +-- hasNum = num.hasCard +-- } ; +-- +-- DetQuantOrd quant num ord = { +-- s = quant.s ! num.hasCard ! num.n ++ num.s ! Nom ++ ord.s ! Nom; +-- sp = \\c => quant.sp ! num.hasCard ! num.n ! npNom ++ num.s ! Nom ++ ord.s ! npcase2case c ; +-- n = num.n ; +-- hasNum = True +-- } ; +-- +-- DetNP det = { +-- s = case det.hasNum of {True => \\_ => det.s ; _ => \\c => det.sp ! c} ; +-- a = agrP3 det.n +-- } ; +-- +-- PossPron p = { +-- s = \\_,_ => p.s ! NCase Gen ; +-- sp = \\_,_,c => p.sp ! npcase2case c +-- } ; +-- +-- NumSg = {s = \\c => []; n = Sg ; hasCard = False} ; +-- NumPl = {s = \\c => []; n = Pl ; hasCard = False} ; +-----b NoOrd = {s = []} ; +-- +-- NumCard n = n ** {hasCard = True} ; +-- +-- NumDigits n = {s = n.s ! NCard ; n = n.n} ; +-- OrdDigits n = {s = n.s ! NOrd} ; +-- +-- NumNumeral numeral = {s = numeral.s ! NCard; n = numeral.n} ; +-- OrdNumeral numeral = {s = numeral.s ! NOrd} ; +-- +-- AdNum adn num = {s = \\c => adn.s ++ num.s!c ; n = num.n} ; +-- +-- OrdSuperl a = {s = \\c => a.s ! AAdj Superl c } ; +-- +-- DefArt = { +-- s = \\hasCard,n => artDef ; +-- sp = \\hasCard,n => case of { +-- => table { NCase Gen => "its"; _ => "it" } ; +-- => table { NCase Nom => "they"; NPAcc => "them"; NCase Gen => "theirs" } ; +-- _ => \\c => artDef +-- } +-- } ; +-- +-- IndefArt = { +-- s = \\hasCard,n => case of { +-- => artIndef ; +-- _ => [] +-- } ; +-- sp = \\hasCard,n => case of { +-- => table {NCase Gen => "one's"; _ => "one" }; +-- => table {NCase Gen => "ones'"; _ => "ones" } ; +-- _ => \\c => [] +-- } +-- } ; +-- +-- MassNP cn = { +-- s = \\c => cn.s ! Sg ! npcase2case c ; +-- a = agrP3 Sg +-- } ; +-- +-- UseN n = n ; +-- UseN2 n = n ; +-----b UseN3 n = n ; +-- +-- Use2N3 f = { +-- s = \\n,c => f.s ! n ! Nom ; +-- g = f.g ; +-- c2 = f.c2 +-- } ; +-- +-- Use3N3 f = { +-- s = \\n,c => f.s ! n ! Nom ; +-- g = f.g ; +-- c2 = f.c3 +-- } ; +-- +-- ComplN2 f x = {s = \\n,c => f.s ! n ! Nom ++ f.c2 ++ x.s ! NPAcc ; g = f.g} ; +-- ComplN3 f x = { +-- s = \\n,c => f.s ! n ! Nom ++ f.c2 ++ x.s ! NPAcc ; +-- g = f.g ; +-- c2 = f.c3 +-- } ; +-- +-- AdjCN ap cn = { +-- s = \\n,c => preOrPost ap.isPre (ap.s ! agrgP3 n cn.g) (cn.s ! n ! c) ; +-- g = cn.g +-- } ; +-- RelCN cn rs = { +-- s = \\n,c => cn.s ! n ! c ++ rs.s ! agrgP3 n cn.g ; +-- g = cn.g +-- } ; +-- AdvCN cn ad = {s = \\n,c => cn.s ! n ! c ++ ad.s ; g = cn.g} ; +-- +-- SentCN cn sc = {s = \\n,c => cn.s ! n ! c ++ sc.s ; g = cn.g} ; +-- +-- ApposCN cn np = {s = \\n,c => cn.s ! n ! Nom ++ np.s ! NCase c ; g = cn.g} ; +-- +--} + +} diff --git a/lib/src/hungarian/NumeralHun.gf b/lib/src/hungarian/NumeralHun.gf new file mode 100644 index 000000000..5f22f0ae0 --- /dev/null +++ b/lib/src/hungarian/NumeralHun.gf @@ -0,0 +1,99 @@ +concrete NumeralHun of Numeral = CatHun [Numeral,Digits] ** open ResHun in +{ +--{ +-- +--lincat +-- Digit = {s : DForm => CardOrd => Case => Str} ; +-- Sub10 = {s : DForm => CardOrd => Case => Str ; n : Number} ; +-- Sub100 = {s : CardOrd => Case => Str ; n : Number} ; +-- Sub1000 = {s : CardOrd => Case => Str ; n : Number} ; +-- Sub1000000 = {s : CardOrd => Case => Str ; n : Number} ; +-- +--lin num x = x ; +--lin n2 = let two = mkNum "two" "twelve" "twenty" "second" in +-- {s = \\f,o => case of { +-- => regGenitiveS "twelfth" ; +-- _ => two.s ! f ! o +-- } +-- } ; +-- +--lin n3 = mkNum "three" "thirteen" "thirty" "third" ; +--lin n4 = mkNum "four" "fourteen" "forty" "fourth" ; +--lin n5 = mkNum "five" "fifteen" "fifty" "fifth" ; +--lin n6 = regNum "six" ; +--lin n7 = regNum "seven" ; +--lin n8 = mkNum "eight" "eighteen" "eighty" "eighth" ; +--lin n9 = mkNum "nine" "nineteen" "ninety" "ninth" ; +-- +--lin pot01 = mkNum "one" "eleven" "ten" "first" ** {n = Sg} ; +--lin pot0 d = d ** {n = Pl} ; +--lin pot110 = regCardOrd "ten" ** {n = Pl} ; +--lin pot111 = regCardOrd "eleven" ** {n = Pl} ; +--lin pot1to19 d = {s = d.s ! teen} ** {n = Pl} ; +--lin pot0as1 n = {s = n.s ! unit} ** {n = n.n} ; +--lin pot1 d = {s = d.s ! ten} ** {n = Pl} ; +--lin pot1plus d e = { +-- s = \\o,c => d.s ! ten ! NCard ! Nom ++ "-" ++ e.s ! unit ! o ! c ; n = Pl} ; +--lin pot1as2 n = n ; +--lin pot2 d = {s = \\o,c => d.s ! unit ! NCard ! Nom ++ mkCard o "hundred" ! c} ** {n = Pl} ; +--lin pot2plus d e = { +-- s = \\o,c => d.s ! unit ! NCard ! Nom ++ "hundred" ++ "and" ++ e.s ! o ! c ; n = Pl} ; +--lin pot2as3 n = n ; +--lin pot3 n = { +-- s = \\o,c => n.s ! NCard ! Nom ++ mkCard o "thousand" ! c ; n = Pl} ; +--lin pot3plus n m = { +-- s = \\o,c => n.s ! NCard ! Nom ++ "thousand" ++ m.s ! o ! c; n = Pl} ; +-- +---- numerals as sequences of digits +-- +-- lincat +-- Dig = TDigit ; +-- +-- lin +-- IDig d = d ** {tail = T1} ; +-- +-- IIDig d i = { +-- s = \\o,c => d.s ! NCard ! Nom ++ commaIf i.tail ++ i.s ! o ! c ; +-- n = Pl ; +-- tail = inc i.tail +-- } ; +-- +-- D_0 = mkDig "0" ; +-- D_1 = mk3Dig "1" "1st" Sg ; +-- D_2 = mk2Dig "2" "2nd" ; +-- D_3 = mk2Dig "3" "3rd" ; +-- D_4 = mkDig "4" ; +-- D_5 = mkDig "5" ; +-- D_6 = mkDig "6" ; +-- D_7 = mkDig "7" ; +-- D_8 = mkDig "8" ; +-- D_9 = mkDig "9" ; +-- +-- oper +-- commaIf : DTail -> Str = \t -> case t of { +-- T3 => "," ; +-- _ => [] +-- } ; +-- +-- inc : DTail -> DTail = \t -> case t of { +-- T1 => T2 ; +-- T2 => T3 ; +-- T3 => T1 +-- } ; +-- +-- mk2Dig : Str -> Str -> TDigit = \c,o -> mk3Dig c o Pl ; +-- mkDig : Str -> TDigit = \c -> mk2Dig c (c + "th") ; +-- +-- mk3Dig : Str -> Str -> Number -> TDigit = \c,o,n -> { +-- s = table {NCard => regGenitiveS c ; NOrd => regGenitiveS o} ; +-- n = n +-- } ; +-- +-- TDigit = { +-- n : Number ; +-- s : CardOrd => Case => Str +-- } ; +-- +--} + +} diff --git a/lib/src/hungarian/ParadigmsHun.gf b/lib/src/hungarian/ParadigmsHun.gf new file mode 100644 index 000000000..5f3da0c56 --- /dev/null +++ b/lib/src/hungarian/ParadigmsHun.gf @@ -0,0 +1,733 @@ +--# -path=.:../abstract:../../prelude:../common + +--1 Hunlish Lexical Paradigms +-- +-- Aarne Ranta 2003--2005 +-- +-- This is an API for the user of the resource grammar +-- for adding lexical items. It gives functions for forming +-- expressions of open categories: nouns, adjectives, verbs. +-- +-- Closed categories (determiners, pronouns, conjunctions) are +-- accessed through the resource syntax API, $Structural.gf$. +-- +-- The main difference with $MorphoHun.gf$ is that the types +-- referred to are compiled resource grammar types. We have moreover +-- had the design principle of always having existing forms, rather +-- than stems, as string arguments of the paradigms. +-- +-- The structure of functions for each word class $C$ is the following: +-- first we give a handful of patterns that aim to cover all +-- regular cases. Then we give a worst-case function $mkC$, which serves as an +-- escape to construct the most irregular words of type $C$. +-- However, this function should only seldom be needed: we have a +-- separate module [``IrregHun`` ../../english/IrregHun.gf], +-- which covers irregular verbss. + +resource ParadigmsHun = open + (Predef=Predef), + Prelude, + ResHun, + CatHun + in +{ + flags optimize = noexpand ; + +--{ +----2 Parameters +---- +---- To abstract over gender names, we define the following identifiers. +-- +--oper +-- Gender : Type ; +-- +-- human : Gender ; +-- nonhuman : Gender ; +-- masculine : Gender ; --% +-- feminine : Gender ; --% +-- +---- To abstract over number names, we define the following. +-- +-- Number : Type ; +-- +-- singular : Number ; +-- plural : Number ; +-- +---- To abstract over case names, we define the following. +-- +-- Case : Type ; --% +-- +-- nominative : Case ; --% +-- genitive : Case ; --% +-- +---- Prepositions are used in many-argument functions for rection. +---- The resource category $Prep$ is used. +-- +---- The number of a noun phrase can be extracted with the following +---- function. +-- +-- npNumber : NP -> Number ; -- exctract the number of a noun phrase +-- +-- +----2 Nouns +-- +---- Nouns are constructed by the function $mkN$, which takes a varying +---- number of arguments. +-- + +oper + mkN = overload { + + mkN : Str -> Noun = + \s -> lin N (regNoun s) ; + } ; + +-- +---- The regular function captures the variants for nouns ending with +---- "s","sh","x","z" or "y": "kiss - kisses", "flash - flashes"; +---- "fly - flies" (but "toy - toys"), +-- +-- mkN : (flash : Str) -> N ; -- plural s, incl. flash-flashes, fly-flies +-- +---- In practice the worst case is to give singular and plural nominative. +-- +-- mkN : (man,men : Str) -> N ; -- irregular plural +-- +---- The theoretical worst case: give all four forms. +-- +-- mkN : (man,men,man's,men's : Str) -> N ; -- irregular genitives +-- +---- Change gender from the default $nonhuman$. +-- +-- mkN : Gender -> N -> N ; -- default nonhuman +-- +----3 Compound nouns +---- +---- A compound noun is an uninflected string attached to an inflected noun, +---- such as "baby boom", "chief executive officer". +-- +-- mkN : Str -> N -> N -- e.g. baby + boom +-- } ; +-- +-- +----3 Relational nouns +-- +-- mkN2 : overload { +-- mkN2 : Str -> N2 ; -- reg. noun, prep. "of" --% +-- mkN2 : N -> N2 ; -- e.g. wife of (default prep. to) +-- mkN2 : N -> Str -> N2 ; -- access to --% +-- mkN2 : N -> Prep -> N2 ; -- e.g. access to +-- mkN2 : Str -> Str -> N2 ; -- access to (regular noun) --% +-- } ; +-- +---- Use the function $mkPrep$ or see the section on prepositions below to +---- form other prepositions. +---- +---- Three-place relational nouns ("the connection from x to y") need two prepositions. +-- +-- mkN3 : N -> Prep -> Prep -> N3 ; -- e.g. connection from x to y +-- +-- +-- +----3 Proper names and noun phrases +---- +---- Proper names, with a regular genitive, are formed from strings. +-- +-- mkPN : overload { +-- +-- mkPN : Str -> PN ; +-- +---- Sometimes a common noun can be reused as a proper name, e.g. "Bank" +-- +-- mkPN : N -> PN --% +-- } ; +-- +----3 Determiners and quantifiers +-- +-- mkQuant : overload { +-- mkQuant : (this, these : Str) -> Quant ; --% +-- mkQuant : (no_sg, no_pl, none_sg, non_pl : Str) -> Quant ; --% +-- } ; +-- +-- mkOrd : Str -> Ord ; --% +-- +----2 Adjectives +-- +-- mkA : overload { +-- +---- For regular adjectives, the adverbial and comparison forms are derived. This holds +---- even for cases with the variations "happy - happily - happier - happiest", +---- "free - freely - freer - freest", and "rude - rudest". +-- +-- mkA : (happy : Str) -> A ; -- regular adj, incl. happy-happier, rude-ruder +-- +---- However, the duplication of the final consonant cannot be predicted, +---- but a separate case is used to give the comparative +-- +-- mkA : (fat,fatter : Str) -> A ; -- irreg. comparative +-- +---- As many as four forms may be needed. +-- +-- mkA : (good,better,best,well : Str) -> A -- completely irreg. +-- } ; +-- +---- Regular comparison is formed by "more - most" for words with two vowels separated +---- and terminated by some other letters. To force this or the opposite, +---- the following can be used: +-- +-- compoundA : A -> A ; -- force comparison with more/most +-- simpleA : A -> A ; -- force comparison with -er,-est +-- irregAdv : A -> Str -> A ; -- adverb irreg, e.g. "fast" +-- +----3 Two-place adjectives +-- +-- mkA2 : overload { +-- mkA2 : A -> Prep -> A2 ; -- absent from +-- mkA2 : A -> Str -> A2 ; -- absent from --% +-- mkA2 : Str -> Prep -> A2 ; -- absent from --% +-- mkA2 : Str -> Str -> A2 -- absent from --% +-- +-- } ; +-- +-- +----2 Adverbs +-- +---- Adverbs are not inflected. Most lexical ones have position +---- after the verb. Some can be preverbal (e.g. "always"). +-- +-- mkAdv : Str -> Adv ; -- e.g. today +-- mkAdV : Str -> AdV ; -- e.g. always +-- +---- Adverbs modifying adjectives and sentences can also be formed. +-- +-- mkAdA : Str -> AdA ; -- e.g. quite +-- +---- Adverbs modifying numerals +-- +-- mkAdN : Str -> AdN ; -- e.g. approximately +-- +----2 Prepositions +---- +---- A preposition as used for rection in the lexicon, as well as to +---- build $PP$s in the resource API, just requires a string. +-- +-- mkPrep : Str -> Prep ; -- e.g. "in front of" +-- noPrep : Prep ; -- no preposition +-- +---- (These two functions are synonyms.) +-- +----2 Conjunctions +---- +-- +-- mkConj : overload { +-- mkConj : Str -> Conj ; -- and (plural agreement) --% +-- mkConj : Str -> Number -> Conj ; -- or (agrement number given as argument) --% +-- mkConj : Str -> Str -> Conj ; -- both ... and (plural) --% +-- mkConj : Str -> Str -> Number -> Conj ; -- either ... or (agrement number given as argument) --% +-- } ; +-- +----2 Verbs +---- +-- +---- Verbs are constructed by the function $mkV$, which takes a varying +---- number of arguments. +-- +-- mkV : overload { +-- +---- The regular verb function recognizes the special cases where the last +---- character is "y" ("cry-cries" but "buy-buys") or a sibilant +---- ("kiss-"kisses", "jazz-jazzes", "rush-rushes", "munch - munches", +---- "fix - fixes"). +-- +-- mkV : (cry : Str) -> V ; -- regular, incl. cry-cries, kiss-kisses etc +-- +---- Give the present and past forms for regular verbs where +---- the last letter is duplicated in some forms, +---- e.g. "rip - ripped - ripping". +-- +-- mkV : (stop, stopped : Str) -> V ; -- reg. with consonant duplication +-- +---- There is an extensive list of irregular verbs in the module $IrregularHun$. +---- In practice, it is enough to give three forms, +---- e.g. "drink - drank - drunk". +-- +-- mkV : (drink, drank, drunk : Str) -> V ; -- ordinary irregular +-- +---- Irregular verbs with duplicated consonant in the present participle. +-- +-- mkV : (run, ran, run, running : Str) -> V ; -- irregular with duplication --% +-- +---- Except for "be", the worst case needs five forms: the infinitive and +---- the third person singular present, the past indicative, and the +---- past and present participles. +-- +-- mkV : (go, goes, went, gone, going : Str) -> V ; -- totally irregular +-- +---- Adds a prefix to an exisiting verb. This is most useful to create +---- prefix-variants of irregular verbs from $IrregHun$, e.g. "undertake". +-- +-- mkV : Str -> V -> V ; -- fix compound, e.g. under+take +-- }; +-- +---- Verbs with a particle. +---- The particle, such as in "switch on", is given as a string. +-- +-- partV : V -> Str -> V ; -- with particle, e.g. switch + on +-- +---- Reflexive verbs. +---- By default, verbs are not reflexive; this function makes them that. +-- +-- reflV : V -> V ; -- reflexive e.g. behave oneself +-- +----3 Two-place verbs +---- +---- Two-place verbs need a preposition, except the special case with direct object. +---- (transitive verbs). Notice that a particle comes from the $V$. +-- +-- mkV2 : overload { +-- mkV2 : Str -> V2 ; -- kill --% +-- mkV2 : V -> V2 ; -- transitive, e.g. hit +-- mkV2 : V -> Prep -> V2 ; -- with preposiiton, e.g. believe in +-- mkV2 : V -> Str -> V2 ; -- believe in --% +-- mkV2 : Str -> Prep -> V2 ; -- believe in --% +-- mkV2 : Str -> Str -> V2 -- believe in --% +-- }; +-- +----3 Three-place verbs +---- +---- Three-place (ditransitive) verbs need two prepositions, of which +---- the first one or both can be absent. +-- +-- mkV3 : overload { +-- mkV3 : V -> V3 ; -- ditransitive, e.g. give,_,_ +-- mkV3 : V -> Prep -> Prep -> V3 ; -- two prepositions, e.g. speak, with, about +-- mkV3 : V -> Prep -> V3 ; -- give,_,to --% +-- mkV3 : V -> Str -> V3 ; -- give,_,to --% +-- mkV3 : Str -> Str -> V3 ; -- give,_,to --% +-- mkV3 : Str -> V3 ; -- give,_,_ --% +-- }; +-- +----3 Other complement patterns +---- +---- Verbs and adjectives can take complements such as sentences, +---- questions, verb phrases, and adjectives. +-- +-- mkV0 : V -> V0 ; --% +-- mkVS : V -> VS ; -- sentence-compl e.g. say (that S) +-- mkV2S : V -> Prep -> V2S ; -- e.g. tell (NP) (that S) +-- mkVV : V -> VV ; -- e.g. want (to VP) +-- ingVV : V -> VV ; -- e.g. start (VPing) +-- mkV2V : V -> Prep -> Prep -> V2V ; -- e.g. want (noPrep NP) (to VP) +-- ingV2V : V -> Prep -> Prep -> V2V ; -- e.g. prevent (noPrep NP) (from VP-ing) +-- mkVA : V -> VA ; -- e.g. become (AP) +-- mkV2A : V -> Prep -> V2A ; -- e.g. paint (NP) (AP) +-- mkVQ : V -> VQ ; -- e.g. wonder (QS) +-- mkV2Q : V -> Prep -> V2Q ; -- e.g. ask (NP) (QS) +-- +-- mkAS : A -> AS ; --% +-- mkA2S : A -> Prep -> A2S ; --% +-- mkAV : A -> AV ; --% +-- mkA2V : A -> Prep -> A2V ; --% +-- +---- Notice: Categories $V0, AS, A2S, AV, A2V$ are just $A$. +---- $V0$ is just $V$; the second argument is treated as adverb. +-- +-- V0 : Type ; --% +-- AS, A2S, AV, A2V : Type ; --% +-- +----2 Other categories +-- +--mkSubj : Str -> Subj = \s -> lin Subj {s = s} ; --% +-- +----. +----2 Definitions of paradigms +---- +---- The definitions should not bother the user of the API. So they are +---- hidden from the document. +-- +-- Gender = ResHun.Gender ; +-- Number = ResHun.Number ; +-- Case = ResHun.NPCase ; +-- human = Masc ; +-- nonhuman = Neutr ; +-- masculine = Masc ; +-- feminine = Fem ; +-- singular = Sg ; +-- plural = Pl ; +-- nominative = npNom ; +-- genitive = npGen ; +-- +-- npNumber np = (fromAgr np.a).n ; +-- +-- Preposition : Type = Str ; -- obsolete +-- +-- regN = \ray -> +-- let rays = add_s ray +-- in +-- mk2N ray rays ; +-- +-- +-- add_s : Str -> Str = \w -> case w of { +-- _ + ("io" | "oo") => w + "s" ; -- radio, bamboo +-- _ + ("s" | "z" | "x" | "sh" | "ch" | "o") => w + "es" ; -- bus, hero +-- _ + ("a" | "o" | "u" | "e") + "y" => w + "s" ; -- boy +-- x + "y" => x + "ies" ; -- fly +-- _ => w + "s" -- car +-- } ; +-- +-- duplFinal : Str -> Str = \w -> case w of { +-- _ + ("a" | "e" | "o") + ("a" | "e" | "i" | "o" | "u") + ? => w ; -- waited, needed +-- _ + ("a" | "e" | "i" | "o" | "u") + +-- c@("b"|"d"|"g"|"m"|"n"|"p"|"r"|"t") => w + c ; -- omitted, manned +-- _ => w +-- } ; +-- +-- mk2N = \man,men -> +-- let mens = case last men of { +-- "s" => men + "'" ; +-- _ => men + "'s" +-- } +-- in +-- mk4N man men (man + "'s") mens ; +-- +-- mk4N = \man,men,man's,men's -> +-- lin N (mkNoun man man's men men's ** {g = Neutr}) ; +-- +-- genderN g man = lin N {s = man.s ; g = g} ; +-- +-- compoundN s n = lin N {s = \\x,y => s ++ n.s ! x ! y ; g=n.g} ; +-- +-- mkPN = overload { +-- mkPN : Str -> PN = regPN ; +-- mkPN : N -> PN = nounPN +-- } ; +-- +-- mkN2 = overload { +-- mkN2 : N -> Prep -> N2 = prepN2 ; +-- mkN2 : N -> Str -> N2 = \n,s -> prepN2 n (mkPrep s); +-- mkN2 : Str -> Str -> N2 = \n,s -> prepN2 (regN n) (mkPrep s); +-- mkN2 : N -> N2 = \n -> prepN2 n (mkPrep "of") ; +-- mkN2 : Str -> N2 = \s -> prepN2 (regN s) (mkPrep "of") +-- } ; +-- +-- prepN2 = \n,p -> lin N2 (n ** {c2 = p.s}) ; +-- regN2 n = prepN2 (regN n) (mkPrep "of") ; +-- +-- mkN3 = \n,p,q -> lin N3 (n ** {c2 = p.s ; c3 = q.s}) ; +-- +----3 Relational common noun phrases +---- +---- In some cases, you may want to make a complex $CN$ into a +---- relational noun (e.g. "the old town hall of"). +-- +-- cnN2 : CN -> Prep -> N2 ; +-- cnN3 : CN -> Prep -> Prep -> N3 ; +-- +---- This is obsolete. +-- cnN2 = \n,p -> lin N2 (n ** {c2 = p.s}) ; +-- cnN3 = \n,p,q -> lin N3 (n ** {c2 = p.s ; c3 = q.s}) ; +-- +-- regPN n = regGenPN n human ; +-- regGenPN n g = lin PN {s = table {Gen => n + "'s" ; _ => n} ; g = g} ; +-- nounPN n = lin PN {s = n.s ! singular ; g = n.g} ; +-- +-- mkQuant = overload { +-- mkQuant : (this, these : Str) -> Quant = \sg,pl -> mkQuantifier sg pl sg pl; +-- mkQuant : (no_sg, no_pl, none_sg, non_pl : Str) -> Quant = mkQuantifier; +-- } ; +-- +-- mkQuantifier : Str -> Str -> Str -> Str -> Quant = +-- \sg,pl,sg',pl' -> lin Quant { +-- s = \\_ => table { Sg => sg ; Pl => pl } ; +-- sp = \\_ => table { +-- Sg => \\c => regGenitiveS sg' ! npcase2case c ; Pl => \\c => regGenitiveS pl' ! npcase2case c} +-- } ; +-- +-- mkOrd : Str -> Ord = \x -> lin Ord { s = regGenitiveS x}; +-- +-- mk2A a b = mkAdjective a a a b ; +-- regA a = case a of { +-- _ + ("a" | "e" | "i" | "o" | "u" | "y") + ? + _ + +-- ("a" | "e" | "i" | "o" | "u" | "y") + ? + _ => +-- lin A (compoundADeg (regADeg a)) ; +-- _ => lin A (regADeg a) +-- } ; +-- +-- prepA2 a p = lin A2 (a ** {c2 = p.s}) ; +-- +-- ADeg = A ; ---- +-- +-- mkADeg a b c d = mkAdjective a b c d ; +-- +-- regADeg happy = +-- let +-- happ = init happy ; +-- y = last happy ; +-- happie = case y of { +-- "y" => happ + "ie" ; +-- "e" => happy ; +-- _ => duplFinal happy + "e" +-- } ; +-- in mkADeg happy (happie + "r") (happie + "st") (adj2adv happy) ; +-- +-- adj2adv : Str -> Str = \happy -> +-- case happy of { +-- _ + "ble" => init happy + "y" ; +-- _ + "y" => init happy + "ily" ; +-- _ + "ll" => happy + "y" ; +-- _ => happy + "ly" +-- } ; +-- +-- duplADeg fat = +-- mkADeg fat +-- (fat + last fat + "er") (fat + last fat + "est") (adj2adv fat) ; +-- +-- compoundADeg a = +-- let ad = (a.s ! AAdj Posit Nom) +-- in mkADeg ad ("more" ++ ad) ("most" ++ ad) (a.s ! AAdv) ; +-- +-- adegA a = a ; +-- +-- mkAdv x = lin Adv (ss x) ; +-- mkAdV x = lin AdV (ss x) ; +-- mkAdA x = lin AdA (ss x) ; +-- mkAdN x = lin AdN (ss x) ; +-- +-- mkPrep p = lin Prep (ss p) ; +-- noPrep = mkPrep [] ; +-- +-- mk5V a b c d e = lin V (mkVerb a b c d e ** {s1 = []}) ; +-- +-- regV cry = +-- let +-- cries = (regN cry).s ! Pl ! Nom ; -- ! +-- cried : Str = case cries of { +-- _ + "es" => init cries + "d" ; +-- _ => duplFinal cry + "ed" +-- } ; +-- crying : Str = case cry of { +-- _ + "ee" => cry + "ing" ; +-- d + "ie" => d + "ying" ; +-- us + "e" => us + "ing" ; +-- _ => duplFinal cry + "ing" +-- } +-- in mk5V cry cries cried cried crying ; +-- +-- reg2V fit fitted = +-- let fitt = Predef.tk 2 fitted ; +-- in +-- if_then_else V (pbool2bool (Predef.eqStr (last fit) (last fitt))) +-- (mk5V fit (fit + "s") (fitt + "ed") (fitt + "ed") (fitt + "ing")) +-- (regV fit) ; +-- +-- regDuplV fit = +-- case last fit of { +-- ("a" | "e" | "i" | "o" | "u" | "y") => +-- Predef.error (["final duplication makes no sense for"] ++ fit) ; +-- t => +-- let fitt = fit + t in +-- mk5V fit (fit + "s") (fitt + "ed") (fitt + "ed") (fitt + "ing") +-- } ; +-- +-- irregV x y z = let reg = (regV x).s in +-- mk5V x (reg ! VPres) y z (reg ! VPresPart) ** {s1 = []} ; +-- +-- irreg4V x y z w = let reg = (regV x).s in +-- mk5V x (reg ! VPres) y z w ** {s1 = []} ; +-- +-- irregDuplV fit y z = +-- let +-- fitting = (regDuplV fit).s ! VPresPart +-- in +-- mk5V fit (fit + "s") y z fitting ; +-- +-- partV v p = lin V {s = \\f => v.s ! f ++ p ; isRefl = v.isRefl} ; +-- reflV v = lin V {s = v.s ; part = v.part ; isRefl = True} ; +-- +-- prepV2 v p = lin V2 {s = v.s ; s1 = v.s1 ; c2 = p.s ; isRefl = v.isRefl} ; +-- dirV2 v = prepV2 v noPrep ; +-- +-- prepPrepV3 v p q = +-- lin V3 {s = v.s ; s1 = v.s1 ; c2 = p.s ; c3 = q.s ; isRefl = v.isRefl} ; +-- dirV3 v p = prepPrepV3 v noPrep p ; +-- dirdirV3 v = dirV3 v noPrep ; +-- +-- mkVS v = lin VS v ; +-- mkVV v = lin VV { +-- s = table {VVF vf => v.s ! vf ; _ => v.s ! VInf} ; +-- typ = VVInf +-- } ; +-- ingVV v = lin VV { +-- s = table {VVF vf => v.s ! vf ; _ => v.s ! VInf} ; +-- typ = VVPresPart +-- } ; +-- mkVQ v = lin VQ v ; +-- +-- V0 : Type = V ; +---- V2S, V2V, V2Q : Type = V2 ; +-- AS, A2S, AV : Type = A ; +-- A2V : Type = A2 ; +-- +-- mkV0 v = v ; +-- mkV2S v p = lin V2S (prepV2 v p) ; +-- mkV2V v p t = lin V2V (prepV2 v p ** {c3 = t.s ; typ = VVAux}) ; +-- ingV2V v p t = lin V2V (prepV2 v p ** {c3 = t.s ; typ = VVPresPart}) ; +-- mkVA v = lin VA v ; +-- mkV2A v p = lin V2A (prepV2 v p) ; +-- mkV2Q v p = lin V2Q (prepV2 v p) ; +-- +-- mkAS v = v ; +-- mkA2S v p = lin A (prepA2 v p) ; +-- mkAV v = v ; +-- mkA2V v p = prepA2 v p ; +-- +-- +---- pre-overload API and overload definitions +-- +-- mk4N : (man,men,man's,men's : Str) -> N ; +-- regN : Str -> N ; +-- mk2N : (man,men : Str) -> N ; +-- genderN : Gender -> N -> N ; +-- compoundN : Str -> N -> N ; +-- +-- mkN = overload { +-- mkN : (man,men,man's,men's : Str) -> N = mk4N ; +-- mkN : Str -> N = regN ; +-- mkN : (man,men : Str) -> N = mk2N ; +-- mkN : Gender -> N -> N = genderN ; +-- mkN : Str -> N -> N = compoundN +-- } ; +-- +---- Relational nouns ("daughter of x") need a preposition. +-- +-- prepN2 : N -> Prep -> N2 ; +-- +---- The most common preposition is "of", and the following is a +---- shortcut for regular relational nouns with "of". +-- +-- regN2 : Str -> N2 ; +-- +-- mk2A : (free,freely : Str) -> A ; +-- regA : Str -> A ; +-- +-- mkA = overload { +-- mkA : Str -> A = regA ; +-- mkA : (fat,fatter : Str) -> A = \fat,fatter -> +-- mkAdjective fat fatter (init fatter + "st") (adj2adv fat) ; +-- mkA : (good,better,best,well : Str) -> A = \a,b,c,d -> +-- mkAdjective a b c d +-- } ; +-- +-- compoundA = compoundADeg ; +-- simpleA a = +-- let ad = (a.s ! AAdj Posit Nom) +-- in regADeg ad ; +-- +-- irregAdv a adv = lin A {s = table {AAdv => adv; aform => a.s ! aform}} ; +-- +-- prepA2 : A -> Prep -> A2 ; +-- +-- mkA2 = overload { +-- mkA2 : A -> Prep -> A2 = prepA2 ; +-- mkA2 : A -> Str -> A2 = \a,p -> prepA2 a (mkPrep p) ; +-- mkA2 : Str -> Prep -> A2 = \a,p -> prepA2 (regA a) p; +-- mkA2 : Str -> Str -> A2 = \a,p -> prepA2 (regA a) (mkPrep p); +-- } ; +-- +-- mk5V : (go, goes, went, gone, going : Str) -> V ; +-- regV : (cry : Str) -> V ; +-- reg2V : (stop, stopped : Str) -> V; +-- irregV : (drink, drank, drunk : Str) -> V ; +-- irreg4V : (run, ran, run, running : Str) -> V ; +-- +-- -- Use reg2V instead +-- regDuplV : Str -> V ; +-- -- Use irreg4V instead +-- irregDuplV : (get, got, gotten : Str) -> V ; +-- +-- mkV = overload { +-- mkV : (cry : Str) -> V = regV ; +-- mkV : (stop, stopped : Str) -> V = reg2V ; +-- mkV : (drink, drank, drunk : Str) -> V = irregV ; +-- mkV : (run, ran, run, running : Str) -> V = irreg4V ; +-- mkV : (go, goes, went, gone, going : Str) -> V = mk5V ; +-- mkV : Str -> V -> V = prefixV +-- }; +-- +-- prepV2 : V -> Prep -> V2 ; +-- dirV2 : V -> V2 ; +-- prefixV : Str -> V -> V = \p,v -> lin V { s = \\vform => p + v.s ! vform; isRefl = v.isRefl } ; +-- +-- mkV2 = overload { +-- mkV2 : V -> V2 = dirV2 ; +-- mkV2 : Str -> V2 = \s -> dirV2 (regV s) ; +-- mkV2 : V -> Prep -> V2 = prepV2 ; +-- mkV2 : V -> Str -> V2 = \v,p -> prepV2 v (mkPrep p) ; +-- mkV2 : Str -> Prep -> V2 = \v,p -> prepV2 (regV v) p ; +-- mkV2 : Str -> Str -> V2 = \v,p -> prepV2 (regV v) (mkPrep p) +-- }; +-- +-- prepPrepV3 : V -> Prep -> Prep -> V3 ; +-- dirV3 : V -> Prep -> V3 ; +-- dirdirV3 : V -> V3 ; +-- +-- mkV3 = overload { +-- mkV3 : V -> Prep -> Prep -> V3 = prepPrepV3 ; +-- mkV3 : V -> Prep -> V3 = dirV3 ; +-- mkV3 : V -> Str -> V3 = \v,s -> dirV3 v (mkPrep s); +-- mkV3 : Str -> Str -> V3 = \v,s -> dirV3 (regV v) (mkPrep s); +-- mkV3 : V -> V3 = dirdirV3 ; +-- mkV3 : Str -> V3 = \v -> dirdirV3 (regV v) ; +-- } ; +-- +-- mkConj = overload { +-- mkConj : Str -> Conj = \y -> mk2Conj [] y plural ; +-- mkConj : Str -> Number -> Conj = \y,n -> mk2Conj [] y n ; +-- mkConj : Str -> Str -> Conj = \x,y -> mk2Conj x y plural ; +-- mkConj : Str -> Str -> Number -> Conj = mk2Conj ; +-- } ; +-- +-- mk2Conj : Str -> Str -> Number -> Conj = \x,y,n -> +-- lin Conj (sd2 x y ** {n = n}) ; +-- +------ obsolete +-- +---- Comparison adjectives may two more forms. +-- +-- ADeg : Type ; +-- +-- mkADeg : (good,better,best,well : Str) -> ADeg ; +-- +---- The regular pattern recognizes two common variations: +---- "-e" ("rude" - "ruder" - "rudest") and +---- "-y" ("happy - happier - happiest - happily") +-- +-- regADeg : Str -> ADeg ; -- long, longer, longest +-- +---- However, the duplication of the final consonant is nor predicted, +---- but a separate pattern is used: +-- +-- duplADeg : Str -> ADeg ; -- fat, fatter, fattest +-- +---- If comparison is formed by "more", "most", as in general for +---- long adjective, the following pattern is used: +-- +-- compoundADeg : A -> ADeg ; -- -/more/most ridiculous +-- +---- From a given $ADeg$, it is possible to get back to $A$. +-- +-- adegA : ADeg -> A ; +-- +-- +-- regPN : Str -> PN ; +-- regGenPN : Str -> Gender -> PN ; -- John, John's +-- +---- Sometimes you can reuse a common noun as a proper name, e.g. "Bank". +-- +-- nounPN : N -> PN ; +-- +-- +-- +--} ; + +} diff --git a/lib/src/hungarian/ParseEngHun.gf b/lib/src/hungarian/ParseEngHun.gf new file mode 100644 index 000000000..b4775d378 --- /dev/null +++ b/lib/src/hungarian/ParseEngHun.gf @@ -0,0 +1,50 @@ +abstract ParseHunAbs = + Tense, + Cat, + Noun, + Adjective, + Numeral, + Symbol, + Conjunction, + Verb - [SlashV2V, PassV2], + Adverb, + Phrase, + Sentence, + Relative, + Idiom [VP, ProgrVP], + Extra [NP, Quant, VPSlash, VP, GenNP, PassVPSlash], + DictHunAbs ** +{ +--{ +-- +--fun CompoundCN : Num -> N -> CN -> CN ; +-- DashCN : N -> N -> N ; +-- GerundN : V -> N ; +-- GerundAP : V -> AP ; +-- PastPartAP : V2 -> AP ; +-- myself_NP : NP ; +-- yourselfSg_NP : NP ; +-- himself_NP : NP ; +-- herself_NP : NP ; +-- itself_NP : NP ; +-- ourself_NP : NP ; +-- yourselfPl_NP : NP ; +-- themself_NP : NP ; +-- OrdCompar : A -> Ord ; +-- +-- PositAdVAdj : A -> AdV ; +-- +-- UseQuantPN : Quant -> PN -> NP; +-- +-- SlashV2V : V2V -> Pol -> VP -> VPSlash ; +-- +-- ComplPredVP : NP -> VP -> Cl ; +-- +-- that_RP, no_RP : RP ; +-- +-- CompS : S -> Comp ; +-- CompVP : VP -> Comp ; +-- +--} + +} diff --git a/lib/src/hungarian/ParseHun.gf b/lib/src/hungarian/ParseHun.gf new file mode 100644 index 000000000..29263ff26 --- /dev/null +++ b/lib/src/hungarian/ParseHun.gf @@ -0,0 +1,101 @@ +--# -path=alltenses +concrete ParseHun of ParseHunAbs = + TenseX - [Pol, PNeg, PPos], + CatHun, + NounHun, + AdjectiveHun, + NumeralHun, + SymbolHun, + ConjunctionHun, + VerbHun - [SlashV2V, PassV2], + AdverbHun, + PhraseHun, + SentenceHun, + RelativeHun, + IdiomHun [VP, Tense, ProgrVP], + ExtraHun [NP, Quant, VPSlash, VP, Tense, GenNP, PassVPSlash], + DictHun ** +open MorphoHun, ResHun, ParadigmsHun, Prelude in +{ +--{ +-- +--flags +-- literal=Symb ; +-- +--lin +-- myself_NP = regNP "myself" singular ; +-- yourselfSg_NP = regNP "yourself" singular ; +-- himself_NP = regNP "himself" singular ; +-- herself_NP = regNP "herself" singular ; +-- itself_NP = regNP "itself" singular ; +-- ourself_NP = regNP "ourself" plural ; +-- yourselfPl_NP = regNP "yourself" plural ; +-- themself_NP = regNP "themself" plural ; +-- +-- CompoundCN num noun cn = { +-- s = \\n,c => num.s ! Nom ++ noun.s ! num.n ! Nom ++ cn.s ! n ! c ; +-- g = cn.g +-- } ; +-- +-- DashCN noun1 noun2 = { +-- s = \\n,c => noun1.s ! Sg ! Nom ++ "-" ++ noun2.s ! n ! c ; +-- g = noun2.g +-- } ; +-- +-- GerundN v = { +-- s = \\n,c => v.s ! VPresPart ; +-- g = Neutr +-- } ; +-- +-- GerundAP v = { +-- s = \\agr => v.s ! VPresPart ; +-- isPre = True +-- } ; +-- +-- PastPartAP v = { +-- s = \\agr => v.s ! VPPart ; +-- isPre = True +-- } ; +-- +-- OrdCompar a = {s = \\c => a.s ! AAdj Compar c } ; +-- +-- PositAdVAdj a = {s = a.s ! AAdv} ; +-- +-- UseQuantPN q pn = {s = \\c => q.s ! False ! Sg ++ pn.s ! npcase2case c ; a = agrgP3 Sg pn.g} ; +-- +-- SlashV2V v p vp = insertObjc (\\a => p.s ++ case p.p of {CPos => ""; _ => "not"} ++ +-- v.c3 ++ +-- infVP v.typ vp a) +-- (predVc v) ; +-- +-- ComplPredVP np vp = { +-- s = \\t,a,b,o => +-- let +-- verb = vp.s ! t ! a ! b ! o ! np.a ; +-- compl = vp.s2 ! np.a +-- in +-- case o of { +-- ODir => compl ++ "," ++ np.s ! npNom ++ verb.aux ++ verb.adv ++ vp.ad ++ verb.fin ++ verb.inf ; +-- OQuest => verb.aux ++ compl ++ "," ++ np.s ! npNom ++ verb.adv ++ vp.ad ++ verb.fin ++ verb.inf +-- } +-- } ; +-- +-- that_RP = { +-- s = \\_ => "that" ; +-- a = RNoAg +-- } ; +-- no_RP = { +-- s = \\_ => "" ; +-- a = RNoAg +-- } ; +-- +-- CompS s = {s = \\_ => "that" ++ s.s} ; +-- CompVP vp = {s = \\a => infVP VVInf vp a} ; +-- +--lin +-- PPos = {s = [] ; p = CPos} ; +-- PNeg = {s = [] ; p = CNeg True} ; -- contracted: don't +-- +--} + +} diff --git a/lib/src/hungarian/PhraseHun.gf b/lib/src/hungarian/PhraseHun.gf new file mode 100644 index 000000000..4f1fe8131 --- /dev/null +++ b/lib/src/hungarian/PhraseHun.gf @@ -0,0 +1,32 @@ +concrete PhraseHun of Phrase = CatHun ** open Prelude, ResHun in +{ +--{ +-- +-- lin +-- PhrUtt pconj utt voc = {s = pconj.s ++ utt.s ++ voc.s} ; +-- +-- UttS s = s ; +-- UttQS qs = {s = qs.s ! QDir} ; +-- UttImpSg pol imp = {s = pol.s ++ imp.s ! pol.p ! ImpF Sg False} ; +-- UttImpPl pol imp = {s = pol.s ++ imp.s ! pol.p ! ImpF Pl False} ; +-- UttImpPol pol imp = {s = pol.s ++ imp.s ! pol.p ! ImpF Sg True} ; +-- +-- UttIP ip = {s = ip.s ! npNom} ; --- Acc also +-- UttIAdv iadv = iadv ; +-- UttNP np = {s = np.s ! npNom} ; +-- UttVP vp = {s = infVP VVInf vp (agrP3 Sg)} ; +-- UttAdv adv = adv ; +-- UttCN n = {s = n.s ! Sg ! Nom} ; +-- UttCard n = {s = n.s ! Nom} ; +-- UttAP ap = {s = ap.s ! agrP3 Sg} ; +-- UttInterj i = i ; +-- +-- NoPConj = {s = []} ; +-- PConjConj conj = {s = conj.s2} ; --- +-- +-- NoVoc = {s = []} ; +-- VocNP np = {s = "," ++ np.s ! npNom} ; +-- +--} + +} diff --git a/lib/src/hungarian/QuestionHun.gf b/lib/src/hungarian/QuestionHun.gf new file mode 100644 index 000000000..1768fff4a --- /dev/null +++ b/lib/src/hungarian/QuestionHun.gf @@ -0,0 +1,73 @@ +concrete QuestionHun of Question = CatHun ** open ResHun, Prelude in +{ +--{ +-- +-- flags optimize=all_subs ; +-- +-- lin +-- +-- QuestCl cl = { +-- s = \\t,a,p => +-- let cls = cl.s ! t ! a ! p +-- in table { +-- QDir => cls ! OQuest ; +-- QIndir => "if" ++ cls ! ODir +-- } ---- "whether" in ExtHun +-- } ; +-- +-- QuestVP qp vp = +-- let cl = mkClause (qp.s ! npNom) (agrP3 qp.n) vp +-- in {s = \\t,a,b,_ => cl.s ! t ! a ! b ! ODir} ; +-- +-- QuestSlash ip slash = +-- mkQuestion (ss (slash.c2 ++ ip.s ! NPAcc)) slash ; +-- --- stranding in ExratHun +-- +-- QuestIAdv iadv cl = mkQuestion iadv cl ; +-- +-- QuestIComp icomp np = +-- mkQuestion icomp (mkClause (np.s ! npNom) np.a (predAux auxBe)) ; +-- +-- +-- PrepIP p ip = {s = p.s ++ ip.s ! NPAcc} ; +-- +-- AdvIP ip adv = { +-- s = \\c => ip.s ! c ++ adv.s ; +-- n = ip.n +-- } ; +-- +-- IdetCN idet cn = { +-- s = \\c => idet.s ++ cn.s ! idet.n ! npcase2case c ; +-- n = idet.n +-- } ; +-- +-- IdetIP idet = { +-- s = \\c => idet.s ; +-- n = idet.n +-- } ; +-- +-- IdetQuant idet num = { +-- s = idet.s ! num.n ++ num.s ! Nom ; +-- n = num.n +-- } ; +-- +-- AdvIAdv i a = ss (i.s ++ a.s) ; +-- +-- CompIAdv a = a ; +-- CompIP p = ss (p.s ! npNom) ; +-- +-- lincat +-- QVP = ResHun.VP ; +-- lin +-- ComplSlashIP vp np = insertObjPre (\\_ => vp.c2 ++ np.s ! NPAcc) vp ; +-- AdvQVP vp adv = insertObj (\\_ => adv.s) vp ; +-- AddAdvQVP vp adv = insertObj (\\_ => adv.s) vp ; +-- +-- QuestQVP qp vp = +-- let cl = mkClause (qp.s ! npNom) (agrP3 qp.n) vp +-- in {s = \\t,a,b,_ => cl.s ! t ! a ! b ! ODir} ; +-- +-- +--} + +} diff --git a/lib/src/hungarian/RelativeHun.gf b/lib/src/hungarian/RelativeHun.gf new file mode 100644 index 000000000..67316dc16 --- /dev/null +++ b/lib/src/hungarian/RelativeHun.gf @@ -0,0 +1,56 @@ +concrete RelativeHun of Relative = CatHun ** open ResHun in +{ +--{ +-- +-- flags optimize=all_subs ; +-- +-- lin +-- +-- RelCl cl = { +-- s = \\t,a,p,_ => "such" ++ "that" ++ cl.s ! t ! a ! p ! ODir ; +-- c = npNom +-- } ; +-- +-- RelVP rp vp = { +-- s = \\t,ant,b,ag => +-- let +-- agr = case rp.a of { +-- RNoAg => ag ; +-- RAg a => a +-- } ; +-- cl = mkClause (rp.s ! RC (fromAgr agr).g npNom) agr vp +-- in +-- cl.s ! t ! ant ! b ! ODir ; +-- c = npNom +-- } ; +-- +---- Pied piping: "at which we are looking". Stranding and empty +---- relative are defined in $ExtraHun.gf$ ("that we are looking at", +---- "we are looking at"). +-- +-- RelSlash rp slash = { +-- s = \\t,a,p,agr => +-- slash.c2 ++ rp.s ! RPrep (fromAgr agr).g ++ slash.s ! t ! a ! p ! ODir ; +-- c = NPAcc +-- } ; +-- +-- FunRP p np rp = { +-- s = \\c => np.s ! NPAcc ++ p.s ++ rp.s ! RPrep (fromAgr np.a).g ; +-- a = RAg np.a +-- } ; +-- +-- IdRP = +-- { s = table { +-- RC _ (NCase Gen) => "whose" ; +-- RC Neutr _ => "which" ; +-- RC _ NPAcc => "whom" ; +-- RC _ (NCase Nom) => "who" ; +-- RPrep Neutr => "which" ; +-- RPrep _ => "whom" +-- } ; +-- a = RNoAg +-- } ; +-- +--} + +} diff --git a/lib/src/hungarian/ResHun.gf b/lib/src/hungarian/ResHun.gf new file mode 100644 index 000000000..81da3b47d --- /dev/null +++ b/lib/src/hungarian/ResHun.gf @@ -0,0 +1,552 @@ +--# -path=.:../abstract:../common:../../prelude + +--1 Hungarian auxiliary operations. + +-- This module contains operations that are needed to make the +-- resource syntax work. + +resource ResHun = ParamX ** open Prelude in +{ + + flags + optimize=noexpand ; + coding = utf8 ; + +-- Some parameters, such as $Number$, are inherited from $ParamX$. +-- +--2 For $Noun$ +-- +-- This is case as needed when inflecting nouns. +-- + param + Case = Nom | Acc | Dat | Ins | Ess | Tra | Cau + | Ill | Sub | All | Ine | Sup | Ade | Ela + | Del | Abl | Ter | For | Tem + ; + + Harm = H_a | H_e | H_o ; + + oper + Noun = {s : Number => Case => Str} ; + + endCase : Case -> HarmForms = \c -> case c of { + Nom => harm1 [] ; + Acc => harm3 "ot" "et" "öt" ; + Dat => harm "nak" "nek" ; + Ins => harm "al" "el" ; + Ess => harm "stul" "stül" ; + Tra => harm "á" "é" ; + Cau => harm1 "ért" ; + Ill => harm "ba" "be" ; + Sub => harm "ra" "re" ; + All => harm3 "hoz" "hez" "höz" ; + Ine => harm "ban" "ben" ; + Sup => harm3 "on" "en" "ön" ; + Ade => harm "nál" "nél" ; + Ela => harm "ból" "ből" ; + Del => harm "ról" "ről" ; + Abl => harm "tól" "tő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" + } ; + + harm3 : Str -> Str -> Str -> HarmForms = \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 ; + + regNoun : Str -> Noun = \w -> { + s = \\n,c => + let h = getHarm w + in + w + useHarm h (endNumber n) + useHarm h (endCase c) + } ; + + +-- +-- param +-- Agr = AgP1 Number | AgP2 Number | AgP3Sg Gender | AgP3Pl ; +-- +-- param +-- Gender = Neutr | Masc | Fem ; +-- +-- +----2 For $Verb$ +-- +---- Only these five forms are needed for open-lexicon verbs. +-- +-- param +-- VForm = +-- VInf +-- | VPres +-- | VPPart +-- | VPresPart +-- | VPast --# notpresent +-- ; +-- +---- Auxiliary verbs have special negative forms. +-- +-- VVForm = +-- VVF VForm +-- | VVPresNeg +-- | VVPastNeg --# notpresent +-- ; +-- +---- The order of sentence is needed already in $VP$. +-- +-- Order = ODir | OQuest ; +-- +---- The type of complement of a VV +-- +-- VVType = VVAux | VVInf | VVPresPart ; -- can do / try to do / start doing +-- +----2 For $Adjective$ +-- +-- AForm = AAdj Degree Case | AAdv ; +-- +----2 For $Relative$ +-- +-- RAgr = RNoAg | RAg Agr ; +-- RCase = RPrep Gender | RC Gender NPCase ; +-- +----2 For $Numeral$ +-- +-- CardOrd = NCard | NOrd ; +-- DForm = unit | teen | ten ; +-- +----2 Transformations between parameter types +-- +-- oper +-- toAgr : Number -> Person -> Gender -> Agr = \n,p,g -> +-- case p of { +-- P1 => AgP1 n ; +-- P2 => AgP2 n ; +-- P3 => case n of { +-- Sg => AgP3Sg g ; +-- Pl => AgP3Pl +-- } +-- } ; +-- +-- fromAgr : Agr -> {n : Number ; p : Person ; g : Gender} = \a -> case a of { +-- AgP1 n => {n = n ; p = P1 ; g = Masc} ; +-- AgP2 n => {n = n ; p = P2 ; g = Masc} ; +-- AgP3Pl => {n = Pl ; p = P3 ; g = Masc} ; +-- AgP3Sg g => {n = Sg ; p = P3 ; g = g} +-- } ; +-- +-- agrP3 : Number -> Agr = \n -> agrgP3 n Neutr ; +-- +-- agrgP3 : Number -> Gender -> Agr = \n,g -> toAgr n P3 g ; +-- +-- conjAgr : Agr -> Agr -> Agr = \a0,b0 -> +-- let a = fromAgr a0 ; b = fromAgr b0 +-- in +-- toAgr +-- (conjNumber a.n b.n) +-- (conjPerson a.p b.p) a.g ; +-- +---- For $Lex$. +-- +---- For each lexical category, here are the worst-case constructors. +-- +-- mkNoun : (_,_,_,_ : Str) -> {s : Number => Case => Str} = +-- \man,mans,men,mens -> { +-- s = table { +-- Sg => table { +-- Gen => mans ; +-- _ => man +-- } ; +-- Pl => table { +-- Gen => mens ; +-- _ => men +-- } +-- } +-- } ; +-- +-- mkAdjective : (_,_,_,_ : Str) -> {s : AForm => Str; lock_A : {}} = +-- \good,better,best,well -> lin A { +-- s = table { +-- AAdj Posit c => (regGenitiveS good) ! c ; +-- AAdj Compar c => (regGenitiveS better) ! c ; +-- AAdj Superl c => (regGenitiveS best) ! c ; +-- AAdv => well +-- } +-- } ; +-- +-- mkVerb : (_,_,_,_,_ : Str) -> Verb = +-- \go,goes,went,gone,going -> { +-- s = table { +-- VInf => go ; +-- VPres => goes ; +-- VPast => went ; --# notpresent +-- VPPart => gone ; +-- VPresPart => going +-- } ; +-- isRefl = False +-- } ; +-- +-- mkIP : (i,me,my : Str) -> Number -> {s : NPCase => Str ; n : Number} = +-- \i,me,my,n -> let who = mkNP i me my n P3 Neutr in { +-- s = who.s ; +-- n = n +-- } ; +-- +-- mkNP : (i,me,my : Str) -> Number -> Person -> Gender -> +-- {s : NPCase => Str ; a : Agr} = \i,me,my,n,p,g -> +-- { s = table { +-- NCase Nom => i ; +-- NPAcc => me ; +-- NCase Gen => my +-- } ; +-- a = toAgr n p g ; +-- }; +-- +-- regNP : Str -> Number -> {s : NPCase => Str ; a : Agr} = \that,n -> +-- mkNP that that (that + "'s") n P3 Neutr ; +-- +-- regGenitiveS : Str -> Case => Str = \s -> +-- table { Gen => genitiveS s; _ => s } ; +-- +-- genitiveS : Str -> Str = \dog -> +-- case last dog of { +-- "s" => dog + "'" ; +-- _ => dog + "'s" +-- }; +-- +---- We have just a heuristic definition of the indefinite article. +---- There are lots of exceptions: consonantic "e" ("euphemism"), consonantic +---- "o" ("one-sided"), vocalic "u" ("umbrella"). +-- +-- artIndef = pre { +-- "eu" | "Eu" | "uni" | "up" => "a" ; +-- "un" => "an" ; +-- "a" | "e" | "i" | "o" | "A" | "E" | "I" | "O" => "an" ; +-- "SMS" | "sms" => "an" ; --- +-- _ => "a" +-- } ; +-- +-- artDef = "the" ; +-- +---- For $Verb$. +-- +-- Verb : Type = { +-- s : VForm => Str ; +-- isRefl : Bool +-- } ; +-- +-- param +-- CPolarity = +-- CPos +-- | CNeg Bool ; -- contracted or not +-- +-- oper +-- contrNeg : Bool -> Polarity -> CPolarity = \b,p -> case p of { +-- Pos => CPos ; +-- Neg => CNeg b +-- } ; +-- +-- VerbForms : Type = +-- Tense => Anteriority => CPolarity => Order => Agr => +-- {aux, adv, fin, inf : Str} ; -- would, not, sleeps, slept +-- +-- VP : Type = { +-- s : VerbForms ; +-- prp : Str ; -- present participle +-- ptp : Str ; -- past participle +-- inf : Str ; -- the infinitive form ; VerbForms would be the logical place +-- ad : Str ; -- sentence adverb +-- s2 : Agr => Str -- complement +-- } ; +-- +-- +-- SlashVP = VP ** {c2 : Str} ; +-- +-- predVc : (Verb ** {c2 : Str}) -> SlashVP = \verb -> +-- predV verb ** {c2 = verb.c2} ; +-- +-- predV : Verb -> VP = \verb -> { +-- s = \\t,ant,b,ord,agr => +-- let +-- inf = verb.s ! VInf ; +-- fin = presVerb verb agr ; +-- part = verb.s ! VPPart ; +-- in +-- case of { +-- => vff fin [] ; +-- => vf (does agr) inf ; +-- => vf (have agr) part ; --# notpresent +-- => vfn c (have agr) (havent agr) part ; --# notpresent +-- => vff (verb.s ! VPast) [] ; --# notpresent +-- => vf "did" inf ; --# notpresent +-- => vfn c "did" "didn't" inf ; --# notpresent +-- => vf "had" part ; --# notpresent +-- => vfn c "had" "hadn't" part ; --# notpresent +-- => vf "will" inf ; --# notpresent +-- => vfn c "will" "won't" inf ; --# notpresent +-- => vf "will" ("have" ++ part) ; --# notpresent +-- => vfn c "will" "won't"("have" ++ part) ; --# notpresent +-- => vf "would" inf ; --# notpresent +-- => vfn c "would" "wouldn't" inf ; --# notpresent +-- => vf "would" ("have" ++ part) ; --# notpresent +-- => vfn c "would" "wouldn't" ("have" ++ part) ; --# notpresent +-- => vfn c (does agr) (doesnt agr) inf +-- } ; +-- prp = verb.s ! VPresPart ; +-- ptp = verb.s ! VPPart ; +-- inf = verb.s ! VInf ; +-- ad = [] ; +-- s2 = \\a => if_then_Str verb.isRefl (reflPron ! a) [] +-- } ; +-- +-- predAux : Aux -> VP = \verb -> { +-- s = \\t,ant,cb,ord,agr => +-- let +-- b = case cb of { +-- CPos => Pos ; +-- _ => Neg +-- } ; +-- inf = verb.inf ; +-- fin = verb.pres ! b ! agr ; +-- finp = verb.pres ! Pos ! agr ; +-- part = verb.ppart ; +-- in +-- case of { +-- => vf (have agr) part ; --# notpresent +-- => vfn c (have agr) (havent agr) part ; --# notpresent +-- => vf (verb.past ! b ! agr) [] ; --# notpresent +-- => vfn c (verb.past!Pos!agr)(verb.past!Neg!agr) [] ; --# notpresent +-- => vf "had" part ; --# notpresent +-- => vfn c "had" "hadn't" part ; --# notpresent +-- => vf "will" inf ; --# notpresent +-- => vfn c "will" "won't" inf ; --# notpresent +-- => vf "will" ("have" ++ part) ; --# notpresent +-- => vfn c "will" "won't"("have" ++ part) ; --# notpresent +-- => vf "would" inf ; --# notpresent +-- => vfn c "would" "wouldn't" inf ; --# notpresent +-- => vf "would" ("have" ++ part) ; --# notpresent +-- => vfn c "would" "wouldn't" ("have" ++ part) ; --# notpresent +-- => vf fin [] ; +-- => vfn c finp fin [] +-- } ; +-- prp = verb.prpart ; +-- ptp = verb.ppart ; +-- inf = verb.inf ; +-- ad = [] ; +-- s2 = \\_ => [] +-- } ; +-- +-- vff : Str -> Str -> {aux, adv, fin, inf : Str} = \x,y -> +-- {aux = [] ; adv = [] ; fin = x ; inf = y} ; +-- +-- vf : Str -> Str -> {aux, adv, fin, inf : Str} = \x,y -> vfn True x x y ; +-- +-- vfn : Bool -> Str -> Str -> Str -> {aux, fin, adv, inf : Str} = +-- \contr,x,y,z -> +-- case contr of { +-- True => {aux = y ; adv = [] ; fin = [] ; inf = z} ; +-- False => {aux = x ; adv = "not" ; fin = [] ; inf = z} +-- } ; +-- +-- insertObj : (Agr => Str) -> VP -> VP = \obj,vp -> { +-- s = vp.s ; +-- prp = vp.prp ; +-- ptp = vp.ptp ; +-- inf = vp.inf ; +-- ad = vp.ad ; +-- s2 = \\a => vp.s2 ! a ++ obj ! a +-- } ; +-- +-- insertObjPre : (Agr => Str) -> VP -> VP = \obj,vp -> { +-- s = vp.s ; +-- prp = vp.prp ; +-- ptp = vp.ptp ; +-- inf = vp.inf ; +-- ad = vp.ad ; +-- s2 = \\a => obj ! a ++ vp.s2 ! a +-- } ; +-- +-- insertObjc : (Agr => Str) -> SlashVP -> SlashVP = \obj,vp -> +-- insertObj obj vp ** {c2 = vp.c2} ; +-- +----- The adverb should be before the finite verb. +-- +-- insertAdV : Str -> VP -> VP = \ad,vp -> { +-- s = vp.s ; +-- prp = vp.prp ; +-- ptp = vp.ptp ; +-- inf = vp.inf ; +-- ad = vp.ad ++ ad ; +-- s2 = \\a => vp.s2 ! a +-- } ; +-- +---- +-- +-- predVV : {s : VVForm => Str ; typ : VVType} -> VP = \verb -> +-- let verbs = verb.s +-- in +-- case verb.typ of { +-- VVAux => predAux { +-- pres = table { +-- Pos => \\_ => verbs ! VVF VPres ; +-- Neg => \\_ => verbs ! VVPresNeg +-- } ; +-- past = table { --# notpresent +-- Pos => \\_ => verbs ! VVF VPast ; --# notpresent +-- Neg => \\_ => verbs ! VVPastNeg --# notpresent +-- } ; --# notpresent +-- inf = verbs ! VVF VInf ; +-- ppart = verbs ! VVF VPPart ; +-- prpart = verbs ! VVF VPresPart ; +-- } ; +-- _ => predV {s = \\vf => verbs ! VVF vf ; isRefl = False} +-- } ; +-- +-- presVerb : {s : VForm => Str} -> Agr -> Str = \verb -> +-- agrVerb (verb.s ! VPres) (verb.s ! VInf) ; +-- +-- infVP : VVType -> VP -> Agr -> Str = \typ,vp,a -> +-- vp.ad ++ +-- case typ of { +-- VVAux => vp.inf ; +-- VVInf => "to" ++ vp.inf ; +-- _ => vp.prp +-- } ++ +-- vp.s2 ! a ; +-- +-- agrVerb : Str -> Str -> Agr -> Str = \has,have,agr -> +-- case agr of { +-- AgP3Sg _ => has ; +-- _ => have +-- } ; +-- +-- have = agrVerb "has" "have" ; +-- havent = agrVerb "hasn't" "haven't" ; +-- does = agrVerb "does" "do" ; +-- doesnt = agrVerb "doesn't" "don't" ; +-- +-- Aux = { +-- pres : Polarity => Agr => Str ; +-- past : Polarity => Agr => Str ; --# notpresent +-- inf,ppart,prpart : Str +-- } ; +-- +-- auxBe : Aux = { +-- pres = \\b,a => case of { +-- => "am" ; +-- => ["am not"] ; --- am not I +-- _ => agrVerb (posneg b "is") (posneg b "are") a +-- } ; +-- past = \\b,a => case a of { --# notpresent +-- AgP1 Sg | AgP3Sg _ => posneg b "was" ; --# notpresent +-- _ => (posneg b "were") --# notpresent +-- } ; --# notpresent +-- inf = "be" ; +-- ppart = "been" ; +-- prpart = "being" +-- } ; +-- +-- posneg : Polarity -> Str -> Str = \p,s -> case p of { +-- Pos => s ; +-- Neg => s + "n't" +-- } ; +-- +-- conjThat : Str = "that" ; +-- +-- reflPron : Agr => Str = table { +-- AgP1 Sg => "myself" ; +-- AgP2 Sg => "yourself" ; +-- AgP3Sg Masc => "himself" ; +-- AgP3Sg Fem => "herself" ; +-- AgP3Sg Neutr => "itself" ; +-- AgP1 Pl => "ourselves" ; +-- AgP2 Pl => "yourselves" ; +-- AgP3Pl => "themselves" +-- } ; +-- +---- For $Sentence$. +-- +-- Clause : Type = { +-- s : Tense => Anteriority => CPolarity => Order => Str +-- } ; +-- +-- mkClause : Str -> Agr -> VP -> Clause = +-- \subj,agr,vp -> { +-- s = \\t,a,b,o => +-- let +-- verb = vp.s ! t ! a ! b ! o ! agr ; +-- compl = vp.s2 ! agr +-- in +-- case o of { +-- ODir => subj ++ verb.aux ++ verb.adv ++ vp.ad ++ verb.fin ++ verb.inf ++ compl ; +-- OQuest => verb.aux ++ subj ++ verb.adv ++ vp.ad ++ verb.fin ++ verb.inf ++ compl +-- } +-- } ; +-- +-- +---- For $Numeral$. +-- +-- mkNum : Str -> Str -> Str -> Str -> {s : DForm => CardOrd => Case => Str} = +-- \two, twelve, twenty, second -> +-- {s = table { +-- unit => table {NCard => regGenitiveS two ; NOrd => regGenitiveS second} ; +-- teen => \\c => mkCard c twelve ; +-- ten => \\c => mkCard c twenty +-- } +-- } ; +-- +-- regNum : Str -> {s : DForm => CardOrd => Case => Str} = +-- \six -> mkNum six (six + "teen") (six + "ty") (regOrd six) ; +-- +-- regCardOrd : Str -> {s : CardOrd => Case => Str} = \ten -> +-- {s = table {NCard => regGenitiveS ten ; +-- NOrd => regGenitiveS (regOrd ten)} } ; +-- +-- mkCard : CardOrd -> Str -> Case => Str = \o,ten -> +-- (regCardOrd ten).s ! o ; +-- +-- regOrd : Str -> Str = \ten -> +-- case last ten of { +-- "y" => init ten + "ieth" ; +-- _ => ten + "th" +-- } ; +-- +-- mkQuestion : +-- {s : Str} -> Clause -> +-- {s : Tense => Anteriority => CPolarity => QForm => Str} = \wh,cl -> +-- { +-- s = \\t,a,p => +-- let +-- cls = cl.s ! t ! a ! p ; +-- why = wh.s +-- in table { +-- QDir => why ++ cls ! OQuest ; +-- QIndir => why ++ cls ! ODir +-- } +-- } ; +-- +-- +--} + +} diff --git a/lib/src/hungarian/SentenceHun.gf b/lib/src/hungarian/SentenceHun.gf new file mode 100644 index 000000000..0760d91f8 --- /dev/null +++ b/lib/src/hungarian/SentenceHun.gf @@ -0,0 +1,75 @@ +concrete SentenceHun of Sentence = CatHun ** open Prelude, ResHun in +{ +--{ +-- +-- flags optimize=all_subs ; +-- +-- lin +-- +-- PredVP np vp = mkClause (np.s ! npNom) np.a vp ; +-- +-- PredSCVP sc vp = mkClause sc.s (agrP3 Sg) vp ; +-- +-- ImpVP vp = { +-- s = \\pol,n => +-- let +-- agr = AgP2 (numImp n) ; +-- verb = infVP VVAux vp agr ; +-- dont = case pol of { +-- CNeg True => "don't" ; +-- CNeg False => "do" ++ "not" ; +-- _ => [] +-- } +-- in +-- dont ++ verb +-- } ; +-- +-- SlashVP np vp = +-- mkClause (np.s ! npNom) np.a vp ** {c2 = vp.c2} ; +-- +-- AdvSlash slash adv = { +-- s = \\t,a,b,o => slash.s ! t ! a ! b ! o ++ adv.s ; +-- c2 = slash.c2 +-- } ; +-- +-- SlashPrep cl prep = cl ** {c2 = prep.s} ; +-- +-- SlashVS np vs slash = +-- mkClause (np.s ! npNom) np.a +-- (insertObj (\\_ => conjThat ++ slash.s) (predV vs)) ** +-- {c2 = slash.c2} ; +-- +-- EmbedS s = {s = conjThat ++ s.s} ; +-- EmbedQS qs = {s = qs.s ! QIndir} ; +-- EmbedVP vp = {s = infVP VVInf vp (agrP3 Sg)} ; --- agr +-- +-- UseCl t p cl = { +-- s = t.s ++ p.s ++ cl.s ! t.t ! t.a ! ctr p.p ! ODir +-- } ; +-- UseQCl t p cl = { +-- s = \\q => t.s ++ p.s ++ cl.s ! t.t ! t.a ! ctr p.p ! q +-- } ; +-- UseRCl t p cl = { +-- s = \\r => t.s ++ p.s ++ cl.s ! t.t ! t.a ! ctr p.p ! r ; +-- c = cl.c +-- } ; +-- UseSlash t p cl = { +-- s = t.s ++ p.s ++ cl.s ! t.t ! t.a ! ctr p.p ! ODir ; +-- c2 = cl.c2 +-- } ; +-- +-- AdvS a s = {s = a.s ++ s.s} ; +-- ExtAdvS a s = {s = a.s ++ "," ++ s.s} ; +-- +-- SSubjS a s b = {s = a.s ++ s.s ++ b.s} ; +-- +-- RelS s r = {s = s.s ++ "," ++ r.s ! agrP3 Sg} ; +-- +-- oper +-- ctr : CPolarity -> CPolarity = \x -> x ; +----- ctr = contrNeg True ; -- contracted negations +-- +--} +-- + +} diff --git a/lib/src/hungarian/StructuralHun.gf b/lib/src/hungarian/StructuralHun.gf new file mode 100644 index 000000000..66654f5db --- /dev/null +++ b/lib/src/hungarian/StructuralHun.gf @@ -0,0 +1,148 @@ +concrete StructuralHun of Structural = CatHun ** + open MorphoHun, ResHun, ParadigmsHun, + (C = ConstructX), Prelude in +{ +--{ +-- +-- flags optimize=all ; +-- +-- lin +-- above_Prep = mkPrep "above" ; +-- after_Prep = mkPrep "after" ; +-- all_Predet = ss "all" ; +-- almost_AdA = mkAdA "almost" ; +-- almost_AdN = mkAdN "almost" ; +-- although_Subj = ss "although" ; +-- always_AdV = mkAdV "always" ; +-- and_Conj = mkConj "and" ; +-- because_Subj = ss "because" ; +-- before_Prep = mkPrep "before" ; +-- behind_Prep = mkPrep "behind" ; +-- between_Prep = mkPrep "between" ; +-- both7and_DConj = mkConj "both" "and"; +-- but_PConj = ss "but" ; +-- by8agent_Prep = mkPrep "by" ; +-- by8means_Prep = mkPrep "by" ; +-- can8know_VV, can_VV = { +-- s = table { +-- VVF VInf => ["be able to"] ; +-- VVF VPres => "can" ; +-- VVF VPPart => ["been able to"] ; +-- VVF VPresPart => ["being able to"] ; +-- VVF VPast => "could" ; --# notpresent +-- VVPastNeg => "couldn't" ; --# notpresent +-- VVPresNeg => "can't" +-- } ; +-- typ = VVAux +-- } ; +-- during_Prep = mkPrep "during" ; +-- either7or_DConj = mkConj "either" "or" singular ; +-- everybody_NP = regNP "everybody" singular ; +-- every_Det = mkDeterminer singular "every" ; +-- everything_NP = regNP "everything" singular ; +-- everywhere_Adv = mkAdv "everywhere" ; +-- few_Det = mkDeterminer plural "few" ; +----- first_Ord = ss "first" ; DEPRECATED +-- for_Prep = mkPrep "for" ; +-- from_Prep = mkPrep "from" ; +-- he_Pron = mkPron "he" "him" "his" "his" singular P3 masculine ; +-- here_Adv = mkAdv "here" ; +-- here7to_Adv = mkAdv ["to here"] ; +-- here7from_Adv = mkAdv ["from here"] ; +-- how_IAdv = ss "how" ; +-- how8much_IAdv = ss "how much" ; +-- how8many_IDet = mkDeterminer plural ["how many"] ; +-- if_Subj = ss "if" ; +-- in8front_Prep = mkPrep ["in front of"] ; +-- i_Pron = mkPron "I" "me" "my" "mine" singular P1 human ; +-- in_Prep = mkPrep "in" ; +-- it_Pron = mkPron "it" "it" "its" "its" singular P3 nonhuman ; +-- less_CAdv = C.mkCAdv "less" "than" ; +-- many_Det = mkDeterminer plural "many" ; +-- more_CAdv = C.mkCAdv "more" "than" ; +-- most_Predet = ss "most" ; +-- much_Det = mkDeterminer singular "much" ; +-- must_VV = { +-- s = table { +-- VVF VInf => ["have to"] ; +-- VVF VPres => "must" ; +-- VVF VPPart => ["had to"] ; +-- VVF VPresPart => ["having to"] ; +-- VVF VPast => ["had to"] ; --# notpresent +-- VVPastNeg => ["hadn't to"] ; --# notpresent +-- VVPresNeg => "mustn't" +-- } ; +-- typ = VVAux +-- } ; +-----b no_Phr = ss "no" ; +-- no_Utt = ss "no" ; +-- on_Prep = mkPrep "on" ; +------ one_Quant = mkDeterminer singular "one" ; -- DEPRECATED +-- only_Predet = ss "only" ; +-- or_Conj = mkConj "or" singular ; +-- otherwise_PConj = ss "otherwise" ; +-- part_Prep = mkPrep "of" ; +-- please_Voc = ss "please" ; +-- possess_Prep = mkPrep "of" ; +-- quite_Adv = mkAdv "quite" ; +-- she_Pron = mkPron "she" "her" "her" "hers" singular P3 feminine ; +-- so_AdA = mkAdA "so" ; +-- somebody_NP = regNP "somebody" singular ; +-- someSg_Det = mkDeterminer singular "some" ; +-- somePl_Det = mkDeterminer plural "some" ; +-- something_NP = regNP "something" singular ; +-- somewhere_Adv = mkAdv "somewhere" ; +-- that_Quant = mkQuant "that" "those" ; +-- there_Adv = mkAdv "there" ; +-- there7to_Adv = mkAdv "there" ; +-- there7from_Adv = mkAdv ["from there"] ; +-- therefore_PConj = ss "therefore" ; +-- they_Pron = mkPron "they" "them" "their" "theirs" plural P3 human ; +-- this_Quant = mkQuant "this" "these" ; +-- through_Prep = mkPrep "through" ; +-- too_AdA = mkAdA "too" ; +-- to_Prep = mkPrep "to" ; +-- under_Prep = mkPrep "under" ; +-- very_AdA = mkAdA "very" ; +-- want_VV = mkVV (regV "want") ; +-- we_Pron = mkPron "we" "us" "our" "ours" plural P1 human ; +-- whatPl_IP = mkIP "what" "what" "what's" plural ; +-- whatSg_IP = mkIP "what" "what" "what's" singular ; +-- when_IAdv = ss "when" ; +-- when_Subj = ss "when" ; +-- where_IAdv = ss "where" ; +-- which_IQuant = {s = \\_ => "which"} ; +-----b whichPl_IDet = mkDeterminer plural ["which"] ; +-----b whichSg_IDet = mkDeterminer singular ["which"] ; +-- whoPl_IP = mkIP "who" "whom" "whose" plural ; +-- whoSg_IP = mkIP "who" "whom" "whose" singular ; +-- why_IAdv = ss "why" ; +-- without_Prep = mkPrep "without" ; +-- with_Prep = mkPrep "with" ; +-----b yes_Phr = ss "yes" ; +-- yes_Utt = ss "yes" ; +-- youSg_Pron = mkPron "you" "you" "your" "yours" singular P2 human ; +-- youPl_Pron = mkPron "you" "you" "your" "yours" plural P2 human ; +-- youPol_Pron = mkPron "you" "you" "your" "yours" singular P2 human ; +-- +-- not_Predet = {s = "not" ; lock_Predet = <>} ; +-- no_Quant = mkQuant "no" "no" "none" "none" ; +-- if_then_Conj = mkConj "if" "then" singular ; +-- nobody_NP = regNP "nobody" singular ; +-- nothing_NP = regNP "nothing" singular ; +-- +-- at_least_AdN = mkAdN "at least" ; +-- at_most_AdN = mkAdN "at most" ; +-- +-- except_Prep = mkPrep "except" ; +-- +-- as_CAdv = C.mkCAdv "as" "as" ; +-- +-- have_V2 = dirV2 (mk5V "have" "has" "had" "had" "having") ; +-- that_Subj = ss "that" ; +-- lin language_title_Utt = ss "Hunlish" ; +-- +--} +-- + +} diff --git a/lib/src/hungarian/SymbolHun.gf b/lib/src/hungarian/SymbolHun.gf new file mode 100644 index 000000000..0866083a6 --- /dev/null +++ b/lib/src/hungarian/SymbolHun.gf @@ -0,0 +1,48 @@ +--# -path=.:../abstract:../common + +concrete SymbolHun of Symbol = CatHun ** open Prelude, ResHun in +{ +--{ +-- +--lin +-- SymbPN i = {s = addGenitiveS i.s ; g = Neutr} ; +-- IntPN i = {s = addGenitiveS i.s ; g = Neutr} ; +-- FloatPN i = {s = addGenitiveS i.s ; g = Neutr} ; +-- NumPN i = {s = i.s ; g = Neutr} ; +-- CNIntNP cn i = { +-- s = \\c => cn.s ! Sg ! Nom ++ (addGenitiveS i.s) ! npcase2case c ; +-- a = agrgP3 Sg cn.g +-- } ; +-- CNSymbNP det cn xs = { +-- s = \\c => det.s ++ cn.s ! det.n ! Nom ++ (addGenitiveS xs.s) ! npcase2case c ; +-- a = agrgP3 det.n cn.g +-- } ; +-- CNNumNP cn i = { +-- s = \\c => cn.s ! Sg ! Nom ++ i.s ! npcase2case c ; +-- a = agrgP3 Sg cn.g +-- } ; +-- +-- SymbS sy = sy ; +-- +-- SymbNum sy = { s = addGenitiveS sy.s ; n = Pl ; hasCard = True } ; +-- SymbOrd sy = { s = \\c => sy.s ++ (regGenitiveS "th")!c} ; +-- +--lincat +-- +-- Symb, [Symb] = SS ; +-- +--lin +-- MkSymb s = s ; +-- +-- BaseSymb = infixSS "and" ; +-- ConsSymb = infixSS "," ; +-- +--oper +-- -- Note: this results in a space before 's, but there's +-- -- not mauch we can do about that. +-- addGenitiveS : Str -> Case => Str = \s -> +-- table { Gen => s ++ "'s"; _ => s } ; +-- +--} + +} diff --git a/lib/src/hungarian/VerbHun.gf b/lib/src/hungarian/VerbHun.gf new file mode 100644 index 000000000..215b24ed8 --- /dev/null +++ b/lib/src/hungarian/VerbHun.gf @@ -0,0 +1,63 @@ +concrete VerbHun of Verb = CatHun ** open ResHun in +{ +--{ +-- +-- flags optimize=all_subs ; +-- +-- lin +-- UseV = predV ; +-- +-- SlashV2a v = predVc v ; +-- Slash2V3 v np = +-- insertObjc (\\_ => v.c2 ++ np.s ! NPAcc) (predV v ** {c2 = v.c3}) ; +-- Slash3V3 v np = +-- insertObjc (\\_ => v.c3 ++ np.s ! NPAcc) (predVc v) ; ---- +-- +-- ComplVV v vp = insertObj (\\a => infVP v.typ vp a) (predVV v) ; +-- ComplVS v s = insertObj (\\_ => conjThat ++ s.s) (predV v) ; +-- ComplVQ v q = insertObj (\\_ => q.s ! QIndir) (predV v) ; +-- ComplVA v ap = insertObj (ap.s) (predV v) ; +-- +-- SlashV2V v vp = insertObjc (\\a => v.c3 ++ infVP v.typ vp a) (predVc v) ; +-- SlashV2S v s = insertObjc (\\_ => conjThat ++ s.s) (predVc v) ; +-- SlashV2Q v q = insertObjc (\\_ => q.s ! QIndir) (predVc v) ; +-- SlashV2A v ap = insertObjc (\\a => ap.s ! a) (predVc v) ; ---- +-- +-- ComplSlash vp np = insertObjPre (\\_ => vp.c2 ++ np.s ! NPAcc) vp ; +-- +-- SlashVV vv vp = +-- insertObj (\\a => infVP vv.typ vp a) (predVV vv) ** +-- {c2 = vp.c2} ; +-- SlashV2VNP vv np vp = +-- insertObjPre (\\_ => vv.c2 ++ np.s ! NPAcc) +-- (insertObjc (\\a => vv.c3 ++ infVP vv.typ vp a) (predVc vv)) ** +-- {c2 = vp.c2} ; +-- +-- UseComp comp = insertObj comp.s (predAux auxBe) ; +-- +-- AdvVP vp adv = insertObj (\\_ => adv.s) vp ; +-- AdVVP adv vp = insertAdV adv.s vp ; +-- +-- AdvVPSlash vp adv = insertObj (\\_ => adv.s) vp ** {c2 = vp.c2} ; +-- AdVVPSlash adv vp = insertAdV adv.s vp ** {c2 = vp.c2} ; +-- +-- ReflVP v = insertObjPre (\\a => v.c2 ++ reflPron ! a) v ; +-- +-- PassV2 v = insertObj (\\_ => v.s ! VPPart) (predAux auxBe) ; +-- +-----b UseVS, UseVQ = \vv -> {s = vv.s ; c2 = [] ; isRefl = vv.isRefl} ; -- no "to" +-- +-- CompAP ap = ap ; +-- CompNP np = {s = \\_ => np.s ! NPAcc} ; +-- CompAdv a = {s = \\_ => a.s} ; +-- CompCN cn = {s = \\a => case (fromAgr a).n of { +-- Sg => artIndef ++ cn.s ! Sg ! Nom ; +-- Pl => cn.s ! Pl ! Nom +-- } +-- } ; +-- +-- UseCopula = predAux auxBe ; +-- +--} + +}