Crate rusty_parser

Rusty Parser

A Generic compile-time Parser generator and Pattern Matching Library written in Rust

RustyParser provides a set of basic parsers, combinators, and parser-generating functions.

This library is designed to work with general iterators, but some functionalities are limited to std::str::Chars or std::iter::Cloned<std::slice::Iter>.

Example

use rusty_parser as rp;
use rp::IntoParser;
// define pattern
// digit: [0-9]
// this will match one digit, and returns (char,), the character it parsed
let digit_parser = rp::range('0'..='9');
// define pattern
// num: digit+
// this will match one or more digits, and returns (Vec<char>,), the character it parsed
let num_parser = digit_parser.repeat(1..);
// map the output
// Vec<char>  -->  i32
let num_parser = num_parser.map(|digits: Vec<char>| -> i32 {
    let mut num = 0;
    for ch in digits {
        num = num * 10 + (ch as i32 - '0' as i32);
    }
    num
});
// parse input iterator with given pattern, and return the result
let res = rp::parse(&num_parser, "123456hello_world".chars());
// res contains the result of parsing
assert_eq!(res.output.unwrap(), (123456,));
// res.it: iterator after parsing
// here, '123456' is parsed, so the rest is "hello_world"
assert_eq!(res.it.collect::<String>(), "hello_world");

Those generated parsers are used to parse the input string, and return the extracted data.

parse(...) takes a Pattern Object and iterator of input string, then returns ParseResult<Self::Output, It>.

match_pattern(...) is used when you only want to check if the pattern is matched or not, without extracting data. For some parsers, like repeat, it is expensive to call parse(...) to get the output since it invokes Vec::push inside.

Note

• Since the parse(...) internally clones the iterator, the iterator must be cheaply clonable.
• Output must be Tuple, including (). If you want to return a single value, use (Value,).

Macros

• or
  A macro for creating or combination of parsers.
• seq
  A macro for creating a sequence of parsers.

Structs

• DictBTree
  Dictionary using trie, implementation uses BTreeMap; O(log(N)) search.
• DictHashMap
  Dictionary using trie, implementation uses HashMap; O(1) search.
• DynBoxChars
  A Box<dyn Parser> wrapper for iterators of std::str::Chars.
• DynBoxSlice
  A Box<dyn Parser> wrapper for iterators of std::iter::Cloned<std::slice::Iter>.
• ParseResult
  struct that holds the result of parsing.

Traits

• InputIteratorTrait
  A trait alias that Input Iterator must hold.
• IntoParser
  Trait for converting possible types to Parser.
• Parser
  Parser trait.

Functions

• any
  This parser will match any character.
• check
  Check single item with the given closure.
• constant
  This Parser will always success and return the clone of given output.
• end
  Parser that success if reached end of input
• fail
  This Parser will always fail.
• into_parser
  convert the given type to Parser ( if it impl IntoParser )
• match_pattern
  Match the input with the given parser.
• one
  Check one character is equal to the given character.
• one_by
  Check one character is equal to the given character by equility function.
• or
  A binary or combinator
• parse
  Parse the input with the given parser.
• range
  Check one character is in the given range.
• seq
  A binary seq combinator
• slice
  Compare the input starts with the given slice.
• slice_by
  Compare the input starts with the given slice. With given equality function.
• str
  Compare the input string starts with the given string.
• str_by
  Compare the input string starts with the given string. With given equality function.
• string
  Compare the input string starts with the given string.
• string_by
  Compare the input string starts with the given string. With given equality function.
• vec
  Compare the input starts with the given slice.
• vec_by
  Compare the input starts with the given slice. With given equality function.