Trait combine::parser::Parser

pub trait Parser {
    type Input: Stream;
    type Output;
    type PartialState: Default;
    fn easy_parse<I>(
        &mut self, 
        input: I
    ) -> Result<(Self::Output, I), ParseError<I>>
    where
        I: Stream,
        Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
        I::Position: Default,
        Self: Sized + Parser<Input = Stream<I>>,
    { ... }
    fn parse(
        &mut self, 
        input: Self::Input
    ) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error> { ... }
    fn parse_with_state(
        &mut self, 
        input: &mut Self::Input, 
        state: &mut Self::PartialState
    ) -> Result<Self::Output, <Self::Input as StreamOnce>::Error> { ... }
    fn parse_stream(
        &mut self, 
        input: &mut Self::Input
    ) -> ParseResult<Self::Output, Self::Input> { ... }
    fn parse_stream_consumed(
        &mut self, 
        input: &mut Self::Input
    ) -> ConsumedResult<Self::Output, Self::Input> { ... }
    fn parse_stream_consumed_partial(
        &mut self, 
        input: &mut Self::Input, 
        state: &mut Self::PartialState
    ) -> ConsumedResult<Self::Output, Self::Input> { ... }
    fn parse_lazy(
        &mut self, 
        input: &mut Self::Input
    ) -> ConsumedResult<Self::Output, Self::Input> { ... }
    fn parse_first(
        &mut self, 
        input: &mut Self::Input, 
        state: &mut Self::PartialState
    ) -> ConsumedResult<Self::Output, Self::Input> { ... }
    fn parse_partial(
        &mut self, 
        input: &mut Self::Input, 
        state: &mut Self::PartialState
    ) -> ConsumedResult<Self::Output, Self::Input> { ... }
    fn add_error(
        &mut self, 
        _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
    ) { ... }
    fn by_ref(&mut self) -> &mut Self
    where
        Self: Sized,
    { ... }
    fn with<P2>(self, p: P2) -> With<Self, P2>
    where
        Self: Sized,
        P2: Parser<Input = Self::Input>,
    { ... }
    fn skip<P2>(self, p: P2) -> Skip<Self, P2>
    where
        Self: Sized,
        P2: Parser<Input = Self::Input>,
    { ... }
    fn and<P2>(self, p: P2) -> (Self, P2)
    where
        Self: Sized,
        P2: Parser<Input = Self::Input>,
    { ... }
    fn or<P2>(self, p: P2) -> Or<Self, P2>
    where
        Self: Sized,
        P2: Parser<Input = Self::Input, Output = Self::Output>,
    { ... }
    fn then<N, F>(self, f: F) -> Then<Self, F>
    where
        Self: Sized,
        F: FnMut(Self::Output) -> N,
        N: Parser<Input = Self::Input>,
    { ... }
    fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F>
    where
        Self: Sized,
        F: FnMut(&mut Self::Output) -> N,
        N: Parser<Input = Self::Input>,
    { ... }
    fn map<F, B>(self, f: F) -> Map<Self, F>
    where
        Self: Sized,
        F: FnMut(Self::Output) -> B,
    { ... }
    fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F>
    where
        Self: Sized,
        F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>,
    { ... }
    fn message<S>(self, msg: S) -> Message<Self>
    where
        Self: Sized,
        S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>,
    { ... }
    fn expected<S>(self, msg: S) -> Expected<Self>
    where
        Self: Sized,
        S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>,
    { ... }
    fn silent(self) -> Silent<Self>
    where
        Self: Sized,
    { ... }
    fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F>
    where
        Self: Parser<Input = I> + Sized,
        F: FnMut(Self::Output) -> Result<O, E>,
        I: Stream,
        E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>,
    { ... }
    fn iter(
        self, 
        input: &mut Self::Input
    ) -> Iter<Self, Self::PartialState, FirstMode>
    where
        Self: Parser + Sized,
    { ... }
    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,
    { ... }
    fn boxed<'a>(
        self
    ) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a>
    where
        Self: Sized + 'a,
    { ... }
    fn left<R>(self) -> Either<Self, R>
    where
        Self: Sized,
        R: Parser<Input = Self::Input, Output = Self::Output>,
    { ... }
    fn right<L>(self) -> Either<L, Self>
    where
        Self: Sized,
        L: Parser<Input = Self::Input, Output = Self::Output>,
    { ... }
}

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 ().

Loading content...

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>>, 

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>

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>

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>

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>

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>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Parses using the stream input by calling Stream::uncons one or more times.

Specialized version of parse_stream_consumed which permits error value creation to be skipped in the common case.

When this parser returns EmptyErr, this method is allowed to return an empty Error. The error value that would have been returned can instead be obtained by calling add_error. This allows a parent parser such as choice to skip the creation of an unnecessary error value, if an alternative parser succeeds.

External callers should never have to call this function directly.

Parsers should seek to implement this function instead of the above two if errors can be encountered before consuming input. The default implementation always returns all errors, with add_error being a no-op.

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Parses using the stream input and allows itself to be resumed at a later point using parse_partial by storing the necessary intermediate state in state.

Unlike parse_partial function this is allowed to assume that there is no partial state to resume.

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Parses using the stream input and allows itself to be resumed at a later point using parse_partial by storing the necessary intermediate state in state

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Adds the first error that would normally be returned by this parser if it failed with an EmptyErr result.

See parse_lazy for details.

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    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>, 

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>, 

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>, 

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>, 

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>, 

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>, 

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, 

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>, 

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>>, 

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>>, 

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, 

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>, 

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 });

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    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], "")));

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

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

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

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Turns the parser into a trait object by putting it in a Box. Can be used to easily return parsers from functions without naming the type.

fn test<'input, F>(
    c: char,
    f: F)
    -> Box<Parser<Input = &'input str, Output = (char, char), PartialState = ()>>
    where F: FnMut(char) -> bool + 'static
{
    ::combine::combinator::no_partial((token(c), satisfy(f))).boxed()
}
let result = test('a', |c| c >= 'a' && c <= 'f')
    .parse("ac");
assert_eq!(result, Ok((('a', 'c'), "")));

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    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(), "")));

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    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(), "")));

Loading content...

Implementations on Foreign Types

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn parser_count(&self) -> ErrorOffset

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn parser_count(&self) -> ErrorOffset

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn parser_count(&self) -> ErrorOffset

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn parser_count(&self) -> ErrorOffset

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn parser_count(&self) -> ErrorOffset

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn parser_count(&self) -> ErrorOffset

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn parser_count(&self) -> ErrorOffset

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn parser_count(&self) -> ErrorOffset

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn parser_count(&self) -> ErrorOffset

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn parser_count(&self) -> ErrorOffset

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn parser_count(&self) -> ErrorOffset

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn parser_count(&self) -> ErrorOffset

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

Loading content...

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, 

type Input = I

type Output = f32

type PartialState = ()

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

impl<'a, I> Parser for take_until_bytes<'a, I> where
    <I as StreamOnce>::Error: ParseError<<I as StreamOnce>::Item, <I as StreamOnce>::Range, <I as StreamOnce>::Position>,
    I: RangeStream + FullRangeStream,
    I::Range: AsRef<[u8]> + Range, 

type Input = I

type Output = I::Range

type PartialState = ()

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<I::Range, I> where
    M: ParseMode, 

fn add_error(&mut self, errors: &mut Tracked<<I as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<I as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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>

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<O, I>

fn parse_lazy(&mut self, input: &mut Self::Input) -> ConsumedResult<O, I>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<F, P::Input> where
    M: ParseMode, 

fn add_error(&mut self, errors: &mut Tracked<<P::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<P::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<F, P::Input> where
    M: ParseMode, 

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<F, P::Input> where
    M: ParseMode, 

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

impl<F, R, I> Parser for TakeFn<F, I> where
    F: FnMut(I::Range) -> R,
    R: Into<TakeRange>,
    I: RangeStream + FullRangeStream,
    I::Range: Range, 

type Input = I

type Output = I::Range

type PartialState = usize

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    offset: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

impl<I> Parser for TakeUntilByte<I> where
    <I as StreamOnce>::Error: ParseError<<I as StreamOnce>::Item, <I as StreamOnce>::Range, <I as StreamOnce>::Position>,
    I: RangeStream + FullRangeStream,
    I::Range: AsRef<[u8]> + Range, 

type Input = I

type Output = I::Range

type PartialState = ()

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<I::Range, I> where
    M: ParseMode, 

fn add_error(&mut self, errors: &mut Tracked<<I as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<I as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

impl<I> Parser for TakeUntilByte2<I> where
    <I as StreamOnce>::Error: ParseError<<I as StreamOnce>::Item, <I as StreamOnce>::Range, <I as StreamOnce>::Position>,
    I: RangeStream + FullRangeStream,
    I::Range: AsRef<[u8]> + Range, 

type Input = I

type Output = I::Range

type PartialState = ()

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<I::Range, I> where
    M: ParseMode, 

fn add_error(&mut self, errors: &mut Tracked<<I as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<I as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

impl<I> Parser for TakeUntilByte3<I> where
    <I as StreamOnce>::Error: ParseError<<I as StreamOnce>::Item, <I as StreamOnce>::Range, <I as StreamOnce>::Position>,
    I: RangeStream + FullRangeStream,
    I::Range: AsRef<[u8]> + Range, 

type Input = I

type Output = I::Range

type PartialState = ()

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<I::Range, I> where
    M: ParseMode, 

fn add_error(&mut self, errors: &mut Tracked<<I as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<I as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<char, I> where
    M: ParseMode, 

fn add_error(&mut self, errors: &mut Tracked<<I as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<I as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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>

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

impl<I> Parser for Position<I> where
    I: Stream, 

type Input = I

type Output = I::Position

type PartialState = ()

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<I::Position, I>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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>

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

impl<I> Parser for Take<I> where
    I: RangeStream, 

type Input = I

type Output = I::Range

type PartialState = ()

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    to_consume: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(
    &mut self,
    _errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_consumed_expected_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<O, I>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_consumed_mode<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<O, I>

fn parse_lazy(&mut self, input: &mut Self::Input) -> ConsumedResult<O, I>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_consumed_mode<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<P::Output, I>

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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>

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<O, P::Input> where
    M: ParseMode, 

fn add_error(&mut self, errors: &mut Tracked<<P::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<P::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

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

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

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

impl<P> Parser for Choice<P> where
    P: ChoiceParser, 

type Input = P::Input

type Output = P::Output

type PartialState = P::PartialState

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

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

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

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

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

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

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

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

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

impl<P> Parser for Ignore<P> where
    P: Parser, 

type Input = P::Input

type Output = ()

type PartialState = P::PartialState

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    _mode: M,
    input: &mut Self::Input,
    _state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

impl<P> Parser for Expected<P> where
    P: Parser, 

type Input = P::Input

type Output = P::Output

type PartialState = P::PartialState

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

impl<P> Parser for Silent<P> where
    P: Parser, 

type Input = P::Input

type Output = P::Output

type PartialState = P::PartialState

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(
    &mut self,
    _errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn add_consumed_expected_error(
    &mut self,
    _errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<<P::Input as StreamOnce>::Range, P::Input> where
    M: ParseMode, 

fn add_error(&mut self, errors: &mut Tracked<<P::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<P::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<(), P::Input> where
    M: ParseMode, 

fn add_error(&mut self, errors: &mut Tracked<<P::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<P::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<(), P::Input> where
    M: ParseMode, 

fn add_error(&mut self, errors: &mut Tracked<<P::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<P::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<(), P::Input> where
    M: ParseMode, 

fn add_error(&mut self, errors: &mut Tracked<<P::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    errors: &mut Tracked<<P::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

fn add_consumed_expected_error(
    &mut self,
    error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_mode_impl<M>(
    &mut self,
    mode: M,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input> where
    M: ParseMode, 

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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>

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn add_error(
    &mut self,
    _error: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

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>

fn add_error(
    &mut self,
    errors: &mut Tracked<<Self::Input as StreamOnce>::Error>
)

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_first(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

fn parse_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 

fn silent(self) -> Silent<Self> where
    Self: Sized, 

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized, 

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

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, 

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;

fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 

Loading content...