english 0.0.9

English inflector decliner conjugator from wiktionary data
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use crate::*;

///The Noun struct is used for handling more complicated noun phrases
/// It is interchangeable with strings for all noun functions such as count_with_number()
///
/// # Examples
/// ```
///  let jeans = Noun::from("pair").with_complement("of jeans");
///  assert_eq!(English::count_with_number(jeans, 3), "3 pairs of jeans");
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Noun {
    pub head: String,
    pub modifier: Option<String>,   // words before the head
    pub complement: Option<String>, // words after the head
}

impl Noun {
    pub fn new(head: impl Into<String>) -> Self {
        Noun {
            head: head.into(),
            modifier: None,
            complement: None,
        }
    }

    pub fn with_specifier(mut self, pre: impl Into<String>) -> Self {
        self.modifier = Some(pre.into());
        self
    }

    pub fn with_complement(mut self, post: impl Into<String>) -> Self {
        self.complement = Some(post.into());
        self
    }
}

impl Noun {
    /// Returns a noun inflected according to the count. Wrapper around English::noun()
    ///
    /// # Examples
    /// ```rust
    /// assert_eq!(English::count("cat", 1), "cat");
    /// assert_eq!(English::count("cat", 2), "cats");
    /// ```
    pub fn count<T: Into<Noun>>(word: T, count: u32) -> String {
        if count == 1 {
            English::noun(word, &Number::Singular)
        } else {
            English::noun(word, &Number::Plural)
        }
    }

    /// Returns a noun inflected according to the count, preserves the number in output
    ///
    /// # Examples
    /// ```rust
    /// assert_eq!(English::count("cat", 1), "1 cat");
    /// assert_eq!(English::count("cat", 2), "2 cats");
    /// ```
    pub fn count_with_number<T: Into<Noun>>(word: T, count: u32) -> String {
        format!("{} {}", count, Noun::count(word, count))
    }

    /// Returns the plural form of a noun.
    ///
    /// # Examples
    /// ```
    /// assert_eq!(English::plural("child"), "children");
    /// assert_eq!(English::plural("cat"), "cats");
    /// ```
    pub fn plural<T: Into<Noun>>(word: T) -> String {
        English::noun(word, &Number::Plural)
    }

    /// Returns the singular form of a noun.
    ///
    /// # Examples
    /// ```
    /// assert_eq!(English::singular("cat2"), "cat");
    /// ```
    pub fn singular<T: Into<Noun>>(word: T) -> String {
        English::noun(word, &Number::Singular)
    }
}

impl From<String> for Noun {
    fn from(s: String) -> Self {
        Noun {
            head: s,
            modifier: None,
            complement: None,
        }
    }
}
impl From<&String> for Noun {
    fn from(s: &String) -> Self {
        Noun {
            head: s.clone(),
            modifier: None,
            complement: None,
        }
    }
}

impl From<&str> for Noun {
    fn from(s: &str) -> Self {
        Noun {
            head: s.to_string(),
            modifier: None,
            complement: None,
        }
    }
}
impl From<&Noun> for Noun {
    fn from(s: &Noun) -> Self {
        s.clone()
    }
}