Struct jp_inflections::Verb

pub struct Verb {
    pub word: Word,
    pub verb_type: VerbType,
}

Represents a Japanese verb

Fields

word: Word

verb_type: VerbType

Implementations

impl Verb

pub fn new(word: Word, verb_type: VerbType) -> Self

Returns a new verb

pub fn get_reading(&self) -> String

Same as Word::get_reading(&self)

pub fn is_dict_form(&self) -> bool

Returns true if self is in dictionary form

Example

use jp_inflections::{Word, VerbType};

let verb = Word::new("ならう", Some("習う")).into_verb(VerbType::Godan).unwrap();
assert!(verb.is_dict_form());

pub fn get_stem(&self, form: WordForm) -> Result<Word, Error>

Returns the stem of a word

Example

use jp_inflections::{Word, VerbType, WordForm};

let verb = Word::new("ならう", Some("習う")).into_verb(VerbType::Godan).unwrap();
assert_eq!(verb.get_stem(WordForm::Long).unwrap().kana, String::from("ならい"));
assert_eq!(verb.get_stem(WordForm::Long).unwrap().kanji.unwrap(), String::from("習い"));

assert_eq!(verb.get_stem(WordForm::Short).unwrap().kana, String::from("ならわ"));
assert_eq!(verb.get_stem(WordForm::Short).unwrap().kanji.unwrap(), String::from("習わ"));

pub fn dictionary(&self, form: WordForm) -> Result<Word, Error>

Returns the dictionary form of a word

Example

use jp_inflections::{Word, VerbType, WordForm};

let verb = Word::new("ならう", Some("習う")).into_verb(VerbType::Godan).unwrap();
assert_eq!(verb.dictionary(WordForm::Long).unwrap().kana, String::from("ならいます"));
assert_eq!(verb.dictionary(WordForm::Long).unwrap().kanji.unwrap(), String::from("習います"));

assert_eq!(verb.dictionary(WordForm::Short).unwrap().kana, String::from("ならう"));
assert_eq!(verb.dictionary(WordForm::Short).unwrap().kanji.unwrap(), String::from("習う"));

pub fn negative(&self, form: WordForm) -> Result<Word, Error>

Returns the negative form of a verb

Example

use jp_inflections::{Word, VerbType, WordForm};

let verb = Word::new("ならう", Some("習う")).into_verb(VerbType::Godan).unwrap();
assert_eq!(verb.negative(WordForm::Short).unwrap().kana, String::from("ならわない"));
assert_eq!(verb.negative(WordForm::Short).unwrap().kanji.unwrap(), String::from("習わない"));

assert_eq!(verb.negative(WordForm::Long).unwrap().kana, String::from("ならいません"));
assert_eq!(verb.negative(WordForm::Long).unwrap().kanji.unwrap(), String::from("習いません"));

pub fn te_form(&self) -> Result<Word, Error>

Returns the verb in its て form.

Example

use jp_inflections::{Word, VerbType, WordForm};

let verb = Word::new("ならう", Some("習う")).into_verb(VerbType::Godan).unwrap();
assert_eq!(verb.te_form().unwrap().kana, String::from("ならって"));
assert_eq!(verb.te_form().unwrap().kanji.unwrap(), String::from("習って"));

pub fn negative_te_form(&self) -> Result<Word, Error>

Returns the verb in its negative て form.

Example

use jp_inflections::{Word, VerbType, WordForm};

let verb = Word::new("ならう", Some("習う")).into_verb(VerbType::Godan).unwrap();
assert_eq!(verb.negative_te_form().unwrap().kana, String::from("ならわなくて"));
assert_eq!(verb.negative_te_form().unwrap().kanji.unwrap(), String::from("習わなくて"));

pub fn past(&self, form: WordForm) -> Result<Word, Error>

Returns the verb in the past form

Example

use jp_inflections::{Word, VerbType, WordForm};

let verb = Word::new("ならう", Some("習う")).into_verb(VerbType::Godan).unwrap();
assert_eq!(verb.past(WordForm::Short).unwrap().kana, String::from("ならった"));
assert_eq!(verb.past(WordForm::Short).unwrap().kanji.unwrap(), String::from("習った"));

assert_eq!(verb.past(WordForm::Long).unwrap().kana, String::from("ならいました"));
assert_eq!(verb.past(WordForm::Long).unwrap().kanji.unwrap(), String::from("習いました"));

pub fn negative_past(&self, form: WordForm) -> Result<Word, Error>

Returns the verb in the negative past form

Example

use jp_inflections::{Word, VerbType, WordForm};

let verb = Word::new("ならう", Some("習う")).into_verb(VerbType::Godan).unwrap();
assert_eq!(verb.negative_past(WordForm::Short).unwrap().kana, String::from("ならわなかった"));
assert_eq!(verb.negative_past(WordForm::Short).unwrap().kanji.unwrap(), String::from("習わなかった"));

assert_eq!(verb.negative_past(WordForm::Long).unwrap().kana, String::from("ならいませんでした"));
assert_eq!(verb.negative_past(WordForm::Long).unwrap().kanji.unwrap(), String::from("習いませんでした"));

pub fn potential(&self, form: WordForm) -> Result<Word, Error>

Returns the verb in the potential form

Example

use jp_inflections::{Word, VerbType, WordForm};

let verb = Word::new("ならう", Some("習う")).into_verb(VerbType::Godan).unwrap();
assert_eq!(verb.potential(WordForm::Short).unwrap().kana, String::from("ならえる"));
assert_eq!(verb.potential(WordForm::Short).unwrap().kanji.unwrap(), String::from("習える"));

assert_eq!(verb.potential(WordForm::Long).unwrap().kana, String::from("ならえます"));
assert_eq!(verb.potential(WordForm::Long).unwrap().kanji.unwrap(), String::from("習えます"));

pub fn negative_potential(&self, form: WordForm) -> Result<Word, Error>

Returns the verb in the negative potential form

Example

use jp_inflections::{Word, VerbType, WordForm};

let verb = Word::new("ならう", Some("習う")).into_verb(VerbType::Godan).unwrap();
assert_eq!(verb.negative_potential(WordForm::Short).unwrap().kana, String::from("ならえない"));
assert_eq!(verb.negative_potential(WordForm::Short).unwrap().kanji.unwrap(), String::from("習えない"));

assert_eq!(verb.negative_potential(WordForm::Long).unwrap().kana, String::from("ならえません"));
assert_eq!(verb.negative_potential(WordForm::Long).unwrap().kanji.unwrap(), String::from("習えません"));

pub fn imperative(&self) -> Result<Word, Error>

Returns the verb in the imperative form

Example

use jp_inflections::{Word, VerbType, WordForm};

let verb = Word::new("たべる", Some("食べる")).into_verb(VerbType::Ichidan).unwrap();
assert_eq!(verb.imperative().unwrap().kana, String::from("たべろ"));
assert_eq!(verb.imperative().unwrap().kanji.unwrap(), String::from("食べろ"));

let verb = Word::new("ならう", Some("習う")).into_verb(VerbType::Godan).unwrap();
assert_eq!(verb.imperative().unwrap().kana, String::from("ならえ"));
assert_eq!(verb.imperative().unwrap().kanji.unwrap(), String::from("習え"));

pub fn imperative_negative(&self) -> Result<Word, Error>

Returns the verb in the negative imperative form

Example

use jp_inflections::{Word, VerbType, WordForm};

let verb = Word::new("たべる", Some("食べる")).into_verb(VerbType::Ichidan).unwrap();
assert_eq!(verb.imperative_negative().unwrap().kana, String::from("たべるな"));
assert_eq!(verb.imperative_negative().unwrap().kanji.unwrap(), String::from("食べるな"));

let verb = Word::new("ならう", Some("習う")).into_verb(VerbType::Godan).unwrap();
assert_eq!(verb.imperative_negative().unwrap().kana, String::from("ならうな"));
assert_eq!(verb.imperative_negative().unwrap().kanji.unwrap(), String::from("習うな"));

pub fn causative(&self) -> Result<Word, Error>

Returns the verb in the causative form

Example

use jp_inflections::{Word, VerbType, WordForm};

let verb = Word::new("たべる", Some("食べる")).into_verb(VerbType::Ichidan).unwrap();
assert_eq!(verb.causative().unwrap().kana, String::from("たべさせる"));
assert_eq!(verb.causative().unwrap().kanji.unwrap(), String::from("食べさせる"));

pub fn causative_passive(&self) -> Result<Word, Error>

Returns the verb in the passive-causative form

Example

use jp_inflections::{Word, VerbType, WordForm};

let verb = Word::new("たべる", Some("食べる")).into_verb(VerbType::Ichidan).unwrap();
assert_eq!(verb.causative_passive().unwrap().kana, String::from("たべさせられる"));
assert_eq!(verb.causative_passive().unwrap().kanji.unwrap(), String::from("食べさせられる"));
let verb = Word::new("ならう", Some("習う")).into_verb(VerbType::Godan).unwrap();
assert_eq!(verb.causative_passive().unwrap().kanji.unwrap(), String::from("習わされる"));

pub fn negative_causative_passive(&self) -> Result<Word, Error>

Returns the verb in the negative passive-causative form

Example

use jp_inflections::{Word, VerbType, WordForm};

let verb = Word::new("たべる", Some("食べる")).into_verb(VerbType::Ichidan).unwrap();
assert_eq!(verb.negative_causative_passive().unwrap().kana, String::from("たべさせられない"));
assert_eq!(verb.negative_causative_passive().unwrap().kanji.unwrap(), String::from("食べさせられない"));
let verb = Word::new("ならう", Some("習う")).into_verb(VerbType::Godan).unwrap();
assert_eq!(verb.negative_causative_passive().unwrap().kanji.unwrap(), String::from("習わされない"));

pub fn negative_causative(&self) -> Result<Word, Error>

Returns the verb in the negative causative form

Example

use jp_inflections::{Word, VerbType, WordForm};

let verb = Word::new("たべる", Some("食べる")).into_verb(VerbType::Ichidan).unwrap();
assert_eq!(verb.negative_causative().unwrap().kana, String::from("たべさせない"));
assert_eq!(verb.negative_causative().unwrap().kanji.unwrap(), String::from("食べさせない"));

pub fn passive(&self) -> Result<Word, Error>

Returns the verb in the passive form

Example

use jp_inflections::{Word, VerbType, WordForm};

let verb = Word::new("たべる", Some("食べる")).into_verb(VerbType::Ichidan).unwrap();
assert_eq!(verb.passive().unwrap().kana, String::from("たべられる"));
assert_eq!(verb.passive().unwrap().kanji.unwrap(), String::from("食べられる"));

pub fn negative_passive(&self) -> Result<Word, Error>

Returns the verb in the negative passive form

Example

use jp_inflections::{Word, VerbType, WordForm};

let verb = Word::new("たべる", Some("食べる")).into_verb(VerbType::Ichidan).unwrap();
assert_eq!(verb.negative_passive().unwrap().kana, String::from("たべられない"));
assert_eq!(verb.negative_passive().unwrap().kanji.unwrap(), String::from("食べられない"));

Trait Implementations

impl Clone for Verb

fn clone(&self) -> Verb

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Verb

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq<Verb> for Verb

fn eq(&self, other: &Verb) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Verb) -> bool

This method tests for !=.

impl StructuralPartialEq for Verb