(Hun) Prevent redundant use of IndefArt in DetQuant with a Numeral

src/hungarian/NounHun.gf

@@ -58,7 +58,9 @@ concrete NounHun of Noun = CatHun ** open ResHun, Prelude in {
 
   -- : Quant -> Num -> Det ;
   DetQuant quant num = quant ** num ** {
-    s = \\c => quant.s ! num.n ! c
+    s = \\c => case <isNum num,quant.isIndefArt> of {
+                 <True,True> => [] ; -- don't output "a 2 cars"
+                 _           => quant.s ! num.n ! c }
             ++ num.s ! Attrib ;      -- TODO: add inflection table in numbers
     sp = \\c => quant.sp ! num.n ! c
             ++ num.s ! Indep
@@ -115,13 +117,14 @@ concrete NounHun of Noun = CatHun ** open ResHun, Prelude in {
   DefArt = {
     s,
     sp = \\_,_ => pre {"a" ; "az" / v } ;
+    isIndefArt = False ;
     } ;
 
-
   -- : Quant
   IndefArt = {
     s,
     sp = \\_,_ => "egy" ;
+    isIndefArt = True ;
     } ;
 
   -- : Pron -> Quant

src/hungarian/NumeralHun.gf

@@ -30,48 +30,48 @@ lin
   pot0 d = d ;
 
   -- : Sub100 ;                              -- 10
-  pot110 = {s = table {p => "tíz"} ; n=Pl} ;
+  pot110 = {s = table {p => "tíz"} ; n = Pl ; numtype = IsNum} ;
   -- : Sub100 ;                              -- 11
-  pot111 = {s = table {p => "tizenegy"} ; n=Pl} ;
+  pot111 = {s = table {p => "tizenegy"} ; n = Pl ; numtype = IsNum} ;
   -- : Digit -> Sub100 ;                     -- 10 + d
   pot1to19 d =
       {s = table {p => "tizen" ++ d.s ! <Unit,p>} ;
-       n = Pl} ;
+       n = Pl ; numtype = IsNum} ;
   --  : Sub10 -> Sub100 ;                    -- coercion of 1..9
   pot0as1 n =
       {s = table {p => n.s ! <Unit,p>} ;
-       n = Pl} ;
+       n = Pl ; numtype = IsNum} ;
 
   -- : Digit -> Sub100 ;                     -- d * 10
   pot1 d =
       {s = table {p => d.s ! <Ten,p>} ;
-       n = Pl} ;
+       n = Pl ; numtype = IsNum} ;
   -- : Digit -> Sub10 -> Sub100 ;            -- d * 10 + n
   pot1plus d e =
       {s = table {p => (d.s ! <Ten,Attrib>) ++ e.s ! <Unit,p>} ;
-       n = Pl} ;
+       n = Pl ; numtype = IsNum} ;
 
   -- : Sub100 -> Sub1000 ;                   -- coercion of 1..99
   pot1as2 n = n ;
   --  : Sub10 -> Sub1000 ;                   -- m * 100
   pot2 d =
       {s = table {p => (d.s ! <Unit,Attrib>) ++ "száz"} ;
-       n = Pl} ;
+       n = Pl ; numtype = IsNum} ;
   --  : Sub10 -> Sub100 -> Sub1000 ;         -- m * 100 + n
   pot2plus d e =
       {s = table {p => (d.s ! <Unit,Attrib>) ++ "száz" ++ e.s ! p} ;
-       n = Pl} ;
+       n = Pl ; numtype = IsNum} ;
 
   -- : Sub1000 -> Sub1000000 ;               -- coercion of 1..999
   pot2as3 n = n ;
   -- : Sub1000 -> Sub1000000 ;               -- m * 1000
   pot3 n =
       {s = table {p => n.s ! Attrib ++ "ezer"} ;
-       n = Pl} ;
+       n = Pl ; numtype = IsNum} ;
   --  : Sub1000 -> Sub1000 -> Sub1000000 ;   -- m * 1000 + n
   pot3plus n m =
       {s = table {p => n.s ! Attrib ++ "ezer" ++ m.s ! p} ;
-       n = Pl} ;
+       n = Pl ; numtype = IsNum} ;
 
 oper
   LinDigit : Type = {s : DForm*Place => Str ; n : Number} ;
@@ -85,7 +85,8 @@ oper
                <Unit,Attrib> => ua ;
                <Ten, Attrib> => ta } ;
 --    ord = ord ; -- TODO figure out where to use ordinal
-    n = Pl
+    n = Pl ;
+    numType = IsNum ;
     } ;
 
   }

src/hungarian/ParamHun.gf

@@ -65,13 +65,13 @@ param
 
   CardOrd = NOrd | NCard ; -- Not used yet
 
---  NumType = NoNum | IsDig | IsNum ;
+  NumType = NoNum | IsDig | IsNum ;
 
--- oper
+oper
---   isNum : {numtype : NumType} -> Bool = \nt -> case nt.numtype of {
+  isNum : {numtype : NumType} -> Bool = \nt -> case nt.numtype of {
---     NoNum => False ;
+    NoNum => False ;
---     _     => True
+    _     => True
---     } ;
+    } ;
 --------------------------------------------------------------------------------
 -- Adjectives
 

src/hungarian/ResHun.gf

@@ -102,11 +102,13 @@ oper
   Quant : Type = {
     s, -- form that comes before noun: "{this} car"
     sp : Number => Case => Str ; -- independent form, "I like {this}" (DetNP)
+    isIndefArt : Bool ; -- standard trick to prevent "a one car"
     } ;
 
   mkQuant : (s,sp : Str) -> Quant = \s,sp -> {
     s = (mkNoun s).s ;
     sp = (mkNoun sp).s ;
+    isIndefArt = False ;
     } ;
 
  -- Det is formed in DetQuant : Quant -> Num -> Det
@@ -115,19 +117,19 @@ oper
     s,
     sp : Case => Str ;
     n : Number ;
---    numtype : NumType ; -- Whether its Num component is digit, numeral or Sg/Pl
+    numtype : NumType ; -- Whether its Num component is digit, numeral or Sg/Pl
     } ;
 
   Num : Type = {
     s : Place => Str ;  -- Independent or attribute
     n : Number ;        -- Singular or plural
-    -- numtype : NumType ; -- Digit, numeral or Sg/Pl : makes a difference in many languages
+    numtype : NumType ; -- Digit, numeral or Sg/Pl : makes a difference in many languages
     } ;
 
   baseNum : Num = {
     s = \\_ => [] ;
     n = Sg ;
-    -- numtype = NoNum
+    numtype = NoNum
     } ;
 
   {- Numeral can become Num via