[−][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_consumed
, or parse_lazy
. If the last is implemented, an
implementation of add_error
may also be required. See the documentation for
parse_lazy
for details.
Associated Types
type Input: Stream
The type which is taken as input for the parser. The type must implement the Stream
trait
which allows the parser to read items from the type.
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 easy_parse<I>(
&mut self,
input: I
) -> Result<(Self::Output, I), ParseError<I>> where
I: Stream,
Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
I::Position: Default,
Self: Sized + Parser<Input = Stream<I>>,
&mut self,
input: I
) -> Result<(Self::Output, I), ParseError<I>> where
I: Stream,
Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
I::Position: Default,
Self: Sized + Parser<Input = Stream<I>>,
Entry point of the parser. Takes some input and tries to parse it, returning an easy to use and format error if parsing did not succeed.
Returns the parsed result and the remaining input if the parser succeeds, or a
This function wraps requires Self::Input == easy::Stream<I>
which makes it return
return easy::Errors
if an error occurs. Due to this wrapping it is recommended that the
parser Self
is written with a generic input type.
use combine::{Parser, Stream}; use combine::parser::repeat::many1; use combine::parser::char::letter; // Good! parser!{ fn my_parser[I]()(I) -> String where [I: Stream<Item=char>] { many1(letter()) } } // Won't compile with `easy_parse` since it is specialized on `&str` parser!{ fn my_parser2['a]()(&'a str) -> String { many1(letter()) } } fn main() { assert_eq!(my_parser().parse("abc"), Ok(("abc".to_string(), ""))); // Would fail to compile if uncommented // my_parser2().parse("abc") }
fn parse(
&mut self,
input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>
&mut self,
input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>
Entry point of the parser. Takes some input and tries to parse it.
Returns the parsed result and the remaining input if the parser succeeds, or a error otherwise.
This is the most straightforward entry point to a parser. Since it does not decorate the
input in any way you may find the error messages a hard to read. If that is the case you
may want to try wrapping your input with an easy::Stream
or call easy_parse
instead.
fn parse_with_state(
&mut self,
input: &mut Self::Input,
state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>
&mut self,
input: &mut Self::Input,
state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>
Entry point of the parser when using partial parsing. Takes some input and tries to parse it.
Returns the parsed result and the remaining input if the parser succeeds, or a error otherwise.
fn parse_stream(
&mut self,
input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>
&mut self,
input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>
Parses using the stream input
by calling Stream::uncons
one or more times.
On success returns Ok((value, new_state))
, and on failure returns Err(error)
.
Furthermore new_state
and error
are wrapped in Consumed
, providing information on
whether this parser consumed any input data or not.
fn parse_stream_consumed(
&mut self,
input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>
&mut self,
input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>
Parses using the stream input
by calling Stream::uncons
one or more times.
Semantically equivalent to parse_stream
, except this method returns a flattened result
type, combining Result
and Consumed
into a single FastResult
.
fn parse_stream_consumed_partial(
&mut self,
input: &mut Self::Input,
state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>
&mut self,
input: &mut Self::Input,
state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>
fn parse_lazy(
&mut self,
input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>
&mut self,
input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>
Parses using the stream input
by calling Stream::uncons
one or more times.
Specialized version of parse_stream_consumed
which permits error value creation to be
skipped in the common case.
When this parser returns EmptyErr
, this method is allowed to return an empty
Error
. The error value that would have been returned can instead be obtained by
calling add_error
. This allows a parent parser such as choice
to skip the creation of
an unnecessary error value, if an alternative parser succeeds.
External callers should never have to call this function directly.
Parsers should seek to implement this function instead of the above two if errors can be
encountered before consuming input. The default implementation always returns all errors,
with add_error
being a no-op.
fn parse_first(
&mut self,
input: &mut Self::Input,
state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>
&mut self,
input: &mut Self::Input,
state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>
Parses using the stream input
and allows itself to be resumed at a later point using
parse_partial
by storing the necessary intermediate state in state
.
Unlike parse_partial
function this is allowed to assume that there is no partial state to
resume.
fn parse_partial(
&mut self,
input: &mut Self::Input,
state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>
&mut self,
input: &mut Self::Input,
state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>
Parses using the stream input
and allows itself to be resumed at a later point using
parse_partial
by storing the necessary intermediate state in state
fn add_error(
&mut self,
_error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)
&mut self,
_error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)
Adds the first error that would normally be returned by this parser if it failed with an
EmptyErr
result.
See parse_lazy
for details.
fn 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) -> ParseResult<(char, char), &'static str> { let mut p = digit(); let ((d, _), consumed) = try!((p.by_ref(), letter()).parse_stream(input)); let (d2, consumed) = try!(consumed.combine(|_| p.parse_stream(input))); Ok(((d, d2), consumed)) } fn main() { let mut input = "1a23"; assert_eq!( test(&mut input).map(|(t, c)| (t, c.map(|_| input))), Ok((('1', '2'), Consumed::Consumed("3"))) ); }
fn with<P2>(self, p: P2) -> With<Self, P2> where
Self: Sized,
P2: Parser<Input = Self::Input>,
Self: Sized,
P2: Parser<Input = Self::Input>,
Discards the value of the self
parser and returns the value of p
.
Fails if any of the parsers fails.
let result = digit() .with(token('i')) .parse("9i") .map(|x| x.0); assert_eq!(result, Ok('i'));
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
Self: Sized,
P2: Parser<Input = Self::Input>,
Self: Sized,
P2: Parser<Input = Self::Input>,
Discards the value of the p
parser and returns the value of self
.
Fails if any of the parsers fails.
let result = digit() .skip(token('i')) .parse("9i") .map(|x| x.0); assert_eq!(result, Ok('9'));
fn and<P2>(self, p: P2) -> (Self, P2) where
Self: Sized,
P2: Parser<Input = Self::Input>,
Self: Sized,
P2: Parser<Input = Self::Input>,
Parses with self
followed by p
.
Succeeds if both parsers succeed, otherwise fails.
Returns a tuple with both values on success.
let result = digit() .and(token('i')) .parse("9i") .map(|x| x.0); assert_eq!(result, Ok(('9', 'i')));
fn or<P2>(self, p: P2) -> Or<Self, P2> where
Self: Sized,
P2: Parser<Input = Self::Input, Output = Self::Output>,
Self: Sized,
P2: Parser<Input = Self::Input, Output = Self::Output>,
Returns a parser which attempts to parse using self
. If self
fails without consuming
any input it tries to consume the same input using p
.
If you are looking to chain 3 or more parsers using or
you may consider using the
choice!
macro instead, which can be clearer and may result in a faster parser.
let mut parser = string("let") .or(digit().map(|_| "digit")) .or(string("led")); assert_eq!(parser.parse("let"), Ok(("let", ""))); assert_eq!(parser.parse("1"), Ok(("digit", ""))); assert!(parser.parse("led").is_err()); let mut parser2 = string("two").or(string("three")); // Fails as the parser for "two" consumes the first 't' before failing assert!(parser2.parse("three").is_err()); // Use 'attempt' to make failing parsers always act as if they have not consumed any input let mut parser3 = attempt(string("two")).or(attempt(string("three"))); assert_eq!(parser3.parse("three"), Ok(("three", "")));
fn then<N, F>(self, f: F) -> Then<Self, F> where
Self: Sized,
F: FnMut(Self::Output) -> N,
N: Parser<Input = Self::Input>,
Self: Sized,
F: FnMut(Self::Output) -> N,
N: Parser<Input = Self::Input>,
Parses using self
and then passes the value to f
which returns a parser used to parse
the rest of the input.
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::Input>,
Self: Sized,
F: FnMut(&mut Self::Output) -> N,
N: Parser<Input = Self::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 flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
Self: Sized,
F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>,
Self: Sized,
F: FnMut(Self::Output) -> Result<B, <Self::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> where
Self: Sized,
S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>,
Self: Sized,
S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>,
Parses with self
and if it fails, adds the message msg
to the error.
let result = token('9') .message("Not a nine") .easy_parse(State::new("8")); assert_eq!(result, Err(easy::Errors { position: SourcePosition::default(), errors: vec![ easy::Error::Unexpected('8'.into()), easy::Error::Expected('9'.into()), easy::Error::Message("Not a nine".into()) ] }));
fn expected<S>(self, msg: S) -> Expected<Self> where
Self: Sized,
S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>,
Self: Sized,
S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>,
Parses with self
and if it fails without consuming any input any expected errors are
replaced by msg
. msg
is then used in error messages as "Expected msg
".
let result = token('9') .expected("nine") .easy_parse(State::new("8")); assert_eq!(result, Err(easy::Errors { position: SourcePosition::default(), errors: vec![ easy::Error::Unexpected('8'.into()), easy::Error::Expected("nine".into()) ] }));
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(State::new("8")); assert_eq!(result, Err(easy::Errors { position: SourcePosition::default(), errors: vec![ easy::Error::Unexpected('8'.into()), ] }));
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
Self: Parser<Input = I> + Sized,
F: FnMut(Self::Output) -> Result<O, E>,
I: Stream,
E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>,
Self: Parser<Input = I> + Sized,
F: FnMut(Self::Output) -> Result<O, E>,
I: Stream,
E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>,
Parses with self
and applies f
on the result if self
parses successfully.
f
may optionally fail with an error which is automatically converted to a ParseError
.
let mut parser = many1(digit()) .and_then(|s: String| s.parse::<i32>()); let result = parser.easy_parse(State::new("1234")).map(|(x, state)| (x, state.input)); assert_eq!(result, Ok((1234, ""))); let result = parser.easy_parse(State::new("999999999999999999999999")); assert!(result.is_err()); // Errors are report as if they occurred at the start of the parse assert_eq!(result.unwrap_err().position, SourcePosition { line: 1, column: 1 });
fn iter(
self,
input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
Self: Parser + Sized,
self,
input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
Self: Parser + 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], "")));
fn partial_iter<'a, 's, M>(
self,
mode: M,
input: &'a mut Self::Input,
partial_state: &'s mut Self::PartialState
) -> Iter<'a, Self, &'s mut Self::PartialState, M> where
Self: Parser + Sized,
M: ParseMode,
self,
mode: M,
input: &'a mut Self::Input,
partial_state: &'s mut Self::PartialState
) -> Iter<'a, Self, &'s mut Self::PartialState, M> where
Self: Parser + 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], "")));
fn boxed<'a>(
self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
Self: Sized + 'a,
self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
Self: Sized + 'a,
Turns the parser into a trait object by putting it in a Box
. Can be used to easily
return parsers from functions without naming the type.
fn test<'input, F>( c: char, f: F) -> Box<Parser<Input = &'input str, Output = (char, char), PartialState = ()>> where F: FnMut(char) -> bool + 'static { ::combine::combinator::no_partial((token(c), satisfy(f))).boxed() } let result = test('a', |c| c >= 'a' && c <= 'f') .parse("ac"); assert_eq!(result, Ok((('a', 'c'), "")));
fn left<R>(self) -> Either<Self, R> where
Self: Sized,
R: Parser<Input = Self::Input, Output = Self::Output>,
Self: Sized,
R: Parser<Input = Self::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 = Self::Input, Output = Self::Output>,
Self: Sized,
L: Parser<Input = Self::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<L, R> Parser for Either<L, R> where
L: Parser,
R: Parser<Input = L::Input, Output = L::Output>,
[src]
impl<L, R> Parser for Either<L, R> where
L: Parser,
R: Parser<Input = L::Input, Output = L::Output>,
type Input = L::Input
type Output = L::Output
type PartialState = Option<Either<L::PartialState, R::PartialState>>
fn parse_lazy( | [src] |
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<'a, I: Stream, O> Parser for dyn FnMut(&mut I) -> ParseResult<O, I> + 'a
[src]
impl<'a, I: Stream, O> Parser for dyn FnMut(&mut I) -> ParseResult<O, I> + 'a
type Input = I
type Output = O
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Self::Input) -> ConsumedResult<O, I> | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, O> Parser for fn(_: &mut I) -> ParseResult<O, I> where
I: Stream,
[src]
impl<I, O> Parser for fn(_: &mut I) -> ParseResult<O, I> where
I: Stream,
type Input = I
type Output = O
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Self::Input) -> ConsumedResult<O, I> | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<Input: Stream, A> Parser for (A,) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
[src]
impl<Input: Stream, A> Parser for (A,) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
type Input = Input
type Output = (A::Output,)
type PartialState = PartialState1<SequenceState<A::Output, A::PartialState>>
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn add_error( | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<Input: Stream, A, B> Parser for (A, B) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
[src]
impl<Input: Stream, A, B> Parser for (A, B) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
type Input = Input
type Output = (A::Output, B::Output)
type PartialState = PartialState2<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>>
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn add_error( | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<Input: Stream, A, B, C> Parser for (A, B, C) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
[src]
impl<Input: Stream, A, B, C> Parser for (A, B, C) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
type Input = 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( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn add_error( | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<Input: Stream, A, B, C, D> Parser for (A, B, C, D) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
D: Parser<Input = Input>,
[src]
impl<Input: Stream, A, B, C, D> Parser for (A, B, C, D) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
D: Parser<Input = Input>,
type Input = 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( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn add_error( | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<Input: Stream, A, B, C, D, E> Parser for (A, B, C, D, E) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
D: Parser<Input = Input>,
E: Parser<Input = Input>,
[src]
impl<Input: Stream, A, B, C, D, E> Parser for (A, B, C, D, E) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
D: Parser<Input = Input>,
E: Parser<Input = Input>,
type Input = 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( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn add_error( | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<Input: Stream, A, B, C, D, E, F> Parser for (A, B, C, D, E, F) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
D: Parser<Input = Input>,
E: Parser<Input = Input>,
F: Parser<Input = Input>,
[src]
impl<Input: Stream, A, B, C, D, E, F> Parser for (A, B, C, D, E, F) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
D: Parser<Input = Input>,
E: Parser<Input = Input>,
F: Parser<Input = Input>,
type Input = 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( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn add_error( | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<Input: Stream, A, B, C, D, E, F, G> Parser for (A, B, C, D, E, F, G) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
D: Parser<Input = Input>,
E: Parser<Input = Input>,
F: Parser<Input = Input>,
G: Parser<Input = Input>,
[src]
impl<Input: Stream, A, B, C, D, E, F, G> Parser for (A, B, C, D, E, F, G) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
D: Parser<Input = Input>,
E: Parser<Input = Input>,
F: Parser<Input = Input>,
G: Parser<Input = Input>,
type Input = 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( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn add_error( | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<Input: Stream, A, B, C, D, E, F, G, H> Parser for (A, B, C, D, E, F, G, H) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
D: Parser<Input = Input>,
E: Parser<Input = Input>,
F: Parser<Input = Input>,
G: Parser<Input = Input>,
H: Parser<Input = Input>,
[src]
impl<Input: Stream, A, B, C, D, E, F, G, H> Parser for (A, B, C, D, E, F, G, H) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
D: Parser<Input = Input>,
E: Parser<Input = Input>,
F: Parser<Input = Input>,
G: Parser<Input = Input>,
H: Parser<Input = Input>,
type Input = 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( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn add_error( | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<Input: Stream, A, B, C, D, E, F, G, H, I> Parser for (A, B, C, D, E, F, G, H, I) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
D: Parser<Input = Input>,
E: Parser<Input = Input>,
F: Parser<Input = Input>,
G: Parser<Input = Input>,
H: Parser<Input = Input>,
I: Parser<Input = Input>,
[src]
impl<Input: Stream, A, B, C, D, E, F, G, H, I> Parser for (A, B, C, D, E, F, G, H, I) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
D: Parser<Input = Input>,
E: Parser<Input = Input>,
F: Parser<Input = Input>,
G: Parser<Input = Input>,
H: Parser<Input = Input>,
I: Parser<Input = Input>,
type Input = 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( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn add_error( | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<Input: Stream, A, B, C, D, E, F, G, H, I, J> Parser for (A, B, C, D, E, F, G, H, I, J) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
D: Parser<Input = Input>,
E: Parser<Input = Input>,
F: Parser<Input = Input>,
G: Parser<Input = Input>,
H: Parser<Input = Input>,
I: Parser<Input = Input>,
J: Parser<Input = Input>,
[src]
impl<Input: Stream, A, B, C, D, E, F, G, H, I, J> Parser for (A, B, C, D, E, F, G, H, I, J) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
D: Parser<Input = Input>,
E: Parser<Input = Input>,
F: Parser<Input = Input>,
G: Parser<Input = Input>,
H: Parser<Input = Input>,
I: Parser<Input = Input>,
J: Parser<Input = Input>,
type Input = 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( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn add_error( | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K> Parser for (A, B, C, D, E, F, G, H, I, J, K) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
D: Parser<Input = Input>,
E: Parser<Input = Input>,
F: Parser<Input = Input>,
G: Parser<Input = Input>,
H: Parser<Input = Input>,
I: Parser<Input = Input>,
J: Parser<Input = Input>,
K: Parser<Input = Input>,
[src]
impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K> Parser for (A, B, C, D, E, F, G, H, I, J, K) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
D: Parser<Input = Input>,
E: Parser<Input = Input>,
F: Parser<Input = Input>,
G: Parser<Input = Input>,
H: Parser<Input = Input>,
I: Parser<Input = Input>,
J: Parser<Input = Input>,
K: Parser<Input = Input>,
type Input = 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( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn add_error( | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L> Parser for (A, B, C, D, E, F, G, H, I, J, K, L) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
D: Parser<Input = Input>,
E: Parser<Input = Input>,
F: Parser<Input = Input>,
G: Parser<Input = Input>,
H: Parser<Input = Input>,
I: Parser<Input = Input>,
J: Parser<Input = Input>,
K: Parser<Input = Input>,
L: Parser<Input = Input>,
[src]
impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L> Parser for (A, B, C, D, E, F, G, H, I, J, K, L) where
Input: Stream,
Input::Error: ParseError<Input::Item, Input::Range, Input::Position>,
A: Parser<Input = Input>,
B: Parser<Input = Input>,
C: Parser<Input = Input>,
D: Parser<Input = Input>,
E: Parser<Input = Input>,
F: Parser<Input = Input>,
G: Parser<Input = Input>,
H: Parser<Input = Input>,
I: Parser<Input = Input>,
J: Parser<Input = Input>,
K: Parser<Input = Input>,
L: Parser<Input = Input>,
type Input = 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( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn add_error( | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<'a, P: ?Sized> Parser for &'a mut P where
P: Parser,
[src]
impl<'a, P: ?Sized> Parser for &'a mut P where
P: Parser,
type Input = P::Input
type Output = P::Output
type PartialState = P::PartialState
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P: ?Sized> Parser for Box<P> where
P: Parser,
[src]
impl<P: ?Sized> Parser for Box<P> where
P: Parser,
type Input = P::Input
type Output = P::Output
type PartialState = P::PartialState
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
Implementors
impl<'a, B, I> Parser for F32<B, I> where
I: Stream<Item = u8>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
B: ByteOrder,
[src]
impl<'a, B, I> Parser for F32<B, I> where
I: Stream<Item = u8>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
B: ByteOrder,
type Input = I
type Output = f32
type PartialState = ()
fn parse_lazy( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<'a, B, I> Parser for F64<B, I> where
I: Stream<Item = u8>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
B: ByteOrder,
[src]
impl<'a, B, I> Parser for F64<B, I> where
I: Stream<Item = u8>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
B: ByteOrder,
type Input = I
type Output = f64
type PartialState = ()
fn parse_lazy( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<'a, B, I> Parser for I16<B, I> where
I: Stream<Item = u8>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
B: ByteOrder,
[src]
impl<'a, B, I> Parser for I16<B, I> where
I: Stream<Item = u8>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
B: ByteOrder,
type Input = I
type Output = i16
type PartialState = ()
fn parse_lazy( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<'a, B, I> Parser for I32<B, I> where
I: Stream<Item = u8>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
B: ByteOrder,
[src]
impl<'a, B, I> Parser for I32<B, I> where
I: Stream<Item = u8>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
B: ByteOrder,
type Input = I
type Output = i32
type PartialState = ()
fn parse_lazy( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<'a, B, I> Parser for I64<B, I> where
I: Stream<Item = u8>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
B: ByteOrder,
[src]
impl<'a, B, I> Parser for I64<B, I> where
I: Stream<Item = u8>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
B: ByteOrder,
type Input = I
type Output = i64
type PartialState = ()
fn parse_lazy( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<'a, B, I> Parser for U16<B, I> where
I: Stream<Item = u8>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
B: ByteOrder,
[src]
impl<'a, B, I> Parser for U16<B, I> where
I: Stream<Item = u8>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
B: ByteOrder,
type Input = I
type Output = u16
type PartialState = ()
fn parse_lazy( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<'a, B, I> Parser for U32<B, I> where
I: Stream<Item = u8>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
B: ByteOrder,
[src]
impl<'a, B, I> Parser for U32<B, I> where
I: Stream<Item = u8>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
B: ByteOrder,
type Input = I
type Output = u32
type PartialState = ()
fn parse_lazy( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<'a, B, I> Parser for U64<B, I> where
I: Stream<Item = u8>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
B: ByteOrder,
[src]
impl<'a, B, I> Parser for U64<B, I> where
I: Stream<Item = u8>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
B: ByteOrder,
type Input = I
type Output = u64
type PartialState = ()
fn parse_lazy( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<'a, C, I> Parser for BytesCmp<C, I> where
C: FnMut(u8, u8) -> bool,
I: Stream<Item = u8, Range = &'a [u8]>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
[src]
impl<'a, C, I> Parser for BytesCmp<C, I> where
C: FnMut(u8, u8) -> bool,
I: Stream<Item = u8, Range = &'a [u8]>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
type Input = I
type Output = &'static [u8]
type PartialState = ()
fn parse_lazy( | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<'a, F, G, R, I> Parser for CapturesMany<F, G, R, I> where
F: FromIterator<I::Range>,
G: FromIterator<F>,
R: Regex<I::Range>,
I: FullRangeStream,
I::Range: Range,
[src]
impl<'a, F, G, R, I> Parser for CapturesMany<F, G, R, I> where
F: FromIterator<I::Range>,
G: FromIterator<F>,
R: Regex<I::Range>,
I: FullRangeStream,
I::Range: Range,
type Input = I
type Output = G
type PartialState = ()
fn parse_lazy( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<'a, F, R, I> Parser for Captures<F, R, I> where
F: FromIterator<I::Range>,
R: Regex<I::Range>,
I: FullRangeStream,
I::Range: Range,
[src]
impl<'a, F, R, I> Parser for Captures<F, R, I> where
F: FromIterator<I::Range>,
R: Regex<I::Range>,
I: FullRangeStream,
I::Range: Range,
type Input = I
type Output = F
type PartialState = ()
fn parse_lazy( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<'a, F, R, I> Parser for FindMany<F, R, I> where
F: FromIterator<I::Range>,
R: Regex<I::Range>,
I: FullRangeStream,
I::Range: Range,
[src]
impl<'a, F, R, I> Parser for FindMany<F, R, I> where
F: FromIterator<I::Range>,
R: Regex<I::Range>,
I: FullRangeStream,
I::Range: Range,
type Input = I
type Output = F
type PartialState = ()
fn parse_lazy( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<'a, I> Parser for Bytes<I> where
I: Stream<Item = u8, Range = &'a [u8]>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
[src]
impl<'a, I> Parser for Bytes<I> where
I: Stream<Item = u8, Range = &'a [u8]>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
type Input = I
type Output = &'static [u8]
type PartialState = ()
fn parse_lazy( | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<'a, R, I> Parser for Find<R, I> where
R: Regex<I::Range>,
I: FullRangeStream,
I::Range: Range,
[src]
impl<'a, R, I> Parser for Find<R, I> where
R: Regex<I::Range>,
I: FullRangeStream,
I::Range: Range,
type Input = I
type Output = I::Range
type PartialState = ()
fn parse_lazy( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<'a, R, I> Parser for Match<R, I> where
R: Regex<I::Range>,
I: FullRangeStream,
[src]
impl<'a, R, I> Parser for Match<R, I> where
R: Regex<I::Range>,
I: FullRangeStream,
type Input = I
type Output = I::Range
type PartialState = ()
fn parse_lazy( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<C, I> Parser for StrCmp<C, I> where
C: FnMut(char, char) -> bool,
I: Stream<Item = char>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
[src]
impl<C, I> Parser for StrCmp<C, I> where
C: FnMut(char, char) -> bool,
I: Stream<Item = char>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
type Input = I
type Output = &'static str
type PartialState = ()
fn parse_lazy( | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<C, T, I> Parser for Tokens<C, T, I> where
C: FnMut(T::Item, I::Item) -> bool,
T: Clone + IntoIterator,
I: Stream,
[src]
impl<C, T, I> Parser for Tokens<C, T, I> where
C: FnMut(T::Item, I::Item) -> bool,
T: Clone + IntoIterator,
I: Stream,
type Input = I
type Output = T
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Self::Input) -> ConsumedResult<T, I> | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<C, T, I> Parser for Tokens2<C, T, I> where
C: FnMut(T::Item, I::Item) -> bool,
T: Clone + IntoIterator,
I: Stream,
[src]
impl<C, T, I> Parser for Tokens2<C, T, I> where
C: FnMut(T::Item, I::Item) -> bool,
T: Clone + IntoIterator,
I: Stream,
type Input = I
type Output = T
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Self::Input) -> ConsumedResult<T, I> | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<E, I, O> Parser for EnvParser<E, I, O> where
E: Clone,
I: Stream,
[src]
impl<E, I, O> Parser for EnvParser<E, I, O> where
E: Clone,
I: Stream,
type Input = I
type Output = O
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Self::Input) -> ConsumedResult<O, I> | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<F, I, O, S> Parser for Opaque<F, I, O, S> where
I: Stream,
S: Default,
F: FnMut(&mut dyn FnMut(&mut dyn Parser<Input = I, Output = O, PartialState = S>)),
[src]
impl<F, I, O, S> Parser for Opaque<F, I, O, S> where
I: Stream,
S: Default,
F: FnMut(&mut dyn FnMut(&mut dyn Parser<Input = I, Output = O, PartialState = S>)),
type Input = I
type Output = O
type PartialState = S
fn parse_stream_consumed( | [src] |
fn parse_lazy(&mut self, input: &mut Self::Input) -> ConsumedResult<O, I> | [src] |
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error( | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<F, P> Parser for Count<F, P> where
<P::Input as StreamOnce>::Error: ParseError<<P::Input as StreamOnce>::Item, <P::Input as StreamOnce>::Range, <P::Input as StreamOnce>::Position>,
P: Parser,
F: Extend<P::Output> + Default,
[src]
impl<F, P> Parser for Count<F, P> where
<P::Input as StreamOnce>::Error: ParseError<<P::Input as StreamOnce>::Item, <P::Input as StreamOnce>::Range, <P::Input as StreamOnce>::Position>,
P: Parser,
F: Extend<P::Output> + Default,
type Input = P::Input
type Output = F
type PartialState = ()
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error(&mut self, errors: &mut Tracked<<P::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<F, P> Parser for Many<F, P> where
P: Parser,
F: Extend<P::Output> + Default,
[src]
impl<F, P> Parser for Many<F, P> where
P: Parser,
F: Extend<P::Output> + Default,
type Input = P::Input
type Output = F
type PartialState = (F, P::PartialState)
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error( | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<F, P> Parser for Many1<F, P> where
F: Extend<P::Output> + Default,
P: Parser,
[src]
impl<F, P> Parser for Many1<F, P> where
F: Extend<P::Output> + Default,
P: Parser,
type Input = P::Input
type Output = F
type PartialState = (bool, bool, F, P::PartialState)
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_consumed_expected_error( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<F, P> Parser for TakeUntil<F, P> where
F: Extend<<P::Input as StreamOnce>::Item> + Default,
P: Parser,
[src]
impl<F, P> Parser for TakeUntil<F, P> where
F: Extend<<P::Input as StreamOnce>::Item> + Default,
P: Parser,
type Input = P::Input
type Output = F
type PartialState = (F, P::PartialState)
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<F, P, S> Parser for SepBy<F, P, S> where
F: Extend<P::Output> + Default,
P: Parser,
S: Parser<Input = P::Input>,
[src]
impl<F, P, S> Parser for SepBy<F, P, S> where
F: Extend<P::Output> + Default,
P: Parser,
S: Parser<Input = P::Input>,
type Input = P::Input
type Output = F
type PartialState = <Or<SepBy1<F, P, S>, FnParser<P::Input, fn(_: &mut Self::Input) -> ParseResult<F, Self::Input>>> as Parser>::PartialState
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_consumed_expected_error( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<F, P, S> Parser for SepBy1<F, P, S> where
F: Extend<P::Output> + Default,
P: Parser,
S: Parser<Input = P::Input>,
[src]
impl<F, P, S> Parser for SepBy1<F, P, S> where
F: Extend<P::Output> + Default,
P: Parser,
S: Parser<Input = P::Input>,
type Input = P::Input
type Output = F
type PartialState = (Option<Consumed<()>>, F, <With<S, P> as Parser>::PartialState)
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_consumed_expected_error( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<F, P, S> Parser for SepEndBy<F, P, S> where
F: Extend<P::Output> + Default,
P: Parser,
S: Parser<Input = P::Input>,
[src]
impl<F, P, S> Parser for SepEndBy<F, P, S> where
F: Extend<P::Output> + Default,
P: Parser,
S: Parser<Input = P::Input>,
type Input = P::Input
type Output = F
type PartialState = <Or<SepEndBy1<F, P, S>, FnParser<P::Input, fn(_: &mut Self::Input) -> ParseResult<F, Self::Input>>> as Parser>::PartialState
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<F, P, S> Parser for SepEndBy1<F, P, S> where
F: Extend<P::Output> + Default,
P: Parser,
S: Parser<Input = P::Input>,
[src]
impl<F, P, S> Parser for SepEndBy1<F, P, S> where
F: Extend<P::Output> + Default,
P: Parser,
S: Parser<Input = P::Input>,
type Input = P::Input
type Output = F
type PartialState = (Option<Consumed<()>>, F, <With<S, Optional<P>> as Parser>::PartialState)
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::byte::AlphaNum<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::byte::AlphaNum<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
type Input = I
type Output = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::Output
type PartialState = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::byte::CrLf<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::byte::CrLf<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
type Input = I
type Output = <Expected<With<Satisfy<I, fn(_: u8) -> bool>, Newline<I>>> as Parser>::Output
type PartialState = <Expected<With<Satisfy<I, fn(_: u8) -> bool>, Newline<I>>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::byte::Digit<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::byte::Digit<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
type Input = I
type Output = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::Output
type PartialState = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::byte::HexDigit<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::byte::HexDigit<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
type Input = I
type Output = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::Output
type PartialState = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::byte::Letter<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::byte::Letter<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
type Input = I
type Output = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::Output
type PartialState = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::byte::Lower<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::byte::Lower<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
type Input = I
type Output = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::Output
type PartialState = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::byte::Newline<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::byte::Newline<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
type Input = I
type Output = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::Output
type PartialState = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::byte::OctDigit<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::byte::OctDigit<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
type Input = I
type Output = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::Output
type PartialState = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::byte::Space<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::byte::Space<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
type Input = I
type Output = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::Output
type PartialState = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::byte::Spaces<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::byte::Spaces<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
type Input = I
type Output = <Expected<SkipMany<Space<I>>> as Parser>::Output
type PartialState = <Expected<SkipMany<Space<I>>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::byte::Tab<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::byte::Tab<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
type Input = I
type Output = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::Output
type PartialState = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for TakeUntilByte<I> where
I: RangeStream + FullRangeStream,
I::Range: AsRef<[u8]> + Range,
[src]
impl<I> Parser for TakeUntilByte<I> where
I: RangeStream + FullRangeStream,
I::Range: AsRef<[u8]> + Range,
type Input = I
type Output = I::Range
type PartialState = usize
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode<M>( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for TakeUntilByte2<I> where
I: RangeStream + FullRangeStream,
I::Range: AsRef<[u8]> + Range,
[src]
impl<I> Parser for TakeUntilByte2<I> where
I: RangeStream + FullRangeStream,
I::Range: AsRef<[u8]> + Range,
type Input = I
type Output = I::Range
type PartialState = usize
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode<M>( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for TakeUntilByte3<I> where
I: RangeStream + FullRangeStream,
I::Range: AsRef<[u8]> + Range,
[src]
impl<I> Parser for TakeUntilByte3<I> where
I: RangeStream + FullRangeStream,
I::Range: AsRef<[u8]> + Range,
type Input = I
type Output = I::Range
type PartialState = usize
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode<M>( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::byte::Upper<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::byte::Upper<I> where
I: Stream<Item = u8>,
I::Error: ParseError<u8, I::Range, I::Position>,
type Input = I
type Output = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::Output
type PartialState = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::char::AlphaNum<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::char::AlphaNum<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
type Input = I
type Output = <Expected<Satisfy<I, fn(_: char) -> bool>> as Parser>::Output
type PartialState = <Expected<Satisfy<I, fn(_: char) -> bool>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::char::CrLf<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::char::CrLf<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
type Input = I
type Output = <Expected<With<Satisfy<I, fn(_: char) -> bool>, Newline<I>>> as Parser>::Output
type PartialState = <Expected<With<Satisfy<I, fn(_: char) -> bool>, Newline<I>>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::char::Digit<I> where
<I as StreamOnce>::Error: ParseError<<I as StreamOnce>::Item, <I as StreamOnce>::Range, <I as StreamOnce>::Position>,
I: Stream<Item = char>,
[src]
impl<I> Parser for combine::parser::char::Digit<I> where
<I as StreamOnce>::Error: ParseError<<I as StreamOnce>::Item, <I as StreamOnce>::Range, <I as StreamOnce>::Position>,
I: Stream<Item = char>,
type Input = I
type Output = char
type PartialState = ()
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error(&mut self, errors: &mut Tracked<<I as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::char::HexDigit<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::char::HexDigit<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
type Input = I
type Output = <Expected<Satisfy<I, fn(_: char) -> bool>> as Parser>::Output
type PartialState = <Expected<Satisfy<I, fn(_: char) -> bool>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::char::Letter<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::char::Letter<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
type Input = I
type Output = <Expected<Satisfy<I, fn(_: char) -> bool>> as Parser>::Output
type PartialState = <Expected<Satisfy<I, fn(_: char) -> bool>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::char::Lower<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::char::Lower<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
type Input = I
type Output = <Expected<Satisfy<I, fn(_: char) -> bool>> as Parser>::Output
type PartialState = <Expected<Satisfy<I, fn(_: char) -> bool>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::char::Newline<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::char::Newline<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
type Input = I
type Output = <Expected<Satisfy<I, fn(_: char) -> bool>> as Parser>::Output
type PartialState = <Expected<Satisfy<I, fn(_: char) -> bool>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::char::OctDigit<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::char::OctDigit<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
type Input = I
type Output = <Expected<Satisfy<I, fn(_: char) -> bool>> as Parser>::Output
type PartialState = <Expected<Satisfy<I, fn(_: char) -> bool>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::char::Space<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::char::Space<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
type Input = I
type Output = <Expected<Satisfy<I, fn(_: char) -> bool>> as Parser>::Output
type PartialState = <Expected<Satisfy<I, fn(_: char) -> bool>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::char::Spaces<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::char::Spaces<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
type Input = I
type Output = <Expected<SkipMany<Space<I>>> as Parser>::Output
type PartialState = <Expected<SkipMany<Space<I>>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for Str<I> where
I: Stream<Item = char>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
[src]
impl<I> Parser for Str<I> where
I: Stream<Item = char>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
type Input = I
type Output = &'static str
type PartialState = ()
fn parse_lazy( | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::char::Tab<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::char::Tab<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
type Input = I
type Output = <Expected<Satisfy<I, fn(_: char) -> bool>> as Parser>::Output
type PartialState = <Expected<Satisfy<I, fn(_: char) -> bool>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for combine::parser::char::Upper<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
[src]
impl<I> Parser for combine::parser::char::Upper<I> where
I: Stream<Item = char>,
I::Error: ParseError<char, I::Range, I::Position>,
type Input = I
type Output = <Expected<Satisfy<I, fn(_: char) -> bool>> as Parser>::Output
type PartialState = <Expected<Satisfy<I, fn(_: char) -> bool>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for Any<I> where
I: Stream,
[src]
impl<I> Parser for Any<I> where
I: Stream,
type Input = I
type Output = I::Item
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Self::Input) -> ConsumedResult<I::Item, I> | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for Eof<I> where
I: Stream,
[src]
impl<I> Parser for Eof<I> where
I: Stream,
type Input = I
type Output = ()
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Self::Input) -> ConsumedResult<(), I> | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for Position<I> where
I: Stream,
[src]
impl<I> Parser for Position<I> where
I: Stream,
type Input = I
type Output = I::Position
type PartialState = ()
fn parse_lazy( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for Token<I> where
I: Stream,
I::Item: PartialEq + Clone,
[src]
impl<I> Parser for Token<I> where
I: Stream,
I::Item: PartialEq + Clone,
type Input = I
type Output = I::Item
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Self::Input) -> ConsumedResult<I::Item, I> | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for Range<I> where
I: RangeStream,
I::Range: PartialEq + Range,
[src]
impl<I> Parser for Range<I> where
I: RangeStream,
I::Range: PartialEq + Range,
type Input = I
type Output = I::Range
type PartialState = ()
fn parse_lazy( | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for Take<I> where
I: RangeStream,
[src]
impl<I> Parser for Take<I> where
I: RangeStream,
type Input = I
type Output = I::Range
type PartialState = ()
fn parse_lazy( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I> Parser for TakeUntilRange<I> where
I: RangeStream,
I::Range: PartialEq + Range,
[src]
impl<I> Parser for TakeUntilRange<I> where
I: RangeStream,
I::Range: PartialEq + Range,
type Input = I
type Output = I::Range
type PartialState = usize
fn parse_partial( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, A, B, P, F> Parser for FlatMap<P, F> where
I: Stream,
P: Parser<Input = I, Output = A>,
F: FnMut(A) -> Result<B, I::Error>,
[src]
impl<I, A, B, P, F> Parser for FlatMap<P, F> where
I: Stream,
P: Parser<Input = I, Output = A>,
F: FnMut(A) -> Result<B, I::Error>,
type Input = I
type Output = B
type PartialState = P::PartialState
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, A, B, P, F> Parser for Map<P, F> where
I: Stream,
P: Parser<Input = I, Output = A>,
F: FnMut(A) -> B,
[src]
impl<I, A, B, P, F> Parser for Map<P, F> where
I: Stream,
P: Parser<Input = I, Output = A>,
F: FnMut(A) -> B,
type Input = I
type Output = B
type PartialState = P::PartialState
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, F> Parser for TakeWhile<I, F> where
I: RangeStream,
I::Range: Range,
F: FnMut(I::Item) -> bool,
[src]
impl<I, F> Parser for TakeWhile<I, F> where
I: RangeStream,
I::Range: Range,
F: FnMut(I::Item) -> bool,
type Input = I
type Output = I::Range
type PartialState = usize
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, F> Parser for TakeWhile1<I, F> where
I: RangeStream,
I::Range: Range,
F: FnMut(I::Item) -> bool,
[src]
impl<I, F> Parser for TakeWhile1<I, F> where
I: RangeStream,
I::Range: Range,
F: FnMut(I::Item) -> bool,
type Input = I
type Output = I::Range
type PartialState = usize
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, O, F> Parser for FnParser<I, F> where
I: Stream,
F: FnMut(&mut I) -> ParseResult<O, I>,
[src]
impl<I, O, F> Parser for FnParser<I, F> where
I: Stream,
F: FnMut(&mut I) -> ParseResult<O, I>,
type Input = I
type Output = O
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Self::Input) -> ConsumedResult<O, I> | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, O, P> Parser for LookAhead<P> where
I: Stream,
P: Parser<Input = I, Output = O>,
[src]
impl<I, O, P> Parser for LookAhead<P> where
I: Stream,
P: Parser<Input = I, Output = O>,
type Input = I
type Output = O
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Self::Input) -> ConsumedResult<O, I> | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, O, P> Parser for NotFollowedBy<P> where
I: Stream,
P: Parser<Input = I, Output = O>,
[src]
impl<I, O, P> Parser for NotFollowedBy<P> where
I: Stream,
P: Parser<Input = I, Output = O>,
type Input = I
type Output = ()
type PartialState = P::PartialState
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error( | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, O, P> Parser for Try<P> where
I: Stream,
P: Parser<Input = I, Output = O>,
[src]
impl<I, O, P> Parser for Try<P> where
I: Stream,
P: Parser<Input = I, Output = O>,
type Input = I
type Output = O
type PartialState = P::PartialState
fn parse_stream_consumed( | [src] |
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_consumed_mode<M>( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, O, P, R> Parser for Factory<P, R> where
I: Stream,
P: FnMut() -> R,
R: Parser<Input = I, Output = O>,
[src]
impl<I, O, P, R> Parser for Factory<P, R> where
I: Stream,
P: FnMut() -> R,
R: Parser<Input = I, Output = O>,
type Input = I
type Output = O
type PartialState = R::PartialState
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error( | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, O, P, R> Parser for Lazy<P> where
I: Stream,
P: FnMut() -> R,
R: Parser<Input = I, Output = O>,
[src]
impl<I, O, P, R> Parser for Lazy<P> where
I: Stream,
P: FnMut() -> R,
R: Parser<Input = I, Output = O>,
type Input = I
type Output = O
type PartialState = R::PartialState
fn parse_stream_consumed( | [src] |
fn parse_lazy(&mut self, input: &mut Self::Input) -> ConsumedResult<O, I> | [src] |
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_consumed_mode<M>( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error( | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, O, P1, P2> Parser for Or<P1, P2> where
I: Stream,
P1: Parser<Input = I, Output = O>,
P2: Parser<Input = I, Output = O>,
[src]
impl<I, O, P1, P2> Parser for Or<P1, P2> where
I: Stream,
P1: Parser<Input = I, Output = O>,
P2: Parser<Input = I, Output = O>,
type Input = I
type Output = O
type PartialState = <Choice<(P1, P2)> as Parser>::PartialState
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, P> Parser for Message<P> where
I: Stream,
P: Parser<Input = I>,
[src]
impl<I, P> Parser for Message<P> where
I: Stream,
P: Parser<Input = I>,
type Input = I
type Output = P::Output
type PartialState = P::PartialState
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, P> Parser for Satisfy<I, P> where
I: Stream,
P: FnMut(I::Item) -> bool,
[src]
impl<I, P> Parser for Satisfy<I, P> where
I: Stream,
P: FnMut(I::Item) -> bool,
type Input = I
type Output = I::Item
type PartialState = ()
fn parse_lazy( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, P, Op> Parser for Chainl1<P, Op> where
I: Stream,
P: Parser<Input = I>,
Op: Parser<Input = I>,
Op::Output: FnOnce(P::Output, P::Output) -> P::Output,
[src]
impl<I, P, Op> Parser for Chainl1<P, Op> where
I: Stream,
P: Parser<Input = I>,
Op: Parser<Input = I>,
Op::Output: FnOnce(P::Output, P::Output) -> P::Output,
type Input = I
type Output = P::Output
type PartialState = (Option<(P::Output, Consumed<()>)>, <(Op, P) as Parser>::PartialState)
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, P, Op> Parser for Chainr1<P, Op> where
I: Stream,
P: Parser<Input = I>,
Op: Parser<Input = I>,
Op::Output: FnOnce(P::Output, P::Output) -> P::Output,
[src]
impl<I, P, Op> Parser for Chainr1<P, Op> where
I: Stream,
P: Parser<Input = I>,
Op: Parser<Input = I>,
Op::Output: FnOnce(P::Output, P::Output) -> P::Output,
type Input = I
type Output = P::Output
type PartialState = ()
fn parse_lazy( | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, P, R> Parser for SatisfyMap<I, P> where
I: Stream,
P: FnMut(I::Item) -> Option<R>,
[src]
impl<I, P, R> Parser for SatisfyMap<I, P> where
I: Stream,
P: FnMut(I::Item) -> Option<R>,
type Input = I
type Output = R
type PartialState = ()
fn parse_lazy( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, P1, P2> Parser for Skip<P1, P2> where
I: Stream,
P1: Parser<Input = I>,
P2: Parser<Input = I>,
[src]
impl<I, P1, P2> Parser for Skip<P1, P2> where
I: Stream,
P1: Parser<Input = I>,
P2: Parser<Input = I>,
type Input = I
type Output = P1::Output
type PartialState = <(P1, Ignore<P2>) as Parser>::PartialState
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, P1, P2> Parser for With<P1, P2> where
I: Stream,
P1: Parser<Input = I>,
P2: Parser<Input = I>,
[src]
impl<I, P1, P2> Parser for With<P1, P2> where
I: Stream,
P1: Parser<Input = I>,
P2: Parser<Input = I>,
type Input = I
type Output = P2::Output
type PartialState = <(Ignore<P1>, P2) as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, T> Parser for Unexpected<I, T> where
I: Stream,
[src]
impl<I, T> Parser for Unexpected<I, T> where
I: Stream,
type Input = I
type Output = T
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Self::Input) -> ConsumedResult<T, I> | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<I, T> Parser for Value<I, T> where
I: Stream,
T: Clone,
[src]
impl<I, T> Parser for Value<I, T> where
I: Stream,
T: Clone,
type Input = I
type Output = T
type PartialState = ()
fn parse_lazy(&mut self, _: &mut Self::Input) -> ConsumedResult<T, I> | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<L, R, P> Parser for Between<L, R, P> where
L: Parser,
R: Parser<Input = <L as Parser>::Input>,
P: Parser<Input = <L as Parser>::Input>,
[src]
impl<L, R, P> Parser for Between<L, R, P> where
L: Parser,
R: Parser<Input = <L as Parser>::Input>,
P: Parser<Input = <L as Parser>::Input>,
type Input = <L as Parser>::Input
type Output = <Map<(L, P, R), fn(_: (L::Output, P::Output, R::Output)) -> P::Output> as Parser>::Output
type PartialState = <Map<(L, P, R), fn(_: (L::Output, P::Output, R::Output)) -> P::Output> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<O, P> Parser for FromStr<O, P> where
<P::Input as StreamOnce>::Error: ParseError<<P::Input as StreamOnce>::Item, <P::Input as StreamOnce>::Range, <P::Input as StreamOnce>::Position>,
P: Parser,
P::Output: StrLike,
O: FromStr,
O::Err: Display,
[src]
impl<O, P> Parser for FromStr<O, P> where
<P::Input as StreamOnce>::Error: ParseError<<P::Input as StreamOnce>::Item, <P::Input as StreamOnce>::Range, <P::Input as StreamOnce>::Position>,
P: Parser,
P::Output: StrLike,
O: FromStr,
O::Err: Display,
type Input = P::Input
type Output = O
type PartialState = P::PartialState
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error(&mut self, errors: &mut Tracked<<P::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P> Parser for Choice<P> where
P: ChoiceParser,
[src]
impl<P> Parser for Choice<P> where
P: ChoiceParser,
type Input = P::Input
type Output = P::Output
type PartialState = P::PartialState
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P> Parser for Optional<P> where
P: Parser,
[src]
impl<P> Parser for Optional<P> where
P: Parser,
type Input = P::Input
type Output = Option<P::Output>
type PartialState = P::PartialState
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P> Parser for AnyPartialStateParser<P> where
P: Parser,
P::PartialState: 'static,
[src]
impl<P> Parser for AnyPartialStateParser<P> where
P: Parser,
P::PartialState: 'static,
type Input = P::Input
type Output = P::Output
type PartialState = AnyPartialState
fn parse_lazy( | [src] |
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode<M>( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P> Parser for AnySendPartialStateParser<P> where
P: Parser,
P::PartialState: Send + 'static,
[src]
impl<P> Parser for AnySendPartialStateParser<P> where
P: Parser,
P::PartialState: Send + 'static,
type Input = P::Input
type Output = P::Output
type PartialState = AnySendPartialState
fn parse_lazy( | [src] |
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode<M>( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P> Parser for Ignore<P> where
P: Parser,
[src]
impl<P> Parser for Ignore<P> where
P: Parser,
type Input = P::Input
type Output = ()
type PartialState = P::PartialState
fn parse_lazy( | [src] |
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P> Parser for NoPartial<P> where
P: Parser,
[src]
impl<P> Parser for NoPartial<P> where
P: Parser,
type Input = <P as Parser>::Input
type Output = <P as Parser>::Output
type PartialState = ()
fn parse_lazy( | [src] |
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P> Parser for Expected<P> where
P: Parser,
[src]
impl<P> Parser for Expected<P> where
P: Parser,
type Input = P::Input
type Output = P::Output
type PartialState = P::PartialState
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P> Parser for Silent<P> where
P: Parser,
[src]
impl<P> Parser for Silent<P> where
P: Parser,
type Input = P::Input
type Output = P::Output
type PartialState = P::PartialState
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error( | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P> Parser for combine::parser::range::Recognize<P> where
<P::Input as StreamOnce>::Error: ParseError<<P::Input as StreamOnce>::Item, <P::Input as StreamOnce>::Range, <P::Input as StreamOnce>::Position>,
P: Parser,
P::Input: RangeStream,
<P::Input as StreamOnce>::Range: Range,
[src]
impl<P> Parser for combine::parser::range::Recognize<P> where
<P::Input as StreamOnce>::Error: ParseError<<P::Input as StreamOnce>::Item, <P::Input as StreamOnce>::Range, <P::Input as StreamOnce>::Position>,
P: Parser,
P::Input: RangeStream,
<P::Input as StreamOnce>::Range: Range,
type Input = P::Input
type Output = <P::Input as StreamOnce>::Range
type PartialState = <RecognizeWithValue<P> as Parser>::PartialState
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error(&mut self, errors: &mut Tracked<<P::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P> Parser for RecognizeWithValue<P> where
P: Parser,
P::Input: RangeStream,
<P::Input as StreamOnce>::Range: Range,
[src]
impl<P> Parser for RecognizeWithValue<P> where
P: Parser,
P::Input: RangeStream,
<P::Input as StreamOnce>::Range: Range,
type Input = P::Input
type Output = (<P::Input as StreamOnce>::Range, P::Output)
type PartialState = (usize, P::PartialState)
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode<M>( | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P> Parser for SkipCount<P> where
<P::Input as StreamOnce>::Error: ParseError<<P::Input as StreamOnce>::Item, <P::Input as StreamOnce>::Range, <P::Input as StreamOnce>::Position>,
P: Parser,
[src]
impl<P> Parser for SkipCount<P> where
<P::Input as StreamOnce>::Error: ParseError<<P::Input as StreamOnce>::Item, <P::Input as StreamOnce>::Range, <P::Input as StreamOnce>::Position>,
P: Parser,
type Input = P::Input
type Output = ()
type PartialState = <With<Count<Sink, P>, Value<P::Input, ()>> as Parser>::PartialState
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error(&mut self, errors: &mut Tracked<<P::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P> Parser for SkipCountMinMax<P> where
<P::Input as StreamOnce>::Error: ParseError<<P::Input as StreamOnce>::Item, <P::Input as StreamOnce>::Range, <P::Input as StreamOnce>::Position>,
P: Parser,
[src]
impl<P> Parser for SkipCountMinMax<P> where
<P::Input as StreamOnce>::Error: ParseError<<P::Input as StreamOnce>::Item, <P::Input as StreamOnce>::Range, <P::Input as StreamOnce>::Position>,
P: Parser,
type Input = P::Input
type Output = ()
type PartialState = <With<CountMinMax<Sink, P>, Value<P::Input, ()>> as Parser>::PartialState
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error(&mut self, errors: &mut Tracked<<P::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P> Parser for SkipMany<P> where
P: Parser,
[src]
impl<P> Parser for SkipMany<P> where
P: Parser,
type Input = <P as Parser>::Input
type Output = <Ignore<Many<Sink, Ignore<P>>> as Parser>::Output
type PartialState = <Ignore<Many<Sink, Ignore<P>>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P> Parser for SkipMany1<P> where
P: Parser,
[src]
impl<P> Parser for SkipMany1<P> where
P: Parser,
type Input = <P as Parser>::Input
type Output = <Ignore<Many1<Sink, Ignore<P>>> as Parser>::Output
type PartialState = <Ignore<Many1<Sink, Ignore<P>>> as Parser>::PartialState
fn parse_lazy( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P> Parser for SkipUntil<P> where
<P::Input as StreamOnce>::Error: ParseError<<P::Input as StreamOnce>::Item, <P::Input as StreamOnce>::Range, <P::Input as StreamOnce>::Position>,
P: Parser,
[src]
impl<P> Parser for SkipUntil<P> where
<P::Input as StreamOnce>::Error: ParseError<<P::Input as StreamOnce>::Item, <P::Input as StreamOnce>::Range, <P::Input as StreamOnce>::Position>,
P: Parser,
type Input = P::Input
type Output = ()
type PartialState = <With<TakeUntil<Sink, P>, Value<P::Input, ()>> as Parser>::PartialState
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error(&mut self, errors: &mut Tracked<<P::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P, F> Parser for combine::parser::combinator::Recognize<F, P> where
P: Parser,
F: Default + Extend<<P::Input as StreamOnce>::Item>,
[src]
impl<P, F> Parser for combine::parser::combinator::Recognize<F, P> where
P: Parser,
F: Default + Extend<<P::Input as StreamOnce>::Item>,
type Input = P::Input
type Output = F
type PartialState = (F, P::PartialState)
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P, F> Parser for CountMinMax<F, P> where
P: Parser,
F: Extend<P::Output> + Default,
[src]
impl<P, F> Parser for CountMinMax<F, P> where
P: Parser,
F: Extend<P::Output> + Default,
type Input = P::Input
type Output = F
type PartialState = (usize, F, P::PartialState)
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P, F, O, E, I> Parser for AndThen<P, F> where
I: Stream,
P: Parser<Input = I>,
F: FnMut(P::Output) -> Result<O, E>,
E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
[src]
impl<P, F, O, E, I> Parser for AndThen<P, F> where
I: Stream,
P: Parser<Input = I>,
F: FnMut(P::Output) -> Result<O, E>,
E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>,
I::Error: ParseError<I::Item, I::Range, I::Position>,
type Input = P::Input
type Output = O
type PartialState = P::PartialState
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>) | [src] |
fn add_consumed_expected_error( | [src] |
fn parser_count(&self) -> ErrorOffset | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P, N, F> Parser for Then<P, F> where
F: FnMut(P::Output) -> N,
P: Parser,
N: Parser<Input = P::Input>,
[src]
impl<P, N, F> Parser for Then<P, F> where
F: FnMut(P::Output) -> N,
P: Parser,
N: Parser<Input = P::Input>,
type Input = N::Input
type Output = N::Output
type PartialState = (P::PartialState, Option<(bool, N)>, N::PartialState)
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P, N, F> Parser for ThenPartial<P, F> where
F: FnMut(&mut P::Output) -> N,
P: Parser,
N: Parser<Input = P::Input>,
[src]
impl<P, N, F> Parser for ThenPartial<P, F> where
F: FnMut(&mut P::Output) -> N,
P: Parser,
N: Parser<Input = P::Input>,
type Input = N::Input
type Output = N::Output
type PartialState = (P::PartialState, Option<(bool, P::Output)>, N::PartialState)
fn parse_partial( | [src] |
fn parse_first( | [src] |
fn parse_mode_impl<M>( | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_lazy( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<P, Q> Parser for Escaped<P, Q> where
P: Parser,
<P::Input as StreamOnce>::Item: PartialEq,
Q: Parser<Input = P::Input>,
[src]
impl<P, Q> Parser for Escaped<P, Q> where
P: Parser,
<P::Input as StreamOnce>::Item: PartialEq,
Q: Parser<Input = P::Input>,
type Input = P::Input
type Output = ()
type PartialState = EscapedState<P::PartialState, Q::PartialState>
fn parse_lazy( | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<T, I> Parser for NoneOf<T, I> where
T: Clone + IntoIterator<Item = I::Item>,
I: Stream,
I::Item: PartialEq,
[src]
impl<T, I> Parser for NoneOf<T, I> where
T: Clone + IntoIterator<Item = I::Item>,
I: Stream,
I::Item: PartialEq,
type Input = I
type Output = I::Item
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Self::Input) -> ConsumedResult<I::Item, I> | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
fn add_error( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |
impl<T, I> Parser for OneOf<T, I> where
T: Clone + IntoIterator<Item = I::Item>,
I: Stream,
I::Item: PartialEq,
[src]
impl<T, I> Parser for OneOf<T, I> where
T: Clone + IntoIterator<Item = I::Item>,
I: Stream,
I::Item: PartialEq,
type Input = I
type Output = I::Item
type PartialState = ()
fn parse_lazy(&mut self, input: &mut Self::Input) -> ConsumedResult<I::Item, I> | [src] |
fn add_error( | [src] |
fn easy_parse<I>( | [src] |
fn parse( | [src] |
fn parse_with_state( | [src] |
fn parse_stream( | [src] |
fn parse_stream_consumed( | [src] |
fn parse_stream_consumed_partial( | [src] |
fn parse_first( | [src] |
fn parse_partial( | [src] |
ⓘImportant traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where | [src] |
fn with<P2>(self, p: P2) -> With<Self, P2> where | [src] |
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where | [src] |
fn and<P2>(self, p: P2) -> (Self, P2) where | [src] |
fn or<P2>(self, p: P2) -> Or<Self, P2> where | [src] |
fn then<N, F>(self, f: F) -> Then<Self, F> where | [src] |
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where | [src] |
fn map<F, B>(self, f: F) -> Map<Self, F> where | [src] |
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where | [src] |
fn message<S>(self, msg: S) -> Message<Self> where | [src] |
fn expected<S>(self, msg: S) -> Expected<Self> where | [src] |
fn silent(self) -> Silent<Self> where | [src] |
fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn iter( | [src] |
ⓘImportant traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>( | [src] |
ⓘImportant traits for Box<W>
fn boxed<'a>( | [src] |
ⓘImportant traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where | [src] |
ⓘImportant traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where | [src] |