FM-SBLEX-3.0: src/fsv/Rules.hs
module Rules where
import General -- language-independent functional morphology library
import Types -- morphological parameters and word classes
-- Missing: Species.
-- Noun: Weak Declension
-- Maskulinum
species_masc :: Species -> (Number,Case) -> [String] -> Str
species_masc Indef _ xs = strings xs
species_masc Def (n,c) xs = strings $
case (c,n) of
(Gen,Sg) -> [x ++ "ns" | x <- xs]
(Dat,Sg) -> [x ++ "num" | x <- xs]
(_,Sg) -> [x ++ "n" | x <- xs]
(Nom,Pl) -> [x ++ y | x <- xs, y <- ["ni", "nir"]]
(Gen,Pl) -> [x ++ "nna" | x <- xs]
(Dat,Pl) -> [x ++ "in" | x <- xs]
(Ack,Pl) -> [x ++ "na" | x <- xs]
biti_rule :: String -> NN
biti_rule biti = i_rule (tk 1 biti)
bryti_rule :: String -> NN
bryti_rule bryti = except (i_rule bryti) [(NN_C Sg Nom Indef,bryti)]
landbo_rule :: String -> NN
landbo_rule landbo (NN_C n c d) = species_masc d (n,c) $
case (n,c) of
(Sg,Nom) -> [landbo, landbo++"i", landbo++"e"]
(Pl,Nom) -> [landbo ++ suff | suff <- ["ar","r","","ær"]]
(Pl,Dat) -> [landbo++"um", landbo++"om", landbo++"m"]
_ -> [landbo, landbo++"a", landbo++"æ"]
i_rule :: String -> NN
i_rule bit (NN_C n c d) = species_masc d (n,c) $
case (n,c) of
(Sg,Nom) -> [bit++"i", bit++"e"]
(Pl,Nom) -> bita_bitae ++ [bit++"ar",bit++"ær"]
(Pl,Dat) -> [bit++"um", bit++"om"]
_ -> bita_bitae
where bita_bitae = [bit++"a", bit++"æ"]
-- Femininum
species_fem :: Species -> (Number,Case) -> [String] -> Str
species_fem Indef _ xs = strings xs
species_fem Def (n,c) xs = strings $
case (c,n) of
(Nom,Sg) -> [x ++ "n" | x <- xs]
(Gen,Sg) -> [x ++ y | x <- xs, y <- ["nna", "nnar"]]
(Dat,Sg) -> [x ++ "nni" | x <- xs]
(Ack,Sg) -> [x ++ "na" | x <- xs]
(Nom,Pl) -> [x ++ y | x <- xs, y <- ["na", "nar"]] -- ?
(Gen,Pl) -> [x ++ "nna" | x <- xs]
(Dat,Pl) -> [x ++ "in" | x <- xs]
(Ack,Pl) -> [x ++ y | x <- xs, y <- ["na", "nar"]]
gata_rule :: String -> NN
gata_rule gata (NN_C n c d) = species_fem d (n,c) $
case (n,c) of
(Sg,Nom) -> [gat++"a",gat++"æ"]
(Sg,_) -> [gat++"u",gat++"o"]
(Pl,Gen) -> [gat++suff | suff <- ["na", "næ", "u","o"]]
(Pl,Dat) -> [gat++"um", gat++"om"]
(Pl,_) -> [gat++suff | suff <- ["u", "ur", "o","or"]]
where gat = tk 1 gata
kyrkia_rule :: String -> NN
kyrkia_rule kyrkia = excepts (gata_rule kyrkia)
[(NN_C Pl Gen Indef,
strings [kyrk++"na", kyrk++"næ", kyrk++"iu", kyrk++"io"])]
where kyrk = tk 2 kyrkia
fru_rule :: String -> NN
fru_rule fru (NN_C n c d) = species_fem d (n,c) $
case (n,c) of
(Sg,Nom) -> [fru,fru++"a", fru++"æ"]
(Sg,_) -> [fru,fru++"u",fru++"o"]
(Pl,Gen) -> [fru]
(Pl,Dat) -> [fru++suff | suff <- ["om","m","um"]]
(Pl,_) -> [fru++suff | suff <- ["o","or","ur","r",""]]
glaethi_rule :: String -> NN
glaethi_rule glaethi (NN_C n c d) =
case (n,c) of
(Sg,Nom) -> strings [glaethi++"n", glaeth++"en"]
(Sg,Gen) -> strings [glaethi++"nna",glaethi++"nnar"]
(Sg,Dat) -> strings [glaethi++"nni", glaeth++"enni"]
(Sg,Ack) -> strings [glaethi++"na", glaeth++"ena"]
_ -> nonExist
where glaeth = tk 1 glaethi
-- Neutrum
species_neu :: Species -> (Number,Case) -> [String] -> Str
species_neu Indef _ xs = strings xs
species_neu Def (n,c) xs = strings $
case (c,n) of
(Gen,Sg) -> [x ++ "ns" | x <- xs]
(Dat,Sg) -> [x ++ "nu" | x <- xs]
(_,Sg) -> [x ++ "t" | x <- xs]
(Gen,Pl) -> [x ++ "nna" | x <- xs]
(_,Pl) -> [x ++ "in" | x <- xs]
ogha_rule :: String -> NN
ogha_rule ogha (NN_C n c d) =
species_neu d (n,c) $
case (n,c) of
(Sg,_) -> [ogh++"a" ,ogh++"æ"]
(Pl,Gen) -> [ogh++"na" ,ogh++"næ"]
(Pl,Dat) -> [ogh++"um" ,ogh++"om"]
_ -> [ogh++"un" ,ogh++"on"]
where ogh = tk 1 ogha
-- Noun: Strong Declension
-- Masc
fisker_rule :: String -> NN
fisker_rule fisker (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Nom,Indef) -> [fisker]
(Sg,Gen,Indef) -> [fisk++"s"]
(Sg,Dat,Indef) -> [fisk ++ x | x <- ["i","e",""]]
(Sg,Ack,Indef) -> [fisk]
(Pl,Nom,Indef) -> [fisk ++ x | x <- ["a","ar","æ","ær"]]
(Pl,Dat,Indef) -> [fisk ++ x | x <- ["um","om"]]
(Pl,_,Indef) -> [fisk ++ x | x <- ["a","æ"]]
(Sg,Nom,Def) -> [fisk++"rin"]
(Sg,Gen,Def) -> [fisk++"sins"]
(Sg,Dat,Def) -> [fisk ++ x | x <- ["inum","enum","num"]]
(Sg,Ack,Def) -> [fisk++"in"]
(Pl,Nom,Def) -> [fisk ++ x | x <- ["ani","anir","æni","ænir"]]
(Pl,Dat,Def) -> [fisk ++ x | x <- ["umin","omin"]]
(Pl,_,Def) -> [fisk ++ x | x <- ["ana","æna"]]
where fisk = tk 2 fisker
aengil_rule :: String -> NN
aengil_rule aengil (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Gen,Indef) -> [aengil++"s"]
(Sg,Dat,Indef) -> [aengl ++ x | x <- ["i","e"]]
(Sg,_,Indef) -> [aengil]
(Pl,Nom,Indef) -> [aengl ++ x | x <- ["a","ar","æ","ær"]]
(Pl,Dat,Indef) -> [aengl ++ x | x <- ["um","om"]]
(Pl,_,Indef) -> [aengl ++ x | x <- ["a","æ"]]
(Sg,Gen,Def) -> [aeng++"ilsins"]
(Sg,Dat,Def) -> [aengl ++ x | x <- ["inum","enum"]]
(Sg,_,Def) -> [aeng ++ x | x <- ["lin","ilin"]]
(Pl,Nom,Def) -> [aengl ++ x | x <- ["ani","anir","æni","ænir"]]
(Pl,Dat,Def) -> [aengl ++ x | x <- ["umin","omin"]]
(Pl,_,Def) -> [aengl ++ x | x <- ["ana","æna"]]
where aeng = tk 2 aengil
aengl = aeng++"l"
sko_rule :: String -> NN
sko_rule sko (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Gen,Indef) -> [sko++"s"]
(Sg,Nom,Indef) -> [sko, sko++ "r"]
(Sg,_,Indef) -> [sko]
(Pl,Nom,Indef) -> [sko ++ x | x <- ["a","ar","ar","r"]]
(Pl,Dat,Indef) -> [sko ++ x | x <- ["um","om","m"]]
(Pl,_,Indef) -> [sko,sko++"a"]
(Sg,Nom,Def) -> [sko ++ x | x <- ["n","in","rin","rn"]]
(Sg,Gen,Def) -> [sko++"sins"]
(Sg,Dat,Def) -> [sko ++ "num"]
(Sg,Ack,Def) -> [sko++ x | x <- ["in","n"]]
(Pl,Nom,Def) -> [sko ++ x | x <- ["ani","anir","ni","nir"]]
(Pl,Dat,Def) -> [sko ++ x | x <- ["umin","omin","min"]]
(Pl,_,Def) -> [sko ++ x | x <- ["anna","nna"]]
aptan_rule :: String -> NN
aptan_rule aptan (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Gen,Indef) -> [aptan ++ "s"]
(Sg,Dat,Indef) -> [apt ++ x | x <- ["ni","ne"]]
(Sg,_,Indef) -> [aptan]
(Pl,Nom,Indef) -> [apt ++ x | x <- ["na","nar","næ","nær"]]
(Pl,Dat,Indef) -> [apt ++ x | x <- ["num","nom"]]
(Pl,_,Indef) -> [apt ++ x | x <- ["na","næ"]]
(Sg,Gen,Def) -> [apt ++ "ansins"]
(Sg,Dat,Def) -> [apt ++ x | x <- ["ninum","nenum"]]
(Sg,_,Def) -> [apt ++ x | x <- ["nin","anin"]]
(Pl,Nom,Def) -> [apt ++ x | x <- ["nani","nanir","næni","nænir"]]
(Pl,Dat,Def) -> [apt ++ x | x <- ["numin","nomin"]]
(Pl,Gen,Def) -> [apt ++ x | x <- ["nanna","nænna"]]
(Pl,Ack,Def) -> [apt ++ x | x <- ["nana","næna"]]
where apt = tk 2 aptan
vaever_rule :: String -> NN
vaever_rule vaever (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Nom,Indef) -> [vaever]
(Sg,Gen,Indef) -> [vaef ++ "s"]
(Sg,_,Indef) -> [vaef]
(Pl,Nom,Indef) -> [vaef ++ x | x <- ["ia","iar","iæ","iær"]]
(Pl,Dat,Indef) -> [vaef ++ x | x <- ["ium","iom"]]
(Pl,_,Indef) -> [vaef ++ x | x <- ["ia","iæ"]]
(Sg,Nom,Def) -> [vae ++ "vrin"]
(Sg,Gen,Def) -> [vaef ++ "sins"]
(Sg,Dat,Def) -> [vaef ++"num"]
(Sg,Ack,Def) -> [vaef ++ "in"]
(Pl,Nom,Def) -> [vaef ++ x | x <- ["iani","ianir","iæni","iænir"]]
(Pl,Dat,Def) -> [vaef ++ x | x <- ["iumin","iomin"]]
(Pl,Gen,Def) -> [vaef ++ x | x <- ["ianna","iænna"]]
(Pl,Ack,Def) -> [vaef ++ x | x <- ["iana","iæna"]]
where vae = tk 3 vaever
vaef = vae++"f"
laegger_rule :: String -> NN
laegger_rule laegger (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Nom,Indef) -> [laegger]
(Sg,Gen,Indef) -> [laegg ++ x | x <- ["ia","iar","iæ","iær"]]
(Sg,Dat,Indef) -> [laeg ++ x | x <- ["gi","ge",""]]
(Sg,Ack,Indef) -> [laeg]
(Pl,Nom,Indef) -> [laegg ++ x | x <- ["ia","iar","iæ","iær"]]
(Pl,Dat,Indef) -> [laegg ++ x | x <- ["ium","iom"]]
(Pl,_,Indef) -> [laegg ++ x | x <- ["ia","iæ"]]
(Sg,Nom,Def) -> [laegg ++ "rin"]
(Sg,Gen,Def) -> [laegg ++ "sins"]
(Sg,Dat,Def) -> (laeg++"num"):[laegg ++ x | x <- ["inum","enum"]]
(Sg,Ack,Def) -> [laeg ++ "in"]
(Pl,Nom,Def) -> [laegg ++ x | x <- ["iani","ianir","iæni","iænir"]]
(Pl,Dat,Def) -> [laegg ++ x | x <- ["iumin","iomin"]]
(Pl,_,Def) -> [laegg ++ x | x <- ["ianna","iænna"]]
where laeg = tk 3 laegger
laegg = tk 2 laegger
oeri_rule :: String -> NN
oeri_rule oeri (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Nom,Indef) -> [oeri,oeri++"r"]
(Sg,Gen,Indef) -> [oeri++"s"]
(Sg,_,Indef) -> [oeri,oer++"e"]
(Pl,Nom,Indef) -> [oer ++ x | x <- ["a","ar","æ","ær"]]
(Pl,Dat,Indef) -> [oer ++ x | x <- ["um","om"]]
(Pl,_,Indef) -> [oer ++ x | x <- ["a","æ"]]
(Sg,Nom,Def) -> [oeri ++ x | x <- ["n","rn"]]
(Sg,Gen,Def) -> [oeri ++ "sins"]
(Sg,Dat,Def) -> [oer ++ x | x <- ["inum","enum"]]
(Sg,Ack,Def) -> [oer ++ x | x <- ["in","en"]]
(Pl,Nom,Def) -> [oer ++ x | x <- ["ani","anir","æni","ænir"]]
(Pl,Dat,Def) -> [oer ++ x | x <- ["umin","omin"]]
(Pl,Gen,Def) -> [oer ++ x | x <- ["anna","ænna"]]
(Pl,Ack,Def) -> [oer ++ x | x <- ["ana","æna"]]
where oer = tk 1 oeri
raetter_rule :: String -> NN
raetter_rule raetter (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Nom,Indef) -> [raetter]
(Sg,Gen,Indef) -> (rae++"z"):[raett ++ x | x <- ["a","ar","æ","ær"]]
(Sg,Dat,Indef) -> [raet ++ x | x <- ["ti","te",""]]
(Sg,Ack,Indef) -> [raet]
(Pl,Nom,Indef) -> [raett ++ x | x <- ["i","ir","e","er"]]
(Pl,Dat,Indef) -> [raett ++ x | x <- ["um","om"]]
(Pl,_,Indef) -> [raett ++ x | x <- ["a","æ"]]
(Sg,Nom,Def) -> [raett ++ "rin"]
(Sg,Gen,Def) -> [raett ++ "sins", rae++"zins"]
(Sg,Dat,Def) -> (raet++"num"):[raett ++ x | x <- ["inum","enum"]]
(Sg,Ack,Def) -> [raett ++ "in"]
(Pl,Nom,Def) -> [raett ++ x | x <- ["ini","inir"]]
(Pl,Dat,Def) -> [raett ++ x | x <- ["umin","omin"]]
(Pl,Gen,Def) -> [raett ++ x | x <- ["anna","ænna"]]
(Pl,Ack,Def) -> [raett ++ x | x <- ["ina","ena"]]
where raet = tk 3 raetter
raett = tk 2 raetter
rae = tk 4 raetter
bondi_rule :: String -> NN
bondi_rule bondi (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Nom,Indef) -> [bondi, bond++"e"]
(Sg,_,Indef) -> [bond++"a", bond++"æ"]
(Pl,Gen,Indef) -> [bond++"a", bond++"æ"]
(Pl,Dat,Indef) -> [bond++"um", bond++"om"]
(Pl,_,Indef) -> [umlaut(bond)++"er"]
(Sg,Nom,Def) -> [bond++"in", bond++"en"]
(Sg,Gen,Def) -> [bond++"sins"]
(Sg,Dat,Def) -> [bond++"anum",bond++"ænum"]
(Sg,Ack,Def) -> [bond++"in"]
(Pl,Nom,Def) -> [umlaut(bond)++suf | suf <- ["rini","rinir"]]
(Pl,Dat,Def) -> [bond ++ suf | suf <- ["umin","omin"]]
(Pl,Gen,Def) -> [bond ++ suf | suf <- ["anna","ænna"]]
(Pl,Ack,Def) -> [umlaut(bond)++"rina"]
where bond = tk 1 bondi
son_rule :: String -> NN
son_rule son (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Nom,Indef) -> [son, s++"un"]
(Sg,Gen,Indef) -> [son ++ "ar", son++"ær", sun++"ar", sun++"ær"]
(Sg,Dat,Indef) -> [syn++"i", syn++"e",sun]
(Sg,Ack,Indef) -> [syn, son,sun]
(Pl,Nom,Indef) -> [syn++ suff | suff <- ["i","ir","e","er"]]
(Pl,Gen,Indef) -> [son++"a", son++"æ", sun++"a", sun++"æ"]
(Pl,Dat,Indef) -> [son++"um", sun++"um"]
(Pl,Ack,Indef) -> [syn++"i",sun++"u"]
(Sg,Nom,Def) -> [son++"in", sun++"in"]
(Sg,Gen,Def) -> [son++"sins", sun++"sins"]
(Sg,Dat,Def) -> [syn++"inum",syn++"enum",sun++"um"]
(Sg,Ack,Def) -> [syn++"in", son++"in", sun++"in"]
(Pl,Nom,Def) -> [syn++"ini",syn++"inir", syn++"eni",syn++"enir"]
(Pl,Gen,Def) -> [son++"anna", son++"ænna",sun++"anna", sun++"ænna"]
(Pl,Dat,Def) -> [son++"umin",sun++"umin"]
(Pl,Ack,Def) -> [syn++"ina", sun++"una"]
where s = tk 2 son
sun = s ++ "un"
syn = s ++ "yn"
mather_rule :: String -> NN
mather_rule mather (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Nom,Indef) -> [mather, man]
(Sg,Gen,Indef) -> [man++"z"]
(Sg,Dat,Indef) -> [man++"ni", man++"ne"]
(Sg,Ack,Indef) -> [man]
(Pl,Gen,Indef) -> [man++"na", man++"næ"]
(Pl,Dat,Indef) -> [man++"num",man++"nom"]
(Pl,_,Indef) -> [maen]
(Sg,Nom,Def) -> [math++"irin",math++"rin",man++"nin"]
(Sg,Gen,Def) -> [man++"zins"]
(Sg,Dat,Def) -> [man++"ninum",man++"nenum"]
(Sg,Ack,Def) -> [man++"nin"]
(Pl,Nom,Def) -> [maen++"ni",maen++"nir"]
(Pl,Gen,Def) -> [man++"nanna", man++"nænna"]
(Pl,Dat,Def) -> [man++"numin",man++"nomin"]
(Pl,Ack,Def) -> [maen++"na"]
where math = tk 2 mather
man = tk 3 mather ++ "n"
maen = tk 3 mather ++ "æn"
foter_rule :: String -> NN
foter_rule foter (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Nom,Indef) -> [foter]
(Sg,Gen,Indef) -> [fot++suff | suff <- ["a","ar","æ","ær"]]
(Sg,Dat,Indef) -> [foet++"i",foet++"e",fot++"i",fot++"e"]
(Sg,Ack,Indef) -> [fot]
(Pl,Gen,Indef) -> [fot++"a",fot++"æ"]
(Pl,Dat,Indef) -> [fot++"um",fot++"om"]
(Pl,_,Indef) -> [foet++"er"]
(Sg,Nom,Def) -> [fot++"rin"]
(Sg,Gen,Def) -> [fot++"sins"]
(Sg,Dat,Def) -> [foet++"inum",foet++"enum",fot++"inum",fot++"enum"]
(Sg,Ack,Def) -> [fot++"in"]
(Pl,Nom,Def) -> [foet++"rini",foet++"rinir"]
(Pl,Gen,Def) -> [fot++"anna", fot++"ænna"]
(Pl,Dat,Def) -> [fot++"umin", fot++"omin"]
(Pl,Ack,Def) -> [foet++"rina"]
where fot = tk 2 foter
foet = umlaut fot
fathir_rule :: String -> NN
fathir_rule fathir (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Nom,Indef) -> [fathir]
(Sg,Gen,Indef) -> [fath++"ur",fath++"urs",fath++"or",fath++"ors"]
(Sg,Dat,Indef) -> [fath++"ur",fath++"or",faeth++"er"]
(Sg,Ack,Indef) -> [fath++"ur",fath++"or"]
(Pl,Gen,Indef) -> [faeth++"ra",faeth++"ræ"]
(Pl,Dat,Indef) -> [faeth++"rum",faeth++"rom"]
(Pl,_,Indef) -> [faeth++"er"]
(Sg,Nom,Def) -> [fath++"irin",fath++"rin"]
(Sg,Gen,Def) -> [fath++"ursins",fath++"urins",fath++"orsins",fath++"orins"]
(Sg,Dat,Def) -> [fath++"urnum",fath++"ornum",faeth++"ernum"]
(Sg,Ack,Def) -> [fath++"urin",fath++"rin"]
(Pl,Nom,Def) -> [faeth++"rini",faeth++"rinir"]
(Pl,Gen,Def) -> [faeth++"ranna",faeth++"rænna"]
(Pl,Dat,Def) -> [faeth++"rumin",faeth++"romin"]
(Pl,Ack,Def) -> [faeth++"rina"]
where fath = tk 2 fathir
faeth = umlaut fath
eghandi_rule :: String -> NN
eghandi_rule eghandi (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Nom,Indef) -> [eghand++"i",eghand++"e"]
(Sg,_,Indef) -> [eghand++"a",eghand++"æ"]
(Pl,Gen,Indef) -> [eghand++"a",eghand++"æ"]
(Pl,Dat,Indef) -> [eghand++"um",eghand++"om"]
(Pl,_,Indef) -> [eghand++"er",eghand++"ar"]
(Sg,Nom,Def) -> [eghand++"in",eghand++"en"]
(Sg,Gen,Def) -> [eghand++"sins"]
(Sg,Dat,Def) -> [eghand++"anum",eghand++"ænum"]
(Sg,Ack,Def) -> [eghand++"in"]
(Pl,Nom,Def) -> [eghand++"inir",eghand++"ini"]
(Pl,Gen,Def) -> [eghand++"anna",eghand++"ænna"]
(Pl,Dat,Def) -> [eghand++"umin",eghand++"omin"]
(Pl,Ack,Def) -> [eghand++"ina"]
where eghand = tk 1 eghandi
-- Fem.
agn_rule :: String -> NN
agn_rule agn (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Gen,Indef) -> [agn ++ x | x <- ["a","ar","æ","ær"]]
(Sg,_,Indef) -> [agn]
(Pl,Dat,Indef) -> [agn ++ x | x <- ["um","om"]]
(Pl,Gen,Indef) -> [agn ++ x | x <- ["a","æ"]]
(Pl,_,Indef) -> [agn ++ x | x <- ["a","ar","æ","ær"]]
(Sg,Nom,Def) -> [agn ++ "in"]
(Sg,Gen,Def) -> [agn ++ x | x <- ["inna","innar"]]
(Sg,Dat,Def) -> [agn ++ "inni"]
(Sg,Ack,Def) -> [agn ++ "ina"]
(Pl,Gen,Def) -> [agn ++ x | x <- ["anna","ænna"]]
(Pl,Dat,Def) -> [agn ++ x | x <- ["umin","omin"]]
(Pl,_,Def) -> [agn ++ x | x <- ["ana","anar","æna","ænar"]]
bro_rule :: String -> NN
bro_rule bro (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Gen,Indef) -> [bro ++ x | x <- ["a","ar","æ","ær","r",""]]
(Sg,_,Indef) -> [bro]
(Pl,Dat,Indef) -> [bro ++ x | x <- ["um","om","m"]]
(Pl,Gen,Indef) -> [bro ++ x | x <- ["a","æ",""]]
(Pl,_,Indef) -> [bro ++ x | x <- ["a","ar","æ","ær","r",""]]
(Sg,Nom,Def) -> [bro ++ x | x <- ["in", "n"]]
(Sg,Gen,Def) -> [bro ++ x | x <- ["inna","nna","innar","nnar"]]
(Sg,Dat,Def) -> [bro ++ x | x <- ["inni","nni"]]
(Sg,Ack,Def) -> [bro ++ x | x <- ["ina","na"]]
(Pl,Gen,Def) -> [bro ++ x | x <- ["anna","ænna","nna"]]
(Pl,Dat,Def) -> [bro ++ x | x <- ["umin","omin","min"]]
(Pl,_,Def) -> [bro ++ x | x <- ["ana","anar","æna","ænar","nar","rna","rnar","na","nar"]]
aeg_rule :: String -> NN
aeg_rule aeg (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Gen,Indef) -> [aeg ++ suf | suf <- ["gia","giar","giæ","giær"]]
(Sg,_,Indef) -> [aeg]
(Pl,Dat,Indef) -> [aeg ++ suf | suf <- ["gium","giom"]]
(Pl,Gen,Indef) -> [aeg ++ suf | suf <- ["gia","giæ"]]
(Pl,_,Indef) -> [aeg ++ suf | suf <- ["gia","giar","giæ","giær"]]
(Sg,Nom,Def) -> [aeg ++ suf | suf <- ["gin"]]
(Sg,Gen,Def) -> [aeg ++ suf | suf <- ["inna","innar"]]
(Sg,Dat,Def) -> [aeg ++ suf | suf <- ["ginni"]]
(Sg,Ack,Def) -> [aeg ++ suf | suf <- ["gina"]]
(Pl,Gen,Def) -> [aeg ++ suf | suf <- ["gianna","giænna"]]
(Pl,Dat,Def) -> [aeg ++ suf | suf <- ["giumin","giomin"]]
(Pl,_,Def) -> [aeg ++ suf | suf <- ["iana","ianar","iæna","iænar"]]
heth_rule :: String -> NN
heth_rule heth (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Nom,Indef) -> [heth]
(Sg,Gen,Indef) -> [heth ++ suf | suf <- ["a","ar","æ","ær"]]
(Sg,_,Indef) -> [heth ++ suf | suf <- ["i","e",""]]
(Pl,Dat,Indef) -> [heth ++ suf | suf <- ["um","om"]]
(Pl,Gen,Indef) -> [heth ++ suf | suf <- ["a","æ"]]
(Pl,_,Indef) -> [heth ++ suf | suf <- ["a","ar","æ","ær"]]
(Sg,Nom,Def) -> [heth ++ suf | suf <- ["in"]]
(Sg,Gen,Def) -> [heth ++ suf | suf <- ["inna","innar"]]
(Sg,Dat,Def) -> [heth ++ suf | suf <- ["inni"]]
(Sg,Ack,Def) -> [heth ++ suf | suf <- ["ina"]]
(Pl,Gen,Def) -> [heth ++ suf | suf <- ["anna","ænna"]]
(Pl,Dat,Def) -> [heth ++ suf | suf <- ["umin","omin"]]
(Pl,_,Def) -> [heth ++ suf | suf <- ["ana","anar","æna","ænar"]]
faerth_rule :: String -> NN
faerth_rule faerth (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Gen,Indef) -> [faerth ++ suf | suf <- ["a","ar","æ","ær"]]
(Sg,_,Indef) -> [faerth]
(Pl,Dat,Indef) -> [faerth ++ suf | suf <- ["um","om"]]
(Pl,Gen,Indef) -> [faerth ++ suf | suf <- ["a","æ"]]
(Pl,_,Indef) -> [faerth ++ suf | suf <- ["i","ir","e","er"]]
(Sg,Nom,Def) -> [faerth ++ "in"]
(Sg,Gen,Def) -> [faerth ++ suf | suf <- ["inna","innar"]]
(Sg,Dat,Def) -> [faerth ++ suf | suf <- ["inni"]]
(Sg,Ack,Def) -> [faerth ++ suf | suf <- ["ina"]]
(Pl,Gen,Def) -> [faerth ++ suf | suf <- ["anna","ænna"]]
(Pl,Dat,Def) -> [faerth ++ suf | suf <- ["umin","omin"]]
(Pl,_,Def) -> [faerth ++ suf | suf <- ["ina","inar","ena","enar"]]
gas_rule :: String -> NN
gas_rule gas (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Gen,Indef) -> [gas ++ suf | suf <- ["a","ar"]]
(Sg,_,Indef) -> [gas]
(Pl,Dat,Indef) -> [gas ++ suf | suf <- ["um"]]
(Pl,Gen,Indef) -> [gas ++ suf | suf <- ["a"]]
(Pl,_,Indef) -> [umlaut(gas)]
(Sg,Nom,Def) -> [gas ++ "in"]
(Sg,Gen,Def) -> [gas ++ suf | suf <- ["inna","innar"]]
(Sg,Dat,Def) -> [gas ++ "inni"]
(Sg,Ack,Def) -> [gas ++ "ina"]
(Pl,Gen,Def) -> [gas ++ "anna"]
(Pl,Dat,Def) -> [gas ++ "umin"]
(Pl,_,Def) -> [umlaut(gas) ++ suf | suf <- ["ina","inar"]]
bok_rule :: String -> NN
bok_rule bok (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Gen,Indef) -> [bok++"a",bok++"ar"]
(Sg,_,Indef) -> [bok]
(Pl,Gen,Indef) -> [bok++"a"]
(Pl,Dat,Indef) -> [bok++"um",bok++"om"]
(Pl,_,Indef) -> [boek++"er"]
(Sg,Nom,Def) -> [bok++"in"]
(Sg,Gen,Def) -> [bok++"inna",bok++"innar"]
(Sg,Dat,Def) -> [bok++"inni"]
(Sg,Ack,Def) -> [bok++"ina"]
(Pl,Nom,Def) -> [boek++"enar",boek++"ena"]
(Pl,Gen,Def) -> [bok++"anna"]
(Pl,Dat,Def) -> [bok ++ suf | suf <- ["umin","omin"]]
(Pl,Ack,Def) -> [boek++"enar"]
where boek = umlaut bok
ko_rule :: String -> NN
ko_rule ko (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Gen,Indef) -> [ko++"a",ko++"ar",ko++"r"]
(Sg,_,Indef) -> [ko]
(Pl,Gen,Indef) -> [ko,ko++"a",ko++"æ"]
(Pl,Dat,Indef) -> [ko++"um",ko++"m",ko++"om"]
(Pl,_,Indef) -> [koe,koe++"r",ko,ko++"r"]
(Sg,Nom,Def) -> [ko++"in",ko++"n"]
(Sg,Gen,Def) -> [ko ++ suf | suf <- ["innar","nnar", "nna", "inna"]]
(Sg,Dat,Def) -> [ko++"inni",ko++"nni"]
(Sg,Ack,Def) -> [ko++"ina", ko++"na"]
(Pl,Gen,Def) -> [ko++"anna"]
(Pl,Dat,Def) -> [ko++"umin", ko++"omin", ko++"min"]
(Pl,_,Def) -> [koe++"na",koe++"nar",ko++"na", ko++"nar"]
where koe = umlaut ko
mothir_rule :: String -> NN
mothir_rule mothir (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Nom,Indef) -> [mothir]
(Sg,Gen,Indef) -> [moth++"ur",moth++"urs",moth++"or",moth++"ors"]
(Sg,Dat,Indef) -> [moth++"ur",moth++"or",myth++"r"]
(Sg,Ack,Indef) -> [moth++"ur", moth++"or"]
(Pl,Gen,Indef) -> [moeth++"ra", moeth++"ræ"]
(Pl,Dat,Indef) -> [moeth++"rum",moeth++"rom"]
(Pl,_,Indef) -> [moeth++"er"]
(Sg,Nom,Def) -> [moth++"irin"]
(Sg,Gen,Def) -> [moth ++ suf | suf <- ["urinnar","urinna","orinnar","orinna"]]
(Sg,Dat,Def) -> [moth++"urinni",moth++"orinni", myth ++ "rinni"]
(Sg,Ack,Def) -> [moth++suff | suff <- ["urina","urna", "orina", "orna"]]
(Pl,Gen,Def) -> [moeth++"ranna",moeth++"rænna"]
(Pl,Dat,Def) -> [moeth++"rumin",moeth++"romin"]
(Pl,_,Def) -> [moeth++"rinar",moeth++"rina"]
where moth = tk 2 mothir
myth = tk 4 mothir ++ "yþ"
moeth = umlaut moth
-- Neut.
skip_rule :: String -> NN
skip_rule skip (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Gen,Indef) -> [skip++"s"]
(Sg,Dat,Indef) -> [skip ++ x | x <- ["i","e",""]]
(Sg,_,Indef) -> [skip]
(Pl,Gen,Indef) -> [skip ++ x | x <- ["a","æ"]]
(Pl,Dat,Indef) -> [skip ++ x | x <- ["um","om"]]
(Pl,_,Indef) -> [skip]
(Sg,Gen,Def) -> [skip++"sins"]
(Sg,Dat,Def) -> [skip ++ x | x <- ["inu","enu","nu"]]
(Sg,_,Def) -> [skip ++ "it"]
(Pl,Dat,Def) -> [skip ++ x | x <- ["umin","omin"]]
(Pl,Gen,Def) -> [skip ++ x | x <- ["anna","ænna"]]
(Pl,_,Def) -> [skip ++ "in"]
bo_rule :: String -> NN
bo_rule bo (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Gen,Indef) -> [bo++"s"]
(Sg,_,Indef) -> [bo]
(Pl,Gen,Indef) -> [bo ++ x | x <- ["a",""]]
(Pl,Dat,Indef) -> [bo ++ "m"]
(Pl,_,Indef) -> [bo]
(Sg,Gen,Def) -> [bo++"sins"]
(Sg,Dat,Def) -> [bo ++ "no"]
(Sg,_,Def) -> [bo ++ x | x <- ["t","it"]]
(Pl,Dat,Def) -> [bo ++ "min"]
(Pl,Gen,Def) -> [bo ++ x | x <- ["anna","nna"]]
(Pl,_,Def) -> [bo ++ x | x <- ["in","n"]]
hovuth_rule :: String -> NN
hovuth_rule hovuth (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Gen,Indef) -> [hov++"uz", huv++"uz"]
(Sg,Dat,Indef) -> [hof++"þe", hoef++"þi", hof++"þi"]
(Sg,_,Indef) -> [hov++"uþ",huv++"uþ"]
(Pl,Gen,Indef) -> [hof++"þa",hoef++"þa"]
(Pl,Dat,Indef) -> [hof++"þom",hof++"þum",hoef++"þum"]
(Pl,_,Indef) -> [hov++"uþ",huv++"uþ"]
(Sg,Gen,Def) -> [hov++"uzins",huv++"uzins"]
(Sg,Dat,Def) -> [hof++"þenu",hoef++"inu",hof++"þinu"]
(Sg,_,Def) -> [hov++"uþit",huv++"uþit"]
(Pl,Gen,Def) -> [hof++"þanna",hoef++"þanna"]
(Pl,Dat,Def) -> [hof++"þomin",hof++"þumin",hoef++"þumin"]
(Pl,_,Def) -> [hov++"uþin",huv++"uþin"]
where hov = tk 2 hovuth
huv = tk 2 hov ++ "uv"
hof = tk 1 hov ++ "f"
hoef = umlaut hof
trae_rule :: String -> NN
trae_rule trae (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Gen,Indef) -> [trae++"s"]
(Sg,_,Indef) -> [trae]
(Pl,Gen,Indef) -> [trae++"a",trae]
(Pl,Dat,Indef) -> [trae++"um",trae++"m"]
(Pl,_,Indef) -> [trae]
(Sg,Gen,Def) -> [trae++"sins"]
(Sg,Dat,Def) -> [trae++"no"]
(Sg,_,Def) -> [trae ++ x | x <- ["t","it"]]
(Pl,Gen,Def) -> [trae ++ x | x <- ["anna","nna"]]
(Pl,Dat,Def) -> [trae++"umin",trae++"min"]
(Pl,_,Def) -> [trae ++ x | x <- ["in","n"]]
skaer_rule :: String -> NN
skaer_rule skaer (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Gen,Indef) -> [skaer++"s"]
(Sg,Dat,Indef) -> [skaer++"i"]
(Sg,_,Indef) -> [skaer]
(Pl,Gen,Indef) -> [skaer++"ia"]
(Pl,Dat,Indef) -> [skaer++"iom",skaer++"ium"]
(Pl,_,Indef) -> [skaer]
(Sg,Gen,Def) -> [skaer++"ins"]
(Sg,Dat,Def) -> [skaer++"inu"]
(Sg,_,Def) -> [skaer++"it"]
(Pl,Gen,Def) -> [skaer++"ianna"]
(Pl,Dat,Def) -> [skaer++"iomin",skaer++"iumin"]
(Pl,_,Def) -> [skaer++"in"]
minne_rule :: String -> NN
minne_rule minne (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Gen,Indef) -> [minn++"is"]
(Sg,_,Indef) -> [minne]
(Pl,Gen,Indef) -> [minn++"a"]
(Pl,Dat,Indef) -> [minn++"om"]
(Pl,_,Indef) -> [minne]
(Sg,Gen,Def) -> [minn++"isins"]
(Sg,Dat,Def) -> [minne++"no"]
(Sg,_,Def) -> [minne++"t"]
(Pl,Gen,Def) -> [minn++"anna"]
(Pl,Dat,Def) -> [minn++"omin"]
(Pl,_,Def) -> [minne++"n"]
where minn = tk 1 minne
aepli_rule :: String -> NN
aepli_rule aepli (NN_C n c d) =
strings $
case (n,c,d) of
(Sg,Gen,Indef) -> [aepli++"s"]
(Sg,_,Indef) -> [aepli]
(Pl,Gen,Indef) -> [aepl++"a"]
(Pl,Dat,Indef) -> [aepl++"om"]
(Pl,_,Indef) -> [aepli]
(Sg,Gen,Def) -> [aepl++"isins"]
(Sg,Dat,Def) -> [aepl++"inu"]
(Sg,_,Def) -> [aepl++"it"]
(Pl,Nom,Def) -> [aepl++"in"]
(Pl,Gen,Def) -> [aepl++"anna"]
(Pl,Dat,Def) -> [aepl++"umin"]
(Pl,_,Def) -> [aepl++"it"]
where aepl = tk 1 aepli
-- Adjective
-- strong
{-
helagher_rule :: String -> AV
mither_rule :: String -> AV
gamal_rule :: String -> AV
kristin_rule :: String -> AV
-}
comparative :: (Gender,Number,Case) -> String -> [String]
comparative (g,n,c) blar =
case (g,n,c) of
(Fem,Sg,_) -> [blar++"e",blar++"i"]
(Masc,Sg,Nom) -> [blar++"e",blar++"i"]
(_,Sg,_) -> [blar++"e",blar++"i",blar++"a"]
(_,Pl,Gen) -> [blar++"a"]
(_,Pl,Dat) -> [blar++"e",blar++"i",blar++"om",blar++"um"]
(_,Pl,_) -> [blar++"e",blar++"i"]
blar_rule :: String -> AV
blar_rule blar para =
strings $
case para of
(StrongPos g n c) -> blar_strong_rule blar (g,n,c)
(WeakPos g n c) -> blar_weak_rule blar (g,n,c)
(Comp g n c) -> comparative (g,n,c) blar
(Super) -> [blar++"er"]
langer_rule :: String -> AV
langer_rule langer para =
strings $
case para of
(StrongPos g n c) -> langer_strong_rule langer (g,n,c)
(WeakPos g n c) -> langer_weak_rule langer (g,n,c)
(Comp g n c) -> comparative (g,n,c) (laeng ++ "r")
(Super) -> [laeng++"ster"]
where lang = tk 2 langer
laeng = changeVowel "æ" lang
helagher_rule :: String -> AV
helagher_rule helagher para =
strings $
case para of
(StrongPos g n c) -> helagher_strong_rule helagher (g,n,c)
(WeakPos g n c) -> langer_weak_rule helagher (g,n,c)
(Comp g n c) -> comparative (g,n,c) (helagh ++ "r")
(Super) -> [helagh++"ster"]
where helagh = tk 2 helagher
blar_strong_rule :: String -> (Gender,Number,Case) -> [String]
blar_strong_rule blar para =
case para of
(Masc,Sg,Nom) -> [bla++"r",bla]
(Masc,Sg,Gen) -> [bla++"s"]
(Masc,Sg,Dat) -> [bla++suff | suff <- ["om","m","r","ur"]]
(Masc,Sg,Ack) -> [bla++"n"]
(Masc,Pl,Nom) -> [bla++suff | suff <- ["","ir","r"]]
(Fem,Sg,Gen) -> [bla++"r",bla]
(Fem,Sg,Dat) -> [bla++"e",bla]
(Fem,Pl,Nom) -> [bla++"r",bla]
(Fem,Pl,Ack) -> [bla++"r",bla]
(Neut,Sg,Gen) -> [bla++"s"]
(Neut,Sg,Dat) -> [bla ++ suff | suff <- ["","o","u"]]
(Neut,Sg,_) -> [bla++"t", bla++"tt"]
(_,Pl,Dat) -> [bla++suff | suff <- ["om","m","um"]]
_ -> [bla]
where bla = tk 1 blar
blar_weak_rule :: String -> (Gender,Number,Case) -> [String]
blar_weak_rule blar para =
case para of
(Masc,Sg,Nom) -> [bla++suff | suff <- ["","e","i"]]
(Masc,Sg,_) -> [bla]
(Masc,Pl,_) -> blao_blau
(Fem,Sg,Nom) -> [bla]
(Fem,Sg,_) -> blao_blau
(Fem,Pl,_) -> blao_blau
(Neut,Sg,_) -> [bla]
(Neut,Pl,_) -> blao_blau
where blao_blau = [bla++suff | suff <- ["","o","u"]]
bla = tk 1 blar
langer_weak_rule :: String -> (Gender,Number,Case) -> [String]
langer_weak_rule langer para =
case para of
(Fem,Sg,Nom) -> langa
(Fem,_,_) -> lango_langu
(Masc,Sg,Nom) -> [lang++x | x <- ["i","e"]]
(Masc,Sg,_) -> langa
(Masc,Pl,_) -> lango_langu
(Neut,Sg,_) -> langa
(Neut,Pl,_) -> lango_langu
where lang = tk 2 langer
lango_langu = [lang++ x | x <- ["o","u"]]
langa = [lang++"a"]
langer_strong_rule :: String -> (Gender,Number,Case) -> [String]
langer_strong_rule langer para =
case para of
(Masc,Sg,Nom) -> [langer]
(Masc,Sg,Gen) -> [lang++"s"]
(Masc,Sg,Dat) -> [lang++"om",lang++"um"]
(Masc,Sg,Ack) -> [lang++"an", lang++"æn"]
(Masc,Pl,Nom) -> [lang++suff | suff <- ["i","e","ir","er"]]
(Masc,Pl,Ack) -> [lang++"a",lang++"æ"]
(Fem,Sg,Nom) -> [lang]
(Fem,Sg,Gen) -> [lang++suff | suff <- ["a","ra","ar","rar", "æ","ræ","ær","rær"]]
(Fem,Sg,Dat) -> [lang++suff | suff <- ["i","ri","e","re"]]
(Fem,Sg,Ack) -> [lang++"a", lang++"æ"]
(Fem,Pl,Nom) -> [lang++suff | suff <- ["a","ar","æ","ær"]]
(Fem,Pl,Ack) -> [lang++suff | suff <- ["a","ar","æ","ær"]]
(Neut,Sg,Gen) -> [lang++"s"]
(Neut,Sg,Dat) -> [lang++"o",lang++"u"]
(Neut,Sg,_) -> [lang++"t"]
(Neut,Pl,Nom) -> [lang]
(Neut,Pl,Ack) -> [lang]
(_,Pl,Gen) -> [lang++suff | suff <- ["a","ra","æ","ræ"]]
(_,Pl,Dat) -> [lang++suff | suff <- ["om","m","um"]]
where lang = tk 2 langer
helagher_strong_rule :: String -> (Gender,Number,Case) -> [String]
helagher_strong_rule helagher para =
case para of
(Masc,Sg,Nom) -> [helagher]
(Masc,Sg,Gen) -> [hela++"x"]
(Masc,Sg,Dat) -> [haelgh++"om",haelgh++"um"]
(Masc,Sg,Ack) -> [haelgh++"an", haelgh++"æn"]
(Masc,Pl,Nom) -> [haelgh++suff | suff <- ["i","e","ir","er"]]
(Masc,Pl,Ack) -> [haelgh++"a",haelgh++"æ"]
(Fem,Sg,Nom) -> [helagh]
(Fem,Sg,Gen) -> [haelgh++suff | suff <- ["a","ra","ar","rar",
"æ","ræ","ær","rær"]]
(Fem,Sg,Dat) -> [haelgh++suff | suff <- ["i","ri","e","re"]]
(Fem,Sg,Ack) -> [haelgh++"a", haelgh++"æ"]
(Fem,Pl,Nom) -> [haelgh++suff | suff <- ["a","ar","æ","ær"]]
(Fem,Pl,Ack) -> [haelgh++suff | suff <- ["a","ar","æ","ær"]]
(Neut,Sg,Gen) -> [hela++"x"]
(Neut,Sg,Dat) -> [haelgh++"o",haelgh++"u"]
(Neut,Sg,_) -> [hela++"kt"]
(Neut,Pl,Nom) -> [helagh]
(Neut,Pl,Ack) -> [helagh]
(_,Pl,Gen) -> [haelgh++suff | suff <- ["a","ra","æ","ræ"]]
(_,Pl,Dat) -> [haelgh++suff | suff <- ["om","m","um"]]
where helagh = tk 2 helagher
hela = tk 2 helagh
haelgh = changeVowel "æ" (tk 1 hela) ++ "gh"
-------------------------------------------------
-- Adverb
opta_rule :: String -> Adverb
opta_rule opta (AdverbForm g) =
mkStr $ case g of
Posit -> opta
Compar -> opta++"r"
Superl -> opta++"st"
laenger_rule :: String -> Adverb
laenger_rule laenge (AdverbForm g) =
mkStr $ case g of
Posit -> laenge
Compar -> laenge++"r"
Superl -> (tk 1 laenge)++"st"
yter_rule :: String -> Adverb
yter_rule yter (AdverbForm g) =
mkStr $ case g of
Posit -> yter
Compar -> yter++"mer"
Superl -> yter++"st"
-------------------------------------------------
ord_fyrsti_rule :: String -> Ordinal
ord_fyrsti_rule fyrsti (OrdF g n c) =
strings $
case (g,n,c) of
(Masc,Sg,Nom) -> [fyrsti]
(Masc,Sg,_) -> [fyrsti++"a"]
(Fem,Sg,Nom) -> [fyrsti++"a",fyrsti]
(Neut,Sg,_) -> [fyrsti++"a"]
_ -> [fyrsti++"u"]
ord_annar_rule :: Ordinal
ord_annar_rule (OrdF g n c) =
strings $
case (g,n,c) of
(Masc,Sg,Nom) -> ["annar","annan"]
(Masc,Sg,Gen) -> ["annars"]
(Masc,Sg,Ack) -> ["annan"]
(Masc,Sg,Dat) -> ["aþrum","aþrom","andrum","androm"]
(Masc,Pl,Nom) -> ["aþri","aþrir","andri","andrir"]
(Masc,Pl,Ack) -> ["aþra","andra"]
(Fem,Sg,Nom) -> ["annur","annor"]
(Fem,Sg,Gen) -> ["annara","annarra", "annarar","annarrar"]
(Fem,Sg,Dat) -> ["annari","annarri"]
(Fem,Sg,Ack) -> ["aþra","andra"]
(Fem,Pl,Nom) -> ["aþra","andra","aþrar","andrar"]
(Fem,Pl,Ack) -> ["aþrar","andra","andrar"]
(Neut,Sg,Nom) -> ["annat"]
(Neut,Sg,Gen) -> ["annars"]
(Neut,Sg,Dat) -> ["aþru","aþro","andru","andro"]
(Neut,Sg,Ack) -> ["annat"]
(Neut,Pl,Nom) -> ["annur","annor"]
(Neut,Pl,Ack) -> ["annur","annor"]
(_,Pl,Gen) -> ["annara","annarra","andra"]
(_,Pl,Dat) -> ["aþrum","aþrom","andrum","androm"]
-- Pronomen
sin_rule :: String -> Pronoun
sin_rule sin (PNF g n c) =
strings $
case (g,n,c) of
(_,Pl,Gen) -> [sin++"na"]
(_,Pl,Dat) -> [sin++"um",sin++"om"]
(Masc,Sg,Gen) -> [sin++"s"]
(Masc,Sg,Dat) -> [sin++"um",sin++"om"]
(Masc,Sg,_) -> [sin]
(Masc,Pl,Nom) -> [sin++"i",sin++"ir"]
(Masc,Pl,Ack) -> [sin++"a"]
(Fem,Sg,Nom) -> [sin]
(Fem,Sg,Gen) -> [sin++"na",sin++"nar"]
(Fem,Sg,Dat) -> [sin++"ni",sin++"ne"]
(Fem,Sg,Ack) -> [sin++"a"]
(Fem,Pl,_) -> [sin++"a",sin++"ar"]
(Neut,Sg,Gen) -> [sin++"s"]
(Neut,Sg,Dat) -> [sin++"u",sin++"o"]
(Neut,Sg,_) -> [si ++ "t"]
(Neut,Pl,_) -> [sin]
where si = tk 1 sin
var_rule :: Pronoun
var_rule (PNF g n c) =
case (g,n,c) of
(Masc,Sg,Ack) -> strings ["van", "varn"]
(_,Pl,Gen) -> strings ["varra"]
(Fem,Sg,Gen) -> strings ["varra","varrar"]
(Neut,Sg,Nom) -> strings ["vart"]
(Neut,Sg,Ack) -> strings ["vart"]
_ -> sin_rule "var" (PNF g n c)
ithar_rule :: Pronoun
ithar_rule (PNF g n c) =
strings $
case (g,n,c) of
(_,Pl,Gen) -> ["iþra"]
(_,Pl,Dat) -> ["iþrum","iþrom"]
(Masc,Sg,Nom) -> ["iþar"]
(Masc,Sg,Gen) -> ["iþars"]
(Masc,Sg,Dat) -> ["iþrum","iþrom"]
(Masc,Sg,Ack) -> ["iþan"]
(Masc,Pl,Nom) -> ["iþri", "iþrir"]
(Masc,Pl,Ack) -> ["iþra"]
(Fem,Sg,Nom) -> ["iþur"]
(Fem,Sg,Gen) -> ["iþra","iþrar"]
(Fem,Sg,Dat) -> ["iþre"]
(Fem,Sg,Ack) -> ["iþra"]
(Fem,Pl,_) -> ["iþra","iþrar"]
(Neut,Sg,Nom) -> ["iþart"]
(Neut,Sg,Gen) -> ["iþars"]
(Neut,Sg,Dat) -> ["iþru","iþro"]
(Neut,Sg,Ack) -> ["iþart"]
(Neut,Pl,_) -> ["iþur"]
thaen_rule :: Pronoun
thaen_rule (PNF g n c) =
strings $
case (g,n,c) of
(_,Pl,Gen) -> ["þera", "þerra", "þæra", "þærra"]
(_,Pl,Dat) -> ["þem","þom","þøm"]
(Masc,Sg,Nom) -> ["þæn"]
(Masc,Sg,Gen) -> ["þæs"]
(Masc,Sg,Dat) -> ["þem","þæm","þøm"]
(Masc,Sg,Ack) -> ["þæn","þen"]
(Masc,Pl,Nom) -> ["þe", "þer"]
(Masc,Pl,Ack) -> ["þa","þe"]
(Fem,Sg,Nom) -> ["þe","þøn"]
(Fem,Sg,Gen) -> ["þera","þærra"]
(Fem,Sg,Dat) -> ["þeri","þere","þerre"]
(Fem,Sg,Ack) -> ["þa"]
(Fem,Pl,_) -> ["þa","þar","þæ","þær","þe","þer"]
(Neut,Sg,Nom) -> ["þæt"]
(Neut,Sg,Gen) -> ["þæs"]
(Neut,Sg,Dat) -> ["þy","þi","þe"]
(Neut,Sg,Ack) -> ["þæt"]
(Neut,Pl,_) -> ["þøn","þe"]
thaeni_rule :: Pronoun
thaeni_rule (PNF g n c) =
strings $
case (g,n,c) of
(_,Pl,Gen) -> ["þæssa"]
(_,Pl,Dat) -> ["þæssum","þæmma","þænna"]
(Masc,Sg,Nom) -> ["þænni","þænne"]
(Masc,Sg,Gen) -> ["þæssa"]
(Masc,Sg,Dat) -> ["þæssum","þæssom","þæmma","þænna"]
(Masc,Sg,Ack) -> ["þænna"]
(Masc,Pl,Nom) -> ["þæssi", "þæssir"]
(Masc,Pl,Ack) -> ["þæssa"]
(Fem,Sg,Nom) -> ["þæssi","þæsse"]
(Fem,Sg,Gen) -> ["þæssa"]
(Fem,Sg,Dat) -> ["þæssi","þæsse"]
(Fem,Sg,Ack) -> ["þæssa","þænna"]
(Fem,Pl,_) -> ["þæssa","þæssar"]
(Neut,Sg,Nom) -> ["þætta"]
(Neut,Sg,Gen) -> ["þæssa"]
(Neut,Sg,Dat) -> ["þæssu","þæsso"]
(Neut,Sg,Ack) -> ["þætta"]
(Neut,Pl,_) -> ["þæssi","þæssin","þænne","þæsson","þæssa","þæssom"]
hvar_rule :: Pronoun
hvar_rule (PNF g n c) =
strings $
case (g,n,c) of
(_,Pl,_) -> []
(Fem,Sg,_) -> []
(Masc,Sg,Nom) -> ["hva","hvar","ha","har"]
(Masc,Sg,Gen) -> ["hvas","hvæs","hves","hvess"]
(Masc,Sg,Dat) -> ["hvem"]
(Masc,Sg,Ack) -> ["hvan","hvem","hven"]
(Neut,Sg,Nom) -> ["hvat","hvadh"]
(Neut,Sg,Gen) -> ["hvas","hvæs"]
(Neut,Sg,Dat) -> ["hvi"]
(Neut,Sg,Ack) -> ["hvat","hvadh"]
hvilkin_rule :: Pronoun
hvilkin_rule (PNF g n c) =
strings $
case (g,n,c) of
(_,Pl,Gen) -> ["hvilika","hvilikra"]
(_,Pl,Dat) -> ["hvilikum","hvilikom"]
(Masc,Sg,Nom) -> ["hvilikin"]
(Masc,Sg,Gen) -> ["hvilikins"]
(Masc,Sg,Dat) -> ["hvilikom","hvilikum"]
(Masc,Sg,Ack) -> ["hvilikin"]
(Masc,Pl,Nom) -> ["hviliki","hvilike"]
(Masc,Pl,Ack) -> ["hvilika"]
(Fem,Sg,Nom) -> ["hvilikin"]
(Fem,Sg,Gen) -> ["hvilika","hvilikra"]
(Fem,Sg,Dat) -> ["hviliki","hvilikri","hvilike"]
(Fem,Sg,Ack) -> ["hvilika"]
(Fem,Pl,_) -> ["hvilika"]
(Neut,Sg,Nom) -> ["hvilikit"]
(Neut,Sg,Gen) -> ["hvilikins"]
(Neut,Sg,Dat) -> ["hviliku","hviliko"]
(Neut,Sg,Ack) -> ["hvilikit"]
(Neut,Pl,_) -> ["hvilikin"]
nokor_rule :: Pronoun
nokor_rule (PNF g n c) =
strings $
case (g,n,c) of
(_,Pl,Dat) -> ["nakrom","nakvarom","nokrum","nokorum"]
(Masc,Sg,Nom) -> ["nakvar","nokor"]
(Masc,Sg,Gen) -> ["nakvars","nokors"]
(Masc,Sg,Dat) -> ["nakrom","nakvarom","nokrum","nokorum"]
(Masc,Sg,Ack) -> ["nakvan","nakvarn","nakon"]
(Masc,Pl,Gen) -> ["nakra","nakwara","nokra","nokora"]
(Masc,Pl,Nom) -> [x ++ y | x <- ["nakri","nakvari","nokri","nokori"], y <- ["","r"]]
(Masc,Pl,Ack) -> ["nakra","nakvara","nokra","nokora"]
(Fem,Sg,Nom) -> [x ++ y | x <- ["nakra","nakvara","nokra","nokora"], y <- ["","r"]]
(Fem,Sg,Gen) -> ["nakra","nakvara","nokra","nokora"]
(Fem,Sg,Dat) -> ["nakre","nakvare","nokri","nokori"]
(Fem,Sg,Ack) -> ["nakra","nakvara","nokra","nokora"]
(Fem,Pl,Gen) -> ["nakra","nakwara","nokra","nokora"]
(Fem,Pl,_) -> [x ++ y | x <- ["nakra","nakvara","nokra","nokora"], y <- ["","r"]]
(Neut,Sg,Nom) -> ["nakvat","nokot"]
(Neut,Sg,Gen) -> ["nakvars","nokors"]
(Neut,Sg,Dat) -> ["nakro","nakvaro","nokru","nokoru"]
(Neut,Sg,Ack) -> ["nakvat","nokot"]
(Neut,Pl,Gen) -> ["nakra","nakwara","nakrar","nakwarar","nokra","nokora"]
(Neut,Pl,_) -> ["nakor","nokor"]
aengin_rule :: Pronoun
aengin_rule (PNF g n c) =
strings $
case (g,n,c) of
(_,Pl,Gen) -> ["ænga","ængra"]
(_,Pl,Dat) -> ["ængum","ængom"]
(Masc,Sg,Nom) -> ["ængin"]
(Masc,Sg,Gen) -> ["ængsins"]
(Masc,Sg,Dat) -> ["ængum","ængom"]
(Masc,Sg,Ack) -> ["ængin"]
(Masc,Pl,Nom) -> ["ængi","ænge"]
(Masc,Pl,Ack) -> ["ænga"]
(Fem,Sg,Nom) -> ["ængin","ængon"]
(Fem,Sg,Gen) -> ["ænga","ænginna"]
(Fem,Sg,Dat) -> ["ængi","ænginni","ænge","ænginne"]
(Fem,Sg,Ack) -> ["ænga"]
(Fem,Pl,_) -> ["ænga","ængar"]
(Neut,Sg,Nom) -> ["ænkti","ænkte","ængte","ænti","ækki"]
(Neut,Sg,Gen) -> ["ængsings"]
(Neut,Sg,Dat) -> ["ængu","ængo"]
(Neut,Sg,Ack) -> ["ænkti","ænkte","ængte","ænti","ækki"]
(Neut,Pl,_) -> ["ængin","ængon"]
hvaer_rule :: Pronoun
hvaer_rule (PNF g n c) =
strings $
case (g,n,c) of
(_,Pl,_) -> []
(Masc,Sg,Nom) -> ["hvar"]
(Masc,Sg,Gen) -> ["hvars"]
(Masc,Sg,Dat) -> ["hvarium","hvariom"]
(Masc,Sg,Ack) -> ["hvarn"]
(Fem,Sg,Nom) -> ["hvar","hvarium","hvarion"]
(Fem,Sg,Gen) -> ["hvarra","hvaria"]
(Fem,Sg,Dat) -> ["hvare","hvarre", "hvarie","hvario"]
(Fem,Sg,Ack) -> ["hvaria"]
(Neut,Sg,Nom) -> ["hvart"]
(Neut,Sg,Gen) -> ["hvars"]
(Neut,Sg,Dat) -> ["hvariu","hvario"]
(Neut,Sg,Ack) -> ["hvart"]
hvarghin_rule :: Pronoun
hvarghin_rule (PNF g n c) =
strings $
case (g,n,c) of
(_,Pl,_) -> []
(Fem,Sg,Ack) -> ["hvargha"]
(Fem,_,_) -> []
(Masc,Sg,Nom) -> ["hvarghin"]
(Masc,Sg,Gen) -> ["hvarghins"]
(Masc,Sg,Dat) -> ["hvarghum","hvarghom"]
(Masc,Sg,Ack) -> ["hvarghin"]
(Neut,Sg,Dat) -> ["hvarghu","hvargho"]
(Neut,Sg,Gen) -> []
(Neut,Sg,_) -> ["hvarki","hvarti","hvarte","hvarghit"]
person_rule :: PPronoun
person_rule t = strings $ case t of
(First Sing Nom) -> ["iak","iæk","iagh"]
(First Sing Gen) -> ["min"]
(First Sing Dat) -> ["mæ","mær","mik","migh"]
(First Sing Ack) -> ["mik","migh"]
(First Dual Nom) -> ["vit"]
(First Dual Gen) -> ["okar","okkar"]
(First Dual _) -> ["oker"]
(First Plu Nom) -> ["vi","vir"]
(First Plu Gen) -> ["var","vara","varra"]
(First Plu _) -> ["os"]
(Second Sing Nom) -> ["þu"]
(Second Sing Gen) -> ["þin"]
(Second Sing Dat) -> ["þä","þär","þik","digh"]
(Second Sing Ack) -> ["þik","thigh","digh"]
(Second Dual Nom) -> ["it"]
(Second Dual Gen) -> ["ikar","ikkar"]
(Second Dual _) -> ["iker"]
(Second Plu Nom) -> ["i","ir"]
(Second Plu Gen) -> ["iþar","iþra"]
(Second Plu _) -> ["iþer"]
(Refl Sing Nom) -> []
(Refl Sing Gen) -> ["sin"]
(Refl Sing Dat) -> ["sæ","sær","sik","sigh"]
(Refl Sing Ack) -> ["sik","sigh"]
(Refl Dual Nom) -> []
(Refl Dual Gen) -> ["sin"]
(Refl Dual _) -> ["sæ","sær","sik"]
(Refl Plu Nom) -> []
(Refl Plu Gen) -> ["sin"]
(Refl Plu Dat) -> ["sæ","sær","sik"]
(Refl Plu Ack) -> ["sæ","sær","sik"]
hanhon_rule :: Pronoun
hanhon_rule (PNF g n c) =
strings $
case (g,n,c) of
(_,Pl,_) -> []
(Neut,Sg,_) -> []
(Masc,Sg,Nom) -> ["han"]
(Masc,Sg,Gen) -> ["hans"]
(Masc,Sg,Dat) -> ["hanum","honum","honom"]
(Masc,Sg,Ack) -> ["han"]
(Fem,Sg,Nom) -> ["hon"]
(Fem,Sg,Gen) -> ["hænna","hænnar","hænnas","hænnes"]
(Fem,Sg,Dat) -> ["hænni","hænne"]
(Fem,Sg,Ack) -> ["hana","hona"]
-- Verb
passivum :: Vox -> [String] -> Str
passivum p xs =
strings $
case p of
Act -> xs
Pass -> map (++"s") xs
indicative_pl :: (Person,Modus,Vox) -> String -> Str
indicative_pl (p,m,v) stem =
passivum v $
case (m,p) of
(_,P1) -> [stem ++ "um", stem ++ "om"]
(_,P2) -> [stem ++ "in"]
(Ind, P3) -> [stem ++ "a"]
(Conj,P3) -> [stem ++ suf | suf <- ["i","in","e","en"]]
imperative_pl :: Person12 -> String -> Str
imperative_pl p stem =
strings $
case p of
Pers1 -> [stem ++ "um", stem ++ "om"]
Pers2 -> [stem ++ "in"]
preteritum_ind_pl :: (Person,Vox) -> String -> Str
preteritum_ind_pl (p,v) stem =
passivum v $
case p of
P1 -> [stem++"þum",stem++"þom"]
P2 -> [stem++"þin"]
P3 -> [stem++"þu", stem++"þo"]
preteritum_conj_pl :: (Person,Vox) -> String -> Str
preteritum_conj_pl (p,v) stem =
passivum v $
case p of
P1 -> [stem++"þum",stem++"þom"]
P2 -> [stem++"þin"]
P3 -> [stem++"þi", stem++"þin"]
v_to_f :: String -> String
v_to_f stem
| last stem == 'v' = init stem ++ "f"
| otherwise = stem
-- svaga verb
aelska_rule :: String -> Verb
aelska_rule aelska p =
case p of
PresSg Ind Act -> strings [aelska++"r",aelska]
(PresSg Ind Pass) -> strings [aelska ++"s"]
(Inf v) -> passivum v [aelska]
(ImperSg) -> strings [aelska]
(ImperPl per) -> imperative_pl per aelsk
(PresPl per m v) -> indicative_pl (per,m,v) aelsk
(PretInd Pl per v) -> preteritum_ind_pl (per,v) aelsk
(PretConjPl per v) -> preteritum_conj_pl (per,v) (aelsk++"a")
(PresSg Conj v) -> passivum v [aelsk++"i",aelsk++"e"]
(PretInd Sg _ v) -> passivum v [aelska++"þi"]
(PretConjSg v) -> passivum v [aelska++"þi", aelska++"þe"]
where aelsk = tk 1 aelska
kraevia_rule :: String -> Verb
kraevia_rule kraevia p =
case p of
(PresSg Ind Act) -> strings [kraev++"er"]
(PresSg Ind Pass) -> strings [kraef++"s"]
(Inf v) -> passivum v [kraevia]
(ImperSg) -> strings [kraef]
(ImperPl Pers1) -> strings [kraef++"ium",kraef++"iom"]
(ImperPl Pers2) -> strings [kraev++"i"]
(PresPl P1 _ v) -> passivum v [kraef++"ium",kraef++"iom"]
(PresPl P2 Ind v) -> passivum v [kraev++"i"]
(PresPl P3 Ind v) -> passivum v [kraef++"ia"]
(PretInd Sg _ v) -> passivum v [kraf++"þi"]
(PretConjSg v) -> passivum v [kraf++"þi", kraf++"þe"]
(PretInd Pl per v) -> preteritum_ind_pl (per,v) kraf
(PretConjPl per v) -> preteritum_conj_pl (per,v) kraf
_ -> aelska_rule (kraev++"a") p
where kraev = tk 2 kraevia
kraef = v_to_f kraev
kraf = case findStemVowel kraef of
(pre,_,suf) -> pre ++ "a" ++ suf
foera_rule :: String -> Verb
foera_rule foera p =
case p of
(PresSg Ind Act) -> strings [foer++"ir", foer++"i"]
(PresSg Ind Pass) -> strings [foer++"s"]
(Inf v) -> passivum v [foera]
(ImperSg) -> strings [foer]
(PretInd Pl per v) -> preteritum_ind_pl (per,v) foer
(PretConjPl per v) -> preteritum_conj_pl (per,v) foer
(PretInd Sg _ v) -> passivum v [foer++"þi"]
(PretConjSg v) -> passivum v [foer++"þi", foer++"þe"]
_ -> aelska_rule foera p
where foer = tk 1 foera
is_pret :: VerbForm -> Bool
is_pret v = elem v $
[PretInd n p v | v <- values, n <- values, p <- values] ++
[PretConjSg v | v <- values] ++
[PretConjPl p v | v <- values, p <- values]
is_pres :: VerbForm -> Bool
is_pres v = elem v $
[PresSg m v | v <- values, m <- values] ++
[PresPl p m v | v <- values, m <- values, p <- values]
liva_rule :: String -> Verb
liva_rule liva p =
case p of
(PresSg Ind Act) -> strings [liv++"er", liv++"ir", liv++"i"]
(PresSg Ind Pass) -> strings [lif++"s"]
ImperSg -> strings [lif]
p | is_pret p -> foera_rule (lif++"a") p
_ -> foera_rule liva p
where liv = tk 1 liva
lif = v_to_f liv
-- starka verb
vika_rule :: String -> Verb
vika_rule vika p =
case p of
(PresSg Ind Act) -> strings [vik++"er"]
(PresSg Ind Pass) -> strings [vik ++"s"]
(Inf v) -> passivum v [vika]
(ImperSg) -> strings [vik]
(ImperPl per) -> imperative_pl per vik
(PresPl per m v) -> indicative_pl (per,m,v) vik
(PretInd Pl P1 v) -> passivum v [vik++"um",vik++"om"]
(PretInd Pl P2 v) -> passivum v [vik++"in"]
(PretInd Pl P3 v) -> passivum v [vik++"u",vik++"o"]
(PretConjPl P1 v) -> passivum v [vik++"um",vik++"om"]
(PretConjPl P2 v) -> passivum v [vik++"in"]
(PretConjPl P3 v) -> passivum v [vik++"i",vik++"in"]
(PresSg Conj v) -> passivum v [vik++"i",vik++"e"]
(PretInd Sg P2 v) -> passivum v [vek++"t"]
(PretInd Sg _ v) -> passivum v [vek]
(PretConjSg v) -> passivum v [vik++"i", vik++"e"]
where vik = tk 1 vika
vek = changeVowel "e" vik
laesa_rule :: String -> Verb
laesa_rule laesa p =
case p of
(PresSg Ind Act) -> strings [laes]
(PresSg Ind Pass) -> strings [laes]
(Inf v) -> passivum v [laesa]
(ImperSg) -> strings [laes]
(ImperPl per) -> imperative_pl per laes
(PresPl per m v) -> indicative_pl (per,m,v) laes
(PretInd Pl P1 v) -> passivum v [las++"um",las++"om"]
(PretInd Pl P2 v) -> passivum v [las++"in"]
(PretInd Pl P3 v) -> passivum v [las++"u",las++"o"]
(PretConjPl P1 v) -> passivum v [las++"um",las++"om"]
(PretConjPl P2 v) -> passivum v [las++"in"]
(PretConjPl P3 v) -> passivum v [las++"i",las++"in"]
(PresSg Conj v) -> passivum v [laes++"i",laes++"e"]
(PretInd Sg P2 v) -> passivum v [las++"ts"]
(PretInd Sg _ v) -> passivum v [las]
(PretConjSg v) -> passivum v [las++"i", las++"e"]
where laes = tk 1 laesa
las = changeVowel "a" (tk 1 laesa)
-- Auxilary functions
-- Handles the umlaut phenomena.
isVowel :: Char -> Bool
isVowel c = elem c "aeiouyæø"
changeVowel :: String -> String -> String
changeVowel vowel s = case findStemVowel s of
(spr,i,ck) -> spr ++ vowel ++ ck
-- Assumes that the stem vowel is the last vowel or diphtong in
-- the input stem.
findStemVowel :: String -> (String, String, String)
findStemVowel sprick = (reverse rps, reverse i, reverse kc) where
(kc, irps) = break isVowel $ reverse sprick
(i, rps) = span isVowel $ irps
umlaut :: String -> String
umlaut man = m ++ mkUm a ++ n where
(m,a,n) = findStemVowel man
mkUm v = case v of
"a" -> "æ"
"o" -> "ø"
_ -> v