Struct MyStem 

pub struct MyStem {
    pub process: Popen,
}

A Mystem process representation

Fields

process: Popen

Implementations

impl MyStem

pub fn new() -> Result<Self, AppError>

Returns a MyStem instance with running process of mystem binary. It keeps mystem running all the time and reuse it.

Examples found in repository

examples/test.rs (line 7)

fn main() -> Result<(), mystem::AppError> {
    let mut instance = mystem::MyStem::new()?;
    for stem in instance.stemming("Связался с лучшим - подохни как все, Говноед.".into())?
    {
        println!(
            "'{}' most likely is a '{}' and lexeme is '{}'.{}{}",
            stem.text,
            stem.lex[0].grammem.part_of_speech,
            stem.lex[0].lex,
            {
                match stem.lex[0]
                    .grammem
                    .facts
                    .contains(&mystem::Fact::Other(Obscene))
                {
                    true => " Obscene lexis.",
                    false => "",
                }
            },
            {
                match stem.lex.len() {
                    0 | 1 => "".to_string(),
                    x if x > 1 => format!(" Also has {} found lexems.", x),
                    _ => unreachable!(),
                }
            }
        )
    }
    instance.terminate();
    Ok(())
}

pub fn terminate(&mut self) -> Result<(), Error>

Terminate mystem instance.

Examples found in repository

examples/test.rs (line 34)

fn main() -> Result<(), mystem::AppError> {
    let mut instance = mystem::MyStem::new()?;
    for stem in instance.stemming("Связался с лучшим - подохни как все, Говноед.".into())?
    {
        println!(
            "'{}' most likely is a '{}' and lexeme is '{}'.{}{}",
            stem.text,
            stem.lex[0].grammem.part_of_speech,
            stem.lex[0].lex,
            {
                match stem.lex[0]
                    .grammem
                    .facts
                    .contains(&mystem::Fact::Other(Obscene))
                {
                    true => " Obscene lexis.",
                    false => "",
                }
            },
            {
                match stem.lex.len() {
                    0 | 1 => "".to_string(),
                    x if x > 1 => format!(" Also has {} found lexems.", x),
                    _ => unreachable!(),
                }
            }
        )
    }
    instance.terminate();
    Ok(())
}

pub fn stemming(&mut self, text: String) -> Result<Vec<Stemming>, AppError>

Returns Vec with mystem::Stemming for each word in text

Examples

    let mut instance = mystem::MyStem::new()?;
    for stem in instance.stemming("Связался с лучшим - подохни как все.".into())? {
        println!("{} is a lexeme of {}", stem.lex, stem.text)
    }
    // связываться is a lexeme of Связался
    // с is a lexeme of с
    // хороший is a lexeme of лучшим
    // подыхать is a lexeme of подохни
    // как is a lexeme of как
    // все is a lexeme of все

Examples found in repository

examples/test.rs (line 8)

fn main() -> Result<(), mystem::AppError> {
    let mut instance = mystem::MyStem::new()?;
    for stem in instance.stemming("Связался с лучшим - подохни как все, Говноед.".into())?
    {
        println!(
            "'{}' most likely is a '{}' and lexeme is '{}'.{}{}",
            stem.text,
            stem.lex[0].grammem.part_of_speech,
            stem.lex[0].lex,
            {
                match stem.lex[0]
                    .grammem
                    .facts
                    .contains(&mystem::Fact::Other(Obscene))
                {
                    true => " Obscene lexis.",
                    false => "",
                }
            },
            {
                match stem.lex.len() {
                    0 | 1 => "".to_string(),
                    x if x > 1 => format!(" Also has {} found lexems.", x),
                    _ => unreachable!(),
                }
            }
        )
    }
    instance.terminate();
    Ok(())
}

Trait Implementations

impl Debug for MyStem

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

Formats the value using the given formatter.