---------------------------------------------------------------------- -- | -- Module : NounRulesSw -- Maintainer : Markus Forsberg -- Stability : (stability) -- Portability : (portability) -- -- -- Swedish noun functions ------------------------------------------------------------------------- module NounRulesSw where import GenRulesSw import General import TypesSw import Char(isDigit) import List type NSg = String type NSgD = String type NPl = String type NPlD = String type NComp = String type NDeriv = String -- General Noun functions mk_substantive :: NSg -> NSgD -> NPl -> NPlD -> NComp -> NDeriv -> Substantive mk_substantive apa apan apor aporna ap_comp ap_deriv = variants (mk_substantive_v (lift apa) (lift apan) (lift apor) (lift aporna) (lift ap_comp) (lift ap_comp) (lift ap_deriv)) [(MedComposite,strings (compound_s ap_comp))] mk_substantive_comp :: NSg -> NSgD -> NPl -> NPlD -> NComp -> NComp -> NDeriv -> Substantive mk_substantive_comp apa apan apor aporna ap_comp ap_comp2 ap_deriv a = mk_substantive_v (lift apa) (lift apan) (lift apor) (lift aporna) (lift ap_comp) (lift ap_comp2) (lift ap_deriv) a mk_substantive_v :: [NSg] -> [NSgD] -> [NPl] -> [NPlD] -> [NComp] -> [NComp] -> [NDeriv]-> Substantive mk_substantive_v apa apan apor aporna ap_comp ap_comp2 ap_deriv a = case a of SF n s c -> strings $ mk_case_v c $ case (n,s) of (Sg,Indef) -> apa (Sg,Def) -> apan (Pl,Indef) -> apor (Pl,Def) -> aporna InitComposite -> strings ap_comp MedComposite -> strings ap_comp2 SMS -> nonExist Deriv -> strings ap_deriv mk_nna :: [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> Substantive mk_nna apa apas apan apans apor apors aporna apornas a = strings $ case a of SF n s c -> case (n,s,c) of (Sg,Indef,Nom) -> apa (Sg,Indef,Gen) -> apas (Sg,Def,Nom) -> apan (Sg,Def,Gen) -> apans (Pl,Indef,Nom) -> apor (Pl,Indef,Gen) -> apors (Pl,Def,Nom) -> aporna (Pl,Def,Gen) -> apornas InitComposite -> map (++ "-") apa MedComposite -> map (++ "-") apa SMS -> map (++ "-") apa Deriv -> map (++ "-") apa mk_subst :: NSg -> NSgD -> NPl -> NPlD -> Substantive mk_subst bil bilen bilar bilarna = mk_substantive bil bilen bilar bilarna bil bil mk_subst_v :: [NSg] -> [NSgD] -> [NPl] -> [NPlD] -> [NComp] -> Substantive mk_subst_v bil bilen bilar bilarna bilc = variants (mk_substantive_v bil bilen bilar bilarna bilc bilc bilc) [(MedComposite,strings (concat (map compound_s bilc)))] mk_case :: Casus -> String -> String mk_case c [] = [] mk_case c s = case c of Nom -> s Gen | elem (last s) "sxzSXZ" -> s Gen | elem (last s) "?!" || isDigit (last s) -> s ++ ":s" Gen -> s ++ "s" mk_case_v :: Casus -> [String] -> [String] mk_case_v c xs = concat $ map f (filter (not.null) xs) where f s = case c of Nom -> [s] Gen | not (null s) && elem (last s) "sxzSXZ" -> [s] Gen | not (null s) && (elem (last s) "!?" || isDigit (last s)) -> [s ++ ":s",s++"-s"] Gen -> [s ++ "s"] hyphenate_compounds :: Substantive -> Substantive hyphenate_compounds f = compvariants [w +? "-" | w <- unStr (f InitComposite)] [w +? "-" | w <- unStr (f MedComposite)] f geminator :: Substantive -> Substantive geminator f | and [isSuffixOf "mm" w | w <- unStr (f (SF Sg Indef Nom))] = f | otherwise = compexcept' [ungeminate w | w <- unStr (f InitComposite)] [ungeminate w | w <- unStr (f MedComposite)] f -- additional compound form compvariants :: [NComp] -> [NComp] -> Substantive -> Substantive compvariants compi compm f = variants f [ (InitComposite,strings compi), (MedComposite,strings compm), (SMS,strings [ x | x@(_:_) <- compi,last x=='-']) ] compvariant :: [NComp] -> Substantive -> Substantive compvariant compi f = variants f [(InitComposite,strings compi), (MedComposite,strings (concat [compound_s w | w <- compi]))] -- replace compound form compexcept :: [NComp] -> Substantive -> Substantive compexcept compi f = excepts f [(InitComposite,strings compi), (MedComposite,strings (concat [compound_s w | w <- compi]))] compexcept' :: [NComp] -> [NComp] -> Substantive -> Substantive compexcept' compi compm f = excepts f [(InitComposite,strings compi), (MedComposite,strings compm)] compderivexcept :: [NComp] -> [NDeriv] -> Substantive -> Substantive compderivexcept comp deriv f = excepts (compexcept comp f) [(Deriv,strings deriv)] --- variants sgdefvariants :: [NSgD] -> Substantive -> Substantive sgdefvariants nom_s finite_f = variants finite_f [(SF Sg Def Nom, strings nom_s), (SF Sg Def Gen, strings (map (mk_case Gen) nom_s))] sgindefvariants :: [NSg] -> Substantive -> Substantive sgindefvariants nom_s finite_f = variants finite_f [(SF Sg Indef Nom, strings nom_s), (SF Sg Indef Gen, strings (map (mk_case Gen) nom_s))] pldefvariants :: [NPlD] -> Substantive -> Substantive pldefvariants nom_s finite_f = variants finite_f [(SF Pl Def Nom, strings nom_s), (SF Pl Def Gen, strings (map (mk_case Gen) nom_s))] plindefvariants :: [NPl] -> Substantive -> Substantive plindefvariants nom_s finite_f = variants finite_f [(SF Pl Indef Nom, strings nom_s), (SF Pl Indef Gen, strings (map (mk_case Gen) nom_s))] -- excepts sgdefexcepts :: [NSgD] -> Substantive -> Substantive sgdefexcepts nom_s finite_f = excepts finite_f [(SF Sg Def Nom, strings nom_s), (SF Sg Def Gen, strings (map (mk_case Gen) nom_s))] sgindefexcepts :: [NSg] -> Substantive -> Substantive sgindefexcepts nom_s finite_f = excepts finite_f [(SF Sg Indef Nom, strings nom_s), (SF Sg Indef Gen, strings (map (mk_case Gen) nom_s))] pldefexcepts :: [NPlD] -> Substantive -> Substantive pldefexcepts nom_s finite_f = excepts finite_f [(SF Pl Def Nom, strings nom_s), (SF Pl Def Gen, strings (map (mk_case Gen) nom_s))] plindefexcepts :: [NPl] -> Substantive -> Substantive plindefexcepts nom_s finite_f = excepts finite_f [(SF Pl Indef Nom, strings nom_s), (SF Pl Indef Gen, strings (map (mk_case Gen) nom_s))] sgvariants :: [NSg] -> [NSgD] -> Substantive -> Substantive sgvariants sg sget f = sgdefvariants sget (sgindefvariants sg f) plvariants :: [NPl] -> [NPlD] -> Substantive -> Substantive plvariants pl plet f = pldefvariants plet (plindefvariants pl f) plexcepts :: [NPl] -> [NPlD] -> Substantive -> Substantive plexcepts pl plet f = pldefexcepts plet (plindefexcepts pl f) no_plural :: Substantive -> Substantive no_plural v = v `only` [SF Sg s c | s <- values, c <- values] no_singular :: Substantive -> Substantive no_singular v = v `only` [SF Pl s c | s <- values, c <- values] onlyPlD :: Substantive -> Substantive onlyPlD v = v `only` [SF Pl Def c | c <- values] -- Declension 1 nn1 :: String -> Substantive nn1 apa = mk_substantive apa (ifEndThen (=='a') apa (apa ++ "n") (apa ++ "en")) apor (apor ++ "na") [] [] where ap = dropEndIf (=='a') apa apor = ap ++ "or" nn1flicka :: String -> Substantive nn1flicka flicka = -- compvariants [tk 1 flicka ++ "e"] $ nn1 flicka nn1kyrka :: String -> Substantive nn1kyrka kyrka = compvariant [tk 1 kyrka ++ "o"] (nn1 kyrka) nn1gata :: String -> Substantive nn1gata gata = compvariant [tk 1 gata ++ "u"] (nn1 gata) nn1olja :: String -> Substantive nn1olja olja = compexcept [tk 1 olja ++ "e"] (nn1 olja) nn1mamma :: String -> Substantive nn1mamma mamma = compexcept [mamma] (nn1 mamma) nn1siffra :: String -> Substantive nn1siffra siffra = compexcept [insert_second_last (tk 1 siffra) 'e'] (nn1 siffra) nn1dimma :: String -> Substantive nn1dimma dimma = compexcept [tk 2 dimma] (nn1 dimma) nn1sopor :: String -> Substantive nn1sopor sopor = no_singular $ nn1 $ tk 2 sopor nn1faggorna :: String -> Substantive nn1faggorna faggorna = onlyPlD $ nn1 $ tk 4 faggorna -- Declension 2 nn2 :: String -> Substantive nn2 pojke = mk_substantive pojke pojken (pojk ++ "ar") (pojk ++ "arna") pojk pojk where pojk = drop_final_e pojke pojken = pojke ++ if_vowel (last pojke) "n" "en" -- ungeminate nn2nyckel :: String -> Substantive nn2nyckel nyckel = mk_substantive nyckel (nyckel ++"n") (nyckl ++"ar") (nyckl ++"arna") nyckel nyckl where nyckl = drop_last_vowel nyckel nn2öken :: String -> Substantive nn2öken öken = mk_subst öken (ökn ++"en") (ökn ++"ar") (ökn ++"arna") where ökn = drop_last_vowel öken nn2hummer :: String -> Substantive nn2hummer hummer = mk_subst hummer (hummer ++"n") (humr ++"ar") (humr ++"arna") where humr = drop_second_last $ drop_last_vowel $ hummer nn2kam :: String -> Substantive nn2kam kam = mk_subst kam (kamm ++"en") (kamm ++"ar") (kamm ++"arna") where kamm = geminate kam nn2pengar :: String -> Substantive nn2pengar pengar = mk_subst [] [] (pengar) (pengar ++"na") nn2mor :: String -> Substantive nn2mor mor_or_moder = compvariants [moder++"s",mor,mor++"s"] [mor,mor++"s"] $ sgindefvariants [moder] $ mk_substantive mor (moder ++"n") (moedr ++"ar") (moedr ++"arna") moder moder where (mor,moder) = if (dp 3 mor_or_moder) == "der" then (tk 3 mor_or_moder ++ "r", mor_or_moder) else (mor_or_moder, tk 1 mor_or_moder ++ "der") moedr = umlaut $ drop_last_vowel moder nn2dotter :: String -> Substantive nn2dotter dotter = mk_substantive dotter (dotter ++"n") (döttr ++"ar") (döttr ++"arna") dotter [] where döttr = umlaut $ drop_last_vowel dotter nn2fordran :: String -> Substantive nn2fordran fordran = mk_substantive fordran fordran fordringar (fordringar ++"na") fordran [] where fordringar = tk 2 fordran ++ "ingar" nn2verkan :: String -> Substantive nn2verkan verkan = mk_substantive verkan verkan verkningar (verkningar ++"na") verkan [] where verkningar = tk 2 verkan ++ "ningar" nn2toker :: String -> Substantive nn2toker tok = sgindefvariants [tok++"er"] (nn2 tok) nn2herre :: String -> Substantive nn2herre herre = sgdefvariants [herre++"n"] (nn2 herre) nn2vers :: String -> Substantive nn2vers vers = combine (NounRulesSw.nn2 vers) (NounRulesSw.nn3 vers) nn2manöver :: String -> Substantive nn2manöver manöver = combine (nn2nyckel manöver) (no_singular (nn3 (drop_last_vowel manöver))) nn2själ :: String -> Substantive nn2själ själ = compvariant [själ++"a"] (nn2 själ) nn2brud :: String -> Substantive nn2brud brud = compvariant [brud++"e"] (nn2 brud) nn2jord :: String -> Substantive nn2jord jord = compvariant [jord++"e",jord++"a"] (nn2 jord) nn2hjälte :: String -> Substantive nn2hjälte hjälte = compexcept [hjälte] (nn2 hjälte) nn2herde :: String -> Substantive nn2herde herde = compexcept [herd++"e", herd++"a"] (nn2 herde) where herd = tk 1 herde nn2by :: String -> Substantive nn2by by = compvariant [by++"a"] (nn2 by) nn2fågel :: String -> Substantive nn2fågel fågel = compvariant [(drop_last_vowel fågel)++"a"] (nn2nyckel fågel) nn2lem :: String -> Substantive nn2lem lem = compvariant [(geminate lem)++"a"] (nn2kam lem) nn2vägnar :: String -> Substantive nn2vägnar vägnar = no_singular $ nn2 (tk 2 vägnar) nn2stadgar :: String -> Substantive nn2stadgar stadgar = compvariant [(tk 2 stadgar)++"e"] (nn2vägnar stadgar) -- Declension 3 nn3 :: String -> Substantive nn3 sak = mk_subst sak (sak ++ "en") (sak ++ "er") (sak++"erna") nn3vin :: String -> Substantive nn3vin vin = mk_subst vin (vin ++ "et") (vin ++ "er") (vin ++ "erna") nn3gäst :: String -> Substantive nn3gäst gäst = compvariant [gäst++"a"] (nn3 gäst) nn3bygd :: String -> Substantive nn3bygd bygd = compvariant [bygd++"e"] (nn3 bygd) nn3hävd :: String -> Substantive nn3hävd hävd = compvariant [hävd++"e",hävd++"a"] (nn3 hävd) nn3motor :: String -> Substantive nn3motor motor = mk_subst motor (motor ++ "n") (motor ++ "er") (motor ++ "erna") nn3parti :: String -> Substantive nn3parti parti = sgdefvariants [parti++"t"] (nn3vin parti) nn3poesi :: String -> Substantive nn3poesi poesi = sgdefvariants [poesi++"en"] (nn3motor poesi) nn3musa :: String -> Substantive nn3musa musa = mk_subst musa (musa ++ "n") (mus ++ "er") (mus ++ "erna") where mus = tk 1 musa nn3museum :: String -> Substantive nn3museum museum = mk_subst museum (muse ++ "et") (muse ++ "er") (muse ++ "erna") where muse = tk 2 museum nn3gladiolus :: String -> Substantive nn3gladiolus gladiolus = mk_subst gladiolus (gladiolus ++ "en") (gladiol ++ "er") (gladiol ++ "erna") where gladiol = tk 2 gladiolus nn3fiber :: String -> Substantive nn3fiber fiber = mk_substantive fiber (fiber++"n") (fibr ++ "er") (fibr ++ "erna") fiber fibr where fibr = drop_last_vowel fiber nn3tand :: String -> Substantive nn3tand tand = mk_subst tand (tand++"en") (tänd ++ "er") (tänd ++ "erna") where tänd = umlaut tand nn3land :: String -> Substantive nn3land land = mk_subst land (land++"et") (länd ++ "er") (länd ++ "erna") where länd = umlaut land nn3paraply :: String -> Substantive nn3paraply paraply = sgdefvariants [paraply++"t",paraply++"n"] (nn3vin paraply) nn3hobby :: String -> Substantive nn3hobby hobby = plindefvariants [(tk 1 hobby)++"ies"] (nn3 hobby ) nn3kastanj :: String -> Substantive nn3kastanj kastanj = sgindefvariants [kastanj++"e"] (nn3 kastanj) nn3akademi :: String -> Substantive nn3akademi akademi = sgdefvariants [akademi] (nn3 akademi) nn3paket :: String -> Substantive nn3paket paket = combine (nn3 paket) (nn5 paket) nn3element :: String -> Substantive nn3element element = combine (nn3vin element) (nn5 element) nn3kläder :: String -> Substantive nn3kläder = no_singular . nn3 . tk 2 nn3kliche :: String -> Substantive nn3kliche kliche = combine (nn3motor kliche) (no_singular (nn3 (tk 1 kliche ++ "e"))) nn3bok :: String -> Substantive nn3bok bok = mk_subst bok (bok ++"en") (böcker) (böcker++"na") where böcker = umlaut (tk 1 bok) ++ "cker" nn3fot :: String -> Substantive nn3fot fot = mk_subst fot (fot ++"en") (fötter) (fötter++"na") where fötter = umlaut (geminate fot) ++ "er" nn3bockfot :: String -> Substantive nn3bockfot fot = compexcept' [fot,fot+?"s"] [fot,fot+?"s"] (mk_subst fot (fot ++"en") (fötter) (fötter++"na")) where fötter = umlaut (geminate fot) ++ "er" nn3vän :: String -> Substantive nn3vän vän = mk_subst vän (vänn ++"en") (vänn ++"er") (vänn ++"erna") where vänn = vän ++ [last vän] nn3flanell :: String -> Substantive nn3flanell flanell = sgdefvariants [flanell++"et"] (nn3 flanell) -- Declension 4 nn4 :: String -> Substantive nn4 linje = mk_subst linje (linje ++ "n") (linje ++ "r") (linje++"rna") nn4studio :: String -> Substantive nn4studio studio = plindefvariants [studio++"s"] (nn4 studio) nn4ampere :: String -> Substantive nn4ampere ampere = plvariants [ampere] [ampere++"n"] (nn4 ampere) nn4bonde :: String -> Substantive nn4bonde bonde = compvariant [bond] $ mk_substantive bonde (bonde ++ "n") (bönd ++ "er") (bönd++"erna") bonde bond where bond = tk 1 bonde bönd = umlaut bond -- Declension 5 nn5 :: String -> Substantive nn5 rike = mk_subst rike (rike++et) (rike++en) (rike++ena) where et = if_vowel (last rike) "t" "et" en = if_vowel (last rike) "n" "en" ena = if_vowel (last rike) "na" "ena" nn5knä :: String -> Substantive nn5knä knä = sgdefvariants [knä++"et"] (nn5 knä) nn5äpple :: String -> Substantive nn5äpple äpple = compexcept [insert_second_last (tk 1 äpple) 'e'] (nn5 äpple) nn5samhälle :: String -> Substantive nn5samhälle samhälle = compvariant [tk 1 samhälle] (nn5 samhälle) nn5arbete :: String -> Substantive nn5arbete arbete = compderivexcept [arbet] [] (nn5 arbete) where arbet = tk 1 arbete nn5bi :: String -> Substantive nn5bi bi = pldefvariants [bi++"en"] (except (nn5 bi) [(SF Sg Def c, mk_case c (bi++"et")) | c <- values]) nn5frö :: String -> Substantive nn5frö frö = pldefvariants [frö++"en"] $ sgdefvariants [frö++"et"] (nn5 frö) nn5party :: String -> Substantive nn5party party = plindefvariants [tk 1 party ++ "ies"] (nn5 party) nn5abc :: String -> Substantive nn5abc abc nf = strings $ case nf of (SF Sg Indef Nom) -> [abc] (SF Sg Indef Gen) -> [abc ++ ":s",abc++"-s"] (SF Sg Def Nom) -> [abc ++ "-et", abc++"-t",abc ++ ":et", abc++":t"] (SF Sg Def Gen) -> [abc ++ "-ets", abc++"-ts",abc ++ ":ets", abc++":ts"] (SF Pl Indef Nom) -> [abc ++ ":n",abc++"-n"] (SF Pl Indef Gen) -> [abc ++ ":ns",abc++"-ns"] (SF Pl Def Nom) -> [abc++"-na",abc++":na"] (SF Pl Def Gen) -> [abc++"-nas",abc++":nas"] InitComposite -> [abc++"-"] MedComposite -> [abc++"-"] SMS -> [abc++"-"] Deriv -> [abc] nnkol14 :: String -> Substantive nnkol14 kol14 n = strings $ case n of (SF Sg Indef Nom) -> [kol14] (SF Sg Indef Gen) -> [kol14++"-s",kol14++":s"] InitComposite -> [kol14++"-"] MedComposite -> [kol14++"-"] _ -> [] nn5anmodan :: String -> Substantive nn5anmodan anmodan = mk_subst anmodan anmodan anmodanden (anmodanden++"a") where anmodanden = anmodan++"den" -- Declension 6 nn6 :: String -> Substantive nn6 lik = mk_subst lik (lik ++ "et") lik (lik ++ "en") nn6barn :: String -> Substantive nn6barn barn = compvariant [barn++"a"] (nn6 barn) nn6arv :: String -> Substantive nn6arv arv = compvariant [arv++"e"] (nn6 arv) nn6mil :: String -> Substantive nn6mil mil = mk_subst mil (mil ++ "en") mil (mil ++ "en") nn6broder :: String -> Substantive nn6broder broder = compvariants [broder++"s"] [] $ mk_subst broder (broder ++ "n") (bröd++"er") (bröd ++ "erna") where bröd = umlaut brod brod = tk 2 broder nn6akademiker :: String -> Substantive nn6akademiker akademiker = mk_subst akademiker (akademiker ++ "n") akademiker (akademiker ++ "na") nn6lager :: String -> Substantive nn6lager lager = pldefvariants [lager++"na"] (mk_substantive lager (lagr ++"et") (lager) (lagr ++"en") lager lagr) where lagr = ungeminate (tk 2 lager) ++ [last lager] nn6nummer :: String -> Substantive nn6nummer nummer = pldefvariants [nummer++"na"] (mk_substantive nummer (numr ++"et") (nummer) (numr ++"en") nummer numr) where numr = drop_second_last $ drop_last_vowel $ nummer nn6garage :: String -> Substantive nn6garage garage = mk_subst garage (garage ++ "t") garage (garage ++ "n") nn6manus :: String -> Substantive nn6manus manus = sgdefvariants [manus] (nn6 manus) nn6gås :: String -> Substantive nn6gås gås = mk_subst gås (gås++"en") gäss (gäss++"en") where gäss = (vc "ä" gås) ++"s" nn6ordförande :: String -> Substantive nn6ordförande ordförande = plindefvariants [ordförande++"n"] (nn6akademiker ordförande) nn6far :: String -> Substantive nn6far far_or_fader = nn2mor far `except` [(SF Pl d c, mkPl d c) | d <- values, c <- values] where far = if (dp 3 far_or_fader == "der") then tk 3 far_or_fader ++"r" else far_or_fader mkPl d c = mk_case c $ case d of Indef -> (umlaut (tk 1 far)) ++ "der" _ -> (umlaut (tk 1 far)) ++ "derna" nn6papper :: String -> Substantive nn6papper papper = mk_substantive papper (pappr ++ "et") papper (pappr ++ "en") papper pappr where pappr = drop_last_vowel papper nn6kikare :: String -> Substantive nn6kikare kikare = mk_substantive kikare (kikare ++ "n") kikare (kikar ++ "na") kikar kikar where kikar = tk 1 kikare nn6program :: String -> Substantive nn6program program = mk_subst program (programm ++"et") program (programm ++"en") where programm = program ++ [last program] nn6mus :: String -> Substantive nn6mus mus = mk_subst mus (mus ++"en") möss (möss ++"en") where möss = vc "ö" $ geminate mus nn6vaktman :: String -> Substantive nn6vaktman man = mk_subst man (mann ++"en") män (männ ++"en") where män = umlaut man männ = geminate män mann = geminate man nn6borst :: String -> Substantive nn6borst borst = sgdefvariants [borst++"en"] (nn6 borst) nn6klientel :: String -> Substantive nn6klientel klientel = combine (nn6 klientel) (nn6mil klientel) --nn6frx :: String -> Substantive --nn6frx f = mk_substantive_v [f] [f ++"-et",f ++":et",f++"-t",f++":t"] [f++"-en",f++":en",f++"-n",f++":n"] -- [f++"-ena",f++":ena",f++"-na",f++":na"] [f++"-"] [f++"-"] [] nn6ordalag :: String -> Substantive nn6ordalag ordalag = no_singular (nn6 ordalag) -- Declension 7 nn7musical :: String -> Substantive nn7musical musical = pldefvariants [musical +? "sarna"] (mk_subst musical (musical+?"en") (musical +? "s") (musical +? "sen")) -- nn7jeans :: String -> Substantive -- nn7jeans jeans = nn7musical -- no plural nn0 :: String -> Substantive nn0 mjölk = mk_subst mjölk (mjölk++"en") [] [] nn0oväsen :: String -> Substantive nn0oväsen oväsen = sgdefexcepts [oväsen++"det",oväsen++"et"] (nn0 oväsen) nn0tröst :: String -> Substantive nn0tröst tröst = compvariant [tröst++"e"] (nn0 tröst) nn0adel :: String -> Substantive nn0adel adel = sgdefexcepts [adel++"n"] (nn0 adel) nn0skum :: String -> Substantive nn0skum skum = sgdefexcepts [skumm++"et"] (nn0 skum) where skumm = geminate skum nn0skam :: String -> Substantive nn0skam skam = sgdefexcepts [skamm++"en"] (nn0 skam) where skamm = geminate skam nn0manna :: String -> Substantive nn0manna manna = sgdefexcepts [manna++"n", manna++"t"] (nn0 manna) nn0början :: String -> Substantive nn0början början = mk_substantive början början [] [] [] [] nn0uran :: String -> Substantive nn0uran uran = sgdefvariants [uran++"et"] (nn0 uran) -- nn0fåfänga :: String -> Substantive -- nn0fåfänga = nn0adel nn0biologi :: String -> Substantive nn0biologi biologi = sgdefvariants [biologi++"en"] (nn0adel biologi) nn0brådska :: String -> Substantive nn0brådska brådska = compexcept [brådske] (nn0adel brådska) where brådske = (tk 1 brådska) ++ "e" nn0smör :: String -> Substantive nn0smör smör = sgdefexcepts [smör++"et"] (nn0 smör) nn0kaffe :: String -> Substantive nn0kaffe kaffe = sgdefexcepts [kaffe++"t"] (nn0 kaffe) nn0socker :: String -> Substantive nn0socker socker = sgdefexcepts [drop_last_vowel socker ++ "et"] (nn0 socker) nn0januari :: String -> Substantive nn0januari januari = mk_substantive januari januari [] [] januari [] nn0aktinium :: String -> Substantive nn0aktinium aktinium = sgdefexcepts [aktinium, aktinium++"et"] (nn0 aktinium) -- pending declension nnvkansli :: String -> Substantive nnvkansli kansli = pldefvariants [kansli++"en"] (combine (nn3parti kansli) (nn6akademiker kansli)) nnvfaktum :: String -> Substantive nnvfaktum faktum = plvariants [fakt++"a"] [fakt++"a"] $ sgdefvariants [faktum] (nn6mil faktum) where fakt = tk 2 faktum nnvdistikon :: String -> Substantive nnvdistikon distikon = plvariants [distik++"a"] [distik++"a"] (nn6 distikon) where distik = tk 2 distikon nnvabdomen :: String -> Substantive nnvabdomen abdomen = plvariants [abdom++"ina"] [abdom++"ina"] (mk_substantive abdomen abdomen abdomen abdomen abdomen abdomen) where abdom = tk 2 abdomen nnvnomen :: String -> Substantive nnvnomen nomen = plvariants [nom++"ina"] [nom++"ina"] (mk_substantive nomen (nomen++"et") nomen (nomen++"en") nomen nomen) where nom = tk 2 nomen nnvunderstatement :: String -> Substantive nnvunderstatement understatement = plvariants [understatement++"s"] [understatement++"sen"] (nn6 understatement) nnvfranc :: String -> Substantive nnvfranc franc = pldefvariants [franc++"en"] (nnvunderstatement franc) nnvcocktail :: String -> Substantive nnvcocktail cocktail = plvariants [cocktail++"ar"] [cocktail++"arna"] (nn7musical cocktail) nnvgangster :: String -> Substantive nnvgangster gangster = combine s_f ar_f where s_f = mk_subst gangster (gangster++"n") (gangster++"s") (gangster++"sen") ar_f = mk_subst gangster (gangster++"n") (gangstr++"ar") (gangstr++"arna") gangstr = drop_last_vowel gangster nnvpartner :: String -> Substantive nnvpartner partner = plvariants [partner] [partner ++"na",partner ++"sarna"] $ mk_subst partner (partner++"n") (partner++"s") (partner++"sen") -- $ (nn7musical partner) nnvcentrum :: String -> Substantive nnvcentrum centrum = plvariants [centr++"a", centr++"er"] [centr++"ana", centr++"erna"] $ sgdefvariants [centr++"et",centrum] um_f where um_f = mk_subst centrum (centrum++"et") centrum (centrum++"en") centr = tk 2 centrum nnvtempo :: String -> Substantive nnvtempo tempo = mk_subst tempo tempo tempo (tempo++"na") nnvantecedentia :: String -> Substantive nnvantecedentia antecedentia = plvariants [antecedenti++"er"] [antecedenti++"erna"] (mk_subst [] [] antecedentia antecedentia) where antecedenti = tk 1 antecedentia nnvtrall :: String -> Substantive nnvtrall trall = combine (nn2 trall) (nn5 trall) nnvbehå :: String -> Substantive nnvbehå behå = combine (nn2 behå) (nn6akademiker behå) nnvjojo :: String -> Substantive nnvjojo jojo = combine (nn2 jojo) (nn4 jojo) nnvsandwich :: String -> Substantive nnvsandwich sandwich = plvariants [sandwich++"es"] [sandwich++"esen"] (nn3 sandwich) nnvabc :: String -> Substantive nnvabc = nn5abc nnvgarn :: String -> Substantive nnvgarn garn = combine (nn3vin garn) (nn6 garn) nnvhuvud :: String -> Substantive nnvhuvud huvud = plindefvariants [huvud++"en"] (mk_subst huvud (huvud++"et") huvud (huvud++"ena")) nnvkvantum :: String -> Substantive nnvkvantum = nnvcentrum nnvspektrum :: String -> Substantive nnvspektrum spektrum = plvariants [spektrum,spektr++"a"] [spektrum++"en", spektr++"ana"] $ sgdefvariants [spektr++"et", spektrum++"et"] $ mk_subst spektrum spektrum (spektr++"er") (spektr++"ena") where spektr = tk 2 spektrum nnvblinker :: String -> Substantive nnvblinker blinker = plvariants [blinker++"s"] [blinker++"sen",blinker++"sarna"] $ mk_subst blinker (blinker++"n") (blinkr++"ar") (blinkr++"arna") where blinkr = mmr (drop_last_vowel blinker) nnvdress :: String -> Substantive nnvdress dress = plvariants [dress++"er"] [dress++"erna"] $ mk_subst dress (dress++"en") (dress++"ar") (dress++"arna") nnvhambo :: String -> Substantive nnvhambo hambo = plvariants [hambo++"r"] [hambo++"rna"] $ mk_subst hambo (hambo++"n") (hambo++"er") (hambo++"erna") nnvkaliber :: String -> Substantive nnvkaliber kaliber = plvariants [kalibr++"er"] [kalibr++"erna"] $ mk_subst kaliber (kaliber++"n") (kalibr++"ar") (kalibr++"arna") where kalibr = drop_last_vowel kaliber nnvklammer :: String -> Substantive nnvklammer klammer = plvariants [klamr ++ "ar"] [klamr++"arna"] $ mk_subst klammer (klammer++"n") klammer (klammer++"na") where klamr = ungeminate (tk 2 klammer) ++ dp 1 klammer nnvplayboy :: String -> Substantive nnvplayboy playboy = plvariants [playboy++"s"] [playboy++"sen",playboy++"sarna"] $ mk_subst playboy (playboy++"en") (playboy++"ar") (playboy++"arna") nnvroller :: String -> Substantive nnvroller roller = plvariants [rollr++"ar"] [rollr++"arna"] $ mk_subst roller (roller++"n") (roller) (roller++"na") where rollr = drop_last_vowel roller nnvtrio :: String -> Substantive nnvtrio trio = plvariants [trio++"s"] [trio++"sen"] $ mk_subst trio (trio++"n") (trio++"r") (trio++"rna") nnvborr :: String -> Substantive nnvborr borr = combine (nn2 borr) (nn6 borr) nnvtest :: String -> Substantive nnvtest test = combine (nn3 test) (nn6 test) -- irregular nouns nnonarkotikum :: String -> Substantive nnonarkotikum narkotikum = sgvariants [narkotik++"a"] [narkotik++"an"] $ (mk_subst narkotikum (narkotikum++"et") (narkotik++"a") (narkotik++"a")) where narkotik = tk 2 narkotikum nnoexamen :: String -> Substantive nnoexamen examen = mk_subst examen examen (exam++"ina") (exam++"ina") where exam = tk 2 examen nnoemeritus :: String -> Substantive nnoemeritus emeritus = mk_subst emeritus emeritus emeriti (emeriti++"na") where emeriti = tk 2 emeritus ++ "i" nnofullmäktig :: String -> Substantive nnofullmäktig fullmäktig = mk_subst fullmäktig (fullmäktig++"en") (fullmäktig++"e") (fullmäktig++"e") -- nnoprestanda :: String -> Substantive -- nnoprestanda prestanda = mk_substantive prestanda prestanda [] [] prestanda prestanda nnoöga :: String -> Substantive nnoöga öga = mk_subst öga (öga++"t") ögon (ögon++"en") where ögon = tk 1 öga ++ "on" nnodata :: String -> Substantive nnodata data_ = mk_subst [] [] (data_) (data_++"n") nnoofficer :: String -> Substantive nnoofficer officer = sgdefvariants [officer++"n"] (mk_subst officer (officer++"en") (officer++"are") (officer++"arna")) -- definite noun nndkneken :: String -> Substantive nndkneken kneken = mk_subst [] kneken [] [] nndbrådrasket :: String -> Substantive nndbrådrasket brådrasket = mk_subst [] brådrasket [] [] -- no inflection nni :: String -> Substantive nni w = missing (nngfebruari w) [SF Sg Indef Gen] nni_ns :: String -> Substantive nni_ns w = compexcept' [w] [w] (missing (nngfebruari w) [SF Sg Indef Gen]) -- genitive inflection nngfebruari :: String -> Substantive nngfebruari februari = mk_subst februari [] [] [] -- multi-words nnm0 f xs (SFM t) = mapStr (rs++) (f lw t) where lw = last xs rs = unwords (init xs) ++ " " -- definite nnmdu ::[String] -> (SubstM -> Str) nnmdu = nnm0 (\w -> missing (nndkneken w) [InitComposite,MedComposite]) nnmdn ::[String] -> (SubstM -> Str) nnmdn = nnm0 (\w -> missing (nndbrådrasket w) [InitComposite, MedComposite]) nnmg :: [String] -> (SubstM -> Str) nnmg = nnm0 (\w -> missing (nngfebruari w) [InitComposite, MedComposite]) nnmi :: [String] -> (SubstM -> Str) nnmi = nnm0 (\w -> missing (nni w) [InitComposite, MedComposite])