english 0.0.8

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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use crate::*;

///The Verb struct is used for handling more complicated verb phrases
/// It is interchangeable with strings for all verb functions such as present_participle()
///
/// # Examples
/// ```
///  let pick_up = Verb::from("pick").with_particle("up");
///  assert_eq!(English::past_participle(pick_up), "picked up");
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Verb {
    pub head: String,             // "pick"
    pub particle: Option<String>, // "up"
}

impl Verb {
    /// Create a new verb with just the head.
    pub fn new(head: impl Into<String>) -> Self {
        Verb {
            head: head.into(),
            particle: None,
        }
    }

    /// Set the particle of a phrasal verb.
    pub fn with_particle(mut self, particle: impl Into<String>) -> Self {
        self.particle = Some(particle.into());
        self
    }
}

impl English {
    /// Returns the third-person singular present tense of the verb.
    ///
    /// # Examples
    /// ```
    /// assert_eq!(English::third_person("run"), "runs");
    /// ```
    pub fn third_person<T: Into<Verb>>(wordish: T) -> String {
        English::verb(
            wordish,
            &Person::Third,
            &Number::Singular,
            &Tense::Present,
            &Form::Finite,
        )
    }

    /// Returns the past tense of the verb.
    ///
    /// # Examples
    /// ```
    /// assert_eq!(English::past("walk"), "walked");
    /// ```
    pub fn past<T: Into<Verb>>(wordish: T) -> String {
        English::verb(
            wordish,
            &Person::Third,    // person doesn’t matter in past tense finite
            &Number::Singular, // irrelevant
            &Tense::Past,
            &Form::Finite,
        )
    }

    /// Returns the present participle ("-ing" form) of the verb.
    ///
    /// # Examples
    /// ```
    /// assert_eq!(English::present_participle("swim"), "swimming");
    /// ```
    pub fn present_participle<T: Into<Verb>>(wordish: T) -> String {
        English::verb(
            wordish,
            &Person::First,    // irrelevant for participles
            &Number::Singular, // irrelevant
            &Tense::Present,
            &Form::Participle,
        )
    }

    /// Returns the past participle of the verb.
    ///
    /// # Examples
    /// ```
    /// assert_eq!(English::past_participle("eat"), "eaten");
    /// ```
    pub fn past_participle<T: Into<Verb>>(wordish: T) -> String {
        English::verb(
            wordish,
            &Person::First,    // irrelevant
            &Number::Singular, // irrelevant
            &Tense::Past,
            &Form::Participle,
        )
    }

    /// Returns the infinitive (base) form of the verb.
    ///
    /// # Examples
    /// ```
    /// assert_eq!(English::infinitive("go"), "go");
    /// ```
    pub fn infinitive<T: Into<Verb>>(wordish: T) -> String {
        English::verb(
            wordish,
            &Person::First,    // irrelevant
            &Number::Singular, // irrelevant
            &Tense::Present,   // irrelevant
            &Form::Infinitive,
        )
    }
}

impl From<String> for Verb {
    fn from(s: String) -> Self {
        Verb {
            head: s,
            particle: None,
        }
    }
}

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

impl From<&str> for Verb {
    fn from(s: &str) -> Self {
        Verb {
            head: s.to_string(),
            particle: None,
        }
    }
}

/// Just clones it
impl From<&Verb> for Verb {
    fn from(s: &Verb) -> Self {
        s.clone()
    }
}