[−][src]Crate combinedfun
This is a parser combinator library that aims to provide short and consise, but easily readable parser combinators.
If you don't know how parser combinators work, I suggest looking at
nom
first.
This library doesn't use macros, so it is a bit limited for some applications (specifically
places where you can use map_parser
are rather limited).
It also uses operator overloading for writing parsers that are easy to read and write.
Here is one example (I have no clue why almost every closure needs its arguments specified):
use std::iter; use combinedfun as cf; enum End { Repeat(String), Add(usize), } let parser = ( cf::record_while(|c: &char| c.is_digit(10), 1..) >> (|s: &str| s.parse::<usize>().unwrap()) >> ( -cf::tag(" ") >> cf::take(..) >> (|s: &str| End::Repeat(s.to_owned())) | -cf::tag("+") >> cf::record_while(|c: &char| c.is_digit(10), 1..) >> (|s: &str| End::Add(s.parse::<usize>().unwrap())) ) >> (|(i, end)| match end { End::Repeat(s) => (0..i).fold("".to_owned(), |acc, _| acc + &s), End::Add(j) => (i + j).to_string() }) ); assert_eq!(parser.parse("3 abc"), Ok("abcabcabc".to_owned())); assert_eq!(parser.parse("10 x"), Ok("xxxxxxxxxx".to_owned())); assert_eq!(parser.parse("42+123"), Ok("165".to_owned())); assert_eq!(parser.parse("42+abc"), Err(())); assert_eq!(parser.parse("+123"), Err(()));
Re-exports
pub use traits::AltError; |
pub use traits::Collection; |
pub use traits::ConsumeError; |
pub use traits::EofError; |
pub use traits::HasEof; |
pub use traits::NotError; |
pub use traits::Position; |
pub use traits::RangeLike; |
pub use traits::Recordable; |
pub use traits::SplitFirst; |
pub use traits::Tag; |
pub use traits::TagError; |
pub use types::Index; |
pub use types::NoCollection; |
pub use types::Pos; |
pub use types::Span; |
pub use types::PositionedError; |
Modules
combinators | These combinators all correspond to one function (with some extra argument sometimes) |
str_parsers | Defines helpful parsers for parsing |
traits | |
types |
Macros
parser | The parser macro allows you to easily write the type of a parser in a return position, using
|
parser_dbg | Allows debugging a parser. It uses the |
parser_hint | Allows helping Rusts type inference by returning an ε parser with the given type parameters. This is intended to be used with the overloaded operators. |
Structs
ElementSeparator | This type is used to make the syntactic sugar work. It's observed if you "divide" one
|
Ignored | This type is used to make the syntactic sugar work. It's observed if you put a minus in front
of a |
MapResult | This wrapper can be used to map to a |
Parser | This type is the one all functionality is built on. |
WithCollectionGenerator | This type is used to make the syntactic sugar work. It's observed if you multiply a parser or
an |
Traits
ParserImpl | This trait has to be implemented for the combinators in |
Functions
consume_one_where | Consumes the first element/character of the input, if it matches the given condition. |
consume_while | Consumes elements/characters of the input that match the given condition. |
eof | Fails if the input isn't empty. |
epsilon | Matches nothing, always succeeds. |
f | Creates an |
fail_with | Always fails, generating the error using a closure. |
fail_with_const | Always fails, generating the error using |
lookahead | Outputs the result of the given parser without consuming it. |
not | Fails if the given parser succeeds, and succeeds if the given parser fails. |
output | Outputs the output of the given function, or fails if the function returns |
record_while | Like |
tag | Requires the input to start with the given subsequence/substring. |
take | Consumes the rest of the input, and returns the matched string. |
Type Definitions
FnParser | A shortcut for parsers that are defined by functions. |
NoError | The unit type can be used to not keep track of what specifically got the parser to fail. |