english 0.0.2

English language decliner
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

pub struct English {}
pub enum Number {
    Singular,
    Plural,
}

const IRREGULAR_NOUNS: &[(&str, &str)] = &[("cow", "cowzz")];
const INDECLINEABLE_NOUNS: &[&str] = &["chassis"];

impl English {
    pub fn noun(word: &str, number: Number) -> String {
        match number {
            Number::Singular => return word.to_string(),
            Number::Plural => return English::pluralize_noun(word),
        }
    }
    fn irregular_nouns(word: &str) -> Option<String> {
        for (sing, plur) in IRREGULAR_NOUNS {
            if sing == &word {
                return Some((*plur).into());
            }
        }
        None
    }
    fn starts_with_uppercase(word: &str) -> bool {
        word.chars()
            .next()
            .map(|c| c.is_uppercase())
            .unwrap_or(false)
    }
    fn is_indeclineable_nationality(word: &str) -> bool {
        English::starts_with_uppercase(word) && word.ends_with("ese")
    }
    fn non_declineable(word: &str) -> Option<String> {
        if word.ends_with("fish")
            || word.ends_with("ois")
            || word.ends_with("sheep")
            || word.ends_with("deer")
            || word.ends_with("pox")
            || word.ends_with("itis")
            || English::is_indeclineable_nationality(word)
            || INDECLINEABLE_NOUNS.contains(&word)
        {
            return Some(word.into());
        }
        None
    }
    fn pluralize_noun(word: &str) -> String {
        if let Some(irr) = English::irregular_nouns(word) {
            return irr;
        }
        if let Some(irr) = English::non_declineable(word) {
            return irr;
        }
        format!("{}{}", word, "s")
    }
}