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

Maltese RG: work on numerals, quants, dets, and enclitic pronouns with nouns

Browse Source
This commit is contained in:
john.j.camilleri
2013-02-13 16:18:09 +00:00
parent ffb17bd26a
commit 02169db183
28 changed files with 822 additions and 713 deletions
Download Patch File Download Diff File Expand all files Collapse all files

380
lib/src/maltese/NumeralMlt.gf
View File

@@ -1,7 +1,7 @@
-- NumeralMlt.gf: cardinals and ordinals
--
-- Maltese Resource Grammar Library
-- John J. Camilleri, 2012
-- Maltese GF Resource Grammar
-- John J. Camilleri 2011 -- 2013
-- Licensed under LGPL
concrete NumeralMlt of Numeral = CatMlt [Numeral,Digits] ** open Prelude,ResMlt in {
@@ -12,11 +12,6 @@ concrete NumeralMlt of Numeral = CatMlt [Numeral,Digits] ** open Prelude,ResMlt
-- Dig, Digits
{-
-- This code taken from examples/numerals/maltese.sty in GF darcs repository, July 2011.
-- Original author unknown
-- ABSTRACT definitions copied from lib/src/abstract/Numeral.gf
-- Numerals from 1 to 999999 in decimal notation
cat
Numeral ; -- 0..
@@ -46,18 +41,18 @@ concrete NumeralMlt of Numeral = CatMlt [Numeral,Digits] ** open Prelude,ResMlt
pot3 : Sub1000 -> Sub1000000 ; -- m * 1000
pot3plus : Sub1000 -> Sub1000 -> Sub1000000 ; -- m * 1000 + n
-}
oper
--- I have a strong suspicion that these can be better factored, esp wrt thou
Form1 = {
s : DForm => CardOrd => Num_Case => Str ;
--thou : CardOrd => Str ;
s : DForm => CardOrd => NumCase => Str ;
thou : { s : Str ; treatAs : DForm } ;
n : Num_Number ;
n : NumForm ;
} ;
Form2 = {
s : CardOrd => Num_Case => Str ;
--thou : CardOrd => Str ;
s : CardOrd => NumCase => Str ;
thou : { s : Str ; treatAs : DForm } ;
n : Num_Number ;
n : NumForm ;
f : DForm ;
} ;
@@ -72,75 +67,74 @@ concrete NumeralMlt of Numeral = CatMlt [Numeral,Digits] ** open Prelude,ResMlt
oper
-- Make a "number" (in this case a Form1)
-- Should be moved to ResMlt ?
-- Params:
-- unit, eg TNEJN
-- ordinal unit (without article), eg TIENI
-- adjectival, eg ŻEWĠ
-- teen, eg TNAX
-- ten, eg GĦOXRIN
-- number, eg Num_Dl
--mkNum : Str -> Str -> Str -> Str -> Str -> Str -> Str -> Num_Number -> Form1 = \unit,ordunit,adjectival,teen,ten,hundred,thousand,num -> {
mkNum : Str -> Str -> Str -> Str -> Str -> Num_Number -> Form1 = \unit,ordunit,adjectival,teen,ten,num ->
-- number, eg Num2
mkNum : Str -> Str -> Str -> Str -> Str -> NumForm -> Form1 = \unit,ordunit,adjectival,teen,ten,num ->
let
hundred = case num of {
Num_Sg => "mija" ;
Num_Dl => "mitejn" ;
Num1 => "mija" ;
Num2 => "mitejn" ;
_ => adjectival
} ;
thousand = case num of {
Num_Sg => "wieħed" ;
Num_Dl => "elfejn" ;
Num1 => "wieħed" ;
Num2 => "elfejn" ;
_ => case adjectival of {
_ + "'" => (init adjectival) + "t" ; -- eg SEBA' -> SEBAT
_ + "t" => adjectival ; -- eg SITT -> SITT
_ => adjectival + "t" -- eg ĦAMES -> ĦAMEST
_ + "'" => (init adjectival) + "t" ; -- SEBA' -> SEBAT
_ + "t" => adjectival ; -- SITT -> SITT
_ => adjectival + "t" -- ĦAMES -> ĦAMEST
}
}
in {
s = table {
Unit => table {
NCard => table {
NumNominative => unit ; -- eg TNEJN
NumAdjectival => adjectival -- eg ŻEWĠ
NumNom => unit ; -- TNEJN
NumAdj => case num of {
Num1 => "" ; -- [] baqra
_ => adjectival -- ŻEWĠ baqar
}
} ;
NOrd => \\numcase => artDef ++ ordunit -- eg IT-TIENI
NOrd => \\numcase => ordunit -- TIENI
} ;
Teen => table {
NCard => table {
NumNominative => teen ; -- eg TNAX
NumAdjectival => teen + "-il" -- eg TNAX-IL
NumNom => teen ; -- TNAX
NumAdj => glue teen "-il" -- TNAX-IL
} ;
NOrd => table {
NumNominative => artDef ++ teen ; -- eg IT-TNAX
NumAdjectival => artDef ++ (teen + "-il") -- eg IT-TNAX-IL
NumNom => teen ; -- TNAX
NumAdj => glue teen "-il" -- TNAX-IL
}
} ;
Ten => table {
NCard => \\numcase => ten ; -- eg TLETIN
NOrd => \\numcase => artDef ++ ten -- eg IT-TLETIN
} ;
Hund => table {
Ten => \\cardord,numcase => ten ; -- TLETIN
-- Hund, Thou
_ => table {
NCard => case num of {
Num_Sg => table {
NumNominative => "mija" ; -- ie MIJA
NumAdjectival => "mitt" -- ie MITT suldat
Num1 => table {
NumNom => "mija" ; -- MIJA
NumAdj => "mitt" -- MITT suldat
} ;
Num_Dl => \\numcase => hundred ; -- ie MITEJN
Num2 => \\numcase => hundred ; -- MITEJN
_ => table {
NumNominative => hundred ++ "mija" ; -- eg MIJA, SEBA' MIJA
NumAdjectival => hundred ++ "mitt" -- eg MITT, SEBA' MITT suldat
NumNom => hundred ++ "mija" ; -- MIJA, SEBA' MIJA
NumAdj => hundred ++ "mitt" -- MITT, SEBA' MITT suldat
}
} ;
NOrd => case num of {
Num_Sg => table {
NumNominative => artDef ++ "mija" ; -- ie IL-MIJA
NumAdjectival => artDef ++ "mitt" -- ie IL-MITT suldat
Num1 => table {
NumNom => "mija" ; -- MIJA
NumAdj => "mitt" -- MITT suldat
} ;
Num_Dl => \\numcase => artDef ++ hundred ; -- ie IL-MITEJN, IL-MITEJN suldat
Num2 => \\numcase => hundred ; -- MITEJN, MITEJN suldat
_ => table {
NumNominative => artDef ++ hundred ++ "mija" ; -- eg IS-SEBA' MIJA
NumAdjectival => artDef ++ hundred ++ "mitt" -- eg IS-SEBA' MITT suldat
NumNom => hundred ++ "mija" ; -- SEBA' MIJA
NumAdj => hundred ++ "mitt" -- SEBA' MITT suldat
}
}
}
@@ -152,62 +146,59 @@ concrete NumeralMlt of Numeral = CatMlt [Numeral,Digits] ** open Prelude,ResMlt
lin
-- Unit Ord.Unit Adjectival Teen Ten Number
n2 = mkNum "tnejn" "tieni" "żewġ" "tnax" "għoxrin" Num_Dl ;
n3 = mkNum "tlieta" "tielet" "tlett" "tlettax" "tletin" Num_Pl ; -- TODO tlett / tliet ?
n4 = mkNum "erbgħa" "raba'" "erba'" "erbatax" "erbgħin" Num_Pl ;
n5 = mkNum "ħamsa" "ħames" "ħames" "ħmistax" "ħamsin" Num_Pl ;
n6 = mkNum "sitta" "sitt" "sitt" "sittax" "sittin" Num_Pl ;
n7 = mkNum "sebgħa" "seba'" "seba'" "sbatax" "sebgħin" Num_Pl ;
n8 = mkNum "tmienja" "tmin" "tmin" "tmintax" "tmenin" Num_Pl ;
n9 = mkNum "disgħa" "disa'" "disa'" "dsatax" "disgħin" Num_Pl ;
n2 = mkNum "tnejn" "tieni" "żewġ" "tnax" "għoxrin" Num2 ;
n3 = mkNum "tlieta" "tielet" "tlett" "tlettax" "tletin" Num3_10 ; --- TODO tlett / tliet ?
n4 = mkNum "erbgħa" "raba'" "erba'" "erbatax" "erbgħin" Num3_10 ;
n5 = mkNum "ħamsa" "ħames" "ħames" "ħmistax" "ħamsin" Num3_10 ;
n6 = mkNum "sitta" "sitt" "sitt" "sittax" "sittin" Num3_10 ;
n7 = mkNum "sebgħa" "seba'" "seba'" "sbatax" "sebgħin" Num3_10 ;
n8 = mkNum "tmienja" "tmin" "tmin" "tmintax" "tmenin" Num3_10 ;
n9 = mkNum "disgħa" "disa'" "disa'" "dsatax" "disgħin" Num3_10 ;
oper
-- Helper functions for below
mkForm2 : Form2 = overload {
-- Infer adjectival, thousands
mkForm2 : Str -> Str -> DForm -> Form2 = \card,ord,form -> {
mkForm2 : Str -> Str -> DForm -> NumForm -> Form2 = \card,ord,dform,numform -> {
s = table {
NCard => \\numcase => card ;
NOrd => \\numcase => ord
} ;
--thou = card ;
thou = { s = card ; treatAs = form } ;
n = Num_Pl ;
f = form ;
thou = { s = card ; treatAs = dform } ;
n = numform ;
f = dform ;
} ;
-- Explicit everything
mkForm2 : Str -> Str -> Str -> Str -> DForm -> Form2 = \card,ord,adj,thousand,form -> {
mkForm2 : Str -> Str -> Str -> Str -> DForm -> NumForm -> Form2 = \card,ord,adj,thousand,dform,numform -> {
s = table {
NCard => table {
NumNominative => card ;
NumAdjectival => adj
NumNom => card ;
NumAdj => adj
} ;
--NOrd => \\numcase => addDefiniteArticle ord
NOrd => table {
NumNominative => artDef ++ ord ;
NumAdjectival => artDef ++ adj
NumNom => ord ;
NumAdj => adj
}
} ;
--thou = thousand ;
thou = { s = thousand ; treatAs = form } ;
n = Num_Pl ;
f = form ;
thou = { s = thousand ; treatAs = dform } ;
n = numform ;
f = dform ;
} ;
-- Given an existing table
mkForm2 : (CardOrd => Num_Case => Str) -> DForm -> Form2 = \tab,form -> {
mkForm2 : (CardOrd => NumCase => Str) -> DForm -> NumForm -> Form2 = \tab,dform,numform -> {
s = tab ;
thou = {
s = case form of {
Teen => tab ! NCard ! NumAdjectival ;
_ => tab ! NCard ! NumNominative
s = case dform of {
Teen => tab ! NCard ! NumAdj ;
_ => tab ! NCard ! NumNom
} ;
treatAs = form ;
treatAs = dform ;
} ;
n = Num_Pl ;
f = form ;
n = numform ;
f = dform ;
} ;
}; -- end of mkForm2 overload
@@ -219,39 +210,18 @@ concrete NumeralMlt of Numeral = CatMlt [Numeral,Digits] ** open Prelude,ResMlt
-- Sub10 ; 1
-- Unit Ord.Unit Adjectival Teen Ten Number
pot01 = mkNum "wieħed" "ewwel" "wieħed" [] [] Num_Sg ;
pot01 = mkNum "wieħed" "ewwel" "wieħed" [] [] Num1 ;
-- Digit -> Sub10 ; d * 1
pot0 d = d ** {n = case d.n of { Num_Dl => Num_Dl ; _ => Num_Pl } } ;
pot0 d = d ** {n = case d.n of { Num2 => Num2 ; _ => Num3_10 }} ;
-- Sub100 ; 10, 11
-- Cardinal Ordinal Adjectival Thousand Form
pot110 = mkForm2 "għaxra" "għaxar" "għaxar" "għaxart" Unit ;
pot111 = mkForm2 "ħdax" "ħdax" "ħdax-il" "ħdax-il" Teen ;
{-
pot110 = {
s = table {
NCard => table {
NumNominative => "għaxra" ;
NumAdjectival => "għaxar"
} ;
NOrd => \\numcase => addDefiniteArticle "għaxar"
} ;
thou = table {
NCard => "għaxart" ;
NOrd => addDefiniteArticle "għaxart"
} ;
n = Num_Pl ;
f = Ten ;
} ;
-}
pot110 = mkForm2 "għaxra" "għaxar" "għaxar" "għaxart" Unit Num3_10 ;
pot111 = mkForm2 "ħdax" "ħdax" (glue "ħdax" "-il") (glue "ħdax" "-il") Teen Num11_19 ;
-- Digit -> Sub100 ; 10 + d
pot1to19 d =
mkForm2
(d.s ! Teen)
Teen
;
pot1to19 d = mkForm2 (d.s ! Teen) Teen Num11_19 ;
-- Sub10 -> Sub100 ; coercion of 1..9
pot0as1 d = {
@@ -263,18 +233,27 @@ concrete NumeralMlt of Numeral = CatMlt [Numeral,Digits] ** open Prelude,ResMlt
-- Digit -> Sub100 ; d * 10
pot1 d =
mkForm2
(d.s ! Ten)
Ten
;
let
numform : NumForm = case d.n of {
Num1 => Num3_10 ;
_ => Num20_99
}
in mkForm2 (d.s ! Ten) Ten numform ;
-- Digit -> Sub10 -> Sub100 ; d * 10 + n
pot1plus d n =
let unit = (n.s ! Unit ! NCard ! NumNominative) in
let
unit = (n.s ! Unit ! NCard ! NumNom) ;
numform : NumForm = case d.n of {
Num1 => Num11_19 ;
_ => Num20_99
}
in
mkForm2
(unit ++ "u" ++ (d.s ! Ten ! NCard ! NumNominative))
(artDef ++ unit ++ "u" ++ (d.s ! Ten ! NCard ! NumNominative))
(unit ++ "u" ++ (d.s ! Ten ! NCard ! NumNom))
(unit ++ "u" ++ (d.s ! Ten ! NCard ! NumNom))
Ten
numform
;
-- Sub100 -> Sub1000 ; coercion of 1..99
@@ -285,39 +264,33 @@ concrete NumeralMlt of Numeral = CatMlt [Numeral,Digits] ** open Prelude,ResMlt
s = m.s ! Hund ;
thou = {
s = case m.n of {
Num_Sg => "mitt" ; -- Special case for "mitt elf"
Num_Dl => "mitejn" ; -- Special case for "mitejn elf"
Num1 => "mitt" ; -- Special case for "mitt elf"
Num2 => "mitejn" ; -- Special case for "mitejn elf"
_ => m.thou.s
} ;
treatAs = Hund ;
} ;
n = Num_Pl ;
n = Num0 ;
f = Hund ;
} ;
-- Sub10 -> Sub100 -> Sub1000 ; m * 100 + n
pot2plus m n =
let
hund : Str = m.s ! Hund ! NCard ! NumNominative
hund : Str = m.s ! Hund ! NCard ! NumNom ;
in {
s = table {
NCard => table {
NumNominative => hund ++ "u" ++ n.s ! NCard ! NumNominative ;
NumAdjectival => hund ++ "u" ++ n.s ! NCard ! NumAdjectival
s = \\cardord,numcase => case n.n of {
Num1 => hund ++ "u" ;
_ => hund ++ "u" ++ n.s ! NCard ! numcase
} ;
NOrd => table {
NumNominative => artDef ++ hund ++ "u" ++ n.s ! NCard ! NumNominative ;
NumAdjectival => artDef ++ hund ++ "u" ++ n.s ! NCard ! NumAdjectival
}
} ;
thou = {
s = hund ++ "u" ++ n.thou.s ;
treatAs = case n.n of {
Num_Sg => Ten ; -- specific case for mija u wiehed elf
_ => n.f -- eg So that "106,000" is treated as "6,000"
Num1 => Ten ; -- specific case for mija u wiehed elf
_ => n.f -- So that "106,000" is treated as "6,000"
} ;
} ;
n = Num_Pl ;
n = case n.n of { Num2 => Num3_10 ; _ => n.n } ;
f = Hund ;
} ;
@@ -328,27 +301,17 @@ concrete NumeralMlt of Numeral = CatMlt [Numeral,Digits] ** open Prelude,ResMlt
pot3 m = {
s =
case <m.n, m.thou.treatAs> of {
<Num_Sg ,_> => numTable "elf" ; -- 1 * 1000
<Num_Dl,_> => numTable "elfejn" ; -- 2 * 2000
<Num_Pl ,Unit> => numTable m.thou.s "elef" ; -- 3-10 * 1000
<Num_Pl ,_> => numTable m.thou.s "elf" -- 11+ * 1000
<Num1,_> => numTable "elf" ; -- 1 * 1000
<Num2,_> => numTable "elfejn" ; -- 2 * 1000
<_,Unit> => numTable m.thou.s "elef" ; -- 3-10 * 1000
<_,_> => numTable m.thou.s "elf" -- 11+ * 1000
} ;
{-
case m.f of {
Unit => numTable m.thou "elef" ; --
_ => case m.n of {
Num_Sg => numTable "elf" ; --
Num_Dl => numTable "elfejn" ; --
Num_Pl => numTable m.thou "elf" --
}
} ;
-}
thou = {
s = m.thou.s ;
treatAs = m.f ;
} ;
n = Num_Pl ;
f = Hund ; -- NOT IMPORTANT
n = Num0 ;
f = Thou ; -- NOT IMPORTANT
} ;
-- Sub1000 -> Sub1000 -> Sub1000000 ; m * 1000 + n
@@ -356,70 +319,37 @@ concrete NumeralMlt of Numeral = CatMlt [Numeral,Digits] ** open Prelude,ResMlt
s =
let
ukemm = table {
NumNominative => "u" ++ (n.s ! NCard ! NumNominative) ;
NumAdjectival => "u" ++ (n.s ! NCard ! NumAdjectival)
NumNom => "u" ++ (n.s ! NCard ! NumNom) ;
NumAdj => "u" ++ (n.s ! NCard ! NumAdj)
}
in
case <m.n, m.thou.treatAs> of {
<Num_Sg ,_> => numTable "elf" ukemm ;
<Num_Dl,_> => numTable "elfejn" ukemm ;
<Num_Pl ,Unit> => numTable (m.thou.s ++ "elef") ukemm ;
<Num_Pl ,_> => numTable (m.thou.s ++ "elf") ukemm
<Num1,_> => numTable "elf" ukemm ;
<Num2,_> => numTable "elfejn" ukemm ;
<_,Unit> => numTable (m.thou.s ++ "elef") ukemm ;
<_,_> => numTable (m.thou.s ++ "elf") ukemm
} ;
{-
Num_Sg => elf2 "elf" ukemm ;
Num_Dl => elf2 "elfejn" ukemm ;
Num_Pl => case m.f of {
Unit => elf2 m.thou ("elef" ++ ukemm) ;
_ => elf2 m.thou ("elf" ++ ukemm)
}
-}
thou = {
s = m.thou.s ;
treatAs = m.f ;
} ;
n = Num_Pl ;
n = case n.n of { Num2 => Num3_10 ; _ => n.n } ;
f = Hund ; -- NOT IMPORTANT
} ;
oper
-- Build "x thousand" table
numTable : (CardOrd => Num_Case => Str) = overload {
numTable : (CardOrd => NumCase => Str) = overload {
numTable : Str -> (CardOrd => Num_Case => Str) = \thou -> table {
NCard => \\numcase => thou ;
NOrd => \\numcase => artDef ++ thou
} ;
numTable : Str -> (CardOrd => NumCase => Str) = \thou ->
\\cardord,numcase => thou ;
numTable : Str -> Str -> (CardOrd => Num_Case => Str) = \thou,attach -> table {
NCard => \\numcase => thou ++ attach ;
NOrd => \\numcase => artDef ++ thou ++ attach
} ;
numTable : Str -> (Num_Case => Str) -> (CardOrd => Num_Case => Str) = \thou,attach -> table {
NCard => table {
NumNominative => thou ++ (attach ! NumNominative) ;
NumAdjectival => thou ++ (attach ! NumAdjectival)
} ;
NOrd => table {
NumNominative => artDef ++ thou ++ (attach ! NumNominative) ;
NumAdjectival => artDef ++ thou ++ (attach ! NumAdjectival)
}
} ;
numTable : Str -> Str -> (CardOrd => NumCase => Str) = \thou,attach ->
\\cardord,numcase => thou ++ attach ;
numTable : Str -> (NumCase => Str) -> (CardOrd => NumCase => Str) = \thou,attach ->
\\cardord,numcase => thou ++ (attach ! numcase) ;
} ;
{-
-- elf : (CardOrd => Str) = overload {
elf : Str -> (CardOrd => Num_Case => Str) = \m -> table {
NCard => \\numcase => m ;
NOrd => \\numcase => addDefiniteArticle m
} ;
elf2 : Str -> Str -> (CardOrd => Num_Case => Str) = \m,n -> table {
NCard => \\numcase => m ++ n ;
NOrd => \\numcase => (addDefiniteArticle m) ++ n
} ;
-}
-- } ;
{-
Numerals as sequences of digits have a separate, simpler grammar
@@ -438,22 +368,17 @@ concrete NumeralMlt of Numeral = CatMlt [Numeral,Digits] ** open Prelude,ResMlt
lincat
Dig = {
s : Str ;
n : Num_Number
s : NumCase => Str ;
n : NumForm ;
-- i : Int ; -- internal counter
} ;
oper
-- Helper for making a Dig object. Specifying no number inplies plural.
mkDig : Dig = overload {
mkDig : Str -> Dig = \digit -> lin Dig {
s = digit ;
n = Num_Pl
-- Helper for making a Dig object.
mkDig : Str -> NumForm -> Dig = \digit,num -> lin Dig {
s = \\numcase => digit ;
n = num
} ;
mkDig : Str -> Num_Number -> Dig = \digit,num -> lin Dig {
s = digit ;
n = num
} ;
} ;
-- For correct comma placement in Digits
commaIf : DTail -> Str = \t -> case t of {
@@ -467,25 +392,46 @@ concrete NumeralMlt of Numeral = CatMlt [Numeral,Digits] ** open Prelude,ResMlt
} ;
lin
D_0 = mkDig "0" ;
D_1 = mkDig "1" Num_Sg ;
D_2 = mkDig "2" Num_Dl ;
D_3 = mkDig "3" ;
D_4 = mkDig "4" ;
D_5 = mkDig "5" ;
D_6 = mkDig "6" ;
D_7 = mkDig "7" ;
D_8 = mkDig "8" ;
D_9 = mkDig "9" ;
-- Dig
D_0 = mkDig "0" Num0 ;
D_1 = mkDig "1" Num1 ;
D_2 = mkDig "2" Num2 ;
D_3 = mkDig "3" Num3_10 ;
D_4 = mkDig "4" Num3_10 ;
D_5 = mkDig "5" Num3_10 ;
D_6 = mkDig "6" Num3_10 ;
D_7 = mkDig "7" Num3_10 ;
D_8 = mkDig "8" Num3_10 ;
D_9 = mkDig "9" Num3_10 ;
-- Create Digits from a Dig
-- Dig -> Digits
IDig d = d ** {tail = T1} ;
-- Create Digits from combining Dig with Digits
IIDig d i = {
s = d.s ++ (commaIf i.tail) ++ i.s ;
n = Num_Pl ;
tail = inc i.tail
} ;
-- Dig -> Digits -> Digits
IIDig d i =
let
digits = d.s ! NumNom ++ (commaIf i.tail) ++ i.s ! NumNom;
numform = case <d.n,i.n> of {
<Num0,num> => num ; -- 0 x
<Num1,Num0> => Num3_10 ; -- 1 0
<Num1,_> => Num11_19 ; -- 1 1
<Num2,_> => Num20_99 ; -- 2 x
<Num3_10,_> => Num20_99 ; -- [3-9] x
<Num20_99,_> => Num20_99 ;
<_,_> => Num20_99 --- how to handle overwrap? see i:Int in lincat Dig above
} ;
in {
s = table {
NumNom => digits ;
NumAdj => case numform of {
Num11_19 => glue digits "-il" ;
_ => digits
}
} ;
n = numform ;
tail = inc i.tail
} ;
}