rcombinators is a parser combinator library without special magic. It aims to be both easy to use and reasonably fast, without using too much special syntax or macros.
You will notice two kinds of parsers that however differ only in minor aspects:
- Ones starting with a capital letter are
structs (such as
Sequence). You can create them using
ParserName::new(), or a specialized constructor method.
- Ones starting with a lower case letter (and in snake case, such as
string_of). Those are functions returning
Parserobjects combined from one or more elementary parsers.
The resulting objects implementing the
Parser trait are identical to use.
Note that not all primitives and combinators are exported at the crate level! Only "important" ones are.
Here's a short example of how to use it:
use rcombinators::combinators; use rcombinators::primitives; use rcombinators::ParseState; use rcombinators::Parser; // Goal: Parse the string between the parentheses, and then the float. let mut ps = ParseState::new("(a1b3c4) -1.25e-1"); let mut some_string = combinators::Alternative::new( (primitives::StringParser::new("xyz"), primitives::string_of("abcde12345", combinators::RepeatSpec::Min(1)))); let mut in_parens = combinators::Sequence::new( (primitives::StringParser::new("("), some_string, primitives::StringParser::new(")"))); assert_eq!(Ok( ("(".to_string(), "a1b3c4".to_string(), ")".to_string())), in_parens.parse(&mut ps)); // You can continue using a ParseState, for example when implementing your own parsers. let _ = primitives::whitespace().parse(&mut ps); // Parsers returned by functions such as float() should be cached when used more frequently. // This saves time due to not needing to construct the parsers repeatedly. assert_eq!(Ok(-0.125), primitives::float().parse(&mut ps));
ParseState encapsulates a stream of chars.