Trait combine::ParserExt [−] [src]

pub trait ParserExt: Parser + Sized {
    fn with<P2>(self, p: P2) -> With<Self, P2> where P2: Parser<Input=Self::Input> { ... }
    fn skip<P2>(self, p: P2) -> Skip<Self, P2> where P2: Parser<Input=Self::Input> { ... }
    fn and<P2>(self, p: P2) -> And<Self, P2> where P2: Parser<Input=Self::Input> { ... }
    fn or<P2>(self, p: P2) -> Or<Self, P2> where P2: Parser<Input=Self::Input> { ... }
    fn then<N, F>(self, f: F) -> Then<Self, F> where F: FnMut(Self::Output) -> N, N: Parser<Input=Self::Input> { ... }
    fn map<F, B>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Output) -> B { ... }
    fn message<S>(self, msg: S) -> Message<Self> where S: Into<Info<Self::Input::Item, Self::Input::Range>> { ... }
    fn expected<S>(self, msg: S) -> Expected<Self> where S: Into<Info<Self::Input::Item, Self::Input::Range>> { ... }
    fn and_then<F, O, E>(self, f: F) -> AndThen<Self, F> where F: FnMut(Self::Output) -> Result<O, E>, E: Into<Error<Self::Input::Item, Self::Input::Range>> { ... }
    fn iter(self, input: State<Self::Input>) -> Iter<Self> { ... }
}

Extension trait which provides functions that are more conveniently used through method calls

Provided Methods

fn with<P2>(self, p: P2) -> With<Self, P2> where P2: Parser<Input=Self::Input>

Discards the value of the self parser and returns the value of p Fails if any of the parsers fails

 let result = digit()
     .with(token('i'))
     .parse("9i")
     .map(|x| x.0);
 assert_eq!(result, Ok('i'));

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where P2: Parser<Input=Self::Input>

Discards the value of the p parser and returns the value of self Fails if any of the parsers fails

 let result = digit()
     .skip(token('i'))
     .parse("9i")
     .map(|x| x.0);
 assert_eq!(result, Ok('9'));

fn and<P2>(self, p: P2) -> And<Self, P2> where P2: Parser<Input=Self::Input>

Parses with self followed by p Succeeds if both parsers succeed, otherwise fails Returns a tuple with both values on success

 let result = digit()
     .and(token('i'))
     .parse("9i")
     .map(|x| x.0);
 assert_eq!(result, Ok(('9', 'i')));

fn or<P2>(self, p: P2) -> Or<Self, P2> where P2: Parser<Input=Self::Input>

Returns a parser which attempts to parse using self. If self fails without consuming any input it tries to consume the same input using p.

let mut parser = string("let")
    .or(digit().map(|_| "digit"))
    .or(string("led"));
assert_eq!(parser.parse("let"), Ok(("let", "")));
assert_eq!(parser.parse("1"), Ok(("digit", "")));
assert!(parser.parse("led").is_err());

let mut parser2 = string("two").or(string("three"));
// Fails as the parser for "two" consumes the first 't' before failing
assert!(parser2.parse("three").is_err());

// Use 'try' to make failing parsers always act as if they have not consumed any input
let mut parser3 = try(string("two")).or(try(string("three")));
assert_eq!(parser3.parse("three"), Ok(("three", "")));

fn then<N, F>(self, f: F) -> Then<Self, F> where F: FnMut(Self::Output) -> N, N: Parser<Input=Self::Input>

Parses using self and then passes the value to f which returns a parser used to parse the rest of the input

 let result = digit()
     .then(|d| parser(move |input| {
         if d == '9' {
             Ok((9, Consumed::Empty(input)))
         }
         else {
             let err = ParseError::new(input.position, Error::Message("Not a nine".into()));
             Err((Consumed::Empty(err)))
         }
     }))
     .parse("9");
 assert_eq!(result, Ok((9, "")));

fn map<F, B>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Output) -> B

Uses f to map over the parsed value

 let result = digit()
     .map(|c| c == '9')
     .parse("9")
     .map(|x| x.0);
 assert_eq!(result, Ok(true));

fn message<S>(self, msg: S) -> Message<Self> where S: Into<Info<Self::Input::Item, Self::Input::Range>>

Parses with self and if it fails, adds the message msg to the error

 let result = token('9')
     .message("Not a nine")
     .parse("8");
 assert_eq!(result, Err(ParseError {
     position: <char as Positioner>::start(),
     errors: vec![
         Error::Unexpected('8'.into()),
         Error::Expected('9'.into()),
         Error::Message("Not a nine".into())
     ]
 }));

fn expected<S>(self, msg: S) -> Expected<Self> where S: Into<Info<Self::Input::Item, Self::Input::Range>>

Parses with self and if it fails without consuming any input any expected errors are replaced by msg. msg is then used in error messages as "Expected msg".

let result = token('9')
    .expected("nine")
    .parse("8");
assert_eq!(result, Err(ParseError {
    position: <char as Positioner>::start(),
    errors: vec![Error::Unexpected('8'.into()), Error::Expected("nine".into())]
}));

fn and_then<F, O, E>(self, f: F) -> AndThen<Self, F> where F: FnMut(Self::Output) -> Result<O, E>, E: Into<Error<Self::Input::Item, Self::Input::Range>>

Parses with self and applies f on the result if self parses successfully f may optionally fail with an error which is automatically converted to a ParseError

 let mut parser = many1(digit())
     .and_then(|s: String| s.parse::<i32>());
 let result = parser.parse("1234");
 assert_eq!(result, Ok((1234, "")));
 let err = parser.parse("abc");
 assert!(err.is_err());

fn iter(self, input: State<Self::Input>) -> Iter<Self>

Creates an iterator from a parser and a state. Can be used as an alternative to many when collecting directly into a FromIterator type is not desirable

let mut buffer = String::new();
let number = parser(|input| {
    buffer.clear();
    let mut iter = digit().iter(input);
    buffer.extend(&mut iter);
    let i = buffer.parse::<i32>().unwrap();
    iter.into_result(i)
});
let result = sep_by(number, char(','))
    .parse("123,45,6");
assert_eq!(result, Ok((vec![123, 45, 6], "")));

Implementors