Module combine::easy

Available on crate feature std only.

Stream wrapper which provides an informative and easy to use error type.

Unless you have specific constraints preventing you from using this error type (such as being a no_std environment) you probably want to use this stream type. It can easily be used through the EasyParser::easy_parse method.

The provided Errors type is roughly the same as ParseError in combine 1.x and 2.x.

#[macro_use]
extern crate combine;
use combine::{easy, Parser, EasyParser, Stream, many1};
use combine::parser::char::letter;
use combine::stream::StreamErrorFor;
use combine::error::{ParseError, StreamError};

fn main() {
    parser!{
       fn parser[Input]()(Input) -> String
        where [
            Input: Stream<Token = char, Error = easy::ParseError<Input>>,
            Input::Range: PartialEq,
            // If we want to use the error type explicitly we need to help rustc infer
            // `StreamError` to `easy::Error` (rust-lang/rust#24159)
            Input::Error: ParseError<
                Input::Token,
                Input::Range,
                Input::Position,
                StreamError = easy::Error<Input::Token, Input::Range>
            >
        ]
        {
            many1(letter()).and_then(|word: String| {
                if word == "combine" {
                    Ok(word)
                } else {
                    Err(easy::Error::Expected(easy::Info::Static("combine")))
                }
            })
        }
    }

    parser!{
       fn parser2[Input]()(Input) -> String
        where [
            Input: Stream<Token = char>,
        ]
        {
            many1(letter()).and_then(|word: String| {
                if word == "combine" {
                    Ok(word)
                } else {
                    // Alternatively it is possible to only use the methods provided by the
                    // `StreamError` trait.
                    // In that case the extra bound is not necessary (and this method will work
                    // for other errors than `easy::Errors`)
                    Err(StreamErrorFor::<Input>::expected_static_message("combine"))
                }
            })
        }
    }

    let input = "combin";
    let expected_error = Err(easy::Errors {
        errors: vec![
            easy::Error::Expected("combine".into())
        ],
        position: 0,
    });
    assert_eq!(
        parser().easy_parse(input).map_err(|err| err.map_position(|p| p.translate_position(input))),
        expected_error
    );
    assert_eq!(
        parser2().easy_parse(input).map_err(|err| err.map_position(|p| p.translate_position(input))),
        expected_error
    );
}

Structs

• Errors
  Struct which hold information about an error that occurred at a specific position. Can hold multiple instances of Error if more that one error occurred in the same position.
• Stream

Enums

• Error
  Enum used to store information about an error that has occurred during parsing.
• Info
  Enum holding error information. Variants are defined for Stream::Token and Stream::Range as well as string variants holding easy descriptions.

Type Aliases

• ParseError
  Convenience alias over Errors for StreamOnce types which makes it possible to specify the Errors type from a StreamOnce by writing ParseError<Input> instead of Errors<Input::Token, Input::Range, Input::Position>