pub trait Parser {
type Input: Stream;
type Output;
type PartialState: Default;
Show 28 methods
// Provided methods
fn easy_parse<I>(
&mut self,
input: I,
) -> Result<(Self::Output, I), ParseError<I>>
where I: Stream,
Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
I::Position: Default,
Self: Sized + Parser<Input = Stream<I>> { ... }
fn parse(
&mut self,
input: Self::Input,
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error> { ... }
fn parse_with_state(
&mut self,
input: &mut Self::Input,
state: &mut Self::PartialState,
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error> { ... }
fn parse_stream(
&mut self,
input: &mut Self::Input,
) -> ParseResult<Self::Output, Self::Input> { ... }
fn parse_stream_consumed(
&mut self,
input: &mut Self::Input,
) -> ConsumedResult<Self::Output, Self::Input> { ... }
fn parse_stream_consumed_partial(
&mut self,
input: &mut Self::Input,
state: &mut Self::PartialState,
) -> ConsumedResult<Self::Output, Self::Input> { ... }
fn parse_lazy(
&mut self,
input: &mut Self::Input,
) -> ConsumedResult<Self::Output, Self::Input> { ... }
fn parse_first(
&mut self,
input: &mut Self::Input,
state: &mut Self::PartialState,
) -> ConsumedResult<Self::Output, Self::Input> { ... }
fn parse_partial(
&mut self,
input: &mut Self::Input,
state: &mut Self::PartialState,
) -> ConsumedResult<Self::Output, Self::Input> { ... }
fn add_error(
&mut self,
_error: &mut Tracked<<Self::Input as StreamOnce>::Error>,
) { ... }
fn by_ref(&mut self) -> &mut Self
where Self: Sized { ... }
fn with<P2>(self, p: P2) -> With<Self, P2>
where Self: Sized,
P2: Parser<Input = Self::Input> { ... }
fn skip<P2>(self, p: P2) -> Skip<Self, P2>
where Self: Sized,
P2: Parser<Input = Self::Input> { ... }
fn and<P2>(self, p: P2) -> (Self, P2)
where Self: Sized,
P2: Parser<Input = Self::Input> { ... }
fn or<P2>(self, p: P2) -> Or<Self, P2>
where Self: Sized,
P2: Parser<Input = Self::Input, Output = Self::Output> { ... }
fn then<N, F>(self, f: F) -> Then<Self, F>
where Self: Sized,
F: FnMut(Self::Output) -> N,
N: Parser<Input = Self::Input> { ... }
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F>
where Self: Sized,
F: FnMut(&mut Self::Output) -> N,
N: Parser<Input = Self::Input> { ... }
fn map<F, B>(self, f: F) -> Map<Self, F>
where Self: Sized,
F: FnMut(Self::Output) -> B { ... }
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F>
where Self: Sized,
F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error> { ... }
fn message<S>(self, msg: S) -> Message<Self>
where Self: Sized,
S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>> { ... }
fn expected<S>(self, msg: S) -> Expected<Self>
where Self: Sized,
S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>> { ... }
fn silent(self) -> Silent<Self>
where Self: Sized { ... }
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F>
where Self: Parser<Input = I> + Sized,
F: FnMut(Self::Output) -> Result<O, E>,
I: Stream,
E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError> { ... }
fn iter(
self,
input: &mut <Self as Parser>::Input,
) -> Iter<'_, Self, Self::PartialState, FirstMode> ⓘ
where Self: Parser + Sized { ... }
fn partial_iter<'a, 's, M>(
self,
mode: M,
input: &'a mut <Self as Parser>::Input,
partial_state: &'s mut Self::PartialState,
) -> Iter<'a, Self, &'s mut Self::PartialState, M> ⓘ
where Self: Parser + Sized,
M: ParseMode { ... }
fn boxed<'a>(
self,
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a>
where Self: Sized + 'a { ... }
fn left<R>(self) -> Either<Self, R> ⓘ
where Self: Sized,
R: Parser<Input = Self::Input, Output = Self::Output> { ... }
fn right<L>(self) -> Either<L, Self> ⓘ
where Self: Sized,
L: Parser<Input = Self::Input, Output = Self::Output> { ... }
}Expand description
By implementing the Parser trait a type says that it can be used to parse an input stream
into the type Output.
All methods have a default implementation but there needs to be at least an implementation of
parse_stream, parse_stream_consumed, or parse_lazy. If the last is implemented, an
implementation of add_error may also be required. See the documentation for
parse_lazy for details.
Required Associated Types§
Sourcetype Input: Stream
type Input: Stream
The type which is taken as input for the parser. The type must implement the Stream trait
which allows the parser to read items from the type.
Sourcetype PartialState: Default
type PartialState: Default
Determines the state necessary to resume parsing after more input is supplied.
If partial parsing is not supported this can be set to ().
Provided Methods§
Sourcefn easy_parse<I>(
&mut self,
input: I,
) -> Result<(Self::Output, I), ParseError<I>>
fn easy_parse<I>( &mut self, input: I, ) -> Result<(Self::Output, I), ParseError<I>>
Entry point of the parser. Takes some input and tries to parse it, returning an easy to use and format error if parsing did not succeed.
Returns the parsed result and the remaining input if the parser succeeds, or a
This function wraps requires Self::Input == easy::Stream<I> which makes it return
return easy::Errors if an error occurs. Due to this wrapping it is recommended that the
parser Self is written with a generic input type.
use combine::{Parser, Stream};
use combine::parser::repeat::many1;
use combine::parser::char::letter;
// Good!
parser!{
fn my_parser[I]()(I) -> String
where [I: Stream<Item=char>]
{
many1(letter())
}
}
// Won't compile with `easy_parse` since it is specialized on `&str`
parser!{
fn my_parser2['a]()(&'a str) -> String
{
many1(letter())
}
}
fn main() {
assert_eq!(my_parser().parse("abc"), Ok(("abc".to_string(), "")));
// Would fail to compile if uncommented
// my_parser2().parse("abc")
}Sourcefn parse(
&mut self,
input: Self::Input,
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>
fn parse( &mut self, input: Self::Input, ) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>
Entry point of the parser. Takes some input and tries to parse it.
Returns the parsed result and the remaining input if the parser succeeds, or a error otherwise.
This is the most straightforward entry point to a parser. Since it does not decorate the
input in any way you may find the error messages a hard to read. If that is the case you
may want to try wrapping your input with an easy::Stream or call easy_parse
instead.
Sourcefn parse_with_state(
&mut self,
input: &mut Self::Input,
state: &mut Self::PartialState,
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>
fn parse_with_state( &mut self, input: &mut Self::Input, state: &mut Self::PartialState, ) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>
Entry point of the parser when using partial parsing. Takes some input and tries to parse it.
Returns the parsed result and the remaining input if the parser succeeds, or a error otherwise.
Sourcefn parse_stream(
&mut self,
input: &mut Self::Input,
) -> ParseResult<Self::Output, Self::Input>
fn parse_stream( &mut self, input: &mut Self::Input, ) -> ParseResult<Self::Output, Self::Input>
Parses using the stream input by calling Stream::uncons one or more times.
On success returns Ok((value, new_state)), and on failure returns Err(error).
Furthermore new_state and error are wrapped in Consumed, providing information on
whether this parser consumed any input data or not.
Sourcefn parse_stream_consumed(
&mut self,
input: &mut Self::Input,
) -> ConsumedResult<Self::Output, Self::Input>
fn parse_stream_consumed( &mut self, input: &mut Self::Input, ) -> ConsumedResult<Self::Output, Self::Input>
Parses using the stream input by calling Stream::uncons one or more times.
Semantically equivalent to parse_stream, except this method returns a flattened result
type, combining Result and Consumed into a single FastResult.
fn parse_stream_consumed_partial( &mut self, input: &mut Self::Input, state: &mut Self::PartialState, ) -> ConsumedResult<Self::Output, Self::Input>
Sourcefn parse_lazy(
&mut self,
input: &mut Self::Input,
) -> ConsumedResult<Self::Output, Self::Input>
fn parse_lazy( &mut self, input: &mut Self::Input, ) -> ConsumedResult<Self::Output, Self::Input>
Parses using the stream input by calling Stream::uncons one or more times.
Specialized version of parse_stream_consumed which permits error value creation to be
skipped in the common case.
When this parser returns EmptyErr, this method is allowed to return an empty
Error. The error value that would have been returned can instead be obtained by
calling add_error. This allows a parent parser such as choice to skip the creation of
an unnecessary error value, if an alternative parser succeeds.
External callers should never have to call this function directly.
Parsers should seek to implement this function instead of the above two if errors can be
encountered before consuming input. The default implementation always returns all errors,
with add_error being a no-op.
Sourcefn parse_first(
&mut self,
input: &mut Self::Input,
state: &mut Self::PartialState,
) -> ConsumedResult<Self::Output, Self::Input>
fn parse_first( &mut self, input: &mut Self::Input, state: &mut Self::PartialState, ) -> ConsumedResult<Self::Output, Self::Input>
Parses using the stream input and allows itself to be resumed at a later point using
parse_partial by storing the necessary intermediate state in state.
Unlike parse_partial function this is allowed to assume that there is no partial state to
resume.
Sourcefn parse_partial(
&mut self,
input: &mut Self::Input,
state: &mut Self::PartialState,
) -> ConsumedResult<Self::Output, Self::Input>
fn parse_partial( &mut self, input: &mut Self::Input, state: &mut Self::PartialState, ) -> ConsumedResult<Self::Output, Self::Input>
Parses using the stream input and allows itself to be resumed at a later point using
parse_partial by storing the necessary intermediate state in state
Sourcefn add_error(
&mut self,
_error: &mut Tracked<<Self::Input as StreamOnce>::Error>,
)
fn add_error( &mut self, _error: &mut Tracked<<Self::Input as StreamOnce>::Error>, )
Adds the first error that would normally be returned by this parser if it failed with an
EmptyErr result.
See parse_lazy for details.
Sourcefn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
Borrows a parser instead of consuming it.
Used to apply parser combinators on self without losing ownership.
fn test(input: &mut &'static str) -> ParseResult<(char, char), &'static str> {
let mut p = digit();
let ((d, _), consumed) = try!((p.by_ref(), letter()).parse_stream(input));
let (d2, consumed) = try!(consumed.combine(|_| p.parse_stream(input)));
Ok(((d, d2), consumed))
}
fn main() {
let mut input = "1a23";
assert_eq!(
test(&mut input).map(|(t, c)| (t, c.map(|_| input))),
Ok((('1', '2'), Consumed::Consumed("3")))
);
}Sourcefn with<P2>(self, p: P2) -> With<Self, P2>
fn with<P2>(self, p: P2) -> With<Self, P2>
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'));Sourcefn skip<P2>(self, p: P2) -> Skip<Self, P2>
fn skip<P2>(self, p: P2) -> Skip<Self, P2>
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'));Sourcefn and<P2>(self, p: P2) -> (Self, P2)
fn and<P2>(self, p: P2) -> (Self, P2)
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')));Sourcefn or<P2>(self, p: P2) -> Or<Self, P2>
fn or<P2>(self, p: P2) -> Or<Self, P2>
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.
If you are looking to chain 3 or more parsers using or you may consider using the
choice! macro instead, which can be clearer and may result in a faster parser.
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 'attempt' to make failing parsers always act as if they have not consumed any input
let mut parser3 = attempt(string("two")).or(attempt(string("three")));
assert_eq!(parser3.parse("three"), Ok(("three", "")));Sourcefn then<N, F>(self, f: F) -> Then<Self, F>
fn then<N, F>(self, f: F) -> Then<Self, F>
Parses using self and then passes the value to f which returns a parser used to parse
the rest of the input.
Since the parser returned from f must have a single type it can be useful to use the
left and right methods to merge parsers of differing types into one.
If you are using partial parsing you may want to use partial_then instead.
let result = digit()
.then(|d| {
if d == '9' {
value(9).left()
}
else {
unexpected_any(d).message("Not a nine").right()
}
})
.easy_parse("9");
assert_eq!(result, Ok((9, "")));Sourcefn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F>
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F>
Variant of then which parses using self and then passes the value to f as a &mut reference.
Useful when doing partial parsing since it does not need to store the parser returned by
f in the partial state. Instead it will call f each to request a new parser each time
parsing resumes and that parser is needed.
Since the parser returned from f must have a single type it can be useful to use the
left and right methods to merge parsers of differing types into one.
let result = digit()
.then_partial(|d| {
if *d == '9' {
value(9).left()
}
else {
unexpected_any(*d).message("Not a nine").right()
}
})
.easy_parse("9");
assert_eq!(result, Ok((9, "")));Sourcefn map<F, B>(self, f: F) -> Map<Self, F>
fn map<F, B>(self, f: F) -> Map<Self, F>
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));Sourcefn flat_map<F, B>(self, f: F) -> FlatMap<Self, F>
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F>
Uses f to map over the output of self. If f returns an error the parser fails.
let result = take(4)
.flat_map(|bs| many(digit()).parse(bs).map(|t| t.0))
.parse("12abcd");
assert_eq!(result, Ok((String::from("12"), "cd")));Sourcefn message<S>(self, msg: S) -> Message<Self>where
Self: Sized,
S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>,
fn message<S>(self, msg: S) -> Message<Self>where
Self: Sized,
S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>,
Parses with self and if it fails, adds the message msg to the error.
let result = token('9')
.message("Not a nine")
.easy_parse(State::new("8"));
assert_eq!(result, Err(easy::Errors {
position: SourcePosition::default(),
errors: vec![
easy::Error::Unexpected('8'.into()),
easy::Error::Expected('9'.into()),
easy::Error::Message("Not a nine".into())
]
}));Sourcefn expected<S>(self, msg: S) -> Expected<Self>where
Self: Sized,
S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>,
fn expected<S>(self, msg: S) -> Expected<Self>where
Self: Sized,
S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::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")
.easy_parse(State::new("8"));
assert_eq!(result, Err(easy::Errors {
position: SourcePosition::default(),
errors: vec![
easy::Error::Unexpected('8'.into()),
easy::Error::Expected("nine".into())
]
}));Sourcefn silent(self) -> Silent<Self>where
Self: Sized,
fn silent(self) -> Silent<Self>where
Self: Sized,
Parses with self, if it fails without consuming any input any expected errors that would
otherwise be emitted by self are suppressed.
let result = token('9')
.expected("nine")
.silent()
.easy_parse(State::new("8"));
assert_eq!(result, Err(easy::Errors {
position: SourcePosition::default(),
errors: vec![
easy::Error::Unexpected('8'.into()),
]
}));Sourcefn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F>
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F>
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.easy_parse(State::new("1234")).map(|(x, state)| (x, state.input));
assert_eq!(result, Ok((1234, "")));
let result = parser.easy_parse(State::new("999999999999999999999999"));
assert!(result.is_err());
// Errors are report as if they occurred at the start of the parse
assert_eq!(result.unwrap_err().position, SourcePosition { line: 1, column: 1 });Sourcefn iter(
self,
input: &mut <Self as Parser>::Input,
) -> Iter<'_, Self, Self::PartialState, FirstMode> ⓘ
fn iter( self, input: &mut <Self as Parser>::Input, ) -> Iter<'_, Self, Self::PartialState, FirstMode> ⓘ
Creates an iterator from a parser and a state. Can be used as an alternative to many
when collecting directly into a Extend 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], "")));Sourcefn partial_iter<'a, 's, M>(
self,
mode: M,
input: &'a mut <Self as Parser>::Input,
partial_state: &'s mut Self::PartialState,
) -> Iter<'a, Self, &'s mut Self::PartialState, M> ⓘ
fn partial_iter<'a, 's, M>( self, mode: M, input: &'a mut <Self as Parser>::Input, partial_state: &'s mut Self::PartialState, ) -> Iter<'a, Self, &'s mut Self::PartialState, M> ⓘ
Creates an iterator from a parser and a state. Can be used as an alternative to many
when collecting directly into a Extend 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], "")));Sourcefn boxed<'a>(
self,
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a>where
Self: Sized + 'a,
fn boxed<'a>(
self,
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a>where
Self: Sized + 'a,
Turns the parser into a trait object by putting it in a Box. Can be used to easily
return parsers from functions without naming the type.
fn test<'input, F>(
c: char,
f: F)
-> Box<Parser<Input = &'input str, Output = (char, char), PartialState = ()>>
where F: FnMut(char) -> bool + 'static
{
::combine::combinator::no_partial((token(c), satisfy(f))).boxed()
}
let result = test('a', |c| c >= 'a' && c <= 'f')
.parse("ac");
assert_eq!(result, Ok((('a', 'c'), "")));Sourcefn left<R>(self) -> Either<Self, R> ⓘ
fn left<R>(self) -> Either<Self, R> ⓘ
Wraps the parser into the Either enum which allows combinators such as then to return
multiple different parser types (merging them to one)
let mut parser = any().then(|c|
if c == '#' {
skip_many(satisfy(|c| c != '\n'))
.with(value("".to_string()))
.left()
} else {
many1(letter())
.map(move |mut s: String| { s.insert(0, c); s })
.right()
});
let result = parser.parse("ac2");
assert_eq!(result, Ok(("ac".to_string(), "2")));
let result = parser.parse("# ac2");
assert_eq!(result, Ok(("".to_string(), "")));Sourcefn right<L>(self) -> Either<L, Self> ⓘ
fn right<L>(self) -> Either<L, Self> ⓘ
Wraps the parser into the Either enum which allows combinators such as then to return
multiple different parser types (merging them to one)
let mut parser = any().then(|c|
if c == '#' {
skip_many(satisfy(|c| c != '\n'))
.with(value("".to_string()))
.left()
} else {
many1(letter())
.map(move |mut s: String| { s.insert(0, c); s })
.right()
});
let result = parser.parse("ac2");
assert_eq!(result, Ok(("ac".to_string(), "2")));
let result = parser.parse("# ac2");
assert_eq!(result, Ok(("".to_string(), "")));