From 22cadd2ac64dbbc64426f9c3281ac88e12de91a5 Mon Sep 17 00:00:00 2001
From: Inari Listenmaa <inari.listenmaa@gmail.com>
Date: Sun, 26 Apr 2020 15:51:34 +0200
Subject: [PATCH] (Hun) Combine the parameters on definiteness and Quant/Det
 type

---
 src/hungarian/NounHun.gf  | 21 +++++++++------------
 src/hungarian/ParamHun.gf | 34 ++++++++++++++++++++++++++--------
 src/hungarian/ResHun.gf   |  8 ++------
 3 files changed, 37 insertions(+), 26 deletions(-)

diff --git a/src/hungarian/NounHun.gf b/src/hungarian/NounHun.gf
index 185b361b5..3698ef6ba 100644
--- a/src/hungarian/NounHun.gf
+++ b/src/hungarian/NounHun.gf
@@ -16,17 +16,18 @@ concrete NounHun of Noun = CatHun ** open
            True  => det.s ! c ;
            False => det.s ! Nom
          } ++ case <p,det.dt> of {
-                <NotPossessed, NoPoss>
+                <_, DetPoss _>
+                   => possessed ;
+                <NotPossessed, _>
                   => standalone ;
-                <_,            DetPoss _>
-                  => possessed ;
-                <Poss per rnum, NoPoss>
+                <Poss per rnum, _>
                   => let pron : Pronoun = pronTable ! <per,rnum> ; -- Possessor's number
                          dnum : CatHun.Num = case det.n of { -- Possessed's number
                                   Sg => NumSg ; Pl => NumPl } ;
                       in caseFromPossStem cn (DetQuant (PossPron pron) dnum) c
          } ++ cn.compl ! det.n ! c ;
     agr = <P3,det.n> ;
+    objdef = dt2objdef det.dt ;
     } ;
 
   -- : PN -> NP ;
@@ -96,8 +97,7 @@ concrete NounHun of Noun = CatHun ** open
                  <True,True> => [] ;
                  _           => quant.sp ! num.n ! c }
             ++ num.s ! Indep ;
-    dt = case quant.qt of { QuantPoss stem => DetPoss stem ;
-                            _              => NoPoss } ;
+    dt = qt2dt quant.qt ;
     } ;
 
   -- : Quant -> Num -> Ord -> Det ;  -- these five best
@@ -160,23 +160,20 @@ concrete NounHun of Noun = CatHun ** open
   DefArt = mkQuant "a" "a" ** {
     s,
     sp = \\_,_ => pre {"a" ; "az" / v } ;
-    qt = Article ;
-    objdef = Def ;
+    qt = DefQuant ;
     } ;
 
   -- : Quant
   IndefArt = mkQuant "egy" [] ** {
     s = \\n,_ => case n of {Sg => "egy" ; Pl => []} ;
     sp = \\n,_ => case n of {Sg => "egy" ; Pl => "sok"} ;
-    qt = Article ;
-    objdef = Indef ;
+    qt = IndefArticle ;
     } ;
 
   -- : Pron -> Quant
   PossPron pron = pron ** {
     s,sp = \\_ => pron.s ;
-    qt = QuantPoss (agr2PossStem pron.agr) ;
-    objdef = Def ;
+    qt = QuantPoss (agr2pstem pron.agr) ;
     caseagr = False ;
     } ;
 
diff --git a/src/hungarian/ParamHun.gf b/src/hungarian/ParamHun.gf
index 9969dbd80..dd396ddf3 100644
--- a/src/hungarian/ParamHun.gf
+++ b/src/hungarian/ParamHun.gf
@@ -18,13 +18,15 @@ oper
 
 param
   QuantType =
-    Article  -- Needed to prevent "a 2 cars"
-  | Other    -- Not poss, not article
+    IndefArticle  -- Needed to prevent "a 2 cars"
+  | IndefQuant    -- Not IndefArt, not poss, not def
+  | DefQuant
   | QuantPoss PossStem -- Which possessive stem it takes
   ;
 
   DetType =
-    NoPoss  -- distinction between Article and Other no longer needed
+    DefDet  -- distinction between Article and Other no longer needed
+  | IndefDet -- still need def or indef
   | DetPoss PossStem -- Sill need to know which stem it takes if Poss
   ;
 
@@ -33,13 +35,29 @@ param
 
 oper
   -- standard trick to prevent "a one car"
-  isIndefArt : {qt : QuantType ; objdef : ObjDef} -> Bool = \quant ->
-    case <quant.qt,quant.objdef> of {
-      <Article,Indef> => True ;
-      _               => False
+  isIndefArt : {qt : QuantType} -> Bool = \quant ->
+    case quant.qt of {
+      IndefArticle => True ;
+      _            => False
     } ;
 
-  agr2PossStem : Person*Number -> PossStem = \pn ->
+  dt2objdef : DetType -> ObjDef = \dt -> case dt of {
+    IndefDet => Indef ;
+    _        => Def
+    } ;
+
+  objdef2dt : ObjDef -> DetType = \od -> case od of {
+    Def => DefDet ;
+    Indef => IndefDet
+    } ;
+
+  qt2dt : QuantType -> DetType = \qt -> case qt of {
+    QuantPoss x => DetPoss x ;
+    DefQuant => DefDet ;
+    _ => IndefDet
+    } ;
+
+  agr2pstem : Person*Number -> PossStem = \pn ->
     case <pn.p1,pn.p2> of {
       <P1,Pl> => dSg_rPl1 ;
       <P3,n>  => dSg_rP3 n ;
diff --git a/src/hungarian/ResHun.gf b/src/hungarian/ResHun.gf
index 16a69253e..0ff69be26 100644
--- a/src/hungarian/ResHun.gf
+++ b/src/hungarian/ResHun.gf
@@ -185,7 +185,6 @@ oper
 
   BaseQuant : Type = {
     poss : HarmForms ; -- Quants made by PossPron need this, empty for others
-    objdef : ObjDef ; -- How V2 agrees if NP with this Det is an object
     caseagr : Bool ; -- If it agrees in case: "azoknak a nőknek" vs. "sok nőknek"
   } ;
 
@@ -200,8 +199,7 @@ oper
   mkQuant : (s,sp : Str) -> Quant = \s,sp -> {
     s = mkCaseNoun s ;
     sp = mkCaseNoun sp ;
-    qt = Other ;
-    objdef = Def ;
+    qt = DefQuant ;
     caseagr = True ;
     poss = harm1 [] ;
     } ;
@@ -212,7 +210,6 @@ oper
     s,
     sp : Case => Str ;
     n : Number ;
---    numtype : NumType ; -- Whether its Num component is digit, numeral or Sg/Pl
     dt : DetType ;
     } ;
 
@@ -221,9 +218,8 @@ oper
     sp = mkCaseNoun s ! n ;
     n = n ;
     numtype = NoNum ;
-    objdef = d ;
     caseagr = ca ;
-    dt = NoPoss ;
+    dt = objdef2dt d ;
     poss = harm1 [] ;
   } ;