Crate ntriple [] [src]

ntriple, a library to parse N-Triples on a per string basis.

# Examples

Here's a typical example. It sends an input string (can be a line from a file for example) to the triple_line() method of the parser, which returns an Option<Triple> if the input is valid, or a None or ParseError if the input is a comment or an invalid triple respectively.

If you are sure that the input should be a triple and no comment, white space, or other rubbish, you can just use the triple method, which omits the Option and directly returns a ParseResult<Triple>.

use ntriple::parser::triple_line;
use ntriple::{Subject, Predicate, Object};

fn main() {

  // Here's some input in n-triples format. Unicode escape sequences are resolved
  // so \u30AA becomes オ.
  let input = "_:subject <> \"\\u30AAオブジェクト\".";
  // parse the input:
  let parse_result = triple_line(&input);

  // The result contains an option, or an error when parsing the input failed.
  match parse_result {

    // Ok if the input is a triple, a comment, an empty string or whitespace(s).
    Ok(triple_option) => {
      match triple_option {
        Some(triple) => { // a valid triple is found.
          match triple.subject {
            // In this case we expect a blank node label
            Subject::BNode(subject) => println!("Subject: blank node: {}", subject),
            _ => println!("Weird, a blank node is expected here.")
          match triple.predicate {
            Predicate::IriRef(iri) => println!("Predicate: {}", iri)
          match triple.object {
            Object::Lit(literal) => println!("Object: literal: {} ",,
            _ => println!("Weird, a literal is expected here.")
        None => { println!("Skipped [{}]", input); }
    // a parse error: the input is no valid triple, comment, empty string or whitespace(s)
    Err(error) => println!("{}\n{}", input, error),



Generated code.



Represents an RDF literal.


Represents an RDF statement in the form of a triple.



Represents the object part of a triple.


Represents the predicate part of a triple.


Represents the subject part of a triple.


Represents either a type or a language.