[−][src]Trait combine::Parser
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
, 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.
Associated Types
type Output
The type which is returned if the parser is successful.
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
fn parse(
&mut self,
input: Input
) -> Result<(Self::Output, Input), <Input as StreamOnce>::Error>
&mut self,
input: Input
) -> Result<(Self::Output, Input), <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.
fn parse_with_state(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> Result<Self::Output, <Input as StreamOnce>::Error>
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> Result<Self::Output, <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.
fn parse_stream(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
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 Commit
into a single ParseResult
.
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
Parses using the stream input
by calling Stream::uncons
one or more times.
Specialized version of parse_stream
which permits error value creation to be
skipped in the common case.
When this parser returns PeekErr
, 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.
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.
fn add_error(&mut self, _error: &mut Tracked<<Input as StreamOnce>::Error>)
Adds the first error that would normally be returned by this parser if it failed with an
PeekErr
result.
See parse_lazy
for details.
fn parse_stream_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
Like parse_stream
but supports partial parsing.
ⓘImportant traits for &'_ mut Wfn by_ref(&mut self) -> &mut Self where
Self: Sized,
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) -> StdParseResult<(char, char), &'static str> { let mut p = digit(); let ((d, _), committed) = (p.by_ref(), letter()).parse_stream(input).into_result()?; let (d2, committed) = committed.combine(|_| p.parse_stream(input).into_result())?; Ok(((d, d2), committed)) } fn main() { let mut input = "1a23"; assert_eq!( test(&mut input).map(|(t, c)| (t, c.map(|_| input))), Ok((('1', '2'), Commit::Commit("3"))) ); }
fn with<P2>(self, p: P2) -> With<Self, P2> where
Self: Sized,
P2: Parser<Input>,
Self: Sized,
P2: Parser<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
Self: Sized,
P2: Parser<Input>,
Self: Sized,
P2: Parser<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) -> (Self, P2) where
Self: Sized,
P2: Parser<Input>,
Self: Sized,
P2: Parser<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
Self: Sized,
P2: Parser<Input, Output = Self::Output>,
Self: Sized,
P2: Parser<Input, Output = Self::Output>,
Returns a parser which attempts to parse using self
. If self
fails without committing
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 committed any input let mut parser3 = attempt(string("two")).or(attempt(string("three"))); assert_eq!(parser3.parse("three"), Ok(("three", "")));
fn then<N, F>(self, f: F) -> Then<Self, F> where
Self: Sized,
F: FnMut(Self::Output) -> N,
N: Parser<Input>,
Self: Sized,
F: FnMut(Self::Output) -> N,
N: Parser<Input>,
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, "")));
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
Self: Sized,
F: FnMut(&mut Self::Output) -> N,
N: Parser<Input>,
Self: Sized,
F: FnMut(&mut Self::Output) -> N,
N: Parser<Input>,
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, "")));
fn map<F, B>(self, f: F) -> Map<Self, F> where
Self: Sized,
F: FnMut(Self::Output) -> B,
Self: Sized,
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 map_input<F, B>(self, f: F) -> MapInput<Self, F> where
Self: Sized,
F: FnMut(Self::Output, &mut Input) -> B,
Self: Sized,
F: FnMut(Self::Output, &mut Input) -> B,
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
Self: Sized,
F: FnMut(Self::Output) -> Result<B, <Input as StreamOnce>::Error>,
Self: Sized,
F: FnMut(Self::Output) -> Result<B, <Input as StreamOnce>::Error>,
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")));
fn message<S>(self, msg: S) -> Message<Self, S> where
Self: Sized,
S: for<'s> ErrorInfo<'s, Input::Token, Input::Range>,
Self: Sized,
S: for<'s> ErrorInfo<'s, Input::Token, Input::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(position::Stream::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()) ] }));
fn expected<S>(self, msg: S) -> Expected<Self, S> where
Self: Sized,
S: for<'s> ErrorInfo<'s, Input::Token, Input::Range>,
Self: Sized,
S: for<'s> ErrorInfo<'s, Input::Token, 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") .easy_parse(position::Stream::new("8")); assert_eq!(result, Err(easy::Errors { position: SourcePosition::default(), errors: vec![ easy::Error::Unexpected('8'.into()), easy::Error::Expected("nine".into()) ] })); let result = token('9') .expected(error::Format(format_args!("That is not a nine!"))) .easy_parse(position::Stream::new("8")); assert_eq!(result, Err(easy::Errors { position: SourcePosition::default(), errors: vec![ easy::Error::Unexpected('8'.into()), easy::Error::Expected("That is not a nine!".to_string().into()) ] }));
fn silent(self) -> Silent<Self> where
Self: Sized,
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(position::Stream::new("8")); assert_eq!(result, Err(easy::Errors { position: SourcePosition::default(), errors: vec![ easy::Error::Unexpected('8'.into()), ] }));
fn and_then<F, O, E>(self, f: F) -> AndThen<Self, F> where
Self: Parser<Input> + Sized,
F: FnMut(Self::Output) -> Result<O, E>,
E: Into<<Input::Error as ParseError<Input::Token, Input::Range, Input::Position>>::StreamError>,
Self: Parser<Input> + Sized,
F: FnMut(Self::Output) -> Result<O, E>,
E: Into<<Input::Error as ParseError<Input::Token, Input::Range, Input::Position>>::StreamError>,
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(position::Stream::new("1234")).map(|(x, state)| (x, state.input)); assert_eq!(result, Ok((1234, ""))); let result = parser.easy_parse(position::Stream::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 });
ⓘImportant traits for Iter<'a, Input, P, S, M>fn iter(
self,
input: &mut Input
) -> Iter<Input, Self, Self::PartialState, FirstMode> where
Self: Parser<Input> + Sized,
self,
input: &mut Input
) -> Iter<Input, Self, Self::PartialState, FirstMode> where
Self: Parser<Input> + Sized,
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], "")));
ⓘImportant traits for Iter<'a, Input, P, S, M>fn partial_iter<'a, 's, M>(
self,
mode: M,
input: &'a mut Input,
partial_state: &'s mut Self::PartialState
) -> Iter<'a, Input, Self, &'s mut Self::PartialState, M> where
Self: Parser<Input> + Sized,
M: ParseMode,
self,
mode: M,
input: &'a mut Input,
partial_state: &'s mut Self::PartialState
) -> Iter<'a, Input, Self, &'s mut Self::PartialState, M> where
Self: Parser<Input> + Sized,
M: ParseMode,
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], "")));
ⓘImportant traits for Box<W>fn boxed<'a>(
self
) -> Box<dyn Parser<Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
Self: Sized + 'a,
self
) -> Box<dyn Parser<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<dyn Parser<&'input str, Output = (char, char), PartialState = ()> + 'input> where F: FnMut(char) -> bool + 'static { combine::parser::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'), "")));
fn left<R>(self) -> Either<Self, R> where
Self: Sized,
R: Parser<Input, Output = Self::Output>,
Self: Sized,
R: Parser<Input, Output = Self::Output>,
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(), "")));
fn right<L>(self) -> Either<L, Self> where
Self: Sized,
L: Parser<Input, Output = Self::Output>,
Self: Sized,
L: Parser<Input, Output = Self::Output>,
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(), "")));
Implementations on Foreign Types
impl<'a, Input: Stream, O> Parser<Input> for dyn FnMut(&mut Input) -> StdParseResult<O, Input> + 'a
[src]
type Output = O
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Input) -> ParseResult<O, Input::Error>
[src]
impl<Input, O> Parser<Input> for fn(_: &mut Input) -> StdParseResult<O, Input> where
Input: Stream,
[src]
Input: Stream,
type Output = O
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Input) -> ParseResult<O, Input::Error>
[src]
impl<Input: Stream, A> Parser<Input> for (A,) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
type Output = (A::Output,)
type PartialState = PartialState1<SequenceState<A::Output, A::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input: Stream, A, B> Parser<Input> for (A, B) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
type Output = (A::Output, B::Output)
type PartialState = PartialState2<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input: Stream, A, B, C> Parser<Input> for (A, B, C) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
type Output = (A::Output, B::Output, C::Output)
type PartialState = PartialState3<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input: Stream, A, B, C, D> Parser<Input> for (A, B, C, D) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
type Output = (A::Output, B::Output, C::Output, D::Output)
type PartialState = PartialState4<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input: Stream, A, B, C, D, E> Parser<Input> for (A, B, C, D, E) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
type Output = (A::Output, B::Output, C::Output, D::Output, E::Output)
type PartialState = PartialState5<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input: Stream, A, B, C, D, E, F> Parser<Input> for (A, B, C, D, E, F) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output)
type PartialState = PartialState6<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input: Stream, A, B, C, D, E, F, G> Parser<Input> for (A, B, C, D, E, F, G) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output)
type PartialState = PartialState7<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input: Stream, A, B, C, D, E, F, G, H> Parser<Input> for (A, B, C, D, E, F, G, H) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output)
type PartialState = PartialState8<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input: Stream, A, B, C, D, E, F, G, H, I> Parser<Input> for (A, B, C, D, E, F, G, H, I) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output)
type PartialState = PartialState9<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input: Stream, A, B, C, D, E, F, G, H, I, J> Parser<Input> for (A, B, C, D, E, F, G, H, I, J) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output)
type PartialState = PartialState10<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>, SequenceState<J::Output, J::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output)
type PartialState = PartialState11<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>, SequenceState<J::Output, J::PartialState>, SequenceState<K::Output, K::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
L: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
L: Parser<Input>,
type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output)
type PartialState = PartialState12<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>, SequenceState<J::Output, J::PartialState>, SequenceState<K::Output, K::PartialState>, SequenceState<L::Output, L::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L, M> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
L: Parser<Input>,
M: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
L: Parser<Input>,
M: Parser<Input>,
type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output)
type PartialState = PartialState13<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>, SequenceState<J::Output, J::PartialState>, SequenceState<K::Output, K::PartialState>, SequenceState<L::Output, L::PartialState>, SequenceState<M::Output, M::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L, M, N> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
L: Parser<Input>,
M: Parser<Input>,
N: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
L: Parser<Input>,
M: Parser<Input>,
N: Parser<Input>,
type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output)
type PartialState = PartialState14<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>, SequenceState<J::Output, J::PartialState>, SequenceState<K::Output, K::PartialState>, SequenceState<L::Output, L::PartialState>, SequenceState<M::Output, M::PartialState>, SequenceState<N::Output, N::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L, M, N, P> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, P) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
L: Parser<Input>,
M: Parser<Input>,
N: Parser<Input>,
P: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
L: Parser<Input>,
M: Parser<Input>,
N: Parser<Input>,
P: Parser<Input>,
type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, P::Output)
type PartialState = PartialState15<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>, SequenceState<J::Output, J::PartialState>, SequenceState<K::Output, K::PartialState>, SequenceState<L::Output, L::PartialState>, SequenceState<M::Output, M::PartialState>, SequenceState<N::Output, N::PartialState>, SequenceState<P::Output, P::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
L: Parser<Input>,
M: Parser<Input>,
N: Parser<Input>,
P: Parser<Input>,
Q: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
L: Parser<Input>,
M: Parser<Input>,
N: Parser<Input>,
P: Parser<Input>,
Q: Parser<Input>,
type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, P::Output, Q::Output)
type PartialState = PartialState16<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>, SequenceState<J::Output, J::PartialState>, SequenceState<K::Output, K::PartialState>, SequenceState<L::Output, L::PartialState>, SequenceState<M::Output, M::PartialState>, SequenceState<N::Output, N::PartialState>, SequenceState<P::Output, P::PartialState>, SequenceState<Q::Output, Q::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q, R> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q, R) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
L: Parser<Input>,
M: Parser<Input>,
N: Parser<Input>,
P: Parser<Input>,
Q: Parser<Input>,
R: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
L: Parser<Input>,
M: Parser<Input>,
N: Parser<Input>,
P: Parser<Input>,
Q: Parser<Input>,
R: Parser<Input>,
type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, P::Output, Q::Output, R::Output)
type PartialState = PartialState17<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>, SequenceState<J::Output, J::PartialState>, SequenceState<K::Output, K::PartialState>, SequenceState<L::Output, L::PartialState>, SequenceState<M::Output, M::PartialState>, SequenceState<N::Output, N::PartialState>, SequenceState<P::Output, P::PartialState>, SequenceState<Q::Output, Q::PartialState>, SequenceState<R::Output, R::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q, R, S> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q, R, S) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
L: Parser<Input>,
M: Parser<Input>,
N: Parser<Input>,
P: Parser<Input>,
Q: Parser<Input>,
R: Parser<Input>,
S: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
L: Parser<Input>,
M: Parser<Input>,
N: Parser<Input>,
P: Parser<Input>,
Q: Parser<Input>,
R: Parser<Input>,
S: Parser<Input>,
type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, P::Output, Q::Output, R::Output, S::Output)
type PartialState = PartialState18<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>, SequenceState<J::Output, J::PartialState>, SequenceState<K::Output, K::PartialState>, SequenceState<L::Output, L::PartialState>, SequenceState<M::Output, M::PartialState>, SequenceState<N::Output, N::PartialState>, SequenceState<P::Output, P::PartialState>, SequenceState<Q::Output, Q::PartialState>, SequenceState<R::Output, R::PartialState>, SequenceState<S::Output, S::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q, R, S, T> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q, R, S, T) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
L: Parser<Input>,
M: Parser<Input>,
N: Parser<Input>,
P: Parser<Input>,
Q: Parser<Input>,
R: Parser<Input>,
S: Parser<Input>,
T: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
L: Parser<Input>,
M: Parser<Input>,
N: Parser<Input>,
P: Parser<Input>,
Q: Parser<Input>,
R: Parser<Input>,
S: Parser<Input>,
T: Parser<Input>,
type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, P::Output, Q::Output, R::Output, S::Output, T::Output)
type PartialState = PartialState19<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>, SequenceState<J::Output, J::PartialState>, SequenceState<K::Output, K::PartialState>, SequenceState<L::Output, L::PartialState>, SequenceState<M::Output, M::PartialState>, SequenceState<N::Output, N::PartialState>, SequenceState<P::Output, P::PartialState>, SequenceState<Q::Output, Q::PartialState>, SequenceState<R::Output, R::PartialState>, SequenceState<S::Output, S::PartialState>, SequenceState<T::Output, T::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q, R, S, T, U> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q, R, S, T, U) where
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
L: Parser<Input>,
M: Parser<Input>,
N: Parser<Input>,
P: Parser<Input>,
Q: Parser<Input>,
R: Parser<Input>,
S: Parser<Input>,
T: Parser<Input>,
U: Parser<Input>,
[src]
Input: Stream,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
A: Parser<Input>,
B: Parser<Input>,
C: Parser<Input>,
D: Parser<Input>,
E: Parser<Input>,
F: Parser<Input>,
G: Parser<Input>,
H: Parser<Input>,
I: Parser<Input>,
J: Parser<Input>,
K: Parser<Input>,
L: Parser<Input>,
M: Parser<Input>,
N: Parser<Input>,
P: Parser<Input>,
Q: Parser<Input>,
R: Parser<Input>,
S: Parser<Input>,
T: Parser<Input>,
U: Parser<Input>,
type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, P::Output, Q::Output, R::Output, S::Output, T::Output, U::Output)
type PartialState = PartialState20<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>, SequenceState<J::Output, J::PartialState>, SequenceState<K::Output, K::PartialState>, SequenceState<L::Output, L::PartialState>, SequenceState<M::Output, M::PartialState>, SequenceState<N::Output, N::PartialState>, SequenceState<P::Output, P::PartialState>, SequenceState<Q::Output, Q::PartialState>, SequenceState<R::Output, R::PartialState>, SequenceState<S::Output, S::PartialState>, SequenceState<T::Output, T::PartialState>, SequenceState<U::Output, U::PartialState>>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<MODE>(
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
[src]
&mut self,
mode: MODE,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
MODE: ParseMode,
fn parser_count(&self) -> ErrorOffset
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<'a, P: ?Sized, Input> Parser<Input> for &'a mut P where
P: Parser<Input>,
Input: Stream,
[src]
P: Parser<Input>,
Input: Stream,
type Output = P::Output
type PartialState = P::PartialState
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
fn parser_count(&self) -> ErrorOffset
[src]
impl<P: ?Sized, Input> Parser<Input> for Box<P> where
P: Parser<Input>,
Input: Stream,
[src]
P: Parser<Input>,
Input: Stream,
type Output = P::Output
type PartialState = P::PartialState
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
fn parser_count(&self) -> ErrorOffset
[src]
Implementors
impl<'a, Input, F, G, R> Parser<Input> for CapturesMany<F, G, R, Input> where
F: FromIterator<Input::Range>,
G: FromIterator<F>,
R: Regex<Input::Range>,
Input: RangeStream,
Input::Range: Range,
[src]
F: FromIterator<Input::Range>,
G: FromIterator<F>,
R: Regex<Input::Range>,
Input: RangeStream,
Input::Range: Range,
type Output = G
type PartialState = ()
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<'a, Input, F, R> Parser<Input> for Captures<F, R, Input> where
F: FromIterator<Input::Range>,
R: Regex<Input::Range>,
Input: RangeStream,
Input::Range: Range,
[src]
F: FromIterator<Input::Range>,
R: Regex<Input::Range>,
Input: RangeStream,
Input::Range: Range,
type Output = F
type PartialState = ()
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<'a, Input, F, R> Parser<Input> for FindMany<F, R, Input> where
F: FromIterator<Input::Range>,
R: Regex<Input::Range>,
Input: RangeStream,
Input::Range: Range,
[src]
F: FromIterator<Input::Range>,
R: Regex<Input::Range>,
Input: RangeStream,
Input::Range: Range,
type Output = F
type PartialState = ()
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<'a, Input, R> Parser<Input> for Find<R, Input> where
R: Regex<Input::Range>,
Input: RangeStream,
Input::Range: Range,
[src]
R: Regex<Input::Range>,
Input: RangeStream,
Input::Range: Range,
type Output = Input::Range
type PartialState = ()
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<'a, Input, R> Parser<Input> for Match<R, Input> where
R: Regex<Input::Range>,
Input: RangeStream,
[src]
R: Regex<Input::Range>,
Input: RangeStream,
type Output = Input::Range
type PartialState = ()
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<'s, 'a, P, Q, I, J, F> Parser<I> for Iterate<F, J, P> where
P: FnMut(&J::Item, &mut I) -> Q,
Q: Parser<I>,
I: Stream,
J: IntoIterator + Clone,
F: Extend<Q::Output> + Default,
[src]
P: FnMut(&J::Item, &mut I) -> Q,
Q: Parser<I>,
I: Stream,
J: IntoIterator + Clone,
F: Extend<Q::Output> + Default,
type Output = F
type PartialState = (Option<Peekable<J::IntoIter>>, bool, F, Q::PartialState)
fn parse_partial(
&mut self,
input: &mut I,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <I as StreamOnce>::Error>
[src]
&mut self,
input: &mut I,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <I as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut I,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <I as StreamOnce>::Error>
[src]
&mut self,
input: &mut I,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <I as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut I,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, I::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut I,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, I::Error> where
M: ParseMode,
impl<F, Input, P> Parser<Input> for Count<F, Input, P> where
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
Input: Stream,
P: Parser<Input>,
F: Extend<P::Output> + Default,
[src]
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
Input: Stream,
P: Parser<Input>,
F: Extend<P::Output> + Default,
type Output = F
type PartialState = ()
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<F, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<F, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<F, Input, P> Parser<Input> for Many<F, P> where
Input: Stream,
P: Parser<Input>,
F: Extend<P::Output> + Default,
[src]
Input: Stream,
P: Parser<Input>,
F: Extend<P::Output> + Default,
type Output = F
type PartialState = (F, P::PartialState)
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
fn parser_count(&self) -> ErrorOffset
[src]
impl<F, Input, P> Parser<Input> for Many1<F, P> where
Input: Stream,
F: Extend<P::Output> + Default,
P: Parser<Input>,
[src]
Input: Stream,
F: Extend<P::Output> + Default,
P: Parser<Input>,
type Output = F
type PartialState = (bool, bool, F, P::PartialState)
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<F, Input::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<F, Input::Error> where
M: ParseMode,
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn parser_count(&self) -> ErrorOffset
[src]
impl<F, Input, P> Parser<Input> for TakeUntil<F, P> where
Input: Stream,
F: Extend<<Input as StreamOnce>::Token> + Default,
P: Parser<Input>,
[src]
Input: Stream,
F: Extend<<Input as StreamOnce>::Token> + Default,
P: Parser<Input>,
type Output = F
type PartialState = (F, P::PartialState)
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
impl<F, Input, P, E> Parser<Input> for RepeatUntil<F, P, E> where
Input: Stream,
F: Extend<P::Output> + Default,
P: Parser<Input>,
E: Parser<Input>,
[src]
Input: Stream,
F: Extend<P::Output> + Default,
P: Parser<Input>,
E: Parser<Input>,
type Output = F
type PartialState = (F, bool, P::PartialState, E::PartialState)
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
impl<F, Input, P, S> Parser<Input> for SepBy<F, P, S> where
Input: Stream,
F: Extend<P::Output> + Default,
P: Parser<Input>,
S: Parser<Input>,
[src]
Input: Stream,
F: Extend<P::Output> + Default,
P: Parser<Input>,
S: Parser<Input>,
type Output = F
type PartialState = <Or<SepBy1<F, P, S>, FnParser<Input, fn(_: &mut Input) -> StdParseResult<F, Input>>> as Parser<Input>>::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<F, Input::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<F, Input::Error> where
M: ParseMode,
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn parser_count(&self) -> ErrorOffset
[src]
impl<F, Input, P, S> Parser<Input> for SepBy1<F, P, S> where
Input: Stream,
F: Extend<P::Output> + Default,
P: Parser<Input>,
S: Parser<Input>,
[src]
Input: Stream,
F: Extend<P::Output> + Default,
P: Parser<Input>,
S: Parser<Input>,
type Output = F
type PartialState = (Option<Commit<()>>, F, <With<S, P> as Parser<Input>>::PartialState)
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn parser_count(&self) -> ErrorOffset
[src]
impl<F, Input, P, S> Parser<Input> for SepEndBy<F, P, S> where
Input: Stream,
F: Extend<P::Output> + Default,
P: Parser<Input>,
S: Parser<Input>,
[src]
Input: Stream,
F: Extend<P::Output> + Default,
P: Parser<Input>,
S: Parser<Input>,
type Output = F
type PartialState = <Or<SepEndBy1<F, P, S>, FnParser<Input, fn(_: &mut Input) -> StdParseResult<F, Input>>> as Parser<Input>>::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<F, Input, P, S> Parser<Input> for SepEndBy1<F, P, S> where
Input: Stream,
F: Extend<P::Output> + Default,
P: Parser<Input>,
S: Parser<Input>,
[src]
Input: Stream,
F: Extend<P::Output> + Default,
P: Parser<Input>,
S: Parser<Input>,
type Output = F
type PartialState = (Option<Commit<()>>, F, <With<S, Optional<P>> as Parser<Input>>::PartialState)
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<Input> Parser<Input> for TakeUntilByte<Input> where
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
Input: RangeStream,
Input::Range: AsRef<[u8]> + Range,
[src]
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
Input: RangeStream,
Input::Range: AsRef<[u8]> + Range,
type Output = Input::Range
type PartialState = ()
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Input::Range, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Input::Range, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input> Parser<Input> for TakeUntilByte2<Input> where
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
Input: RangeStream,
Input::Range: AsRef<[u8]> + Range,
[src]
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
Input: RangeStream,
Input::Range: AsRef<[u8]> + Range,
type Output = Input::Range
type PartialState = ()
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Input::Range, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Input::Range, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input> Parser<Input> for TakeUntilByte3<Input> where
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
Input: RangeStream,
Input::Range: AsRef<[u8]> + Range,
[src]
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
Input: RangeStream,
Input::Range: AsRef<[u8]> + Range,
type Output = Input::Range
type PartialState = ()
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Input::Range, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Input::Range, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input> Parser<Input> for Digit<Input> where
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
Input: Stream<Token = char>,
[src]
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
Input: Stream<Token = char>,
type Output = char
type PartialState = ()
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<char, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<char, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input> Parser<Input> for Range<Input> where
Input: RangeStream,
Input::Range: PartialEq + Range,
[src]
Input: RangeStream,
Input::Range: PartialEq + Range,
type Output = Input::Range
type PartialState = ()
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<Input> Parser<Input> for Take<Input> where
Input: RangeStream,
[src]
Input: RangeStream,
type Output = Input::Range
type PartialState = ()
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
impl<Input> Parser<Input> for TakeUntilRange<Input> where
Input: RangeStream,
Input::Range: PartialEq + Range,
[src]
Input: RangeStream,
Input::Range: PartialEq + Range,
type Output = Input::Range
type PartialState = usize
fn parse_partial(
&mut self,
input: &mut Input,
to_consume: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
to_consume: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
impl<Input> Parser<Input> for Any<Input> where
Input: Stream,
[src]
Input: Stream,
type Output = Input::Token
type PartialState = ()
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Input::Token, Input::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Input::Token, Input::Error>
impl<Input> Parser<Input> for Eof<Input> where
Input: Stream,
[src]
Input: Stream,
type Output = ()
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Input) -> ParseResult<(), Input::Error>
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<Input> Parser<Input> for Position<Input> where
Input: Stream,
[src]
Input: Stream,
type Output = Input::Position
type PartialState = ()
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Input::Position, Input::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Input::Position, Input::Error>
impl<Input> Parser<Input> for Token<Input> where
Input: Stream,
Input::Token: PartialEq + Clone,
[src]
Input: Stream,
Input::Token: PartialEq + Clone,
type Output = Input::Token
type PartialState = ()
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Input::Token, Input::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Input::Token, Input::Error>
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<Input, A, B, P, F> Parser<Input> for FlatMap<P, F> where
Input: Stream,
P: Parser<Input, Output = A>,
F: FnMut(A) -> Result<B, Input::Error>,
[src]
Input: Stream,
P: Parser<Input, Output = A>,
F: FnMut(A) -> Result<B, Input::Error>,
type Output = B
type PartialState = P::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
fn parser_count(&self) -> ErrorOffset
[src]
impl<Input, A, B, P, F> Parser<Input> for Map<P, F> where
Input: Stream,
P: Parser<Input, Output = A>,
F: FnMut(A) -> B,
[src]
Input: Stream,
P: Parser<Input, Output = A>,
F: FnMut(A) -> B,
type Output = B
type PartialState = P::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
fn parser_count(&self) -> ErrorOffset
[src]
impl<Input, A, B, P, F> Parser<Input> for MapInput<P, F> where
Input: Stream,
P: Parser<Input, Output = A>,
F: FnMut(A, &mut Input) -> B,
[src]
Input: Stream,
P: Parser<Input, Output = A>,
F: FnMut(A, &mut Input) -> B,
type Output = B
type PartialState = P::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
fn parser_count(&self) -> ErrorOffset
[src]
impl<Input, C, E, T> Parser<Input> for Tokens<C, E, T, Input> where
C: FnMut(T::Item, Input::Token) -> bool,
E: for<'s> ErrorInfo<'s, Input::Token, Input::Range>,
T: Clone + IntoIterator,
Input: Stream,
[src]
C: FnMut(T::Item, Input::Token) -> bool,
E: for<'s> ErrorInfo<'s, Input::Token, Input::Range>,
T: Clone + IntoIterator,
Input: Stream,
type Output = T
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Input) -> ParseResult<T, Input::Error>
[src]
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<Input, C, T> Parser<Input> for TokensCmp<C, T, Input> where
C: FnMut(T::Item, Input::Token) -> bool,
T: Clone + IntoIterator,
Input: Stream,
[src]
C: FnMut(T::Item, Input::Token) -> bool,
T: Clone + IntoIterator,
Input: Stream,
type Output = T
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Input) -> ParseResult<T, Input::Error>
[src]
impl<Input, E, O> Parser<Input> for EnvParser<E, Input, O> where
E: Clone,
Input: Stream,
[src]
E: Clone,
Input: Stream,
type Output = O
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Input) -> ParseResult<O, Input::Error>
[src]
impl<Input, F> Parser<Input> for TakeWhile<Input, F> where
Input: RangeStream,
Input::Range: Range,
F: FnMut(Input::Token) -> bool,
[src]
Input: RangeStream,
Input::Range: Range,
F: FnMut(Input::Token) -> bool,
type Output = Input::Range
type PartialState = usize
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
impl<Input, F> Parser<Input> for TakeWhile1<Input, F> where
Input: RangeStream,
Input::Range: Range,
F: FnMut(Input::Token) -> bool,
[src]
Input: RangeStream,
Input::Range: Range,
F: FnMut(Input::Token) -> bool,
type Output = Input::Range
type PartialState = usize
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
impl<Input, F, O, S> Parser<Input> for Opaque<F, Input, O, S> where
Input: Stream,
S: Default,
F: FnMut(&mut dyn FnMut(&mut dyn Parser<Input, Output = O, PartialState = S>)),
[src]
Input: Stream,
S: Default,
F: FnMut(&mut dyn FnMut(&mut dyn Parser<Input, Output = O, PartialState = S>)),
type Output = O
type PartialState = S
fn parse_stream(
&mut self,
input: &mut Input
) -> ParseResult<O, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<O, <Input as StreamOnce>::Error>
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<O, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<O, <Input as StreamOnce>::Error>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, F, R> Parser<Input> for TakeFn<F, Input> where
F: FnMut(Input::Range) -> R,
R: Into<TakeRange>,
Input: RangeStream,
Input::Range: Range,
[src]
F: FnMut(Input::Range) -> R,
R: Into<TakeRange>,
Input: RangeStream,
Input::Range: Range,
type Output = Input::Range
type PartialState = usize
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode<M>(
&mut self,
mode: M,
input: &mut Input,
offset: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
offset: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
impl<Input, F, R> Parser<Input> for Produce<Input, F> where
Input: Stream,
F: FnMut() -> R,
[src]
Input: Stream,
F: FnMut() -> R,
type Output = R
type PartialState = ()
fn parse_lazy(&mut self, _: &mut Input) -> ParseResult<R, Input::Error>
[src]
impl<Input, InputInner, P, C> Parser<Input> for InputConverter<InputInner, P, C> where
Input: Stream,
InputInner: Stream,
P: Parser<InputInner>,
C: Converter<'c, Input, InputInner = InputInner>,
[src]
Input: Stream,
InputInner: Stream,
P: Parser<InputInner>,
C: Converter<'c, Input, InputInner = InputInner>,
type Output = P::Output
type PartialState = P::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
impl<Input, L, R> Parser<Input> for Either<L, R> where
Input: Stream,
L: Parser<Input>,
R: Parser<Input, Output = L::Output>,
[src]
Input: Stream,
L: Parser<Input>,
R: Parser<Input, Output = L::Output>,
type Output = L::Output
type PartialState = Option<Either<L::PartialState, R::PartialState>>
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<Input, L, R, P> Parser<Input> for Between<Input, L, R, P> where
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
Input: Stream,
L: Parser<Input>,
R: Parser<Input>,
P: Parser<Input>,
[src]
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
Input: Stream,
L: Parser<Input>,
R: Parser<Input>,
P: Parser<Input>,
type Output = P::Output
type PartialState = <Map<(L, P, R), fn(_: (L::Output, P::Output, R::Output)) -> P::Output> as Parser<Input>>::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<P::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<P::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, O, F> Parser<Input> for FnParser<Input, F> where
Input: Stream,
F: FnMut(&mut Input) -> StdParseResult<O, Input>,
[src]
Input: Stream,
F: FnMut(&mut Input) -> StdParseResult<O, Input>,
type Output = O
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Input) -> ParseResult<O, Input::Error>
[src]
impl<Input, O, P> Parser<Input> for FromStr<Input, O, P> where
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
P: Parser<Input>,
P::Output: StrLike,
O: FromStr,
O::Err: Display,
[src]
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
P: Parser<Input>,
P::Output: StrLike,
O: FromStr,
O::Err: Display,
type Output = O
type PartialState = P::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<O, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<O, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, O, P> Parser<Input> for LookAhead<P> where
Input: Stream,
P: Parser<Input, Output = O>,
[src]
Input: Stream,
P: Parser<Input, Output = O>,
type Output = O
type PartialState = ()
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<O, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<O, <Input as StreamOnce>::Error>
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
fn parser_count(&self) -> ErrorOffset
[src]
impl<Input, O, P> Parser<Input> for NotFollowedBy<P> where
Input: Stream,
P: Parser<Input, Output = O>,
[src]
Input: Stream,
P: Parser<Input, Output = O>,
type Output = ()
type PartialState = P::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, _errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
_error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
_error: &mut Tracked<<Input as StreamOnce>::Error>
)
fn parser_count(&self) -> ErrorOffset
[src]
impl<Input, O, P> Parser<Input> for Try<P> where
Input: Stream,
P: Parser<Input, Output = O>,
[src]
Input: Stream,
P: Parser<Input, Output = O>,
type Output = O
type PartialState = P::PartialState
fn parse_stream(
&mut self,
input: &mut Input
) -> ParseResult<O, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<O, <Input as StreamOnce>::Error>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_committed_mode<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
fn parser_count(&self) -> ErrorOffset
[src]
impl<Input, O, P, R> Parser<Input> for Factory<P, R> where
Input: Stream,
P: FnMut(&mut Input) -> R,
R: Parser<Input, Output = O>,
[src]
Input: Stream,
P: FnMut(&mut Input) -> R,
R: Parser<Input, Output = O>,
type Output = O
type PartialState = R::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, O, P, R> Parser<Input> for Lazy<P> where
Input: Stream,
P: FnMut() -> R,
R: Parser<Input, Output = O>,
[src]
Input: Stream,
P: FnMut() -> R,
R: Parser<Input, Output = O>,
type Output = O
type PartialState = R::PartialState
fn parse_stream(
&mut self,
input: &mut Input
) -> ParseResult<O, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<O, <Input as StreamOnce>::Error>
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<O, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<O, <Input as StreamOnce>::Error>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_committed_mode<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, O, P1, P2> Parser<Input> for Or<P1, P2> where
Input: Stream,
P1: Parser<Input, Output = O>,
P2: Parser<Input, Output = O>,
[src]
Input: Stream,
P1: Parser<Input, Output = O>,
P2: Parser<Input, Output = O>,
type Output = O
type PartialState = <Choice<(P1, P2)> as Parser<Input>>::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<Input, P> Parser<Input> for Choice<P> where
Input: Stream,
P: ChoiceParser<Input>,
[src]
Input: Stream,
P: ChoiceParser<Input>,
type Output = P::Output
type PartialState = P::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<Input, P> Parser<Input> for Optional<P> where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = Option<P::Output>
type PartialState = P::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn parser_count(&self) -> ErrorOffset
[src]
impl<Input, P> Parser<Input> for AnyPartialStateParser<P> where
Input: Stream,
P: Parser<Input>,
P::PartialState: 'static,
[src]
Input: Stream,
P: Parser<Input>,
P::PartialState: 'static,
type Output = P::Output
type PartialState = AnyPartialState
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
fn parser_count(&self) -> ErrorOffset
[src]
impl<Input, P> Parser<Input> for AnySendPartialStateParser<P> where
Input: Stream,
P: Parser<Input>,
P::PartialState: Send + 'static,
[src]
Input: Stream,
P: Parser<Input>,
P::PartialState: Send + 'static,
type Output = P::Output
type PartialState = AnySendPartialState
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
fn parser_count(&self) -> ErrorOffset
[src]
impl<Input, P> Parser<Input> for Ignore<P> where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = ()
type PartialState = P::PartialState
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
fn parser_count(&self) -> ErrorOffset
[src]
impl<Input, P> Parser<Input> for NoPartial<P> where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = <P as Parser<Input>>::Output
type PartialState = ()
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
_mode: M,
input: &mut Input,
_state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
_mode: M,
input: &mut Input,
_state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
fn parser_count(&self) -> ErrorOffset
[src]
impl<Input, P> Parser<Input> for Silent<P> where
P: Parser<Input>,
Input: Stream,
[src]
P: Parser<Input>,
Input: Stream,
type Output = P::Output
type PartialState = P::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, _errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
_errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
_errors: &mut Tracked<<Input as StreamOnce>::Error>
)
fn parser_count(&self) -> ErrorOffset
[src]
impl<Input, P> Parser<Input> for combine::parser::range::Recognize<Input, P> where
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
P: Parser<Input>,
Input: RangeStream,
<Input as StreamOnce>::Range: Range,
[src]
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
P: Parser<Input>,
Input: RangeStream,
<Input as StreamOnce>::Range: Range,
type Output = <Input as StreamOnce>::Range
type PartialState = <RecognizeWithValue<P> as Parser<Input>>::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<<Input as StreamOnce>::Range, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<<Input as StreamOnce>::Range, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> Parser<Input> for RecognizeWithValue<P> where
P: Parser<Input>,
Input: RangeStream,
<Input as StreamOnce>::Range: Range,
[src]
P: Parser<Input>,
Input: RangeStream,
<Input as StreamOnce>::Range: Range,
type Output = (<Input as StreamOnce>::Range, P::Output)
type PartialState = (usize, P::PartialState)
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<Input, P> Parser<Input> for SkipCount<Input, P> where
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
P: Parser<Input>,
[src]
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
P: Parser<Input>,
type Output = ()
type PartialState = <With<Count<Sink, Input, P>, Value<Input, ()>> as Parser<Input>>::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<(), <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<(), <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> Parser<Input> for SkipCountMinMax<Input, P> where
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
P: Parser<Input>,
[src]
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
P: Parser<Input>,
type Output = ()
type PartialState = <With<CountMinMax<Sink, P>, Value<Input, ()>> as Parser<Input>>::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<(), <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<(), <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> Parser<Input> for SkipMany<Input, P> where
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
P: Parser<Input>,
[src]
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
P: Parser<Input>,
type Output = ()
type PartialState = <Ignore<Many<Sink, Ignore<P>>> as Parser<Input>>::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<(), <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<(), <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> Parser<Input> for SkipMany1<Input, P> where
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
P: Parser<Input>,
[src]
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
P: Parser<Input>,
type Output = ()
type PartialState = <Ignore<Many1<Sink, Ignore<P>>> as Parser<Input>>::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<(), <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<(), <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> Parser<Input> for SkipUntil<Input, P> where
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
P: Parser<Input>,
[src]
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
P: Parser<Input>,
type Output = ()
type PartialState = <With<TakeUntil<Sink, P>, Value<Input, ()>> as Parser<Input>>::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<(), <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<(), <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> Parser<Input> for Satisfy<Input, P> where
Input: Stream,
P: FnMut(Input::Token) -> bool,
[src]
Input: Stream,
P: FnMut(Input::Token) -> bool,
type Output = Input::Token
type PartialState = ()
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, Input::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, Input::Error>
impl<Input, P, E> Parser<Input> for SkipRepeatUntil<Input, P, E> where
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
P: Parser<Input>,
E: Parser<Input>,
[src]
<Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
Input: Stream,
P: Parser<Input>,
E: Parser<Input>,
type Output = ()
type PartialState = <With<RepeatUntil<Sink, P, E>, Value<Input, ()>> as Parser<Input>>::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<(), <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<(), <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
errors: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P, F> Parser<Input> for combine::parser::combinator::Recognize<F, P> where
Input: Stream,
P: Parser<Input>,
F: Default + Extend<<Input as StreamOnce>::Token>,
[src]
Input: Stream,
P: Parser<Input>,
F: Default + Extend<<Input as StreamOnce>::Token>,
type Output = F
type PartialState = (F, P::PartialState)
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<Input, P, F> Parser<Input> for CountMinMax<F, P> where
Input: Stream,
P: Parser<Input>,
F: Extend<P::Output> + Default,
[src]
Input: Stream,
P: Parser<Input>,
F: Extend<P::Output> + Default,
type Output = F
type PartialState = (usize, F, P::PartialState)
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<Input, P, F, O, E> Parser<Input> for AndThen<P, F> where
Input: Stream,
P: Parser<Input>,
F: FnMut(P::Output) -> Result<O, E>,
E: Into<<Input::Error as ParseError<Input::Token, Input::Range, Input::Position>>::StreamError>,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
[src]
Input: Stream,
P: Parser<Input>,
F: FnMut(P::Output) -> Result<O, E>,
E: Into<<Input::Error as ParseError<Input::Token, Input::Range, Input::Position>>::StreamError>,
Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
type Output = O
type PartialState = P::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
fn parser_count(&self) -> ErrorOffset
[src]
impl<Input, P, N, F> Parser<Input> for Then<P, F> where
Input: Stream,
F: FnMut(P::Output) -> N,
P: Parser<Input>,
N: Parser<Input>,
[src]
Input: Stream,
F: FnMut(P::Output) -> N,
P: Parser<Input>,
N: Parser<Input>,
type Output = N::Output
type PartialState = (P::PartialState, Option<(bool, N)>, N::PartialState)
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<Input, P, N, F> Parser<Input> for ThenPartial<P, F> where
Input: Stream,
F: FnMut(&mut P::Output) -> N,
P: Parser<Input>,
N: Parser<Input>,
[src]
Input: Stream,
F: FnMut(&mut P::Output) -> N,
P: Parser<Input>,
N: Parser<Input>,
type Output = N::Output
type PartialState = (P::PartialState, Option<(bool, P::Output)>, N::PartialState)
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<Input, P, Op> Parser<Input> for Chainl1<P, Op> where
Input: Stream,
P: Parser<Input>,
Op: Parser<Input>,
Op::Output: FnOnce(P::Output, P::Output) -> P::Output,
[src]
Input: Stream,
P: Parser<Input>,
Op: Parser<Input>,
Op::Output: FnOnce(P::Output, P::Output) -> P::Output,
type Output = P::Output
type PartialState = (Option<(P::Output, Commit<()>)>, <(Op, P) as Parser<Input>>::PartialState)
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<Input, P, Op> Parser<Input> for Chainr1<P, Op> where
Input: Stream,
P: Parser<Input>,
Op: Parser<Input>,
Op::Output: FnOnce(P::Output, P::Output) -> P::Output,
[src]
Input: Stream,
P: Parser<Input>,
Op: Parser<Input>,
Op::Output: FnOnce(P::Output, P::Output) -> P::Output,
type Output = P::Output
type PartialState = ()
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<P::Output, Input::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<P::Output, Input::Error>
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<Input, P, Q> Parser<Input> for Escaped<P, Q, Input::Token> where
Input: Stream,
P: Parser<Input>,
<Input as StreamOnce>::Token: PartialEq,
Q: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
<Input as StreamOnce>::Token: PartialEq,
Q: Parser<Input>,
type Output = ()
type PartialState = EscapedState<P::PartialState, Q::PartialState>
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, Input::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, Input::Error>
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<Input, P, R> Parser<Input> for SatisfyMap<Input, P> where
Input: Stream,
P: FnMut(Input::Token) -> Option<R>,
[src]
Input: Stream,
P: FnMut(Input::Token) -> Option<R>,
type Output = R
type PartialState = ()
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, Input::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, Input::Error>
impl<Input, P, S> Parser<Input> for Expected<P, S> where
P: Parser<Input>,
Input: Stream,
S: for<'s> ErrorInfo<'s, Input::Token, Input::Range>,
[src]
P: Parser<Input>,
Input: Stream,
S: for<'s> ErrorInfo<'s, Input::Token, Input::Range>,
type Output = P::Output
type PartialState = P::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn parser_count(&self) -> ErrorOffset
[src]
fn add_committed_expected_error(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P, S> Parser<Input> for Message<P, S> where
Input: Stream,
P: Parser<Input>,
S: for<'s> ErrorInfo<'s, Input::Token, Input::Range>,
[src]
Input: Stream,
P: Parser<Input>,
S: for<'s> ErrorInfo<'s, Input::Token, Input::Range>,
type Output = P::Output
type PartialState = P::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn parser_count(&self) -> ErrorOffset
[src]
fn add_committed_expected_error(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P1, P2> Parser<Input> for Skip<P1, P2> where
Input: Stream,
P1: Parser<Input>,
P2: Parser<Input>,
[src]
Input: Stream,
P1: Parser<Input>,
P2: Parser<Input>,
type Output = P1::Output
type PartialState = <(P1, Ignore<P2>) as Parser<Input>>::PartialState
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
fn parser_count(&self) -> ErrorOffset
[src]
impl<Input, P1, P2> Parser<Input> for With<P1, P2> where
Input: Stream,
P1: Parser<Input>,
P2: Parser<Input>,
[src]
Input: Stream,
P1: Parser<Input>,
P2: Parser<Input>,
type Output = P2::Output
type PartialState = <(Ignore<P1>, P2) as Parser<Input>>::PartialState
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn add_committed_expected_error(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
fn parser_count(&self) -> ErrorOffset
[src]
impl<Input, T> Parser<Input> for NoneOf<T, Input> where
T: Clone + IntoIterator<Item = Input::Token>,
Input: Stream,
Input::Token: PartialEq,
[src]
T: Clone + IntoIterator<Item = Input::Token>,
Input: Stream,
Input::Token: PartialEq,
type Output = Input::Token
type PartialState = ()
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Input::Token, Input::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Input::Token, Input::Error>
impl<Input, T> Parser<Input> for OneOf<T, Input> where
T: Clone + IntoIterator<Item = Input::Token>,
Input: Stream,
Input::Token: PartialEq,
[src]
T: Clone + IntoIterator<Item = Input::Token>,
Input: Stream,
Input::Token: PartialEq,
type Output = Input::Token
type PartialState = ()
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Input::Token, Input::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Input::Token, Input::Error>
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
impl<Input, T> Parser<Input> for Value<Input, T> where
Input: Stream,
T: Clone,
[src]
Input: Stream,
T: Clone,
type Output = T
type PartialState = ()
fn parse_lazy(&mut self, _: &mut Input) -> ParseResult<T, Input::Error>
[src]
impl<Input, T, E> Parser<Input> for Unexpected<Input, T, E> where
Input: Stream,
E: for<'s> ErrorInfo<'s, Input::Token, Input::Range>,
[src]
Input: Stream,
E: for<'s> ErrorInfo<'s, Input::Token, Input::Range>,
type Output = T
type PartialState = ()
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<T, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<T, <Input as StreamOnce>::Error>