docs.rs failed to build mecab-0.1.2
Please check the build logs for more information.
See Builds for ideas on how to fix a failed build, or Metadata for how to configure docs.rs builds.
If you believe this is docs.rs' fault, open an issue.

Visit the last successful build: mecab-0.1.6

mecab-rs

Safe Rust wrapper for mecab a japanese language part-of-speech and morphological analyzer library.

Usage

The wrapper is almost identical to the C++ interface of mecab with the addition of various iterator for comfortable data access. A detailed documentation of the wrapper will follow when Rust 1.0 is finally out and stable.

The basic usage can be seen in the following examples.

Examples

Include this in your Cargo.toml to add mecab to your project:

[dependencies]
mecab = "*"

Single-threaded environment

extern crate mecab;

use mecab::Tagger;

fn main() {
  let input = "太郎は次郎が持っている本を花子に渡した。";
  println!("INPUT: {}", input);

  let mut tagger = Tagger::new("");

  // gets tagged result as String
  let mut result = tagger.parse_str(input);
  println!("RESULT: {}", result);

  // gets N best results as String
  result = tagger.parse_nbest(3, input);
  println!("NBEST:\n{}", result);

  // gets N best in sequence
  tagger.parse_nbest_init(input);
  for i in (0..3) {
    if let Some(res) = tagger.next() {
      println!("{}:\n{}", i, res);
    }
  }

  // gets Node object
  for node in tagger.parse_to_node(input).iter_next() {
    match node.stat as i32 {
      mecab::MECAB_BOS_NODE => {
        print!("{} BOS ", node.id);
      },
      mecab::MECAB_EOS_NODE => {
        print!("{} EOS ", node.id);
      },
      _ => {
        print!("{} {} ", node.id, &(node.surface)[..(node.length as usize)]);
      }
    }

    println!("{} {} {} {} {} {} {} {} {} {} {} {} {}",
      node.feature,
      input.len() as isize - node.surface.len() as isize,
      input.len() as isize - node.surface.len() as isize  + node.length as isize,
      node.rcattr,
      node.lcattr,
      node.posid,
      node.char_type,
      node.stat,
      node.isbest,
      node.alpha,
      node.beta,
      node.prob,
      node.cost);
  }

  // dictionary info
  for dict in tagger.dictionary_info().iter() {
    println!("\nfilename: {}", dict.filename);
    println!("charset: {}", dict.charset);
    println!("size: {}", dict.size);
    println!("type: {}", dict.dict_type);
    println!("lsize: {}", dict.lsize);
    println!("rsize: {}", dict.rsize);
    println!("version: {}", dict.version);
  }
}

Multithreaded environment

extern crate mecab;

use mecab::Model;

fn main() {
  let input = "太郎は次郎が持っている本を花子に渡した。";

  // create model object
  let model = Model::new("");

  // create tagger based on the model
  let mut tagger = model.create_tagger();

  // create lattice object per thread
  let mut lattice = model.create_lattice();

  // get tagged result as string
  lattice.set_sentence(input);

  // parse lattice
  tagger.parse(&lattice);
  println!("{}", lattice.to_string());

  // iterate over node objects
  for node in lattice.bos_node().iter_next() {
    match node.stat as i32 {
      mecab::MECAB_BOS_NODE => {
        print!("{} BOS ", node.id);
      },
      mecab::MECAB_EOS_NODE => {
        print!("{} EOS ", node.id);
      },
      _ => {
        print!("{} {} ", node.id, &(node.surface)[..(node.length as usize)]);
      }
    }

    println!("{} {} {} {} {} {} {} {} {} {} {} {} {}",
      node.feature,
      input.len() as isize - node.surface.len() as isize,
      input.len() as isize - node.surface.len() as isize  + node.length as isize,
      node.rcattr,
      node.lcattr,
      node.posid,
      node.char_type,
      node.stat,
      node.isbest,
      node.alpha,
      node.beta,
      node.prob,
      node.cost);
  }

  // iterate over begin and end nodes
  let len = lattice.size();
  for i in (0..len+1) {
    let b = lattice.begin_nodes(i);
    let e = lattice.end_nodes(i);

    if let Some(nodes) = b {
      for node in nodes.iter_bnext() {
        println!("B[{}] {}\t{}", i, node.surface, node.feature);
      }
    }

    if let Some(nodes) = e {
      for node in nodes.iter_enext() {
        println!("E[{}] {}\t{}", i, node.surface, node.feature);
      }
    }
  }

  // get N best results
  lattice.set_request_type(mecab::MECAB_NBEST);
  lattice.set_sentence(input);
  tagger.parse(&lattice);

  for i in (0..10) {
    println!("NBEST: {}", i);
    println!("{}", lattice.to_string());

    if !lattice.next() {
      break;
    }
  }

  // marginal probabilities
  lattice.remove_request_type(mecab::MECAB_NBEST);
  lattice.set_request_type(mecab::MECAB_MARGINAL_PROB);
  lattice.set_sentence(input);
  tagger.parse(&lattice);

  println!("{}", lattice.theta());

  for node in lattice.bos_node().iter_next() {
    println!("{}\t{}\t{}", &(node.surface)[..(node.length as usize)], node.feature, node.prob);
  }

  // dictionary info
  for dict in model.dictionary_info().iter() {
    println!("\nfilename: {}", dict.filename);
    println!("charset: {}", dict.charset);
    println!("size: {}", dict.size);
    println!("type: {}", dict.dict_type);
    println!("lsize: {}", dict.lsize);
    println!("rsize: {}", dict.rsize);
    println!("version: {}", dict.version);
  }
}

License

The MIT License (MIT)

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.